Sign in Subscribe
By Thisara Priyamal —

Spring Boot ELK Stack Integration | ලොග් කළමනාකරණය | Sinhala Guide

Spring Boot ELK Stack Integration | ලොග් කළමනාකරණය | Sinhala Guide

ආයුබෝවන් යාළුවනේ, Spring Boot එක්ක ELK Stack එකේ වැඩ ගැන කතා කරමු!

ආයුබෝවන් යාළුවනේ! අද අපි කතා කරන්න යන්නේ ඔයාලගේ Spring Boot applications වල logs ටික ලේසියෙන්ම, smart විදියට manage කරගන්න පුළුවන් සුපිරි combo එකක් ගැන. ඒ තමයි ELK Stack එක! විශේෂයෙන්ම විශාල applications develop කරනකොට, logs management කියන්නේ හරිම අමාරු වැඩක්. එක තැනක logs file එකක් බල බල ඉන්න එක හරිම අපහසුයි නේද? ඒත් ELK Stack එකත් එක්ක ඒක ගොඩක් ලේසි වෙනවා. අද අපි Spring Boot application එකකින් logs, ELK Stack එකට යවලා, ඒ logs monitor කරන්නේ කොහොමද කියලා පියවරෙන් පියවර බලමු.

ඉතින්, අපි පටන් ගමු නේද!

ELK Stack කියන්නේ මොකක්ද? (What is ELK Stack?)

ELK Stack කියන්නේ Elasticsearch, Logstash, සහ Kibana කියන Open-Source Tools තුන එකට එකතු වෙලා හදන Stack එකකට. මේ තුනම Elastic සමාගමෙන් හදපු ඒවා. මේවා එකට පාවිච්චි කරලා data, විශේෂයෙන්ම logs, collect කරන්න, process කරන්න, store කරන්න, analyse කරන්න, සහ visualize කරන්න පුළුවන්.

  • Elasticsearch: මේක තමයි Distributed, RESTful Search සහ Analytics Engine එක. අපේ logs වගේ unstructured data ලේසියෙන් store කරලා, search කරන්න පුළුවන් තැන. හිතන්නකෝ, Google Search Engine එක වගේ, හැබැයි අපේ data වලට.
  • Logstash: මේක Data Processing Pipeline එක. විවිධ sources වලින් (අපේ Spring Boot app එක වගේ) data අරගෙන, transform කරලා, Elasticsearch වගේ තැනකට යවන එක මේකෙන් කරන්නේ. Data එකතු කරලා, purify කරන filtering process එක මේකෙන් සිදුවෙනවා.
  • Kibana: මේක Visualization Layer එක. Elasticsearch එකේ තියෙන data ලස්සන Graphs, Charts, Dashboards විදියට බලන්න මේක පාවිච්චි කරනවා. Logs analyze කරලා, trends බලන්න, errors හොයාගන්න මේක හරිම පහසුයි.

ඇයි අපිට ELK Stack එකක් ඕනේ? (Why do we need an ELK Stack?)

Spring Boot application එකක් develop කරනකොට, logs කියන්නේ හරිම වැදගත් දෙයක්. Errors, Warnings, Info messages වගේ දේවල් වලින් application එකේ behaviour එක තේරුම් ගන්න පුළුවන්. ඒත් සාමාන්‍යයෙන් logs application server එකේ local file system එකට තමයි save වෙන්නේ. විශාල microservices architecture එකකදී application instances ගොඩක් run වෙනකොට, ඒ හැම එකේම logs වෙන වෙනම බලන එක හරිම අමාරුයි, කාලය නාස්ති වෙන වැඩක්.

අන්න ඒ වගේ වෙලාවකදී තමයි ELK Stack එකේ වටිනාකම තේරෙන්නේ:

  • Centralized Logging: ඔයාලගේ හැම Spring Boot application එකකින්ම එන logs එක තැනකට (Elasticsearch) ගබඩා කරන්න පුළුවන්.
  • Real-time Analysis: Logs එන ගමන්ම analyse කරන්න පුළුවන්. මොකද, Kibana එකෙන් එන logs real-time display කරන නිසා.
  • Troubleshooting Made Easy: Error එකක් ආවම, හැම server එකක්ම check නොකර, එකම තැනකින් search කරලා, issue එක ඉක්මනින්ම හොයාගන්න පුළුවන්.
  • Performance Monitoring: Application එකේ performance metrics වගේ දේවලුත් logs එක්ක send කරලා, Kibana එකෙන් visualise කරලා බලන්න පුළුවන්.

ELK Stack එක Setup කරමු (Setting up the ELK Stack)

ELK Stack එක Setup කරන්න ලේසිම ක්‍රමය තමයි Docker පාවිච්චි කරන එක. අපි මෙතනදී docker-compose එකක් පාවිච්චි කරමු. මේ docker-compose.yml file එක හදලා, project folder එකේ තියන්න:

version: '7.8'
services:
  elasticsearch:
    image: docker.elastic.co/elasticsearch/elasticsearch:7.17.0
    container_name: elasticsearch
    ports:
      - "9200:9200"
      - "9300:9300"
    environment:
      - xpack.security.enabled=false
      - discovery.type=single-node
    volumes:
      - elasticsearch-data:/usr/share/elasticsearch/data

  logstash:
    image: docker.elastic.co/logstash/logstash:7.17.0
    container_name: logstash
    ports:
      - "5000:5000"
      - "9600:9600"
    volumes:
      - ./logstash/logstash.conf:/usr/share/logstash/pipeline/logstash.conf
    depends_on:
      - elasticsearch

  kibana:
    image: docker.elastic.co/kibana/kibana:7.17.0
    container_name: kibana
    ports:
      - "5601:5601"
    depends_on:
      - elasticsearch

volumes:
  elasticsearch-data:

මේ docker-compose.yml file එක create කරපු තැනම logstash කියලා folder එකක් හදලා, ඒක ඇතුළේ logstash.conf කියලා file එකක් හදන්න. මේක තමයි අපේ Logstash configuration file එක. ඒක අපි ඊළඟට බලමු.

දැන් terminal එක open කරලා, මේ docker-compose.yml file එක තියෙන directory එකට ගිහින් පහත command එක run කරන්න:

docker-compose up -d

ටික වෙලාවකින් ELK Stack එකේ services ටික up වෙයි. දැන් ඔයාට Kibana එක http://localhost:5601 URL එකෙන් access කරන්න පුළුවන්.

Logstash Configure කරමු (Configuring Logstash)

Logstash තමයි අපේ Spring Boot application එකෙන් එන logs receive කරලා, Elasticsearch එකට යවන්නේ. ඒකට අපි logstash/logstash.conf file එක මේ විදියට හදමු:

input {
  beats {
    port => 5000
  }
}

filter {
  # Optionally, you can add filters here to process your logs.
  # For example, to parse JSON messages or add fields.
}

output {
  elasticsearch {
    hosts => ["elasticsearch:9200"]
    index => "spring-boot-logs-%{+YYYY.MM.dd}"
  }
  stdout {
    codec => rubydebug
  }
}

මෙතනදී:

  • input: beats plugin එකෙන් 5000 port එකෙන් logs receive කරනවා. Spring Boot application එක Logstash එකට logs යවන්නේ මේ port එක හරහා.
  • filter: මේක optional. logs modify කරන්න, parse කරන්න වගේ දේවලට පාවිච්චි කරන්න පුළුවන්.
  • output: logs elasticsearch service එකේ 9200 port එකට යවනවා. index එක spring-boot-logs- නමින් create වෙනවා, ඒ වගේම දින අනුව logs organize වෙනවා. stdout output එකෙන් Logstash console එකේ logs print වෙනවා.

Spring Boot Project එකක් Set Up කරමු (Setting up a Spring Boot Project)

දැන් අපි Spring Boot application එකක් හදලා, logs ELK Stack එකට යවන්න සූදානම් කරමු.

1. Project එකක් Create කරගමු

start.spring.io එකට ගිහින්, Java, Maven project එකක් generate කරගන්න. Dependencies විදියට Spring Web add කරගන්න.

2. Dependencies Add කරමු

pom.xml file එකට logstash-logback-encoder dependency එක add කරන්න. මේකෙන් තමයි Logback logs, Logstash format එකට encode කරලා Logstash server එකට යවන්නේ.

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

    <!-- Logstash Logback Encoder -->
    <dependency>
        <groupId>net.logstash.logback</groupId>
        <artifactId>logstash-logback-encoder</artifactId>
        <version>7.4</version> <!-- නවතම version එක බලන්න -->
    </dependency>

    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
    </dependency>
</dependencies>

3. Logback Configuration එක හදමු

src/main/resources folder එකේ logback-spring.xml කියලා file එකක් හදලා, පහත configuration එක add කරන්න.

<?xml version="1.0" encoding="UTF-8"?>
<configuration>

    <!-- Spring Boot's default logging configuration -->
    <include resource="org/springframework/boot/logging/logback/base.xml"/>

    <!-- Logstash Appender Configuration -->
    <appender name="LOGSTASH" class="net.logstash.logback.appender.LogstashTcpSocketAppender">
        <!-- Logstash server address and port -->
        <destination>localhost:5000</destination>
        
        <!-- Encoder to format logs as JSON for Logstash -->
        <encoder class="net.logstash.logback.encoder.LogstashEncoder">
            <!-- Spring Boot application name, useful for filtering in Kibana -->
            <customFields>{"app_name":"my-spring-boot-app"}</customFields>
        </encoder>
    </appender>

    <!-- Root logger to send INFO level logs to CONSOLE and LOGSTASH -->
    <root level="INFO">
        <appender-ref ref="CONSOLE"/>
        <appender-ref ref="LOGSTASH"/>
    </root>

    <!-- Specific logger for debugging (optional) -->
    <logger name="org.springframework" level="INFO"/>
    <logger name="com.example.springelk" level="DEBUG"/> <!-- ඔබේ package එකට අනුව වෙනස් කරන්න -->

</configuration>

මේ logback-spring.xml එකේ <destination>localhost:5000</destination> කියන තැන, ඔයාලගේ Logstash server එකේ IP address එකයි port එකයි දෙන්න ඕනේ. අපි Docker පාවිච්චි කරන නිසා localhost:5000 කියලා දුන්නා.

4. Sample Controller එකක් හදමු

දැන් අපි simple REST Controller එකක් හදලා, ඒකෙන් logs ටිකක් generate කරලා බලමු.

package com.example.springelk.controller;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class HelloController {

    private static final Logger logger = LoggerFactory.getLogger(HelloController.class);

    @GetMapping("/hello")
    public String hello() {
        logger.info("Hello endpoint called. This is an INFO message.");
        logger.debug("Debug message from hello endpoint.");
        
        // Simulate an error
        try {
            int i = 1 / 0; 
        } catch (Exception e) {
            logger.error("An error occurred in hello endpoint: {}", e.getMessage(), e);
        }
        
        return "Hello, ELK Stack!";
    }

    @GetMapping("/info")
    public String info() {
        logger.info("Info endpoint called. All good here!");
        return "Info endpoint logs generated!";
    }
}

දැන් ඔයාලගේ Spring Boot application එක run කරන්න. (mvn spring-boot:run or from your IDE).

Application එක run වුණාට පස්සේ, browser එකේ http://localhost:8080/hello සහ http://localhost:8080/info වගේ URLs ටික access කරන්න. එතකොට logs generate වෙනවා. මේ logs ටික දැන් Logstash හරහා Elasticsearch එකට යනවා.

Kibana එකෙන් Logs බලමු (Viewing Logs in Kibana)

දැන් Kibana එකට ගිහින් අපේ logs බලමු. Browser එකේ http://localhost:5601 URL එකට යන්න.

  1. Kibana dashboard එකේදී, වම් පැත්තේ තියෙන navigation menu එකෙන් "Stack Management" වලට යන්න.
  2. ඒක ඇතුළේ "Index Patterns" යටතේ "Create index pattern" කියන එක click කරන්න.
  3. "Index pattern name" කියන තැන spring-boot-logs-* කියලා type කරන්න. (අපි Logstash output එකේදී දීපු index format එකට ගැලපෙන විදියට) ඊට පස්සේ "Next step" click කරන්න.
  4. "Time field" එක විදියට @timestamp තෝරලා "Create index pattern" click කරන්න.
  5. දැන් ආපහු වම් පැත්තේ navigation menu එකෙන් "Analytics" යටතේ "Discover" වලට යන්න.

දැන් ඔයාට ඔයාලගේ Spring Boot application එකෙන් ආපු හැම log entry එකක්ම Kibana එකේ පේනවා ඇති! ඔයාට උඩ තියෙන search bar එක පාවිච්චි කරලා logs filter කරන්න පුළුවන්. උදාහරණයක් විදියට, level:ERROR කියලා search කරලා errors විතරක් බලන්න පුළුවන්. app_name:my-spring-boot-app කියලා search කරලා ඔයාගේ application එකේ logs විතරක් filter කරන්නත් පුළුවන්.

පහත රූප සටහන බලන්න, මේ වගේ දෙයක් තමයි Kibana Discover tab එකේදී ඔයාට පෙනෙන්නේ.

Kibana Discover Tab Example

(සටහන: මෙය පොදු උදාහරණ රූපයක් වන අතර, ඔබේ ලොග් මත පදනම්ව පෙනුම වෙනස් විය හැක.)

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

ඉතින් යාළුවනේ, මේක තමයි Spring Boot applications වල logs, ELK Stack එකත් එක්ක manage කරන විදිය. මේකෙන් ඔයාලගේ development process එකට ලොකු පහසුවක් ලැබෙනවා වගේම, production වලදී logs analyse කරන එකත් හරිම ලේසි වෙනවා. Centralized logging, real-time analysis, සහ powerful visualizations නිසා ඔයාලට ඔයාලගේ applications වල behaviour එක ගොඩක් හොඳින් තේරුම් ගන්න පුළුවන් වෙනවා.

මේ ගැන ඔයාලගේ අත්දැකීම් මොනවද? පහළින් comment එකක් දාලා කියන්න! ඊළඟ project එකට මේක apply කරලා බලන්න, ඔයාලට ලොකු වෙනසක් දැනේවි!

Previous

Django Authentication (පරිශීලක කළමනාකරණය) - Complete Sinhala Guide

 Next

AWS SageMaker MLOps සිංහලෙන් | Pipelines, CI/CD, Model Monitoring