Setiap sysadmin Linux telah berada di sana. Anda SSH menjadi pelayan pengeluaran, dan ada sesuatu yang tidak kena. Purata muatan adalah melalui bumbung, tapak web merangkak, dan `atas` menunjukkan sedozen proses misteri. awak buat apa? Sebelum anda boleh menyelesaikan masalah, anda perlu memahami perkara yang sedang berjalan — dan ini bermakna menguasai pengurusan proses Linux.

Proses adalah denyutan jantung mana-mana sistem Linux. Setiap program yang dijalankan, setiap daemon latar belakang, setiap tugas cron — semuanya adalah proses. Mengetahui cara memeriksa, mengawal, mengutamakan dan mengasingkannya adalah perkara yang memisahkan penolak butang daripada sysadmin sebenar. Panduan ini merangkumi segala-galanya daripada asas `ps` kepada kawalan sumber lanjutan dengan cgroups v2.

---

Memahami Proses Linux: Asas

proses hanyalah contoh program yang sedang berjalan. Apabila anda menaip `ls` dalam terminal anda, shell membuat proses baharu, memuatkan binari `ls` ke dalam ingatan, melaksanakannya dan menunggu sehingga ia selesai. Setiap proses mendapat PID (Process ID) yang unik — nombor yang mengenal pastinya kepada kernel.

Keadaan Proses

Setiap proses pada sistem Linux berada dalam salah satu daripada keadaan ini pada bila-bila masa:

Petua Pro: Bilangan proses yang tinggi dalam `D` (tidur tanpa gangguan) biasanya bermaksud masalah cakera. Anda tidak boleh membunuh ini dengan `kill -9` — anda perlu membetulkan isu I/O yang mendasari.

Hubungan Ibu Bapa-Anak

Setiap proses (kecuali PID 1 — `systemd` atau `init`) mempunyai proses induk (PPID). Apabila ibu bapa meninggal dunia, anak-anaknya menjadi anak yatim dan diterima pakai oleh PID 1. Inilah sebabnya daemon yang direka bentuk dengan betul mengendalikan penutupan yang anggun — mereka perlu membersihkan proses anak mereka sebelum keluar.

```bash

Lihat pokok proses

pstree -p

Tunjukkan PID, PPID, dan arahan untuk setiap proses

ps -eo pid,ppid,cmd ```

---

Perintah ps: Alat Pertama dan Paling Berkuasa Anda

`ps` ialah pisau Swiss Army untuk pemeriksaan proses. Walaupun kebanyakan sysadmin mengetahui `ps aux`, terdapat banyak lagi perkara di bawah hud.

Doa ps penting

```bash

Klasik: semua proses untuk semua pengguna

ps aux

Gaya BSD dengan output tersuai

ps aux --sort=-%mem # Isih mengikut penggunaan memori (menurun) ps aux --sort=-%cpu # Isih mengikut penggunaan CPU (menurun)

Lihat baris arahan penuh (tidak dipotong)

ps auxww

Tunjukkan pokok proses

ps axjf

Format output tersuai — tunjukkan dengan tepat apa yang anda perlukan

ps -eo pid,ppid,pengguna,%cpu,%mem,stat,mula,masa,cmd --sort=-%cpu

Tunjukkan urutan dalam proses

ps -eLf | grep nginx

Tunjukkan hanya proses yang dimiliki oleh pengguna tertentu

ps -u www-data -o pid,cmd,%mem ```

Membaca ps Output

Apabila anda menjalankan `ps aux`, lajur `STAT` menceritakan kisah itu. Proses yang menunjukkan `R+` sedang aktif berjalan di latar depan. `S` bermaksud ia sedang tidur dengan tenang. `D` bermakna ia tersekat menunggu cakera I/O. `Z` bermaksud ia adalah zombi — mati tetapi tidak dituai. Dan `+` bermaksud ia berada dalam kumpulan proses latar depan.

Helah yang paling berguna: Paip `ps` untuk menapis bunyi:

```bash

Cari 5 pengguna memori teratas

ps aux --sort=-%mem | kepala -6

Cari semua proses berjalan sebagai akar

ps -U root -o pid,cmd --no-headers

Kira jumlah proses

ps aux --no-headers | wc -l ```

Pelayan yang sihat biasanya menjalankan 150-400 proses bergantung pada beban kerja. Jika anda melihat 1000+, sesuatu mungkin menimbulkan terlalu banyak utas atau proses.

---

Pemantauan Masa Nyata dengan bahagian atas dan htop

Walaupun `ps` memberi anda syot kilat, `atas` dan `htop` memberi anda paparan langsung yang menyegarkan aktiviti sistem.

atas: Terbina Dalam dan Sentiasa Tersedia

```bash
atas
```

Di dalam `atas`, arahan interaktif patut dihafal:

```bash

Mod kelompok — berguna untuk skrip dan pengelogan

atas -b -n 1

Pantau hanya proses yang dimiliki oleh pengguna tertentu

atas -u www-data ```

htop: Lebih bagus, tetapi Tidak Sentiasa Dipasang

```bash

Pasangnya

sudo apt install htop -y # Debian/Ubuntu
sudo dnf pasang htop -y # RHEL/Fedora
```

htop menunjukkan:

• CPU berkod warna dan bar memori


• Pemandangan pokok (F5)


• Sokongan tetikus


• Pembunuhan proses mudah dengan kekunci anak panah + F9

```bash

Pandangan pokok dari baris arahan

htop -t
```

---

Isyarat Proses: Bahasa Kawalan

Isyarat ialah cara kernel dan pengguna berkomunikasi dengan proses. Setiap sysadmin mesti tahu enam ini:

```bash

Penutupan anggun

bunuh -15 1234 # atau hanya: bunuh 1234

Paksa bunuh (pilihan terakhir)

bunuh -9 1234 # atau: bunuh -SIGKILL 1234

Muat semula konfigurasi (contoh apache)

bunuh -1 $(cat /var/run/apache2.pid) bunuh -HUP $(cat /var/run/apache2.pid)

Jeda dan sambung semula proses

bunuh -STOP 1234 # Jeda ia bunuh -SAMB 1234 # Sambung semula

Bunuh semua proses mengikut nama

pkill -f "pelayan nod.js" killall nginx ```

Peraturan emas proses pembunuhan: Sentiasa cuba SIGTERM (15) dahulu. Beri proses 5-10 saat untuk membersihkan. Hanya naik ke SIGKILL (9) jika ia mengabaikan anda. SIGKILL tidak membenarkan proses menutup pengendalian fail, siram penimbal atau membersihkan memori kongsi — ia boleh menyebabkan sistem anda berada dalam keadaan tidak konsisten.

---

Keutamaan Proses: nice and renice

Linux menggunakan sistem keutamaan yang dipanggil nilai bagus untuk menentukan berapa banyak masa CPU yang diperolehi oleh sesuatu proses. Julat ialah -20 (keutamaan tertinggi) hingga +19 (keutamaan terendah). Lalai ialah 0.

```bash

Mulakan proses dengan keutamaan yang rendah

bagus -n 19 ./backup.sh

Tukar keutamaan proses berjalan

renice -n 10 -p 1234

Renice semua proses yang dimiliki oleh pengguna

renice -n 5 -u www-data ```

Bila hendak menggunakan bagus:

• Keutamaan tinggi (+19): Pemprosesan kelompok, sandaran, pemampatan log — apa-apa yang tidak boleh menjejaskan perkhidmatan yang dihadapi pengguna
• Lalai (0): Kebanyakan proses biasa
• Keutamaan rendah (-20 hingga -5): Perkhidmatan sensitif kependaman (pelayan pangkalan data, VoIP, apl masa nyata). Gunakan dengan berhati-hati!

```bash

Tingkatkan proses pangkalan data kepada keutamaan tinggi

sudo renice -n -5 -p $(pgrep mysqld)

Kurangkan keutamaan pemutar log

sudo renice -n 15 -p $(pgrep logrotate) ```

Amaran: Hanya root boleh menetapkan nilai bagus negatif (keutamaan lebih tinggi). Pengguna biasa hanya boleh membuat proses mereka lebih bagus (keutamaan lebih rendah). Ini menghalang pengguna penyangak daripada memonopoli CPU.

---

cgroups v2: Kawalan Sumber Berbutir Halus

cgroups (kumpulan kawalan) ialah mekanisme kernel untuk mengehadkan, mengira dan mengasingkan penggunaan sumber (CPU, memori, cakera I/O, rangkaian) kumpulan proses. Linux moden menggunakan cgroups v2 (hierarki bersatu), diurus terutamanya melalui systemd.

Kawalan Sumber sistemd

Setiap perkhidmatan systemd boleh menggunakan had sumber secara langsung dalam fail unitnya:

```ini
[Perkhidmatan]
CPUQuota=50% # Hadkan kepada 50% daripada satu CPU
MemoryMax=512M # Had memori keras
MemoryHigh=384M # Had memori lembut (mencetuskan tuntutan semula)
TasksMax=100 # Bilangan maksimum tugas (proses/benang)
IOReadBandwidthMax=/dev/sda 100M # Baca had lebar jalur
IOWriteBandwidthMax=/dev/sda 50M # Tulis had lebar jalur
```

Mohon dan sahkan:

```bash
sudo systemctl daemon-reload
sudo systemctl mulakan semula myapp.service

Semak penggunaan sumber semasa

systemctl tunjukkan myapp.service --property=MemoryCurrent systemctl tunjukkan myapp.service --property=CPUUsageNSec ```

Menggunakan systemd-run untuk Kawalan Sumber Ad-Hoc

Tidak mahu menulis fail perkhidmatan? Gunakan `systemd-run` untuk menggunakan had dengan cepat:

```bash

Jalankan arahan dengan had ingatan

systemd-run --user --scope -p MemoryMax=256M ./memory-hungry-script.sh

Jalankan dengan had CPU

sudo systemd-run --scope -p CPUQuota=30% ./slow-down.sh

Skop cgroup — jalankan dengan had I/O

sudo systemd-run --scope -p IOReadBandwidthMax="/dev/sda 10M" rsync -av /large-files/ /backup/ ```

cgroups v2 Hierarki

Anda boleh memeriksa cgroups terus melalui sistem fail di `/sys/fs/cgroup/`:

```bash

Lihat semua pengawal cgroup

ls /sys/fs/cgroup/

Semak penggunaan memori untuk perkhidmatan systemd

cat /sys/fs/cgroup/system.slice/myapp.service/memory.current

Tetapkan had maksimum memori secara dinamik

echo 536870912 > /sys/fs/cgroup/system.slice/myapp.service/memory.max ```

Bila Menggunakan cgroups vs nice

---

Proses Zombi: Mengesan dan Berurusan Dengannya

Proses zombi ialah proses mati yang belum dituai oleh induknya. Ia muncul dalam `ps` dengan keadaan `Z` dan teg `[defunct]`.

```bash

Cari semua zombi

ps aux | awk '{jika ($8 == "Z") cetak}'

Kira zombi

ps aux --no-headers | awk '{jika ($8 == "Z") cetak}' | wc -l ```

Mengapa zombi buruk: Proses zombi telah mengeluarkan ingatan dan sumbernya, tetapi ia masih menempati satu slot dalam jadual proses. Memandangkan jadual proses kernel mempunyai saiz maksimum tetap (biasanya PID_MAX = 32768 secara lalai, 4194304 dengan kernel moden), terlalu banyak zombi boleh menghalang proses baharu daripada dicipta — keadaan penolakan perkhidmatan.

Cara membetulkan zombi:

1. Cari ibu bapa: `ps -o ppid= -p `


2. Jika ibu bapa masih hidup, hantar SIGCHLD: `bunuh -CHLD ` — ini memberitahu ibu bapa untuk menuai anak-anaknya


3. Jika itu tidak berjaya, bunuh ibu bapa: `bunuh ` — anak yatim diterima pakai dan dituai oleh init/systemd


4. Jika induk adalah PID 1 (systemd) dan ia tidak menuai, anda mempunyai pepijat kernel — but semula

```bash

Cari kiraan zombi di seluruh sistem

grep zombi /proc/stat

Atau lebih langsung

zombi=$(ps aux --no-headers | awk '{if ($8 == "Z") print}' | wc -l) echo "Proses zombie: $zombie" ```

---

Aliran Kerja Praktikal untuk Kerja Sysadmin Harian

1. Cari Apa Itu Sumber Hogging

```bash

Babi CPU (5 teratas)

ps aux --sort=-%cpu | kepala -6

Babi ingatan (5 teratas)

ps aux --sort=-%mem | kepala -6

Proses paling aktif oleh I/O (memerlukan iotop)

sudo iotop -oPa -n 1 ```

2. Bunuh Proses Tersekat Dengan Anggun

```bash

Langkah 1: Cari proses

ps aux | grep stuck-app

Langkah 2: Cuba penamatan yang anggun

bunuh -15 12345 tidur 5

Langkah 3: Semak sama ada ia masih hidup

ps -p 12345 --tiada pengepala

Langkah 4: Paksa bunuh jika masih berjalan

bunuh -9 12345 ```

3. Jejaki Kebocoran Sumber

```bash

Tonton penggunaan memori bagi proses tertentu dari semasa ke semasa

manakala benar; buat
ps -o rss -p 12345 --tiada pengepala | awk '{print strftime("%H:%M:%S"), $1/1024 " MB"}'
tidur 5
selesai
```

4. Cari Perkhidmatan Berjalan yang Tidak Perlu

```bash

Senaraikan semua perkhidmatan systemd yang sedang berjalan

systemctl list-units --type=service --state=running

Lumpuhkan apa-apa yang tidak sepatutnya ada

sudo systemctl disable --now bluetooth.service ```

---

Kesimpulan

Pengurusan proses Linux ialah kemahiran yang anda bina satu insiden pada satu masa. Mulakan dengan `ps` dan `top` — ia sentiasa tersedia dan sangat berkuasa sebaik sahaja anda belajar membaca outputnya. Tambahkan `kill` dan pengendalian isyarat pada memori otot anda. Kemudian lulus ke `nice`/`renice` untuk pelarasan keutamaan dan `cgroups`/systemd untuk kawalan sumber sebenar dalam persekitaran pengeluaran.

Sysadmin yang menguasai alatan ini ialah mereka yang boleh mendiagnosis pelayan di bawah beban dalam beberapa minit, bukan jam. Mereka adalah orang yang tidur sepanjang malam kerana had sumber mereka menghalang sebarang proses tunggal daripada menurunkan keseluruhan pelayan. Dan mereka adalah orang yang yakin boleh berkata, "Saya tahu betul-betul apa yang sedang berjalan pada sistem saya."

Lain kali pelayan anda perlahan, jangan but semula. Mulakan dengan `ps aux --sort=-%cpu | kepala -20` dan berusaha ke bawah. Anda bukan sahaja akan menyelesaikan masalah itu — anda akan memahaminya.