# Fayl va Papka Operatsiyalari !!! info "Bu darsda" - 🎯 Fayl va papkalarni yaratish, nusxalash, ko'chirish, o'chirish buyruqlarini o'rganasiz - 🎯 `find`, `grep`, `tar`, `chmod` — ilg'or vositalar bilan tanishasiz - 🎯 `rm -rf` ning qanchalik xavfli ekanini tushunasiz — va uni qachon ishlatmaslik kerakligini bilib olasiz - ⏱️ O'qish vaqti: ~15 daqiqa - 🧩 Kerakli bilim: [Linux fayl tizimi tuzilishi](3.%20Fayl%20tizimi%20tuzilishi.md) --- ## 🪝 Ish stolini tasavvur qiling Katta bir idorada ishlaydigan xodimni tasavvur qiling. Uning ish stolida: - **Papkalar** bor — har birida hujjatlar. - U hujjatni **ko'chirishi** (original qoladi), **siljitishi** (original ketadi), **o'chirishi** yoki yangi **bo'sh varaq yaratishi** mumkin. - Ba'zan noto'g'ri hujjatni tasodifan **yo'q qilib yuboradi** — o'chirilgan narsa savatchaga ham tushmaydi, tamom yo'qoladi. Linux terminalida ham xuddi shunday. Farqi — bu yerda barcha "ish stoli" buyruqlar bilan boshqariladi. Va **bitta yozuv xatosi** bir nechta yillik ishni o'chirib yuborishi mumkin. Keling, asboblarni birma-bir o'rganaylik. --- ## Fayl tizimi — shkaf modeli Buyruqlardan oldin bir daqiqa: Linux fayl tizimi qanday tashkil etilgan? !!! tip "Oddiy qilib aytganda" Linux fayl tizimi — bu katta shkaf. Shkafda **tortmalar** (papkalar), tortmalarda **qog'ozlar** (fayllar) bor. Har bir tortmaning o'z joyi va nomi bor. Siz terminal orqali shu shkafni boshqarasiz. ```mermaid flowchart TD A["/ — ildiz (butun shkaf)"] --> B["/home — foydalanuvchilar"] A --> C["/etc — konfiguratsiyalar"] A --> D["/var — o'zgaruvchan ma'lumotlar"] A --> E["/tmp — vaqtinchalik fayllar"] B --> F["/home/ali — Ali's papkasi"] F --> G["hujjatlar/"] F --> H["loyiha/"] style A fill:#1e3a8a,stroke:#60a5fa,color:#fff style F fill:#065f46,stroke:#34d399,color:#fff ``` --- ## Asosiy operatsiyalar ### Papka va fayl yaratish — `mkdir` va `touch` Shkafda yangi tortma ochasizmi? `mkdir`. Bo'sh varaq qo'yasizmi? `touch`. ```bash # Oddiy papka yaratish mkdir loyiha # Bir vaqtda bir necha papka mkdir frontend backend database # Ichma-ich papkalar (kataloglar zanjiriga) mkdir -p loyiha/frontend/src # -p: o'rtadagi papkalar yo'q bo'lsa ham yaratadi # Bo'sh fayl yaratish touch index.html # Bir vaqtda bir necha fayl touch app.py config.yml README.md # Mavjud faylning "oxirgi o'zgartirilgan" vaqtini yangilash touch mavjud_fayl.txt # Fayl bor bo'lsa — vaqt yangilanadi, yo'q bo'lsa — yaratiladi ``` !!! tip "Oddiy qilib aytganda" `touch` nomi g'alati tuyuladi. Tasavvur qiling: siz stolda yotgan qog'ozga barmoq tegizasiz ("touch"). Agar qog'oz bor bo'lsa — shunchaki "tegindingiz" (vaqt yangilandi). Yo'q bo'lsa — yangi qog'oz paydo bo'ldi. !!! question "Tekshirib ko'ring" `mkdir loyiha/frontend/src` — xato beradi. `mkdir -p loyiha/frontend/src` — ishlaydi. Nima uchun?

Javob — bosib oching

Chunki `loyiha/` papkasi hali mavjud emas. `mkdir` standart holatda faqat bitta yangi papka yaratadi va o'rtadagi papkalar yo'q bo'lsa xato beradi. `-p` (parents) bayrog'i "yo'q bo'lsa ham barcha o'rta papkalarni yarat" deydi.

--- ### Nusxalash — `cp` **Nusxalash** — originaldan **yangi nusxa** hosil qilish. Original o'z joyida qoladi. ```bash # Faylni nusxalash cp maqola.txt zaxira_maqola.txt # Boshqa papkaga nusxalash cp config.yml /tmp/config_backup.yml # Papkani nusxalash (ichidagi hamma narsasi bilan) cp -r loyiha/ loyiha_zaxira/ # -r: rekursiv (papka ichini ham ko'chiradi) # Nusxalash jarayonini ko'rsatish cp -rv src/ dest/ # -v: verbose (nima qilayotganini chop etadi) # Mavjud faylni qayta yozishdan oldin so'rash cp -i muhim.conf /etc/muhim.conf # -i: interactive (tasdiqlash so'raydi) ``` !!! warning "Tez-tez uchraydigan xato" Papkani `-r` bayrog'isiz nusxalashga urinsa, `cp` xato beradi: `cp: -r not specified; omitting directory`. Papka nusxalashda **har doim** `-r` yozing.

🔬 Chuqurroq — cp ning qo'shimcha imkoniyatlari

```bash # Faqat yangi/o'zgargan fayllarni nusxalash cp -u src/* dest/ # -u: update (yaniroq bo'lsa ko'chiradi) # Fayl meta-ma'lumotlarini (huquqlar, vaqt) saqlash cp -p original.conf backup.conf # -p: preserve # Simvolik havolalarni kuzatmaslik cp -P symlink.txt dest/ # -P: symlink'ni o'zi ko'chiradi, maqsadni emas # rsync bilan nusxalash (katta fayllar va tarmoq uchun yaxshiroq) rsync -av src/ dest/ ``` `rsync` — `cp` ning kuchliroq ukasi. Uzilishdan keyin davom ettiradi, o'zgargan fayllarni aniqlaydi, tarmoq orqali ishlaydi.

--- ### Ko'chirish va nomini o'zgartirish — `mv` `mv` (move) — **ko'chiradi**. Original yangi joyga o'tadi, eski joyda qolmaydi. Xuddi shu buyruq fayl nomini o'zgartirish uchun ham ishlatiladi. ```bash # Faylni ko'chirish mv hisobot.txt /home/ali/hujjatlar/ # Papkani ko'chirish mv eski_loyiha/ /tmp/arxiv/ # Nomini o'zgartirish (bir xil papkada "ko'chirish") mv eskiloyal.txt yangi_nom.txt # Ko'chirish bilan nomini o'zgartirish — bir vaqtda mv config.yml /etc/app/konfiguratsiya.yml # Mavjud faylni qayta yozishdan oldin so'rash mv -i muhim.txt /var/backup/ # -i: interactive ``` !!! tip "Oddiy qilib aytganda" `mv` — bu "kesib-joylashtirish" (Ctrl+X, Ctrl+V). `cp` esa "nusxalab-joylashtirish" (Ctrl+C, Ctrl+V). Faqat ikkinchisida original qoladi. ```mermaid flowchart LR subgraph cp["cp — nusxalash"] direction LR A1["original.txt"] -->|"nusxa"| B1["nusxa.txt"] A1 -.->|"original qoladi"| A1 end subgraph mv["mv — ko'chirish"] direction LR A2["fayl.txt"] -->|"ko'chadi"| B2["yangi_joy/fayl.txt"] A2 -.->|"eski joy bo'shaydi"| X2["(yo'q)"] end style X2 fill:#7f1d1d,stroke:#f87171,color:#fff ``` --- ### O'chirish — `rm` va `rmdir` Bu yerda ehtiyotkor bo'lish kerak. ```bash # Faylni o'chirish rm keraksiz.log # O'chirishdan oldin tasdiqlash so'rash rm -i muhim.txt # -i: har bir fayl uchun so'raydi # Papkani o'chirish (faqat bo'sh papkalar uchun) rmdir bo_sh_papka/ # Papkani barcha mazmuni bilan o'chirish rm -r loyiha/ # -r: rekursiv # Majburan o'chirish (ogohlantirish so'ralmaydi) rm -f majburiy.txt # -f: force ``` !!! danger "Ehtiyot bo'ling — rm -rf" `rm -rf` — Linux'dagi eng xavfli buyruq kombinatsiyasi. - `-r` (recursive): papka ichidagi **hamma narsani** o'chiradi - `-f` (force): hech qanday ogohlantirish ko'rsatmaydi, hech narsa so'ramaydi **O'chirilgan fayl savatga tushmaydi. Ctrl+Z ishlamaydi. Qaytarib bo'lmaydi.** ```bash # BU BUYRUQ BUTUN TIZIMNI O'CHIRISHI MUMKIN: rm -rf / # "/" — ildiz papka, ya'ni barcha fayllar! # Xavfsizroq: avval tekshiring ls -la nima_ochirmoqchiman/ # Avval ko'ring rm -ri nima_ochirmoqchiman/ # -i bilan tasdiqlang ``` Hatto tajribali muhandislar ham `rm -rf` bilan falokatga uchragan. Professional muhitda bu buyruqni ishlatishdan oldin **ikki marta o'ylang**. --- ## 💻 O'zingiz sinab ko'ring Quyidagi amaliyotni bosqichma-bosqich bajaring: ```bash # 1. Ish maydonini tayyorlang mkdir -p ~/amaliyot/papka1/ichki mkdir ~/amaliyot/papka2 # 2. Bir necha fayl yarating touch ~/amaliyot/test1.txt ~/amaliyot/test2.txt touch ~/amaliyot/papka1/ichki/chuqur_fayl.txt # 3. Fayl tuzilishini ko'ring ls -la ~/amaliyot/ ls -la ~/amaliyot/papka1/ichki/ # 4. Nusxalang cp ~/amaliyot/test1.txt ~/amaliyot/test1_nusxa.txt # 5. Ko'chiring mv ~/amaliyot/test2.txt ~/amaliyot/papka2/ # 6. Natijani tekshiring ls ~/amaliyot/ ls ~/amaliyot/papka2/ # 7. O'chiring (ehtiyotlik bilan!) rm ~/amaliyot/test1_nusxa.txt rmdir ~/amaliyot/papka2/ # Bu ishlamaydi, nima uchun? rm -r ~/amaliyot/papka2/ # Bu ishlaydi ``` !!! question "Tekshirib ko'ring" 7-qadamda `rmdir ~/amaliyot/papka2/` xato beradi. Nima uchun?

Javob — bosib oching

Chunki `papka2/` ichida `test2.txt` fayli bor. `rmdir` faqat **bo'sh** papkalarni o'chiradi. Ichida biror narsa bo'lsa — xato beradi. Bu aslida xavfsizlik qatlami: tasodifan ichli papkani o'chirib yubormaslik uchun.

--- ## Fayl tarkibini ko'rish — `head`, `tail`, `less`, `grep` Faylni to'liq ochmasdan ham uning tarkibini o'rganish mumkin. ### `head` va `tail` — boshi va oxiri ```bash # Faylning birinchi qatorlari head fayl.txt # Birinchi 10 qator (standart) head -n 20 fayl.txt # Birinchi 20 qator # Faylning oxirgi qatorlari tail fayl.txt # Oxirgi 10 qator tail -n 20 fayl.txt # Oxirgi 20 qator # Real vaqt monitoring — log kuzatish tail -f /var/log/nginx/access.log # Yangi qatorlar paydo bo'lganda ko'rsatadi tail -F /var/log/app.log # Fayl o'zgarsa ham kuzatishni davom ettiradi ``` !!! tip "Oddiy qilib aytganda" `tail -f` — bu telefonning bildirishnomasi kabi. Fayl yangilanganida siz ham ko'rasiz. Server loglarini kuzatishda har kuni ishlatiladi. **DevOps amaliyotida:** ```bash # Nginx loglari — oxirgi 100 ta so'rov tail -n 100 /var/log/nginx/access.log # Ilovaning real vaqt log'lari tail -f /var/log/app/*.log # Kubernetes pod loglari kubectl logs -f deployment/app ``` ### `less` — katta fayllarni sahifalab ko'rish ```bash less /var/log/syslog # Faylni sahifalab ko'rish less -N fayl.txt # Qator raqamlari bilan # less ichida navigatsiya: # Space — keyingi sahifa # b — oldingi sahifa # /so'z — qidirish # n — keyingi mos # q — chiqish # G — fayl oxiriga o'tish # g — fayl boshiga o'tish ``` ### `grep` — matni izlash `grep` — fayllar ichida matn izlaydi. DevOps da eng tez-tez ishlatiladi. ```bash # Asosiy foydalanish grep "xato" log.txt # log.txt da "xato" so'zini izla grep "error" /var/log/nginx/error.log # Foydali bayroqlar grep -i "error" fayl.txt # -i: katta-kichik harf farq qilmaydi grep -v "INFO" fayl.txt # -v: mos kelmaydiganlarni ko'rsat (teskari) grep -n "error" fayl.txt # -n: qator raqami bilan grep -r "pattern" /path/ # -r: papka ichini ham izla grep -A 3 "error" fayl.txt # -A: mosdan keyin 3 qator ham ko'rsat grep -B 3 "error" fayl.txt # -B: mosdan oldin 3 qator ham ko'rsat grep -C 3 "error" fayl.txt # -C: oldin ham, keyin ham 3 qator ``` **DevOps amaliyotida:** ```bash # Xato loglarini tahlil qilish grep -i "error\|exception\|fail" /var/log/app.log # HTTP 500 xatolarini topish grep " 500 " /var/log/nginx/access.log # Muvaffaqiyatsiz SSH urinishlar grep "Failed password" /var/log/auth.log # Konfiguratsiyadan port izlash grep "listen.*80" /etc/nginx/sites-enabled/* # Docker log'larida xato izlash docker logs container_name 2>&1 | grep -i error ```

🔬 Chuqurroq — grep va regex

`grep` oddiy matn izlashdan tashqari **regular expression** (regex) ham qo'llab-quvvatlaydi: ```bash # Qator boshida grep "^error" fayl.txt # "error" bilan boshlanadigan qatorlar # Qator oxirida grep "error$" fayl.txt # "error" bilan tugaydigan qatorlar # Wildcard grep "err.*or" fayl.txt # err va or orasida istalgan belgilar # "yoki" — biri yoki ikkinchisi grep "error\|warning" fayl.txt # Kengaytirilgan regex (-E) grep -E "error|warning" fayl.txt grep -E "[0-9]{3}-[0-9]{4}" fayl.txt # Telefon raqam formati # Perl regex (-P) — eng kuchli grep -P "\d{3}-\d{4}" fayl.txt ``` Regex — alohida katta mavzu. Hozir shuni biling: `grep -E` kuchliroq variant, `-i` katta-kichik harfni e'tiborsiz qoldiradi.

--- ## Fayllarni izlash — `find`, `locate`, `which` ### `find` — kuchli fayl qidiruvchi `find` — fayl tizimi bo'ylab izlaydi. Ko'p parametrlarni qo'llash mumkin. ```bash # Nom bo'yicha izlash find /home -name "*.txt" # .txt fayllarni izlash find . -name "config*" # config bilan boshlangan fayllar find /etc -iname "*.CONF" # katta-kichik harf farq qilmaydi # Tur bo'yicha izlash find /var -type f # Faqat fayllar find /var -type d # Faqat papkalar find /dev -type l # Simvolik havolalar # Hajm bo'yicha izlash find /var/log -size +100M # 100MB dan katta find /tmp -size -1M # 1MB dan kichik find . -size 0 # Bo'sh fayllar # Vaqt bo'yicha izlash find /var/log -mtime -7 # 7 kun ichida o'zgargan find /tmp -mtime +30 # 30 kundan eski find . -mmin -60 # 60 daqiqa ichida o'zgargan ``` **DevOps amaliyotida:** ```bash # Eski log fayllarni o'chirish find /var/log -name "*.log" -mtime +30 -delete # Bo'sh papkalarni topib o'chirish find /tmp -type d -empty -delete # Konfiguratsiya fayllarini topish find /etc -name "*.conf" -o -name "*.cfg" # Kubernetes manifestlarini topish find ./k8s -name "*.yaml" -mtime -1 # Nginx ga tegishli fayllar find /opt -user nginx -type f ```

🔬 Chuqurroq — find ning kuchli imkoniyatlari

```bash # Permission bo'yicha izlash find /var -perm 644 # Aynan 644 huquq find /bin -perm -755 # Kamida 755 huquq find /home -perm /222 # Yozish huquqi bor # Egasi bo'yicha izlash find /home -user john # john ga tegishli find /var -group www-data # www-data guruhiga tegishli find / -nouser # Hech kimga tegishli emas # Xavfsizlik audit uchun find /usr -perm -4000 -o -perm -2000 # SUID/SGID fayllar find /var -perm -002 -type f # Hamma yoza oladigan fayllar (xavfli) # Topilgan fayllar bilan amal bajarish (-exec) find /var/log -name "*.log" -mtime +30 -exec gzip {} \; find /tmp -name "*.tmp" -exec rm -f {} \; # Singan simvolik havolalar find /usr -type l ! -exec test -e {} \; -print ``` `-exec` — `find` ning eng kuchli xususiyati. Topilgan har bir fayl ustida ixtiyoriy buyruq bajaradi. `{}` — topilgan fayl o'rniga qo'yiladi, `\;` — buyruq tugashini bildiradi.

### `locate` — tez qidiruv ```bash locate nginx.conf # nginx.conf fayllarni tez topish locate "*.log" | head -20 # .log fayllar ro'yxati # Ma'lumotlar bazasini yangilash (locate indeks ishlatadi) sudo updatedb # Katta-kichik harf farq qilmaydi locate -i NGINX.CONF # Regex bilan locate -r "nginx.*\.conf$" ``` !!! tip "Oddiy qilib aytganda" `locate` — kutubxona katalogi kabi. Katalogdan tez topasiz, lekin katalog har kuni bir marta yangilanadi. Shu sababli yangi yaratilgan faylni `locate` ko'rmasligi mumkin — `sudo updatedb` bilan yangilang yoki `find` ishlatang. ### `which` va `whereis` — buyruq joylashuvi ```bash which python3 # /usr/bin/python3 which docker # /usr/bin/docker which kubectl # /usr/local/bin/kubectl whereis nginx # nginx: /usr/sbin/nginx /etc/nginx ... type ls # ls is aliased to 'ls --color=auto' type cd # cd is a shell builtin ``` --- ## Fayl taqqoslash — `diff` va `cmp` ### `diff` — farqlarni ko'rish ```bash diff file1.txt file2.txt # Unified format (git diff kabi) diff -u file1.txt file2.txt # Eng o'qilishi oson format # Katta-kichik harf e'tiborsiz diff -i file1.txt file2.txt # Bo'shliqlarni e'tiborsiz diff -w file1.txt file2.txt # Yon-yon taqqoslash diff -y file1.txt file2.txt # Papkalar taqqoslash diff -r dir1/ dir2/ ``` **DevOps amaliyotida:** ```bash # Konfiguratsiya o'zgarishini tekshirish diff -u nginx.conf.old nginx.conf # Kubernetes manifestlar farqi diff -u deployment-v1.yaml deployment-v2.yaml # Zaxira bilan solishtirish diff -r /etc/nginx/ /backup/nginx/ ``` ### `cmp` — ikkilik taqqoslash ```bash cmp file1 file2 # Farq bormi? cmp -l file1 file2 # Barcha farqlarni ko'rsat cmp -s file1 file2 # Faqat chiqish kodi (skriptlar uchun) ``` --- ## Fayl havolalari — `ln` ### Hard link va Symbolic link !!! tip "Oddiy qilib aytganda" **Hard link** — bitta faylga ikki nom. Ikkalasini ham o'zgartirsa — biri o'zgaradi. **Symbolic link** — strelka-yorliq. Ko'rsatib turadi, original yo'q bo'lsa — ishlamaydi. ```bash # Hard link yaratish ln original.txt hardlink.txt # Symbolic link (symlink) yaratish ln -s original.txt symlink.txt ln -s /path/to/source /path/to/link # Havolalarni ko'rish ls -li # inode raqamlari bilan ls -la # symlink ko'rinadi (-> bilan) ``` **DevOps amaliyotida:** ```bash # Nginx sayt aktivlashtirish (klassik pattern) ln -s /etc/nginx/sites-available/mysite /etc/nginx/sites-enabled/ # Ilova versiyasini boshqarish ln -s /opt/app-v2.1.0 /opt/app-current # kubectl versiyalari ln -s /usr/local/bin/kubectl-1.25 /usr/local/bin/kubectl ```

🔬 Chuqurroq — hard link va inode tushunchasi

Linux fayl tizimida har bir fayl aslida **inode** (fayl meta-ma'lumotlari: hajm, huquqlar, disk manzili) va **nom**dan iborat. Hard link — bitta inodega ikki nom. ```bash ls -li original.txt hardlink.txt # 1234567 -rw-r--r-- 2 ali ali 100 Jun 2 original.txt # 1234567 -rw-r--r-- 2 ali ali 100 Jun 2 hardlink.txt # ^^^ bir xil inode! ^ 2 = link count ``` Hard link cheklovlari: - Papkalarga hard link yaratib bo'lmaydi (tizim tuzilishi buziladi) - Har xil fayl tizimlariga hard link yaratib bo'lmaydi Symbolic link bu cheklovlardan ozod, lekin original fayl o'chirilsa — symlink "sinadi".

--- ## Arxivlash va siqish — `tar`, `gzip`, `zip` ### `tar` — ko'p faylni birga to'plash ```bash # Arxiv yaratish tar -cvf arxiv.tar fayl1 fayl2 papka/ # -c: create, -v: verbose, -f: file tar -czvf arxiv.tar.gz papka/ # gzip siqish bilan tar -cjvf arxiv.tar.bz2 papka/ # bzip2 siqish bilan tar -cJvf arxiv.tar.xz papka/ # xz siqish bilan # Arxiv tarkibini ko'rish tar -tvf arxiv.tar tar -tzvf arxiv.tar.gz # Arxivdan chiqarish tar -xvf arxiv.tar tar -xzvf arxiv.tar.gz tar -xjvf arxiv.tar.bz2 # Muayyan fayllarni chiqarish tar -xvf arxiv.tar fayl1.txt tar -xzvf arxiv.tar.gz "*.conf" # Fayllarni istisno qilish tar --exclude="*.log" -czvf zaxira.tar.gz /opt/app/ ``` **DevOps amaliyotida:** ```bash # Ilova zaxirasini sana bilan saqlash tar -czvf app-backup-$(date +%Y%m%d).tar.gz /opt/myapp/ # Ma'lumotlar bazasi zaxirasi mysqldump mydb | gzip > mydb-$(date +%Y%m%d).sql.gz # Konfiguratsiya zaxirasi (loglar tashqari) tar --exclude="*.log" -czvf config-backup.tar.gz /etc/ # Kubernetes manifestlarni arxivlash tar -czvf k8s-manifests-$(date +%Y%m%d).tar.gz *.yaml # Zaxiradan tiklash tar -xzvf app-backup-20231201.tar.gz -C /opt/ ``` !!! tip "Oddiy qilib aytganda" `tar` — bu "yelim" buyruq: ko'p faylni birga yopishtirib bitta to'plam hosil qiladi. `gz`/`bz2`/`xz` esa shu to'plamni kichiklashtiradi (siqadi). Birinchi o'rganilganda harf kombinatsiyalari esda qolmaydi — bu normal. Ish jarayonida yodlanadi. ### Siqish vositalari ```bash # gzip/gunzip gzip fayl.txt # fayl.txt.gz yaratadi, original o'chadi gunzip fayl.txt.gz # fayl.txt ga qaytaradi gzip -d fayl.txt.gz # gunzip bilan bir xil gzip -k fayl.txt # -k: keep, original o'chirmaydi # zip/unzip (Windows bilan moslik uchun qulay) zip arxiv.zip fayl1 fayl2 zip -r arxiv.zip papka/ unzip arxiv.zip unzip -l arxiv.zip # Faqat tarkibni ko'rish # 7zip 7z a arxiv.7z fayl1 fayl2 7z x arxiv.7z ``` --- ## Ruxsatlar va egaik — `chmod`, `chown` ### `chmod` — fayl huquqlarini o'zgartirish !!! tip "Oddiy qilib aytganda" Har bir fayl uchun uchta guruh: **egasi** (u), **guruh** (g), **boshqalar** (o). Har biriga uchta huquq: **o'qish** (r=4), **yozish** (w=2), **ishlatish** (x=1). Ularni qo'shsak raqam hosil bo'ladi: `rwx = 7`, `rw- = 6`, `r-- = 4`. ```bash # Raqamli usul chmod 755 fayl.txt # rwxr-xr-x: egasi to'liq, boshqalar o'qish+ishlatish chmod 644 fayl.txt # rw-r--r--: egasi o'qish+yozish, boshqalar faqat o'qish chmod 600 fayl.txt # rw-------: faqat egasi ko'ra oladi (kalit fayllar) chmod 777 fayl.txt # rwxrwxrwx: hamma hamma narsani qila oladi (xavfli!) # Belgilar usuli chmod u+x fayl.txt # Egasiga ishlatish huquqi qo'sh chmod g-w fayl.txt # Guruhdan yozish huquqini olib tashla chmod o=r fayl.txt # Boshqalarga faqat o'qish chmod a+r fayl.txt # Hammaga o'qish qo'sh (a = all) # Rekursiv chmod -R 755 papka/ # Papka va barcha ichidagilarga ``` **DevOps amaliyotida:** ```bash # Veb fayllar chmod -R 644 /var/www/html/ chmod -R 755 /var/www/html/scripts/ # Ilova fayllar chmod 755 /opt/myapp/bin/* chmod 600 /opt/myapp/config/secrets.conf # SSH kalitlari (SSH aniq huquqlarni talab qiladi) chmod 700 ~/.ssh/ chmod 600 ~/.ssh/id_rsa chmod 644 ~/.ssh/id_rsa.pub chmod 600 ~/.ssh/authorized_keys # Skriptlarni ishlatish uchun ruxsat berish chmod +x deploy.sh ```

🔬 Chuqurroq — maxsus bitlar: SUID, SGID, Sticky

```bash # SUID — fayl egasi nomidan ishlatish chmod u+s dastur # "setuid" bit chmod 4755 dastur # raqamli # SGID — guruh nomidan ishlatish chmod g+s papka/ # Papkada yaratilgan fayllar guruhni meros oladi chmod 2755 papka/ # Sticky bit — faqat egasi o'chira oladi chmod +t /tmp # /tmp klasik misol: barcha yoza oladi, faqat o'zinikilni o'chira oladi chmod 1777 /tmp # SUID/SGID fayllarni xavfsizlik uchun tekshirish find /usr -perm -4000 # Barcha SUID fayllar find /usr -perm -2000 # Barcha SGID fayllar ``` `/tmp` papkasida sticky bit bor — shuning uchun siz `/tmp/boshqa_fayl.txt` ni o'chira olmaysiz, faqat o'zingiz yaratganlarni o'chira olasiz.

### `chown` — fayl egasini o'zgartirish ```bash # Egasini o'zgartirish chown ali fayl.txt chown ali:developers fayl.txt # egasi va guruhi birga chown :developers fayl.txt # Faqat guruhni o'zgartirish # Rekursiv chown -R ali:developers papka/ # Namunaviy fayldan olish chown --reference=ref_fayl maqsad_fayl ``` **DevOps amaliyotida:** ```bash # Veb server fayllar chown -R www-data:www-data /var/www/html/ # Ilova fayllar chown -R app:app /opt/myapp/ # Log fayllar chown -R syslog:adm /var/log/ chmod 640 /var/log/*.log # Docker socket chown root:docker /var/run/docker.sock chmod 660 /var/run/docker.sock ``` --- ## Amaliy DevOps stsenariylari ### 1. Log tahlili va tozalash ```bash #!/bin/bash # Log tahlil va tozalash skripti LOG_DIR="/var/log" DAYS_TO_KEEP=30 # Katta log fayllarni topish echo "=== Katta log fayllar (>100MB) ===" find $LOG_DIR -name "*.log" -size +100M -exec ls -lh {} \; # Eski log fayllar echo "=== Eski log fayllar (>$DAYS_TO_KEEP kun) ===" find $LOG_DIR -name "*.log" -mtime +$DAYS_TO_KEEP # Eski loglarni arxivlash echo "=== Eski loglarni arxivlash ===" find $LOG_DIR -name "*.log" -mtime +$DAYS_TO_KEEP -exec gzip {} \; # Juda eski arxivlarni o'chirish find $LOG_DIR -name "*.gz" -mtime +90 -delete # Xulosa echo "=== Log papka hajmi ===" du -sh $LOG_DIR/* ``` ### 2. Ilova joylash (deployment) ```bash #!/bin/bash # Ilova joylash skripti APP_NAME="myapp" VERSION="v2.1.0" DEPLOY_DIR="/opt" BACKUP_DIR="/backup" # Joriy versiyani zaxiralash if [ -L "$DEPLOY_DIR/$APP_NAME-current" ]; then CURRENT_VERSION=$(readlink $DEPLOY_DIR/$APP_NAME-current | xargs basename) echo "Joriy versiya zaxiralanmoqda: $CURRENT_VERSION" tar -czvf $BACKUP_DIR/$APP_NAME-$CURRENT_VERSION-$(date +%Y%m%d).tar.gz \ -C $DEPLOY_DIR $CURRENT_VERSION fi # Yangi versiyani joylash echo "$APP_NAME $VERSION joylashtirilmoqda" tar -xzvf $APP_NAME-$VERSION.tar.gz -C $DEPLOY_DIR # Symlink yangilash ln -sfn $DEPLOY_DIR/$APP_NAME-$VERSION $DEPLOY_DIR/$APP_NAME-current # Huquqlarni sozlash chown -R app:app $DEPLOY_DIR/$APP_NAME-$VERSION chmod 755 $DEPLOY_DIR/$APP_NAME-$VERSION/bin/* echo "Joylash muvaffaqiyatli tugadi" ``` ### 3. Xavfsizlik audit ```bash #!/bin/bash # Xavfsizlik audit skripti echo "=== Xavfsizlik audit hisoboti ===" echo "Sana: $(date)" echo # SUID/SGID fayllar echo "=== SUID/SGID Fayllar ===" find /usr -perm -4000 -o -perm -2000 2>/dev/null # Hamma yoza oladigan fayllar (xavfli) echo "=== Hamma yoza oladigan fayllar ===" find /var -perm -002 -type f 2>/dev/null | head -20 # Yuqori CPU jarayonlar echo "=== Yuqori CPU jarayonlar ===" ps aux | grep -v "^\[" | sort -k3 -nr | head -10 # Tarmoq ulanishlari echo "=== Faol tarmoq ulanishlari ===" netstat -tulpn | grep LISTEN # Oxirgi kirishlar echo "=== Oxirgi kirishlar ===" lastlog | grep -v "Never" # Muvaffaqiyatsiz SSH urinishlar echo "=== Muvaffaqiyatsiz SSH urinishlar ===" grep "Failed password" /var/log/auth.log 2>/dev/null | tail -10 ``` --- ## 🎒 Xulosa — eng muhimi Agar bu darsdan faqat 5 narsani eslab qolsangiz: 1. **`mkdir -p`** — ichma-ich papkalar yaratadi, o'rta papkalar yo'q bo'lsa ham ishlaydi. 2. **`cp -r`** — papkani nusxalashda `-r` majburiy; `mv` esa ko'chiradi, original qolmaydi. 3. **`rm -rf`** — QAYTARIB BO'LMAYDIGAN o'chirish. Ishlatingdan oldin `ls` bilan tekshiring. 4. **`tail -f`** — real vaqt log kuzatish; `find -mtime` — vaqt bo'yicha fayl izlash. 5. **`chmod 600`** — maxfiy fayllar (SSH kalitlar, parol fayllari) uchun standart; `chmod 755` — dasturlar uchun. !!! success "Keyingi qadam" Fayl operatsiyalarini o'zgandik. Keyingi darsda — **matn muharrirlari** (nano, vim): serverda grafik interfeys bo'lmaganda fayllarni qanday tahrirlash kerakligini o'rganamiz. Vim'ning birinchi bosqichi odatda "qanday chiqish kerak?" degan savol bilan boshlanadi — javobini oldindan bilasiz: `:q!`