# Linux Jarayonlari (Processes) !!! info "Bu darsda" - 🎯 **Jarayon (process)** nima ekanini va uning hayot siklini tushunasiz - 🎯 PID, PPID, foreground/background tushunchalarini o'rganasiz - 🎯 `ps`, `top`, `htop`, `kill`, `jobs`, `bg`, `fg` buyruqlarini amalda ishlatasiz - 🎯 Signallar bilan jarayonlarni boshqarishni o'rganasiz - ⏱️ O'qish vaqti: ~15 daqiqa - 🧩 Kerakli bilim: [Linux fayl tizimi](../1.%20Linux%20asoslari/2.%20Fayl%20tizimi.md) --- ## 🪝 Serveringiz nima uchun sekinlashdi? Soat 02:30 kechasi. Sizning web-saytingiz ishlamay qoldi. Foydalanuvchilar shikoyat qilmoqda. Serverga kirasiz — hamma narsa muzday. Nima bo'ldi? Kimdir bir oy oldin yozgan bitta skript doiraviy halqada ishlab, server xotirasini yeb qo'ygan. 5 daqiqada uni topasiz, o'chirasiz — sayt tiklandi. Qanday? `ps`, `top` va `kill` buyruqlari bilan. Jarayonlarni boshqarish — bu DevOps muhandisining eng ko'p ishlatiladigan ko'nikmasi. Keling, uni noldan o'rganamiz. --- ## Jarayon (process) nima? Fayl ustida saqlangan dastur — bu shunchaki instruksiyalar to'plami. Disk da yotadi, hech narsa qilmaydi. Siz uni ishga tushirganingizda, Linux uni **xotiraga yuklaydi, unga resurslar beradi va nazorat qilishni boshlaydi** — shundan keyin u "jarayon" bo'ladi. !!! tip "Oddiy qilib aytganda" Dastur — bu retsept. Jarayon — o'sha retsept bo'yicha **hozir pishirilayotgan ovqat**. Bir xil retseptdan bir vaqtda 10 ta ovqat pishirish mumkin — bu 10 ta alohida jarayon. Har bir jarayonning o'z "shaxsiy guvohnomasi" bor: ``` ┌─────────────────────────────────────────┐ │ PID: 1234 ← Noyob raqam (ID) │ │ PPID: 1000 ← Kim yaratgan (ota) │ │ User: www-data ← Kim nomidan ishlaydi│ │ Command: nginx ← Qaysi dastur │ │ Memory: 50 MB ← Xotira │ │ CPU: 5% ← Protsessor yuki │ └─────────────────────────────────────────┘ ``` **PID** (Process ID) — har bir jarayonning noyob raqami. Linux uni avtomatik beradi. Tizim yoqilganda birinchi ishga tushadigan jarayon har doim **PID=1** (bu `systemd` yoki `init`). **PPID** (Parent Process ID) — bu jarayonni kim yaratgan. Har bir jarayon biror boshqa jarayondan tug'iladi — bu "ota-bola" munosabati. --- ## Ota-bola munosabati — "Menejer va xodimlar" Linux'dagi barcha jarayonlar bitta daraxt hosil qiladi. `systemd` (PID=1) — bu butun daraxtning ildizi, ya'ni bosh menejer. U boshqa barcha jarayonlarning "buyuk bobosi". ```mermaid flowchart TD A["systemd
PID: 1"] --> B["bash (terminal)
PID: 850"] A --> C["nginx (web server)
PID: 1234"] A --> D["sshd (SSH server)
PID: 512"] B --> E["ps aux
PID: 1435"] B --> F["vim file.txt
PID: 1436"] C --> G["nginx: worker
PID: 1235"] C --> H["nginx: worker
PID: 1236"] style A fill:#1e3a8a,stroke:#60a5fa,color:#fff style C fill:#065f46,stroke:#34d399,color:#fff ``` !!! tip "Oddiy qilib aytganda" Tasavvur qiling: restoran. Bosh menejer (systemd, PID=1) oshxonani ochadi. U oshpazlarni (nginx, sshd) yollaydi. Har bir oshpaz o'z yordamchilarini (worker process'lar) jalb qilishi mumkin. Har kimning o'z raqami (PID) va kim yollagani (PPID) belgilangan.

🔬 Chuqurroq — fork() va exec() mexanizmi

Yangi jarayon yaratish ikki bosqichda bo'ladi: **1. `fork()`** — ota jarayon o'zining nusxasini yaratadi. Ikki "egizak" bo'ladi: ota va bola. Bola ota bilan bir xil kodga ega, lekin alohida xotira manzilida ishlaydi. **2. `exec()`** — bola jarayon o'zini yangi dastur bilan almashtiradi. Endi u boshqa dasturni ishlatadi. ```bash # Siz terminalga `ls` yozganingizda quyidagi jarayon bo'ladi: # bash → fork() → bash nusxasi yaratiladi # → exec("ls") → nusxa "ls" dasturiga aylanadi # → ls natijani beradi va o'ladi # → bash kutib turgan edi, davom etadi ``` **Copy-on-Write (CoW):** Fork paytida xotira haqiqatda ko'chirilmaydi. Faqat bola o'zgartirish qilganda yangi xotira ajratiladi. Bu fork'ni juda tez va tejamkor qiladi.

--- ## Jarayonning hayot sikli Har bir jarayon tug'iladi, ishlaydi va o'ladi. Ba'zida "tirik mayit" ham bo'ladi. ```mermaid stateDiagram-v2 [*] --> Running : fork() + exec() Running --> Sleeping : I/O kutish Sleeping --> Running : I/O tayyor Running --> Stopped : Ctrl+Z / SIGSTOP Stopped --> Running : fg / SIGCONT Running --> Zombie : jarayon tugadi, ota kutmadi Zombie --> [*] : ota wait() chaqirdi Running --> [*] : normal tugash ``` **Asosiy holatlar:** | Holat | STAT kodi | Ma'nosi | |-------|-----------|---------| | Running | `R` | Hozir protsessorda ishlayapti | | Sleeping | `S` | Biror narsani kutmoqda (disk, tarmoq) | | Stopped | `T` | To'xtatilgan (Ctrl+Z bilan) | | Zombie | `Z` | Tugagan, lekin ota uni "olmagan" | !!! warning "Tez-tez uchraydigan xato" **Zombie jarayon** — bu o'lik jarayon bo'lib, u tizimda "ruhday" sarsonlanib yuradi. PID egallaydi, lekin ish qilmaydi. Ko'p zombie jarayon bo'lsa — bu ota jarayon yomon yozilgani belgisi. Odatda otani restart qilish yoki to'xtatish zombie'larni tozalaydi. --- ## Foreground va Background jarayonlar Terminalda buyruq yozganingizda u **foreground** (old plan) da ishlaydi: natijani kutib turasiz, yangi buyruq yozolmaysiz. **Background** (orqa plan) — jarayon ishlayapti, lekin terminal bo'sh, siz boshqa narsa qilasiz. !!! tip "Oddiy qilib aytganda" Telefonla gaplashayotganda boshqa ilovada musiqa eshitasiz — musiqa background'da. Gaplashayotgan qo'ng'iroq — foreground'da. Linux'da ham xuddi shunday. ```bash # Foreground — natijani kutasiz sleep 10 # 10 soniya terminal band # Background — & belgisi bilan, terminal bo'shaydi sleep 300 & # Orqada ishlaydi, [1] 1234 chiqadi # [1] = job raqami, 1234 = PID ``` ### Foreground ↔ Background almashish ```bash # Ishlayotgan jarayonni to'xtatib, background'ga o'tkazish sleep 300 # Boshlang # Ctrl+Z bosing → [1]+ Stopped sleep 300 bg # Background'ga yuboring # yoki bg %1 # Job raqami bilan # Background'ga o'tgan jarayonni qaytarish fg # Oxirgi job'ni foreground'ga fg %1 # Job #1 ni # Barcha background job'larni ko'rish jobs # Ro'yxat jobs -l # PID'lar bilan ``` ### `nohup` — terminal yopilganda ham davom etsin Oddiy `&` bilan ishga tushirilgan jarayon terminal yopilganda o'ladi. `nohup` bunga yo'l qo'ymaydi: ```bash # Terminal yopilganda ham ishlaydi nohup ./backup.sh & # Log faylga yo'naltirish bilan nohup ./backup.sh > backup.log 2>&1 & ``` --- ## 💻 O'zingiz sinab ko'ring — 1 Quyidagi buyruqlarni ketma-ket bajaring: ```bash # 1. Uch ta background jarayon ishga tushiring sleep 100 & sleep 200 & sleep 300 & # 2. Ularni ko'ring jobs # Kutilgan natija: # [1] Running sleep 100 & # [2]- Running sleep 200 & # [3]+ Running sleep 300 & ``` !!! question "Tekshirib ko'ring" `jobs` natijasida `+` va `-` belgilari nima degani? Bir daqiqa o'ylang.

Javob — bosib oching

- `+` — **joriy job** (fg chaqirilsa birinchi qaytadigan) - `-` — **keyingi job** (joriy o'chirilsa u joriy bo'ladi) - Belgisiz — qolganlar

--- ## Jarayonlarni kuzatish: `ps`, `top`, `htop` ### `ps` — jarayonlarning "surat"i `ps` buyrug'i — joriy lahzadagi jarayonlar holati. Dinamik emas, statik — xuddi suratga tushirgandek. ```bash # Faqat joriy terminaldagi jarayonlar ps # Barcha jarayonlar — eng ko'p ishlatiladigan shakl ps aux # Tushuntirish: # a = barcha foydalanuvchilar # u = foydalanuvchi ma'lumotlari bilan # x = terminalsiz jarayonlar ham (daemon'lar) ``` `ps aux` natijasi qanday o'qiladi: ``` USER PID %CPU %MEM VSZ RSS TTY STAT START TIME COMMAND root 1 0.0 0.4 77616 8652 ? Ss Oct01 0:01 /sbin/init www-data 1234 2.5 1.2 125432 25084 ? S 10:30 0:05 nginx: worker ``` | Ustun | Ma'nosi | |-------|---------| | PID | Jarayon raqami | | %CPU | Protsessor yuki | | %MEM | Xotira yuki | | VSZ | Ajratilgan virtual xotira (KB) | | RSS | Haqiqatda ishlatilgan xotira (KB) | | TTY | Terminal (`?` = terminalsiz, ya'ni daemon) | | STAT | Holat (`S`=sleeping, `R`=running, `Z`=zombie) | ```bash # Amaliy misollar ps aux | grep nginx # nginx jarayonlarini topish ps aux --sort=-pmem | head # Eng ko'p xotira ishlatuvchilar ps aux --sort=-pcpu | head # Eng ko'p CPU ishlatuvchilar ps -f --forest # Ota-bola daraxt ko'rinishida ```

🔬 Chuqurroq — ps formatini o'zingiz moslashtirish

```bash # Faqat kerakli ustunlarni tanlash ps -eo pid,ppid,user,cmd,pcpu,pmem # CPU bo'yicha saralangan holda ps -eo pid,user,cmd --sort=-pcpu # Process hierarchy tree (pstree o'rniga) ps axjf # Faqat ma'lum foydalanuvchi jarayonlari ps -u www-data -f # O'zingizning barcha jarayonlaringiz ps -u $USER # pstree — daraxt ko'rinishi pstree -p # PID'lar bilan pstree -u # foydalanuvchilar bilan ``` `ps` standart POSIX vositasi, barcha Unix/Linux tizimlarda ishlaydi. `aux` parametrlar birikmasini eslab qoling — hayotingizda minglab marta ishlatasiz.

### `top` — real vaqt monitoringi `ps` suratga olsa, `top` — jonli translyatsiya. Har 3 soniyada yangilanadi. ```bash top # Ishga tushirish top -u www-data # Faqat ma'lum foydalanuvchi jarayonlari top -p 1234,5678 # Faqat ma'lum PID'lar ``` `top` ichida navigatsiya: | Tugma | Amal | |-------|------| | [[q]] | Chiqish | | [[k]] | Jarayonni to'xtatish (PID so'raladi) | | [[M]] | Xotira bo'yicha tartiblash | | [[P]] | CPU bo'yicha tartiblash | | [[1]] | Har bir CPU yadrosi alohida | | [[h]] | Yordam | `top` yuqori qatorini o'qish: ``` Tasks: 142 total, 1 running, 141 sleeping %Cpu(s): 2.3 us, 1.1 sy, 0.0 ni, 96.5 id, 0.1 wa MiB Mem : 2048 total, 512 free, 1024 used, 512 buff/cache ``` - `us` — foydalanuvchi dasturlari yuki - `sy` — kernel yuki - `id` — bo'sh (idle) vaqt - `wa` — disk/tarmoq kutish vaqti (`wa` yuqori bo'lsa — I/O muammo) ### `htop` — top'ning qulay versiyasi `htop` — rangli, sichqoncha qo'llab-quvvatlanadigan, ko'proq ma'lumot beruvchi versiya. ```bash # O'rnatish sudo apt install htop # Ubuntu/Debian sudo dnf install htop # Fedora/RHEL # Ishga tushirish htop ``` `htop` tugmalari: | Tugma | Amal | |-------|------| | [[F3]] | Qidirish | | [[F4]] | Filter | | [[F5]] | Daraxt ko'rinishi | | [[F6]] | Ustun bo'yicha tartiblash | | [[F9]] | Signal yuborish | | [[F10]] | Chiqish | | [[u]] | Foydalanuvchi bo'yicha filter | --- ## 💻 O'zingiz sinab ko'ring — 2 ```bash # 1. top'ni oching va CPU bo'yicha tartiblab ko'ring top # top ichida: P tugmasini bosing → CPU bo'yicha tartiblandi # 2. Eng ko'p xotira ishlatayotgan 5 ta jarayonni toping ps aux --sort=-pmem | head -6 # Birinchi qator sarlavha, qolgan 5 ta — jarayonlar # 3. Nginx ishlayaptimi? (nginx o'rnatilgan bo'lsa) ps aux | grep nginx ``` !!! question "Tekshirib ko'ring" `ps aux | grep nginx` chiqishida `grep nginx` ham ko'rinadi. Nima uchun? Bu muammo emasmi?

Javob — bosib oching

Muammo emas. `grep nginx` buyrug'ining o'zi ham jarayon, u ham `nginx` so'zini o'z komanda satrida uchratadi. Buni chetlab o'tish uchun: ```bash ps aux | grep [n]ginx # yoki pgrep nginx ``` `[n]ginx` — regexp: `[n]` bitta harfni qidiradi, lekin `[n]ginx` ifodasi o'zi grep'ning komanda satrida bo'lmaydi, shuning uchun o'ziga mos kelmaydi.

--- ## Signallar — jarayonlarga xabar yuborish **Signal** — jarayonga yuborilgan qisqa xabar. "To'xta", "Qayta yükla", "Vaqtincha pauza" kabi. !!! tip "Oddiy qilib aytganda" Signallar — bu boshqaruvchiga ishora. Oshpazga (jarayon) "to'xta" (`SIGTERM`) yoki "hoziroq to'xta" (`SIGKILL`) deyishingiz mumkin. Farqi: `SIGTERM` bilan oshpaz qo'lini yuvib, pechni o'chirib, tartibli chiqadi. `SIGKILL` bilan esa kutmasdan darhol o'chiriladi. ### Asosiy signallar | Signal | Raqam | Qachon ishlatish | |--------|-------|-----------------| | `SIGTERM` | 15 | Normal to'xtatish — jarayon tozalab chiqadi | | `SIGKILL` | 9 | Zo'raki to'xtatish — hech narsa qilmasdan o'ladi | | `SIGHUP` | 1 | Konfiguratsiyani qayta yuklash (restart qilmasdan) | | `SIGSTOP` | 19 | Vaqtincha to'xtatish (Ctrl+Z) | | `SIGCONT` | 18 | To'xtatilganni davom ettirish | ### `kill` — signal yuborish Ism chalkash: `kill` faqat o'ldirmaydi, istalgan signal yuboradi. ```bash # Signal yuborish — asosiy shakl kill -TERM 1234 # Muloyim to'xtatish (default) kill -9 1234 # Zo'raki to'xtatish kill -HUP 1234 # Konfiguratsiyani qayta yuklash kill -STOP 1234 # Vaqtincha to'xtatish kill -CONT 1234 # Davom ettirish # -TERM standart bo'lgani uchun quyidagi bir xil: kill 1234 kill -15 1234 kill -TERM 1234 # Barcha signal nomlarini ko'rish kill -l ``` !!! warning "Tez-tez uchraydigan xato" `kill -9` ni birinchi vosita sifatida ishlatmang. Avval `kill -15` (SIGTERM) bering — jarayon bazani yopadi, fayllarni saqlaydi. Faqat SIGTERM ishlamasa `kill -9` ishlating. Aks holda ma'lumot yo'qolishi yoki fayl buzilishi mumkin. ```bash # To'g'ri tartib: kill -15 1234 # Avval muloyim sleep 5 # 5 soniya kutish kill -9 1234 # Agar hali ham ishlayotgan bo'lsa ``` ### `killall` va `pkill` — nom bo'yicha ```bash # killall — aniq nom bo'yicha killall nginx # Barcha nginx jarayonlarini SIGTERM bilan killall -9 nginx # Barcha nginx'larni SIGKILL bilan killall -u username # Foydalanuvchining barcha jarayonlari # pkill — shablon bo'yicha pkill nginx # "nginx" nomli jarayonlar pkill -f "python.*backup" # Komanda satrida "python...backup" bor jarayonlar pkill -u username # Foydalanuvchi jarayonlari # pgrep — faqat PID topish (o'ldirmay) pgrep nginx # nginx PID'larini ko'rish pgrep -f python # Python bilan bog'liq jarayonlar ``` --- ## Jarayon ustuvorligi: `nice` va `renice` Linux bir vaqtda o'nlab jarayonlarni boshqaradi. Hammaga bir xil e'tibor bermaydi — ustuvorlik (priority) bo'yicha ishlatadi. **Nice value** — jarayonning "muloyimlik darajasi". Qanchalik muloyim bo'lsa, boshqalarga shunchalik ko'p resurs beradi (o'zi kam oladi). ``` Diapazoni: -20 dan +19 gacha -20 -10 0 +10 +19 | | | | | Yuqori Baland Normal Past Eng past ustuvorlik ustuvorlik (root kerak) (background ish) ``` !!! tip "Oddiy qilib aytganda" Nice value — navbatdagi odamning muloyimligi. `-20` — "Men birinchi bo'lishim shart!" (juda tajovuzkor). `+19` — "Joylashganingizdan keyin men o'tiraman" (juda muloyim). Standart — `0` (normal). ```bash # Jarayonni past ustuvorlik bilan ishga tushirish nice -n 10 ./sezim_emas.sh # +10 nice (past ustuvorlik) nice -n 15 find / -name "*.log" # Disk izlash boshqalarga xalaqit bermasin # Root uchun yuqori ustuvorlik sudo nice -n -10 ./muhim_skript.sh # Ishlayotgan jarayonning ustuvorligini o'zgartirish renice 10 1234 # PID 1234 ni +10 ga o'zgartirish renice 5 -u username # Foydalanuvchining barcha jarayonlari sudo renice -5 1234 # Yuqori ustuvorlik (root kerak) # Joriy nice value'larni ko'rish ps -eo pid,ni,cmd ``` **Amaliy misol:** ```bash # Tungi backup'ni past ustuvorlik bilan — server sekinlashmaydi nice -n 19 tar -czf /backup/archive.tar.gz /var/www/ & # Kritik jarayonni yuqori ustuvorlik bilan (root) sudo nice -n -10 /scripts/critical_sync.sh ```

🔬 Chuqurroq — PR va NI ustunlari, real-time ustuvorlik

`ps` va `top` da ikki ustuvorlik ko'rsatiladi: - **NI** — nice value (-20 dan +19) - **PR** — real ustuvorlik (kernel ichki hisobi) Aloqa: `PR = 20 + NI` (odatda). Nice 0 → PR 20. Nice -10 → PR 10. **Real-time ustuvorlik** (ilg'or): ```bash # chrt — real-time scheduling chrt -r 99 command # SCHED_RR, 99-ustuvorlik (eng yuqori) chrt -f 50 command # SCHED_FIFO, 50-ustuvorlik chrt -o 0 command # SCHED_OTHER (standart) chrt -p 1234 # Jarayonning joriy scheduling'i ``` Real-time scheduling video/audio ishlov berish, industrial nazorat tizimlari uchun ishlatiladi. Noto'g'ri ishlatilsa butun tizim muzlashi mumkin.

--- ## System xizmatlar va daemon'lar **Daemon** — bu fon rejimida doimiy ishlaydigan jarayon. Web server (nginx), SSH server (sshd), ma'lumotlar bazasi (mysql) — bularning hammasi daemon. Zamonaviy Linux'da daemon'lar `systemd` orqali boshqariladi. ```bash # Holat tekshirish systemctl status nginx # nginx holati systemctl is-active nginx # aktiv yoki emas # Boshqarish sudo systemctl start nginx # Boshlash sudo systemctl stop nginx # To'xtatish sudo systemctl restart nginx # Qayta ishga tushirish sudo systemctl reload nginx # Konfiguratsiyani qayta yuklash # Avtomatik boshlash sudo systemctl enable nginx # Tizim yoqilganda avtomatik sudo systemctl disable nginx # Avtomatikni o'chirish # Log'larni ko'rish journalctl -u nginx # Barcha log'lar journalctl -u nginx -f # Real vaqt (Ctrl+C bilan chiqish) journalctl -u nginx --since "1 hour ago" ``` Service holatlari: | Holat | Ma'nosi | |-------|---------| | `active (running)` | Ishlayapti | | `active (exited)` | Ishga tushdi va tugadi (bir martalik) | | `inactive (dead)` | Ishlamayapti | | `failed` | Xato bilan to'xtadi |

🔬 Chuqurroq — o'z service'ingizni yaratish

```bash # 1. Service faylini yarating sudo nano /etc/systemd/system/myapp.service ``` ```ini [Unit] Description=Mening ilovam After=network.target [Service] Type=simple User=www-data WorkingDirectory=/opt/myapp ExecStart=/opt/myapp/start.sh Restart=always # Ishdan chiqsa avtomatik qayta ishga tushirish RestartSec=5 # 5 soniya kutib [Install] WantedBy=multi-user.target ``` ```bash # 2. systemd'ga yangi faylni taniting sudo systemctl daemon-reload # 3. Yoqing va boshlang sudo systemctl enable myapp sudo systemctl start myapp # 4. Tekshiring systemctl status myapp ``` **Muhim parametrlar:** - `Restart=always` — har qanday holatda qayta ishga tushiradi - `Restart=on-failure` — faqat xato bo'lsa qayta ishga tushiradi - `RestartSec=5` — qayta urinishlar orasidagi kutish

--- ## 💻 O'zingiz sinab ko'ring — 3 Jarayonlarni boshqarish amaliyoti: ```bash # 1. Sekin jarayon yarating sleep 1000 & # Natija: [1] 2345 (2345 — siz ko'radigan PID boshqacha bo'ladi) # 2. Uning PID'ini toping pgrep sleep # 3. Muloyim to'xtating kill -TERM $(pgrep sleep) # yoki killall sleep # 4. Tasdiqlang — endi ko'rinmasligi kerak pgrep sleep ``` !!! question "Tekshirib ko'ring" Quyidagi ikkita buyruq bir xil natija beradimi? ``` kill -15 1234 kill -SIGTERM 1234 ```

Javob — bosib oching

Ha, mutlaqo bir xil. `15` va `SIGTERM` — bir xil signalning ikki xil yozuvi. `TERM` ham ishlaydi (SIG prefikssiz): ```bash kill -15 1234 kill -SIGTERM 1234 kill -TERM 1234 ``` Uchalasi bir xil. Amalda odatda `kill -9` va `kill -15` raqam shakli ko'proq ishlatiladi.

--- ## 🎒 Xulosa — eng muhimi Agar bu darsdan 5 narsani eslab qolsangiz: 1. **Jarayon** — bu xotirada ishlayotgan dastur. Har birining noyob **PID** (raqamli identifikatori) va **PPID** (ota jarayoni) bor. 2. **Daraxt tuzilishi** — barcha jarayonlar `systemd` (PID=1) dan tug'ilgan daraxt hosil qiladi. 3. **Kuzatish** — `ps aux` statik holat, `top`/`htop` real vaqt. `ps aux | grep dastur` — biror narsani qidirish. 4. **To'xtatish** — avval `kill -15` (muloyim), ishlamasa `kill -9` (zo'raki). `kill` o'ldirmaydi — signal yuboradi. 5. **Ustuvorlik** — `nice` yangi jarayon uchun, `renice` ishlayotgan jarayon uchun. `-20` eng yuqori, `+19` eng past. !!! success "Keyingi qadam" Jarayonlarni boshqarishni o'rgandingiz. Keyingi darsda **fayl ruxsatlari va egalik** (`chmod`, `chown`) mavzusiga o'tamiz — kim qaysi faylni o'qiy olishi, yozishi va ishga tushirishini boshqaramiz. Bu ham DevOps'dagi kunlik ko'nikmalardan biri.