முக்கிய விஷயங்கள்
- Docker image என்பது உறைந்த ஒரு snapshot; container என்பது அந்த snapshot மெமரியில் லைவாக இயங்கும் ரன்டைம் instance.
- Dockerfile எழுதும்போது dependency ஃபைல்களை முதலில் COPY செய்தால், layer caching மூலமாக build நேரம் நிமிடங்களிலிருந்து சில நொடிகளாகக் குறையும்.
- Containers இயல்பாகவே stateless; நீங்கள் volume இணைக்கவில்லை என்றால் container நின்ற அடுத்த நொடி உங்கள் database தகவல்கள் அழிந்துவிடும்.
- Docker Compose மூலம் ஒரே ஒரு ஃபைலில் உங்கள் App மற்றும் PostgreSQL டேட்டாபேஸை internal networking வசதியோடு எளிதாக இயக்க முடியும்.
சென்னை OMR-ல் இருக்கும் IT கம்பெனியாக இருந்தாலும் சரி, பெங்களூரு Outer Ring Road ஸ்டார்ட்-அப்பாக இருந்தாலும் சரி, வெள்ளிக்கிழமை ஈவினிங் ஸ்பிரிண்ட் டெமோவில் அடிக்கடி கேட்கும் ஒரு டயலாக் உண்டு: "என் லேப்டாப்ல எல்லாம் பக்காவா ஓடுச்சு ப்ரோ!". ஆனால் அதே கோடை staging சர்வருக்கு புஷ் பண்ணும்போது Node version அல்லது OS லைப்ரரி மாறி ஒட்டுமொத்த அப்ளிகேஷனும் கிராஷ் ஆகிவிடும். உங்கள் வீக்-எண்ட் ப்ளானை காலி செய்யும் இந்த தலைவலிக்கு ஒரே தீர்வு Docker மட்டும்தான்.
Docker என்பது உங்கள் அப்ளிகேஷன் கோடு, ரன்டைம் என்விரான்மென்ட், சிஸ்டம் லைப்ரரிகள் மற்றும் கான்ஃபிகரேஷன் எல்லாவற்றையும் ஒன்றாகக் கட்டி ஒரு பெட்டிக்குள் அடைத்துத் தரும் டூல். உங்கள் கோடு உங்களுடைய மேக்புக்கில் ஓடினாலும், பக்கத்து சீட் நண்பரின் லினக்ஸ் சிஸ்டத்தில் ஓடினாலும் அல்லது AWS EC2 சர்வரில் ஓடினாலும் ஒரே மாதிரிதான் வேலை செய்யும். எந்தவித பில்ட்-அப்பும் இல்லாமல் Docker-ன் முக்கிய விஷயங்களை ஆழமாகப் பார்க்கலாம்.
Docker Image-க்கும் Container-க்கும் என்ன வித்தியாசம்?
இதை மிக எளிமையாகப் புரிந்துகொள்ள object-oriented programming கான்செப்ட்டை நினைத்துப் பாருங்கள். Docker image என்பது ஒரு Class; Docker container என்பது அதிலிருந்து உருவாக்கப்படும் Object அல்லது Instance. நீங்கள் ஒருமுறை Image-ஐ பில்ட் செய்துவிட்டால், அதிலிருந்து எத்தனை கண்டெய்னர்களை வேண்டுமானாலும் நொடிகளில் உருவாக்கிக்கொள்ளலாம்.
நம் ஊர் பாணியில் சொன்னால், சூப்பர் மார்க்கெட்டில் வாங்கும் ரெடிமேட் இட்லி மாவு பாக்கெட் தான் Image. அது ஃப்ரிட்ஜில் எந்த மாற்றமும் இல்லாமல் அப்படியே இருக்கும். அதைத் திறந்து நீங்கள் தோசைக் கல்லில் ஊற்றிச் சுடும் தோசைதான் Container. அது உயிருடன் இருக்கும், சூடாக இருக்கும், சாப்பிட்டு முடித்ததும் காலி ஆகிவிடும். தொழில்நுட்ப ரீதியாகப் பார்த்தால், Image என்பது read-only அடுக்குகளால் (layers) ஆனது. நீங்கள் container-ஐ ரன் செய்யும்போது அதன் மேல் ஒரு மெல்லிய writable லேயர் உட்காரும். உங்கள் ஆப் உருவாக்கும் தற்காலிக ஃபைல்கள் எல்லாமே அந்த writable லேயரில்தான் சேமிக்கப்படும்.
ஒரு எளிய Nginx வெப் சர்வர் இமேஜை டவுன்லோட் செய்து கண்டெய்னராக இயக்க
docker run -d --name my-web-server -p 8080:80 nginx:alpine
# தற்போது இயங்கும் கண்டெய்னர்களின் பட்டியலைப் பார்க்க
docker ps
# கண்டெய்னரின் லாக்ஸை நேரடியாகப் பார்க்க
docker logs --tail 20 my-web-serverஒரு Clean Dockerfile எப்படி எழுதலாம்?
Dockerfile என்பது உங்கள் அப்ளிகேஷனுக்கான இமேஜை Docker எப்படி உருவாக்க வேண்டும் என்று சொல்லும் ஒரு ரெசிபி குறிப்பு மாதிரி. இதில் எழுதப்படும் ஒவ்வொரு வரியும் (Instruction) ஒரு புதிய லேயரை உருவாக்கும். தேவையில்லாத வரிகளை மாற்றி மாற்றி எழுதினால் இமேஜ் சைஸ் பல நூறு எம்பி எகிறிவிடும்.
ஒரு நல்ல டெவலப்பர் எப்போதும் கேச்சிங் (Caching) தத்துவத்தை சரியாகப் பயன்படுத்துவார். உங்கள் கோடில் ஒரு சிறிய எழுத்தை மாற்றினாலும் COPY . . வரிக்கு கீழே இருக்கும் எல்லாமே மறுபடியும் பில்ட் ஆகும். அதனால் அடிக்கடி மாறாத dependency ஃபைல்களை (package.json) முதலில் காப்பி செய்து இன்ஸ்டால் பண்ண வேண்டும். அதன் பிறகே அப்ளிகேஷன் கோடை காப்பி செய்ய வேண்டும். இதனால் அடுத்த முறை பில்ட் செய்யும்போது சில நொடிகளில் வேலை முடிந்துவிடும்.
லைட்வெயிட் Node.js பேஸ் இமேஜ்
FROM node:22-alpine
# ஆப் இயங்குவதற்கான டைரக்டரி
WORKDIR /usr/src/app
# டிபென்டன்சி ஃபைல்களை மட்டும் முதலில் நகலெடுக்கிறோம்
COPY package*.json ./
# ப்ரொடக்ஷன் பேக்கேஜ்களை மட்டும் இன்ஸ்டால் செய்கிறோம்
RUN npm ci --only=production
# மீதமுள்ள சோர்ஸ் கோடை இப்போது நகலெடுக்கிறோம்
COPY . .
# ஆப் இயங்கும் போர்ட் எண்
EXPOSE 3000
# கண்டெய்னர் ஸ்டார்ட் ஆகும்போது ஓட வேண்டிய கமாண்ட்
CMD ["node", "server.js"]Volumes மற்றும் Ports ஏன் ரொம்ப முக்கியம்?
Docker கண்டெய்னர்கள் அடிப்படையில் ephemeral தன்மை கொண்டவை. அதாவது ஒரு கண்டெய்னரை டெலீட் செய்தால், அதற்குள் நீங்கள் சேமித்து வைத்த டேட்டா, யூசர் அப்லோட் செய்த படங்கள் எல்லாமே அடியோடு அழிந்துவிடும். டேட்டாபேஸ் ரன் பண்ணும்போது இப்படி நடந்தால் என்னவாகும்? அந்த விபத்தைத் தடுக்கத்தான் நாம் Volumes பயன்படுத்துகிறோம்.
Volume என்பது உங்கள் கம்ப்யூட்டரின் (Host OS) ஹார்ட் டிஸ்க்கில் ஒரு ஃபோல்டரை எடுத்து, கண்டெய்னருக்குள் இருக்கும் ஃபோல்டருடன் இணைக்கும் ஒரு பிரிட்ஜ். கண்டெய்னர் கிராஷ் ஆனாலும் உங்கள் டேட்டா லேப்டாப் ஹார்ட் டிஸ்க்கில் பத்திரமாக இருக்கும். அதேபோல் Port Mapping என்பதும் ஒரு முக்கியமான பாலம். கண்டெய்னருக்குள் 3000-வது போர்ட்டில் ஆப் ஓடிக்கொண்டிருக்கும், ஆனால் உங்கள் பிரவுசரில் பார்க்க உங்கள் லேப்டாப்பின் 8080 போர்ட்டை கண்டெய்னரின் 3000 போர்ட்டுடன் -p 8080:3000 என்று மேப் செய்ய வேண்டும்.
Docker Compose வெச்சு App மற்றும் DB-யை எப்படி இணைக்கலாம்?
ஒரு ரியல்-டைம் ப்ராஜெக்ட்டில் ஆப் மட்டும் தனியாக இருக்காது. கூடவே PostgreSQL டேட்டாபேஸ், Redis cache என்று பல சர்வீஸ்கள் இருக்கும். இவை ஒவ்வொன்றுக்கும் டெர்மினலில் தனித்தனியாக நீளமான கமாண்ட்களை அடித்துக்கொண்டிருந்தால் நேரம் வீணாகும். இதை ஒரே ஃபைலில் மேனேஜ் செய்ய உதவுவதுதான் Docker Compose.
Compose-ல் நாம் சர்வீஸ்களை define செய்துவிட்டால், Docker அவற்றுக்கு இடையே ஒரு பிரத்யேக இன்டர்னல் நெட்வொர்க்கை அமைத்துக் கொடுக்கும். இதனால் உங்கள் நோட் ஜேஎஸ் ஆப் டேட்டாபேஸை அதனுடைய ஐபி அட்ரஸ் தெரியாமலேயே, postgres-db என்ற சர்வீஸ் பெயரை வைத்தே லோக்கலாக தொடர்பு கொள்ள முடியும்.
services:
web-api:
build: .
ports:
"3000:3000"
environment:
DB_HOST=postgres-dbDB_USER=myuserDB_PASSWORD=secretpass
depends_on:
postgres-db
postgres-db:
image: postgres:17-alpine
environment:
POSTGRES_USER: myuser
POSTGRES_PASSWORD: secretpass
POSTGRES_DB: main_db
volumes:
pgdata:/var/lib/postgresql/data
volumes:
pgdata:இப்போது டெர்மினலில் docker compose up -d என்று ஒரே ஒரு கமாண்ட் கொடுத்தால் போதும். உங்கள் ஆப் மற்றும் டேட்டாபேஸ் இரண்டும் பேக்கிரவுண்டில் பத்திரமாகத் தொடங்கிவிடும். ஆப் வேலை செய்து முடிந்ததும் docker compose down கொடுத்தால் கிளீனாக நின்றுவிடும்.
இந்திய ஐடி நிறுவனங்கள் மற்றும் இன்டர்வியூக்களில் இது எங்கே பயன்படுகிறது?
TCS, Infosys, Zoho முதல் Swiggy, Flipkart போன்ற பெரிய டெக் நிறுவனங்கள் வரை இன்று Docker தெரியாத பேக்-எண்ட் டெவலப்பர்களை யோசிக்கக்கூட மாட்டார்கள். இன்டர்வியூக்களில் அடிக்கடி கேட்கப்படும் ட்ரிக்கியான கேள்விகள் சில உண்டு: "Docker multi-stage build எதற்குப் பயன்படுத்துவீர்கள்?", "CMD-க்கும் ENTRYPOINT-க்கும் என்ன வித்தியாசம்?" மற்றும் "Container restart ஆனால் டேட்டா அழியாமல் இருக்க என்ன செய்வீர்கள்?". இந்த மூன்று கேள்விகளுக்கும் சரியான பதிலை நீங்கள் மேலோட்டமாகப் புரியாமல் சொல்ல முடியாது. உங்கள் ரெஸ்யூமில் Docker அனுபவத்தை ஒரு வரியில் போடுவதற்குப் பதிலாக, லோக்கல் டெவலப்மென்ட்டில் Compose வழியாக DB மற்றும் Redis-ஐ எப்படி செட் செய்தீர்கள் என்று விவரித்தால் நிச்சயம் கூடுதல் மதிப்பு கிடைக்கும்.
டெவலப்பர்கள் பண்ற பொதுவான தப்புகள் என்னென்ன?
முதல் தப்பு, .dockerignore ஃபைலை உருவாக்காமல் விடுவது. Git-க்கு .gitignore போல Docker-க்கு .dockerignore ரொம்ப முக்கியம். இதை நீங்கள் போடவில்லை என்றால் உங்கள் லேப்டாப்பில் இருக்கும் பல நூறு எம்பி node_modules ஃபோல்டரும் சேர்த்து இமேஜுக்குள் காப்பி ஆகி இமேஜ் சைஸ் ஜிபி கணக்கில் வீங்கிவிடும்.
இரண்டாவது தப்பு, கண்டெய்னரை ரூட் (Root) யூசராகவே இயக்குவது. ப்ரொடக்ஷனில் இது பெரிய செக்யூரிட்டி ஓட்டை. உங்கள் Dockerfile-ல் ஒரு நான்-ரூட் யூசரை (USER node) உருவாக்குவது எப்போதும் பாதுகாப்பானது. மூன்றாவது தப்பு, பாஸ்வேர்டுகள் மற்றும் API Keys போன்ற சீக்ரெட்களை Dockerfile-லேயே ஹார்ட்கோட் செய்து வைப்பது. இமேஜை யாருக்கு அனுப்பினாலும் உங்கள் ரகசியங்கள் அம்பலமாகிவிடும்; இவற்றை எப்போதும் environment variables வழியாகவே உள்ளே அனுப்ப வேண்டும்.
நீங்க இப்போ செய்து பார்க்க வேண்டிய ஒரு சின்ன டாஸ்க்
தியரியை மட்டும் படித்துவிட்டு மூடி வைக்காதீர்கள். உங்கள் மெஷினில் Docker Desktop அல்லது Docker Engine இருக்கிறதா என்று உறுதி செய்துகொள்ளுங்கள். இப்போது உங்கள் டெர்மினலைத் திறந்து பின்வரும் டாஸ்க்கை செய்து பாருங்கள்:
ஒரு ஃபோல்டரில் எளிய index.html ஃபைலை உருவாக்குங்கள். அங்கே ஒரு Dockerfile எழுதி, பேஸ் இமேஜாக nginx:alpine பயன்படுத்தி, உங்கள் html ஃபைலை Nginx-ன் default ஃபோல்டருக்கு (/usr/share/nginx/html) நகலெடுங்கள். பிறகு docker build -t my-first-web . கொடுத்து இமேஜை பில்ட் செய்து, உங்கள் பிரவுசரில் போர்ட் 8080-ல் ரன் செய்து பாருங்கள். திரையில் உங்கள் வெப் பேஜ் தோன்றிவிட்டால், வாழ்த்துகள்! நீங்கள் Docker உலகிற்குள் வெற்றிகரமாக நுழைந்துவிட்டீர்கள்.
கருத்துகள் (0)
Be the first to comment!