Spring Boot Consul Tutorial Sinhala | Service Discovery | Configuration | HashiCorp

ආයුබෝවන්, Spring Boot Developers ලාට!

අද කාලේ Software Development වල Microservices කියන්නේ මාරම ජනප්‍රිය Topic එකක්. හැබැයි මේ Microservices Architecture එකේ වැඩ කරනකොට එන ප්‍රධාන ගැටලු කීපයක් තියෙනවා. එකක් තමයි, Services ගොඩක් අතරේ තියෙන සම්බන්ධතාවය (Service Discovery) manage කරන එක. අනිත් එක තමයි, මේ හැම Service එකකටම වෙන වෙනම Configuration (සැකසුම්) manage කරන එක.

මේ ප්‍රශ්න වලට විසඳුමක් විදිහට HashiCorp Consul කියන Tool එක ගැන තමයි අද අපි කතා කරන්න යන්නේ. Spring Boot Application එකක් Consul එක්ක කොහොමද එකට වැඩ කරන්නේ කියලා මේ Tutorial එකෙන් අපි සරලව තේරුම් ගමු. විශේෂයෙන්ම, Service Discovery සහ Distributed Configuration Management වලට Consul භාවිතා කරන ආකාරය අපි පැහැදිලි කරනවා.

මේ ලිපිය කියෙව්වට පස්සේ ඔයාට පුළුවන් වෙයි Spring Boot Project එකක් Consul එක්ක Register කරලා ඒකේ Configurations Consul හරහා manage කරගන්න.

Consul යනු කුමක්ද? (What is Consul?)

Consul කියන්නේ HashiCorp සමාගම විසින් හඳුන්වා දුන්න Distributed Service Mesh එකක්. සරලව කිව්වොත්, Microservices Architecture එකක තියෙන Services අතර සම්බන්ධතාවය සහ ඒවායේ Configurations manage කරන්න පුදුමාකාර විදිහට උදව් වෙන Tool එකක්. Consul වලට ප්‍රධාන Features කීපයක්ම තියෙනවා:

• Service Discovery: Services එකිනෙකා හොයාගන්න උදව් කරනවා. Services dynamically එනකොට, යනකොට, Update වෙනකොට මේක මාරම වැදගත්.
• Configuration Management (Key/Value Store): Services වල Configurations centralized විදිහට manage කරන්න පුළුවන්. Database Credentials, API Keys වගේ දේවල් මේ Key/Value Store එකේ තියන්න පුළුවන්.
• Health Checking: Register කරලා තියෙන Services හරියට වැඩ කරනවද කියලා check කරනවා. වැඩ කරන්නේ නැති Services Discovery Service එකෙන් අයින් කරනවා.
• Secure Service Communication: TLS හරහා Services අතරේ Secure Communication කරන්න පුළුවන්.

මේ සියල්ලම එකට එකතු වෙලා, ඔයාගේ Microservices Deployment එක වඩාත් Robust සහ Manageable එකක් බවට පත් කරනවා. හරි, එහෙනම් Spring Boot වලට මේක කොහොමද වැදගත් වෙන්නේ කියලා බලමු.

Spring Boot Microservices වලට Consul අවශ්‍ය ඇයි? (Why Spring Boot Needs Consul?)

Monolithic Application එකක් ගත්තොත්, හැමදේම එකම Codebase එකේ තියෙන නිසා Services අතරේ Communication, Configuration Management කියන දේවල් එච්චර සංකීර්ණ නැහැ. හැබැයි Microservices වලදී කතාව වෙනස්.

Configuration Management ගැටලුව:

ஒவ்வொரு Microservice එකකටම තමන්ටම වෙන් වුණු Configurations තියෙනවා. ඒ වගේම Production environment එකේදී මේ Configurations වෙනස් වෙන්න පුළුවන්. උදාහරණයක් විදිහට, Database Connection String එකක් වෙනස් වුණොත්, අපිට Services සියල්ලම Restart නොකර ඒ Configuration එක Update කරන්න පුළුවන් නම් ඒක මාරම පහසුවක්. Consul Key/Value Store එක මේකට හොඳ විසඳුමක්. අපේ Configurations Consul එකේ තියලා, Spring Boot Application එකට පුළුවන් Consul වලින් Configurations Read කරන්න.

Service Discovery ගැටලුව:

Microservices වලදී, ඔයාට Services ගොඩක් තියෙන්න පුළුවන්. උදාහරණයක් විදිහට, Order Service එකට Product Service එකෙන් Product Details ගන්න ඕන වෙනවා. Product Service එකේ Instances දහයක් දොළහක් තියෙන්න පුළුවන්. ඒ වගේම ඒ Instances වල IP Addresses සහ Port numbers නිතරම වෙනස් වෙන්න පුළුවන් (විශේෂයෙන් Cloud Environment එකකදී). සාමාන්‍ය විදිහට, මේ IP Address එක Hardcode කරන්න බැහැ. එතකොට, Order Service එකට Product Service එක හොයාගන්නේ කොහොමද? මේකට තමයි Service Discovery Pattern එක භාවිතා කරන්නේ. Consul කියන්නේ ඒ සඳහා පාවිච්චි කරන්න පුළුවන් Effective Tool එකක්. Consul server එකේ Register වෙලා තියෙන Service Instances ගැන තොරතුරු ඕනම Service එකකට Consul හරහා ලබාගන්න පුළුවන්.

මේ හේතු නිසා තමයි Spring Boot Microservices වලදී Consul කියන්නේ නැතුවම බැරි Tool එකක් වෙන්නේ.

Spring Boot සමඟ Consul ඒකාබද්ධ කරමු (Integrating Spring Boot with Consul)

හරි, දැන් අපි බලමු Spring Boot Application එකක් Consul එක්ක integrate කරගන්නේ කොහොමද කියලා. මේ සඳහා අපිට Spring Cloud Consul Project එකේ Dependencies අවශ්‍ය වෙනවා.

පියවර 1: Consul Server එක සකසා ගැනීම (Setting up Consul Server)

මේ Tutorial එක සඳහා ඔයාගේ Local Machine එකේ Consul Server එකක් Run වෙන්න ඕනේ. ඒක මාරම ලේසියි. HashiCorp Consul Official Website එකෙන් (consul.io) Download කරලා, Command Line එකෙන් පහත විදිහට Run කරන්න පුන්ළුවන්:

consul agent -dev

මේ Command එකෙන් Consul Server එක Development Mode එකේ Run වෙනවා. සාමාන්‍යයෙන්, Consul UI එකට Browser එකෙන් යන්න පුළුවන් http://localhost:8500/ui හරහා.

පියවර 2: Maven Dependencies එකතු කිරීම (Adding Maven Dependencies)

ඔයාගේ Spring Boot Project එකේ pom.xml (Maven Project එකක් නම්) එකට පහත Dependencies එකතු කරන්න:

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-consul-discovery</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-consul-config</artifactId> <!-- Configuration Management සඳහා -->
    </dependency>
</dependencies>

<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-dependencies</artifactId>
            <version>2021.0.3</version> <!-- Spring Cloud version එක මේකෙන් තෝරන්න -->
            <type>pom</type>
            <scope>import</scope>
        </dependency>
    </dependencies>
</dependencyManagement>

<build>
    <plugins>
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
        </plugin>
    </plugins>
</build>

<version>2021.0.3</version> කියන එක ඔයාගේ Spring Boot version එකට ගැළපෙන Spring Cloud Version එකක් වෙන්න ඕන. ඒ සඳහා Spring Cloud Release Train එකේ Documentations බලන්න.

පියවර 3: Application Properties සකස් කිරීම (Configuring Application Properties)

Consul එක්ක Communicate කරන්න අවශ්‍ය Configurations application.properties හෝ application.yml file එකට එකතු කරන්න. සාමාන්‍යයෙන්, Configuration Management වලට bootstrap.properties/bootstrap.yml භාවිතා කරනවා, මොකද ඒක Application එක ආරම්භ වෙන්නත් කලින් Load වෙනවා.

src/main/resources/application.properties:

spring.application.name=my-consul-app
server.port=8080

# Consul Host and Port
spring.cloud.consul.host=localhost
spring.cloud.consul.port=8500

# Enable Consul Service Discovery
spring.cloud.consul.discovery.enabled=true
spring.cloud.consul.discovery.register=true # True නම් Application එක Consul එක්ක Register වෙනවා
spring.cloud.consul.discovery.instance-id=${spring.application.name}:${instanceId:${random.value}}
spring.cloud.consul.discovery.healthCheckPath=/actuator/health # Health check endpoint එකක්
spring.cloud.consul.discovery.healthCheckInterval=10s

src/main/resources/bootstrap.properties: (Configuration Management සඳහා)

spring.application.name=my-consul-app

# Consul Host and Port (bootstrap එකෙත් define කරන්න පුළුවන්)
spring.cloud.consul.host=localhost
spring.cloud.consul.port=8500

# Enable Consul Configuration
spring.cloud.consul.config.enabled=true
spring.cloud.consul.config.format=properties # හෝ YAML
spring.cloud.consul.config.prefix=config # Consul Key/Value Store එකේ prefix එක
spring.cloud.consul.config.defaultContext=application # Global configurations සඳහා
spring.cloud.consul.config.data-centers=dc1 # Optional: specific data center

bootstrap.properties එකේ spring.cloud.consul.config.prefix=config කියන්නේ, Consul Key/Value Store එකේ ඔයාගේ Configurations තියෙන Path එක. උදාහරණයක් විදිහට, config/my-consul-app/my-property වගේ.

පියවර 4: Spring Boot Main Application Class එක සකස් කිරීම (Main Application Class Setup)

ඔයාගේ Main Application Class එකට @EnableDiscoveryClient Annotation එක එකතු කරන්න. මේකෙන් Spring Boot Application එක Service Discovery Client එකක් විදිහට ක්‍රියා කරන්න පටන් ගන්නවා.

package com.example.consulapp;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@SpringBootApplication
@EnableDiscoveryClient
@RestController
public class MyConsulAppApplication {

    @Value("${my.greeting:Hello from default value}")
    private String greetingMessage;

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

    @GetMapping("/hello")
    public String hello() {
        return "Hello from '" + greetingMessage + "' in Spring Boot Consul App!";
    }

    @GetMapping("/service-info")
    public String serviceInfo() {
        return "Service Name: my-consul-app, Port: 8080, Registered with Consul";
    }
}

@Value("${my.greeting:Hello from default value}") කියන එකෙන් අපි Consul එකෙන් එන my.greeting කියන Property එක Read කරනවා. Consul එකේ මේ Property එක නැතිනම් Default Value එක Use කරනවා.

ප්‍රායෝගික උදාහරණයක්: Spring Boot App එකක් Consul සමඟ Register කරමු (Practical Example: Registering a Spring Boot App with Consul)

දැන් අපි මේක Practical විදිහට කරලා බලමු.

පියවර 1: Consul Server එක Run කරන්න

Command Line එක Open කරලා, Consul executable එක තියෙන තැනට ගිහින් මේ Command එක Run කරන්න:

consul agent -dev

Consul UI එකට යන්න http://localhost:8500/ui. Services Section එක හිස්ව තියෙයි තාම.

පියවර 2: Spring Boot Application එක Run කරන්න

දැන් ඔයාගේ IntelliJ IDEA හෝ VS Code වගේ IDE එකකින් හෝ Maven Command එකකින් Spring Boot Application එක Run කරන්න:

mvn spring-boot:run

Application එක Start වුණාට පස්සේ, Console එකේ ඔයාට Consul එක්ක සම්බන්ධ වෙන Log Messages බලාගන්න පුළුවන්.

පියවර 3: Consul UI එකෙන් Verify කරන්න

Application එක Successful විදිහට Start වුණාට පස්සේ, Consul UI එකේ http://localhost:8500/ui කියන Address එකට ගිහින් Services Section එක බලන්න. ඔයාට my-consul-app කියලා Service එකක් Register වෙලා තියෙනවා දකින්න පුළුවන් වෙයි. ඒ වගේම ඒකේ Health Status එක Green (passing) වෙන්න ඕනේ.

පියවර 4: Configuration Management Test කරන්න

දැන් අපි Consul Key/Value Store එකට Configuration එකක් දාමු. Consul UI එකේ Key/Value Tab එකට ගිහින්, config/my-consul-app/my-property කියලා Key එකක් Create කරලා, Value එක ආයුබෝවන් ලෝකය! කියලා දෙන්න.

දැන් ඔයාගේ Browser එකේ http://localhost:8080/hello කියන Address එකට යන්න. ඔයාට Hello from 'ආයුබෝවන් ලෝකය!' in Spring Boot Consul App! කියලා Output එක ලැබෙන්න ඕනේ.

තව දුරටත්, Consul UI එකට ගිහින් config/my-consul-app/my-property කියන Key එකේ Value එක වෙනස් කරන්න. උදාහරණයක් විදිහට ආයුබෝවන් ශ්‍රී ලංකාව! කියලා. Spring Cloud Consul වලට Spring Cloud Bus (මෙහිදී AMQP/Kafka අවශ්‍ය වෙනවා) නැතිව වුණත් Configurations Reload කරන්න පුළුවන් (Default Refresh Interval එකකින්). නැත්නම් Manual Refresh Endpoint එකක් Use කරන්න පුළුවන්. Simple Refresh සඳහා @RefreshScope Annotation එක භාවිතා කරන්න පුළුවන්.

package com.example.consulapp;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
import org.springframework.cloud.context.config.annotation.RefreshScope; // මේක මාරම වැදගත්
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@SpringBootApplication
@EnableDiscoveryClient
@RestController
@RefreshScope // මෙය එකතු කරන්න
public class MyConsulAppApplication {

    @Value("${my.greeting:Hello from default value}")
    private String greetingMessage;

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

    @GetMapping("/hello")
    public String hello() {
        return "Hello from '" + greetingMessage + "' in Spring Boot Consul App!";
    }

    @GetMapping("/service-info")
    public String serviceInfo() {
        return "Service Name: my-consul-app, Port: 8080, Registered with Consul";
    }
}

@RefreshScope එකතු කරලා, Consul එකේ Value එක වෙනස් කරලා, http://localhost:8080/actuator/refresh (spring-boot-starter-actuator dependency එක අවශ්‍යයි) කියන Endpoint එකට POST Request එකක් යැව්වම, Application එක Restart නොකරම අලුත් Value එක Load වෙනවා.

අවසන් වශයෙන් (Conclusion)

Consul කියන්නේ Microservices Architecture එකකදී Service Discovery, Configuration Management සහ Health Checking වගේ දේවල් simplify කරන්න පුළුවන් අතිශය බලවත් Tool එකක්. Spring Boot Developers ලා විදිහට අපිට Spring Cloud Consul Project එක භාවිතා කරලා ඉතා පහසුවෙන් අපේ Application Consul එක්ක integrate කරගන්න පුළුවන්.

මේ Tutorial එකෙන් ඔයාට Consul යනු කුමක්ද, Spring Boot සමඟ Consul ඒකාබද්ධ කරන්නේ කෙසේද සහ Service Registration හා Configuration Management කරන්නේ කෙසේද යන්න ගැන හොඳ අවබෝධයක් ලැබෙන්න ඇති කියලා හිතනවා. මතක තියාගන්න, Production Environment එකකදී Consul Setup කරනකොට Security, High Availability වගේ දේවල් ගැනත් සැලකිලිමත් වෙන්න ඕනේ.

දැන් ඔයාගේ ඊළඟ Spring Boot Project එකේදී Consul භාවිතා කරලා බලන්න! ඔයාගේ අත්දැකීම් කොහොමද? ගැටලු ආවොත්, කමෙන්ට් සෙක්ෂන් එකේ අහන්න. අපි හැමෝටම උදව් කරගමු!