Spring Boot Chaos Engineering | Chaos Monkey | Resilience | Sinhala Guide

කොහොමද යාලුවනේ?

අද අපි කතා කරන්න යන්නේ ටිකක් වෙනස්, හැබැයි software ලෝකයේ ගොඩක් වැදගත් මාතෘකාවක් ගැන. ඒ තමයි Chaos Engineering! අද කාලේ applications හදනකොට, විශේෂයෙන්ම microservices architecture එකත් එක්ක වැඩ කරනකොට, අපේ system එක මොන වගේ situation එකකදී වුණත් stable විදිහට වැඩ කරනවාද කියලා දැනගන්න එක ගොඩක් වැදගත් නේද? System එකේ එක කොටසක් fail වුණොත්, අනිත් කොටස් වලට මොකද වෙන්නේ? මේ වගේ ප්‍රශ්න වලට උත්තර හොයාගන්න තමයි Chaos Engineering කියන concept එක අපිට උදව් කරන්නේ.

මේ tutorial එකෙන් අපි බලමු මොකක්ද මේ Chaos Engineering කියන්නේ කියලා. ඊට පස්සේ, අපි Spring Boot applications එක්ක Chaos Monkey කියන ජනප්‍රිය tool එක පාවිච්චි කරලා අපේ apps වල resilience එක (ඕනෑම තත්වයකට ඔරොත්තු දීමේ හැකියාව) කොහොමද test කරන්නේ කියලා practical විදිහට ඉගෙන ගමු. ඔබේ Spring Boot project එකට Chaos Monkey එකතු කරලා, ඔබේ app එක failure වලට කොච්චර හොඳට මුහුණ දෙනවාද කියලා බලන්න මේක හොඳ අවස්ථාවක්!

1. Chaos Engineering කියන්නේ මොකක්ද?

සරලව කිව්වොත්, Chaos Engineering කියන්නේ අපේ system එකේ vulnerabilities (දුර්වලතා) හොයාගන්න හිතාමතාම failures (අසාර්ථකවීම්) ඇති කරන එක. මේක හරියට vaccine එකක් වගේ. අපි පොඩි failures system එකට introduce කරලා, system එක ඒවට කොහොමද respond කරන්නේ කියලා බලනවා.

• ඇයි මේක වැදගත්? අපි හැමෝම දන්නවා, distributed systems වල failures කියන්නේ නොවැළැක්විය හැකි දෙයක්. Network එකේ අවුලක් වෙන්න පුළුවන්, database එක slow වෙන්න පුළුවන්, server එකක් crash වෙන්න පුළුවන්. මේ වගේ දේවල් ඇත්තටම වෙනකන් ඉන්නේ නැතුව, අපි proactive විදිහට මේ වගේ scenario simulate කරනවා.
• Netflix ගේ දායකත්වය: මේ concept එක ජනප්‍රිය කළේ Netflix ආයතනය විසින්. ඔවුන්ගේ production system එකේ resilience එක වැඩි කරන්න එයාලා Chaos Monkey කියන tool එක හඳුන්වා දුන්නා. ඒක ඔවුන්ගේ servers random විදිහට shutdown කළා. මේකෙන් ඔවුන්ට පුළුවන් වුණා system එකේ අඩුපාඩු කලින්ම හොයාගෙන ඒවා හදන්න.
• මූලික අරමුණු:
  • System එකේ දුර්වලතා හඳුනා ගැනීම.
  • Application එකේ resilience එක වැඩි දියුණු කිරීම.
  • සැබෑ production environment එකේදී ඇතිවිය හැකි ගැටළු කලින්ම වළක්වා ගැනීම.
  • Team එකේ විශ්වාසය (confidence) වැඩි කිරීම - අපේ system එක මොන වගේ තත්වයකදී වුණත් හොඳට වැඩ කරනවා කියලා.

Chaos Engineering කියන්නේ simply failures ඇති කරලා බලන එකට වඩා වැඩි දෙයක්. මේක scientific method එකකට කරන දෙයක්.

1. Hypothesize (උපකල්පනයක් ඉදිරිපත් කිරීම): "අපේ database එක slow වුණොත්, user logins වලට බලපෑමක් වෙන්නේ නැහැ."
2. Experiment (පරීක්ෂණයක් සිදු කිරීම): හිතාමතාම database එකට latency එකක් (ප්‍රමාදයක්) introduce කිරීම.
3. Verify (තහවුරු කිරීම): අපේ උපකල්පනය හරිද වැරදිද කියලා බලන එක. අපේ උපකල්පනය වැරදි නම්, අපි system එකේ අදාළ කොටස වැඩි දියුණු කරනවා.

2. Chaos Monkey සහ Spring Boot

Netflix ගේ original Chaos Monkey එක Java Virtual Machine (JVM) එකක් හෝ server එකක් kill කරන්න තමයි නිර්මාණය කළේ. නමුත් Chaos Monkey for Spring Boot කියන්නේ Spring Boot applications වලටම විශේෂයෙන් හදපු tool එකක්. මේකෙන් අපිට පුළුවන් Spring Boot application එක ඇතුලතින්ම failures introduce කරන්න.

මේක Spring Boot starter dependency එකක් විදිහට අපේ project එකට එකතු කරන්න පුළුවන්. එතකොට අපිට පුළුවන් කිසිම සංකීර්ණ setup එකක් නැතුවම Chaos Engineering experiments කරන්න.

Chaos Monkey for Spring Boot එකට පුළුවන් මේ වගේ විවිධ "අටෑක්ස්" (attacks) කරන්න:

• Latency Assaults: Method call එකකට හෝ REST endpoint එකකට අමතර ප්‍රමාදයක් (delay) එකතු කිරීම. (උදා: "මේ API call එකට තත්පර 2ක් delay කරනවා.")
• Exception Assaults: Method call එකකදී random විදිහට exception එකක් (error එකක්) throw කිරීම. (උදා: "Database error එකක් simulate කරනවා.")
• KillApp Assaults: Application එක සම්පූර්ණයෙන්ම shutdown කිරීම (JVM එක kill කිරීම). මේක Production environment වලදී ගොඩක් කල්පනාවෙන් පාවිච්චි කරන්න ඕන දෙයක්.
• Memory Assaults: Application එකේ memory එක වැඩි කිරීමෙන් OutOfMemoryError එකක් simulate කිරීම.
• Disc Space Assaults: Hard drive එකේ ඉඩ අඩුවීම simulate කිරීම.

මේ attacks එකක් හෝ කීපයක් එකවර activate කරන්න පුළුවන්. ඒ වගේම, මේ attacks apply වෙන්නේ කොයි වගේ methods වලටද (controllers, services, repositories) කියලා අපිට specify කරන්නත් පුළුවන්.

Spring Boot Project එකකට Chaos Monkey එකතු කරමු

මුලින්ම, අපි ඉතාම සරල Spring Boot project එකක් හදමු. මේකට අපි Spring Initializr (start.spring.io) පාවිච්චි කරනවා.

• Dependencies: Spring Web, Spring Boot Actuator (මේක monitoring වලට වැදගත්)

දැන්, අපේ pom.xml (Maven පාවිච්චි කරනවා නම්) හෝ build.gradle (Gradle පාවිච්චි කරනවා නම්) එකට Chaos Monkey dependency එක එකතු කරන්න ඕනේ. මෙතනදී අපි Maven පාවිච්චි කරනවා කියලා හිතමු.

ඔබේ pom.xml එකේ <dependencies> section එකට පහත dependency එක එකතු කරන්න:

<dependency>
    <groupId>de.codecentric</groupId>
    <artifactId>chaos-monkey-spring-boot</artifactId>
    <version>2.5.2</version> <!-- Latest stable version එක පාවිච්චි කරන්න -->
</dependency>

සැලකිය යුතුයි: <version> එක සඳහා සැමවිටම නවතම stable version එක භාවිතා කරන්න. ඔබට Maven Central repository එකෙන් නවතම version එක සොයාගත හැක.

3. Chaos Monkey Configure කරමු!

Dependency එක එකතු කළාට පස්සේ, අපිට පුළුවන් අපේ application.properties හෝ application.yml file එකේ Chaos Monkey configuration කරන්න. අපි application.yml එක පාවිච්චි කරමු. මේකෙන් අපිට Chaos Monkey activate කරලා, විවිධ attacks configure කරන්න පුළුවන්.

මූලික Configuration (application.yml)

chaos:
  monkey:
    enabled: true # Chaos Monkey activate කරන්න. (production වලදී false කරන්න)
    assaults:
      level: 5 # 5% ක requests ප්‍රමාණයකට attack එකක් apply කරන්න. 1-100 අතර අගයක්.
      latency-active: true # Latency assaults activate කරන්න
      latency-range-start: 100 # Minimum latency (milliseconds)
      latency-range-end: 1000 # Maximum latency (milliseconds)
      exceptions-active: true # Exception assaults activate කරන්න
      killapp-active: false # Application එක kill කිරීමේ assault එක deactivate කරන්න (ගොඩක් කල්පනාකාරී වෙන්න!)
      memory-active: false # Memory assaults deactivate කරන්න
      disc-space-active: false # Disk space assaults deactivate කරන්න
    watcher:
      controller: true # @RestController methods වලට attacks apply කරන්න
      rest-controller: true # @RestController methods වලට attacks apply කරන්න (alternative)
      service: false # @Service methods වලට attacks apply කරන්න
      repository: false # @Repository methods වලට attacks apply කරන්න
      component: false # @Component methods වලට attacks apply කරන්න

Configuration විස්තර කිරීම:

• chaos.monkey.enabled: true: මේකෙන් Chaos Monkey activate කරනවා. ඔබ production environment එකකදී මේක false කරන්න ඕනේ, නැත්නම් ඔබගේ application එකේ හිතාමතාම failures ඇතිවෙන්න පුළුවන්.
• chaos.monkey.assaults.level: 5: මේක තමයි Chaos Monkey ගේ "శක්තිය" (strength) හෝ "impact level" එක. 1-100 අතර අගයක්. 5 කියන්නේ, ආසන්න වශයෙන් 5% ක requests ප්‍රමාණයකට attack එකක් apply වෙනවා කියන එක. මේක වැඩි කරන තරමට, attack වෙන requests ප්‍රමාණය වැඩි වෙනවා.
• chaos.monkey.assaults.latency-active: true: මේකෙන් latency assaults activate කරනවා. එතකොට, යම් requests ප්‍රමාණයකට (level එක අනුව) අපි දීපු range එක ඇතුලේ random delay එකක් එකතු වෙනවා.
• chaos.monkey.assaults.latency-range-start සහ latency-range-end: මේවා තමයි latency assault එකේ delay එකේ minimum සහ maximum values (milliseonds වලින්). උදාහරණයක් ලෙස, 100-1000ms කියන්නේ 100ms ත් 1000ms ත් අතර random delay එකක් ලැබෙනවා කියන එක.
• chaos.monkey.assaults.exceptions-active: true: මේකෙන් exception assaults activate කරනවා. මේක activate කරාම, යම් requests ප්‍රමාණයකට (level එක අනුව) random විදිහට ChaosMonkeyException එකක් throw වෙනවා. ඔබේ code එක මේ exceptions handle කරන්නේ කොහොමද කියලා බලන්න මේක හොඳ ක්‍රමයක්.
• chaos.monkey.assaults.killapp-active: false: මේක තමයි වඩාත්ම භයානක assault එක. මේක true කළොත්, Chaos Monkey එක application එක completely shutdown කරනවා. Development හෝ testing environment වලදී විතරක් මේක පාවිච්චි කරන්න.
• chaos.monkey.watcher.controller: true, rest-controller: true: මේවා තමයි Chaos Monkey attacks apply විය යුතු Spring beans specify කරන්නේ. controller: true කියන්නේ @Controller annotated classes වලටත්, rest-controller: true කියන්නේ @RestController annotated classes වලටත් attacks apply වෙනවා කියන එක. ඔබට අවශ්‍ය නම් service, repository, component වැනි දේවලටත් attacks apply කරන්න පුළුවන්.

ඔබට පුළුවන් මේ settings ඔබේ අවශ්‍යතාවයට අනුව modify කරන්න. උදාහරණයක් ලෙස, මුලින්ම level එක අඩු කරලා පටන් ගන්න. ඊට පස්සේ ක්‍රමයෙන් වැඩි කරන්න. ඒ වගේම, එක් වරකට එක assault එකක් විතරක් activate කරලා test කරන්න පුළුවන්. ඒකෙන් attack එකේ බලපෑම හොඳින් තේරුම් ගන්න පුළුවන්.

4. Resilience එක Test කරමු

දැන් අපි Chaos Monkey configure කරලා තියෙන නිසා, අපිට පුළුවන් අපේ application එකේ resilience එක test කරන්න. මේ සඳහා අපි සරල Spring Boot REST Controller එකක් හදාගමු.

සරල REST Controller එකක්

HelloController.java වගේ file එකක් හදාගෙන මේ code එක එකතු කරන්න:

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class HelloController {

    @GetMapping("/hello")
    public String hello() {
        System.out.println("Hello endpoint called.");
        return "Hello from Spring Boot!";
    }

    @GetMapping("/data")
    public String getData() {
        System.out.println("Data endpoint called.");
        // මෙතනදී අපි සාමාන්‍යයෙන් database එකකට access කරනවා හෝ වෙන service එකක් call කරනවා.
        // Chaos Monkey assaults මේ වගේ methods වලට තමයි apply වෙන්නේ.
        return "Some important data fetched from a 'service'.";
    }

    @GetMapping("/safe")
    public String getSafeData() {
        // මේ method එකට Chaos Monkey assault apply වෙන්න ඕනෙ නැත්නම්, අපි @ChaosMonkeyKiller වගේ annotation එකක් පාවිච්චි කරන්න පුළුවන්.
        // නමුත්, watcher configuration එක හොඳටම ඇති මේ වගේ දේවල් control කරන්න.
        return "This is a safe endpoint, not targeted by Chaos Monkey (usually).";
    }
}

Application එක Run කරලා Test කරමු

දැන් ඔබගේ Spring Boot application එක start කරන්න. ඒක සාමාන්‍ය විදිහටම start වෙයි. (console එකේ "Chaos Monkey is ready to rumble!" කියලා message එකක් පෙනෙන්න ඕනේ).

දැන් web browser එකක් හෝ Postman/curl වැනි tool එකක් පාවිච්චි කරලා http://localhost:8080/hello හෝ http://localhost:8080/data වගේ endpoints වලට request කීපයක් යවන්න.

• /hello හෝ /data endpoints වලට requests යවනකොට, සමහර වෙලාවට ඔබට අසාමාන්‍ය ලෙස delay එකක් (latency) පෙනෙන්න පුළුවන්.
• ඒ වගේම, සමහර වෙලාවට "Internal Server Error" එකක් (HTTP 500) ලැබිලා, log එකේ ChaosMonkeyException එකක් පෙනෙන්න පුළුවන්.
• මේක වෙන්නේ අපි level: 5 දීලා තියෙන නිසා, 5% ක requests ප්‍රමාණයකට මේ assaults apply වෙන නිසයි.

මේ results නිරීක්ෂණය කරන එක ගොඩක් වැදගත්.

• Latency Assaults: ඔබේ application එකේ UI එක (if any) වැඩිපුර delay එකක් ආවොත් කොහොමද behave කරන්නේ? User experience එකට බලපානවද? timeouts handle කරනවද?
• Exception Assaults: ඔබේ application එක exceptions handle කරන්නේ කොහොමද? Global error handlers තියෙනවද? Proper error messages return කරනවද? Logs වලට errors report වෙනවද?

ඊළඟ පියවර: Resilience වැඩි දියුණු කිරීම

Chaos Monkey පාවිච්චි කරලා ඔබ system එකේ දුර්වලතා හොයාගත්තට පස්සේ, ඊළඟට කළ යුත්තේ ඒ දුර්වලතා හදලා system එකේ resilience එක වැඩි දියුණු කරන එකයි.

උදාහරණයක් ලෙස:

• Timeouts සහ Retries: External service call කරනකොට timeouts සහ retry mechanisms implement කරන්න.
• Circuit Breaker Pattern: Microservices වලදී ගොඩක් වැදගත් pattern එකක් තමයි Circuit Breaker එක. එක් service එකක් fail වෙනකොට අනිත් services වලටත් ඒක බලපාන්නේ නැතිව ඉන්න මේක උදව් වෙනවා. Resilience4j වගේ libraries මේකට පාවිච්චි කරන්න පුළුවන්.
• Fallback Mechanisms: යම් operation එකක් fail වුණොත්, default response එකක් හෝ alternative logic එකක් සපයන එක.
• Load Balancers සහ Replicas: Multiple instances run කරලා, load balancer එකක් පාවිච්චි කිරීමෙන් එක් instance එකක් fail වුණොත් අනිත් ඒවාට request යොමු කරන්න පුළුවන්.

මේ වගේ දේවල් implement කරලා, ආයෙත් Chaos Monkey පාවිච්චි කරලා test කරන්න. මේක continuous process එකක්.

නිගමනය

ඉතින් යාලුවනේ, Chaos Engineering කියන්නේ අපේ applications වල robustness (ශක්තිමත් බව) සහ resilience එක වැඩි කරගන්න පුදුම විදිහට උදව් වෙන ක්‍රමයක්. Chaos Monkey වගේ tools වලින් Spring Boot applications වලට මේක add කරන එක හරිම ලේසියි. මේකෙන් අපිට පුළුවන් production environment එකේදී සැබෑ ගැටළු ඇතිවෙන්න කලින්ම ඒවා හඳුනාගෙන, නිවැරදි කිරීම් කරන්න.

අදම ඔයාලගේ Spring Boot project එකකට මේක එකතු කරලා බලන්න. මොන වගේ results ද ඔයාලට ලැබෙන්නේ කියලා කමෙන්ට් සෙක්ෂන් එකේ කියන්නත් අමතක කරන්න එපා! මතක තියාගන්න, හොඳ software engineer කෙනෙක් කියන්නේ failures වලට බය නැති, ඒවායින් ඉගෙනගෙන system එක වැඩි දියුණු කරන කෙනෙක්. Chaos Engineering මේ ගමනට හොඳම යාළුවෙක්!

මීළඟ tutorial එකකින් හමුවෙමු!