Spring Boot Multi-Cloud Deployment Sinhala Guide | AWS, Azure, GCP එකටම

ආයුබෝවන් හැමෝටම! ✋ අද අපි කතා කරන්න යන්නේ මේ දවස්වල Software Engineering ලෝකේ ගොඩක් ජනප්‍රිය මාතෘකාවක් ගැන – ඒ තමයි Multi-Cloud Deployment. විශේෂයෙන්ම, අපේ ප්‍රියතම Spring Boot Application එකක්, එකවර AWS, Azure, Google Cloud වගේ Cloud Providers කිහිපයකටම deploy කරන්නේ කොහොමද කියලා.

දැන් ඔයාලා හිතනවා ඇති, "අයියෝ, මේක නිකන් බත් කනවා වගේ ලේසියි කියලා හිතුවොත් වැරදියි!" කියලා. ඇත්තටම, පොඩි දැනුමක් සහ සැලසුමක් තිබ්බොත් මේක එච්චරම අමාරු දෙයක් නෙවෙයි. මේ guide එකෙන් අපි පියවරෙන් පියවර Multi-Cloud ලෝකයට පිවිසිලා, Spring Boot Application එකක් සාර්ථකව deploy කරන්නේ කොහොමද කියලා බලමු. මේක ඔයාලගේ ඊලඟ project එකට වටිනා අත්දැකීමක් වෙයි!

Multi-Cloud කියන්නේ මොකක්ද? (What is Multi-Cloud?)

සරලවම කිව්වොත්, Multi-Cloud කියන්නේ එකම ආයතනයක් තමන්ගේ applications සහ data, Cloud Service Providers (CSP) කිහිපයකම (උදා: AWS, Microsoft Azure, Google Cloud Platform (GCP)) distribute කරලා පවත්වාගෙන යන එකටයි. මේක Hybrid Cloud එකක් නෙවෙයි. Hybrid Cloud කියන්නේ on-premise infrastructure එකයි, public cloud එකයි එකට පාවිච්චි කරන එකට.

Multi-Cloud වල වාසි (Benefits of Multi-Cloud)

• Vendor Lock-in Avoidance (සැපයුම්කරු මත යැපීම අඩු කිරීම): එකම Cloud Provider කෙනෙක් මත සම්පූර්ණයෙන්ම රඳා පවතින්නේ නැතුව ඉන්න පුළුවන්. ඒ කියන්නේ, අද AWS වලින් ප්‍රශ්නයක් ආවොත්, හෙට Azure එකට මාරු වෙන්න පුළුවන් වගේ දෙයක්.
• Increased Resilience and Disaster Recovery (වැඩි දියුණු කළ ඔරොත්තු දීමේ හැකියාව සහ ආපදා ප්‍රතිසාධනය): එක් Cloud Provider කෙනෙක්ගේ සේවාව බිඳ වැටුනොත් (ඒ කියන්නේ outage එකක් ආවොත්), අපේ services අනිත් Cloud Providers ලා හරහා දිගටම පවත්වාගෙන යන්න පුළුවන්. හිතන්න, ඔයාගේ බිස්නස් එකේ සර්වර්ස් එක තැනක විතරක් තියෙනවාට වඩා, තැන් කිහිපයක තිබ්බොත් ආරක්ෂාව වැඩි නේද?
• Cost Optimization (පිරිවැය ප්‍රශස්තකරණය): විවිධ Cloud Providers ලා විවිධ සේවාවන් වලට විවිධ මිල ගණන් අය කරනවා. අපිට පුළුවන් අපේ application එකේ කොටස්, අඩුම මිලට හොඳම සේවාව දෙන Cloud Provider ගෙන් ගන්න.
• Compliance and Data Sovereignty (අනුකූලතාවය සහ දත්ත ස්වෛරීත්වය): සමහර රටවල්වල, දත්ත (data) යම් භූගෝලීය කලාපයක් තුළම තියාගන්න ඕන කියන නීති තියෙනවා. Multi-Cloud එකක් හරහා අපිට මේ අවශ්‍යතා සපුරා ගන්න පුළුවන්.

Multi-Cloud වල අභියෝග (Challenges of Multi-Cloud)

• Increased Complexity (වැඩි වන සංකීර්ණත්වය): Cloud Providers ලා කිහිප දෙනෙක් manage කරන එක ලේසි නෑ. Monitoring, security, networking වගේ දේවල් වලට අමතර උත්සාහයක් ඕන වෙනවා.
• Data Transfer Costs (දත්ත හුවමාරු පිරිවැය): Cloud Providers ලා අතර data transfer කරනකොට ගාස්තු අය කරනවා. මේවා සැලකිල්ලට ගන්නේ නැතුව ගියාම, බිල වැඩියෙන් එන්න පුළුවන්.
• Operational Consistency (ක්‍රියාකාරීත්වයේ අනුකූලතාවය): විවිධ Cloud Providers ලාගේ tools, APIs සහ services වෙනස්. ඒ නිසා deploy කරනකොට සහ manage කරනකොට consistency එකක් පවත්වා ගැනීම අභියෝගයක්.
• Security Concerns (ආරක්ෂක ගැටලු): Cloud Providers ලා කිහිප දෙනෙක් පාවිච්චි කරනකොට, security policies සහ best practices, හැම තැනටම අදාළ කරගන්න එක අමාරු වෙන්න පුළුවන්.

Spring Boot Multi-Cloud වලට ගැලපෙන්නේ ඇයි? (Why is Spring Boot suitable for Multi-Cloud?)

Spring Boot කියන්නේ Java Developers ලා අතර ගොඩක් ජනප්‍රිය Framework එකක්. Multi-Cloud Environments වලදී මේක විශේෂයෙන්ම හොඳට ගැලපෙනවා. ඇයි කියලා බලමු:

• Portability (පහසුවෙන් ගෙන යා හැකි වීම): Spring Boot Applications, “fat JARs” විදියට build වෙන්නේ. මේවාට අවශ්‍ය සියලුම dependencies අඩංගු නිසා, Java Virtual Machine (JVM) එකක් තියෙන ඕනෑම තැනක run කරන්න පුළුවන්. මේක Cloud Providers ලා අතර application එක මාරු කරන්න ගොඩක් පහසු කරනවා.
• Externalized Configuration (බාහිරගත කළ වින්‍යාසය): Spring Boot වලින් application configurations (database credentials, API keys වගේ දේවල්) externalize කරන්න පුළුවන්. ඒ කියන්නේ, මේවා application එකේ code එකෙන් වෙන් කරලා, environment variables, config files, හෝ Cloud-specific secret management services (AWS Secrets Manager, Azure Key Vault, GCP Secret Manager) හරහා manage කරන්න පුළුවන්. මේක Multi-Cloud environments වලදී එකම application එක විවිධ configurations එක්ක run කරන්න අත්‍යවශ්‍යයි.
• Spring Cloud Project (Spring Cloud ව්‍යාපෘතිය): Spring Cloud කියන්නේ Spring Boot Application වලට cloud-native features ගොඩක් add කරන project එකක්. Service Discovery, Circuit Breakers, Distributed Tracing, API Gateways වගේ දේවල් මේකට අයිතියි. මේවා Cloud Provider කෙනෙක් මත රඳා නොපවතින නිසා (provider-agnostic), Multi-Cloud environments වලදී ගොඩක් ප්‍රයෝජනවත් වෙනවා.
• Containerization Friendly (කන්ටේනර්කරණයට හිතකර): Spring Boot applications, Docker containers ඇතුලේ run කරන්න ගොඩක් පහසුයි. Docker සහ Kubernetes වගේ technologies, Cloud Providers ලා අතර application එක migrate කරන්න තියෙන හොඳම ක්‍රමයක්.

පොදු Multi-Cloud Deployment Strategies (Common Multi-Cloud Deployment Strategies)

Spring Boot Application එකක් Multi-Cloud environment එකකට deploy කරන්න විවිධ ක්‍රම තියෙනවා. අපි ප්‍රධාන ඒවා කීපයක් බලමු:

• Lift-and-Shift (VMs): මේක තමයි සරලම ක්‍රමය. On-premise servers වල run වෙන application එකක්, වෙනස්කම් ගොඩක් නොකරම, Cloud Provider කෙනෙක්ගේ Virtual Machine (VM) එකක් මතට මාරු කරන එක. මේකේ වාසිය තමයි ඉක්මනින් කරන්න පුළුවන් වීම. අවාසිය තමයි Cloud-native features වලින් ප්‍රයෝජන ගන්න බැරි වීම.
• Containerization (Docker & Kubernetes): මේක තමයි Multi-Cloud වලට හොඳම ක්‍රමය. Application එක Docker container එකක් විදියට package කරලා, Kubernetes (AWS EKS, Azure AKS, GCP GKE) වගේ Container Orchestration platform එකක් හරහා Cloud Providers කිහිපයකම run කරන එක. Application එකේ portability එක වැඩි කරනවා වගේම, scalability සහ resilience එකත් වැඩි කරනවා.
• Platform-as-a-Service (PaaS): මේකෙන් Cloud Provider කෙනෙක්, application එක run කරන්න අවශ්‍ය runtime environment එක සපයනවා. (උදා: AWS Elastic Beanstalk, Azure App Service, GCP App Engine/Cloud Run). මේකෙන් infrastructure management එක අඩු වෙනවා, ඒත් Provider-specific tools සහ services පාවිච්චි කරන්න වෙන නිසා Vendor Lock-in අවදානමක් තියෙනවා.

මේ tutorial එකේදී, අපි Containerization ක්‍රමය භාවිතා කරලා Spring Boot Application එකක් Multi-Cloud environment එකකට deploy කරන විදිය බලමු. මේක තමයි අද දවසේ ගොඩක් ජනප්‍රිය සහ effective ම ක්‍රමය.

Practical Example: Spring Boot Application එකක් Containerize කරමු (Let's Containerize a Spring Boot Application)

මුලින්ම අපි සරල Spring Boot Application එකක් හදමු. ඊට පස්සේ ඒක Dockerize කරලා, විවිධ Cloud Environments වලට ගැලපෙන විදියට configuration කරන්න බලමු.

1. අපි Application එකක් හදමු (Let's Create an Application)

ඔයාලට Spring Initializr එක පාවිච්චි කරලා ඉක්මනින්ම Project එකක් හදාගන්න පුළුවන්. Dependencies විදියට Spring Web එක add කරන්න.

pom.xml (dependencies)

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
    <xsi:schemaLocation>http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd</xsi:schemaLocation>
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>3.2.5</version> <!-- Change to your preferred Spring Boot version -->
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.example</groupId>
    <artifactId>multi-cloud-demo</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>multi-cloud-demo</name>
    <description>Demo project for Spring Boot Multi-Cloud deployment</description>
    <properties>
        <java.version>17</java.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

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

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

src/main/java/com/example/multiclouddemo/MultiCloudDemoApplication.java

package com.example.multiclouddemo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class MultiCloudDemoApplication {

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

}

src/main/java/com/example/multiclouddemo/HelloController.java

මේ Controller එකෙන් අපි environment specific message එකක් return කරනවා. මේක Spring Boot profile එක activate වෙන විදිය අනුව වෙනස් වෙනවා.

package com.example.multiclouddemo;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class HelloController {

    @Value("${my.message:Hello from Default Environment!}")
    private String message;

    @GetMapping("/hello")
    public String hello() {
        return message;
    }
}

src/main/resources/application.properties

server.port=8080
my.message=Hello from Generic Environment!

Cloud-Specific Configuration Files (Cloud-Specific වින්‍යාස ගොනු)

දැන් අපි Cloud එක අනුව වෙනස් වෙන messages ටිකක් හදමු.

src/main/resources/application-aws.properties

my.message=Hello from AWS Cloud!

src/main/resources/application-azure.properties

my.message=Hello from Azure Cloud!

src/main/resources/application-gcp.properties

my.message=Hello from Google Cloud!

මේ වගේ application-{profile}.properties files හදනකොට, අපි SPRING_PROFILES_ACTIVE environment variable එක set කරලා, අපිට ඕන profile එක activate කරන්න පුළුවන්. උදාහරණයක් විදියට, SPRING_PROFILES_ACTIVE=aws කියලා දුන්නොත්, AWS specific message එක my.message variable එකට load වෙනවා.

2. Dockerize කරමු (Let's Dockerize it)

දැන් අපි මේ Spring Boot Application එක Docker image එකක් විදියට package කරමු. Project root directory එකේ Dockerfile කියන file එක හදන්න.

Dockerfile

# Stage 1: Build the application
FROM maven:3.8.5-openjdk-17-slim AS build
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=build /app/target/*.jar app.jar
EXPOSE 8080
ENTRYPOINT ["java", "-jar", "app.jar"]

මේ Dockerfile එක multi-stage build එකක්. ඒ කියන්නේ, මුලින්ම Maven image එකක් පාවිච්චි කරලා අපේ application එක build කරලා JAR file එක හදාගන්නවා. ඊට පස්සේ, පොඩිම OpenJDK image එකක් පාවිච්චි කරලා final Docker image එක හදනවා. මේකෙන් image size එක ගොඩක් අඩු කරගන්න පුළුවන්.

Docker Image එක Build කරලා Run කරමු (Let's Build and Run the Docker Image)

Project root directory එකේදී මේ commands ටික run කරන්න:

# Build the Spring Boot JAR
mvn clean package

# Build the Docker image
docker build -t multi-cloud-demo .

# Run the Docker container with default profile
docker run -p 8080:8080 multi-cloud-demo

# Test it (open browser or curl): http://localhost:8080/hello
# Output: Hello from Generic Environment!

# Run with AWS profile
docker run -p 8080:8080 -e SPRING_PROFILES_ACTIVE=aws multi-cloud-demo
# Test it: http://localhost:8080/hello
# Output: Hello from AWS Cloud!

# Run with Azure profile
docker run -p 8080:8080 -e SPRING_PROFILES_ACTIVE=azure multi-cloud-demo
# Test it: http://localhost:8080/hello
# Output: Hello from Azure Cloud!

දැන් ඔයාලට පේනවා ඇති, අපි SPRING_PROFILES_ACTIVE environment variable එකෙන් profile එක වෙනස් කරනකොට, application එකේ output එකත් වෙනස් වෙනවා. මේක තමයි Multi-Cloud deployments වලදී configuration manage කරන්න තියෙන මූලිකම ක්‍රමවේදය.

Multi-Cloud Deployment (AWS, Azure, GCP)

අපි දැන් හදපු Docker image එක Cloud Providers තුනකටම deploy කරන්නේ කොහොමද කියලා සරලව බලමු. මේ හැම Cloud Provider කෙනෙක්ටම තමන්ගේම Container Registry (Docker images store කරන්න) සහ Container Orchestration Service (Docker containers run කරන්න) එකක් තියෙනවා.

1. AWS (Amazon Web Services) වලට යවමු

• Container Registry: AWS Elastic Container Registry (ECR)
• Container Orchestration: AWS Elastic Container Service (ECS) හෝ AWS Elastic Kubernetes Service (EKS)

පියවර:

1. ECR එකේ repository එකක් හදන්න.
2. ECS (Fargate) එකේ Task Definition එකක් හදලා, Service එකක් deploy කරන්න. මෙතනදී SPRING_PROFILES_ACTIVE=aws කියන environment variable එක Task Definition එකට add කරන්න පුළුවන්.
3. EKS පාවිච්චි කරනවා නම්, Kubernetes deployment සහ service YAML files හදලා, kubectl apply -f කරන්න පුළුවන්.

ඔබේ local Docker image එක ECR එකට push කරන්න. (මේකට AWS CLI install කරලා configure කරන්න ඕන.)

aws ecr get-login-password --region <your-region> | docker login --username AWS --password-stdin <your-aws-account-id>.dkr.ecr.<your-region>.amazonaws.com
docker tag multi-cloud-demo:latest <your-aws-account-id>.dkr.ecr.<your-region>.amazonaws.com/multi-cloud-demo:latest
docker push <your-aws-account-id>.dkr.ecr.<your-region>.amazonaws.com/multi-cloud-demo:latest

2. Azure (Microsoft Azure) වලට යවමු

• Container Registry: Azure Container Registry (ACR)
• Container Orchestration: Azure Container Apps (ACA) හෝ Azure Kubernetes Service (AKS)

පියවර:

1. ACR එකේ repository එකක් හදන්න.
2. Azure Container Apps හෝ AKS එකේ Deployment එකක් හදන්න. මෙතනදී SPRING_PROFILES_ACTIVE=azure කියන environment variable එක add කරන්න පුළුවන්.

ඔබේ local Docker image එක ACR එකට push කරන්න. (මේකට Azure CLI install කරලා configure කරන්න ඕන.)

az acr login --name <your-acr-name>
docker tag multi-cloud-demo:latest <your-acr-name>.azurecr.io/multi-cloud-demo:latest
docker push <your-acr-name>.azurecr.io/multi-cloud-demo:latest

3. Google Cloud Platform (GCP) වලට යවමු

• Container Registry: Google Container Registry (GCR) / Artifact Registry
• Container Orchestration: Google Cloud Run හෝ Google Kubernetes Engine (GKE)

පියවර:

1. Artifact Registry එකේ repository එකක් හදන්න.
2. Google Cloud Run (serverless) හෝ GKE එකේ Deployment එකක් හදන්න. Cloud Run වලදී revision settings හරහා, GKE වලදී Deployment YAML එකේදී SPRING_PROFILES_ACTIVE=gcp කියන environment variable එක add කරන්න පුළුවන්.

ඔබේ local Docker image එක Artifact Registry එකට push කරන්න. (මේකට gcloud CLI install කරලා configure කරන්න ඕන.)

gcloud auth configure-docker
docker tag multi-cloud-demo:latest gcr.io/<your-gcp-project-id>/multi-cloud-demo:latest
docker push gcr.io/<your-gcp-project-id>/multi-cloud-demo:latest

මේ විදියට, එකම Docker image එකක් භාවිතා කරලා, විවිධ Cloud Providers ලා මතට deploy කරන්න පුළුවන්. ඒ වගේම, Spring Boot Profiles හරහා Cloud-specific configuration manage කරන්නත් පුළුවන්.

නිගමනය (Conclusion)

අද අපි Multi-Cloud Deployment කියන්නේ මොකක්ද, ඒකේ වාසි සහ අභියෝග මොනවද, වගේම Spring Boot Applications මේකට කොහොමද ගැලපෙන්නේ කියලා ඉගෙන ගත්තා. විශේෂයෙන්ම, Dockerization සහ Spring Boot Profiles පාවිච්චි කරලා, අපේ Application එක AWS, Azure, Google Cloud වැනි Cloud Providers කිහිපයකටම deploy කරන විදිය practical විදියට බැලුවා.

Multi-Cloud කියන්නේ අනාගතය. මේකෙන් අපේ Applications වල resilience, scalability, සහ cost-effectiveness එක වැඩි කරගන්න පුළුවන්. හැබැයි මේකේ තියෙන සංකීර්ණත්වයත් අපි අමතක කරන්න හොඳ නෑ.

දැන් ඔයාලා මේක තනියම ට්‍රයි කරලා බලන්න! 🚀 පොඩි Spring Boot Application එකක් හදලා, Dockerize කරලා, ඔයාලට පුළුවන් Cloud Provider කෙනෙක් මත deploy කරන්න. ඒ වගේම, වෙනත් Cloud Providers ලා ගැනත් explore කරන්න. ඔයාලගේ අත්දැකීම් පහලින් comment කරන්න! මේ වගේ තවත් Guides ඕන නම් ඒකත් කියන්න. හැමෝටම ජය!