Mengaktifkan HTTPS di Spring Boot dengan sertifikat Azure Key Vault

Artikel
05/23/2023

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 menyeluruh 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 mungkin. 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 toko 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 showing interaction of elements in this tutorial.

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 - membuat secara gratis.
Java Development Kit (JDK) yang didukung dengan 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 sistem diaktifkan. Contributor Berikan peran ke identitas terkelola yang ditetapkan sistem, lalu atur akses scope ke langganan Anda.
Instans Azure Key Vault. Jika Anda tidak memilikinya, lihat Mulai Cepat: Membuat brankas kunci menggunakan portal Azure.
Aplikasi Spring Boot. Jika Anda tidak memilikinya, buat proyek Maven dengan Spring Initializr. Pastikan untuk memilih Proyek Maven dan, di bawah Dependensi, 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 dalam tutorial ini berlaku untuk sertifikat TLS/SSL apa pun (termasuk yang 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 Mulai Cepat: Mengatur dan mengambil sertifikat dari Azure Key Vault menggunakan portal Azure.

Catatan

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:

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

Tip

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

Jalankan 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 dalam 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 ini memungkinkan aplikasi Spring Boot untuk melakukan tindakan muat untuk sertifikat TLS/SSL, seperti yang disebutkan di awal tutorial. Tabel berikut menjelaskan nilai properti.

Properti	Deskripsi
`server.ssl.key-alias`	Nilai argumen `--name` yang Anda sampaikan ke `az keyvault certificate create`.
`server.ssl.key-store-type`	Harus berupa `AzureKeyVault` .
`server.ssl.trust-store-type`	Harus berupa `AzureKeyVault` .
`server.port`	Port TCP lokal untuk mendengarkan koneksi HTTPS.
`azure.keyvault.uri`	Properti `vaultUri` dalam JSON kembali 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 sistemnya telah diberikan akses ke Key Vault. Oleh karena itu, aplikasi ini juga telah diberikan akses.

Perubahan ini memungkinkan aplikasi Spring Boot memuat sertifikat TLS/SSL. Pada langkah berikutnya, Anda akan mengaktifkan aplikasi untuk melakukan tindakan terima 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 tindakan saat ini 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 untuk panggilan HTTP yang value Anda buat.
- Metode inbound hanya mengembalikan salam pembuka ketika browser membuat permintaan HTTPS ke jalur /ssl-test. Metode inbound menggambarkan cara server menyajikan sertifikat TLS/SSL ke browser.
- Metode ini 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 kelompok keamanan jaringan yang dibuat di dalam <your-resource-group-name> memungkinkan lalu lintas masuk pada port 22 dan 8443 dari alamat IP Anda. Untuk mempelajari tentang mengonfigurasi aturan kelompok keamanan jaringan untuk mengizinkan lalu lintas masuk, lihat bagian Bekerja dengan aturan keamanan dari Buat, ubah, atau hapus kelompok keamanan jaringan.
Letakkan file JAR yang dapat dieksekusi di 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 menutup server dan menutup soket jaringan.
```
curl --insecure https://<your VM public IP address>:8443/exit
```

Sekarang setelah Anda melihat beban dan menyajikan tindakan dengan sertifikat TLS/SSL yang ditandatangani sendiri, buat beberapa perubahan sepele pada aplikasi untuk melihat tindakan terima juga.

Jalankan 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, penyajian, dan terima sesuai 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
```
Upload 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 menutup server dan menutup soket jaringan.
```
curl --insecure https://<your VM public IP address>:8443/exit
```

Anda sekarang telah mengamati ilustrasi sederhana tentang tindakan beban, penyajian, dan terima dengan sertifikat TLS/SSL yang ditandatangani sendiri yang disimpan di Azure Key Vault.

Sebarkan 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 di Azure.

Sampel sertifikat Azure for Spring developers Spring Cloud Azure Key Vault

Share via