Spring Boot Application Deployment on OpenShift | Sinhala Guide

ඉතින් කොහොමද යාලුවනේ! අද අපි කතා කරන්න යන්නේ මේ දවස් වල ගොඩක් trending මාතෘකාවක් ගැන. ඒ තමයි Spring Boot Application එකක් Red Hat OpenShift වලට deploy කරන්නේ කොහොමද කියන එක. මේක software development කරන අපිට අත්‍යවශ්‍ය knowledge එකක්. ඒ නිසා, කිසිම දෙයක් මග නොහැර අපි step-by-step මේක ඉගෙන ගනිමු!

අද වන විට Cloud Computing කියන්නේ IT industry එකේ අතිශය වැදගත් කොටසක් බවට පත්වෙලා. ඒ වගේම Containerization තාක්ෂණය (Docker වගේ) සහ Kubernetes (container orchestration) නිසා applications deploy කරන එක ගොඩක් පහසු වෙලා තියෙනවා. Red Hat OpenShift කියන්නේ Enterprise-grade Kubernetes platform එකක්, ඒ වගේම Spring Boot කියන්නේ Java applications ඉක්මනින් සහ පහසුවෙන් develop කරන්න පුළුවන් ප්‍රබල framework එකක්. මේ දෙක එකතු උනාම ලැබෙන වාසි නම් කියලා නිම කරන්න බැහැ.

මේ Tutorial එකෙන් අපි මොනවද ඉගෙන ගන්නේ?

• OpenShift සහ Spring Boot එකට භාවිතා කිරීමේ වැදගත්කම.
• සරල Spring Boot REST API Application එකක් හදන හැටි.
• OpenShift වලට deploy කරන්න Dockerfile එකක් හදාගන්න හැටි.
• oc CLI (OpenShift Command Line Interface) එක භාවිතයෙන් Application එක OpenShift වලට deploy කරන හැටි.
• Deploy කරපු Application එක test කරන හැටි.

අපි දැන් වැඩේට බහිමු නේද?

OpenShift සහ Spring Boot එකට භාවිතා කිරීමේ වැදගත්කම

අපි මුලින්ම බලමු ඇයි මේ දෙක මෙච්චර වැදගත් කියලා.

• Scalability: OpenShift වල Kubernetes engine එක නිසා ඔබේ Spring Boot Application එකට අවශ්‍ය විදිහට resources වැඩි කරන්න (scale up) හෝ අඩු කරන්න (scale down) පුළුවන්. Load එක වැඩි වෙනකොට automatically තවත් instances හදාගන්න පුළුවන්.
• Portability: Docker containers නිසා, ඔබේ Application එක ඔබේ local machine එකේදී වගේම OpenShift cluster එකකදීත් එකම විදිහට වැඩ කරනවා. "Works on my machine" ප්‍රශ්නයක් නැහැ!
• Developer Productivity: Spring Boot වල rapid development features නිසා ඉක්මනින් applications හදන්න පුළුවන්. OpenShift වල CI/CD (Continuous Integration/Continuous Delivery) pipelines සහ developer-friendly tools නිසා deploy කරන එකත් ගොඩක් පහසු වෙනවා.
• Resilience & High Availability: OpenShift මගින් Application එකේ failures manage කරනවා. උදාහරණයක් විදිහට, එක pod එකක් crash උනොත් අලුත් pod එකක් automatically create කරනවා.
• Security: OpenShift වල built-in security features ගොඩක් තියෙනවා. Role-Based Access Control (RBAC), network policies වගේ දේවල් නිසා ඔබේ Application එක ආරක්ෂිතව තියාගන්න පුළුවන්.

අවශ්‍ය දේවල් සූදානම් කරගනිමු (Prerequisites)

මේ tutorial එකට යන්න කලින් අපිට මේ ටික ඕනේ වෙනවා:

• Java Development Kit (JDK) 11+: Spring Boot applications develop කරන්න.
• Apache Maven or Gradle: Project build කරන්න.
• OpenShift Cluster Access: Red Hat OpenShift cluster එකකට access තියෙන්න ඕනේ (developer account එකක් හෝ local Minishift/CodeReady Containers setup එකක් වෙන්න පුළුවන්).
• OpenShift CLI (oc client): Command Line එකෙන් OpenShift එක්ක වැඩ කරන්න. මේක Red Hat website එකෙන් download කරගන්න පුළුවන්.
• Git: Source code manage කරන්න (optional, but good practice).

මේ ටික ඔක්කොම හරි නම්, අපි අපේ Application එක හදමු!

සරල Spring Boot REST API Application එකක් හදමු

මුලින්ම අපි සරල Spring Boot REST API එකක් හදමු. මේකට අපි Spring Initializr එක භාවිතා කරමු. පහත dependencies තෝරගන්න:

• Spring Web
• Spring Boot DevTools (optional, but useful for local development)

Project එක Generate කරලා download කරගන්න. ඊට පස්සේ ඔබේ favorite IDE එකෙන් (IntelliJ IDEA, VS Code වගේ) open කරගන්න.

src/main/java/com/example/openshift/springboot/HelloController.java වගේ file එකක් හදලා මේ code එක දාගන්න:

package com.example.openshift.springboot;

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

@RestController
public class HelloController {

    @GetMapping("/hello")
    public String sayHello() {
        return "Hello from Spring Boot on OpenShift! අම්මෝ ඒක!";
    }
}

දැන් project එක build කරගමු. Terminal එක open කරලා project root directory එකට ගිහින් මේ command එක run කරන්න:

mvn clean package

මේක සාර්ථකව run උනාට පස්සේ, target/ directory එක ඇතුළේ .jar file එකක් තියෙන්න ඕනේ (උදා: springboot-openshift-0.0.1-SNAPSHOT.jar). මේක තමයි අපි OpenShift වලට deploy කරන්න යන්නේ.

Dockerfile එකක් හදමු

OpenShift වලට Application එකක් deploy කරනකොට, අපිට Docker image එකක් අවශ්‍ය වෙනවා. මේ image එක හදන්න අපි Dockerfile එකක් භාවිතා කරනවා. Project root directory එකේ Dockerfile නමින් file එකක් හදලා මේ content එක paste කරන්න:

# Use a multi-stage build for efficiency

# Stage 1: Build the application
FROM maven:3.8.5-openjdk-17 AS builder
WORKDIR /app
COPY pom.xml .
COPY src ./src
RUN mvn clean package -DskipTests

# Stage 2: Create the final image
FROM openjdk:17-jdk-slim
WORKDIR /app
COPY --from=builder /app/target/*.jar app.jar
EXPOSE 8080
ENTRYPOINT ["java", "-jar", "app.jar"]

මේ Dockerfile එක ගැන පොඩ්ඩක් කතා කරමු:

• FROM maven:3.8.5-openjdk-17 AS builder: පළවෙනි stage එකට Maven සහ JDK 17 තියෙන image එකක් base image එක විදිහට ගන්නවා. අපි මේකට builder කියලා නමක් දුන්නා.
• WORKDIR /app: Docker image එක ඇතුළේ වැඩ කරන directory එක /app විදිහට සකසනවා.
• COPY pom.xml . සහ COPY src ./src: අපේ project files image එකට copy කරනවා.
• RUN mvn clean package -DskipTests: Application එක build කරනවා. අපි tests skip කරේ build time එක අඩු කරන්න.
• FROM openjdk:17-jdk-slim: දෙවෙනි stage එකට, Java runtime එක විතරක් තියෙන lightweight image එකක් base image එක විදිහට ගන්නවා. මේක නිසා final image එකේ size එක ගොඩක් අඩු වෙනවා.
• COPY --from=builder /app/target/*.jar app.jar: පළවෙනි stage එකේදී build කරපු .jar file එක දෙවෙනි stage එකේ image එකට copy කරනවා.
• EXPOSE 8080: Application එක 8080 port එකෙන් expose කරනවා කියලා කියනවා.
• ENTRYPOINT ["java", "-jar", "app.jar"]: Container එක start වෙනකොට run වෙන්න ඕනේ command එක. මේක අපේ Spring Boot Application එක run කරන command එකයි.

OpenShift වලට Deploy කරමු (Practical Example)

දැන් අපි බලමු මේ Application එක OpenShift වලට deploy කරන්නේ කොහොමද කියලා. මේ පියවර ටික හොඳට බලන්න.

1. OpenShift Login වෙමු

මුලින්ම, ඔබේ OpenShift cluster එකට login වෙන්න ඕනේ. මේකට ඔබේ cluster admin විසින් ලබා දුන් login command එක භාවිතා කරන්න. සාමාන්‍යයෙන් මේ වගේ එකක්:

oc login --token=<your-token> --server=<your-openshift-api-url>

නැත්නම් username/password වලින් login වෙන්න පුළුවන්:

oc login -u <username> -p <password> --server=<your-openshift-api-url>

2. අලුත් Project එකක් හදමු

Deploy කරන්න කලින්, අපිට අලුත් project (namespace) එකක් අවශ්‍යයි. මේකෙන් අපේ Application එකේ resources වෙනම තියාගන්න පුළුවන්:

oc new-project springboot-openshift-demo

දැන් ඔබේ current project එක springboot-openshift-demo විදිහට set වෙන්න ඕනේ.

3. Dockerfile එක භාවිතයෙන් Image එක Build කර Deploy කරමු

අපේ Spring Boot Application එකේ Dockerfile එක තියෙන නිසා, OpenShift එකට පුළුවන් ඒක build කරලා, image එක internal registry එකට push කරලා, ඊට පස්සේ Application එක deploy කරන්න. මේක තමයි OpenShift එක්ක වැඩ කරනකොට තියෙන ලොකුම පහසුවක්.

Project root directory එකේ ඉඳන් මේ command එක run කරන්න:

oc new-build --name=my-springboot-app --binary --strategy=docker

මේ command එකෙන් කරන්නේ my-springboot-app නමින් new build config එකක් හදන එක. මේක --binary strategy එක භාවිතා කරනවා. ඒ කියන්නේ source code එක අපේ local machine එකේ ඉඳන් provide කරනවා කියන එක. --strategy=docker කියන්නේ අපි Dockerfile එකක් භාවිතා කරනවා කියන එකයි.

දැන් build එක trigger කරලා අපේ source code එක (build කරපු .jar file එකයි Dockerfile එකයි) OpenShift වලට යවමු:

oc start-build my-springboot-app --from-dir=. --follow

--from-dir=. කියන්නේ මේ current directory එකේ තියෙන content එක යවන්න කියලා. --follow කියන්නේ build process එකේ logs අපිට live බලන්න පුළුවන් කියන එකයි. මේකෙන් Dockerfile එක run වෙලා image එක build වෙන හැටි බලාගන්න පුළුවන්.

Build එක සාර්ථකව අවසන් උනාට පස්සේ, OpenShift automatically අපේ Application එක deploy කරනවා. මොකද new-build එකක් හදනකොට, ඒක DeploymentConfig එකක් සහ ImageStream එකක් create කරනවා. ImageStream එක update වෙනකොට DeploymentConfig එක automatically deploy වෙනවා.

4. Application එක Expose කරමු (Route එකක් හදමු)

Deploy කරපු Application එක පිටත ලෝකයට expose කරන්න අපි Route එකක් හදන්න ඕනේ. Route එකක් කියන්නේ OpenShift cluster එක ඇතුළේ තියෙන service එකකට පිටතින් access කරන්න පුළුවන් URL එකක්.

oc expose service my-springboot-app

මේ command එක run කරාට පස්සේ, ඔබේ Application එකට අදාළ public URL එකක් create වෙනවා. මේක බලාගන්න මේ command එක run කරන්න:

oc get route my-springboot-app

Output එකේ HOST/PORT යටතේ තියෙන URL එක copy කරගන්න (උදා: my-springboot-app-springboot-openshift-demo.apps.your-cluster.com).

5. Application එක Test කරමු

දැන් copy කරගත්ත URL එක ඔබේ web browser එකේ open කරලා, අපේ /hello endpoint එකට request එකක් යවමු. URL එකට /hello කියලා එකතු කරන්න:

http://my-springboot-app-springboot-openshift-demo.apps.your-cluster.com/hello

ඔබට Hello from Spring Boot on OpenShift! අම්මෝ ඒක! කියලා response එකක් ලැබෙන්න ඕනේ. එහෙනම් වැඩේ සාර්ථකයි!

වැදගත් OpenShift Commands ටිකක්

• oc get pods: ඔබගේ project එකේ තියෙන pods බලාගන්න.
• oc logs <pod-name>: Pod එකේ logs බලාගන්න. (oc get pods වලින් pod name එක ගන්න)
• oc get svc: ඔබගේ project එකේ තියෙන services බලාගන්න.
• oc get dc: DeploymentConfigs බලාගන්න.
• oc delete all --selector app=my-springboot-app: ඔබගේ Application එකට අදාළ සියලුම resources (Deployment, Service, Route, BuildConfig) delete කරන්න.

Conclusion

ඉතින් යාලුවනේ, මේ tutorial එකෙන් අපි Spring Boot Application එකක් Red Hat OpenShift platform එකට deploy කරන්නේ කොහොමද කියලා පැහැදිලිව ඉගෙන ගත්තා. අපි මුලින්ම සරල Spring Boot Application එකක් හැදුවා, ඊට පස්සේ Dockerfile එකක් හදලා, oc CLI එක භාවිතයෙන් Application එක build කරලා deploy කරලා, අන්තිමට ඒක test කරා.

මේක software development වල අත්‍යවශ්‍ය step එකක්. මේ දැනුම ඔබට ඔබේ projects වලට අනිවාර්යයෙන්ම ගොඩක් වැදගත් වේවි. Cloud-native development වලට මේ වගේ platforms භාවිතා කරන එක ඔබේ applications වල scalability, resilience සහ maintainability වැඩි දියුණු කරනවා.

දැන් ඔබත් පුරුදු වෙන්න මේ වගේ applications deploy කරන්න. ඔබේ අදහස්, ප්‍රශ්න හෝ මේ වගේ deploy කරපු අත්දැකීම් පහතින් comment කරන්න! ඒ වගේම මේක තවත් කෙනෙක්ට වැදගත් වෙයි කියලා හිතෙනවා නම් Share කරන්න අමතක කරන්න එපා. ජය වේවා!