Spring Boot & Docker: App එක Containerize කරමු! 🚀

කොහොමද යාලුවනේ! අද අපි කතා කරන්න යන්නේ මේ දවස් වල Software Engineering ලෝකේ හරිම ජනප්‍රිය වෙලා තියෙන, හැම තැනම කතාබහට ලක්වෙන වැදගත් මාතෘකාවක් ගැන – ඒ තමයි Spring Boot applications Dockerization කරන එක.

දන්නවනේ, සාමාන්‍යයෙන් අපි Project එකක් කරනකොට, ඒක develop කරන්න, run කරන්න, deploy කරන්න විවිධ dependencies, libraries, runtime environments ඕන වෙනවා. ඔයාලට මතක ඇති සමහර වෙලාවට අපේ local machine එකේ වැඩ කරන application එකක් server එකට දාපු ගමන් වැඩ කරන්නේ නැහැ. 'It works on my machine' කියන meme එක හැදුනෙත් ඕක නිසා තමයි. මේකට එක එක හේතු තියෙන්න පුළුවන්: Java version එකේ අවුලක්, Maven/Gradle dependencies එකක් නැති එකක්, database එකේ setup එකක් වගේ දේවල්. මේ හැමදේම හරිගස්සන එක කියන්නේ developer කෙනෙක්ට හරිම කරදරකාරී වැඩක්, ඒ වගේම ගොඩක් වෙලාවට කන කට්ටක්.

අන්න ඒ වගේ අවුල් නැති කරලා, අපේ application එක ඕනම තැනක, ඕනම environment එකක කිසිම කරදරයකින් තොරව run කරන්න පුළුවන් solution එකක් තමයි Docker කියන්නේ. ඒ නිසා අද අපි බලමු Spring Boot application එකක් Dockerize කරන්නේ කොහොමද කියලා, ඒකට Dockerfile එකක් හදලා, image එක build කරලා, container එකක් විදියට run කරලා කොහොමද අපේ application එක ඕන තැනක වැඩ කරවන්නේ කියලා. මේකෙන් ඔයාලට ඔයාලගේ applications deploy කරන එක හරිම පහසු කරගන්න පුළුවන් වෙයි!

Docker කියන්නේ මොකක්ද? 🐳

සරලවම කිව්වොත්, Docker කියන්නේ software applications isolate කරලා, ඒවට ඕන කරන හැම dependency එකක්ම එක්කම, වෙනම, ස්වාධීන 'package' එකක් විදියට run කරන්න පුළුවන් platform එකක්. මේ package එකට අපි කියන්නේ container එකක් කියලා.

සාමාන්‍යයෙන් අපි application එකක් run කරනකොට virtual machine (VM) එකක් පාවිච්චි කරනවා. VM එකක් කියන්නේ සම්පූර්ණ operating system (OS) එකක්ම අනුකරණය කරන, ඒක ඇතුලේ අපේ application එක run කරන දෙයක්. හැබැයි VM එකක් හරිම heavyweight. ඒකට වෙනම OS එකක්, virtual hardware එකක් වගේ ගොඩක් දේවල් ඕන වෙනවා.

ඒත් container එකක් එහෙම නැහැ. container එකක් run වෙන්නේ host OS එකේ kernel එක share කරගෙන. ඒක නිසා container එකක් VM එකකට වඩා හරිම lightweight. ඒ වගේම ගොඩක් ඉක්මනට start කරන්න පුළුවන්. මේකෙන් අපේ resources ගොඩක් save වෙනවා, ඒ වගේම application එක deploy කරන එකත් ගොඩක් වේගවත් වෙනවා.

Docker භාවිතා කිරීමේ වාසි (Benefits of using Docker):

• Consistency: 'It works on my machine' ප්‍රශ්නේ Docker එක්ක නැති වෙනවා. ඔයාගේ machine එකේ container එක වැඩ කරනවා නම්, server එකෙත් ඒ විදියටම වැඩ කරනවා.
• Portability: Docker container එකක් කියන්නේ ඕනම Docker-enabled machine එකක run කරන්න පුළුවන් standard unit එකක්.
• Isolation: එක container එකක් තව container එකකට බලපෑමක් කරන්නේ නැහැ. ඒ නිසා dependencies clash වෙන්නේ නැහැ.
• Efficiency: Lightweight නිසා, VM වලට වඩා අඩු resource ප්‍රමාණයක් තමයි containers වලට ඕන වෙන්නේ.
• Scalability: Application එකේ load එක වැඩි වෙනකොට, අවශ්‍ය නම් තවත් containers පහසුවෙන් add කරන්න පුළුවන්.

Spring Boot App එකක් Ready කරමු 🏗️

දැන් අපි බලමු Spring Boot application එකක් Dockerize කරන්න කලින්, ඒක කොහොමද Docker ready කරගන්නේ කියලා. මේකට අපි හදන්න යන්නේ හරිම simple Spring Boot REST API එකක්. අපි මේකේ source code එක ගැන ගොඩක් කතා කරන්නේ නැහැ, මොකද අපේ ප්‍රධාන අවධානය යොමු වෙන්නේ Dockerization process එකට නිසා.

මුලින්ම, ඔයාලට Spring Boot project එකක් නැත්නම්, Spring Initializr එකෙන් ඉක්මනටම project එකක් හදාගන්න පුළුවන්. dependencies විදියට 'Spring Web' විතරක් තෝරගත්තත් ඇති.

Project එක හදාගත්තට පස්සේ, ඔයාලට පුළුවන් මේ වගේ simple Controller එකක් හදන්න:

package com.example.dockerguide;

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 DockerGuideApplication {

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

	@GetMapping("/")
	public String hello() {
		return "Hello from Spring Boot inside Docker! 👋";
	}
}

මේකෙන් අපි කරන්නේ, root path (/) එකට request එකක් ආවම, "Hello from Spring Boot inside Docker! 👋" කියලා message එකක් return කරන එක. මේක තනිකරම demonstration එකක් විදියට හිතන්න. ඔයාලට පුළුවන් ඔයාලගේ තියෙන ඕනම Spring Boot project එකක් මේකට භාවිතා කරන්න.

අපිට මේ application එක Dockerize කරන්න කලින්, ඒක executable JAR file එකක් විදියට build කරගන්න ඕන. ඒකට ඔයාලා Maven භාවිතා කරනවා නම්:

./mvnw clean package

Gradle භාවිතා කරනවා නම්:

./gradlew clean build

මේ commands වලින් අපේ Spring Boot application එක target/ (Maven) නැත්නම් build/libs/ (Gradle) directory එක ඇතුලේ .jar file එකක් විදියට build වෙනවා. මේ JAR file එක තමයි අපි Docker image එක ඇතුලට දාන්න යන්නේ.

Dockerfile එකක් හදමු 📝

දැන් තමයි වැදගත්ම කොටස! Dockerfile එකක් කියන්නේ අපේ Docker image එක හදන්න ඕන steps මොනවද කියලා Docker Engine එකට කියන blueprint එකක්. මේක text file එකක්, ඒකට කිසිම file extension එකක් නැහැ, නිකන්ම Dockerfile කියලා තමයි නම දෙන්නේ.

අපි දැන් බලමු Spring Boot application එකක් සඳහා සාමාන්‍ය Dockerfile එකක් කොහොමද හදන්නේ කියලා. Project root directory එකේ Dockerfile කියලා අලුත් file එකක් හදලා මේ code එක ඒකට දාගන්න:

# Stage 1: Build the application (using a multi-stage build for smaller final image) 
FROM openjdk:17-jdk-slim AS build
WORKDIR /app
COPY .mvn/ .mvn/
COPY mvnw pom.xml ./ 
COPY src ./src
RUN ./mvnw clean package -DskipTests

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

දැන් අපි මේ Dockerfile එකේ තියෙන හැම line එකක්ම explain කරමු:

• # Stage 1: Build the application ...මේක multi-stage build එකක්. මේකෙන් අපිට පුළුවන් build කරන්න ඕන කරන tools (Maven/Gradle, JDK) තියෙන විශාල image එකක් භාවිතා කරලා application එක build කරලා, ඊට පස්සේ run කරන්න විතරක් ඕන කරන tools (JRE) තියෙන පොඩි image එකක් ඇතුලට අපේ final artifact එක (JAR file) විතරක් copy කරන්න. මේකෙන් අපේ final Docker image එකේ size එක ගොඩක් අඩු වෙනවා.
• FROM openjdk:17-jdk-slim AS buildමේකෙන් අපි කියනවා, අපේ build stage එකට openjdk:17-jdk-slim කියන base image එක පාවිච්චි කරන්න කියලා. jdk-slim කියන්නේ production එකට ගොඩක් optimized කරපු, අනවශ්‍ය දේවල් අයින් කරපු, පොඩි image එකක්. AS build කියන්නේ මේ stage එකට අපි build කියලා නමක් දෙනවා, ඒක අපිට ඊළඟ stage එකේදී refer කරන්න පුළුවන් වෙන්න.
• WORKDIR /appමේකෙන් කියන්නේ මේ stage එක ඇතුලේ ඊළඟට එන commands run කරන්න ඕන default working directory එක /app කියලා. මේකෙන් files copy කරන එක, commands run කරන එක පහසු වෙනවා.
• COPY .mvn/ .mvn/, COPY mvnw pom.xml ./, COPY src ./srcමේ commands වලින් අපේ Spring Boot project එකේ files Docker image එක ඇතුලට copy කරනවා. COPY <source> <destination> කියන format එකට තමයි මේවා වැඩ කරන්නේ. අපි මේකේ pom.xml එකයි src directory එකයි වෙන් කරලා copy කරන්නේ Docker's layer caching feature එක optimize කරන්න. pom.xml එකේ changes අඩු නිසා, ඒ layer එක cache වෙලා තවදුරටත් build process එක වේගවත් වෙනවා.
• RUN ./mvnw clean package -DskipTestsමේකෙන් අපි Docker image එක build කරනකොටම Maven Wrapper (mvnw) එක භාවිතා කරලා අපේ application එක package කරනවා. -DskipTests කියන්නේ tests run නොකර package කරන්න කියන එක. build කාලය අඩු කරගන්න මේක උදව් වෙනවා.
• # Stage 2: Create the final Docker imageදැන් අපි අපේ final, lightweight image එක හදනවා.
• FROM openjdk:17-jre-slimඅපේ final image එකට අපි openjdk:17-jre-slim base image එක භාවිතා කරනවා. jre-slim කියන්නේ Java applications run කරන්න විතරක් ඕන කරන minimal Java Runtime Environment එකක්. ඒක JDK image එකට වඩා ගොඩක් පොඩි නිසා final image එකත් පොඩි වෙනවා.
• WORKDIR /appමේකත් කලින් වගේම working directory එක set කරනවා.
• COPY --from=build /app/target/*.jar app.jarමේක multi-stage build එකේ හරිම වැදගත් කොටසක්. --from=build කියන එකෙන් අපි කියනවා, කලින් build කියලා නම් කරපු stage එකෙන් files copy කරන්න කියලා. මේකෙන් අපි කලින් stage එකේදී build කරපු JAR file එක (/app/target/*.jar) අරගෙන, අපේ final image එකේ /app directory එක ඇතුලේ app.jar කියලා copy කරනවා. මේකෙන් build tools image එකට එන්නේ නැති නිසා final image එකේ size එක විශාල වශයෙන් අඩු වෙනවා.
• EXPOSE 8080මේකෙන් Docker Engine එකට කියනවා අපේ application එක 8080 port එකෙන් listen කරනවා කියලා. මේක documentation purpose එකකට විතරයි, ඇත්තටම port එක expose වෙන්නේ නැහැ container එක run කරනකන්.
• ENTRYPOINT ["java", "-jar", "app.jar"]මේක තමයි අපේ container එක start වෙනකොට run කරන්න ඕන command එක. java -jar app.jar කියන command එකෙන් අපේ Spring Boot application එක run කරනවා.

දැන් අපේ Dockerfile එක ready! මේ Dockerfile එකෙන් හරිම efficient, lightweight Docker image එකක් හදන්න පුළුවන්.

.dockerignore file එකක් ගැන:

.dockerignore කියන්නේ .gitignore වගේම file එකක්. අපි මේකෙන් Docker image එක build කරනකොට copy කරන්න අවශ්‍ය නැති files, folders specify කරනවා. උදාහරණයක් විදියට target/, build/ directories, .git/, IDE specific files (.idea/, *.iml) වගේ දේවල් මේකට දාන්න පුළුවන්. මේකෙන් build context එකේ size එක අඩු වෙනවා, build process එක වේගවත් වෙනවා. ඔයාලට පුළුවන් මේ වගේ .dockerignore file එකක් හදන්න:

.mvn/
build/
.gradle/
.idea/
mvnw
mvnw.cmd
src/
target/
*.iml
.git/
Dockerfile

අපේ Dockerfile එකේ COPY commands භාවිතා කරන විදියට, .dockerignore එකේ තියෙන සමහර දේවල් අවශ්‍ය නැති වෙන්න පුළුවන්. හැබැයි production ready Dockerfile එකකදී මේක තියෙන එක හරිම හොඳ පුරුද්දක්.

Docker Image එක Build කරමු 🛠️

දැන් අපි අපේ Dockerfile එක හදලා ඉවරයි. ඊළඟට අපිට තියෙන්නේ මේ Dockerfile එක භාවිතා කරලා Docker image එකක් build කරන්න. මේකට අපි docker build command එක භාවිතා කරනවා.

Project root directory එකේ command prompt එකක්/terminal එකක් open කරගෙන මේ command එක run කරන්න:

docker build -t spring-boot-docker-guide:1.0 .

මේ command එක ගැන ටිකක් පැහැදිලි කරමු:

• docker build: Docker image එකක් build කරන්න භාවිතා කරන command එක.
• -t spring-boot-docker-guide:1.0: මේකෙන් අපි අපේ image එකට නමක් (tag) දෙනවා. spring-boot-docker-guide කියන්නේ image එකේ නම, 1.0 කියන්නේ tag එක (version එක). මේකෙන් අපිට image එක identify කරන්න ලේසියි.
• . (dot): මේකෙන් කියන්නේ Dockerfile එක තියෙන්නේ current directory එකේ කියලා. මේක තමයි build context එක. Docker Engine එක මේ directory එක ඇතුලේ තමයි Dockerfile එක හොයන්නේ, ඒ වගේම image එකට copy කරන්න ඕන files හොයන්නෙත් මෙතනින් තමයි.

මේ command එක run කරාම Docker Engine එක Dockerfile එකේ තියෙන instructions එකින් එක execute කරගෙන යනවා. ඔයාලට build process එකේ output එක terminal එකේ බලාගන්න පුළුවන් වෙයි. build එක සාර්ථකව ඉවර වුනොත්, අන්තිමට Successfully built <image ID> සහ Successfully tagged spring-boot-docker-guide:1.0 කියලා message එකක් බලාගන්න පුළුවන්.

Image එක build වුනාද බලන්න මේ command එක run කරන්න:

docker images

ඔයාලට මේ වගේ output එකක් බලාගන්න පුළුවන් වෙයි:

REPOSITORY                  TAG       IMAGE ID       CREATED          SIZE
spring-boot-docker-guide    1.0       <some ID>      About a minute ago   ~180MB
openjdk                     17-jre-slim  <some ID>      3 weeks ago      ~180MB
openjdk                     17-jdk-slim  <some ID>      3 weeks ago      ~280MB
...

මේකේ අපේ spring-boot-docker-guide image එකේ size එක බලන්න. සාමාන්‍ය Spring Boot JAR එකක් run කරන්න ඕන JVM එකත් එක්ක ගත්තම මේ image size එක හරිම පොඩි එකක්. මේක තමයි multi-stage build එකේ ලොකුම වාසිය!

Docker Container එක Run කරමු 🚀

දැන් අපි build කරපු Docker image එකෙන් container එකක් run කරන්න තමයි යන්නේ. මේකට අපි docker run command එක භාවිතා කරනවා.

docker run -p 8080:8080 -d spring-boot-docker-guide:1.0

මේ command එකේ තේරුම බලමු:

• docker run: Docker container එකක් run කරන්න භාවිතා කරන command එක.
• -p 8080:8080: මේක port mapping එකක්. container එක ඇතුලේ තියෙන 8080 port එක, host machine එකේ 8080 port එකට map කරනවා. ඒ කියන්නේ අපේ host machine එකේ 8080 port එකට එන request container එක ඇතුලේ තියෙන application එකට යනවා. (පළමු 8080 host port එක, දෙවන 8080 container port එක)
• -d: මේකෙන් කියන්නේ container එක detached mode එකේ run කරන්න කියලා. ඒ කියන්නේ container එක background එකේ run වෙනවා, අපිට terminal එකේ දිගටම වැඩ කරන්න පුළුවන්.
• spring-boot-docker-guide:1.0: අපි කලින් build කරපු image එකේ නම සහ tag එක.

මේ command එක run කරාට පස්සේ ඔයාලට container ID එකක් බලාගන්න පුළුවන් වෙයි. container එක run වෙනවාද කියලා බලන්න මේ command එක භාවිතා කරන්න:

docker ps

මේකෙන් දැනට run වෙන containers list එක බලාගන්න පුළුවන්. අපේ spring-boot-docker-guide container එකත් මේ list එකේ තියෙන්න ඕන. ඒකේ Ports column එකේ 0.0.0.0:8080->8080/tcp වගේ එකක් පෙන්වයි, ඒ කියන්නේ port mapping එක හරියටම වැඩ කරනවා කියන එක.

දැන් ඔයාලට පුළුවන් web browser එකක් open කරලා, http://localhost:8080/ කියලා type කරලා බලන්න. අපේ Spring Boot application එකෙන් return කරන "Hello from Spring Boot inside Docker! 👋" message එක ඔයාලට බලාගන්න පුළුවන් වෙයි!

මාරයි නේද? 🥳 දැන් ඔයාලගේ Spring Boot application එක Docker container එකක් විදියට සාර්ථකව run වෙනවා.

Container එක නවත්වන්න ඕන නම්, කලින් docker ps command එකෙන් බලාගත්ත container ID එක පාවිච්චි කරලා මේ command එක run කරන්න:

docker stop <container ID>

උදාහරණයක් විදියට: docker stop a1b2c3d4e5f6

අවසාන වශයෙන්: Containerization වල අනාගතය 🌟

ඉතින් යාලුවනේ, අද අපි Spring Boot application එකක් Dockerize කරන්නේ කොහොමද කියලා මුල ඉඳන්ම ඉගෙන ගත්තා. Docker කියන්නේ deployment process එක simplify කරන, consistency වැඩි කරන, scalability වැඩි කරන සුපිරි tool එකක් කියන එක දැන් ඔයාලට හොඳටම පැහැදිලි වෙන්න ඇති.

අපි අද කතා කරපු multi-stage builds, .dockerignore වගේ best practices භාවිතා කරන එක හරිම වැදගත්, මොකද ඒකෙන් අපේ Docker images වල size එක අඩු කරගන්න පුළුවන්, ඒ වගේම build process එක වේගවත් කරගන්නත් පුළුවන්. මේවා තමයි production environment එකකට යනකොට හරිම වැදගත් වෙන්නේ.

දැන් ඔයාලට පුළුවන් ඔයාලගේම Spring Boot applications Dockerize කරලා බලන්න. මේකෙන් ඔයාලගේ development workflow එකට ලොකු පහසුවක් වෙයි. ඒ වගේම DevOps ලෝකයට යන පළමු පියවරත් මේක තමයි.

මේ ගැන ඔයාලගේ අදහස් මොනවද? ඔයාලා දැනටමත් Spring Boot applications Dockerize කරලා තියෙනවාද? එහෙම නම් ඔයාලා භාවිතා කරන tactics මොනවද? පහලින් comment එකක් දාගෙන යන්න අමතක කරන්න එපා. මේ වගේ තවත් guide එකකින් හමුවෙමු! Happy Coding! 👋