JavaScript Full-stackDocker Compose: ko'p servisli stack
JavaScript Full-stack · 33-qism. Linux, server, Docker

Docker Compose: ko'p servisli stack

20 daqiqa32/38-dars

Qisqacha: Docker Compose — bir nechta konteynerni bitta YAML faylda (compose.yaml) yozib, bitta buyruq bilan boshqarish vositasi: docker compose up -d. Faylda har servisning image'i yoki build'i, muhit o'zgaruvchilari, volume'lari, tarmog'i va ishga tushish tartibi (depends_on) bor. Kurs tajribasida vazifalar ning yetti servisi 32 soniyada ko'tarildi. Ikki xatoni ham o'z boshimizdan o'tkazdik. Terminalda eksport qilingan o'zgaruvchi .env dagidan ustun chiqdi va API ishga tushmadi. Ortiqcha TRUST_PROXY qiymati esa soxta mijoz IP'sini logga yozdirdi.

Bu darsda

  • compose.yaml ni o'qiysiz va yozasiz: services, build va image, environment, env_file, volumes, networks, depends_on.
  • Servislarni to'g'ri tartibda ko'tarasiz: sog'liq, bir martalik migratsiya, keyin API va web.
  • Sirlarni .env da saqlaysiz va ${VAR:?} bilan majburiy qilasiz.
  • Interpolatsiya ustuvorligini bilasiz: terminal o'zgaruvchisi .env dan ustun.
  • X-Forwarded-For zanjirida TRUST_PROXY nechta bo'lishi kerakligini hisoblaysiz.
  • up, ps, logs, exec, config, down buyruqlari bilan ishlaysiz.

Oldin bilishingiz kerak: Docker tarmoqlari, Volume va bind mount, YAML, TOML, INI va .env, Reverse proxy.

1. Nega bu kerak?

vazifalar ni oddiy docker run bilan ko'tarishni tasavvur qiling. Avval tarmoq yaratiladi, keyin ikki volume. Postgres va Redis parollar bilan ishga tushadi. Baza tayyor bo'lishini kutib, migratsiya o'tkaziladi. Keyin API va ishchi ko'tariladi va API sog'lom bo'lishi kutiladi. Oxirida web porti bilan. Har biri — uzun buyruq, o'nlab bayroq. Bitta bayroq unutilsa yoki tartib buzilsa — stack ishlamaydi. Ertaga serverda hammasini qaytadan terish kerak.

Compose bu ro'yxatni faylga aylantiradi. Fayl — "nima bo'lishi kerak" degan tavsif. "Qanday qilish"ni Compose o'zi hal qiladi: tarmoq va volume yaratadi, image'larni yig'adi, servislarni to'g'ri tartibda ko'taradi. Fayl repoda turadi va lokalda ham, serverda ham bir xil ishlaydi.

O'xshatish: orkestr partiturasi. Har cholg'uchi (servis) o'z qismini biladi, partitura (fayl) esa kim qachon kirishini belgilaydi. Dirijyor — Compose.

2. Fayl tuzilishi

Kurs tajribasidagi compose.yaml, ko'rsatmalar aynan. Izohlar qisqartirilgan, loyiha va image nomlari almashtirilgan (vazifalar):

yaml
name: vazifalar

x-api: &api
  image: ${API_IMAGE:-vazifalar-api:4.1.0}
  build:
    context: .
  env_file: .env
  environment: &api-env
    NODE_ENV: ${NODE_ENV:-production}
    HOST: 0.0.0.0
    PORT: "3000"
    SAQLASH: prisma
    DATABASE_URL: postgres://vazifalar_api:${API_DB_PAROL:?API_DB_PAROL kerak}@db:5432/vazifalar
    AUTH_DATABASE_URL: postgres://vazifalar_auth:${AUTH_DB_PAROL:?AUTH_DB_PAROL kerak}@db:5432/vazifalar
    REDIS_URL: redis://:${REDIS_PAROL:?REDIS_PAROL kerak}@redis:6379
    # haqiqiy proxy'lar soni: lokal 1 (web nginx), serverda 2
    TRUST_PROXY: ${TRUST_PROXY:-1}
    # sinov pochtasi: Mailpit STARTTLS bilan
    SMTP_HOST: ${SMTP_HOST:-pochta}
    SMTP_PORT: ${SMTP_PORT:-1025}
    NODE_EXTRA_CA_CERTS: ${NODE_EXTRA_CA_CERTS:-/tls/pochta/sert.pem}
  volumes:
    - ./tls/pochta/sert.pem:/tls/pochta/sert.pem:ro
  networks: [ichki]

services:
  db:
    image: pgvector/pgvector:0.8.7-pg18-trixie
    environment:
      POSTGRES_PASSWORD: ${POSTGRES_PAROL:?POSTGRES_PAROL kerak}
      POSTGRES_DB: vazifalar
      TZ: UTC
    volumes:
      - db-data:/var/lib/postgresql
    shm_size: 256m
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U postgres -d vazifalar"]
      interval: 5s
      timeout: 3s
      retries: 20
    networks: [ichki]

  redis:
    image: redis:8.8.4
    command: ["redis-server", "--appendonly", "yes", "--requirepass", "${REDIS_PAROL:?REDIS_PAROL kerak}"]
    volumes:
      - redis-data:/data
    healthcheck:
      test: ["CMD-SHELL", "redis-cli -a \"$$REDIS_PAROL\" --no-auth-warning ping | grep -q PONG"]
      interval: 5s
      timeout: 3s
      retries: 20
    environment:
      REDIS_PAROL: ${REDIS_PAROL}
    networks: [ichki]

  # bir martalik: migratsiyalar va rollarga parol
  migratsiya:
    <<: *api
    command: ["sh", "-c", "node node_modules/prisma/build/index.js migrate deploy && node scripts/rol-parollari.mjs"]
    environment:
      DATABASE_URL: postgres://postgres:${POSTGRES_PAROL}@db:5432/vazifalar
      API_DB_PAROL: ${API_DB_PAROL}
      AUTH_DB_PAROL: ${AUTH_DB_PAROL}
      ISHCHI_DB_PAROL: ${ISHCHI_DB_PAROL:?ISHCHI_DB_PAROL kerak}
    env_file: []
    depends_on:
      db: { condition: service_healthy }
    restart: "no"

  api:
    <<: *api
    depends_on:
      migratsiya: { condition: service_completed_successfully }
      redis: { condition: service_healthy }

  ishchi:
    <<: *api
    command: ["node", "dist/ishchi.js"]
    environment:
      <<: *api-env
      ISHCHI_DATABASE_URL: postgres://vazifalar_ishchi:${ISHCHI_DB_PAROL}@db:5432/vazifalar
    depends_on:
      migratsiya: { condition: service_completed_successfully }
      redis: { condition: service_healthy }
    healthcheck:
      disable: true

  web:
    image: ${WEB_IMAGE:-vazifalar-web:12.1.0}
    build:
      context: ../vazifalar
      args:
        VITE_API_URL: /v1
    ports:
      - "127.0.0.1:${WEB_PORT:-4780}:8080"
    depends_on:
      api: { condition: service_healthy }
    networks: [ichki]

  pochta:
    image: axllent/mailpit:v1.33.0
    command: ["--smtp-tls-cert", "/tls/sert.pem", "--smtp-tls-key", "/tls/kalit.pem", "--smtp-require-starttls"]
    volumes:
      - ./tls/pochta:/tls:ro
    networks: [ichki]

volumes:
  db-data:
  redis-data:

networks:
  ichki:

Uzun qatorlar bo'linmadi: YAML'da ularni bo'lish qiymatni o'zgartirib yuborishi mumkin. Telefonda gorizontal suring.

Yuqori daraja to'rt qism:

  • name — loyiha nomi. Konteynerlar vazifalar-api-1, tarmoq vazifalar_ichki, volume vazifalar_db-data bo'lib nomlanadi. Bir serverda ikki loyiha bo'lsa, nomlar to'qnashmaydi.
  • services — konteynerlar. Har kalit (db, api) — servis nomi va ichki DNS'dagi nomi (Docker tarmoqlari).
  • volumes — nomli volume'lar (Volume va bind mount).
  • networks — tarmoqlar; bizda bitta, ichki.

Faylda ${API_IMAGE:-vazifalar-api:4.1.0} kabi joylar bor. Compose ishga tushirishdan oldin ularni o'zgaruvchi qiymati bilan almashtiradi. Bu almashtirish interpolatsiya deyiladi. Qiymat qayerdan olinishi va uning tuzoqlari — «Sirlar: .env» bo'limida.

3. Servislar

3.1 x-api va YAML langarlari

api, ishchi va migratsiya bitta image'dan ishlaydi va sozlamalarining ko'pi umumiy. Uch marta takrorlamaslik uchun YAML langari (anchor) ishlatilgan (YAML):

  • x-api: &api — blokka api nomli langar qo'yiladi. x- bilan boshlangan kalitni Compose servis deb hisoblamaydi.
  • <<: *api — shu blokni servisga qo'shadi. Servisda yozilgan kalit (command, environment) langardagisini almashtiradi.
  • <<: *api-env (ishchi'da) — environment almashtirilmasdan, to'ldirilishi uchun: umumiy o'zgaruvchilar va ustiga ISHCHI_DATABASE_URL.

3.2 build va image

x-api da ikkalasi bor. build.context: . — image shu papkadagi Dockerfile'dan yig'iladi. image: vazifalar-api:4.1.0 — yig'ilgan image'ga beriladigan nom. Serverda oldindan yig'ilgan image bo'lsa, build ishlatilmaydi va image shu nom bilan olinadi.

web boshqa papkadan yig'iladi: context: ../vazifalar, ya'ni vazifalar-api va vazifalar papkalari yonma-yon turadi. args — Dockerfile'dagi ARG VITE_API_URL ga qiymat (Multi-stage build).

3.3 environment va env_file

  • env_file: .env — fayldagi hamma qator konteyner muhitiga o'tadi: ILOVA_SIRI, CORS_ORIGINS va boshqalar.
  • environment — aniq qiymatlar. Ikkalasida bir xil kalit bo'lsa, environment ustun.

migratsiya da env_file: [] — langardan kelgan .env olib tashlangan. Migratsiyaga ilova sirlari kerak emas, unga faqat superuser ulanishi va rol parollari beriladi.

3.4 db va redis

  • db — Postgres 18 va pgvector. Ma'lumot db-data volume'ida. Yo'l — /var/lib/postgresql, eski /var/lib/postgresql/data emas (Volume va bind mount darsidagi PG18 tuzog'i).
  • shm_size: 256m — Postgres umumiy xotirasi uchun. Docker'ning sukut 64 MB'i katta so'rovlarda yetmasligi mumkin (hujjat bo'yicha).
  • healthcheck — pg_isready baza ulanish qabul qilayotganini tekshiradi.
  • redis — parol bilan (--requirepass) va diskka yozish bilan (--appendonly yes). Sog'liq tekshiruvidagi $$REDIS_PAROL da ikkita $: Compose bitta $ ni o'zgaruvchi deb o'qiydi, $$ esa haqiqiy $ beradi. Natijada o'zgaruvchini konteyner ichidagi shell o'qiydi.

Ikkalasida ham ports yo'q — ular faqat ichki tarmoqda.

3.5 migratsiya: bir martalik servis

Bu servis ishlab turmaydi. U migratsiyalarni o'tkazadi va chiqadi. Kod 0 bo'lsa — muvaffaqiyat. Ikki buyruq bajaradi:

  1. prisma migrate deploy — 27 ta migratsiya (Prisma prodakshnda).
  2. scripts/rol-parollari.mjs — ilova rollariga (vazifalar_api, vazifalar_auth, vazifalar_ishchi) parol qo'yadi.

Ikkinchisi nega kerak? Migratsiyalar rollarni parolsiz yaratadi: lokal Postgres'da ular parolsiz kirardi. Docker'dagi Postgres esa tarmoqdan kelgan ulanishdan parol so'raydi. Skript parollarni .env dan oladi, 16 belgidan qisqasini rad etadi va qiymatni logga chiqarmaydi.

3.6 depends_on: kim kimni kutadi

depends_on faqat tartibni emas, shartni ham beradi:

  • service_healthy — o'sha servis sog'liq tekshiruvidan o'tguncha kutadi;
  • service_completed_successfully — o'sha servis kod 0 bilan tugaguncha kutadi;
  • service_started (sukut) — faqat ishga tushganini kutadi.
flowchart LR
  D["db"] -- healthy --> M["migratsiya"]
  M -- "kod 0" --> A["api"]
  M -- "kod 0" --> I["ishchi"]
  R["redis"] -- healthy --> A
  R -- healthy --> I
  A -- healthy --> W["web"]

web nega api ning sog'ligini kutadi? Sababi web ichidagi nginx'da. U proxy_pass dagi nomni ishga tushishdayoq IP'ga aylantiradi (Docker tarmoqlari). Agar api hali yo'q bo'lsa, nginx nomni topa olmaydi. API sog'lig'ini esa Dockerfile'dagi HEALTHCHECK beradi (Dockerfile best practices). ishchi da tekshiruv o'chirilgan (disable: true): u HTTP port tinglamaydi.

pochta hech kimni kutmaydi va uni ham hech kim kutmaydi. API pochtaga faqat xat yuborishda ulanadi.

3.7 web va uning nginx'i

web — yagona nashr qilingan servis: 127.0.0.1:4780 → konteynerning 8080 i. ${WEB_PORT:-4780} — port .env dan o'zgartirilishi mumkin. Web image ichidagi nginx sozlamasi (vazifalar/docker/nginx.conf) ikki ish qiladi: statik fayllarni beradi va /v1/ ni API'ga uzatadi. Uzatish qismi (izoh qatori olib tashlangan):

nginx
location /v1/ {
    proxy_pass http://api:3000;
    proxy_http_version 1.1;
    proxy_set_header Connection "";
    proxy_set_header Host $host;
    proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
    proxy_set_header X-Forwarded-Proto $http_x_forwarded_proto;
    proxy_read_timeout 1h;
    proxy_buffering off;
}
  • proxy_pass http://api:3000 — servis nomi bilan.
  • $proxy_add_x_forwarded_for — kelgan X-Forwarded-For ga qo'shadi, almashtirmaydi. Bu tafsilot quyidagi ikkinchi xatoda hal qiluvchi bo'ladi.
  • proxy_read_timeout 1h va proxy_buffering off — uzoq ochiq turadigan SSE ulanishlari uchun (Reverse proxy).

To'liq fayl (statik fayllar, kesh sarlavhalari, SPA) Reverse proxy va Statik fayllar, SPA darslaridagi qoidalarni takrorlaydi. Ichki nginx'da TLS va tezlik limitlari yo'q — ular serverdagi tashqi nginx'da.

4. Sirlar: .env

Compose fayli repoda turadi, parollar esa yo'q. Ular .env faylida — git'da emas (.gitignore), image'da emas (.dockerignore). Repoda faqat namuna, .env.compose.example (izohlar qisqartirilgan):

text
# nusxa: cp .env.compose.example .env && chmod 600 .env
POSTGRES_PAROL=
API_DB_PAROL=
AUTH_DB_PAROL=
ISHCHI_DB_PAROL=
REDIS_PAROL=
# ilova: >= 32 belgi
ILOVA_SIRI=
CORS_ORIGINS=https://vazifalar.lokal
ILOVA_URL=https://vazifalar.lokal
API_URL=https://vazifalar.lokal
COOKIE_SECURE=true
HSTS=true
LOG_LEVEL=info

Har bo'sh qiymatga yangi tasodifiy satr:

bash
openssl rand -hex 24

Nega -base64 emas? Parollar DATABASE_URL ichiga qo'yiladi. base64'dagi / va + belgilari esa URL'ni buzadi. Hex — faqat 0-9a-f. Namuna faylning o'zida Node bilan base64url varianti tavsiya qilingan — u ham xavfsiz.

.env Compose uchun ikki vazifani bajaradi. U interpolatsiya manbai: ${API_DB_PAROL} shu yerdan olinadi. Bizda env_file: .env ham bor, shuning uchun fayl konteyner muhitiga ham o'tadi.

${VAR:?xabar} — o'zgaruvchi bo'sh yoki yo'q bo'lsa, Compose ishni to'xtatadi. Kurs tajribasida .env ni vaqtincha olib tashlab, docker compose config ni yurgizdik (chiqishdan parcha):

text
error while interpolating services.api.environment.DATABASE_URL: required variable API_DB_PAROL is missing a value: API_DB_PAROL kerak
error while interpolating services.db.environment.POSTGRES_PASSWORD: required variable POSTGRES_PAROL is missing a value: POSTGRES_PAROL kerak
error while interpolating services.redis.command.[]: required variable REDIS_PAROL is missing a value: REDIS_PAROL kerak

"Interpolatsiyada xato: majburiy o'zgaruvchi qiymatsiz." Parolsiz baza ko'tarilishidan ko'ra, ishga tushmagan stack yaxshiroq. :? bo'lmaganida, Compose faqat ogohlantirib, bo'sh satr qo'yardi — o'sha chiqishning boshida shunday qatorlar ham bor:

text
time="2026-11-06T16:53:55+05:00" level=warning msg="The \"REDIS_PAROL\" variable is not set. Defaulting to a blank string."

docker compose config — Compose faylni o'qib, hamma o'zgaruvchilarni o'rniga qo'yib chiqaradi. Har up dan oldin shu bilan tekshirish — yaxshi odat. Diqqat: uning chiqishida parollar ochiq ko'rinadi, uni chat yoki issue'ga joylamang.

5. Ishga tushirish

bash
docker compose up -d --build

-d — fonda, --build — image'larni (kerak bo'lsa) qayta yig'ish. Kurs tajribasida (Docker Desktop, Compose 5.5.1; image'lar keshdan, baza volume'i oldingi urinishdan qolgan):

text
up exit 0 — 32 s
 Image vazifalar-api:4.1.0 Built 
 Image vazifalar-api:4.1.0 Built 
 Container vazifalar-redis-1 Started 
 Container vazifalar-pochta-1 Started 
 Container vazifalar-db-1 Started 
 Container vazifalar-db-1 Healthy 
 Container vazifalar-migratsiya-1 Started 
 Container vazifalar-redis-1 Healthy 
 Container vazifalar-redis-1 Healthy 
 Container vazifalar-migratsiya-1 Exited 
 Container vazifalar-migratsiya-1 Exited 
 Container vazifalar-api-1 Started 
 Container vazifalar-ishchi-1 Started 
 Container vazifalar-api-1 Healthy 
 Container vazifalar-web-1 Started 

Tartib diagrammadagidek. Avval db sog'lom bo'ladi, keyin migratsiya ishlaydi. U chiqqach api va ishchi ko'tariladi, api sog'lom bo'lgach — web. vazifalar-api:4.1.0 Built ikki marta: bitta image uch servisda ishlatiladi va Compose uni har biri uchun "yig'adi" — ikkinchi va uchinchisi keshdan. Haqiqiy serverda xuddi shu stack birinchi marta 36 soniyada ko'tarildi.

Migratsiya natijasi:

bash
docker compose ps -a \
  --format "{{.Service}} {{.State}} {{.ExitCode}}" | grep migratsiya
docker compose logs migratsiya
text
migratsiya exited 0
migratsiya-1  | 27 migrations found in prisma/migrations
migratsiya-1  | No pending migrations to apply.
migratsiya-1  | parol o'rnatildi: vazifalar_api
migratsiya-1  | parol o'rnatildi: vazifalar_auth
migratsiya-1  | parol o'rnatildi: vazifalar_ishchi

No pending migrations — baza volume'da saqlangan, migratsiyalar oldingi urinishda o'tgan. Toza bazada bu yerda All migrations have been successfully applied. chiqadi. ps -a — to'xtagan konteynerlar ham. Oddiy ps da migratsiya ko'rinmaydi.

To'liq oqim — ro'yxatdan o'tish va xat:

text
royxat 202
"total":1

API ro'yxatni qabul qildi (202), Mailpit'da bitta xat paydo bo'ldi. Xat STARTTLS bilan ketdi: API NODE_EXTRA_CA_CERTS dagi sinov sertifikatiga ishondi. PM2 cluster rejimida bu o'zgaruvchi ishlamagan edi (PM2). Docker'da u konteynerning haqiqiy muhitida — muammo yo'q.

6. Biz shunday xato qildik: terminal .env ni yengdi

Birinchi urinish boshqacha tugadi (63 s):

text
up exit 1 — 63 s
 Container vazifalar-migratsiya-1 Exited 
 Container vazifalar-ishchi-1 Started 
 Container vazifalar-api-1 Started 
 Container vazifalar-api-1 Error dependency api failed to start

(Chiqishdan parcha.) API ishga tushdi va yiqildi, web esa umuman ko'tarilmadi. API logida — SMTP ECONNREFUSED 127.0.0.1:4892: API pochtani pochta:1025 da emas, 127.0.0.1:4892 da qidirgan.

Sabab — compose.yaml dagi SMTP_HOST: ${SMTP_HOST:-pochta}. Kurs tajribasi skriptlari lokal testlar uchun terminalda SMTP_HOST=127.0.0.1 va SMTP_PORT=4892 ni eksport qilgan edi. Compose interpolatsiyada qiymatni avval terminal muhitidan oladi, keyin .env dan, oxirida :- sukutidan (hujjat bo'yicha). Terminaldagi qiymat g'olib chiqdi. Konteyner ichidagi 127.0.0.1 esa — API'ning o'zi.

js
function interpolatsiya(matn, shell, envFayl) {
  const re = /\$\{(\w+)(?::-([^}]*))?\}/g;
  return matn.replace(re, (_, nom, sukut) => {
    const qiymat = shell[nom] ?? envFayl[nom];
    if (qiymat !== undefined && qiymat !== "") return qiymat;
    return sukut ?? "";
  });
}

const envFayl = { REDIS_PAROL: "r-xYz", TRUST_PROXY: "1" };
const qatorlar = [
  "SMTP_HOST: ${SMTP_HOST:-pochta}",
  "REDIS_URL: redis://:${REDIS_PAROL}@redis:6379",
  "TRUST_PROXY: ${TRUST_PROXY:-1}",
];
console.log("toza terminal:");
for (const q of qatorlar) {
  console.log(" ", interpolatsiya(q, {}, envFayl));
}
const shell = { SMTP_HOST: "127.0.0.1" };
console.log("SMTP_HOST eksport qilingan terminal:");
for (const q of qatorlar) {
  console.log(" ", interpolatsiya(q, shell, envFayl));
}

Konsolda:

text
toza terminal:
  SMTP_HOST: pochta
  REDIS_URL: redis://:r-xYz@redis:6379
  TRUST_PROXY: 1
SMTP_HOST eksport qilingan terminal:
  SMTP_HOST: 127.0.0.1
  REDIS_URL: redis://:r-xYz@redis:6379
  TRUST_PROXY: 1

Bir xil fayl, ikki xil terminal — ikki xil stack. Tuzatish: kurs skriptida bu o'zgaruvchilar unset qilindi va ikkinchi urinish o'tdi.

Saboqlar:

  • docker compose config ni o'sha terminalda yurgizing — Compose aynan nima ko'rayotgani chiqadi.
  • Serverda Compose'ni toza muhitdan ishga tushiring: .bashrc dagi export lar stack'ga sizib kirishi mumkin.
  • Terminal ustidan yozishi xavfli qiymat uchun interpolatsiya umuman kerak emas. Uni to'g'ridan yozish yoki faqat .env da saqlash mumkin.

7. Biz shunday xato qildik: soxta mijoz IP'si

7.1 Nima bo'ldi

Reverse proxy darsida API logiga mijozning haqiqiy IP'sini yozishni tuzatgan edik. Express req.ip ni X-Forwarded-For sarlavhasidan oladi. TRUST_PROXY esa "o'ngdan nechta proxy'ga ishonaman" degan son. Compose'da proxy'lar soni o'zgardi. Kurs tajribasida TRUST_PROXY=2 bilan sinadik: so'rovni soxta sarlavha bilan yubordik va API logini o'qidik.

bash
curl -s -o /dev/null -H "X-Forwarded-For: 6.6.6.6" \
  http://127.0.0.1:4780/v1/xff-compose
docker compose logs api | grep xff-compose | tail -1 \
  | grep -oE "\"ip\":\"[^\"]*\""
text
"ip":"6.6.6.6"

API mijoz IP'si deb soxta 6.6.6.6 ni yozdi. TRUST_PROXY=1 bilan qayta o'lchov:

text
TRUST_PROXY=1: "ip":"172.19.0.1"

172.19.0.1 — ichki tarmoq shlyuzi, ya'ni host. Lokalda mijoz (curl) aynan host'da edi — bu to'g'ri javob.

7.2 Nega

Zanjirni kuzatamiz. Lokalda bitta proxy bor — web nginx:

  1. curl sarlavha yuboradi: X-Forwarded-For: 6.6.6.6.
  2. Web nginx so'rovni 172.19.0.1 dan oladi va qo'shadi: 6.6.6.6, 172.19.0.1.
  3. API so'rovni web konteyneridan oladi.

Zanjirdagi har proxy — bitta bo'g'in (inglizcha hop). Express ro'yxatni o'ngdan o'qiydi: avval soket manzili (web), keyin sarlavhadagi manzillar o'ngdan chapga. TRUST_PROXY=n — birinchi n tasiga ishonadi va keyingisini mijoz deb oladi:

js
function reqIp(soket, xff, ishonch) {
  const zanjir = xff ? xff.split(",").map((s) => s.trim()) : [];
  const manzillar = [soket, ...zanjir.reverse()];
  return manzillar[Math.min(ishonch, manzillar.length - 1)];
}

// lokal: curl → web nginx → api (bitta proxy)
const lokalXff = "6.6.6.6, 172.19.0.1";
console.log("lokal, TRUST_PROXY=1:", reqIp("web", lokalXff, 1));
console.log("lokal, TRUST_PROXY=2:", reqIp("web", lokalXff, 2));
// server: mijoz → host nginx → web nginx → api (ikki proxy)
const serverXff = "198.51.100.7, 172.22.0.1";
console.log("server, TRUST_PROXY=2:", reqIp("web", serverXff, 2));
const togri = reqIp("198.51.100.7", "6.6.6.6", 0);
console.log("proxy'siz, TRUST_PROXY=0:", togri);

Konsolda:

text
lokal, TRUST_PROXY=1: 172.19.0.1
lokal, TRUST_PROXY=2: 6.6.6.6
server, TRUST_PROXY=2: 198.51.100.7
proxy'siz, TRUST_PROXY=0: 198.51.100.7

Model Express'ning sonli "trust proxy" qoidasini soddalashtirib takrorlaydi. Lokalda 2 — ortiqcha bitta bo'g'inga ishonish. Bu ortiqcha hop esa mijoz o'zi yozgan sarlavha bo'lib chiqdi.

Serverda zanjir uzunroq: host nginx → web nginx → api. Host nginx X-Forwarded-For $remote_addr bilan mijoz yuborgan sarlavhani almashtiradi (Reverse proxy). Unda faqat haqiqiy IP qoladi (modelda hujjat namunasi 198.51.100.7). Web nginx shlyuzni qo'shadi va 2 to'g'ri javob beradi.

7.3 Oqibati va tuzatish

Soxta IP shunchaki logdagi xato emas. IP bo'yicha ishlaydigan har narsa aldanadi: kirish urinishlari cheklagichi, auth_hodisalar audit jurnali, shubhali faollikni bloklash. Hujumchi har so'rovda boshqa X-Forwarded-For yozib, cheklovni chetlab o'tishi mumkin edi.

Kanon tuzatildi:

  • compose.yaml da sukut — ${TRUST_PROXY:-1}: lokalda bitta proxy;
  • serverdagi production qatlamida (compose.prod.yaml) — 2. Uni Compose production'da darsida ko'ramiz.

Qoida: TRUST_PROXY = haqiqiy proxy'lar soni. Infratuzilma o'zgarsa (Cloudflare qo'shildi, ichki nginx olib tashlandi) — son ham o'zgaradi. Har o'zgarishdan keyin soxta sarlavha bilan tekshiring: logda 6.6.6.6 chiqmasligi kerak. Express hujjati yana bir shartni aytadi: API'ga proxy'larni chetlab, qisqaroq yo'l bilan yetib bo'lmasligi kerak — aks holda mijoz istalgan IP'ni yozadi. Shuning uchun api ning porti umuman nashr qilinmagan.

8. Kundalik buyruqlar

Hammasi compose.yaml turgan papkada ishlatiladi:

Buyruq Nima qiladi
docker compose up -d ko'taradi (o'zgargan servislarni qayta yaratadi)
docker compose ps -a servislar holati, to'xtaganlar bilan
docker compose logs -f api bitta servis logi, jonli
docker compose exec api sh ishlab turgan konteyner ichida buyruq
docker compose config yakuniy konfiguratsiya (parollar bilan)
docker compose stop to'xtatadi, konteynerlar qoladi
docker compose down konteyner va tarmoqni o'chiradi
docker compose down -v volume'larni ham — baza yo'qoladi

exec — docker exec ning Compose ko'rinishi: konteyner nomi o'rniga servis nomi. Skriptda -T qo'shiladi (terminal ajratilmaydi), masalan docker compose exec -T db pg_isready.

down -v — eng xavfli buyruq: db-data volume'i bilan butun baza o'chadi. Serverda uni faqat ataylab va zaxiradan keyin ishlating (Docker debug va xavfsiz tozalash).

Tekshirib ko'ring: compose.yaml da api ning environment iga yangi o'zgaruvchi qo'shdingiz. docker compose restart api yetadimi?

Javob

Yo'q. restart mavjud konteynerni qayta ishga tushiradi — eski sozlamalar bilan. Muhit konteyner yaratilganda yoziladi. docker compose up -d o'zgarishni ko'radi va api ni qayta yaratadi. Xuddi shu tuzoq .env uchun ham: faylni o'zgartirgach — up -d, restart emas.

9. Loyiha qadami

vazifalar-api ga:

  1. compose.yaml — «Fayl tuzilishi» bo'limidagi fayl (name va image nomlarini o'zingiz tanlaysiz).
  2. .env.compose.example — namuna; .env — o'zingiz, chmod 600.
  3. scripts/rol-parollari.mjs — rollarga parol (kanon faylidan).
  4. .gitignore va .dockerignore ga tls/ qo'shing.

vazifalar (web) ga: docker/nginx.conf (kanon faylidan) — oldingi darsdagi Dockerfile shu faylni kutayotgan edi.

Sinov pochtasi uchun sertifikat kerak: tls/pochta/sert.pem va kalit.pem. Uni systemd darsida Mailpit STARTTLS uchun yaratgan edik. Yo'q bo'lsa — o'z-o'zidan imzolangan sertifikat (bu buyruq kurs tajribasida yurgizilmagan; sinalmagan, 2026-11):

bash
mkdir -p tls/pochta
openssl req -x509 -newkey ec -pkeyopt ec_paramgen_curve:P-256 \
  -nodes -days 30 -subj "/CN=pochta" \
  -addext "subjectAltName=DNS:pochta" \
  -keyout tls/pochta/kalit.pem -out tls/pochta/sert.pem

Ishga tushiring va tekshiring:

bash
docker compose config --services
docker compose up -d --build
docker compose ps
curl -s -o /dev/null -w "%{http_code}\n" \
  http://127.0.0.1:4780/v1/vazifalar

Oxirgisi 401 berishi kerak — web nginx so'rovni API'ga yetkazdi. Keyin soxta X-Forwarded-For sinovi: logda 172.19.0.1 ga o'xshash ichki manzil chiqishi kerak (tarmoq raqami sizda boshqacha bo'lishi mumkin), 6.6.6.6 emas.

Hali commit qilmang. Keyingi darsda production qatlami (compose.prod.yaml) qo'shiladi. Hamma Docker fayllari Deploy II darsida bitta commit bilan loyihaga kiradi.

10. Ko'p uchraydigan xatolar

10.1 Bazaga localhost

Konteyner ichida localhost — konteynerning o'zi. Servis nomi: @db:5432.

10.2 depends_on siz yoki shartsiz

Sukut service_started — "ishga tushdi", "tayyor" emas. Baza ulanish qabul qilmasdan API ko'tarilib yiqiladi. Sog'liq tekshiruvi va service_healthy.

10.3 restart bilan yangi sozlama

Muhit yaratilganda yoziladi — up -d.

10.4 Terminal o'zgaruvchisi .env ni yengdi

Kurs tajribasidagi birinchi urinish. docker compose config bilan tekshiring.

10.5 .env git'da

.gitignore da bo'lsin. Repoda — faqat .env.compose.example, qiymatlarsiz.

10.6 Bitta $

Konteyner shell'i o'qishi kerak bo'lgan o'zgaruvchi — $$VAR. Bitta $ bo'lsa, Compose uni o'zi almashtiradi, ko'pincha bo'sh satr bilan.

11. Mashqlar

Mashqlar kurs/mashqlar/33/32-compose/ da. 2- va 3-mashq yechimlari tekshirilgan (biz ishga tushirdik: Node 24.21.0).

1-mashq (oson): bo'shliqlarni to'ldiring

  • Compose fayli nomi —
  • Bir martalik servis tugashini kutish sharti — service_completed_
  • Majburiy o'zgaruvchi sintaksisi — ${VAR:xabar}
  • Volume'larni ham o'chiruvchi bayroq — docker compose down
  • Konteyner shell'i uchun haqiqiy dollar belgisi —
Yechim
  • compose.yaml — eski nomi docker-compose.yml ham o'qiladi.
  • successfully — kod 0.
  • ? — ${API_DB_PAROL:?API_DB_PAROL kerak}.
  • -v — baza yo'qoladi.
  • $$ — $$REDIS_PAROL.

2-mashq (o'rta): interpolatsiya to'liqroq

Darsdagi interpolatsiya ni kengaytiring. Qo'llab-quvvatlansin:

  • ${VAR};
  • ${VAR:-sukut} — yo'q yoki bo'sh bo'lsa sukut, ${VAR-sukut} — faqat yo'q bo'lsa;
  • ${VAR:?xabar} — yo'q yoki bo'sh bo'lsa xato: required variable VAR is missing a value: xabar;
  • $$ → $.

Ustuvorlik: terminal, keyin .env. Terminalda kalit bor bo'lsa (qiymati bo'sh bo'lsa ham), .env ga qaralmaydi.

Yechim
js
function interpolatsiya(matn, shell, envFayl) {
  const re = /\$\$|\$\{(\w+)(?:(:?)([-?])([^}]*))?\}/g;
  return matn.replace(re, (butun, nom, ikkiNuqta, belgi, qolgan) => {
    if (butun === "$$") return "$";
    const q = nom in shell ? shell[nom] : envFayl[nom];
    const yoq = q === undefined || (ikkiNuqta && q === "");
    if (!belgi || !yoq) return q ?? "";
    if (belgi === "-") return qolgan;
    throw new Error(
      `required variable ${nom} is missing a value: ${qolgan}`,
    );
  });
}

const envFayl = { REDIS_PAROL: "r-xYz", BOSH: "" };
const shell = { SMTP_HOST: "127.0.0.1" };
const sinovlar = [
  "${SMTP_HOST:-pochta}",
  "${SMTP_PORT:-1025}",
  "${BOSH:-sukut} [${BOSH-sukut}]",
  'redis-cli -a "$$REDIS_PAROL"',
  "redis://:${REDIS_PAROL:?kerak}@redis",
  "${API_DB_PAROL:?API_DB_PAROL kerak}",
];
for (const s of sinovlar) {
  try {
    console.log(interpolatsiya(s, shell, envFayl));
  } catch (e) {
    console.log("xato:", e.message);
  }
}

Konsolda:

text
127.0.0.1
1025
sukut []
redis-cli -a "$REDIS_PAROL"
redis://:r-xYz@redis
xato: required variable API_DB_PAROL is missing a value: API_DB_PAROL kerak

Uchinchi qator — :- va - farqi: BOSH bor, lekin bo'sh. :- uni "yo'q" deb sukut qo'ydi, - esa bo'sh satrni qoldirdi. Oxirgi qator — kurs tajribasidagi haqiqiy Compose xabarining matni. Haqiqiy Compose bundan ko'proq narsani biladi (ichma-ich sukutlar, :+), lekin asos shu.

3-mashq (qiyin): ishga tushish to'lqinlari

tolqinlar(servislar) funksiyasini yozing. servislar — { nom: [bog'liqliklar] }. Funksiya servislarni "to'lqinlarga" bo'lsin: birinchi to'lqinda bog'liqliksizlar, keyingisida faqat oldingi to'lqinlarga bog'liqlar va hokazo. Har to'lqin ichida nomlar alifbo tartibida. Aylana bog'liqlik bo'lsa — "aylana: <qolganlar>" satrini qaytarsin.

Yechim
js
function tolqinlar(servislar) {
  const qoldi = new Map(Object.entries(servislar));
  const tayyor = new Set();
  const natija = [];
  while (qoldi.size) {
    const tolqin = [...qoldi.keys()].filter((nom) =>
      qoldi.get(nom).every((b) => tayyor.has(b)));
    if (!tolqin.length) {
      return `aylana: ${[...qoldi.keys()].join(", ")}`;
    }
    tolqin.sort();
    for (const nom of tolqin) qoldi.delete(nom);
    for (const nom of tolqin) tayyor.add(nom);
    natija.push(tolqin);
  }
  return natija;
}

const vazifalar = {
  db: [], redis: [], pochta: [],
  migratsiya: ["db"],
  api: ["migratsiya", "redis"],
  ishchi: ["migratsiya", "redis"],
  web: ["api"],
};
tolqinlar(vazifalar).forEach((t, i) => {
  console.log(i + 1, t.join(", "));
});
console.log(tolqinlar({ a: ["b"], b: ["c"], c: ["a"], d: [] }));

Konsolda:

text
1 db, pochta, redis
2 migratsiya
3 api, ishchi
4 web
aylana: a, b, c

Bu — topologik saralash (Kahn algoritmi). To'lqinlar kurs tajribasidagi up chiqishiga mos: db, redis, pochta birga boshlandi, keyin migratsiya, keyin api va ishchi, oxirida web. Compose ham aylana bog'liqlik bilan stackni ko'tara olmaydi — lekin uning xabarini sinamadik, startup order sahifasida ham bu aniq yozilmagan (sinalmagan, 2026-11). d birinchi to'lqinda o'tib ketdi — xabarda faqat aylanadagilar qoldi.

12. Real ishda

  • Lokal ishlab chiqish: yangi dasturchi git clone va docker compose up bilan butun muhitni oladi — README'dagi o'n qadam o'rniga.
  • Kichik production — bitta serverda Compose: ko'p startaplar va ichki xizmatlar shunday ishlaydi. Shartlari bor: restart siyosati, log chegarasi, resurs limitlari (Compose production'da).
  • Katta masshtab — Kubernetes yoki boshqariladigan konteyner platformalari. Compose fayli ularga to'g'ridan-to'g'ri o'tmaydi, lekin tushunchalar (servis, sog'liq, tarmoq, volume) bir xil.
  • Intervyu savollari: "depends_on nimani kutadi?", "env_file va environment farqi?", "Compose'da .env qayerdan o'qiladi?", "down va down -v farqi?", "Reverse proxy ortida mijoz IP'sini qanday to'g'ri olasiz?"

Xulosa

  • compose.yaml — stack tavsifi: services, volumes, networks; name — nomlar prefiksi.
  • YAML langarlari (&api, <<: *api) umumiy sozlamani bir joyda saqlaydi.
  • depends_on shartlari: service_healthy, service_completed_successfully — db → migratsiya → api → web.
  • Sirlar .env da (600, git'siz), ${VAR:?} bilan majburiy; docker compose config — tekshiruv.
  • Terminal o'zgaruvchisi .env dan ustun: kurs tajribasida SMTP_HOST API'ni yiqitdi.
  • TRUST_PROXY = haqiqiy proxy soni: lokalda 2 soxta 6.6.6.6 ni mijoz qilib qo'ydi, 1 — to'g'ri.
  • down -v bazani o'chiradi.

Keyingi dars: Compose production'da: healthcheck, restart, profillar — serverda ishonchli ishlash uchun restart siyosati, resurs limitlari, log hajmi va docker stop grace vaqtini qo'shamiz.

Manbalar

33-qism. Linux, server, Docker · 32-dars yakunlandi

Docker Compose: ko'p servisli stack

20 daqvaqt
0belgi
Keyingi dars: Docker Compose production'da: healthcheck, restart, profillar va chegaralar
Telegram'da
Darsda xato koʻrdingizmi?

Izohlar · 0