Sign in Subscribe
By Thisara Priyamal in Docker Compose —

Docker Compose Basics Sinhala Guide | Multi-Container Apps | Sri Lanka Tech

Docker Compose Basics Sinhala Guide | Multi-Container Apps | Sri Lanka Tech

ආයුබෝවන්, Docker Compose ලෝකයට!

ආයුබෝවන් යාළුවනේ! කොහොමද ඉතින්? අද අපි කතා කරන්න යන්නේ අපේ software development ජීවිතේ ගොඩක් ලේසි කරන, ඒ වගේම production deployments වලටත් අත්‍යවශ්‍ය tool එකක් ගැන. ඒ තමයි Docker Compose. Docker කියන්නේ containers හරහා applications ධාවනය කරන්න පුළුවන් සුපිරි tool එකක් කියලා ඔයාලා දන්නවා ඇති. හැබැයි අපි applications හදනකොට එක container එකක් විතරක් පාවිච්චි කරන්නේ නෑනේ? Web server එකට එකක්, database එකට තව එකක්, caching වලට තවත් එකක් වගේ containers ගොඩක් එකට වැඩ කරන්න ඕන වෙනවා.

ඒ හැම container එකක්ම වෙන වෙනම docker run commands වලින් ධාවනය කරන එක එපා වෙන වැඩක්. ඒ වගේම ඒ අතර සම්බන්ධතාවය හදලා දෙන එකත් ගේමක්. Docker Compose එතනට තමයි එන්නේ! මේකෙන් පුළුවන් multi-container Docker applications ටිකක් එක YAML file එකක් ඇතුළේ define කරලා, එක command එකකින් ඒ ඔක්කොම start කරන්න, stop කරන්න, manage කරන්න.

අද මේ guide එකෙන් අපි බලමු:

  • Docker Compose කියන්නේ මොකද්ද?
  • docker-compose.yml file එකේ මූලික syntax එක.
  • Services, Networks, Volumes කියන්නේ මොනවද කියලා.
  • Commands වගේම docker-compose up සහ docker-compose down පාවිච්චි කරන හැටි.
  • Services scale කරන හැටි සහ environment variables භාවිතය.
  • docker-compose.override.yml file එකේ වැදගත්කම.

ඉතින් අපි පටන් ගමු! Laptop එක ලඟ තියාගෙනම මේ examples ටික try කරන්න අමතක කරන්න එපා හොඳේ.

Docker Compose කියන්නේ මොකද්ද?

සරලව කිව්වොත්, Docker Compose කියන්නේ multi-container Docker applications වලට defining කරලා running කරන්න පුළුවන් tool එකක්. ඒක පාවිච්චි කරන්නේ YAML file එකක්. ඒ file එක ඇතුළේ අපි අපේ application එකට ඕන කරන services (ඒ කියන්නේ containers), networks (containers එකිනෙකා අතර කතා කරන විදිහ) සහ volumes (දත්ත ගබඩා කරන හැටි) ගැන ලියනවා. ඊට පස්සේ එක command එකක් ගැහුවම ඒ ඔක්කොම ටික Docker එකේ set up වෙලා, එකට වැඩ කරන්න පටන් ගන්නවා.

හිතන්න ඔයා web application එකක් හදනවා කියලා. ඒකට web server (Nginx), application code (Node.js/Python), database (PostgreSQL/MySQL), caching layer (Redis) වගේ දේවල් ඕන වෙන්න පුළුවන්. මේ හැම එකක්ම වෙන වෙනම containers. Docker Compose නැතිනම් මේ හැම එකක්ම වෙන වෙනම run කරන්න, link කරන්න, ports හදන්න ගිහින් ජීවිතේම එපා වෙනවා. Compose එකෙන් මේ ඔක්කොම ටික එකම තැනකට ගේනවා.

docker-compose.yml ගොනුව තේරුම් ගනිමු

Docker Compose වල හදවත තමයි docker-compose.yml file එක. මේක YAML (Yet Another Markup Language) syntax එකට ලියපු configuration file එකක්. YAML කියන්නේ කියවන්න ලේසි data serialization format එකක්. මේක spaces (indentation) වලට ගොඩක් සංවේදී නිසා ලියනකොට පරිස්සම් වෙන්න ඕන.

මූලික YAML syntax

  • Key-Value Pairs: key: value (name: John Doe)
  • Lists/Arrays: hyphen එකකින් (- item1)
  • Nested Structures: indentation (spaces) වලින් (service: ports: - "80:80")

docker-compose.yml වල ප්‍රධාන අංග

සාමාන්‍යයෙන් docker-compose.yml file එකක් මෙන්න මේ වගේ sections වලින් හැදිලා තියෙනවා:

  • version: Compose file format එකේ version එක. (දැනට '3.8' වගේ latest එක පාවිච්චි කරන එක හොඳයි.)
  • services: අපේ application එකට ඕන කරන containers (services) මෙතන define කරනවා.
  • networks: services අතර කතාබහට ඕන කරන networks.
  • volumes: containers වල දත්ත ස්ථිරව තියාගන්න.

උදාහරණයක්: සරල Web Application එකක්

අපි Nginx web server එකක් සහ Redis caching layer එකක් තියෙන සරල application එකක් හදමු. මේකට static HTML file එකක් Nginx වලින් serve කරන්න හදමු.

  1. මුලින්ම project folder එකක් හදන්න: mkdir my-compose-app && cd my-compose-app
  2. ඒ ඇතුළේ nginx කියලා folder එකක් හදලා ඒක ඇතුළේ html කියලා තව folder එකක් හදන්න.
  3. nginx/html folder එක ඇතුළේ index.html කියලා file එකක් හදලා මේ code එක දාන්න:
<!-- nginx/html/index.html -->
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Docker Compose Test</title>
</head>
<body>
    <h1>ආයුබෝවන්, Docker Compose ලෝකයට!</h1>
    <p>This is a simple Nginx container running via Docker Compose.</p>
    <p>අපේ Sri Lankan developersලාට Docker Compose පුරුදු වෙන්න හොඳ තැනක්!</p>
</body>
</html>
  1. ඊට පස්සේ project root folder එකේ docker-compose.yml කියලා file එකක් හදලා මේ code එක දාන්න:
# docker-compose.yml
version: '3.8'

services:
  web:
    image: nginx:latest
    ports:
      - "80:80" # Host port 80 map to container port 80
    volumes:
      - ./nginx/html:/usr/share/nginx/html # Mount our local html folder to nginx's default html folder
    networks:
      - app-network

  redis:
    image: redis:latest
    networks:
      - app-network

networks:
  app-network:
    driver: bridge # default network driver

මේ YAML file එකෙන් අපි Nginx web server එක web කියලා service එකක් විදිහටත්, Redis server එක redis කියලා service එකක් විදිහටත් define කරලා තියෙනවා. ඒ වගේම ඒ දෙන්නාටම app-network කියලා custom network එකක් දීලා තියෙනවා එකිනෙකා අතර communicate කරන්න.

Docker Compose Services පාලනය කරමු (`docker-compose up` සහ `docker-compose down`)

docker-compose.yml file එක හැදුවට පස්සේ අපිට පුළුවන් එක command එකකින් ඒ services ටික run කරන්න. අපි බලමු ප්‍රධාන commands ටිකක්:

docker-compose up

මේ command එකෙන් configuration file එකේ තියෙන services ටික build කරලා, create කරලා, start කරනවා. මේක project folder එක ඇතුළේ ඉඳන් run කරන්න ඕන. (අපේ my-compose-app folder එක ඇතුළේ)

docker-compose up

මේක ගැහුවම logs ඔක්කොම terminal එකේම පෙන්වනවා. terminal එක වහනකම් containers run වෙනවා. අපිට ඕන නම් background එකේ run කරන්න -d (detached mode) flag එක පාවිච්චි කරන්න පුළුවන්:

docker-compose up -d

දැන් ඔයාට පුළුවන් browser එකේ http://localhost වලට ගිහින් අපේ Nginx web server එක වැඩද කියලා බලන්න. index.html file එකේ content එක එන්න ඕන.

docker-compose ps

මේ command එකෙන් project එකේ running services මොනවද කියලා බලාගන්න පුළුවන්:

docker-compose ps

අපිට web සහ redis services දෙකම Up කියලා පෙන්නන්න ඕන.

docker-compose logs

ඕනම service එකක logs බලන්න මේ command එක පාවිච්චි කරන්න පුළුවන්:

docker-compose logs web # web service එකේ logs
docker-compose logs redis # redis service එකේ logs

සියලුම services වල logs බලන්න service name එකක් නොදී docker-compose logs විතරක් run කරන්න.

docker-compose down

අපේ application එකේ වැඩ ඉවර වුණාම running services නවත්තලා, containers, networks ඔක්කොම අයින් කරන්න මේ command එක පාවිච්චි කරන්න පුළුවන්:

docker-compose down

මේකෙන් containers සහ networks අයින් කරනවා. හැබැයි volumes අයින් කරන්නේ නෑ. volumes සදහටම අයින් කරන්න ඕන නම් --volumes flag එක පාවිච්චි කරන්න:

docker-compose down --volumes

දැන් ඔයාට http://localhost ගියාම Nginx web page එක පෙන්නන්නේ නෑ. මොකද services ටික stopped.

Services Scale කිරීම සහ Environment Variables භාවිතය

Services Scale කිරීම

අපේ application එකට requests වැඩි වෙනකොට අපිට පුළුවන් එකම service එකේ instances (copies) කිහිපයක් එකවර run කරන්න. මේකට කියන්නේ scaling කියලා. Docker Compose වලින් මේක ලේසියෙන් කරන්න පුළුවන්:

docker-compose up -d --scale web=3

මේ command එකෙන් web service එකේ instances 3ක් run කරනවා. docker-compose ps ගහලා බැලුවොත් ඔයාට Nginx containers 3ක් running කියලා පෙන්නයි. docker-compose scale command එක deprecated වෙලා දැන් up --scale පාවිච්චි කරන්නේ.

Environment Variables භාවිතය

අපේ applications වල database credentials, API keys වගේ සංවේදී දත්ත හෝ configuration settings තියෙන්න පුළුවන්. මේවා docker-compose.yml file එක ඇතුළේ කෙලින්ම ලියන එක හොඳ පුරුද්දක් නෙවෙයි. ඒ වෙනුවට environment variables පාවිච්චි කරන්න පුළුවන්.

ක්‍රම 1: docker-compose.yml ඇතුළේ

අපිට environment block එක පාවිච්චි කරලා service එකකට environment variables යවන්න පුළුවන්:

services:
  db:
    image: postgres:latest
    environment:
      POSTGRES_USER: myuser
      POSTGRES_PASSWORD: mysecretpassword # මෙහෙම කෙලින්ම ලියන එක එච්චර හොඳ නෑ
      POSTGRES_DB: mydb
    networks:
      - app-network

ක්‍රම 2: .env file එකක් හරහා (නිර්දේශිතයි!)

වඩාත් හොඳ ක්‍රමය තමයි project root folder එකේ .env කියලා file එකක් හදලා ඒක ඇතුළේ variables දාන එක. Docker Compose විසින් මේ file එක automatically load කරගන්නවා.

  1. Project root folder එකේ .env කියලා file එකක් හදන්න:
# .env
DB_USER=myuser
DB_PASSWORD=supersecretpassword123
  1. දැන් docker-compose.yml file එකේ මේ variables පාවිච්චි කරන්න පුළුවන් ${VARIABLE_NAME} syntax එකෙන්:
# docker-compose.yml (updated with db service and .env variables)
version: '3.8'

services:
  web:
    image: nginx:latest
    ports:
      - "80:80"
    volumes:
      - ./nginx/html:/usr/share/nginx/html
    networks:
      - app-network

  redis:
    image: redis:latest
    networks:
      - app-network

  db:
    image: postgres:latest
    environment:
      POSTGRES_USER: ${DB_USER}
      POSTGRES_PASSWORD: ${DB_PASSWORD} # .env file එකෙන් values ගන්නවා
      POSTGRES_DB: mydb
    networks:
      - app-network
    volumes:
      - db_data:/var/lib/postgresql/data # persistent data storage for db

networks:
  app-network:
    driver: bridge

volumes:
  db_data: # Define the named volume

දැන් docker-compose up -d run කරාම db service එක .env file එකේ තියෙන values එක්ක start වෙනවා. මේක security අතින් වගේම configuration management අතින් ගොඩක් වැදගත්.

docker-compose.override.yml භාවිතය

බොහෝ වෙලාවට අපිට development environment එකටයි, production environment එකටයි වෙනස් configurations ඕන වෙනවා. උදාහරණයක් විදිහට, development වලදී port එක වෙනස් වෙන්න පුළුවන්, debugging tools එකතු කරන්න පුළුවන්, නැත්නම් development-only services (මොක් API සර්වර් එකක් වගේ) එකතු කරන්න පුළුවන්.

මේ වෙනස්කම් docker-compose.yml file එක ඇතුළේම කරන්න ගියොත් ඒක අවුල් වෙන්න පුළුවන්. මේකට Docker Compose අපිට docker-compose.override.yml කියලා file එකක් හදන්න අවස්ථාව දෙනවා.

Docker Compose විසින් docker-compose.yml සහ docker-compose.override.yml files දෙකම project root folder එකේ තිබ්බොත් ඒ දෙකම එකට merge කරලා execute කරනවා. override file එකේ තියෙන settings, main file එකේ තියෙන settings overwrite කරනවා.

උදාහරණයක්: Development වලදී Port එක වෙනස් කිරීම

  1. Project root folder එකේ docker-compose.override.yml කියලා file එකක් හදලා මේ code එක දාන්න:
# docker-compose.override.yml
version: '3.8'

services:
  web:
    ports:
      - "8080:80" # Web service එකේ port එක 8080 ට වෙනස් කරනවා
    environment:
      DEBUG_MODE: "true" # Development environment එකට debug mode on කරනවා
  
  # Development වලට විතරක් ඕන වෙන service එකක් (e.g., mock API server)
  dev-mock-api:
    image: node:alpine
    working_dir: /app
    command: sh -c "npm install && npm start"
    volumes:
      - ./dev_mock_api:/app
    networks:
      - app-network
    ports:
      - "3000:3000"

දැන් ඔයා docker-compose up -d run කරාම automatically docker-compose.yml සහ docker-compose.override.yml files දෙකම merge වෙලා run වෙනවා. ඒ කියන්නේ web service එක දැන් 80:80 වෙනුවට 8080:80 port එකෙන් expose වෙනවා. ඒ වගේම අලුත් dev-mock-api service එකත් start වෙනවා.

මේකෙන් අපිට පුළුවන් development environment එකයි, production environment එකයි අතර configurations ලේසියෙන් manage කරන්න.

නිගමනය (Conclusion)

ඉතින් යාළුවනේ, මේ guide එකෙන් අපි Docker Compose වල මූලිකාංග ගැන කතා කළා. Multi-container Docker applications manage කරන එකට Docker Compose කියන්නේ නියම විසඳුමක්. YAML syntax එක තේරුම් අරගෙන, services, networks, volumes හරියට define කරන්න පුළුවන් නම්, ඔයාගේ development workflow එක ගොඩක් වේගවත් කරගන්න පුළුවන්. ඒ වගේම production deployments වලදීත් consistency එකක් තියාගන්න පුළුවන්.

අපි මේ tutorial එකෙන්:

  • Docker Compose වල වැදගත්කම.
  • docker-compose.yml file එකේ structure එක.
  • docker-compose up, down, ps වගේ commands.
  • Services scale කරන හැටි.
  • Environment variables භාවිතය (විශේෂයෙන් .env file එක).
  • docker-compose.override.yml file එකේ ප්‍රයෝජන.

ගැන ඉගෙන ගත්තා. දැන් ඔයාට පුළුවන් මේ දැනුම පාවිච්චි කරලා ඔයාගේම multi-container applications හදන්න පටන් ගන්න. මතක තියාගන්න, practice කරන තරමට තමයි ඕනම දෙයක් හොඳට පුළුවන් වෙන්නේ. ඒ නිසා මේ examples ටික ඔයාගේ machine එකේම try කරන්න. වෙනස්කම් කරලා බලන්න. එතකොට තමයි concepts හොඳට ඔළුවට යන්නේ.

ඔයා Docker Compose පාවිච්චි කරලා තියෙනවද? නැත්නම් මේ guide එකෙන් මොනවද අලුතින් ඉගෙන ගත්තේ? ඔයාගේ අත්දැකීම් පහළ comment section එකේ අපිත් එක්ක බෙදාගන්න. මේ වගේ තවත් Sinhala tech guides ඕන නම් අපිට කියන්න!

මීළඟ tutorial එකකින් හමුවෙමු! ගිහින් එන්නම්!

Previous

Next.js Vercel Deploy | පහසුම ක්‍රමය | Sinhala Guide

 Next

Docker Compose Advanced | Multi-Environment, Health Checks, Secrets | Sinhala Guide

You might also like...