Docker Images, Containers හා Layers ගැන සිංහලෙන් ඉගෙන ගන්න | Sinhala Docker Tutorial

ආයුබෝවන් developers ලා හැමෝටම!

ඉතින් කොහොමද ඔයාලට? අද අපි කතා කරන්න යන්නේ මේ දවස්වල Software Development ලෝකයේ හැමෝම වගේ කතා කරන, නැතුවම බැරි තාක්ෂණයක් ගැන. ඒ තමයි Docker! ඔයාලා මොන වගේ කෙනෙක් වුණත් – student කෙනෙක්, beginner කෙනෙක්, නැත්නම් experience තියෙන developer කෙනෙක් වුණත් – Docker කියන්නේ ඔයාලගේ career එකට ලොකු boost එකක් දෙන්න පුළුවන් tool එකක්. ඒකෙන් පුළුවන් ඔයාලගේ applications build කරන, deploy කරන, run කරන විදිය සම්පූර්ණයෙන්ම වෙනස් කරන්න.

ගොඩක් වෙලාවට අපි අහනවා නේද, “මගේ machine එකේ වැඩ කරනවා, ඒත් production එකේ වැඩ කරන්නේ නෑ!” කියලා. මේ වගේ ප්‍රශ්න වලට තියෙන නියමම විසඳුම තමයි Docker. හරියට අපි ගෙදරදී හදන කෑමක් තවත් කෙනෙක්ගේ ගෙදරදීත් ඒ විදියටම හදන්න අවශ්‍ය tools සෙට් එකක් දෙනවා වගේ. Docker වලින් වෙන්නේ ඔයාලගේ application එකයි, ඒකට අවශ්‍ය හැම dependency එකකුයි එක package එකකට දාලා, ඕනෑම තැනක එක විදියටම run කරන්න පුළුවන් වෙන එක.

මේ tutorial එකෙන් අපි Docker Images සහ Containers කියන මූලිකම සංකල්ප දෙක ගැඹුරින් තේරුම් ගන්නවා. Image Layers වල මැජික් එක, Image සහ Container lifecycle එක, ඒවා inspect කරන්නේ කොහොමද කියන දේවල් අපි practical විදියට බලමු. මේක කියවලා ඉවර වෙනකොට ඔයාලට Docker ගැන හොඳ අවබෝධයක් ලැබෙයි කියලා මම විශ්වාස කරනවා. එහෙනම් අපි පටන් ගමු!

Docker Basics: Images සහ Containers

Docker Images සහ Containers කියන්නේ Docker වල හදවත. මේ දෙක හරියට DNA සහ ඒ DNA වලින් හැදෙන ජීවියා වගේ. එකක් නැතුව අනිකට තේරුමක් නෑ.

Docker Image එකක් කියන්නේ මොකක්ද?

සරලවම කිව්වොත්, Docker Image එකක් කියන්නේ ඔයාලගේ application එක run කරන්න අවශ්‍ය වෙන හැමදේම (code, libraries, dependencies, system tools, configuration files) අඩංගු වෙන, read-only template එකක්. මේක හරියට ගොඩනැගිල්ලක blueprint එකක් වගේ. ඒක design එක විතරයි; ජීවමාන ගොඩනැගිල්ලක් නෙවෙයි.

• Immutable: Image එකක් හදපු පාරක් වෙනස් කරන්න බෑ. වෙනස් කරන්න ඕනේ නම් අලුත් Image එකක් හදන්න ඕනේ.
• Portable: ඕනෑම Docker environment එකක run කරන්න පුළුවන්.
• Lightweight: අනවශ්‍ය දේවල් අඩංගු වෙන්නේ නෑ.

Docker Container එකක් කියන්නේ මොකක්ද?

Docker Container එකක් කියන්නේ Image එකක run වෙන instance එකක්. මේක අර ගොඩනැගිල්ලේ blueprint එකෙන් හදපු, ජීවමාන, වැඩ කරන ගොඩනැගිල්ල වගේ. Container එකක් කියන්නේ isolate කරපු environment එකක්, ඒකේ ඇතුලේ තියෙන application එකට host machine එකේ අනිත් applications එක්ක ගැටලුවක් නැතුව තමන්ගේ වැඩේ කරගෙන යන්න පුළුවන්.

• Isolated: Host system එකෙන් සහ අනෙකුත් Containers වලින් සම්පූර්ණයෙන්ම වෙන් වෙලා තියෙන්නේ.
• Ephemeral: සාමාන්‍යයෙන් Container එකක් destroy කරාම ඒක ඇතුලේ කරපු වෙනස්කම් නැතිවෙලා යනවා (stateful data manage කරන්න වෙන strategies ඕනේ).
• Lightweight: Virtual Machines (VMs) වලට වඩා ගොඩක් අඩු resource ප්‍රමාණයක් තමයි භාවිතා කරන්නේ.

ඉතින්, සාරාංශයක් විදියට, Image එක තමයි blueprint එක. Container එක තමයි ඒ blueprint එකෙන් හැදෙන run වෙන object එක.

Images පිටිපස්සේ තියෙන මැජික් එක: Layers

Docker Images ගැන කතා කරනකොට, Layers කියන සංකල්පය තේරුම් ගැනීම අත්‍යවශ්‍යයි. මේක තමයි Docker Images මෙච්චර efficient සහ lightweight වෙන්න ප්‍රධානම හේතුව. කල්පනා කරනවා ඇති මොකක්ද මේ Layers කියන්නේ කියලා නේද?

Image Layers කියන්නේ මොනවද?

Docker Image එකක් කියන්නේ එක layer එකක් නෙවෙයි, එකිනෙක මත ගොඩනැගුණු read-only file system layers ගොඩක එකතුවක්. මේක හරියට transparent sheets ගොඩක් එක උඩ එක තියලා අන්තිමට සම්පූර්ණ පින්තූරයක් හැදෙනවා වගේ වැඩක්.

• Read-Only: හැම Layer එකක්ම read-only. Layer එකක් හැදුවට පස්සේ ඒක වෙනස් කරන්න බෑ.
• Caching: Docker Image එකක් build කරනකොට, හැම instruction එකකටම අලුත් Layer එකක් හැදෙනවා. මේ Layers වලට caching තියෙන නිසා, Image එකේ කොටසක් වෙනස් කළොත්, වෙනස් වුණු Layer එකට උඩින් තියෙන Layers විතරයි අලුතින් build වෙන්නේ. යටින් තියෙන unchanged Layers cache එකෙන් ගන්නවා. මේක build time එක ගොඩක් අඩු කරනවා.
• Sharing: පොදු Base Images භාවිතා කරන Images අතර Layers share කරන්න පුළුවන්. උදාහරණයක් විදියට, ඔයාගේ applications දෙකක් ubuntu Base Image එක භාවිතා කරනවා නම්, ubuntu Layer එක disk එකේ තියෙන්නේ එක සැරයක් විතරයි.

Base Images

Docker Image එකක් පටන් ගන්නේ සාමාන්‍යයෙන් Base Image එකකින්. මේවා තමයි අපේ Image Stack එකේ යටින්ම තියෙන Layers. උදාහරණ විදියට ubuntu, alpine, node, python වගේ Images ගන්න පුළුවන්. මේවා official Images, ඒ කියන්නේ Docker Hub එකේ verified publishers ලා විසින් maintain කරන ඒවා. Lightweight Base Images (e.g., alpine) භාවිතා කිරීමෙන් අපේ final Image size එක ගොඩක් අඩු කරගන්න පුළුවන්.

Layers ක්‍රියාත්මක වන ආකාරය (Practical Example)

අපි මේක Dockerfile එකකින් බලමු. Dockerfile එකක් කියන්නේ Docker Image එකක් build කරන්න අවශ්‍ය instructions අඩංගු වෙන text file එකක්.

# Base Image - මේක තමයි අපේ Image එකේ පළමු Layer එක
FROM alpine:latest

# Layer 1: Working directory එක සකසනවා
WORKDIR /app

# Layer 2: අපේ application files Image එකට copy කරනවා
COPY . /app

# Layer 3: අවශ්‍ය dependencies install කරනවා
RUN apk add --no-cache curl

# Layer 4: Application එක run වෙන port එක expose කරනවා
EXPOSE 8080

# Layer 5: Container එක start වෙනකොට run වෙන්න ඕන command එක
CMD ["curl", "google.com"]

මේ Dockerfile එකේ හැම Instruction එකක්ම අලුත් Layer එකක් හදනවා. ඔයාලා COPY line එකේ file එකක් වෙනස් කරලා ආයෙත් build කළොත්, COPY line එකේ ඉඳන් පහළට තියෙන Layers ටික විතරයි අලුතින් build වෙන්නේ, ඉහළ Layers cache එකෙන් ගන්නවා. නියමයි නේද?

Docker Image Lifecycle: Pull, Build, Push, Remove

Docker Images එක්ක වැඩ කරනකොට අපි භාවිතා කරන ප්‍රධාන Commands ටිකක් තියෙනවා. අපි ඒවා එකින් එක බලමු.

Images Download කිරීම: docker pull

අපිට Docker Hub වගේ registry එකකින් Images download කරගන්න පුළුවන්. මේකට කියන්නේ pull කරනවා කියලා.

docker pull nginx:latest

මේකෙන් වෙන්නේ nginx Image එකේ latest tag එක සහිත version එක ඔයාලගේ local machine එකට download වෙන එක.

Images Build කිරීම: docker build

අපි කලින් කතා කරපු Dockerfile එකක් භාවිතා කරලා අපේම Images හදාගන්න පුළුවන්. මේකට කියන්නේ build කරනවා කියලා.

# Dockerfile එක තියෙන directory එකේ ඉඳන් run කරන්න
docker build -t my-web-app:v1 .

• -t (tag): අපේ Image එකට නමක් සහ version එකක් දෙන්න පුළුවන්. මෙතන my-web-app කියන්නේ නම, v1 කියන්නේ tag එක.
• . (dot): Dockerfile එක තියෙන path එක පෙන්නනවා (මේ directory එකේම තියෙනවා නම් .).

Images Upload කිරීම: docker push

ඔයාලා හදන Images අනිත් අයත් එක්ක share කරන්න Docker Hub වගේ public/private registry එකකට push කරන්න පුළුවන්. ඒකට කලින් Image එකට registry username එකක් එක්ක tag කරන්න ඕනේ.

# Image එකට tag කරනවා
docker tag my-web-app:v1 yourusername/my-web-app:v1

# Image එක push කරනවා
docker push yourusername/my-web-app:v1

Images List කිරීම: docker images

ඔයාලගේ local machine එකේ තියෙන හැම Docker Image එකක්ම බලන්න පුළුවන් මේ command එකෙන්.

docker images

Images Delete කිරීම: docker rmi

අනවශ්‍ය Images remove කරන්න මේ command එක භාවිතා කරන්න පුළුවන්. මතක තියාගන්න, Image එකකින් Container එකක් run වෙනවා නම්, ඒ Container එක stop කරලා delete කරාට පස්සේ තමයි Image එක delete කරන්න පුළුවන් වෙන්නේ.

docker rmi nginx:latest

Docker Container Lifecycle: Run, Start, Stop, Remove

Images වගේම, Containers වලටත් තමන්ගේම lifecycle එකක් තියෙනවා. මේ commands තමයි අපි නිතරම භාවිතා කරන්නේ.

Container එකක් Run කිරීම: docker run

Image එකකින් Container එකක් create කරලා start කරන්න භාවිතා කරන command එක තමයි docker run. මේකෙන් Container එකක් create වෙනවා, ඊට පස්සේ ඒක start වෙනවා.

docker run -d -p 80:80 --name my-nginx-webserver nginx:latest

• -d (detach): Container එක background එකේ run කරන්න.
• -p 80:80 (publish port): Host machine එකේ port 80 එක Container එකේ port 80 එකට map කරනවා. (Host:Container)
• --name my-nginx-webserver: Container එකට නමක් දෙනවා (එහෙම නැත්නම් Docker එකෙන් random නමක් දෙනවා).
• nginx:latest: Container එක run කරන්න අවශ්‍ය Image එක.

Running Containers List කිරීම: docker ps

ඔයාලගේ machine එකේ run වෙන හැම Container එකක්ම බලන්න පුළුවන්.

docker ps

# Stopped Containers එක්ක හැම Container එකක්ම බලන්න
docker ps -a

Stopped Container එකක් Start කිරීම: docker start

docker run කරලා නැවැත්වූ (stopped) Container එකක් ආයෙත් start කරන්න පුළුවන්.

docker start my-nginx-webserver

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

Running Container එකක් gracefully stop කරන්න මේ command එක භාවිතා කරනවා. Docker වලින් application එකට stop වෙන්න signal එකක් යවනවා.

docker stop my-nginx-webserver

Container එකක් Forcefully Kill කිරීම: docker kill

docker stop එක වැඩ කරන්නේ නැත්නම්, නැත්නම් ඉක්මනින්ම Container එක නවත්වන්න ඕනේ නම්, docker kill භාවිතා කරන්න පුළුවන්. මේකෙන් straightaway Container එක නවත්වනවා.

docker kill my-nginx-webserver

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

Stop කරපු Container එකක් delete කරන්න පුළුවන්.

docker rm my-nginx-webserver

# Running Container එකක් force delete කරන්න
docker rm -f my-nginx-webserver

Container එකක් ඇතුළත Command Run කිරීම: docker exec

Running Container එකක් ඇතුළට ගිහින් commands run කරන්න පුළුවන්.

# Container එක ඇතුලේ bash shell එකක් open කරනවා
docker exec -it my-nginx-webserver /bin/bash

# Container එක ඇතුලේ command එකක් run කරනවා
docker exec my-nginx-webserver ls -la /app

• -i (interactive): interactive session එකක් enable කරනවා.
• -t (tty): pseudo-TTY එකක් allocate කරනවා (command line interface එකකට අත්‍යවශ්‍යයි).

Inspecting Docker Objects: ගවේෂණය කරමු!

Docker Images සහ Containers ගැන විස්තර දැනගන්න එකත් ගොඩක් වැදගත්. Debugging වලට වගේම system health check කරන්නත් මේ commands ප්‍රයෝජනවත් වෙනවා.

Image/Container විස්තර බලමු: docker inspect

Image එකක් හෝ Container එකක් ගැන හැම විස්තරයක්ම (network settings, volumes, environment variables, layers, etc.) JSON format එකෙන් බලන්න පුළුවන්.

# Container එකක් inspect කරන්න
docker inspect my-nginx-webserver

# Image එකක් inspect කරන්න
docker inspect nginx:latest

Container Logs බලමු: docker logs

Running Container එකක output logs බලන්න මේක භාවිතා කරනවා.

docker logs my-nginx-webserver

# Real-time logs බලන්න
docker logs -f my-nginx-webserver

Container Resource Usage බලමු: docker stats

Running Containers වල CPU, Memory, Network I/O වගේ resource usage real-time බලන්න පුළුවන්.

docker stats

නිගමනය: Docker එකෙන් වැඩේ ගොඩ දාමු!

ඉතින්, අද අපි Docker Images සහ Containers කියන මූලිකම සංකල්ප දෙක ගැඹුරින් අධ්‍යයනය කළා. Image Layers වල වැදගත්කම, Images සහ Containers වල lifecycle එක, ඒවට අදාළ commands වගේම ඒවා inspect කරන්නේ කොහොමද කියන දේත් අපි ඉගෙන ගත්තා.

දැන් ඔයාලා දන්නවා Docker එකෙන් අපේ applications කොච්චර පහසුවෙන් manage කරන්න පුළුවන්ද කියලා. Consistency, portability, efficiency කියන හැමදේම Docker එකෙන් ලැබෙනවා. “මගේ machine එකේ වැඩ කරනවා” කියන කතාවට සමුදෙන්න පුළුවන්.

මේ tutorial එකෙන් ඔයාලට Docker ගැන හොඳ ආරම්භයක් ලැබෙන්න ඇති කියලා මම හිතනවා. මෙහෙම ඉගෙන ගෙන වැඩක් නෑ, මේ commands ඔයාලගේ terminal එකේ run කරලා බලන්න. ඔයාලගේම applications වලට Dockerfile එකක් හදලා Image එකක් build කරලා, Container එකක් run කරලා බලන්න. එතකොට තමයි නියම අත්දැකීම ලැබෙන්නේ.

ඔයාලට මේ ගැන තියෙන ප්‍රශ්න, අත්දැකීම්, නැත්නම් තවත් දැනගන්න ඕනේ දේවල් comment section එකේ දාන්න. අපි ඒ ගැන කතා කරමු. මතක තියාගන්න, practice makes perfect! එහෙනම් තවත් අලුත් දෙයක් එක්ක හමුවෙමු! Happy Dockering!