Spring Boot Profiles: Smart Configuration Management SC Guide

කොහොමද යාලුවනේ? Software Engineering ක්ෂේත්‍රයේ ඉන්න අපිට, එකම ඇප්ලිකේෂන් එක විවිධ පරිසරවල (environments) වැඩ කරද්දී, ඒ හැම පරිසරයකටම වෙනස් configuration settings අවශ්‍ය වෙනවා නේද? උදාහරණයක් විදියට, Development කරනකොට අපිට local database එකක්, Debugging සඳහා log level වැඩි කරපු settings, වගේ දේවල් ඕනේ වෙනවා. හැබැයි Production වලදී high-performance database එකක්, Strict Security settings, සහ minimal logging තමයි අපිට අවශ්‍ය වෙන්නේ. මේක මාරම ප්‍රශ්නයක්. මොකද මේ settings හැම වෙලාවෙම අතින් වෙනස් කරන්න ගියොත්, වැරදි වෙන්න තියෙන ඉඩ වැඩියි, වැඩත් හෙමින් වෙනවා.

අයියෝ, අවුල් නේද? ඒකට තමයි Spring Boot Profiles කියන සුපිරි feature එක තියෙන්නේ. අද අපි මේ ගැන ගැඹුරින් කතා කරමු, practical විදියට බලමු මේක කොහොමද අපේ project වලට implement කරන්නේ කියලා. සෙට් වෙමු!

මොකක්ද මේ Spring Boot Profile කියන්නේ?

සරලව කිව්වොත්, Spring Boot Profile එකක් කියන්නේ අපේ application එකේ configuration properties සමූහයකට දෙන නමක්. මේ profiles පාවිච්චි කරලා අපිට application එකේ behavior එක, ඒක run කරන environment එක අනුව වෙනස් කරන්න පුළුවන්. උදාහරණයක් විදියට, ‘dev’ කියලා profile එකක් හදලා Development environment එකට අවශ්‍ය configuration ටික දාන්න පුළුවන්. ‘prod’ කියලා profile එකක් හදලා Production environment එකට අවශ්‍ය settings ටික දාගන්න පුළුවන්. ඒ වගේම ‘test’ වගේ profiles හදලා unit testing, integration testing වලටත් වෙනස් settings යොදාගන්න පුළුවන්.

මේකෙන් වෙන්නේ, අපිට එක් එක් environment එකට වෙනම code base එකක් maintain කරන්න අවශ්‍ය වෙන්නේ නෑ. එකම code base එකකින්, environment එක අනුව auto configure වෙන විදියට අපේ application එක හදාගන්න පුළුවන් වීම.

Profiles හදමු – Practical Breakdown

හරි, දැන් බලමු මේ profiles practical විදියට හදන්නේ කොහොමද කියලා.

Default Profile

ඔබ දන්නවා ඇති Spring Boot application එකක් හදද්දී, default configuration ටික `src/main/resources/application.properties` (or `application.yml`) ෆයිල් එකේ තමයි අපි දාන්නේ. මේක තමයි අපේ application එකේ default profile එක.

# application.properties
spring.application.name=my-spring-app
server.port=8080
my.custom.greeting=Hello from Default!

Custom Profiles

දැන් අපි Dev සහ Prod profiles හදමු. මේ සඳහා අපි `application-{profile-name}.properties` වගේ ෆයිල්ස් හදනවා.

Development Profile (`application-dev.properties`)

Development environment එකට අවශ්‍ය settings ටික මෙතන දාමු. සාමාන්‍යයෙන් Development වලදී අපිට in-memory database (H2 වගේ) එකක්, detailed logging, වගේ දේවල් අවශ්‍ය වෙනවා.

# application-dev.properties
spring.datasource.url=jdbc:h2:mem:testdb
spring.datasource.driverClassName=org.h2.Driver
spring.datasource.username=sa
spring.datasource.password=
spring.jpa.hibernate.ddl-auto=update
spring.jpa.show-sql=true
logging.level.root=DEBUG
server.port=8081
my.custom.greeting=Hello from Development!

Production Profile (`application-prod.properties`)

Production environment එකට අවශ්‍ය settings මෙතන දාමු. Production වලදී real database එකක්, error logging පමණක්, වගේ දේවල් තමයි අවශ්‍ය වෙන්නේ.

# application-prod.properties
spring.datasource.url=jdbc:postgresql://prod-db-server:5432/myapp_prod
spring.datasource.driverClassName=org.postgresql.Driver
spring.datasource.username=produser
spring.datasource.password=prod_secure_password
spring.jpa.hibernate.ddl-auto=none
spring.jpa.show-sql=false
logging.level.root=INFO
server.port=80
my.custom.greeting=Hello from Production!

Using @Profile Annotation

සමහර වෙලාවට අපිට profile එකක් active කරපු වෙලාවට විතරක් load වෙන්න ඕනේ bean එකක් හෝ component එකක් තියෙන්න පුළුවන්. ඒකට `@Profile` annotation එක පාවිච්චි කරන්න පුළුවන්.

import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Profile;

@Configuration
public class DataSourceConfig {

    @Profile("dev")
    @Bean
    public String devDataSource() {
        System.out.println("Using Dev Data Source Configuration!");
        return "DevDataSource";
    }

    @Profile("prod")
    @Bean
    public String prodDataSource() {
        System.out.println("Using Prod Data Source Configuration!");
        return "ProdDataSource";
    }

    @Profile("!prod") // Not for prod profile
    @Bean
    public String nonProdBean() {
        System.out.println("This bean is active in non-prod environments.");
        return "NonProdBean";
    }
}

මෙහිදී, `devDataSource()` method එක run වෙන්නේ ‘dev’ profile එක active කරපු වෙලාවට විතරයි. ඒ වගේම `prodDataSource()` method එක run වෙන්නේ ‘prod’ profile එක active කරපු වෙලාවට විතරයි. `!prod` කියන්නේ ‘prod’ profile එක නොවන ඕනෑම profile එකක් active කරද්දී මේ bean එක load වෙනවා කියන එකයි.

Profiles මාරු කරන්නේ කොහොමද?

දැන් අපි profiles හැදුවා. එතකොට අපේ application එක run කරද්දී, අපිට අවශ්‍ය profile එක active කරන්නේ කොහොමද? ක්‍රම කිහිපයක් තියෙනවා.

1. Command Line Argument වලින්

මේක තමයි ගොඩක් වෙලාවට අපි application එක run කරද්දී පාවිච්චි කරන ලේසිම ක්‍රමය. JAR එක run කරද්දී `spring.profiles.active` property එක JVM argument එකක් විදියට දෙන්න පුළුවන්.

# Dev profile active කරන්න
java -jar -Dspring.profiles.active=dev my-spring-app.jar

# Prod profile active කරන්න
java -jar -Dspring.profiles.active=prod my-spring-app.jar

ඔබට profiles කිහිපයක් එකවර active කරන්න අවශ්‍ය නම් comma වලින් වෙන් කරලා දෙන්න පුළුවන්:

java -jar -Dspring.profiles.active=dev,h2 my-spring-app.jar

2. application.properties/yml ෆයිල් එකෙන්

ඔබට ඔබේ `application.properties` (or `application.yml`) ෆයිල් එක ඇතුලෙම default active profile එකක් specify කරන්න පුළුවන්. මේක සාමාන්‍යයෙන් Development environment එකේදී හෝ local testing වලදී පහසුයි.

# application.properties
spring.profiles.active=dev

නමුත් Production environment එකකදී මේ විදියට define කරනවාට වඩා command line arguments හෝ environment variables පාවිච්චි කරන එක තමයි හොඳම practice එක.

3. Environment Variable එකක් විදියට

CI/CD pipelines වලදී සහ Docker containers වගේ දේවල් වලදී මේ ක්‍රමය ගොඩක් වැදගත්. `SPRING_PROFILES_ACTIVE` කියලා Environment Variable එකක් set කරලා profile එක active කරන්න පුළුවන්.

# Linux/macOS
export SPRING_PROFILES_ACTIVE=prod
java -jar my-spring-app.jar

# Windows (Command Prompt)
set SPRING_PROFILES_ACTIVE=prod
java -jar my-spring-app.jar

මේක තමයි Production deployments වලදී ගොඩක් වෙලාවට පාවිච්චි කරන්නේ.

Production එකට Ready කරමු!

Spring Boot profiles පාවිච්චි කරලා Production environment එකට අපේ application එක සූදානම් කරද්දී අවධානය යොමු කළ යුතු කරුණු කිහිපයක් තියෙනවා.

• ආරක්ෂාව (Security): Production profile එකේදී debug mode, test credentials, sensitive data logging වගේ දේවල් අනිවාර්යයෙන් disable කරන්න. Security-related configurations මෙතන manage කරන්න පුළුවන්.
• ලොග් කිරීම (Logging): Development වලදී Debug level logging අවශ්‍ය වුනත්, Production වලදී `INFO`, `WARN` හෝ `ERROR` වගේ levels වලට සීමා කරන්න. අධික logging නිසා performance issues සහ disk space problems ඇති වෙන්න පුළුවන්.
• දත්ත සමුදාය (Database): Production සඳහා high-performance, clustered database connections use කරන්න. Connection pooling (e.g., HikariCP) නිවැරදිව configure කරලා තියෙන්න ඕනේ.
• Performance Tuning: Thread pool sizes, cache settings, JVM arguments වගේ දේවල් Production environment එකට optimize කරන්න පුළුවන්.
• Externalized Configuration: Sensitive information (database passwords, API keys) application properties ෆයිල්ස් වල තියනවාට වඩා Environment variables, Secret Management Services (e.g., HashiCorp Vault, AWS Secrets Manager) හරහා ලබාගන්න විදියට configure කරන්න.

අවසන් වචනය

නියමයි නේද? Spring Boot Profiles කියන්නේ අපේ applications වල configuration management එක ගොඩක් පහසු කරන, වැදගත් tool එකක්. මේකෙන් අපිට application එකේ maintainability එක වැඩි කරගන්න පුළුවන් වගේම, environment-specific errors අඩු කරගන්නත් පුළුවන්. ඒ වගේම, CI/CD pipelines වලදී automated deployments වලටත් මේක අත්‍යවශ්‍ය දෙයක්.

ඔබට දැන් හොඳ අවබෝධයක් තියෙනවා ඇති මේ Profiles කොහොමද හදන්නේ, use කරන්නේ සහ switch කරන්නේ කියලා. මම හිතනවා මේක ඔබේ next Spring Boot Project එකට මාරම ප්‍රයෝජනවත් වෙයි කියලා. මේ concepts ගැන ඔබට ප්‍රශ්න තියෙනවා නම්, පහලින් comment එකක් දාන්න. නැත්නම් ඔබ මේ ගැන දන්නා අලුත් දේවල් share කරන්න. අපි හැමෝටම ඉගෙන ගන්න පුළුවන් වෙයි!

ඊළඟ පෝස්ට් එකෙන් හම්බවෙමු! Happy Coding!