Docker Dockerfile Mastery: ඔබගේ Application deploy කරන්න! | Sinhala Guide

ආයුබෝවන් යාළුවනේ! අද අපි කතා කරන්න යන්නේ software development ලෝකයේ නැතුවම බැරි දෙයක් ගැන – ඒ තමයි Docker. විශේෂයෙන්ම, Dockerfile එකක් කියන්නේ මොකක්ද, ඒක හරියටම ලියන්නේ කොහොමද, ඒ වගේම අපේ applications, efficient සහ secure විදිහට deploy කරන්න Dockerfiles වලින් උපරිම ප්‍රයෝජන ගන්නේ කොහොමද කියලා අපි ගැඹුරින් බලමු.

දැන්, ඔයා developer කෙනෙක්, DevOps engineer කෙනෙක්, නැත්නම් IT student කෙනෙක් වෙන්න පුළුවන්. ඕනෑම කෙනෙකුට තමන්ගේ application එකක්, dependency issues නැතුව, ඕනෑම පරිසරයක smoothly run වෙන්න සලස්වන්න Docker කියන්නේ රත්තරං වගේ දෙයක්. ඒ වගේම, මේක හරියටම පාවිච්චි කරන්න, Dockerfile mastery කියන්නේ අත්‍යවශ්‍ය දෙයක්.

ඉතින්, අපි මේ tutorial එකෙන්, Dockerfile එකක මූලිකාංග වලින් පටන් අරන්, multi-stage builds, .dockerignore වගේ දේවල් ගැන කතා කරලා, හොඳම practices සහ security ගැනත් අවධානය යොමු කරමු. එහෙනම්, අපි පටන් ගමු!

Dockerfile වල මූලිකාංග (Fundamentals of Dockerfile)

Dockerfile එකක් කියන්නේ, Docker image එකක් build කරන්න අවශ්‍ය instructions අඩංගු text file එකක්. හරියට recipe book එකක් වගේ. මේකේ තියෙන instructions එකින් එක run කරලා, අපිට අවශ්‍ය software එක install කරලා, dependency ටික හදලා, අපේ application එක run කරන්න පුම අවශ්‍ය පරිසරය හදාගන්නවා.

එකෙන් එක බලමු මේකේ තියෙන ප්‍රධානම instructions මොනවද කියලා:

ENTRYPOINT

මේකත් CMD වගේම තමයි, container එකක් run වුණාම execute වෙන command එක specify කරනවා. හැබැයි CMD වලට වඩා වෙනස් විදිහට, ENTRYPOINT එකක් define කරලා තිබ්බොත්, CMD එක එතකොට ENTRYPOINT එකට arguments විදිහට pass වෙනවා. Application එකේ ප්‍රධාන executable එක විදිහට මේක පාවිච්චි කරනවා.

CMD

මේකෙන් කරන්නේ, container එකක් run වුණාම default විදිහට execute වෙන්න ඕන command එක specify කරන එක. Dockerfile එකක එක CMD instruction එකක් විතරයි තියෙන්න පුළුවන්.

RUN

මේ instruction එකෙන් කරන්නේ, අපේ image එක build කරන අතරතුරදී commands execute කරන එක. Dependencies install කරන්න, directories හදන්න, files download කරන්න වගේ දේවල් වලට මේක පාවිච්චි කරනවා.

FROM

මේක තමයි Dockerfile එකක පළවෙනිම instruction එක. අපේ image එක හදන්න පාවිච්චි කරන base image එක මේකෙන් specify කරනවා. උදාහරණයක් විදිහට, FROM ubuntu:latest කියන්නේ Ubuntu OS එක base image එක විදිහට පාවිච්චි කරනවා කියන එක.

ප්‍රායෝගික උදාහරණය: මූලික Dockerfile එකක් (Basic Dockerfile Example)

අපි සරල Bash script එකක් run කරන Docker image එකක් හදමු.

# Base image එක තෝරාගැනීම
FROM ubuntu:latest

# OS packages update කරලා curl install කරමු
RUN apt-get update && apt-get install -y curl

# Simple Bash script එකක් add කරමු
COPY script.sh /app/script.sh
RUN chmod +x /app/script.sh

# Container එක start වුනාම default run වෙන්න ඕන command එක
CMD ["/app/script.sh"]

script.sh file එක මෙහෙම හදමු:

#!/bin/bash
echo "Hello from Docker!"

මේ Dockerfile එක build කරන්න:

docker build -t my-simple-app .

Image එක run කරන්න:

docker run my-simple-app

මේකෙන් "Hello from Docker!" කියලා output එකක් එන්න ඕන.

Files Add කිරීම සහ Cache Management (Adding Files and Cache Management)

අපේ local machine එකේ තියෙන files, Docker image එකට transfer කරගන්න ඕන වෙන වෙලාවල් තියෙනවා. ඒකට අපි COPY සහ ADD කියන instructions දෙක පාවිච්චි කරනවා.

ADD

මේකත් COPY වගේම තමයි, නමුත් පොඩි වෙනස්කම් දෙකක් තියෙනවා. එකක් තමයි, source එක URL එකක් නම්, ADD එකෙන් ඒක download කරනවා. අනික, compressed files (Tar, Gzip වගේ) source එකට දුන්නොත්, ADD එකෙන් ඒක automatically extract කරනවා. මේ features නිසා security සහ caching issues එන්න පුළුවන් නිසා, ADD පාවිච්චි කරද්දී කල්පනාකාරී වෙන්න.

COPY

මේකෙන් කරන්නේ, local file system එකේ තියෙන files හෝ directories, Docker image එකේ destination path එකට copy කරන එක. Simple, straight-forward, සහ recommend කරන method එක මේකයි.

.dockerignore

ඔයාට මතකද .gitignore? ඒ වගේම තමයි .dockerignore කියන්නේ. Docker image එක build කරන අතරතුරදී අපිට image එකට add කරන්න අවශ්‍ය නැති files සහ directories specify කරන්න මේක පාවිච්චි කරනවා. උදාහරණයක් විදිහට, node_modules, .git, *.log වගේ දේවල් image එකට දාලා image size එක වැඩි කරගන්න එක තේරුමක් නෑ.

ප්‍රායෝගික උදාහරණය: Node.js Application එකක් සඳහා COPY සහ .dockerignore

අපි Node.js application එකක් Dockerize කරද්දී .dockerignore පාවිච්චි කරන හැටි බලමු.

Dockerfile:

FROM node:16-alpine
WORKDIR /app
COPY package*.json ./
RUN npm install
COPY . .
CMD ["npm", "start"]

.dockerignore file එක:

node_modules
npm-debug.log
.git
.env

මේකෙන් වෙන්නේ node_modules වගේ අනවශ්‍ය files image එකට copy නොකර image size එක අඩු කරගන්න එක. ඒ වගේම, package*.json files මුලින්ම copy කරලා npm install කරන්නේ Docker cache එකෙන් උපරිම ප්‍රයෝජන ගන්න. package.json file එක වෙනස් වුනොත් විතරයි npm install command එක නැවත run වෙන්නේ.

Multi-Stage Builds – කාර්යක්ෂමතාවයට (Multi-Stage Builds – For Efficiency)

ප්‍රොඩක්ෂන් එකට deploy කරන images හැමවිටම පොඩි වෙන්න ඕන. ඒකට තමයි multi-stage builds තියෙන්නේ. මේකෙන් කරන්නේ, image එක build කරන ක්‍රියාවලිය, වෙන වෙනම stages වලට කඩලා, අන්තිම production image එකට අවශ්‍ය දේවල් විතරක් copy කරගන්න එක.

උදාහරණයක් විදිහට, ඔයාට Node.js application එකක් තියෙනවා කියමු. Build කරන්න npm install වගේ commands run කරන්න ගොඩක් build tools ඕන වෙනවා. හැබැයි, application එක run කරන්න එච්චර tools ඕන නෑ. Multi-stage build එකකදී, පළවෙනි stage එකෙන් build tools එක්ක dependencies install කරලා, දෙවෙනි stage එකට final application files විතරක් copy කරලා, lightweight image එකක් හදාගන්නවා.

ප්‍රායෝගික උදාහරණය: Node.js Application එකක් සඳහා Multi-Stage Build

# Stage 1: Build stage - dependencies install කරන්න සහ application එක build කරන්න
FROM node:16-alpine as builder

WORKDIR /app

COPY package*.json ./
RUN npm install

COPY . .
RUN npm run build # Your application's build command

# Stage 2: Production stage - run කරන්න අවශ්‍ය files විතරක් ගන්නවා
FROM node:16-alpine

WORKDIR /app

# Builder stage එකෙන් build output එක copy කරගන්නවා
COPY --from=builder /app/package*.json ./
COPY --from=builder /app/build ./build # Assuming build output is in 'build' folder

# Production dependencies විතරක් install කරන්න පුළුවන් (optional, if not included in builder)
RUN npm install --production

CMD ["node", "build/index.js"] # Adjust based on your build output and entry point

මේකෙන් වෙන්නේ, build එකට පාවිච්චි කරපු අනවශ්‍ය dependencies සහ tools, final image එකට එන්නේ නැති නිසා, image size එක සැලකිය යුතු ලෙස අඩු වෙන එක. මේකේදී --from=builder කියන එකෙන් තමයි පළමු stage එකෙන් files copy කරගන්නේ.

Dockerfile Best Practices සහ Security (Dockerfile Best Practices and Security)

හොඳ Dockerfile එකක් කියන්නේ, efficient, secure, සහ maintain කරන්න ලේසි එකක්. අපි බලමු ඒකට අනුගමනය කරන්න පුළුවන් හොඳම practices මොනවද කියලා:

Cache Busting

Dependencies install කරන RUN instruction එකට උඩින්, COPY package*.json ./ වගේ command එකක් තියන්න. මේකෙන් package files වෙනස් වුණොත් විතරක් dependency install කරන layer එක rebuild වෙනවා. අනෙක් වෙලාවට cache එකෙන් ගන්නවා. මේකෙන් build time එක අඩු වෙනවා.

Security Scanning

ඔබේ Docker images වල vulnerabilities තියෙනවද කියලා scan කරන්න Trivy, Clair, Docker Scan (Snyk powered) වගේ tools පාවිච්චි කරන්න. මේක DevOps pipeline එකේදී incorporate කරන එක අත්‍යවශ්‍යයි. මේවායින් image එකේ තියෙන packages වල known security flaws identify කරන්න පුළුවන්.

Environment Variables

Sensitive data (passwords, API keys) environment variables විදිහට Dockerfile එකේ දාන්න එපා. මොකද Docker image layers ඕනෑම කෙනෙකුට inspect කරන්න පුළුවන්. ඒ වෙනුවට Docker secrets හෝ environment variables runtime එකේදී pass කරන්න. (උදා: docker run -e MY_SECRET_KEY=your_key_here my-app)

.dockerignore Proper Use

ඉස්සර වෙලා කිව්වා වගේම, build context එකට අනවශ්‍ය files ඇතුළත් නොකරන්න. මේකෙන් build time එකත්, image size එකත් දෙකම අඩු වෙනවා. Build context එක කියන්නේ, docker build command එක run කරන directory එක.

Non-Root User

Container එක root user විදිහට run කරනවා වෙනුවට, USER instruction එකෙන් non-root user කෙනෙක් හදලා, ඒ user යටතේ application එක run කරන්න. මේක security එකට හරිම වැදගත්. මොකද, root user කෙනෙක් විදිහට run වුනොත්, container එක compromise වුණොත්, attackerට host system එකටත් access ගන්න ලේසි වෙනවා.

FROM alpine:latest
RUN adduser -D appuser # appuser නමින් non-root user කෙනෙක් හදනවා
USER appuser # ඊළඟ instructions සහ container එක appuser යටතේ run වෙනවා
CMD ["echo", "Hello as appuser"]

Minimize Layers

එක RUN instruction එකක් ඇතුළත commands කීපයක් && වලින් join කරලා run කරන්න. මොකද, Docker එකේදී හැම instruction එකකටම අලුත් layer එකක් හැදෙනවා. Layers වැඩි වෙනකොට image size එකත් වැඩි වෙනවා. උදාහරණයක්:

# Bad practice
RUN apt-get update
RUN apt-get install -y curl

# Good practice
RUN apt-get update && apt-get install -y curl && rm -rf /var/lib/apt/lists/*

අන්තිම rm -rf /var/lib/apt/lists/* එකෙන් කරන්නේ, packages download කරපු cache files delete කරලා image size එක තවත් අඩු කරන එක.

Specific Tags

FROM node:latest වගේ දේවල් පාවිච්චි කරනවා වෙනුවට, FROM node:16-alpine වගේ specific version tags පාවිච්චි කරන්න. මේකෙන් builds predictable වෙනවා. latest tag එකෙන් image එකේ version එක නොදැනීම වෙනස් වෙන්න පුළුවන්, ඒක builds break වෙන්න හේතුවක් වෙන්න පුළුවන්.

Smallest Base Image

හැකි තරම් කුඩාම base image එකක් පාවිච්චි කරන්න. alpine images මේකට හොඳ උදාහරණ. ubuntu හෝ debian වගේ images වලට වඩා alpine images පොඩියි. අඩු layers, අඩු attack surface එකක් කියන්නේ හොඳ දෙයක්.

නිගමනය (Conclusion)

ඉතින් යාළුවනේ, මේ tutorial එකෙන් අපි Dockerfile එකක් කියන්නේ මොකක්ද, ඒකේ තියෙන මූලික instruction sets, files add කරන විදිහ, multi-stage builds වලින් images optimize කරන හැටි, ඒ වගේම Dockerfile best practices සහ security considerations ගැන ගොඩක් දේවල් ඉගෙන ගත්තා.

Dockerfile mastery කියන්නේ modern software development වලට අත්‍යවශ්‍ය skillset එකක්. මේකෙන් ඔයාට clean, efficient, සහ secure containers හදන්න පුළුවන්. මතක තියාගන්න, Dockerize කරපු application එකක් ඕනෑම තැනක එක විදිහට run වෙනවා කියන එක, "build once, run anywhere" කියන concept එකේ හරයයි.

දැන් වෙලාව හරි මේ දේවල් ඔයාගේ project වලට apply කරන්න. පොඩි project එකක් හදලා මේ instructions ටික test කරලා බලන්න. මොකද, theory විතරක් මදි, practice කරන්නම ඕන!

මේ ගැන ඔයාලගේ අදහස්, ප්‍රශ්න, නැත්නම් ඔයාලා පාවිච්චි කරන tips මොනවද කියලා පහළ comment section එකේ කියන්න. අපි කතා කරමු!