By Thisara Priyamal in Spring Boot — 24 Aug 2025

Spring Boot Kubernetes Deployment Helm Operators | Sinhala Tutorial

අද කාලේ Software Development ක්ෂේත්‍රයේ වැඩ කරන කෙනෙක්ට, Cloud-Native Applications කියන concept එක අලුත් දෙයක් නෙවෙයි. Microservices, containerization, scalability වගේ දේවල් ගැන නොදන්න Developer කෙනෙක් හොයාගන්න අමාරුයි. මේ Cloud-Native ලෝකයේදී, Spring Boot සහ Kubernetes කියන්නේ අනිවාර්යයෙන්ම එකට යන combination එකක්. Spring Boot වලින් production-ready Microservices හදන එක පහසු කරනකොට, Kubernetes ඒ applications manage කරන්න අවශ්‍ය infrastructure orchestration එක සපයනවා.

හැබැයි, Kubernetes වලට application එකක් deploy කරන එක, විශේෂයෙන්ම complex Microservices architecture එකකදී, ටිකක් අභියෝගාත්මක වෙන්න පුළුවන්. ඒකට තමයි Helm Charts සහ Kubernetes Operators වගේ tools එන්නේ. මේවා අපේ deployment process එක simplify කරලා, automation වැඩි කරනවා. මේ tutorial එකෙන්, අපි බලමු Spring Boot applications Kubernetes වලට deploy කරන්න Helm Charts කොහොමද use කරන්නේ කියලා, ඒ වගේම Kubernetes Operators වලින් ලැබෙන advanced capabilities මොනවද කියලත්.

මේ ගමනට සූදානම්ද? එහෙනම් අපි පටන් ගමු!

1. Kubernetes වලට Spring Boot App එකක්? ඇයි මේ combination එක?

පළමුවෙන්ම බලමු Spring Boot application එකක් Kubernetes cluster එකක් මත run කිරීමේ වාසි මොනවද කියලා. මේ දෙක එකට ගැලපෙන්නේ ඇයි?

Scalability: Spring Boot apps scale කරන්න හරිම පහසුයි. ඒ වගේම Kubernetes වල තියෙන built-in auto-scaling capabilities (Horizontal Pod Autoscaler, Vertical Pod Autoscaler) නිසා, workload එක වැඩි වෙනකොට app එකේ instances auto-matically වැඩි කරන්න පුළුවන්.
Resilience and High Availability: Kubernetes මඟින් application instances fail වුණොත් ඒවා auto-matically restart කරනවා. ඒ වගේම health checks (Liveness and Readiness Probes) හරහා application එකේ තත්ත්වය නිරීක්ෂණය කරලා, අවුල් තියෙන Pods traffic වලින් අයින් කරන්න පුළුවන්. Spring Boot Actuator endpoints මේකට හොඳට ගැලපෙනවා.
Microservices Architecture: Spring Boot Microservices develop කරන්න හොඳම Framework එකක්. Kubernetes මේ Microservices deploy කරලා, manage කරන්න, service discovery කරන්න, load balance කරන්න අවශ්‍ය සියලු පහසුකම් සපයනවා.
Resource Efficiency: Kubernetes cluster එකක resource utilization එක optimize කරන්න පුළුවන්. Docker containers වලින් Spring Boot apps run කරනකොට, lightweight containers නිසා resources කාර්යක්ෂමව භාවිතා කරන්න පුළුවන්.
Consistent Environments: Docker Images සහ Kubernetes deployments නිසා, development, testing, staging, සහ production environments අතර consistency එකක් පවත්වාගන්න පුළුවන්. “It works on my machine” කියන ප්‍රශ්නයට විසඳුමක්.

මේ වාසි නිසා තමයි අද ගොඩක් companies Spring Boot applications Kubernetes මත deploy කරන්න කැමති.

2. Helm Charts: ඔබේ Applications සඳහා Package Manager

Kubernetes වලට application එකක් deploy කරනකොට, අපිට Deployment, Service, ConfigMap, Secret, Ingress වගේ Kubernetes resources ගොඩක් define කරන්න වෙනවා. මේ හැම එකටම YAML files ලියන්න ඕනේ. පොඩි application එකකට වුණත් මේක ලොකු වැඩක්. App එක update කරනකොට, version manage කරනකොට මේක තවත් සංකීර්ණ වෙනවා.

මෙන්න මෙතනදී තමයි Helm කියන tool එක අපේ උදව්වට එන්නේ. Helm කියන්නේ Kubernetes සඳහා package manager එකක්. Linux වල APT (Ubuntu/Debian) හෝ Yum (RedHat/CentOS) වගේම තමයි Helm වැඩ කරන්නේ. Helm මඟින් Kubernetes application එකක් deploy කරන්න අවශ්‍ය සියලුම resources එක Chart එකක් විදියට package කරන්න පුළුවන්.

Helm Chart එකක තියෙන ප්‍රධාන කොටස් මොනවද?

සාමාන්‍ය Helm Chart එකක් මේ වගේ structure එකකින් සමන්විත වෙනවා:

my-spring-app/
  Chart.yaml          # Chart එක පිළිබඳ විස්තර (name, version, etc.)
  values.yaml         # Default values (variables) for the templates
  charts/             # Sub-charts (dependencies)
  templates/          # Kubernetes resource templates (Deployment, Service, Ingress, etc.)
    deployment.yaml
    service.yaml
    _helpers.tpl      # Reusable templates

Chart.yaml: Chart එකේ නම, version එක, description එක වගේ මූලික තොරතුරු මෙහි සඳහන් වෙනවා.
values.yaml: මේක තමයි Chart එක deploy කරනකොට අපිට customize කරන්න පුළුවන් settings අඩංගු default values file එක. අපේ Docker Image name, port numbers, replica count වගේ දේවල් මෙහි define කරන්න පුළුවන්.
templates/: මේ folder එක ඇතුළේ තමයි අපේ Kubernetes resource definitions (Deployment, Service, ConfigMap, etc.) තියෙන්නේ. මේවා Go template language එකෙන් ලියලා තියෙන්නේ. values.yaml එකේ තියෙන variables මේ templates ඇතුළේ use කරන්න පුළුවන්.

Helm භාවිතයේ වාසි:

Simplified Deployments: සංකීර්ණ applications එක command එකකින් deploy කරන්න පුළුවන්.
Repeatability: එකම Chart එකකින් ඕනෑම Kubernetes cluster එකක application එක deploy කරන්න පුළුවන්, consistency එකක් පවත්වාගන්නවා.
Versioning and Rollbacks: Chart versions manage කරන්නත්, වැරදි deployment එකක් වුණොත් කලින් version එකකට rollback කරන්නත් පුළුවන්.
Customization: values.yaml file එක හරහා deployment එක customize කරන්න පුළුවන්.

3. ඔබේ Spring Boot App එක Helm Chart එකකින් Package කරමු

දැන් අපි බලමු Spring Boot application එකක් Helm Chart එකකින් deploy කරන්නේ කොහොමද කියලා. මේකට අපි පොඩි Spring Boot REST API එකක් use කරමු.

පියවර 1: සරල Spring Boot App එකක් හදමු

මුලින්ම අපි 'Hello World' වගේ සරල Spring Boot Web Application එකක් හදාගනිමු. Spring Initializr (start.spring.io) එකෙන් Web dependency එකත් එක්ක project එකක් generate කරගන්න. ඊට පස්සේ src/main/java/com/example/demo/DemoApplication.java file එක මේ විදියට modify කරන්න.

package com.example.demo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@SpringBootApplication
@RestController
public class DemoApplication {

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

    @GetMapping("/")
    public String hello() {
        return "Hello from Spring Boot on Kubernetes!";
    }
}

පියවර 2: Dockerfile එකක් හදමු

මේ Spring Boot App එක Docker Image එකක් විදියට build කරගන්න ඕනේ. Project root එකේ Dockerfile නමින් file එකක් හදලා මේ content එක paste කරන්න.

FROM eclipse-temurin:17-jdk-jammy
VOLUME /tmp
ARG JAR_FILE=target/*.jar
COPY ${JAR_FILE} app.jar
ENTRYPOINT ["java","-jar","/app.jar"]
EXPOSE 8080

මේ Dockerfile එකෙන් කියන්නේ Java 17 Temurin image එක base කරගෙන, අපේ Spring Boot JAR file එක container එකට copy කරලා, java -jar app.jar command එකෙන් app එක run කරන්න කියලා. Spring Boot app එක default port 8080 එකෙන් run වෙන නිසා, ඒ port එක expose කරනවා.

දැන් Project එක build කරලා Docker image එකක් හදමු. (ඔබේ Docker Hub Username එක your-dockerhub-username වෙනුවට දාන්න).

./mvnw package
docker build -t your-dockerhub-username/spring-boot-helm-demo:1.0.0 .
docker push your-dockerhub-username/spring-boot-helm-demo:1.0.0

පියවර 3: Helm Chart එකක් හදමු

Project root එකට ගිහින් මේ command එක run කරන්න. මේකෙන් my-spring-app කියන නමින් Helm Chart එකක් generate වෙනවා.

helm create my-spring-app

මේකෙන් default chart structure එකක් හැදෙනවා. අපිට දැන් මේක modify කරන්න ඕනේ අපේ Spring Boot app එකට ගැලපෙන්න.

පියවර 4: `values.yaml` modify කරමු

my-spring-app/values.yaml file එක open කරලා, අපේ Docker Image එකේ නම සහ tag එක update කරමු. (your-dockerhub-username වෙනුවට ඔබේ username එක දාන්න).

replicaCount: 1

image:
  repository: your-dockerhub-username/spring-boot-helm-demo
  pullPolicy: IfNotPresent
  # Overrides the image tag whose default is the chart appVersion.
  tag: "1.0.0" # අපේ Docker image tag එක

imagePullSecrets: []
nameOverride: ""
fullnameOverride: ""

serviceAccount:
  # ... (default values)

service:
  type: ClusterIP # අපි External access සඳහා LoadBalancer හෝ NodePort use කරන්න පුළුවන්
  port: 80 # External Port
  targetPort: 8080 # App එක run වෙන Port එක

ingress:
  enabled: false # අවශ්‍ය නම් True කරන්න
  # ... (default values)

resources:
  # We usually recommend not to specify default resources and to leave this as a conscious
  # choice for the user. This also increases chances charts will run on environments with little
  # resources, such as Minikube.
  limits:
    cpu: 500m
    memory: 512Mi
  requests:
    cpu: 200m
    memory: 256Mi

autoscaling:
  enabled: false
  minReplicas: 1
  maxReplicas: 100
  targetCPUUtilizationPercentage: 80
  # targetMemoryUtilizationPercentage: 80

nodeSelector: {}

tolerations: []

affinity: {}

livenessProbe:
  enabled: true
  path: /
  port: http
  initialDelaySeconds: 30
  periodSeconds: 10
  timeoutSeconds: 5
  failureThreshold: 6

readinessProbe:
  enabled: true
  path: /
  port: http
  initialDelaySeconds: 5
  periodSeconds: 10
  timeoutSeconds: 5
  failureThreshold: 3

මෙහිදී අපි:

image.repository සහ image.tag අපේ Docker image එකට අනුව update කළා.
service.port එක 80 (Kubernetes Service port) සහ service.targetPort එක 8080 (Spring Boot app එක run වෙන port එක) ලෙස සැකසුවා.
resources section එකේදී අපේ Pods වලට අවශ්‍ය CPU සහ Memory limits සහ requests define කළා.
Liveness Probe සහ Readiness Probe එකතු කළා. Spring Boot app එකේ / endpoint එක health check එකකට use කරන්න පුළුවන්. Production වලදී Spring Boot Actuator health endpoint (e.g., /actuator/health) use කරන එක වඩා හොඳයි.

පියවර 5: Templates modify කරමු (අවශ්‍ය නම්)

Helm generate කරන default templates (deployment.yaml, service.yaml) අපේ values.yaml එකේ changes වලට අනුව auto-matically adjust වෙනවා. නමුත්, ඔබට විශේෂිත අවශ්‍යතා තියෙනවා නම්, ඔබට my-spring-app/templates/deployment.yaml සහ my-spring-app/templates/service.yaml files modify කරන්න පුළුවන්.

උදාහරණයක් ලෙස, deployment.yaml එකේ image name එක මෙහෙම refer වෙනවා:

        image: "{{ .Values.image.repository }}:{{ .Values.image.tag | default .Chart.AppVersion }}"

Liveness/Readiness probes මෙහෙම add වෙලා තියෙන්න ඕනේ:

          livenessProbe:
            httpGet:
              path: {{ .Values.livenessProbe.path }}
              port: {{ .Values.livenessProbe.port }}
            initialDelaySeconds: {{ .Values.livenessProbe.initialDelaySeconds }}
            periodSeconds: {{ .Values.livenessProbe.periodSeconds }}
            timeoutSeconds: {{ .Values.livenessProbe.timeoutSeconds }}
            failureThreshold: {{ .Values.livenessProbe.failureThreshold }}
          readinessProbe:
            httpGet:
              path: {{ .Values.readinessProbe.path }}
              port: {{ .Values.readinessProbe.port }}
            initialDelaySeconds: {{ .Values.readinessProbe.initialDelaySeconds }}
            periodSeconds: {{ .Values.readinessProbe.periodSeconds }}
            timeoutSeconds: {{ .Values.readinessProbe.timeoutSeconds }}
            failureThreshold: {{ .Values.readinessProbe.failureThreshold }}

පියවර 6: Helm Chart එක Deploy කරමු

දැන් අපේ Helm Chart එක ready. අපි මේක Kubernetes cluster එකකට deploy කරමු. (ඔබේ K8s cluster එක up and running තියෙන්න ඕනේ, e.g., Minikube, Docker Desktop Kubernetes, or a cloud cluster).

helm install my-spring-app ./my-spring-app

මේ command එකෙන් my-spring-app කියන release name එකකින් අපේ Chart එක deploy කරනවා.

Deployment එකේ status එක බලන්න:

kubectl get pods
kubectl get service my-spring-app

service එක ClusterIP type එකෙන් තියෙන නිසා, cluster එක ඇතුලෙන් විතරයි access කරන්න පුළුවන්. External access කරන්න නම්, values.yaml එකේ service.type: LoadBalancer හෝ NodePort ලෙස වෙනස් කරන්න පුළුවන් (ඔබේ cluster environment එක අනුව).

පියවර 7: Update සහ Uninstall

ඔබ values.yaml එකේ හෝ templates වල changes කළා නම්, ඒවා deploy කරන්න helm upgrade command එක use කරන්න:

helm upgrade my-spring-app ./my-spring-app

Application එක uninstall කරන්න නම්:

helm uninstall my-spring-app

මේකෙන් අදාළ සියලුම Kubernetes resources delete වෙනවා.

4. Kubernetes Operators: K8s වලට AI/DevOps ගෙන ඒම

Helm Charts වලින් deployments simplify කළාට, application lifecycle එක manage කරන එක (upgrades, scaling, backups, recovery වගේ) තවමත් manual හෝ complex CI/CD pipelines වලින් කරන්න වෙනවා. මෙන්න මෙතනදී තමයි Kubernetes Operators කියන concept එක එන්නේ.

Operator එකක් කියන්නේ Kubernetes වලට application-specific knowledge add කරන extenders. මේවා software extensions වගේ. Application එකක් manage කරන්න අවශ්‍ය වන operational knowledge (e.g., database instance එකක් කොහොමද deploy කරන්නේ, backup කරන්නේ, scale කරන්නේ) මේ Operators ඇතුළේ code කරලා තියෙනවා.

Operator එකක් වැඩ කරන්නේ කොහොමද?

Operator එකක් ප්‍රධාන වශයෙන් කොටස් දෙකකින් සමන්විත වෙනවා:

Custom Resource Definitions (CRDs): මේවා Kubernetes API එක extend කරන්න use කරනවා. CRD එකක් මඟින් අපේ application එකට අදාළව අලුත් resource type එකක් (e.g., MySQLDatabase, KafkaCluster, SpringApp) define කරන්න පුළුවන්.
Controller: මේක තමයි Operator එකේ මොළය. Controller එකක් Kubernetes API එක නිරන්තරයෙන් නිරීක්ෂණය කරනවා. අලුත් CRD instance එකක් deploy කළාම හෝ existing instance එකක state එක වෙනස් වුණාම, Controller එක ඒක detect කරලා, අපේ application එකේ actual state එක, අපිට අවශ්‍ය state එක (desired state) එකට ගේන්න අවශ්‍ය actions ගන්නවා.

සරලව කිව්වොත්, අපි SpringApp කියන CRD එකක් හදලා, ඒකට my-spring-app කියලා instance එකක් deploy කළොත් (අපිට අවශ්‍ය Spring Boot app එකේ version එක, resources, configuration වගේ දේවල් එක්ක), Operator එකේ Controller එක ඒක detect කරලා, අවශ්‍ය Kubernetes Deployment, Service, ConfigMap වගේ resources auto-matically හදලා deploy කරනවා. Application එකේ health එක නිරීක්ෂණය කරනවා. අවශ්‍ය නම් auto-scale කරනවා. මේ හැමදේම automate කරනවා.

Kubernetes Operators වල වාසි:

Automated Operations: Deployments, upgrades, scaling, backups වගේ manual tasks automate කරනවා.
Reduced Operational Overhead: DevOps team එකට application-specific operations ගැන හිතන්නට අවශ්‍යතාවය අඩු කරනවා.
Application-Specific Intelligence: Application එකේ internal workings ගැන තියෙන දැනුම Kubernetes platform එකටම ගේනවා.
Consistency and Reliability: Operations consistent සහ reliable කරනවා.

Prometheus Operator, Kafka Operator, Strimzi Operator වගේ Operators අද ගොඩක් use වෙනවා. මේවායින් ඒ applications වල deployment සහ management process එක හරිම පහසු කරනවා.

5. Spring Boot සඳහා Operators: අනාගතය අද

Spring Boot applications සඳහා Operators කියන්නේ Cloud-Native ලෝකයේ ඊළඟ මට්ටම. දැනටත් Spring Cloud Kubernetes වගේ projects මඟින් Spring Boot applications Kubernetes cluster එකක් ඇතුළේ run කරන එක පහසු කරලා තියෙනවා. නමුත්, Operator එකක් මඟින් මේ ක්‍රියාවලිය තවත් දියුණු කරන්න පුළුවන්.

Spring Boot Operator එකකින් අපිට මොනවද කරන්න පුළුවන්?

අපි හිතමු Spring Boot Operator එකක් තියෙනවා කියලා. ඒකෙන් මේ වගේ දේවල් automate කරන්න පුළුවන්:

Smart Deployments: අපේ Spring Boot app එකේ JAR file එකක් හෝ Docker image එකක් දුන්නම, Operator එක auto-matically Kubernetes Deployment, Service, Ingress (අවශ්‍ය නම්) වගේ resources generate කරලා deploy කරනවා.
Configuration Management: Spring Boot application එකට අවශ්‍ය application.properties හෝ application.yaml files Kubernetes ConfigMaps වලට convert කරලා, app එක update වුණාම auto-matically reload කරන්න පුළුවන්. Spring Cloud Config Server එකක් manage කරන්නත් Operator එකකට පුළුවන්.
Advanced Health Checks & Monitoring: Spring Boot Actuator endpoints (/actuator/health, /actuator/metrics) use කරලා application එකේ සෞඛ්‍ය තත්වය ඉතා නිරවද්‍යව නිරීක්ෂණය කරන්නත්, ඒ අනුව auto-healing හෝ auto-scaling කරන්නත් පුළුවන්.
Intelligent Scaling: Application එකේ load එක අනුව (e.g., CPU, Memory, or custom metrics from Spring Boot Actuator) වඩාත් කාර්යක්ෂමව scale කරන්න පුළුවන්.
Database Provisioning: Spring Boot application එකට අවශ්‍ය database එකක් (e.g., PostgreSQL, MySQL) cluster එක ඇතුළේ හෝ external cloud provider එකක auto-matically provision කරලා, connection details app එකට inject කරන්න පුළුවන්.
Rolling Updates and Rollbacks: New versions deploy කරනකොට downtime නැතුව rolling updates කරන්නත්, ගැටලුවක් ආවොත් smooth rollbacks කරන්නත් පුළුවන්.

සරලව කිව්වොත්, Helm Chart එකකින් අපි Kubernetes වලට කොහොමද application එකක් deploy කරන්නේ කියලා templates කරනකොට, Operator එකකින් අපි Kubernetes වලට මොනවද deploy කරන්නේ කියලා (අපිට අවශ්‍ය අවසාන state එක) කියලා දීලා, ඒක කොහොමද කරන්නේ කියන එක Operator එකට බාර දෙනවා. මේක Declarative API සහ Control Loop pattern එකේ උපරිම ප්‍රයෝජන ගැනීමක්.

Spring Boot Operator එකක් develop කිරීම තරමක් සංකීර්ණ කාර්යයක් වුණත් (Go language සහ Operator SDK වගේ tools knowledge අවශ්‍යයි), එහි මූලික concept එක තේරුම් ගැනීම වැදගත්. මේවා භාවිතා කිරීමෙන් Cloud-Native applications manage කිරීමේදී ලැබෙන පහසුව අති විශාලයි.

නිගමනය

අපි මේ tutorial එකෙන් Spring Boot applications Kubernetes මත deploy කිරීමේ වැදගත්කම සහ ඒ සඳහා Helm Charts සහ Kubernetes Operators භාවිතා කරන ආකාරය ගැන සාකච්ඡා කළා. Helm Charts මඟින් අපේ deployments simplify කරනවා වගේම, Kubernetes Operators මඟින් application lifecycle management එක auto-mate කරලා, operational overhead එක අඩු කරනවා.

මේ Tools හරිහැටි භාවිතා කිරීමෙන්, ඔබට ඔබේ Spring Boot applications Cloud-Native පරිසරයක වඩාත් කාර්යක්ෂමව, විශ්වාසවන්තව, සහ ස්වයංක්‍රීයව deploy කරලා manage කරන්න පුළුවන්. මේක Cloud-Native Development වල අනාගතය වන අතර, මේ concept තේරුම් ගැනීම අද කාලේ ඕනෑම Software Engineer කෙනෙක්ට අත්‍යවශ්‍යයි.

ඔබත් අදම මේ Helm Charts සහ Operators අත්හදා බලන්න! ඔබේ Spring Boot App එකක් Helm Chart එකකින් deploy කරලා බලන්න. ඔබේ අත්දැකීම් කොමෙන්ට් කරන්න. මේ ගැන තවත් දැනගන්න ඕන දේවල් තියෙනවා නම් ඒවත් කියන්න!

සුභ Coding!

AWS AI/ML මූලිකාංග: Supervised, Unsupervised Learning | සිංහල Tutorial

Java CompletableFuture allOf() & anyOf() Sinhala Guide - Async Programming