JavaScript Full-stackDocker tarmoqlari
JavaScript Full-stack · 33-qism. Linux, server, Docker

Docker tarmoqlari

16 daqiqa31/38-dars

Qisqacha: Har konteynerning o'z tarmoq muhiti bor: o'z IP'si va o'z 127.0.0.1 i. Bir bridge tarmog'idagi konteynerlar bir-birini ko'radi. O'zingiz yaratgan tarmoqda esa ular bir-birini nom bo'yicha topadi: api konteyneri bazaga db:5432 deb ulanadi. Tashqaridan faqat nashr qilingan port ko'rinadi (-p). EXPOSE va docker ps dagi 3000/tcp — nashr emas. -p 8089:80 portni hamma interfeysga ochadi va kurs tajribasida ufw qoidasi bo'lmasa ham internetdan ochildi. Shuning uchun portlar faqat 127.0.0.1 ga nashr qilinadi, baza va Redis esa umuman nashr qilinmaydi.

Bu darsda

  • Konteyner tarmog'i qanday tuzilganini va standart bridge bilan o'z tarmog'ingiz farqini tushuntirasiz.
  • Konteynerlarni nom bo'yicha ulaysiz va ichki DNS'ni tekshirasiz.
  • EXPOSE, nashr qilingan va nashr qilinmagan portni docker ps chiqishidan ajratasiz.
  • Portni faqat 127.0.0.1 ga ochasiz va nega Docker ufw'ni chetlab o'tishini bilasiz.
  • host va none tarmoqlari qachon kerakligini bilasiz.

Oldin bilishingiz kerak: Server tarmoq tashxisi, SSH hardening va ufw firewall, Image, container va registry, Multi-stage build.

1. Nega bu kerak?

Qo'lda deploy qilganimizda hamma narsa bitta serverda edi. API 127.0.0.1:3000 da tinglardi, nginx unga 127.0.0.1 orqali ulanardi. Postgres va Redis ham shu serverdan localhost deb topilardi. Tarmoq tashxisi darsida ko'rganmiz: 127.0.0.1 dagi port tashqaridan ko'rinmaydi.

Docker'da bu manzara o'zgaradi. Endi vazifalar — oltita konteyner: web, api, ishchi, db, redis, pochta. Har konteynerning o'z tarmoq muhiti bor (Konteyner nima darsidagi namespace'lar). Konteyner ichidagi 127.0.0.1 — o'sha konteynerning o'zi. API konteyneri localhost:5432 ga ulansa, u o'z ichidan Postgres qidiradi va topa olmaydi.

Uch savol tug'iladi:

  1. Konteynerlar bir-birini qanday topadi?
  2. Qaysi port tashqaridan ko'rinadi?
  3. Firewall bu portlarni himoya qiladimi?

O'xshatish: ko'p qavatli ofis binosi. Har xonaning ichki telefoni bor. Xodimlar bir-biriga ichki raqam bilan — "buxgalteriya" deb qo'ng'iroq qiladi. Shahar raqami esa faqat qabulxonada. Bino ichidagi qo'ng'iroqlar tashqariga chiqmaydi. Lekin kimdir ichki xonani to'g'ridan-to'g'ri shahar liniyasiga ulab qo'ysa, bino eshigidagi qorovul bundan bexabar qoladi.

2. Konteyner tarmog'i qanday tuzilgan

2.1 bridge: virtual kommutator

Docker host'da virtual bridge — dasturiy kommutator — yaratadi. Har konteyner unga virtual kabel bilan ulanadi va tarmoq ichidan IP oladi. Bir bridge'dagi konteynerlar bir-biri bilan bevosita gaplashadi. Tashqi dunyoga esa host orqali, NAT bilan chiqadi.

Docker o'rnatilganda bitta tarmoq tayyor bo'ladi — standart bridge (host'da docker0 interfeysi). --network ko'rsatilmagan har konteyner shunga tushadi. Kurs tajribasida -p bilan ishga tushirilgan konteyner shu tarmoqdan 172.17.0.2 manzilini oldi (quyida, ufw bo'limida).

2.2 O'z tarmog'ingiz

Standart bridge da bitta muhim narsa yo'q: konteynerlar bir-birini nom bilan topa olmaydi, faqat IP bilan (Docker hujjati, tekshirildi 2026-11). IP esa konteyner qayta yaratilganda o'zgarishi mumkin. Shuning uchun har loyiha uchun alohida tarmoq yaratiladi:

bash
docker network create vazifalar-sinov
docker network ls

Compose buni o'zi qiladi. Kurs tajribasidagi loyiha stack'i uchun Compose <loyiha>_<tarmoq> nomli tarmoq yaratdi (keyingi darsda ochamiz):

text
$ docker network ls --filter name=vazifalar --format "{{.Name}} {{.Driver}}"
vazifalar_ichki bridge

(Bu darsda loyiha va konteyner nomlari qisqartirilgan; o'quv laboratoriyasi tarmog'i qatori olib tashlangan.) O'z tarmog'ingizning yana bir foydasi — ajratish: boshqa loyihaning konteynerlari bu tarmoqda yo'q va sizning bazangizni ko'rmaydi.

flowchart LR
  I["internet"] --> HN["host nginx :443"]
  HN --> W["web :8080<br/>127.0.0.1:4780"]
  subgraph T["vazifalar_ichki"]
    W --> A["api :3000"]
    A --> D["db :5432"]
    A --> R["redis :6379"]
    IS["ishchi"] --> D
  end

Faqat web ning porti host'ga chiqadi, u ham faqat 127.0.0.1 ga. Qolganlari — faqat ichki tarmoqda.

3. Ichki DNS: nom bo'yicha topish

3.1 Kanon tajribasi

O'z tarmog'idagi har konteyner boshqalarini servis nomi bilan topadi. Kurs tajribasida loyiha stack'i ishlab turganda web konteyneri ichidan tekshirdik:

bash
docker compose exec -T web sh -c "getent hosts api db redis"
text
172.19.0.5        api  api
172.19.0.4        db  db
172.19.0.2        redis  redis

getent hosts — tizim nom topish mexanizmi orqali IP so'rash (Server tarmoq tashxisi darsida /etc/hosts bilan ishlatgan edik). Uchala nom ham 172.19.0.x ga aylandi — hammasi bir tarmoqda. Endi nom orqali haqiqiy so'rov:

bash
docker compose exec -T web wget -qO- http://api:3000/health/live
text
{"status":"ok","info":{},"error":{},"details":{}}

web konteyneri api ga nom bilan ulandi va API'ning sog'liq javobini oldi. Shuning uchun loyiha sozlamasida bazaning manzili — db:

text
DATABASE_URL=postgres://vazifalar_api:…@db:5432/vazifalar
REDIS_URL=redis://:…@redis:6379

3.2 DNS server qayerda

Nomni Docker'ning o'rnatilgan DNS serveri aylantiradi. O'z tarmog'idagi har konteyner uchun u 127.0.0.11 manzilida turadi (Docker hujjati, tekshirildi 2026-11). Kurs tajribasidagi o'quv serveri ham Docker konteyneri edi va uning ss -tulpn chiqishida bu manzil ko'rindi:

text
udp   UNCONN 0      0         127.0.0.11:35459      0.0.0.0:*
tcp   LISTEN 0      4096      127.0.0.11:36689      0.0.0.0:*

O'sha o'quv serveri ham boshqa "serverlarni" — Postgres va Redis konteynerlarini — nomi bilan topdi (nomlar qisqartirilgan):

text
Connection to pg (172.18.0.2) 5432 port [tcp/postgresql] succeeded!
Connection to redis (172.18.0.3) 6379 port [tcp/redis] succeeded!
nc: connect to pg (172.18.0.2) port 5433 (tcp) failed: Connection refused

5433 da hech kim tinglamaydi — nom topildi, lekin port yopiq. "Nom topilmadi" va "ulanish rad etildi" — ikki xil muammo, xato matni ularni ajratadi.

3.3 IP emas, nom

IP manzil konteyner qayta yaratilganda o'zgarishi mumkin. Haqiqiy serverda api konteynerini majburan qayta yaratib, oldin va keyin IP'ni tekshirdik:

text
oldin: 172.22.0.6
keyin: 172.22.0.6

Bu safar IP o'zgarmadi. Lekin bu kafolat emas — Docker IP'ni bo'sh manzillardan beradi. Sozlamalarda doim nom yoziladi. Bitta nozik joy bor: nginx proxy_pass http://api:3000 dagi nomni odatda konfiguratsiya yuklanganda bir marta IP'ga aylantiradi. Nomni ishlash davomida qayta so'rash uchun nginx'da alohida sozlama (resolver va o'zgaruvchili proxy_pass) bor. api qayta yaratilib IP o'zgarsa, nginx eski IP'ga yuborishi mumkin. Kurs tajribasida bu kuzatilmadi (sinalmagan, 2026-11), lekin buni bilib qo'ying.

Tarmoqlar IP'larni o'z diapazonidan beradi. Kichik model — IP qaysi tarmoqqa tegishli:

js
function ipSon(ip) {
  return ip.split(".").reduce((s, q) => s * 256 + Number(q), 0);
}

function tarmoqda(ip, cidr) {
  const [manzil, uzunlik] = cidr.split("/");
  const blok = 2 ** (32 - Number(uzunlik));
  return Math.floor(ipSon(ip) / blok) ===
    Math.floor(ipSon(manzil) / blok);
}

const ichki = "172.19.0.0/16";
const ipler = [
  "172.19.0.5", "172.19.0.1", "172.18.0.2", "203.0.113.10",
];
for (const ip of ipler) {
  const joy = tarmoqda(ip, ichki) ? "ichki tarmoqda" : "tashqarida";
  console.log(ip.padEnd(13), joy);
}
const vpn = "172.16.0.0/12";
console.log(`${vpn} ichida:`, tarmoqda("172.19.0.5", vpn));

Konsolda:

text
172.19.0.5    ichki tarmoqda
172.19.0.1    ichki tarmoqda
172.18.0.2    tashqarida
203.0.113.10  tashqarida
172.16.0.0/12 ichida: true

/16 — birinchi 16 bit tarmoqni bildiradi, qolgan 16 bit — tarmoq ichidagi manzil. Bir tarmoqdagi hamma IP shu blokka bo'linganda bir xil natija beradi. Math.floor bitli amallar o'rnida turibdi: JavaScript'da << 32-bitli ishorali son bilan ishlaydi va 172.x dagi katta sonlar manfiy bo'lib qoladi.

Oxirgi qator — real tuzoq. Kurs tajribasidagi hamma Docker tarmoqlari (172.17, 172.18, 172.19, 172.22) 172.16.0.0/12 ichida yotadi. Kompaniya VPN'i ham shu oraliqni ishlatsa, konteyner tarmog'i VPN manzillarini "to'sib" qo'yishi mumkin. Davosi — Docker'ning manzil havzasini o'zgartirish: hujjatga ko'ra havzalar /etc/docker/daemon.json da sozlanadi (default-address-pools; tekshirildi 2026-11, biz sinamadik).

172.19.0.1 ham ichki tarmoqda — bu tarmoqning shlyuzi, host tomoni. Host'dan nashr qilingan port orqali kelgan so'rov konteyner ichida shu manzildan kelgandek ko'rinadi. Keyingi darsda API logida aynan shu IP chiqadi.

4. Portlar: EXPOSE, nashr va 127.0.0.1

4.1 Nashr qilingan va qilinmagan port

Konteyner porti ikki holatda bo'ladi:

  • nashr qilinmagan — faqat ichki tarmoqdagi boshqa konteynerlar ulanadi;
  • nashr qilingan (-p host_ip:host_port:konteyner_port) — host'ning porti konteynerga yo'naltiriladi.

EXPOSE faqat yozuv: "bu image shu portni ishlatadi" (Dockerfile yozish). Loyiha stack'ida docker compose ps:

text
SERVICE   STATUS                           PORTS
api       Up 7 seconds (healthy)           3000/tcp
db        Up 16 seconds (healthy)          5432/tcp
ishchi    Up 6 seconds                     3000/tcp
pochta    Up 17 seconds (healthy)          1025/tcp, 1110/tcp, 8025/tcp
redis     Up 18 seconds (healthy)          6379/tcp
web       Up 1 second (health: starting)   127.0.0.1:4780->8080/tcp

3000/tcp — EXPOSE dan kelgan yozuv, nashr emas. Faqat web da -> bor: host'ning 127.0.0.1:4780 porti konteynerning 8080 iga yo'naltirilgan. Tekshiramiz:

bash
docker compose port api 3000; docker compose port db 5432
text
invalid IP:0
invalid IP:0

Xabar g'alati ko'rinadi, lekin ma'nosi — "nashr qilinmagan, host'dagi manzil yo'q". web uchun esa:

text
8080/tcp→[{127.0.0.1 4780}]

Host'dan so'rov:

text
host → 127.0.0.1:4780/ (web) 200
host → 127.0.0.1:4780/v1/vazifalar (web nginx → api) 401

Ikkinchi qator muhim: host'dan api ga to'g'ridan-to'g'ri yo'l yo'q, lekin web ichidagi nginx /v1/ ni api:3000 ga uzatdi. 401 — API'ning javobi: sessiyasiz so'rov.

Haqiqiy serverdagi xuddi shu stack'da web qatori biroz boshqacha chiqdi:

text
web          Up Less than a second (health: starting)   80/tcp, 127.0.0.1:4780->8080/tcp

80/tcp — base nginx image'ining EXPOSE 80 yozuvi. Bizning nginx 8080 da tinglaydi, 80 da hech kim yo'q. Bu yozuv chalg'itadi, lekin xavfsiz: nashr qilinmagan. Lokal Docker Desktop chiqishida bu qism ko'rinmadi — farq sababini aniqlamadik.

4.2 -p 5432:5432 nima ochadi

-p 8089:80 — host IP'si ko'rsatilmagan. Bu hamma interfeyslar degani: 0.0.0.0 va IPv6 [::]. Kurs tajribasida o'quv serverida (ochiq — konteyner nomi):

text
ochiq 0.0.0.0:8089->80/tcp, [::]:8089->80/tcp

-p 127.0.0.1:8089:80 esa faqat host'ning o'zidan ulanishni beradi:

text
ochiq 127.0.0.1:8089->80/tcp

Qoida: production'da port faqat 127.0.0.1 ga, tashqariga esa host'dagi nginx orqali (Reverse proxy). Baza va Redis portlari umuman nashr qilinmaydi — ular faqat ichki tarmoqda kerak. Lokal ishlab chiqishda bazani DBeaver bilan ko'rish kerak bo'lsa — -p 127.0.0.1:5432:5432, hech qachon -p 5432:5432.

5. Docker va ufw: firewall chetlab o'tiladi

SSH hardening va ufw darsida serverga ufw qo'ydik: sukut bo'yicha kiruvchi hamma narsa taqiqlangan, faqat 22, 80, 443 ochiq. Shu serverda konteyner -p 8089:80 bilan ishga tushdi. ufw'da 8089 uchun qoida yo'q. Kurs tajribasida boshqa "hujumchi" konteyneridan tekshirdik:

text
hujumchidan vps:8089 (ufw: deny incoming, 8089 ga qoida YO'Q) → 200  ← DOCKER UFW NI CHETLAB O'TDI

Port internetga ochiq — firewall'ga qaramasdan. Qisqa sababi: Docker port nashr qilganda iptables ga DNAT qoidasini yozadi — "8089 ga kelgan paketning manzilini konteynerniki (172.17.0.2:80) ga almashtir". Paket host'ga emas, konteynerga o'tkaziladigan trafikka aylanadi, ufw'ning kiruvchi qoidalari esa uni ko'rmaydi. Docker hujjati ham shuni aytadi: paketlar firewall qoidalaridan oldin yo'naltiriladi (tekshirildi, 2026-11). Qoidaning o'zi, paket yo'li diagrammasi va to'liq tajriba — SSH hardening va ufw darsida.

Yechim — o'sha tajribada:

text
VPS ichidan 127.0.0.1:8089 → 200
hujumchidan vps:8089 → 000

127.0.0.1 ga nashr qilingan port tashqaridan ko'rinmaydi. Bitta eslatma: Docker hujjatiga ko'ra 28.0.0 dan eski versiyalarda bir lokal tarmoqdagi (L2) boshqa mashinalar 127.0.0.1 ga nashr qilingan portga ham yeta olgan (tekshirildi, 2026-11). Kurs tajribasida Docker 29 ishlatildi; serveringizda ham versiyani tekshiring (docker version). Docker qoidalaridan oldin o'z filtringizni qo'yish uchun hujjat DOCKER-USER zanjirini tavsiya qiladi. Lekin eng ishonchli himoya — keraksiz portni umuman ochmaslik.

Diqqat: Bulutdagi serverda baza -p 5432:5432 bilan ishga tushirilsa, u bir necha daqiqa ichida internetdagi skanerlar ro'yxatiga tushadi. Parol zaif bo'lsa — ma'lumot o'g'irlanadi yoki shifrlab, to'lov so'raladi. Bu nazariy xavf emas: ochiq Postgres va Redis portlari — avtomatik hujumlarning doimiy nishoni (sinalmagan, 2026-11).

Tekshirib ko'ring: docker ps da 0.0.0.0:6379->6379/tcp ko'rdingiz, serverda ufw yoqiq va 6379 uchun qoida yo'q. Redis tashqaridan ochiqmi?

Javob

Ha, ochiq bo'lishi mumkin: Docker'ning DNAT qoidasi ufw'dan oldin ishlaydi. Tekshirish — boshqa mashinadan nc -zv <server-ip> 6379. Tuzatish — -p 127.0.0.1:6379:6379 yoki portni umuman nashr qilmaslik (Redis'ga faqat ichki tarmoqdagi API ulanadi).

6. host va none tarmoqlari

Bridge'dan tashqari ikkita maxsus rejim bor. Docker hujjati ularni shunday ta'riflaydi: host — konteyner va host orasidagi tarmoq izolyatsiyasini olib tashlaydi, none — konteynerni host'dan va boshqa konteynerlardan to'liq ajratadi (tekshirildi, 2026-11; kurs tajribasida ishlatilmadi):

  • --network host — konteyner host'ning tarmog'ini o'zi ishlatadi: alohida IP yo'q, -p e'tiborsiz qoldiriladi. Konteyner 3000-portda tinglasa, host'ning 3000-porti band bo'ladi. Tez, lekin izolyatsiya yo'q. Docker Desktop'da u Linux'dagidek ishlamasligi mumkin.
  • --network none — tarmoq umuman yo'q, faqat 127.0.0.1. Tarmoqqa muhtoj bo'lmagan bir martalik ishlar uchun, masalan, faylni qayta ishlash.

Bizning stack uchun ikkalasi ham kerak emas — o'z bridge tarmog'imiz yetarli.

7. Loyiha qadami

Bu dars — tajriba darsi: loyiha fayllari o'zgarmaydi. Hali commit qilmang — commit Deploy II darsida. Tarmoq qarorlari keyingi darsdagi compose.yaml ga kiradi:

Qaror compose.yaml da
bitta loyiha tarmog'i networks: [ichki]
baza va Redis nashr qilinmaydi db va redis da ports yo'q
API nashr qilinmaydi faqat web orqali
web faqat lokalga 127.0.0.1:${WEB_PORT:-4780}:8080
manzillar nom bilan @db:5432, @redis:6379

O'zingiz sinab ko'ring — oddiy docker bilan, Compose'siz (bu buyruqlar kurs tajribasida aynan shu shaklda yurgizilmagan; sinalmagan, 2026-11):

bash
docker network create vazifalar-sinov
docker run -d --name sinov-web --network vazifalar-sinov \
  nginx:1.30.6-alpine
docker run --rm --network vazifalar-sinov nginx:1.30.6-alpine \
  wget -qO- http://sinov-web/ | head -3
docker run --rm nginx:1.30.6-alpine \
  wget -qO- -T 3 http://sinov-web/
docker rm -f sinov-web && docker network rm vazifalar-sinov

Birinchi wget — o'sha tarmoqdan, nom bo'yicha: nginx sahifasi qaytishi kerak. Ikkinchisi — standart bridge dan: nom topilmasligi kerak. Oxirgi qatorda tozalash faqat nom bilan — boshqa konteynerlarga tegilmaydi.

8. Ko'p uchraydigan xatolar

8.1 Konteyner ichida localhost

DATABASE_URL=postgres://…@localhost:5432/… — API o'z konteyneri ichidan baza qidiradi va ECONNREFUSED oladi. To'g'ri — servis nomi: @db:5432.

8.2 Bazani hammaga nashr qilish

-p 5432:5432 = 0.0.0.0:5432 — ufw bo'lsa ham internetga ochiq bo'lishi mumkin. Kerak bo'lsa — faqat 127.0.0.1:5432:5432.

8.3 Standart bridge va nom

Standart tarmoqda nom ishlamaydi. Har loyiha uchun o'z tarmog'i (Compose buni o'zi yaratadi).

8.4 EXPOSE ni port ochish deb o'ylash

docker ps dagi 3000/tcp — faqat yozuv. Tashqaridan kirish — -> bo'lgan joyda.

8.5 IP'ni sozlamaga yozish

172.19.0.5 ertaga boshqa konteynerga tegishli bo'lishi mumkin. Doim nom.

9. Mashqlar

Mashqlar kurs/mashqlar/33/31-tarmoq/ da. 2- va 3-mashq yechimlari tekshirilgan (biz ishga tushirdik: Node 24.21.0 va Git Bash).

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

  • Docker'ning sukut tarmoq drayveri —
  • Konteyner ichidagi Docker DNS serveri manzili — 127.0.0.
  • Portni faqat host'ning o'ziga nashr qilish — -p :4780:8080
  • Docker port yo'naltirish uchun yozadigan iptables qoidasi turi —
  • Konteyner host tarmog'ini o'zi ishlatadigan rejim — --network
Yechim
  • bridge — virtual kommutator.
  • 11 — 127.0.0.11.
  • 127.0.0.1 — tashqaridan ko'rinmaydi.
  • DNAT — manzilni almashtiruvchi yo'naltirish; ufw'dan oldin ishlaydi.
  • host — izolyatsiyasiz.

2-mashq (o'rta): docker ps portlarini o'qish

portlar(satr) funksiyasini yozing. U docker ps ning PORTS ustunini (vergul va bo'sh joy bilan ajratilgan) oladi va har yozuv uchun satr qaytaradi: nashr qilinmagan port, faqat bitta IP'ga nashr qilingan yoki hammaga ochiq (0.0.0.0 yoki [::]). Bo'sh satr — "port yo'q".

Yechim
js
function portlar(satr) {
  if (!satr.trim()) return ["port yo'q"];
  return satr.split(", ").map((p) => {
    const m = p.match(/^(.+):(\d+)->(\d+\/\w+)$/);
    if (!m) return `${p}: nashr qilinmagan`;
    const [, ip, host, ichki] = m;
    const hammaga = ip === "0.0.0.0" || ip === "[::]";
    const kim = hammaga ? "HAMMAGA OCHIQ" : "faqat " + ip;
    return `${ichki} -> ${host}: ${kim}`;
  });
}

const ps = [
  ["web", "80/tcp, 127.0.0.1:4780->8080/tcp"],
  ["api", "3000/tcp"],
  ["db", "0.0.0.0:5432->5432/tcp, [::]:5432->5432/tcp"],
  ["migratsiya", ""],
];
for (const [nom, p] of ps) {
  console.log(nom);
  for (const q of portlar(p)) console.log("  " + q);
}

Konsolda:

text
web
  80/tcp: nashr qilinmagan
  8080/tcp -> 4780: faqat 127.0.0.1
api
  3000/tcp: nashr qilinmagan
db
  5432/tcp -> 5432: HAMMAGA OCHIQ
  5432/tcp -> 5432: HAMMAGA OCHIQ
migratsiya
  port yo'q

Regex'dagi (.+) — ochko'z: [::]:5432 da u oxirgi : gacha hamma narsani oladi va IPv6 manzil to'g'ri ajraladi. db qatori — «Bazani hammaga nashr qilish» xatosi: ikki marta, IPv4 va IPv6 uchun.

3-mashq (qiyin): serverdagi ochiq portlarni awk bilan topish

Git Bash'da skript yozing. U ss -tulnH chiqishiga o'xshash namunaviy fayl yaratadi va awk bilan har TCP portni tekshiradi. Hamma interfeysda (0.0.0.0, [::], *) tinglayotgan port ruxsat etilganlar ro'yxatida (22 80 443) bo'lsa — ochiq (kutilgan), bo'lmasa — OCHIQ — tekshiring!. Boshqa manzillarda — faqat <manzil>.

Yechim
bash
cat > ss.txt <<'S'
udp   UNCONN 0 0    127.0.0.11:35459  0.0.0.0:*
tcp   LISTEN 0 4096    0.0.0.0:22     0.0.0.0:*
tcp   LISTEN 0 511     0.0.0.0:80     0.0.0.0:*
tcp   LISTEN 0 511   127.0.0.1:3000   0.0.0.0:*
tcp   LISTEN 0 4096    0.0.0.0:5432   0.0.0.0:*
tcp   LISTEN 0 4096       [::]:22        [::]:*
tcp   LISTEN 0 511   127.0.0.1:4780   0.0.0.0:*
S
awk -v ruxsat="22 80 443" '
  BEGIN {
    n = split(ruxsat, r, " ")
    for (i = 1; i <= n; i++) ok[r[i]] = 1
  }
  $1 == "tcp" {
    port = $5; sub(/.*:/, "", port)
    manzil = $5; sub(/:[0-9]+$/, "", manzil)
    if (manzil == "0.0.0.0" || manzil == "[::]" || manzil == "*") {
      if (port in ok) holat = "ochiq (kutilgan)"
      else holat = "OCHIQ — tekshiring!"
    } else holat = "faqat " manzil
    printf "%-6s %s\n", port, holat
  }
' ss.txt

Natija:

text
22     ochiq (kutilgan)
80     ochiq (kutilgan)
3000   faqat 127.0.0.1
5432   OCHIQ — tekshiring!
22     ochiq (kutilgan)
4780   faqat 127.0.0.1

sub(/.*:/, "", port) oxirgi : gacha hammasini o'chiradi (.* ochko'z) — IPv6 [::]:22 dan ham 22 qoladi. -v ruxsat=… — awk'ka tashqaridan o'zgaruvchi berish. Diqqat: Docker nashr qilgan port bu ro'yxatda har doim ham ko'rinmaydi — uni ss emas, Docker'ning o'z jarayoni yoki iptables qoidasi ushlab turishi mumkin. Shuning uchun serverda docker ps portlarini ham tekshiring (2-mashq).

10. Real ishda

  • Ko'p servisli ilovalar (mikroservislar) aynan shu tamoyilda: ichki tarmoq va nom bo'yicha topish, tashqariga — bitta kirish nuqtasi.
  • Kubernetes da ham g'oya bir xil, faqat kattaroq: har servisning ichki DNS nomi bor, tashqariga Ingress orqali chiqiladi (Kubernetes; sinalmagan, 2026-11).
  • Xavfsizlik auditi: serverda docker ps --format '{{.Names}} {{.Ports}}' va ss -tlnp ni muntazam ko'rib chiqish — 0.0.0.0'dagi har kutilmagan port — signal.
  • Intervyu savollari: "Konteynerlar bir-birini qanday topadi?", "EXPOSE va -p farqi?", "Nega Docker ufw'ni chetlab o'tadi?", "Konteyner ichida localhost nimani bildiradi?"

Xulosa

  • Har konteyner — o'z IP'si va o'z 127.0.0.1 i; bir bridge tarmog'idagilar bir-birini ko'radi.
  • O'z tarmog'ingizda (Compose'da avtomatik) konteynerlar bir-birini servis nomi bilan topadi: db, api, redis. DNS — 127.0.0.11.
  • EXPOSE va 3000/tcp — nashr emas; tashqariga faqat -p. docker compose port nashr qilinmagan port uchun invalid IP:0 deydi.
  • -p 8089:80 — 0.0.0.0 va [::]; Docker DNAT qoidasi ufw'dan oldin ishlaydi va kurs tajribasida port ufw'ga qaramay ochildi.
  • Qoida: web — 127.0.0.1 ga, baza va Redis — umuman nashr qilinmaydi; sozlamalarda IP emas, nom.

Keyingi dars: Docker Compose: ko'p servisli stack — yettita servisni bitta faylda yozamiz va loyihani bitta buyruq bilan ko'taramiz.

Manbalar

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

Docker tarmoqlari

16 daqvaqt
0belgi
Keyingi dars: Docker Compose: ko'p servisli stack
Telegram'da
Darsda xato koʻrdingizmi?

Izohlar · 0