Spring Boot සහ HashiCorp Vault Integration | රහස් කළමනාකරණය | Sinhala Guide

ආයුබෝවන්! Spring Boot සමග HashiCorp Vault භාවිතයෙන් Secrets කළමනාකරණය

ආයුබෝවන්! අද අපි කතා කරන්න යන්නේ software development වල හරිම වැදගත් මාතෘකාවක් ගැන – ඒ තමයි HashiCorp Vault භාවිතයෙන් Spring Boot applications වල secrets manage කරන හැටි. ඩිවලොපර්ස්ලා විදිහට අපි හැමෝම database passwords, API keys, private credentials වගේ sensitive data handle කරනවා. මේවා code එක ඇතුළේ hardcode කරන එක, නැත්නම් application.properties file එකක direct දාන එක කොච්චර භයානකද කියලා ඔයාලා දන්නවා ඇති. Cyber security attacks වැඩිවෙමින් පවතින මේ කාලේ, secrets management කියන්නේ නොසලකා හරින්න බැරි දෙයක්.

මේ tutorial එකෙන් අපි Spring Boot application එකක් HashiCorp Vault එකක් එක්ක integrate කරලා, secrets ආරක්ෂිතව store කරලා retrieve කරන්නේ කොහොමද කියලා පියවරෙන් පියවර බලමු. ඊට පස්සේ ඔබේ applications තවත් secure කරන්න පුළුවන්.

HashiCorp Vault කියන්නේ මොකක්ද?

HashiCorp Vault කියන්නේ secrets management, data encryption, identity-based access වගේ දේවල් සඳහා නිර්මාණය කරපු security tool එකක්. සරලවම කිව්වොත්, ඔබේ application එකට අවශ්‍ය හැම secret එකක්ම (passwords, API keys, certificates) ආරක්ෂිතව තැන්පත් කරලා, ඒවාට අවශ්‍ය වෙලාවට විතරක් access දෙන්න පුළුවන් central place එකක් තමයි Vault කියන්නේ.

ඇයි Vault අවශ්‍ය වෙන්නේ?

• ආරක්ෂාව (Security): Passwords, API keys වගේ දේවල් code එකේ හෝ config files වල hardcode කරලා තියන එක හරිම භයානකයි. මේවා source code repository වලට commit වුණොත්, ඒවාට access තියන ඕනෑම කෙනෙකුට ඔබේ systems වලට penetrate වෙන්න පුළුවන්. Vault මේ secrets encrypt කරලා ආරක්ෂිතව තියාගන්නවා.
• මධ්‍යගත කළමනාකරණය (Centralized Management): ඔබේ applications ගොඩකට secrets තියනවා නම්, ඒ හැම එකක්ම එක තැනකින් manage කරන්න Vault උපකාරී වෙනවා.
• Auditing: කවුද, කවදා, මොන secret එකට access කළාද කියලා Vault මගින් log කරනවා. මේක security compliance වලට හරිම වැදගත්.
• Dynamic Secrets: Database credentials වගේ දේවල් අවශ්‍ය වෙලාවට විතරක් generate කරලා, පාවිච්චි කරලා ඉවර වුණාම revoke කරන්න Vault වලට පුළුවන්. මේක security එක තවත් වැඩි කරනවා.

අද අපි මූලිකවම අවධානය යොමු කරන්නේ Vault වල KV (Key-Value) secrets engine එකට. මේකෙන් පුළුවන් data dictionary එකක් වගේ secrets key-value pairs විදිහට store කරන්න.

Spring Boot Application එකකට Vault Integrarte කරන්නේ කොහොමද?

මුලින්ම, අපිට local machine එකේ running HashiCorp Vault server එකක් ඕනේ. මේ tutorial එකට අපි development server එකක් පාවිච්චි කරමු. ඒක පහසුවෙන් setup කරගන්න පුළුවන්.

පියවර 1: HashiCorp Vault Development Server එකක් පටන් ගමු

ඔබේ Terminal/Command Prompt එක Open කරලා පහත command එක execute කරන්න:

vault server -dev

මේ command එකෙන් dev server එකක් start වෙනවා. මේක ඔබට root token එකක් (Root Token: s.xxxxxxx වගේ එකක්) සහ Vault address එකක් (http://127.0.0.1:8200) ලබාදෙනවා. මේ token එක save කරගන්න, අපිට ඒක ටිකකින් අවශ්‍ය වෙනවා.

ඊට පස්සේ Vault CLI (Command Line Interface) එක use කරන්න මේ environment variables set කරගන්න:

export VAULT_ADDR='http://127.0.0.1:8200'
export VAULT_TOKEN='<ඔබේ Root Token එක මෙතනට දාන්න>'

Windows භාවිතා කරන්නන් PowerShell හෝ Command Prompt එකේ $env:VAULT_ADDR='http://127.0.0.1:8200' සහ $env:VAULT_TOKEN='<ඔබේ Root Token එක මෙතනට දාන්න>' ලෙස භාවිත කරන්න.

පියවර 2: Spring Boot Project එකට Dependencies එකතු කිරීම

ඔබේ Spring Boot project එකේ pom.xml (Maven) හෝ build.gradle (Gradle) file එකට spring-cloud-starter-vault-config dependency එක එකතු කරන්න.

Maven (pom.xml):

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

<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-dependencies</artifactId>
            <version>2023.0.0</version> <!-- හෝ නවතම Stable Version එකක් -->
            <type>pom</type>
            <scope>import</scope>
        </dependency>
    </dependencies>
</dependencyManagement>

මෙහිදී spring-cloud-dependencies version එක ඔබ භාවිත කරන Spring Boot version එකට ගැළපෙන එකක් යොදාගැනීමට වගබලා ගන්න.

පියවර 3: Spring Boot Application Configuration

Spring Boot application එකට Vault සමග connect වෙන්න අවශ්‍ය Configuration අපි bootstrap.properties (හෝ bootstrap.yml) file එකට දාන්න ඕනේ. මේක application.properties එකට කලින් load වෙනවා, ඒ නිසා Vault config මේකට දැමීම සුදුසුයි.

src/main/resources/bootstrap.properties file එක create කරලා පහත details එකතු කරන්න:

spring.application.name=my-vault-app

spring.cloud.vault.scheme=http
spring.cloud.vault.host=127.0.0.1
spring.cloud.vault.port=8200
spring.cloud.vault.token=<ඔබේ Root Token එක මෙතනට දාන්න>

# KV engine version එක specify කරන්න, dev server එක default v2. 
# Vault server configuration එක අනුව මේක වෙනස් වෙන්න පුළුවන්.
spring.cloud.vault.kv.enabled=true
spring.cloud.vault.kv.default-context=application
spring.cloud.vault.kv.profile-separator=/

සටහන: spring.application.name=my-vault-app කියන එක හරිම වැදගත්. මේක තමයි Vault එකේ secrets store කරන path එකට බලපාන්නේ. උදාහරණයක් විදිහට, secret/my-vault-app/config වගේ path එකක් හැදෙන්නේ මේ spring.application.name එකෙන්.

Secrets Vault එකේ Store කරන්නේ සහ Retrieve කරන්නේ කොහොමද?

දැන් අපි secrets Vault එකේ store කරලා, ඒවා Spring Boot application එකෙන් retrieve කරමු.

පියවර 1: Secrets Vault එකේ Store කිරීම

අපි Vault CLI එක පාවිච්චි කරලා secrets store කරමු. අපි උදාහරණයක් විදිහට database.username සහ database.password කියලා secrets දෙකක් store කරමු.

secret/my-vault-app/config කියන path එකට අපි මේ secrets store කරනවා. my-vault-app කියන්නේ spring.application.name එකෙන් ආපු නම.

vault kv put secret/my-vault-app/config database.username=devuser database.password=devpass

මේ command එක execute කළාම Vault එකේ secrets store වෙනවා. ඔබට vault kv get secret/my-vault-app/config command එකෙන් ඒවා බලන්න පුළුවන්.

පියවර 2: Spring Boot Application එකෙන් Secrets Retrieve කිරීම

දැන් අපි Spring Boot application එකෙන් Vault එකේ තියන secrets retrieve කරලා පාවිච්චි කරන්නේ කොහොමද කියලා බලමු. මේක @Value annotation එකෙන් හෝ Environment object එකෙන් කරන්න පුළුවන්.

පහත VaultDemoController class එක නිර්මාණය කරන්න:

package com.example.vaultdemo; // ඔබේ package නම අනුව වෙනස් කරන්න

import org.springframework.beans.factory.annotation.Value;
import org.springframework.core.env.Environment;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class VaultDemoController {

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

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

    private final Environment environment;

    public VaultDemoController(Environment environment) {
        this.environment = environment;
    }

    @GetMapping("/vault-secrets-value")
    public String getSecretsFromValueAnnotation() {
        return "Username (from @Value): " + dbUsername + ", Password (from @Value): " + dbPassword;
    }

    @GetMapping("/vault-secrets-env")
    public String getSecretsFromEnvironment() {
        String username = environment.getProperty("database.username");
        String password = environment.getProperty("database.password");
        return "Username (from Environment): " + username + ", Password (from Environment): " + password;
    }

    @GetMapping("/")
    public String home() {
        return "Welcome to Spring Boot Vault Demo! Try /vault-secrets-value or /vault-secrets-env";
    }
}

මේ controller එකේ අපි secrets retrieve කරන්න ක්‍රම දෙකක් පෙන්වනවා:

1. @Value annotation එක භාවිතයෙන්: ${database.username} වගේ expressions වලින් Vault එකෙන් එන properties direct inject කරන්න පුළුවන්.
2. Environment object එක භාවිතයෙන්: Spring's Environment object එකෙන් getProperty() method එක පාවිච්චි කරලා secrets retrieve කරන්න පුළුවන්.

පියවර 3: Application එක Run කරලා Test කිරීම

දැන් ඔබේ Spring Boot application එක run කරන්න. Maven එකෙන් නම් mvn spring-boot:run command එක execute කරන්න.

Application එක start වුණාම, ඔබේ browser එකෙන් හෝ Postman/curl වගේ tool එකකින් පහත URLs වලට request යවන්න:

• http://localhost:8080/vault-secrets-value
• http://localhost:8080/vault-secrets-env

ඔබට Vault එකේ store කරපු username සහ password ලැබෙනවා දකින්න පුළුවන්. මේකෙන් confirm වෙනවා ඔබේ Spring Boot application එක Vault එකත් එක්ක successfuly integrate වෙලා secrets retrieve කරනවා කියලා.

Production එකට Ready කරන්නේ කොහොමද?

අපි මේ tutorial එකේදී development environment එකට vault server -dev command එකෙන් dev token එකක් පාවිච්චි කළා. නමුත් production environments වලදී මේ ක්‍රමය කිසිසේත් සුදුසු නැහැ. ඒ වෙනුවට මේ දේවල් සලකා බලන්න:

• ආරක්ෂිත Authentication Methods: Production වලදී AppRole, Kubernetes, AWS IAM, Azure Active Directory, GCP IAM වගේ Vault authentication methods භාවිත කරන්න. මේවා වඩාත් ආරක්ෂිතයි, token එකක් hardcode කරන්න අවශ්‍ය වෙන්නේ නැහැ.
• TLS/SSL: Vault server එකට secure connection (HTTPS) එකක් භාවිතා කරන්න. spring.cloud.vault.scheme=https ලෙස වෙනස් කරන්න.
• Leasing and Revocation: Vault dynamic secrets generate කරන්න පුළුවන්. උදාහරණයක් විදිහට database credentials යම් කාලයකට විතරක් (short-lived) generate කරලා, ඒවා expire වුණාම revoke කරන්න පුළුවන්. මේක security එක තවත් වැඩි කරනවා.
• Audit Logging: Vault access logs නිසි පරිදි configure කරලා maintain කරන්න.

නිගමනය

ඔබේ Spring Boot applications වල secrets ආරක්ෂා කරගැනීම ඕනෑම enterprise level application එකකට අත්‍යවශ්‍යයි. HashiCorp Vault වැනි tool එකක් භාවිතයෙන් මේ ක්‍රියාවලිය මධ්‍යගතව, ආරක්ෂිතව සහ කාර්යක්ෂමව කරගන්න පුළුවන්. මේ tutorial එකෙන් ඔබට Spring Boot සමග Vault integrate කරන්නේ කොහොමද කියලා මූලික අවබෝධයක් ලැබෙන්න ඇති. මේ ක්‍රමවේදය ඔබේ project වලටත් අනුගමනය කරලා applications තවත් secure කරගන්න පුළුවන්.

Vault වල තවත් බොහෝ advanced features තියනවා. ඔබ කැමති නම් ඒවා ගැනත් වැඩිදුර ඉගෙන ගන්න පුළුවන්. මේක ඔබේම project එකක implement කරලා බලන්න. ඔබට මේ සම්බන්ධයෙන් කිසියම් ගැටළුවක් හෝ අදහසක් තියනවා නම්, පහතින් comment එකක් දාන්න! ඔබේ අත්දැකීම් බෙදාගන්න.