Docker Images සහ Containers ගැඹුරින් - සිංහල මාර්ගෝපදේශය

හෙලෝ යාලුවනේ! ඩෙවොලොපර් කෙනෙක් විදියට ඔයාට අලුත් ප්‍රොජෙක්ට් එකක් පටන් ගන්නකොට, නැත්නම් වෙන කෙනෙක් හදපු ප්‍රොජෙක්ට් එකක් run කරන්න හදනකොට ප්‍රශ්න ගොඩකට මුහුණ දෙන්න වෙනවා නේද? "මගේ මැෂින් එකේ වැඩ කරනවා, එයාගේ මැෂින් එකේ වැඩ කරන්නේ නෑ!" කියන කතාව අපි හැමෝම අහලා ඇති. Database එකක් install කරන්න ඕන, Node.js version එකක් match වෙන්න ඕන, Python dependency එකක් අවුල්... මේ වගේ දේවල් නිසා කාලය නාස්ති වෙච්ච වාර අනන්තයි.

මේකට තමයි Docker කියන සුපිරි ටූල් එක එන්නේ! Docker කියන්නේ අපේ ඇප්ලිකේෂන්ස් (applications) ඒවාට අවශ්‍ය හැම dependency එකක්ම එක්ක පොඩි, isolated පරිසරයක (isolated environment) run කරන්න පුළුවන් කරන platform එකක්. ඒක හරියට ඔයාගේ ඇප්ලිකේෂන් එක වෙනම පෙට්ටියක දාලා, ඒ පෙට්ටිය ඕනම තැනක ගෙනියන්න පුළුවන් වගේ වැඩක්. කොතන run කළත්, ඒ පෙට්ටිය ඇතුළේ ඇප්ලිකේෂන් එකට අවශ්‍ය හැමදේම තියෙන නිසා කිසිම අවුලක් නෑ.

අද මේ ගයිඩ් එකෙන් අපි Docker වල හදවත වන Images සහ Containers ගැන ගැඹුරින් කතා කරමු. මොනවද මේ Image කියන්නේ, Container කියන්නේ මොනවද, ඒවා එකිනෙකට සම්බන්ධ වෙන්නේ කොහොමද, Images සහ Containers වල ජීවන චක්‍රය (lifecycle) මොකක්ද, ඒවට පාවිච්චි කරන වැදගත් Docker commands මොනවද කියලා අපි පියවරෙන් පියවර බලමු. මේ tutorial එක ඉවර වෙනකොට ඔයාට Docker ගැන හොඳ අවබෝධයක් ලැබිලා, ඔයාගේම ඇප්ලිකේෂන්ස් Dockerize කරන්න පුළුවන් වෙයි!

1. Docker Images - ඔබේ යෙදුමේ Blueprint එක

Docker Images ගැන කතා කරනකොට, හිතන්නකෝ ඔයා ගෙයක් හදන්න යනවා කියලා. ගේ හදන්න කලින් ඔයාට ගේක ප්ලෑන් එකක් (blueprint) ඕනනේ. ඒ ප්ලෑන් එකේ තියෙනවා ගේ කොහොමද හදන්නේ, බිත්ති කොහෙද, දොරවල් ජනෙල් කොහෙද වගේ හැම විස්තරයක්ම. ඒ වගේම තමයි Docker Image එකක් කියන්නේ අපේ ඇප්ලිකේෂන් එක run කරන්න ඕන කරන හැමදේම තියෙන read-only template එකක්. මේක අපේ ඇප්ලිකේෂන් එකේ blueprint එක වගේ.

• ඇයි මේ Image එකක්? Image එකක අපේ code එක, runtime (Node.js, Python, Java වගේ), libraries, dependencies, environment variables, සහ application එක run කරන්න අවශ්‍ය වෙන අනිත් හැම file එකක්ම තියෙනවා. මේක හැමදාම එකම විදියට තියෙනවා. ඒ කියන්නේ, ඔයා Image එකක් හදලා ඒක publish කළාට පස්සේ, කවුරු ඒක පාවිච්චි කළත්, ඒක හැමවිටම එකම විදියට run වෙනවා.
• Read-only: මතක තියාගන්න, Image එකක් කියන්නේ read-only template එකක්. ඔයාට ඒක modify කරන්න බෑ, ඒකෙන් Container එකක් හදලා run කරනකොට තමයි ඒක active වෙන්නේ.

Image Layers: Docker වල සුපිරිම දේ

මේක තමයි Docker වල තියෙන ලොකුම සුපිරිම දේකින් එකක්. Docker Image එකක් කියන්නේ තනි විශාල file එකක් නෙවෙයි. ඒක එක උඩ එකට තියපු layers ගොඩකින් හැදිලා තියෙන්නේ. මේ layers එකිනෙකට වෙනස් වෙනස් commands වලින් හැදිලා තියෙනවා. උදාහරණයක් විදියට:

• පහළම layer එකේ තියෙන්න පුළුවන් OS එකක් (e.g., Ubuntu).
• ඊට උඩින් තවත් layer එකක Node.js install කරලා තියෙන්න පුළුවන්.
• ඊටත් උඩින් layer එකක ඔයාගේ ඇප්ලිකේෂන් එකේ code එක add කරලා තියෙන්න පුළුවන්.
• අන්තිම layer එකේ CMD command එක තියෙන්න පුළුවන්.

මේ layers වල තියෙන වාසිය මොකක්ද? imagine කරන්න ඔයාට එකම Node.js version එකක් පාවිච්චි කරන applications 10ක් තියෙනවා කියලා. සාමාන්‍යයෙන් ඔයාට ඒ හැම ඇප්ලිකේෂන් එකකටම Node.js install කරන්න වෙනවා. හැබැයි Docker වලදී, ඔයාට එක පාරක් Node.js layer එක download කරලා, ඒක ඔයාගේ ඇප්ලිකේෂන්ස් 10ටම share කරන්න පුළුවන්. මේකෙන් disk space එක ඉතිරි වෙනවා වගේම, Image build කරන එකත් වේගවත් වෙනවා. මොකද, layer එකක් වෙනස් වුණොත්, Docker build කරන්නේ ඒ layer එක සහ ඊට උඩින් තියෙන layers ටික විතරයි.

Base Images: ඔබේ ගොඩනැගිල්ලට අත්තිවාරම

ඕනම Image එකක් හදද්දි අපිට Base Image එකක් තෝරගන්න වෙනවා. මේක තමයි අපේ ඇප්ලිකේෂන් එකට අත්තිවාරම වගේ. ජනප්‍රිය Base Images කිහිපයක් තමයි:

• ubuntu, alpine (කුඩා, light-weight OS images)
• node, python, java (විශේෂිත runtimes සහිත images)
• nginx, apache (web server images)

අපි මේවා Docker Hub වගේ official image registries වලින් download කරගන්නවා. අපි පස්සේ බලමු මේවා කොහොමද download කරගන්නේ කියලා.

2. Docker Containers - Images වල Live Instances

Image එක Blueprint එක නම්, Docker Container එකක් කියන්නේ Image එකක runnable instance එකක්. ඒ කියන්නේ, ගේ ප්ලෑන් එකෙන් හදපු ගොඩනැගිල්ල වගේ. Image එක static, read-only වුණත්, Container එක dynamic, writable පරිසරයක්. අපි Image එකකින් Container එකක් run කළාම, ඒක වෙනම process එකක් විදියට අපේ OS එකේ run වෙනවා. ඒ Container එකට තමන්ගේම file system එකක්, network interface එකක්, සහ process ID space එකක් තියෙනවා.

• Isolation: Container එකක ලොකුම වාසිය තමයි isolation එක. හැම Container එකක්ම තමන්ටම වෙන් වුණු, අනෙක් Containers වලට බලපෑමක් නැති පරිසරයක තමයි run වෙන්නේ. ඒක හරියට ඔයාගේ පරිගණකය ඇතුළේ වෙනම කුඩා පරිගණක ගොඩක් run වෙනවා වගේ. මේකෙන් අපේ ඇප්ලිකේෂන්ස් අතර ගැටුම් ඇතිවෙන එක වලක්වනවා.
• Ephemeral (අස්ථිර): සාමාන්‍යයෙන් Containers ephemeral. ඒ කියන්නේ Container එකක් stop කරලා delete කළාම, ඒක ඇතුළේ තිබ්බ හැම data එකක්ම නැතිවෙලා යනවා. හැබැයි මේකට විසඳුම් තියෙනවා (e.g., Volumes), ඒ ගැන අපි තවත් tutorial එකකින් කතා කරමු.

සරලව කිව්වොත්,

• Image: ඇප්ලිකේෂන් එක run කරන්න අවශ්‍ය සියලු දේ අඩංගු පැකේජ් එකක් (static).
• Container: ඒ Image එක active වෙලා run වෙන තත්වය (dynamic).

3. Docker Images Lifecycle - Images Manage කරමු

Docker Images එක්ක වැඩ කරන්න අපිට වැදගත් commands ගොඩක් තියෙනවා. අපි මේවා පියවරෙන් පියවර බලමු.

docker pull: Images Download කරගැනීම

අපිට Image එකක් අවශ්‍ය වුණාම Docker Hub වගේ Registry එකකින් (ඔන්ලයින් store එකක් වගේ) ඒක අපේ ලෝකල් මැෂින් එකට ගන්න පුළුවන්. මේකට අපි docker pull command එක පාවිච්චි කරනවා.

docker pull ubuntu:latest

මේ command එකෙන් Docker Hub එකෙන් ubuntu Image එකේ latest Tag එක සහිත version එක download කරනවා. latest කියන්නේ සාමාන්‍යයෙන් අලුත්ම version එකට දෙන default tag එක. හැබැයි හොඳම practice එක තමයි ubuntu:22.04 වගේ specific version එකක් mention කරන එක, මොකද latest එක ඕන වෙලාවක වෙනස් වෙන්න පුළුවන්.

docker push: Images Publish කිරීම

ඔයාගේම Image එකක් හදලා අනිත් අයට පාවිච්චි කරන්න දෙන්න ඕන නම්, නැත්නම් ඔයාගේම team එක ඇතුළේ share කරන්න ඕන නම්, ඔයාට පුළුවන් ඒ Image එක Registry එකකට push කරන්න. මේකට ඔයා මුලින්ම Image එකට tag එකක් දාන්න ඕන, ඒ tag එකේ ඔයාගේ Registry username එක තියෙන්න ඕන.

docker tag my-app-image:1.0 yourusername/my-app:1.0
docker push yourusername/my-app:1.0

මේකෙන් my-app-image:1.0 කියන අපේ local image එකට yourusername/my-app:1.0 කියන tag එක දාලා, ඒක Docker Hub එකට push කරනවා.

docker rmi: Images Remove කිරීම

අපිට තවදුරටත් අවශ්‍ය නැති Images remove කරන්න docker rmi (remove image) command එක පාවිච්චි කරනවා. මේකෙන් අපේ hard drive space එක ඉතිරි කරගන්න පුළුවන්.

docker rmi ubuntu:latest
# නැත්නම් Image ID එක පාවිච්චි කරන්න පුළුවන්
docker rmi a1b2c3d4e5f6

docker images: Download කර ඇති Images බැලීම

ඔයාගේ local මැෂින් එකේ තියෙන හැම Image එකක්ම බලන්න docker images command එක පාවිච්චි කරන්න පුළුවන්.

docker images

මේකෙන් Image එකේ REPOSITORY, TAG, IMAGE ID, CREATED date එක, සහ SIZE එක වගේ විස්තර බලාගන්න පුළුවන්.

docker inspect image_id: Image විස්තර පරීක්ෂා කිරීම

යම්කිසි Image එකක් ගැන ගැඹුරු විස්තර දැනගන්න ඕන නම් (layers, config, environment variables, history වගේ) docker inspect command එක පාවිච්චි කරන්න.

docker inspect ubuntu:latest

මේකෙන් JSON format එකෙන් ගොඩක් විස්තර පෙන්නනවා.

4. Docker Containers Lifecycle - Containers පාලනය කරමු

Images පාවිච්චි කරලා Containers හදලා run කරන එක තමයි Docker වල මූලිකම ක්‍රියාකාරිත්වය. අපි බලමු මේකට පාවිච්චි කරන commands මොනවද කියලා.

docker run: Container එකක් හදලා Run කිරීම

Image එකකින් Container එකක් හදලා run කරන්න docker run command එක පාවිච්චි කරනවා. මේක තමයි Docker වල වැඩිපුරම පාවිච්චි වෙන command එක.

docker run -d -p 80:80 --name my-nginx-container nginx

මේ command එක තේරුම් ගමු:

• docker run: Container එකක් run කරන්න කියලා Docker engine එකට කියනවා.
• -d (detach mode): Container එක background එකේ run කරන්න කියනවා. නැත්නම් command line එක block වෙනවා.
• -p 80:80 (port mapping): Host මැෂින් එකේ Port 80 එක Container එකේ Port 80 එකට map කරනවා. ඒ කියන්නේ, ඔයාගේ බ්‍රවුසර් එකේ localhost:80 කියලා ගැහුවොත් Container එක ඇතුළේ run වෙන Nginx web server එකට access කරන්න පුළුවන්.
• --name my-nginx-container: Container එකට my-nginx-container කියලා නමක් දෙනවා. නමක් දුන්නේ නැත්නම් Docker එකෙන් random නමක් දෙනවා.
• nginx: මේ command එක run කරන්න ඕන Image එක. (Nginx Image එක local එකේ නැත්නම්, Docker ඒක auto pull කරනවා).

මේ command එකෙන් අපි Nginx web server එකක් run කරනවා. දැන් ඔයාට පුළුවන් http://localhost කියන URL එකට ගිහින් Nginx welcome page එක බලන්න.

docker start: Stop කරපු Container එකක් Start කිරීම

Stop කරපු Container එකක් ආයෙත් පටන් ගන්න docker start command එක පාවිච්චි කරනවා.

docker start my-nginx-container

docker stop: Container එකක් Stop කිරීම

Running Container එකක් gracefully නවත්තන්න (ඇතුළේ run වෙන processes වලට ඉවර වෙන්න කාලය දීලා) docker stop command එක පාවිච්චි කරනවා.

docker stop my-nginx-container

docker rm: Container එකක් Remove කිරීම

නැවත අවශ්‍ය නැති Container එකක් remove කරන්න docker rm (remove container) command එක පාවිච්චි කරනවා. මතක තියාගන්න, Container එකක් remove කරන්න කලින් ඒක stop කරන්න ඕන.

docker rm my-nginx-container

docker ps: Running Containers බැලීම

දැනට run වෙන Containers බලන්න docker ps command එක පාවිච්චි කරන්න පුළුවන්. හැම Container එකක්ම බලන්න (run වෙන ඒවා සහ stop කරලා තියෙන ඒවා) -a flag එක පාවිච්චි කරන්න.

docker ps
# සියලුම Containers බලන්න
docker ps -a

මේකෙන් CONTAINER ID, IMAGE, COMMAND, CREATED, STATUS, PORTS, සහ NAMES වගේ විස්තර බලාගන්න පුළුවන්.

docker logs container_id: Container Logs බැලීම

Container එකක output (logs) බලන්න docker logs command එක පාවිච්චි කරන්න. මේක ඇප්ලිකේෂන් එකක errors fix කරනකොට, නැත්නම් ඒකේ වැඩ කරන විදිය බලනකොට ගොඩක් වැදගත්.

docker logs my-nginx-container
# realtime logs බලන්න
docker logs -f my-nginx-container

docker exec -it container_id bash: Running Container එකකට ඇතුල් වීම

Running Container එකක් ඇතුළට ගිහින් commands execute කරන්න docker exec command එක පාවිච්චි කරන්න පුළුවන්. මේක troubleshooting වලට ගොඩක් ප්‍රයෝජනවත්.

docker exec -it my-nginx-container bash

මේකෙන් Container එක ඇතුළේ bash shell එකක් open වෙනවා. exit කියලා ටයිප් කරලා ආපහු host මැෂින් එකට එන්න පුළුවන්.

5. Practical Use Case: Simple Web Server එකක් Dockerize කරමු

දැන් අපි ඉගෙන ගත්ත දේවල් පාවිච්චි කරලා, පොඩිම පොඩි Nginx web server එකක් Dockerize කළා. අපි ඒක තවත් ටිකක් විස්තරාත්මකව බලමු.

පියවර 1: Nginx Image එක pull කරගැනීම (නැත්නම් auto pull වෙනවා)

docker pull nginx:latest

පියවර 2: Container එක run කිරීම

docker run -d -p 8080:80 --name my-web-server nginx

මේ command එකෙන් කියන්නේ Nginx Image එකෙන් Container එකක් හදලා, ඒකට my-web-server කියලා නමක් දීලා, Host මැෂින් එකේ Port 8080 එක Container එකේ Port 80 එකට සම්බන්ධ කරන්න කියලයි. (Port 80 Host එකේ වෙන මොකක් හරි use කරන නිසා 8080 පාවිච්චි කළා.)

පියවර 3: Container එක run වෙනවද කියලා බලමු

docker ps

ඔයාට මෙතන my-web-server කියන Container එක Up කියලා පෙන්නන්න ඕන.

පියවර 4: Browser එකෙන් access කරමු

දැන් ඔයාට පුළුවන් ඔයාගේ web browser එක open කරලා http://localhost:8080 කියලා ගහලා Nginx welcome page එක බලන්න.

පියවර 5: Logs බලමු

docker logs my-web-server

ඔයාට Nginx server එකේ access logs සහ error logs මෙතනින් බලාගන්න පුළුවන්.

පියවර 6: Container එක නවත්වලා remove කරමු

docker stop my-web-server
docker rm my-web-server

දැන් ඔයා සාර්ථකව Docker Container එකක් run කරලා, ඒක manage කරලා ඉවරයි! මේක කොච්චර සරලද කියලා පේනවා නේද?

වැදගත් Tips:

• Always use specific image tags: nginx:1.21.6 වගේ specific version එකක් පාවිච්චි කරන්න, nginx:latest වෙනුවට. latest tag එක ඕන වෙලාවක වෙනස් වෙන්න පුළුවන් නිසා ඔයාගේ build එක fail වෙන්න පුළුවන්.
• Clean up unused resources: කාලෙන් කාලෙට පාවිච්චි නොකරන Docker Images, Containers, Volumes, සහ Networks remove කරන්න docker system prune command එක පාවිච්චි කරන්න. මේකෙන් disk space එක ඉතිරි කරගන්න පුළුවන්.
• Learn Dockerfile: මේ tutorial එකෙන් අපි Dockerfile ගැන ගැඹුරින් කතා නොකළත්, ඔයාගේම Images හදන්න Dockerfile කියන එක අත්‍යවශ්‍යයි. ඒ ගැනත් ඉස්සරහට tutorial එකක් ගේන්නම්.

අවසන් වශයෙන්

ඉතින් යාලුවනේ, මේ tutorial එකෙන් අපි Docker Images සහ Containers ගැන හොඳ අවබෝධයක් ලබාගත්තා කියලා මම හිතනවා. අපි බැලුවා Docker Image එකක් කියන්නේ මොකක්ද, ඒක layers වලින් හැදිලා තියෙන්නේ කොහොමද කියලා. ඊට පස්සේ Image එකකින් හදන, isolated environment එකක් වන Container එක ගැන ඉගෙන ගත්තා. ඒ වගේම Docker Images සහ Containers වල ජීවන චක්‍රය (lifecycle) සහ ඒවට පාවිච්චි කරන වැදගත් commands ගොඩක් ගැනත් අපි සාකච්ඡා කළා.

Docker වල මේ Images සහ Containers කියන මූලික සංකල්ප තේරුම් ගැනීම, ඔයාට modern software deployment, DevOps, සහ cloud native applications එක්ක වැඩ කරන්න අත්‍යවශ්‍යයි. මේකෙන් ඔයාගේ ඇප්ලිකේෂන්ස් consistently, reliably run කරන්න පුළුවන් වෙනවා විතරක් නෙවෙයි, scalability (වැඩි user පිරිසකට සපෝට් කිරීම) සහ maintainability (නඩත්තු කිරීමේ පහසුව) කියන දේවලටත් ලොකු සහයෝගයක් ලැබෙනවා.

දැන් ඔයාට පුළුවන් මේ ඉගෙන ගත්ත commands පාවිච්චි කරලා, ඔයාගේම ඇප්ලිකේෂන් එකක් Dockerize කරන්න උත්සාහ කරන්න. එහෙම කරනකොට තමයි මේ සංකල්ප ඔයාට හොඳින් තේරෙන්නේ. මොනවා හරි ප්‍රශ්න තියෙනවා නම්, පහළින් කොමෙන්ට් කරන්න. ඔයාගේ අත්දැකීම් අපිත් එක්ක බෙදාගන්නත් අමතක කරන්න එපා!

සතුටින් කෝඩ් කරමු!