Docker என்றால் என்ன, மேலும் டெவெலப்பர்கள் அதை ஏன் கற்க வேண்டும்?

Docker தொடர்ந்து வேலை விளம்பரங்களிலும் setup வழிகாட்டிகளிலும் வெளிவருகிறது, மேலும் நீங்கள் containers ஐ ஒருபோதும் தொட்டிருக்கவில்லை என்றால் இது உண்மையான குறியீடு எழுத அனுமதிக்கப்படுவதற்கு முன் ஏற ஓர் சுவரைப் போல் உணர்வதற்கு பாடுபடலாம். சொல்லகராதியைத் தாண்டிச் சென்றவுடன் இது அত்தளவு சிக்கலானதல்ல.

ஒரு container உண்மையில் என்ன

ஒரு container உங்கள் பயன்பாட்டை அது இயங்குவதற்கு தேவையான எல்லாவற்றுடன் பேக் செய்கிறது: குறியீடு, runtime, system libraries, மற்றும் config கோப்புகள். இது virtual machine அல்ல. ஒரு VM முழு operating system ஐ virtualize செய்கிறது, kernel உட்பட, இதன் பொருள் ஒன்றை boot செய்வதற்கு ஒரு நிமிடம் எடுக்கலாம் மற்றும் சில gigabytes RAM ஐ உட்கொள்ளலாம். ஒரு container host machine ன் kernel ஐ பகிர்ந்து கொள்கிறது மற்றும் செயல்முறையை மட்டুமே தனிமைப்படுத்துகிறது, எனவே இது ஒரு வினாடியில் குறைவாக தொடங்குகிறது மற்றும் பொதுவாக gigabytes க்கு பதிலாக tens of megabytes ஐ பயன்படுத்துகிறது.

Docker உள்ளூர் development மற்றும் CI pipelines ஐ எত்தனை வேகமாக கைப்பற்றியது என்பதற்கான காரணம் இந்த வேறுபாட்டுதான். நீங்கள் ஒரு Postgres database, ஒரு Redis cache, மற்றும் உங்கள் app server ஐ ஒரு laptop இல் உங்கள் OS ல் நேரடியாக நிறுவாமல் spin up செய்யலாம்.

நீங்கள் தெரிந்து கொள்ள வேண்டிய முக்கிய பகுதிகள்

நான்கு சொற்கள் உள்ளன, அவை நீங்கள் நாளுக்கு நாள் எதிர்கொள்ளும் பெரும்பாலான விஷயங்களை உள்ளடக்குகின்றன:

• Image: ஒரு Dockerfile இலிருந்து கட்டப்பட்ட read-only template. இதை ஒரு filesystem ன் snapshot மற்றும் அதை எவ்வாறு இயக்குவது என்பதற்கான metadata ஆக கருதுங்கள்.
• Container: ஒரு image ன் இயங்கும் instance. நீங்கள் அவை வந்த image க்கு தொடுவாமல் containers ஐ தொடங்கலாம், நிறுத்தலாம், மற்றும் நீக்கலாம்.
• Dockerfile: ஒரு image ஐ கட்டுவதற்கான வரி வரி வழிமுறைகள் கொண்ட text file.
• Registry: images பேக் செய்யப்பட்ட மற்றும் pull செய்யப்பட்ட இடம், பெரும்பாலும் Docker Hub.

ஒரு Node.js app க்கான minimal Dockerfile இதுபோல் இருக்கிறது:

FROM node:20-alpine
WORKDIR /app
COPY package*.json ./
RUN npm ci
COPY . .
EXPOSE 3000
CMD ["node", "server.js"]

இதை docker build -t my-app . உடன் build செய்து docker run -p 3000:3000 my-app உடன் இயக்கவும். -p flag உங்கள் machine ல் ஒரு port ஐ container உள்ளே ஒரு port க்கு map செய்கிறது, இதுவே நீங்கள் உங்கள் browser இலிருந்து app ற்கு நிஜமாக அடைந்து செல்வதற்கான வழி.

நீங்கள் தொடர்ந்து பயன்படுத்தும் கட்டளைகள்

ஒரு handful of commands பெரும்பாலான दैनिक work ஐ உள்ளடக்குகிறது:

• docker ps — running containers ஐ list செய்யவும்
• docker ps -a — stopped ones உட்பட, அனைத்து containers ஐ list செய்யவும்
• docker images — உங்கள் machine ல் images ஐ list செய்யவும்
• docker logs <container> — running அல்லது crashed container இலிருந்து output ஐ check செய்யவும்
• docker exec -it <container> sh — running container உள்ளே ஒரு shell ஐ திறக்கவும்
• docker rm / docker rmi — நீங்கள் இனி தேவைப்படாத containers மற்றும் images ஐ clean up செய்யவும்

ஆ கடைசி pair மக்கள் எதிர்பார்க்கும் அதைவிட அதிகமாக முக்கியமானது. Docker மகிழ்ச்சியுடன் disk space ஐ old images மற்றும் stopped containers ல் மறைந்து செல்ல கொடுக்கும். docker system prune ஐ அவ்வப்போது இயக்குவது ஆச்சரியமான அளவு space ஐ reclaim செய்கிறது.

docker-compose வேலைப்பாய்வை எப்படி மாற்றுகிறது

பெரும்பாலான உண்மையான projects க்கு ஒன்றிற்கு அதிகமான containers தேவை: ஒரு app server, ஒரு database, ஒருவேளை ஒரு cache. ஒவ்வொன்றுக்கும் docker run கட்டளைகளை எழுதுவது விரைவாக பழையதாகிவிடும். docker-compose.yml உங்களுக்கு முழு stack ஐ ஒரு file ல் define செய்ய அனுமதிக்கிறது:

services:
  web:
    build: .
    ports:
      - "3000:3000"
    depends_on:
      - db
  db:
    image: postgres:16
    environment:
      POSTGRES_PASSWORD: devpassword
    volumes:
      - db_data:/var/lib/postgresql/data

volumes:
  db_data:

docker compose up ஐ இயக்கவும், இரண்டு services ஒன்றாக தொடங்குகின்றன, networked எனவே web service name மூலம் db க்கு அடைய முடியும். இது ஏறக்குறைய எல்லா open-source repo ன் README ல் நீங்கள் பார்க்கும் setup ஆகும், மற்றும் இதைப் புரிந்துகொள்வது அர்த்தம் நீங்கள் ஒரு project ஐ clone செய்து Postgres, Redis, மற்றும் app தேவைப்படும் வேறு எதையாவது manually install செய்வதற்கு பதிலாக minutes ல் running இல் இருக்க முடியும்.

மக்கள் ஆரம்பத்தில் எங்கே சிக்குகிறார்கள்

Volumes ஏறக்குறைய அனைவரையும் முதலில் குழப்புகிறது. ஒரு volume இல்லாமல், container உள்ளே எழுதப்பட்ட எதுவும் container நீக்கப்பட்டாலும் மறைந்து விடும், இது databases க்கு ஒரு பிரச்சனை. மேலே உள்ள compose file இல் volumes section ஒரு named volume ஐ container உள்ளே ஒரு path க்கு map செய்கிறது எனவே data restarts சுரக்ஷிதமாக இருக்கிறது.

Another common mistake .dockerignore file இல்லாதபோது node_modules அல்லது .git ஐ image ல் copy செய்வது. ஒரு .gitignore போல் ஒன்றைச் சேர்க்கவும்:

node_modules
.git
.env

இது builds வேகமாக வைத்திருக்கிறது மற்றும் images சிறியவை, இது நீங்கள் images ஐ registry க்கு push செய்யும் அல்லது Kubernetes க்கு deploy செய்யும் முறை முக்கியமாகிறது.

Basics ன் பிறகு எங்கே செல்வது

building மற்றும் running containers உணர்வதற்கு சாதாரணமாக இருந்தவுடன், அடுத்த useful skills smaller production images க்கான multi-stage builds, Docker networking modes ஐ புரிந்துகொள்வது, மற்றும் something சரியாக connecting இல்லாதபோது ஒரு docker inspect output ஐ படிப்பது. இவற்றில் எதுவும் கடினமல்ல, இது முதல் முறை அதிருகிறது.

உண்மையான applications ஐ containerize செய்வது மற்றும் அவற்றை cloud deployment pipelines க்கு connecting செய்வது பற்றிய மேலும் விவரங்களுக்கு, Korra Studio க்கான DevOps மற்றும் Cloud segments ஐ check செய்யவும்.