By Thisara Priyamal in Spring Boot — 08 Aug 2025

Spring Boot Vault Integration | Secrets Management Sinhala

ආයුබෝවන් කට්ටියම! අද අපි කතා කරන්න යන්නේ Spring Boot applications වල secrets management කියන වැදගත් මාතෘකාව ගැන. විශේෂයෙන්ම, HashiCorp Vault කියන නියම tool එක Spring Boot එක්ක කොහොමද integrate කරන්නේ කියලා අපි විස්තරාත්මකව බලමු.

දැනට ඔබ API keys, database credentials, third-party service tokens වගේ sensitive data handle කරන්නේ කොහොමද? සමහරවිට hard-code කරනවා ඇති, එහෙම නැත්නම් environment variables වලින් load කරනවා ඇති. මේ ක්‍රම වල තියෙන ලොකුම අවදානම තමයි, ඔබගේ secrets ආරක්ෂිත නැතිකම. මේවා security breaches වලට ලේසියෙන් ගොදුරු වෙන්න පුළුවන්.

අන්න ඒකට විසඳුමක් තමයි HashiCorp Vault. Vault කියන්නේ secrets manage කරන්න, access control කරන්න, සහ audit කරන්න පුළුවන් ප්‍රබල platform එකක්. මේ tutorial එකෙන් අපි Vault කියන්නේ මොකක්ද, ඒක Spring Boot applications වලට කොච්චර වැදගත්ද, සහ ඒක practically implement කරන්නේ කොහොමද කියලා පියවරෙන් පියවර ඉගෙන ගනිමු.

හරි, එහෙනම් අපි වැඩේට බහිමු!

1. Secrets Management වල වැදගත්කම

මුලින්ම අපි බලමු මොනවද මේ "secrets" කියලා කියන්නේ, සහ ඇයි ඒවා ආරක්ෂිතව තියාගන්න ඕන කියලා.

Secrets කියන්නේ මොනවද?

ඕනෑම software application එකක ක්‍රියාකාරිත්වයට අත්‍යවශ්‍ය, නමුත් public කරන්න බැරි sensitive information තමයි secrets කියලා කියන්නේ. උදාහරණ විදියට:

Database Credentials: username, password
API Keys: Google Maps API key, Stripe API key
Cloud Provider Credentials: AWS access keys, Azure service principal credentials
Third-party Service Tokens: OAuth tokens, JWT secrets
Private Keys: SSL certificates, SSH keys

දැනට පවතින Secrets Management ක්‍රම වල අවදානම්

සාමාන්‍යයෙන් developersලා secrets manage කරන්න පාවිච්චි කරන ක්‍රම කීපයක් තියෙනවා. ඒ හැම එකකම යම් යම් අවදානම් තියෙනවා.

Hard-coding secrets (code එක ඇතුලේ කෙලින්ම ලියන එක): මේක කරන්න පුළුවන් ලොකුම වැරැද්දක්. Codebase එකට access තියෙන ඕනෑම කෙනෙක්ට secrets ටික බලන්න පුළුවන්. Git repository එකකට push කරොත්, ඒක ඉවරයි! ඊට අමතරව, secret එක වෙනස් වුනොත්, code එකත් වෙනස් කරලා redeploy කරන්න වෙනවා.
Environment Variables (පරිසර විචල්‍යයන්): මේක hard-coding වලට වඩා ටිකක් හොඳයි. Production server එකේ environment variables විදියට secrets load කරන්න පුළුවන්. හැබැයි, server එකට access තියෙන කෙනෙක්ට මේවා බලන්න පුළුවන්. ඊට අමතරව, production environment එකෙන් තව environment එකකට secret එකක් යද්දී මේක manage කරන්න අපහසු වෙන්න පුළුවන්.
Configuration Files (විවෘත ගොනු): application.properties, .env වගේ files වල secrets දාන එකත් එච්චර ආරක්ෂිත නැහැ. මේ files गलती से Git repository එකකට ගියොත්, ඒකත් security breach එකක් වෙන්න පුළුවන්.

මේ ක්‍රම වල ප්‍රධාන අඩුපාඩුව තමයි secrets වල lifecycle එක manage කරන්න බැරිවීම. ඒ කියන්නේ, secrets rotate කරන එක, revoke කරන එක, සහ ඒවාට access තියෙන්නේ කාටද කියලා control කරන එක අමාරු වෙනවා.

2. HashiCorp Vault හඳුනාගනිමු

දැන් අපි බලමු මේ හැම අවදානමකටම හොඳ විසඳුමක් දෙන HashiCorp Vault ගැන. Vault කියන්නේ මොකක්ද? සරලවම කිව්වොත්, ඒක centralized secrets management system එකක්. ඔබගේ applications වලට අවශ්‍ය සියලුම secrets එක තැනකින් ආරක්ෂිතව ගබඩා කරලා, අවශ්‍ය අයට, අවශ්‍ය වෙලාවට විතරක් access දෙන්න පුළුවන්.

Vault වල ප්‍රධාන විශේෂාංග (Core Features)

Secure Secret Storage: Vault විසින් secrets encrypted කරලා, persistent storage එකක ගබඩා කරනවා.
Dynamic Secrets: Database credentials, cloud API keys වගේ දේවල් අවශ්‍ය වෙලාවට විතරක් generate කරන්න පුළුවන්. මේවාට short lease durations තියෙනවා, ඒ කියන්නේ යම්කිසි කාලයකට පස්සේ ඒවා automatically expire වෙනවා. මේක security එකට හරිම වැදගත්.
Data Encryption as a Service: Secrets වලට අමතරව, ඔබගේ data encrypt කරන්න සහ decrypt කරන්නත් Vault පාවිච්චි කරන්න පුළුවන්.
Lease & Renewal: Vault වලින් generate කරන හැම secret එකකටම 'lease' එකක් තියෙනවා (පරිශීලන කාලයක්). Lease එක ඉවර වුනොත් secret එක expire වෙනවා. Applications වලට මේ lease එක renewal කරගන්න පුළුවන්.
Audit Logging: Vault එකේ වෙන හැම ක්‍රියාකාරකමක්ම log වෙනවා. කවුද, මොන secret එකටද, කීයටද access කළේ වගේ දේවල් audit කරන්න පුළුවන්.

Vault Server එකක් Development Mode එකේ Run කරගනිමු

අපේ Spring Boot application එක එක්ක integrate කරන්න කලින්, අපි Vault server එකක් development mode එකේ run කරගමු. මේක ඉතාම පහසුයි.

මුලින්ම ඔබට Vault install කරගන්න වෙනවා. ඒක Vault Downloads page එකෙන් බාගත කරගන්න පුළුවන්. නැත්නම් Docker පාවිච්චි කරන්න පුළුවන්. අපි Docker වලින් කරමු.

docker run --cap-add=IPC_LOCK -e 'VAULT_DEV_ROOT_TOKEN_ID=myroot' -p 8200:8200 --name dev-vault vault:latest server -dev -dev-listen-address="0.0.0.0:8200"

මේ command එක run කළාම, Vault server එක http://127.0.0.1:8200 port එකේ start වෙනවා. VAULT_DEV_ROOT_TOKEN_ID=myroot කියන එකෙන් අපි root token එක myroot විදියට set කරනවා. මේක development වලට විතරයි හොඳ. Production වලට මේ token එක පාවිච්චි කරන්න එපා.

දැන් ඔබගේ terminal එකේ තව session එකක් open කරගෙන, Vault CLI එක connect කරගන්න.

export VAULT_ADDR='http://127.0.0.1:8200'
export VAULT_TOKEN='myroot'
vault status

vault status command එකෙන් Vault server එකේ status එක බලන්න පුළුවන්. Initialized: true, Sealed: false, Version: ... වගේ විස්තර පෙන්වයි.

KV Secrets Engine v2 සක්‍රීය කිරීම සහ Secret එකක් ගබඩා කිරීම

Vault වල secrets ගබඩා කරන්න secrets engines පාවිච්චි කරනවා. අපි KV (Key-Value) secrets engine එක පාවිච්චි කරමු. ඒක file system එකක වගේ key-value pairs ගබඩා කරන්න පුළුවන්.

vault secrets enable -version=2 kv

මේ command එකෙන් kv කියන path එකේ KV secrets engine v2 සක්‍රීය වෙනවා. දැන් අපි secret එකක් ගබඩා කරමු.

vault kv put kv/my-app username=devUser password=devPass

මෙහිදී kv/my-app කියන්නේ secret එක ගබඩා කරන path එකයි. username සහ password කියන්නේ keys, devUser සහ devPass කියන්නේ values. Spring Boot application එක මේ path එකෙන් secrets කියවයි.

ගබඩා කරපු secret එක බලන්න පුළුවන් මෙහෙමයි:

vault kv get kv/my-app

3. Spring Boot සමග Vault සම්බන්ධ කරගැනීම

දැන් අපේ Vault server එක run වෙනවා, secrets ටිකත් දාලා තියෙන්නේ. ඊළඟට අපි බලමු Spring Boot application එකකට Vault connect කරන්නේ කොහොමද කියලා.

Dependencies

මුලින්ම, ඔබගේ Spring Boot project එකට spring-cloud-starter-vault-config dependency එක එකතු කරන්න ඕන. ඔබ Maven පාවිච්චි කරනවා නම්, pom.xml එකට මේක එකතු කරන්න:

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-vault-config</artifactId>
</dependency>

ඔබ Gradle පාවිච්චි කරනවා නම්, build.gradle එකට මේක එකතු කරන්න:

implementation 'org.springframework.cloud:spring-cloud-starter-vault-config'

මීට අමතරව, spring-cloud-dependencies BOM (Bill of Materials) එකත් dependencyManagement section එකට එකතු කරන්න වෙනවා (Maven වලට). Gradle වලට platform එකතු කරන්න පුළුවන්.

<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-dependencies</artifactId>
            <version>2023.0.0</version> <!-- Replace with the latest version -->
            <type>pom</type>
            <scope>import</scope>
        </dependency>
    </dependencies>
</dependencyManagement>

Gradle:

ext {
    set('springCloudVersion', "2023.0.0") // Replace with the latest version
}
dependencies {
    implementation platform("org.springframework.cloud:spring-cloud-dependencies:${springCloudVersion}")
    implementation 'org.springframework.cloud:spring-cloud-starter-vault-config'
    // ... other dependencies
}

(Version එක දානකොට, Spring Cloud Vault documentation එක බලලා latest stable version එකක් දාගන්න.)

bootstrap.properties / bootstrap.yml Configurations

Spring Cloud Context එක initialisation වෙනකොටම Vault එකෙන් configurations load කරගන්න bootstrap.properties නැත්නම් bootstrap.yml file එකක් පාවිච්චි කරන්න ඕන. මේක src/main/resources folder එක ඇතුලේ හදන්න.

bootstrap.yml

spring:
  cloud:
    vault:
      host: 127.0.0.1
      port: 8200
      scheme: http
      authentication: TOKEN # අපි token based authentication පාවිච්චි කරමු
      token: myroot # Vault server එක start කරපු token එක
      kv:
        enabled: true
        backend: kv # අපි enable කරපු KV secrets engine එකේ path එක
        application-name: my-app # අපි secret එක ගබඩා කරපු path එකේ my-app කියන කොටස

මේ configurations ටික වැදගත්:

spring.cloud.vault.host, port, scheme: Vault server එක run වෙන තැන.
spring.cloud.vault.authentication: TOKEN: අපි authentication සඳහා token එකක් පාවිච්චි කරනවා. Production වලට AppRole, Kubernetes වගේ වඩා ආරක්ෂිත ක්‍රම පාවිච්චි කරන්න පුළුවන්.
spring.cloud.vault.token: myroot: ඔබගේ Vault root token එක. මේක ඉතාම සංවේදී එකක්! Production වලට මේක කෙලින්ම file එකේ දාන්න එපා. Environment variable එකක් විදියට හෝ වෙනත් ආරක්ෂිත ක්‍රමයකින් inject කරන්න පුළුවන්. (උදා: VAULT_TOKEN environment variable එකෙන් Spring Boot automatically load කරගන්නවා)
spring.cloud.vault.kv.enabled: true: KV secrets engine එක enable කරනවා.
spring.cloud.vault.kv.backend: kv: Vault CLI එකෙන් `kv` path එකේ KV engine එක enable කරපු නිසා ඒ path එක දානවා.
spring.cloud.vault.kv.application-name: my-app: Spring Boot application එක secrets load කරගන්න ඕන Vault path එක. මේක kv/my-app කියන path එකට අනුරූපයි.

මේ configure කිරීම් වලින් පස්සේ, Spring Boot application එක start වෙනකොටම, Vault server එකට connect වෙලා kv/my-app path එකේ තියෙන secrets load කරගන්නවා. මේ secrets application එකේ environment variables වගේ වැඩ කරනවා.

Secrets කියවීම: @Value Annotation

Vault එකෙන් load කරගත්ත secrets application එක ඇතුලේ පාවිච්චි කරන්න, @Value annotation එක පාවිච්චි කරන්න පුළුවන්. මේක හරියට application.properties එකෙන් values කියවනවා වගේමයි.

import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

@Component
public class MyService {

    @Value("${username}")
    private String dbUsername;

    @Value("${password}")
    private String dbPassword;

    public void printSecrets() {
        System.out.println("DB Username: " + dbUsername);
        System.out.println("DB Password: " + dbPassword);
    }
}

username සහ password කියන keys ටික Vault එකෙන් load කරගන්නා නිසා, Spring Boot automatically ඒවා dbUsername සහ dbPassword variables වලට assign කරනවා.

4. ප්‍රායෝගික උදාහරණයක්: Secrets කියවමු

දැන් අපි මේක project එකක් විදියට කරලා බලමු.

පියවර 1: Vault Setup (Local Dev Mode)

මේක අපි කලින් කළා. තව පාරක් බලමු:

Docker desktop එක open කරලා තියාගන්න.

Secret එකක් ගබඩා කරන්න:

vault kv put kv/my-app username=vaultUser password=securePass

vaultUser සහ securePass කියන secrets අපි දැන් Vault එකේ දාලා තියෙන්නේ.

KV secrets engine v2 සක්‍රීය කරන්න:

vault secrets enable -version=2 kv

අලුත් terminal එකක් open කරගෙන, Vault CLI එක connect කරගන්න:

export VAULT_ADDR='http://127.0.0.1:8200'
export VAULT_TOKEN='myroot'

Terminal එකේ මේ command එක run කරන්න:

docker run --cap-add=IPC_LOCK -e 'VAULT_DEV_ROOT_TOKEN_ID=myroot' -p 8200:8200 --name dev-vault vault:latest server -dev -dev-listen-address="0.0.0.0:8200"

මේකෙන් Vault server එක myroot token එකත් එක්ක http://127.0.0.1:8200 වල start වෙනවා.

පියවර 2: Spring Boot Project Setup

Spring Initializr (start.spring.io) එකට ගිහින් අලුත් Maven project එකක් හදමු. Dependencies විදියට Spring Web සහ Spring Cloud Vault Config තෝරන්න.

Project එක download කරගෙන, IDE එකකින් (IntelliJ IDEA, VS Code වගේ) open කරන්න.

pom.xml (Dependency Management Section):

Spring Initializr එකෙන් spring-cloud-starter-vault-config dependency එක automatically එකතු වෙයි. හැබැයි, Spring Cloud BOM එක manually එකතු කරන්න වෙනවා. <properties> tag එකට යටින් spring-cloud.version එකක් දාලා, <dependencyManagement> section එකට මේ ටික එකතු කරන්න:

<properties>
    <java.version>17</java.version>
    <spring-cloud.version>2023.0.0</spring-cloud.version> <!-- ඔබේ Spring Boot version එකට ගැලපෙන එකක් දාන්න -->
</properties>

<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-dependencies</artifactId>
            <version>${spring-cloud.version}</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
    </dependencies>
</dependencyManagement>

src/main/resources/bootstrap.yml:

මේ file එක හදලා මේ content එක paste කරන්න. token එක myroot කියලා දාන්න.

spring:
  cloud:
    vault:
      host: 127.0.0.1
      port: 8200
      scheme: http
      authentication: TOKEN
      token: myroot # ඔබගේ development token එක
      kv:
        enabled: true
        backend: kv
        application-name: my-app

src/main/java/com/example/vaultdemo/VaultDemoApplication.java:

Spring Boot main application class එක. මේකටම අපි CommandLineRunner එකක් එකතු කරමු secrets කියවන්න.

package com.example.vaultdemo;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;

@SpringBootApplication
public class VaultDemoApplication {

    @Value("${username}")
    private String vaultUsername;

    @Value("${password}")
    private String vaultPassword;

    public static void main(String[] args) {
        SpringApplication.run(VaultDemoApplication.class, args);
    }

    @Bean
    public CommandLineRunner runner() {
        return args -> {
            System.out.println("------------------------------------");
            System.out.println("Vault Username: " + vaultUsername);
            System.out.println("Vault Password: " + vaultPassword);
            System.out.println("------------------------------------");
        };
    }
}

මෙතනදී අපි @Value("${username}") සහ @Value("${password}") පාවිච්චි කරලා Vault එකෙන් load වුන username සහ password values අපේ variables වලට අරගෙන console එකේ print කරනවා.

පියවර 3: Run සහ Test

Vault server එක run වෙනවාද කියලා තහවුරු කරගන්න (පියවර 1).

Console එකේ output එක බලන්න. ඔබට මේ වගේ output එකක් පෙනෙන්න ඕන:

------------------------------------
Vault Username: vaultUser
Vault Password: securePass
------------------------------------

නියමයි! ඔබ සාර්ථකව Spring Boot application එකක් HashiCorp Vault සමග integrate කරලා secrets කියෙව්වා.

Spring Boot application එක run කරන්න. IDE එකෙන් හෝ Maven/Gradle command එකෙන් run කරන්න පුළුවන්:

./mvnw spring-boot:run

මතක තියාගන්න, production environment එකකදී Vault server එක වඩාත් ආරක්ෂිතව setup කරන්න ඕන (TLS, proper authentication methods like AppRole, Kubernetes, etc.) සහ root token එක කිසිම වෙලාවක මේ විදියට code එකේ දාන්න එපා.

නිගමනය

ඉතින්, මේ tutorial එකෙන් අපි HashiCorp Vault සහ Spring Boot applications එක්ක secrets management කරන්නේ කොහොමද කියලා විස්තරාත්මකව ඉගෙන ගත්තා. Secrets hard-code කරන එකෙන් හෝ environment variables විදියට දාන එකෙන් වෙන්න පුළුවන් අවදානම්, ඒ වගේම Vault වගේ tool එකක් පාවිච්චි කරන එකෙන් ලැබෙන වාසි ඔබ දැන් දන්නවා.

Vault කියන්නේ secure secret storage වලට, dynamic secrets වලට, data encryption වලට, සහ audit logging වලට ඉතාම ප්‍රබල විසඳුමක්. Spring Cloud Vault Config එක්ක ඒක Spring Boot applications වලට integrate කරන එක හරිම ලේසියි.

මේ දැනුම ඔබගේ ඊළඟ Spring Boot project එකේ Vault integrate කරලා, ඔබගේ applications වල security එක තවත් වැඩි දියුණු කරන්න පාවිච්චි කරන්න! මොකද, දත්ත ආරක්ෂාව කියන්නේ අපේ වැඩ වලදී කොයිතරම් වැදගත් දෙයක්ද කියලා අපි දන්නවනේ.

ඔබට මේ tutorial එක ගැන අදහස් තියෙනවා නම්, නැත්නම් ප්‍රශ්න තියෙනවා නම්, පහලින් comment කරන්න. අපි කට්ටියම එකතු වෙලා මේ ගැන තව කතා කරමු!

Spring Boot Vault Integration | Secrets Management Sinhala

1. Secrets Management වල වැදගත්කම

Secrets කියන්නේ මොනවද?

දැනට පවතින Secrets Management ක්‍රම වල අවදානම්

2. HashiCorp Vault හඳුනාගනිමු

Vault වල ප්‍රධාන විශේෂාංග (Core Features)

Vault Server එකක් Development Mode එකේ Run කරගනිමු

KV Secrets Engine v2 සක්‍රීය කිරීම සහ Secret එකක් ගබඩා කිරීම

3. Spring Boot සමග Vault සම්බන්ධ කරගැනීම

Dependencies

bootstrap.properties / bootstrap.yml Configurations

Secrets කියවීම: @Value Annotation

4. ප්‍රායෝගික උදාහරණයක්: Secrets කියවමු

පියවර 1: Vault Setup (Local Dev Mode)

පියවර 2: Spring Boot Project Setup

පියවර 3: Run සහ Test

නිගමනය

Spring Boot Vault Integration | Secrets Management Sinhala Tutorial

Spring Boot සහ Consul: Service Discovery, Configuration (Sinhala)

1. Secrets Management වල වැදගත්කම

Secrets කියන්නේ මොනවද?

දැනට පවතින Secrets Management ක්‍රම වල අවදානම්

2. HashiCorp Vault හඳුනාගනිමු

Vault වල ප්‍රධාන විශේෂාංග (Core Features)

Vault Server එකක් Development Mode එකේ Run කරගනිමු

KV Secrets Engine v2 සක්‍රීය කිරීම සහ Secret එකක් ගබඩා කිරීම

3. Spring Boot සමග Vault සම්බන්ධ කරගැනීම

Dependencies

bootstrap.properties / bootstrap.yml Configurations

Secrets කියවීම: @Value Annotation

4. ප්‍රායෝගික උදාහරණයක්: Secrets කියවමු

පියවර 1: Vault Setup (Local Dev Mode)

පියවර 2: Spring Boot Project Setup

පියවර 3: Run සහ Test

නිගමනය

Spring Boot Vault Integration | Secrets Management Sinhala Tutorial

Spring Boot සහ Consul: Service Discovery, Configuration (Sinhala)

You might also like...