AWS Elastic Beanstalk Docker Deployment SC Guide

කොහොමද යාලුවනේ! ඉතින් මේ ලියන වෙලාවේ මට මතක් වුණේ අපි software develop කරද්දී වැඩේ කරලා ඉවර වෙලත්, ඒක production එකට deploy කරන එක සමහර වෙලාවට කොච්චර වදයක්ද කියලා. පොඩි App එකක් හදලා ඒක ලෝකෙට පෙන්නන්න යද්දී අපිට තියෙන ලොකුම ගැටලුවක් තමයි server එකක් setup කරගෙන, dependency install කරලා, ඒවට security updates දාලා, load balancing හදලා, scaling බලාගන්න එක. ඇත්තටම කිව්වොත් මේ ඔක්කොම කරද්දී අපේ programming වලට තිබ්බ ආසාවත් නැති වෙලා යනවා නේද?

අන්න ඒකට AWS අපිට පට්ට විසඳුමක් දීලා තියෙනවා. ඒ තමයි AWS Elastic Beanstalk කියන්නේ! අද අපි කතා කරන්නේ මේ Elastic Beanstalk ගැන විතරක් නෙවෙයි, අපි Dockerize කරපු App එකක් කොහොමද කිසිම කරදරයක් නැතුව, ගොඩක් ලේසියෙන් Elastic Beanstalk වලට deploy කරන්නේ කියන එක ගැන. අපි බලමු මේකෙන් කොච්චර වෙලාවක් සහ මහන්සියක් අපිට ඉතුරු කරගන්න පුළුවන්ද කියලා. එහෙනම් වැඩේට බහිමු!

AWS Elastic Beanstalk කියන්නේ මොකක්ද?

සරලවම කිව්වොත්, AWS Elastic Beanstalk කියන්නේ අපේ web applications, microservices, වගේ ඒවා Amazon Web Services (AWS) infrastructure එකට deploy කරන්න, manage කරන්න, scale කරන්න පුළුවන් ඉතාමත් පහසු සේවාවක්. මේක 'Platform as a Service' (PaaS) ගණයට තමයි අයිති වෙන්නේ.

සාමාන්‍යයෙන් අපිට server එකක් දාන්න, operating system එක තෝරන්න, web server (Apache, Nginx වගේ) install කරන්න, database එකක් attach කරන්න, load balancing configure කරන්න, auto-scaling හදන්න වගේ වැඩ ගොඩක් කරන්න වෙනවා. මේ හැමදේම Elastic Beanstalk අපිට automatically කරලා දෙනවා. අපිට කරන්න තියෙන්නේ අපේ App එකේ code එක දෙන්න විතරයි!

කොටින්ම කිව්වොත්, Elastic Beanstalk වලදී අපිට underlying infrastructure එක ගැන ඔලුව රත් කරගන්න ඕනේ නෑ. අපිට පුළුවන් අපේ application එක develop කරන එකට විතරක් අවධානය දෙන්න. මේකෙන් අපේ productivity එක වැඩි වෙනවා වගේම, deployment process එකත් ගොඩක් වේගවත් වෙනවා. Java, .NET, PHP, Node.js, Python, Ruby, Go, සහ Docker වගේ විවිධ platform වලට මේක support කරනවා. ඒ වගේම අපිට AWS Console එක හරහා, Command Line Interface (CLI) එක හරහා, නැත්නම් API එකක් හරහා අපේ Elastic Beanstalk environments manage කරන්න පුළුවන්. ඒ කියන්නේ, ඔයාට පුළුවන් ඔයාගේ deployment flow එක තමන්ට ඕන විදියට හදාගන්න, නැත්නම් automated CI/CD pipeline එකකට සම්බන්ධ කරන්න.

Docker සහ Elastic Beanstalk එකට වැඩ කරන්නේ කොහොමද?

දැන් අපි බලමු Docker සහ Elastic Beanstalk එකට එකතු වෙලා කොහොමද අපිට ලොකු වාසියක් දෙන්නේ කියලා. Docker කියන්නේ මොකක්ද කියලා ඔයාලා දන්නවා ඇති කියලා මම හිතනවා. ඒක හරියට පොඩි, තනි තනි package වගේ. අපේ application එකට ඕන කරන code, libraries, dependencies, සහ configurations ඔක්කොම එක container එකකට දාලා, ඒක ඕනම තැනක, ඕනම environment එකක කිසිම වෙනසක් නැතුව run කරන්න පුළුවන්. 'Build once, run anywhere' කියන්නේ මේකට තමයි. මේකෙන් developers ලට ලැබෙන නිදහස අති විශාලයි.

ඉතින් Elastic Beanstalk වලට Dockerize කරපු App එකක් deploy කරන එකෙන් අපිට තියෙන වාසිය තමයි, අපේ App එකේ environment එක ගැන අපිට කිසිම කරදරයක් වෙන්නෙ නෑ. Docker container එකේ තියෙන විදියටම App එක run වෙනවා. ඒක නිසා 'අනේ මගේ machine එකේ නම් වැඩ කළා, production එකේ වැඩ කරන්නේ නෑනේ!' වගේ ප්‍රශ්න අපිට ඇති වෙන්නේ නෑ. විශේෂයෙන්ම Microservices architecture එකක් පාවිච්චි කරනවා නම්, මේ Docker සහ Elastic Beanstalk combination එක අතිශයින්ම ප්‍රයෝජනවත්. එක් එක් service එක වෙන වෙනම Docker container එකක් විදියට Deploy කරලා, ඒවා ස්වාධීනව manage කරන්න පුළුවන්.

Elastic Beanstalk වලදී, අපිට තියෙන්නේ Dockerfile එකක් සහ අපේ App එකේ code එක zip කරලා දුන්නාම, Elastic Beanstalk automatically Docker image එක build කරලා, EC2 instances වල run කරලා, load balancing, auto-scaling ඔක්කොම configure කරනවා. මේක ඇත්තටම 'Magic' වගේ තමයි! ඔයාට single Docker container එකක් deploy කරන්න පුළුවන් වගේම, Docker Compose file එකක් පාවිච්චි කරලා multi-container Docker applications deploy කරන්නත් පුළුවන්. ඒ කියන්නේ, database, web server, worker වගේ services කිහිපයක් එකට තිබ්බත් කිසිම ගැටලුවක් නැතුව deploy කරන්න පුළුවන්.

Dockerized App එකක් Elastic Beanstalk එකට Push කරමු

හරි, දැන් අපි කතාව පැත්තකින් තියලා වැඩේට බහිමු! Dockerize කරපු App එකක් Elastic Beanstalk එකට deploy කරන්නේ කොහොමද කියලා අපි පියවරෙන් පියවර බලමු. මම මෙතනදි Node.js App එකක් උදාහරණයකට ගන්නවා. ඔයාලට මේ concepts ඕනෑම programming language එකක Dockerize කරපු App එකකට apply කරන්න පුළුවන්.

පූර්ව අවශ්‍යතා (Prerequisites)

මේ වැඩේට බහින්න කලින් අපිට මේ ටික ඕනේ:

• AWS Account එකක්: තාම නැත්නම්, free tier එකෙන් අදම හදාගන්න.
• Docker: ඔයාගේ machine එකේ Docker install කරලා තියෙන්න ඕනේ. (Docker Desktop)
• AWS CLI: AWS Command Line Interface install කරලා configure කරලා තියෙන්න ඕනේ. aws configure ගහලා ඔයාගේ Access Key ID සහ Secret Access Key එක දීලා configure කරගන්න.
• EB CLI: Elastic Beanstalk Command Line Interface එක install කරගන්න.

සරල Dockerized App එකක් හදමු (Let's Create a Simple Dockerized App)

මුලින්ම අපි සරල Node.js App එකක් සහ ඒකට Dockerfile එකක් හදාගමු. අලුත් folder එකක් හදලා ඒ ඇතුලට යන්න.

mkdir my-docker-app
cd my-docker-app

දැන් app.js කියලා file එකක් හදලා මේ code එක ඒකට දාන්න:

// app.js
const express = require('express');
const app = express();
const port = 3000; // Change if needed, Elastic Beanstalk will map port 80 to this

app.get('/', (req, res) => {
  res.send('Hello from Docker on Elastic Beanstalk! (SC Guide)');
});

app.listen(port, () => {
  console.log(`App listening at http://localhost:${port}`);
});

මේකට Express.js ඕන වෙන නිසා package.json file එක හදමු. මේකෙන් තමයි Node.js project එකක් කියලා identify වෙන්නේ:

{
  "name": "my-docker-app",
  "version": "1.0.0",
  "description": "A simple Node.js app for Elastic Beanstalk deployment",
  "main": "app.js",
  "scripts": {
    "start": "node app.js"
  },
  "dependencies": {
    "express": "^4.17.1"
  }
}

දැන් Dockerfile එක හදමු. මේක තමයි අපේ App එක container එකක් විදියට build කරන්නේ කොහොමද කියලා Docker ට කියන්නේ:

# Dockerfile
FROM node:14

WORKDIR /usr/src/app

COPY package*.json ./

RUN npm install

COPY . .

EXPOSE 3000

CMD [ "npm", "start" ]

මේ Dockerfile එකෙන් වෙන්නේ Node.js image එකක් පාවිච්චි කරලා අපේ App එකේ dependencies install කරලා, App එක container එකක් විදියට run කරන්න සූදානම් කරන එක. EXPOSE 3000 කියන්නේ App එක 3000 port එකෙන් listen කරනවා කියන එක. Elastic Beanstalk විසින් මේ port එකට traffic redirect කරනවා.

Elastic Beanstalk CLI Setup (eb cli setup)

ඔයාගේ terminal එකේ මේ command එක ගහලා EB CLI install කරගන්න. Python pip පාවිච්චි කරනවා:

pip install awsebcli --upgrade --user

ඉන් පස්සේ aws configure ගහලා ඔයාගේ AWS credentials configure කරගන්න. මේකෙන් තමයි EB CLI එකට ඔයාගේ AWS account එකට access කරන්න පුළුවන් වෙන්නේ. ඔයාට Access Key ID සහ Secret Access Key එක AWS Console එකේ IAM (Identity and Access Management) section එකෙන් ලබාගන්න පුළුවන්. Region එකත් නිවැරදිව දෙන්න මතක තියාගන්න.

Project එක Initialize කරමු (Initialize the Project)

ඔයාගේ App එක තියෙන folder එක ඇතුලේ ඉඳන් මේ command එක ගහන්න:

eb init -p docker -r us-east-1 my-docker-app

• -p docker: අපේ platform එක Docker කියලා කියනවා.
• -r us-east-1: අපි deploy කරන AWS Region එක (ඔයාලට ඕන Region එකක් තෝරගන්න පුළුවන්, us-east-1 කියන්නේ North Virginia).
• my-docker-app: මේක තමයි අපේ application එකට දෙන නම.

මේක run කරාම ඔයාට Environment name එකක්, SSH key pair එකක් තෝරන්න කියයි. Enter ඔබාගෙන ගියාම default values ටික ගන්න පුළුවන්. (SSH key pair එක වැදගත් වෙන්නේ EC2 instance එකට SSH කරන්න ඕන වුණොත්). මේකෙන් .elasticbeanstalk කියලා folder එකක් හැදිලා ඒ ඇතුලේ config file එකක් හැදෙනවා.

Environment එක Create කරමු (Create the Environment)

දැන් අපි අපේ App එකට අවශ්‍ය Environment එක create කරමු. මේකෙන් තමයි EC2 instances, Load Balancer, Security Groups වගේ දේවල් create වෙන්නේ. මේ process එකට විනාඩි කිහිපයක් ගතවෙන්න පුළුවන්.

eb create my-docker-app-env

my-docker-app-env කියන්නේ අපේ environment එකට දෙන නම. මේක deploy වෙන්න විනාඩි කිහිපයක් යයි. ඉවසීමෙන් ඉන්න! deployment එක ඉවර වුණාම ඔයාට URL එකක් ලැබෙයි. ඔයාට eb status ගහලා deployment එකේ progress එක බලන්නත් පුළුවන්.

App එක Deploy කරමු (Deploy the App)

Environment එක හැදුවට පස්සේ, අපේ App එක deploy කරන්න පුළුවන්. ඔයාගේ project folder එකේ ඉඳන් මේ command එක ගහන්න:

eb deploy

මේකෙන් වෙන්නේ ඔයාගේ App එකේ code එක zip කරලා Elastic Beanstalk වලට යවලා, ඒක අලුත් version එකක් විදියට deploy කරන එක. Dockerfile එක තියෙන නිසා, Elastic Beanstalk විසින් Docker image එක build කරලා run කරනවා. Deployment එක සාර්ථක වුණාම, ඔයාගේ App එක live වෙලා තියෙන්න ඕනේ. eb open ගහලා ඔයාගේ App එක browser එකේ open කරගන්නත් පුළුවන්.

Log බලමු සහ Debug කරමු (View Logs and Debug)

අපේ App එකේ මොනවා හරි අවුලක් ආවොත්, logs බලන එක ගොඩක් වැදගත්. Elastic Beanstalk වල logs බලන්න ගොඩක් ලේසියි.

eb logs

මේකෙන් ඔයාගේ App එකේ server logs ඔයාට terminal එකේ බලාගන්න පුළුවන්. ඊට අමතරව AWS Console එකේ Elastic Beanstalk Dashboard එකට ගිහින් Environment එකේ "Logs" section එකෙන් සම්පූර්ණ logs බාගන්නත් පුළුවන්. eb ssh ගහලා ඔයාට කෙලින්ම EC2 instance එකට SSH කරලා, files inspect කරන්නත් පුළුවන්. ඒක debug කරන්න ගොඩක් ප්‍රයෝජනවත්.

Environment එක ඉවත් කරමු (Terminate the Environment)

වැඩේ ඉවර වුණාට පස්සේ, නැත්නම් ඔයාට මේ Environment එක තවදුරටත් ඕනේ නැත්නම්, වියදම් අඩු කරගන්න අමතක නොකර Environment එක terminate කරන්න. මේකෙන් ඒ Environment එකට අදාල හැම AWS resource එකක්ම delete වෙනවා. මතක තියාගන්න, terminate කරාට පස්සේ ඔයාගේ data නැවත ලබාගන්න බැරි වෙන්න පුළුවන්, ඒ නිසා production environments delete කරද්දී පරිස්සම් වෙන්න.

eb terminate

මේක ගහලා Yes දුන්නාම ටික වෙලාවකින් ඔයාගේ environment එක delete වෙලා යයි.

වැදගත් Tips සහ Best Practices

දැන් අපි Dockerize කරපු App එකක් Elastic Beanstalk එකට deploy කරන්නේ කොහොමද කියලා බැලුවානේ. හැබැයි මේක තව ටිකක් optimize කරගන්න සහ production environment එකකට ගැලපෙන විදියට හදාගන්න පුළුවන් tricks ටිකකුත් තියෙනවා.

Environment Variables

ඔයාගේ App එකට database connection strings, API keys වගේ sensitive information ඕන වෙනවනේ. මේවා code එක ඇතුලේ hardcode නොකර environment variables විදියට දාන එක තමයි හොඳම practice එක. Elastic Beanstalk වලදී මේක කරන්න පුළුවන්. ඔයාට පුළුවන් Elastic Beanstalk Console එකෙන් Environment Properties වලට ගිහින් variables add කරන්න. නැත්නම් .ebextensions folder එකක් හදලා YAML/JSON config files දාලා ඒක කරන්නත් පුළුවන්. මේකෙන් ඔයාගේ code base එක clean වෙනවා වගේම, security එකත් වැඩි වෙනවා.

Database එක්ක සම්බන්ධ කරගන්න හැටි (Connecting with Database)

ගොඩක් applications වලට database එකක් ඕනේ වෙනවා. Elastic Beanstalk එකත් එක්කම RDS (Relational Database Service) instance එකක් create කරන්න පුළුවන්. eb create කරද්දී database option එක enable කරන්න පුළුවන්. නැත්නම් වෙනම RDS instance එකක් හදලා ඒක connect කරන්නත් පුළුවන්. මතක තියාගන්න, production environment එකකට නම් database එක වෙනම RDS instance එකක් විදියට තියාගන්න එක තමයි හොඳම solution එක. එතකොට ඔයාට database backups, replication, monitoring වගේ දේවල් RDS හරහා පහසුවෙන් manage කරන්න පුළුවන්. මේකෙන් App එකේ scalability එකටත් direct impact එකක් එනවා.

CI/CD Pipeline

අපි මේ manual විදියට eb deploy කරාට, real-world projects වලදී අපි CI/CD pipeline එකක් පාවිච්චි කරනවා. Code commit කරාම 자동으로 build වෙලා, test වෙලා, deploy වෙන විදියට මේක configure කරන්න පුළුවන්. AWS CodePipeline, AWS CodeBuild, GitHub Actions, Jenkins වගේ services මේකට පාවිච්චි කරන්න පුළුවන්. මේකෙන් අපේ deployment process එක automatic වෙනවා වගේම, human error ඇතිවෙන එකත් අඩු වෙනවා. නිතරම deploy කරන්න පුළුවන් වීම, Continuous Delivery වලට අත්‍යවශ්‍ය දෙයක්.

වියදම් අඩු කරගමු (Cost Optimization)

AWS කියන්නේ pay-as-you-go service එකක්නේ. ඉතින් අපි පාවිච්චි කරන resources වලට තමයි සල්ලි යන්නේ. App එකක් deploy කරාට පස්සේ, ඒක Idle වෙලාවේදීත් සල්ලි යනවා. Test environments වලදී, වැඩේ ඉවර වුණාම eb terminate කරලා Environment එක terminate කරන්න අමතක කරන්න එපා. Production environments වලදී, Auto Scaling Group එක properly configure කරලා, අවශ්‍යතාවය අනුව scale කරන්න පුළුවන් විදියට හදාගන්න. තව EC2 instance types තෝරද්දී, App එකට ගැලපෙනම instance type එක තෝරගන්නත් මතක තියාගන්න. T-series instances වගේ ඒවා test environments වලට ගොඩක් effective. ඒ වගේම CloudWatch Monitoring වලින් වියදම් ගැන අවධානයෙන් ඉන්න එකත් ගොඩක් වැදගත්.

නිගමනය

ඉතින් යාලුවනේ, ඔයාලට දැන් පැහැදිලි ඇති Dockerize කරපු App එකක් AWS Elastic Beanstalk එකට deploy කරන එක කොච්චර ලේසිද කියලා. මේකෙන් අපේ deployment process එක සරල වෙනවා වගේම, time එකත් ගොඩක් ඉතුරු වෙනවා. අපිට පුළුවන් අපේ core business logic එක develop කරන එකට විතරක් අවධානය දෙන්න. Server management, patching, scaling, load balancing වගේ හැම බරක්ම AWS බලාගන්නවා.

ඔයාලත් අනිවාර්යෙන්ම මේක try කරලා බලන්න. පොඩි App එකක් හදලා deploy කරලා බලන්න. මොනවා හරි ප්‍රශ්නයක් ආවොත්, නැත්නම් මේ ගැන ඔයාලගේ අදහස්, අත්දැකීම් තියෙනවා නම් පහළින් comment කරන්න අමතක කරන්න එපා. තවත් මේ වගේ වැදගත් Tech Article එකකින් හම්බවෙමු! ජය වේවා!