Это пошаговый маршрут изучения Linux с упором на практику. Каждый раздел содержит объяснение «почему это устроено именно так», разбор команд и обязательные задания, которые нужно выполнить руками в терминале. Чтение без повторения навыка не даёт — держите терминал открытым рядом с этим текстом.

Как работать с этим курсом: идите сверху вниз, не перепрыгивайте разделы; каждую команду набирайте руками, а не копируйте; в конце каждого блока выполняйте задание; специально ломайте систему в виртуалке и чините — это лучший способ учиться.

• Ведите конспект. Записывайте назначение каждой новой команды и её ключевые флаги своими словами — это закрепляет понимание лучше, чем перечитывание.
• Учитесь читать документацию. Освойте man, --help и утилиту tldr. Умение быстро найти ответ важнее, чем заучивание команд наизусть.
• Делайте снапшоты виртуалки перед рискованными экспериментами, чтобы можно было мгновенно откатиться и спокойно «ломать» систему без страха.
• Повторяйте с интервалами. Возвращайтесь к пройденным разделам через несколько дней — интервальное повторение переводит навык в долговременную память.
• Применяйте на реальной задаче. Поднимите свой домашний сервер или pet-проект и решайте практические проблемы, а не только учебные упражнения.
• Собирайте личную шпаргалку (cheat sheet) и пополняйте её по мере прохождения курса — со временем это станет вашим главным справочником.

Чтобы оставаться в курсе свежих новостей, релизов и инструментов экосистемы Linux:

• Telegram: t.me/linuxkalii
• ВКонтакте: vk.com/kali_linux_backtrack

Часть II. Практика

1. Подготовка окружения
2. Терминал и философия Linux
3. Оболочка (shell): как устроена командная строка
4. Навигация по файловой системе
5. Работа с файлами и папками
6. Просмотр и редактирование текста
7. Права доступа и владельцы
8. Пользователи, группы и sudo
9. Менеджеры пакетов
10. Текстовые редакторы
11. Поиск файлов и содержимого
12. Конвейеры, фильтры и обработка текста
13. Перенаправление потоков
14. Процессы и сигналы
15. systemd и службы
16. Логи и журналирование
17. Сеть
18. Файрвол и базовая безопасность
19. Архивы и сжатие
20. Переменные окружения и PATH
21. Ссылки: hard и symbolic
22. Bash-скрипты
23. Диски, разделы и монтирование
24. Cron и таймеры systemd
25. SSH и удалённый доступ
26. Установка софта из исходников
27. Диагностика и решение проблем
28. Проекты для закрепления
29. Хитрые приёмы и продвинутые команды
30. База по защите серверов
31. Чек-лист команд: проверь себя
32. Шпаргалка по командам
33. Глоссарий
34. Куда двигаться дальше
35. Продвинутое администрирование Linux
36. Полезная бесплатная литература
37. Полезные Telegram-каналы

Часть I. Теория: как устроен Linux изнутри

• T1. Что такое Linux на самом деле
• T2. Kernel space и user space, системные вызовы
• T3. Процессы: рождение, жизнь и смерть
• T4. Управление памятью: виртуальная память, страницы, swap
• T5. Файловые системы и inode: как данные лежат на диске
• T6. Загрузка системы: от кнопки питания до приглашения входа
• T7. Оболочка как интерпретатор: что происходит при вводе команды

Справочное

• Наглядные схемы
• Главный принцип

Хотите понять, почему всё работает именно так? Перед практикой или параллельно с ней прочитайте Часть I. Теория: как устроен Linux изнутри (ниже, разделы T1–T7): ядро, системные вызовы, процессы, память, inode, загрузка.

Несколько схем, которые удобно держать перед глазами. Они визуализируют то, что подробно разобрано в теории (Часть I) и практике.

Где вы и где ядро (слои системы):

┌─────────────────────────────────────────────┐
│   ВАШИ ПРОГРАММЫ (user space)                 │
│   bash · nginx · python · ls · vim            │
└───────────────┬───────────────────────────────┘
                │ системные вызовы (open/read/write/fork…)
┌───────────────▼───────────────────────────────┐
│   ЯДРО LINUX (kernel space)                    │
│   процессы · память · ФС · сеть · драйверы     │
└───────────────┬───────────────────────────────┘
                │
┌───────────────▼───────────────────────────────┐
│   ЖЕЛЕЗО: CPU · ОЗУ · диски · сеть             │
└────────────────────────────────────────────────┘

Дерево файловой системы (главные ветки):

/
├── bin, usr/bin  → программы
├── etc           → конфиги (текстовые файлы)
├── home/         → ваши данные
│   └── user/     → ~/.bashrc, ~/.ssh/ …
├── var/          → логи, кэши, базы (var/log/)
├── tmp/          → временное (чистится)
├── dev/          → устройства (диски, терминалы)
├── proc/, sys/   → виртуальные ФС (инфо о ядре)
└── boot/         → ядро (vmlinuz) и загрузчик

Загрузка системы (по шагам):

[Питание] → BIOS/UEFI → GRUB → ядро+initramfs
   → монтирование / → systemd (PID 1)
   → службы по зависимостям → target → вход

Жизненный цикл процесса:

        fork()            execve()
родитель ──────► копия ──────────► новая программа
                                        │ работает (R/S)
                                        ▼
                                   exit(код)
                                        │
                              ┌─────────┴──────────┐
                       родитель жив?          родитель умер?
                              │                      │
                      Z (зомби, ждёт           «сирота» →
                       wait() родителя)        усыновляет PID 1

Конвейер (pipe) — поток текста через фильтры:

cat access.log │ awk '{print $1}' │ sort │ uniq -c │ sort -rn │ head
   весь лог    →   только IP      → группа →  счёт   → по убыв. → топ-10

Разбор строки прав -rwxr-xr--:

 -   rwx      r-x      r--
тип владелец группа  остальные
 │    │        │        └─ r-- = 4 (только чтение)
 │    │        └────────── r-x = 5 (чтение + выполнение)
 │    └─────────────────── rwx = 7 (полный доступ)
 └──────────────────────── - файл, d папка, l ссылка

         chmod 754 file   →   7=rwx  5=r-x  4=r--

Жёсткая ссылка vs символическая (через inode):

  имя1 ─┐
        ├──► [inode #1234] ──► данные на диске   (жёсткие ссылки: тот же inode)
  имя2 ─┘

  symlink ──► [inode #5678: "путь/к/цели"] ┄┄► имя1   (отдельный файл с путём внутри)

Перед стартом нужна работающая система Linux. Выберите один из вариантов:

• Виртуальная машина (рекомендуется для старта). Поставьте VirtualBox или VMware, скачайте образ Ubuntu Server, Debian или Fedora. Виртуалку не жалко сломать — а ломать вы будете, и это нормально. Сделайте снапшот сразу после установки: к нему можно откатиться, если что-то испортите.
• WSL2 на Windows. Команда wsl --install в PowerShell от администратора. Быстро, но это урезанная среда: нет собственного загрузчика ядра и полноценного systemd на старых версиях, поэтому часть разделов про службы и загрузку отработать не получится.
• Вторая система на диске (dual boot). Самый «настоящий» вариант, но к нему лучше переходить, когда уже освоитесь.
• Облачный VPS. За небольшие деньги можно арендовать сервер и тренироваться на «боевом» окружении с реальным белым IP — отлично для разделов про SSH, файрвол и веб-сервер.

Для обучения берите дистрибутив без графики (Ubuntu Server или Debian netinstall). Так вы быстрее привыкнете жить в терминале.

Чем дистрибутивы отличаются: семейство Debian/Ubuntu использует пакеты .deb и менеджер apt, оно самое популярное и про него больше всего гайдов. Fedora/RHEL/CentOS используют .rpm и dnf, это база корпоративного мира (RedHat). Arch — для тех, кто хочет собрать систему вручную и понять каждый компонент. Начните с Ubuntu/Debian.

Задание: установите дистрибутив в виртуалку, сделайте снапшот, войдите и выполните uname -a. Запишите, какое у вас ядро и архитектура.

Дистрибутив (distro) — это собранный комплект: ядро Linux, системные утилиты, менеджер пакетов и набор программ по умолчанию. Ядро у всех почти одинаковое, различаются в основном менеджер пакетов, цикл обновлений, набор предустановленного ПО и философия проекта. Не существует «лучшего» дистрибутива — есть подходящий под конкретную задачу.

1. Какой менеджер пакетов и формат? Это определяет, какими командами вы будете ставить софт и какие гайды вам подойдут. Семейство Debian/Ubuntu — пакеты .deb и apt. Семейство RHEL/Fedora — .rpm и dnf. Arch — pacman. openSUSE — zypper.
2. Какой цикл релизов? Stable (фиксированные версии: Debian, RHEL) — реже обновления, выше предсказуемость, идеально для серверов. Rolling (непрерывные обновления: Arch, openSUSE Tumbleweed) — всегда свежий софт, но требует внимания.
3. Кто за ним стоит и сколько живёт? Корпоративная поддержка (Red Hat, Canonical, SUSE) и долгий срок поддержки (LTS) важны для продакшена. Community-дистрибутивы дают больше свободы.

• Debian — эталон стабильности и свободного ПО. Пакеты .deb, менеджер apt. Берут на серверы, где важна надёжность и редкие обновления.
• Ubuntu (на базе Debian) — самый популярный «вход» в Linux. Версии LTS поддерживаются 5 лет. Огромное community, больше всего гайдов. Ubuntu Server — лучший старт для изучения администрирования.
• Linux Mint (на базе Ubuntu) — дружелюбный десктоп для перехода с Windows. Хорош как первая графическая система, но для учёбы лучше всё же серверный вариант.
• Fedora — витрина новых технологий Red Hat. Пакеты .rpm, dnf. Свежий софт, но релизы живут недолго (~13 месяцев).
• RHEL / Rocky Linux / AlmaLinux / CentOS Stream — корпоративная база. Rocky и Alma — бесплатные клоны RHEL, на них стоит тренироваться, если цель — работа в энтерпрайзе и сертификаты Red Hat (RHCSA/RHCE).
• Arch Linux — собираете систему вручную из минимума, ставите только нужное. Rolling-релизы и лучшая в мире документация (Arch Wiki). Берут, чтобы понять, из чего состоит система. Не первый дистрибутив для новичка.
• openSUSE (Leap — стабильный, Tumbleweed — rolling) — zypper, отличный графический инструмент настройки YaST.
• Alpine — крошечный дистрибутив на musl и BusyBox. Почти стандарт для Docker-образов из-за минимального размера.
• Kali / Parrot — заточены под пентест и безопасность, с предустановленным набором инструментов. Это специализированные системы, а не дистрибутивы для повседневной работы или первого знакомства с Linux.

• Учу Linux с нуля → Ubuntu Server LTS или Debian (netinstall, без графики). Максимум гайдов, минимум сюрпризов.
• Десктоп вместо Windows → Linux Mint или Ubuntu.
• Карьера в энтерпрайзе / сертификаты → Rocky Linux или AlmaLinux (клоны RHEL).
• Всегда свежий софт, готов разбираться → Fedora или openSUSE Tumbleweed.
• Хочу понять систему до винтика → Arch Linux (с чтением Arch Wiki).
• Контейнеры и образы → Alpine.

Совет: не «прыгайте» по дистрибутивам в поисках идеального. Выберите один из мейнстрима (Ubuntu/Debian), освойте его, а навыки потом легко переносятся на любой другой — основы одинаковы везде.

Задание: поставьте в виртуалку два разных дистрибутива из разных семейств (например, Ubuntu Server и Rocky Linux). Сравните, как в каждом ставится один и тот же пакет (apt install против dnf install), и запишите различия в свой конспект.

Kali Linux — дистрибутив на базе Debian, заточенный под тестирование на проникновение и анализ безопасности. Это не система «для повседневной жизни» и не первый дистрибутив для новичка: её ставят, когда уже понимаешь основы Linux и хочешь освоить инструменты безопасности. Ниже — практический маршрут настройки.

⚠️ Важно: все инструменты Kali используйте только в своей лаборатории или там, где у вас есть письменное разрешение. Сканировать и атаковать чужие системы без разрешения — это уголовная статья, а не «обучение».

• В виртуалке (рекомендуется для учёбы) — VirtualBox или VMware. Kali официально публикует готовые образы для обеих. Скачивайте ТОЛЬКО с официального сайта kali.org/get-kali и сверяйте контрольную сумму SHA256.
• Live-USB — загрузиться с флешки без установки, чтобы попробовать. Режим persistence позволяет сохранять файлы между запусками.
• WSL2 (Windows) — kali-linux ставится из Microsoft Store; удобно для консольных инструментов, но без «тяжёлого» GUI и Wi-Fi-магии.
• На «железо» голой системой ставить не нужно — для повседневки это неудобно и небезопасно.

# 1. Обновить систему целиком (Kali — rolling release, обновления важны)
sudo apt update && sudo apt full-upgrade -y

# 2. Поставить гостевые дополнения для VirtualBox (буфер обмена, экран)
sudo apt install -y virtualbox-guest-x11 && sudo reboot

# 3. Сменить дефолтный пароль пользователя (раньше был kali/kali)
passwd

# 4. Посмотреть, какие метапакеты инструментов доступны
sudo apt install -y kali-tweaks   # удобная утилита настройки

Полный Kali тяжёлый. Часто разумнее ставить нужные группы инструментов:

• kali-linux-headless — без графики, только консоль (для серверов и VPS).
• kali-linux-default — стандартный набор, который идёт с установщиком.
• kali-linux-large — расширенный набор инструментов.
• kali-tools-web, kali-tools-wireless, kali-tools-forensics — точечные группы под задачу.

apt search kali-tools     # посмотреть все группы
sudo apt install -y kali-tools-web

• Не работайте под root постоянно. Современная Kali по умолчанию создаёт обычного пользователя — так и оставьте, поднимайте права через sudo.
• Снимок (snapshot) виртуалки делайте сразу после чистой настройки — сможете откатиться, если что-то сломаете.
• Изолируйте лабораторию. Уязвимые мишени (Metasploitable, DVWA, машины с HackTheBox/TryHackMe) держите в отдельной внутренней сети виртуалки, а не в общей с домашними устройствами.
• Обновляйтесь регулярно — rolling release быстро устаревает.

• TryHackMe и HackTheBox — готовые уязвимые машины и пошаговые комнаты для обучения.
• Metasploitable 2/3, DVWA, OWASP Juice Shop — намеренно уязвимые мишени, которые ставятся в свою же виртуальную сеть.
• VulnHub — образы уязвимых ВМ для скачивания.

Задание: разверните в VirtualBox связку из двух виртуалок в одной внутренней сети (Host-Only / Internal): Kali и Metasploitable 2. Из Kali выполните nmap -sV <ip-мишени>, определите открытые порты и версии сервисов и запишите результаты в конспект. Никаких реальных сетей — только своя лаборатория.

Несколько идей, без которых остальное кажется набором случайных команд.

• Всё есть файл. Диски, процессы, устройства и даже настройки ядра представлены как файлы. Поняв это, вы поймёте половину Linux.
• Маленькие программы, делающие одну вещь хорошо. Их соединяют в цепочки, передавая текст от одной к другой.
• Текст — универсальный интерфейс. Вывод любой команды можно отфильтровать, посчитать, отсортировать и передать дальше.
• Конфигурация — это текстовые файлы. Почти всё в системе настраивается правкой файлов в /etc, а не кликами в окошках. Это значит, что настройку можно сохранить, скопировать на другой сервер и положить в систему контроля версий.

Первые команды, чтобы осмотреться:

whoami      # под каким пользователем вы вошли
hostname    # имя машины
pwd         # текущая папка (print working directory)
uname -a    # информация о ядре
date        # дата и время
uptime      # сколько система работает без перезагрузки
cat /etc/os-release   # какой это дистрибутив и версия

Как получить помощь по любой команде — это важнее, чем зубрить команды:

man ls          # полное руководство (q — выход, / — поиск)
ls --help       # краткая справка прямо в терминале
type ls         # что такое ls: команда, алиас или функция
apropos copy    # найти команды по ключевому слову

Задание: определите версию ядра через uname -r и название дистрибутива из /etc/os-release. Откройте man ls, найдите там, что делает флаг -h, и выйдите из мануала.

Оболочка — это программа, которая читает ваши команды и запускает их. Самая распространённая — bash, на новых системах часто zsh. Понимание оболочки экономит часы работы.

Структура команды: команда -флаги аргументы. Например в ls -l /etc: ls — команда, -l — флаг (опция), /etc — аргумент.

Горячие клавиши, которые ускоряют работу в разы:

Tab            # автодополнение команд, имён файлов и путей
Стрелки ↑ ↓    # листать историю команд
Ctrl+R         # поиск по истории команд (наберите часть команды)
Ctrl+A / Ctrl+E# в начало / в конец строки
Ctrl+U / Ctrl+K# удалить до начала / до конца строки
Ctrl+W         # удалить предыдущее слово
Ctrl+L         # очистить экран (как команда clear)
Ctrl+C         # прервать текущую команду
Ctrl+D         # выход из оболочки / конец ввода

История и алиасы:

history              # показать историю команд
!!                   # повторить последнюю команду
!42                  # выполнить команду номер 42 из истории
alias ll='ls -lah'   # создать короткий псевдоним

Псевдонимы и настройки пропадают после закрытия терминала. Чтобы сохранить навсегда — добавьте их в файл ~/.bashrc (для bash) и выполните source ~/.bashrc.

Подстановки шаблонов (globbing) — оболочка сама разворачивает шаблоны в список файлов:

ls *.txt        # все файлы с расширением .txt
ls file?.txt    # file1.txt, fileA.txt — ? это один любой символ
ls [abc]*       # файлы, начинающиеся на a, b или c

Задание: создайте алиас ll для ls -lah, проверьте его работу, затем добавьте его в ~/.bashrc, чтобы он сохранялся. Найдите через Ctrl+R любую команду, которую вы вводили раньше.

Этот блок объясняет, почему система ведёт себя так, как ведёт. Практик, понимающий теорию, чинит проблемы за минуты, а не часами гадает. Читать можно параллельно с практикой — возвращайтесь сюда, когда команда «работает магически» и хочется понять механизм.

Строго говоря, Linux — это только ядро (kernel), написанное Линусом Торвальдсом в 1991 году. То, что мы устанавливаем (Ubuntu, Debian, Fedora), — это дистрибутив: ядро Linux плюс системные утилиты (в основном из проекта GNU), менеджер пакетов, init-система и прикладные программы. Поэтому формально корректно говорить «GNU/Linux».

Ядро — это слой между железом и программами. Оно делает четыре вещи: управляет процессами (кто и когда выполняется на процессоре), управляет памятью (кому сколько ОЗУ), управляет файловыми системами (как данные лежат на диске) и управляет устройствами через драйверы (диски, сеть, видео).

Ядро Linux монолитное, но модульное: основная часть работает как единое целое, но драйверы можно подгружать и выгружать на лету как модули.

uname -r              # версия работающего ядра
lsmod                 # список загруженных модулей ядра
modinfo модуль        # информация о модуле
ls /boot              # здесь лежат файлы ядра (vmlinuz) и initramfs

Задание: посмотрите версию ядра и выведите список загруженных модулей. Найдите среди них модуль вашей сетевой или файловой системы.

Память и выполнение разделены на два мира. Kernel space — привилегированный режим, где работает ядро и имеет полный доступ к железу. User space — режим, где работают все обычные программы, и им напрямую трогать железо запрещено. Это защита: ошибка или вирус в программе не может напрямую обрушить всю систему.

Как же программа читает файл или открывает сетевое соединение, если ей нельзя к железу? Через системные вызовы (system calls) — это строго определённый «список просьб» к ядру: open, read, write, fork, execve, socket и около трёхсот других. Программа говорит ядру «прочитай мне этот файл», ядро проверяет права и выполняет операцию от её имени. Этот переход из user space в kernel space называется context switch и стоит процессорного времени.

strace ls             # показать ВСЕ системные вызовы команды ls
strace -c ls          # сводка: какие вызовы и сколько раз
ltrace команда        # то же для вызовов библиотек

Это мощнейший инструмент диагностики: когда программа «зависает» или «не находит файл», strace покажет, на каком именно системном вызове и к какому файлу она обращается.

Задание: запустите strace -c ls и посмотрите, какие системные вызовы делает простой ls. Найдите вызовы openat, read, write. Затем strace cat несуществующий_файл — увидите, как вызов openat возвращает ошибку ENOENT.

Процесс — это выполняющаяся программа со своим адресным пространством памяти, открытыми файлами и состоянием. У каждого есть PID и родитель (PPID).

Как рождаются процессы. В Linux новый процесс создаётся почти всегда парой системных вызовов: fork() создаёт точную копию текущего процесса (потомка), а execve() заменяет код потомка на новую программу. Поэтому у всех процессов есть родитель, и все они образуют дерево, растущее из процесса с PID 1 (init/systemd), который запускается ядром первым.

pstree -p             # дерево процессов с PID
ps -ef --forest       # то же в другом виде
echo $$               # PID вашей текущей оболочки
ps -o ppid= -p $$     # PID родителя вашей оболочки

Состояния процесса. В колонке STAT вывода ps aux вы видите буквы: R — выполняется или готов (running), S — спит, ожидая события (interruptible sleep), D — непрерываемый сон, обычно ждёт диск (вот почему процесс в D нельзя убить даже kill -9), Z — зомби (завершился, но родитель ещё не забрал код возврата), T — остановлен.

Зомби и сироты. Когда процесс завершается, он остаётся «зомби» до тех пор, пока родитель не прочитает его код возврата вызовом wait(). Если родитель умер раньше потомка, потомок становится «сиротой» и его усыновляет процесс с PID 1. Куча зомби в системе — признак бага в программе-родителе, которая не убирает за своими потомками.

Планировщик (scheduler). На одном ядре процессора в каждый момент выполняется только один процесс, но ядро десятки раз в секунду переключает их, создавая иллюзию параллельности. Какому процессу дать время, решает планировщик на основе приоритета. Приоритет настраивается значением nice от -20 (самый важный) до +19 (самый уступчивый).

nice -n 10 команда    # запустить с пониженным приоритетом
renice -n 5 -p PID    # изменить приоритет работающего процесса
top                   # колонки PR и NI показывают приоритет

Задание: выведите дерево процессов через pstree -p и найдите процесс с PID 1. Узнайте PID своей оболочки через echo $$. Запустите sleep 1000 &, посмотрите его состояние в ps aux (будет S — спит), измените ему приоритет через renice.

Каждый процесс думает, что владеет всей памятью машины целиком и непрерывно — от нулевого адреса. Это иллюзия, которую создаёт ядро вместе с процессором через виртуальную память. У каждого процесса своё виртуальное адресное пространство, и ядро переводит виртуальные адреса в реальные физические через таблицы страниц. Поэтому процессы изолированы: один не может случайно прочитать или испортить память другого.

Память управляется не байтами, а блоками фиксированного размера — страницами (обычно 4 КБ). Когда программе нужна память, ядро выдаёт ей страницы. Физическая страница попадает в ОЗУ только тогда, когда к ней реально обращаются (lazy allocation) — вот почему программа может «зарезервировать» гигабайты, но реально занять мало.

Swap — это область на диске, куда ядро вытесняет давно неиспользуемые страницы, когда ОЗУ заканчивается. Это спасает от падения, но диск в тысячи раз медленнее ОЗУ, поэтому активный своп = тормоза. Если своп забит и память кончилась, срабатывает OOM Killer (Out Of Memory Killer) — ядро убивает самый «прожорливый» процесс, чтобы спасти систему.

Также важно понимать колонки в free -h: память «занятая» под кэш файлов (buff/cache) — это не потеря, ядро отдаст её программам по требованию. Поэтому «свободно мало» в Linux — норма, смотреть нужно на колонку available.

free -h               # ОЗУ и swap; смотрите колонку available
cat /proc/meminfo     # подробнейшая статистика памяти
vmstat 1              # статистика памяти и подкачки каждую секунду
cat /proc/PID/status  # сколько памяти ест конкретный процесс
dmesg | grep -i oom   # срабатывал ли OOM Killer

Задание: посмотрите free -h и найдите колонку available — это реально доступная программам память. Откройте /proc/meminfo. Запустите vmstat 1, понаблюдайте за колонками si/so (swap in/out) — в норме они нули.

Это ключевая теория, без которой права доступа и ссылки кажутся магией.

Файл на диске состоит из двух частей: метаданных (кому принадлежит, права, размер, временные метки, где лежат блоки данных) и собственно данных. Метаданные хранятся в структуре, которая называется inode (индексный узел). У каждого файла есть свой inode со своим номером. Что важно — имя файла в inode не хранится.

Где же имя? Имя живёт в каталоге. Каталог в Linux — это, по сути, таблица соответствия «имя → номер inode». Когда вы открываете /etc/hosts, ядро идёт по каталогам: находит в / запись etc с её inode, в нём находит запись hosts с номером inode, и по этому inode читает метаданные и данные.

Отсюда логично следует устройство ссылок: жёсткая ссылка — это просто ещё одна запись «имя → тот же inode». Файл физически существует, пока на его inode ссылается хоть одна запись (счётчик ссылок в inode). Символическая ссылка — это отдельный маленький файл со своим inode, внутри которого записан путь-строка к цели; если цель удалить, ссылка повиснет.

Теперь понятно, почему чтобы удалить файл, нужны права на каталог, а не на сам файл: вы редактируете таблицу каталога, а не файл. И почему mv в пределах одной ФС мгновенный даже для гигабайтных файлов — меняется только запись в каталоге, данные не двигаются.

ls -i file            # номер inode файла
stat file             # все метаданные: inode, права, ссылки, времена
df -i                 # сколько inode свободно (можно упереться в них!)
ln target hardlink    # жёсткая ссылка — тот же inode
ln -s target symlink  # символическая — новый inode с путём внутри

Полезный факт: можно остаться без места, даже когда df -h показывает свободные гигабайты — если кончились inode (df -i). Так бывает при миллионах крошечных файлов.

Типы файловых систем: ext4 — стандарт для Linux, надёжный; XFS — для больших объёмов; Btrfs/ZFS — современные, со снапшотами и контрольными суммами; vfat/exFAT — для совместимости с флешками и Windows. Журналируемые ФС (ext4, XFS) ведут «журнал» операций, поэтому переживают внезапное отключение питания без потери целостности.

Задание: создайте файл, посмотрите его inode через ls -i и метаданные через stat. Сделайте жёсткую ссылку и убедитесь через ls -i, что у неё тот же номер inode, а счётчик ссылок (в stat) вырос до 2. Сделайте символическую ссылку — у неё будет другой inode. Удалите оригинал и сравните, что стало с каждой ссылкой.

Понимание загрузки спасает, когда система «не грузится». Этапы по порядку:

1. Прошивка (BIOS или UEFI). При включении процессор выполняет код прошивки материнской платы. Она проверяет железо (POST) и ищет загрузчик. Старый BIOS читает MBR (первый сектор диска), современный UEFI читает EFI-раздел с файлами .efi.
2. Загрузчик (bootloader), обычно GRUB. Показывает меню выбора ОС/ядра, загружает в память само ядро (vmlinuz) и временный образ initramfs, передаёт ядру параметры.
3. Ядро инициализируется. Распаковывается, поднимает управление памятью и процессором, монтирует временную ФС initramfs, в которой лежат драйверы, нужные чтобы добраться до настоящего диска (например, драйвер RAID или шифрования).
4. Монтируется настоящий корень /, и ядро запускает первый процесс — init, в современных системах это systemd, всегда с PID 1.
5. systemd поднимает остальное: монтирует файловые системы из /etc/fstab, запускает службы по зависимостям, доводит систему до нужной цели (target) — обычно multi-user.target (сервер) или graphical.target (десктоп), и показывает приглашение входа.

systemd-analyze            # сколько секунд грузилась система
systemd-analyze blame      # какие службы тормозили загрузку
systemctl get-default      # текущая цель загрузки (target)
journalctl -b              # все логи с момента последней загрузки
cat /proc/cmdline          # с какими параметрами загружено ядро

Понятие target заменило старые «уровни запуска» (runlevels). Цель — это набор служб, который должен быть поднят. Можно переключаться: systemctl isolate multi-user.target уведёт в режим без графики.

Задание: узнайте, сколько времени грузится ваша система через systemd-analyze, и какие службы тормозят через systemd-analyze blame. Посмотрите текущую цель загрузки и параметры, с которыми загружено ядро.

Когда вы набрали ls -l /etc и нажали Enter, оболочка проделывает строгую последовательность: разбивает строку на слова; раскрывает шаблоны (*, ?), переменные ($HOME), подстановки команд ($(...)); ищет программу ls по папкам из PATH; делает fork() (создаёт потомка) и execve() (запускает в нём ls); ждёт завершения и забирает код возврата.

Код возврата — число от 0 до 255, которое возвращает каждая программа: 0 значит успех, любое другое — ошибка. Это основа скриптов и автоматизации.

ls /etc; echo $?      # $? — код возврата последней команды (0 = успех)
ls /nonexistent; echo $?   # будет не ноль
true && echo "ок"     # && выполнит следующую команду только при успехе
false || echo "ошибка"  # || выполнит только при неудаче

На этом строятся цепочки: make && sudo make install установит, только если сборка прошла без ошибок. Понимание fork/exec также объясняет, почему cd — это встроенная команда оболочки, а не программа: если бы cd запускалась как потомок, она сменила бы папку в потомке, а ваша оболочка осталась бы на месте.

Задание: выполните успешную и заведомо ошибочную команду, каждый раз проверяя echo $?. Постройте цепочку mkdir test && cd test && pwd и поломайте её, убрав права, чтобы увидеть, как && останавливает выполнение.

Файловая система Linux — единое дерево от корня /. Никаких дисков C: и D:; всё, включая флешки и сетевые папки, монтируется в общее дерево.

ls           # список файлов
ls -l        # подробно: права, владелец, размер, дата
ls -la       # включая скрытые файлы (начинаются с точки)
ls -lh       # размеры в человекочитаемом виде (К, М, Г)
cd /etc      # перейти в папку
cd ..        # на уровень выше
cd ~         # в домашнюю папку
cd -         # вернуться в предыдущую папку
tree         # дерево папок (нужно установить пакет tree)

Абсолютные и относительные пути: путь, начинающийся с /, — абсолютный (от корня), всё остальное — относительно текущей папки. . означает текущую папку, .. — родительскую.

Ключевые директории:

Задание: дойдите от / до файла /etc/ssh/sshd_config, выведите его права через ls -l и объясните себе каждую букву в строке прав. Затем командой tree -L 1 / посмотрите содержимое корня.

mkdir projects                 # создать папку
mkdir -p a/b/c                 # создать вложенные папки сразу
touch notes.txt                # создать пустой файл / обновить дату
cp notes.txt backup.txt        # копировать
cp -r projects projects_copy   # копировать папку рекурсивно
cp -i file dest                # спрашивать перед перезаписью
mv notes.txt readme.txt        # переименовать или переместить
rm readme.txt                  # удалить файл
rm -r projects_copy            # удалить папку с содержимым
rm -i file.txt                 # спрашивать подтверждение перед удалением

Осторожно с rm: в терминале нет корзины, удалённое не вернуть. Правило новичка: перед rm -r сначала выполните ls на ту же цель, чтобы убедиться, что удаляете именно то, что думаете. Никогда не выполняйте rm -rf / и не подставляйте в путь непроверенные переменные.

Задание: создайте папку linux-practice, внутри три файла; один скопируйте, второй переименуйте, третий удалите. Создайте вложенную структуру a/b/c одной командой.

cat file.txt              # вывести весь файл
less file.txt             # листать (q — выход, / — поиск, G — в конец)
head -n 20 file.txt       # первые 20 строк
tail -n 20 file.txt       # последние 20 строк
tail -f /var/log/syslog   # следить за файлом в реальном времени
wc -l file.txt            # посчитать количество строк
nl file.txt               # вывести файл с номерами строк

less — ваш главный инструмент для чтения логов: внутри работают / для поиска вперёд, ? для поиска назад, n для следующего совпадения, G для перехода в конец, g — в начало.

Задание: откройте большой системный лог через less, найдите внутри слово error, перейдите в конец файла, выйдите. Затем выведите последние 5 строк того же лога одной командой.

Тема, на которой спотыкаются почти все. Разберитесь основательно.

Строка прав из ls -l выглядит так: -rwxr-xr--

• Первый символ — тип: - файл, d папка, l ссылка.
• Дальше три группы по три символа: права владельца, группы, остальных.
• r = чтение (4), w = запись (2), x = выполнение (1).

Для папки права значат немного другое: r — посмотреть список файлов, w — создавать и удалять файлы внутри, x — войти в папку (cd).

chmod 644 file.txt     # rw-r--r--  обычный файл
chmod 755 script.sh    # rwxr-xr-x  скрипт/программа
chmod 600 secret.key   # rw-------  только владелец, для приватных ключей
chmod +x script.sh     # добавить право выполнения
chmod -R 755 mydir     # рекурсивно для папки и содержимого
chown user file.txt    # сменить владельца (нужен sudo)
chown user:group file  # сменить владельца и группу

Как считать числа: rwx = 4+2+1 = 7, r-x = 4+1 = 5, r-- = 4. Поэтому 755 означает: владелец rwx, группа и остальные r-x. Шпаргалка: 755 для программ и папок, 644 для обычных файлов, 600 для секретов.

Задание: создайте скрипт hello.sh со строкой echo "привет". Запустите — получите «Permission denied». Дайте право выполнения через chmod +x и запустите снова ./hello.sh. Поймите, почему первый раз не сработало. Затем поставьте права 600 на файл и проверьте, что другой пользователь не может его прочитать.

В Linux всё многопользовательское. root — суперпользователь, которому разрешено всё. Работать под root постоянно опасно, поэтому используют sudo — выполнение одной команды с правами администратора.

sudo apt update            # выполнить команду от root
sudo -i                    # открыть полноценную сессию root (осторожно)
id                         # ваш ID и группы
whoami                     # текущий пользователь
sudo adduser alex          # создать пользователя
sudo passwd alex           # задать пароль
sudo usermod -aG sudo alex # добавить в группу sudo (право на sudo)
groups alex                # в каких группах состоит пользователь
su - alex                  # переключиться на другого пользователя

Где хранятся учётки: /etc/passwd (список пользователей), /etc/group (группы) и /etc/shadow (хэши паролей, читается только root). Группы нужны, чтобы давать права сразу набору пользователей — например, все в группе docker могут управлять контейнерами.

Задание: создайте пользователя test, добавьте в группу sudo, переключитесь на него через su - test, проверьте whoami и id, затем удалите: sudo deluser test.

Программы ставят не из exe-файлов, а из репозиториев через пакетный менеджер. Менеджер сам скачивает программу и все её зависимости. Зависит от дистрибутива.

Debian / Ubuntu (apt):

sudo apt update            # обновить список доступных пакетов
sudo apt upgrade           # обновить установленные пакеты
sudo apt install htop      # установить
sudo apt remove htop       # удалить
sudo apt autoremove        # убрать ненужные зависимости
apt search nginx           # поиск пакета
apt show nginx             # подробности о пакете

Fedora / RHEL (dnf):

sudo dnf install htop
sudo dnf remove htop
sudo dnf upgrade
dnf search htop

Arch (pacman):

sudo pacman -S htop        # установить
sudo pacman -Syu           # обновить систему
sudo pacman -R htop        # удалить
pacman -Ss htop            # поиск

Универсальные форматы, работающие на любом дистрибутиве: Snap (snap install), Flatpak (flatpak install) и AppImage (просто скачиваемый исполняемый файл). Они тяжелее, но удобны, когда нужного пакета нет в репозитории.

Важная привычка: всегда выполняйте apt update перед apt install, иначе можете поставить устаревшую версию.

Задание: установите htop, tree и ncdu. Запустите каждую: htop — процессы, tree — дерево папок, ncdu — что занимает место на диске. Затем удалите tree и снова установите.

Без умения править конфиги в терминале вы беспомощны на сервере. Минимум — nano, желательно база vim.

nano (простой, для новичка):

nano file.txt
# Ctrl+O — сохранить, Ctrl+X — выйти, Ctrl+W — поиск, Ctrl+K — вырезать строку

vim (мощный, с порогом входа). Главное — режимы:

• i — режим вставки (печатаете текст).
• Esc — обычный режим (команды).
• :w сохранить, :q выйти, :wq сохранить и выйти, :q! выйти без сохранения.
• dd удалить строку, yy копировать строку, p вставить, /слово поиск.

Если открыли vim случайно и не знаете как выйти: нажмите Esc, затем наберите :q! и Enter.

Совет: на сервере по умолчанию часто стоит именно vim, поэтому минимальные навыки в нём обязательны, даже если вы любите nano.

Задание: в vim создайте файл, напишите 5 строк, удалите одну через dd, скопируйте другую через yy и вставьте через p, сохраните и выйдите. Повторите создание файла в nano.

Две разные задачи: найти файл по имени и найти текст внутри файлов.

Поиск файлов по имени и свойствам — find:

find / -name "*.conf"               # найти файлы по имени
find /home -type f -size +100M      # файлы больше 100 МБ
find /var/log -name "*.log" -mtime -7  # изменённые за последние 7 дней
find . -type d -name "cache"        # найти папки с именем cache
find . -name "*.tmp" -delete        # найти и удалить (осторожно!)

Быстрый поиск по индексу — locate (нужно установить и обновить базу sudo updatedb):

locate nginx.conf    # мгновенный поиск по заранее построенному индексу
which python3        # где лежит исполняемый файл программы

Поиск текста внутри файлов — grep:

grep "error" /var/log/syslog        # строки со словом error
grep -i "error" file                # без учёта регистра
grep -r "TODO" .                    # рекурсивно по всем файлам в папке
grep -n "error" file                # показать номера строк
grep -v "debug" file                # строки БЕЗ слова debug
grep -c "error" file                # посчитать количество совпадений

Задание: найдите в /etc все файлы с расширением .conf, затем найдите среди файлов в /etc все строки, содержащие слово port (без учёта регистра), с номерами строк.

Здесь раскрывается сила терминала — соединение команд через | (pipe): вывод одной команды становится вводом следующей.

Кирпичики конвейеров:

wc -l               # посчитать строки
sort                # сортировать
sort -n             # сортировать как числа
uniq                # убрать повторы подряд (обычно после sort)
uniq -c             # посчитать число повторов
cut -d: -f1         # вырезать первое поле, разделитель :
awk '{print $1}'    # вывести первый столбец
sed 's/foo/bar/g'   # заменить foo на bar в каждой строке
tr 'a-z' 'A-Z'      # перевести в верхний регистр

Пример реальной задачи — топ-10 IP по числу запросов в логе веб-сервера:

cat access.log | awk '{print $1}' | sort | uniq -c | sort -rn | head -10

Разбор: awk берёт первый столбец (IP), sort группирует одинаковые рядом, uniq -c считает повторы, sort -rn сортирует по числу по убыванию, head -10 оставляет десятку.

Задание: выведите имена всех пользователей из /etc/passwd (первое поле, разделитель :) и отсортируйте по алфавиту. Затем посчитайте, сколько всего пользователей в системе (подсказка: wc -l).

У каждой программы есть три потока: ввод (stdin), вывод (stdout) и ошибки (stderr). Их можно перенаправлять в файлы.

echo "привет" > file.txt      # записать вывод в файл (перезаписать)
echo "ещё" >> file.txt        # дописать в конец файла
command 2> errors.txt          # перенаправить только ошибки
command > out.txt 2>&1         # и вывод, и ошибки в один файл
command < input.txt            # подать файл на вход программе
command 2>/dev/null            # выбросить ошибки в никуда

/dev/null — «чёрная дыра»: всё, что туда направлено, исчезает. Удобно, чтобы заглушить ненужный вывод.

Связка с конвейером: command | tee file.txt одновременно показывает вывод на экране и пишет в файл.

Задание: запишите вывод команды ls -la /etc в файл etc-list.txt, затем допишите в конец того же файла текущую дату командой date >> etc-list.txt. Проверьте результат через cat.

Каждая запущенная программа — процесс со своим ID (PID).

ps aux          # все процессы в системе
ps aux | grep nginx  # найти конкретный процесс
top             # живой монитор (q — выход)
htop            # удобнее top, с цветами и мышью
kill 1234       # послать процессу сигнал завершения (TERM)
kill -9 1234    # принудительно убить (KILL), последнее средство
pkill firefox   # убить по имени
nice / renice   # запустить / изменить приоритет процесса

Сигналы — это способ общения с процессами. SIGTERM (15) вежливо просит завершиться, SIGKILL (9) убивает мгновенно без возможности сохраниться, SIGHUP (1) часто заставляет службу перечитать конфиг. Всегда сначала пробуйте обычный kill, и только если процесс завис — kill -9.

Фоновые задачи:

sleep 100 &     # запустить в фоне
jobs            # список фоновых задач
fg              # вернуть на передний план
bg              # продолжить приостановленный в фоне
nohup long.sh & # запустить так, чтобы не убилось при выходе из сессии

(Ctrl+Z приостанавливает текущий процесс.)

Задание: запустите sleep 300 &, найдите PID через ps aux | grep sleep, завершите процесс обычным kill. Затем запустите ещё один и убейте его через pkill.

Современные дистрибутивы управляют сервисами через systemd. Это обязательно знать любому, кто администрирует сервер. Служба (unit) — это фоновая программа: веб-сервер, база данных, SSH.

systemctl status ssh         # статус службы
sudo systemctl start nginx   # запустить
sudo systemctl stop nginx    # остановить
sudo systemctl restart nginx # перезапустить
sudo systemctl reload nginx  # перечитать конфиг без полного перезапуска
sudo systemctl enable nginx  # автозапуск при загрузке системы
sudo systemctl disable nginx # убрать из автозапуска
systemctl list-units --type=service  # все запущенные службы
systemctl is-enabled nginx   # стоит ли в автозагрузке

Разница важна: start запускает службу прямо сейчас, enable ставит её в автозагрузку при следующей перезагрузке. Часто нужно и то, и другое: systemctl enable --now nginx.

Задание: установите nginx, запустите его, поставьте в автозагрузку командой enable --now, проверьте статус и откройте http://localhost (или внешний IP сервера) в браузере. Затем остановите службу и убедитесь, что страница перестала открываться.

Когда что-то ломается, ответ почти всегда в логах. Это первое место, куда смотрит администратор.

Системный журнал systemd — journalctl:

journalctl -u nginx          # логи конкретной службы
journalctl -f                # следить за логами в реальном времени
journalctl --since "1 hour ago"   # за последний час
journalctl --since today     # за сегодня
journalctl -p err            # только ошибки
journalctl -b                # логи с момента последней загрузки
journalctl -k                # сообщения ядра (dmesg)

Классические текстовые логи лежат в /var/log:

ls /var/log                  # список логов
tail -f /var/log/syslog      # общий системный лог (Debian/Ubuntu)
less /var/log/auth.log       # попытки входа и sudo

Задание: посмотрите логи службы ssh через journalctl -u ssh, затем выведите только ошибки за сегодня. Откройте /var/log/auth.log и найдите там записи о ваших командах sudo.

ip a                  # интерфейсы и их IP-адреса
ip route              # таблица маршрутизации (через что выходим в сеть)
ping 8.8.8.8          # проверить связь по IP
ping google.com       # проверить связь + работу DNS
curl ifconfig.me      # узнать свой внешний IP
ss -tulpn             # открытые порты и слушающие службы
dig google.com        # запрос к DNS, какой IP у домена
traceroute google.com # путь пакетов до хоста по шагам
nc -zv host 80        # проверить, открыт ли порт на удалённом хосте

Логика диагностики сети по шагам: сначала ping 8.8.8.8 (есть ли вообще интернет по IP), потом ping google.com (работает ли DNS), потом curl к нужному сайту (отвечает ли сервис). Так вы быстро поймёте, где обрыв.

Скачивание файлов и запросы к API:

curl -O https://example.com/file.zip   # скачать файл
wget https://example.com/file.zip      # то же другим инструментом
curl -s https://api.github.com/users/torvalds   # запрос к API
curl -I https://example.com            # только заголовки ответа

Задание: узнайте локальный IP через ip a, внешний — через curl ifconfig.me, проверьте интернет через ping, посмотрите слушающие порты через ss -tulpn и объясните, что за службы их заняли. Сделайте запрос curl -I к любому сайту и прочитайте код ответа.

Файрвол решает, какие подключения к серверу разрешены. На сервере с белым IP без него опасно.

ufw (простой, Ubuntu/Debian):

sudo ufw status              # текущие правила
sudo ufw allow 22            # разрешить SSH (порт 22)
sudo ufw allow 80,443/tcp    # разрешить веб (HTTP и HTTPS)
sudo ufw deny 23             # запретить порт
sudo ufw enable              # включить файрвол

ВАЖНО: прежде чем включать ufw enable на удалённом сервере, обязательно сначала разрешите порт SSH (allow 22), иначе вы отрежете себе доступ.

Базовые правила безопасности сервера: войдите по SSH-ключу и отключите вход по паролю; не работайте постоянно под root; держите систему в обновлениях (apt upgrade); установите fail2ban для защиты от перебора паролей; открывайте только те порты, что реально нужны.

Задание (в виртуалке, не на рабочем сервере): посмотрите статус ufw, разрешите порты 22 и 80, включите файрвол, проверьте правила. Затем выключите его обратно командой sudo ufw disable.

Архивы нужны для бэкапов, переноса файлов и экономии места.

tar -czf archive.tar.gz mydir/   # создать сжатый архив папки
tar -xzf archive.tar.gz          # распаковать архив
tar -tzf archive.tar.gz          # посмотреть содержимое без распаковки
zip -r archive.zip mydir/        # создать zip-архив
unzip archive.zip                # распаковать zip
gzip file.txt                    # сжать один файл (станет file.txt.gz)
gunzip file.txt.gz               # разжать

Запомнить флаги tar: c = create (создать), x = extract (извлечь), z = gzip-сжатие, f = file (имя файла), t = list (содержимое), v = verbose (показывать процесс). Самые частые связки: czf для создания, xzf для распаковки.

Задание: упакуйте папку /etc в архив etc-backup.tar.gz, посмотрите его содержимое без распаковки, затем распакуйте в новую папку и убедитесь, что файлы на месте.

Переменные окружения — это настройки, доступные всем программам. Самая важная — PATH: список папок, где система ищет команды.

echo $HOME           # домашняя папка
echo $PATH           # где ищутся команды (папки через :)
echo $USER           # имя пользователя
env                  # все переменные окружения
export MYVAR=hello   # задать переменную для текущей сессии
echo $MYVAR          # прочитать

Когда вы пишете ls, система ищет файл ls по очереди в каждой папке из PATH. Поэтому, чтобы запустить программу из текущей папки, нужно писать ./program — точка означает «здесь».

Чтобы переменная сохранялась навсегда, добавьте export MYVAR=... в файл ~/.bashrc или ~/.profile.

Задание: выведите свой PATH и разберите, какие папки в нём. Создайте переменную export PROJECT=/home/$USER/projects, проверьте её через echo, затем добавьте в ~/.bashrc, чтобы она сохранялась после перезапуска терминала.

Ссылки позволяют иметь один файл, доступный по нескольким путям.

ln -s /path/to/file link    # символическая ссылка (как ярлык)
ln /path/to/file hardlink   # жёсткая ссылка
ls -l                       # символические ссылки видны как link -> target
readlink link               # куда указывает символическая ссылка

Символическая ссылка (symlink) — это указатель на путь; если удалить оригинал, ссылка «сломается». Жёсткая ссылка указывает прямо на данные на диске; файл существует, пока есть хотя бы одна жёсткая ссылка. На практике в 95% случаев используют именно символические ссылки.

Где это нужно: symlink'и повсюду в системе — например, /usr/bin/python3 часто ссылается на конкретную версию python3.11.

Задание: создайте файл, сделайте на него символическую ссылку в другой папке, отредактируйте файл через ссылку и убедитесь, что изменения попали в оригинал. Затем удалите оригинал и посмотрите, что стало со ссылкой.

Когда команд много, их объединяют в скрипты — это начало автоматизации.

Скрипт бэкапа backup.sh:

#!/bin/bash
# Простой бэкап домашней папки

DATE=$(date +%Y-%m-%d)
SRC="$HOME/documents"
DEST="$HOME/backups"

mkdir -p "$DEST"
tar -czf "$DEST/backup-$DATE.tar.gz" "$SRC"
echo "Бэкап готов: $DEST/backup-$DATE.tar.gz"

Первая строка #!/bin/bash (shebang) говорит системе, какой программой выполнять скрипт. Не забудьте дать право выполнения: chmod +x backup.sh.

Базовые конструкции:

name="Linux"            # переменная (без пробелов вокруг =)
echo "Hello $name"     # подстановка переменной
read answer            # прочитать ввод пользователя

if [ -f "/etc/passwd" ]; then   # проверка: файл существует?
    echo "Файл существует"
else
    echo "Файла нет"
fi

for i in 1 2 3; do      # цикл по списку
    echo "Итерация $i"
done

for f in *.txt; do      # цикл по файлам
    echo "Найден: $f"
done

while [ $count -lt 5 ]; do   # цикл с условием
    echo $count
    count=$((count+1))
done

Полезные проверки в [ ]: -f файл существует, -d папка существует, -z строка пустая, -eq/-lt/-gt сравнение чисел. Аргументы скрипта доступны как $1, $2, а $# — их количество.

Задание: напишите скрипт, который принимает имя папки аргументом ($1), проверяет её существование через if [ -d ] и выводит количество файлов внутри. Запуск: ./count.sh /etc. Добавьте сообщение об ошибке, если папка не передана или не существует.

df -h               # сколько свободно на смонтированных дисках
du -sh /var/log     # размер конкретной папки
du -h --max-depth=1 /var | sort -rh   # что занимает место в /var
lsblk               # список дисков и разделов в виде дерева
mount               # что и куда смонтировано
sudo mount /dev/sdb1 /mnt   # смонтировать раздел в папку /mnt
sudo umount /mnt    # отмонтировать
free -h             # использование оперативной памяти

Монтирование — это «подключение» диска или раздела к папке в дереве. После mount /dev/sdb1 /mnt содержимое флешки становится доступно в /mnt. Постоянные точки монтирования прописываются в файле /etc/fstab.

Задание: найдите 5 самых больших папок в /var командой du -h /var --max-depth=1 | sort -rh | head -5. Посмотрите список всех дисков через lsblk и проверьте свободное место через df -h.

Автоматический запуск команд по расписанию.

crontab -e          # редактировать свои задачи
crontab -l          # показать задачи

Формат строки cron (5 полей времени + команда):

# минута час день_месяца месяц день_недели команда
0 3 * * *      /home/user/backup.sh    # каждый день в 3:00
*/15 * * * *   /home/user/check.sh     # каждые 15 минут
0 0 * * 0      /home/user/weekly.sh    # каждое воскресенье в полночь
30 2 1 * *     /home/user/monthly.sh   # 1-го числа каждого месяца в 2:30

Звёздочка означает «любое значение». Полезный сервис для проверки расписания — мысленно проговорите: «в такую-то минуту, такого-то часа...». Современная альтернатива — таймеры systemd (systemctl list-timers), они логируются в journald и удобнее для сложных сценариев.

Задание: настройте задачу cron, которая каждую минуту дописывает текущую дату в файл ~/cron-test.log (команда date >> ~/cron-test.log). Через пару минут проверьте файл, убедитесь, что строки добавляются, затем удалите задачу через crontab -e.

Главный инструмент работы с серверами — управление машиной через зашифрованное соединение.

ssh user@192.168.1.10         # подключиться к серверу
ssh -p 2222 user@host         # подключение на нестандартном порту
ssh-keygen -t ed25519         # сгенерировать пару ключей
ssh-copy-id user@host         # установить свой публичный ключ на сервер
scp file.txt user@host:/tmp/  # скопировать файл НА сервер
scp user@host:/tmp/file.txt . # скопировать файл С сервера
rsync -av dir/ user@host:/dir/ # синхронизировать папки (умнее scp)

Вход по ключу безопаснее и удобнее пароля. Пара ключей состоит из приватного (~/.ssh/id_ed25519, хранится только у вас, никому не передавать) и публичного (id_ed25519.pub, его кладут на сервер). После ssh-copy-id вы заходите без ввода пароля.

Настройки подключений удобно хранить в ~/.ssh/config:

Host myserver
    HostName 192.168.1.10
    User alex
    Port 2222

После этого достаточно команды ssh myserver.

Задание: сгенерируйте пару SSH-ключей через ssh-keygen, изучите содержимое ~/.ssh/. Если есть две машины или виртуалки — настройте вход по ключу через ssh-copy-id и зайдите без пароля. Пропишите хост в ~/.ssh/config.

Иногда нужной программы нет в репозитории, и её собирают из исходного кода. Классическая последовательность:

sudo apt install build-essential   # компилятор и инструменты сборки
git clone https://github.com/user/project.git
cd project
./configure        # проверить систему и подготовить сборку
make               # скомпилировать
sudo make install  # установить в систему

Не у всех проектов есть ./configure — у одних cmake, у других просто make, у Go/Rust свои сборщики. Всегда читайте файл README или INSTALL в репозитории проекта. Минус ручной сборки: такие программы не обновляются через пакетный менеджер, обновлять придётся вручную.

Задание: установите build-essential, клонируйте любой небольшой open-source проект на C с GitHub, прочитайте его инструкцию по сборке и попробуйте скомпилировать.

Навык, отличающий новичка от профессионала, — умение методично искать причину сбоя, а не паниковать.

Универсальный порядок действий, когда что-то не работает:

1. Прочитать сообщение об ошибке целиком — часто ответ прямо в нём.
2. Посмотреть статус и логи службы: systemctl status имя и journalctl -u имя.
3. Проверить ресурсы: место на диске (df -h), память (free -h), нагрузку (top).
4. Проверить права доступа к файлам (ls -l).
5. Проверить сеть, если проблема сетевая (ping, ss -tulpn).
6. Сформулировать точный текст ошибки и поискать его в интернете.

Частые причины проблем у новичков: закончилось место на диске (df -h покажет 100%); нет прав (Permission denied — нужен sudo или chmod); служба не запущена (systemctl status); опечатка в конфиге (после правки всегда systemctl restart и проверка логов); файрвол блокирует порт.

df -h                # не закончилось ли место
free -h              # хватает ли памяти
dmesg | tail         # последние сообщения ядра (ошибки железа/драйверов)
systemctl --failed   # какие службы упали
journalctl -p err -b # все ошибки с момента загрузки

Задание: специально сломайте конфиг nginx (впишите мусор в /etc/nginx/nginx.conf), попробуйте перезапустить службу, по статусу и логам найдите ошибку, почините конфиг и убедитесь, что служба снова поднялась. Это тренировка реального рабочего цикла.

Делайте их обязательно — именно проекты превращают знание команд в навык.

1. Свой веб-сервер. Поднимите nginx на виртуалке, отдайте свою статичную HTML-страницу, настройте автозапуск, откройте порт в файрволе и проверьте доступ.
2. Скрипт мониторинга. Bash-скрипт, который раз в 5 минут (через cron) проверяет свободное место и память и пишет предупреждение в лог, если места меньше 10%.
3. Бэкап-система. Скрипт + cron, архивирующий выбранную папку каждую ночь и хранящий только последние 7 архивов (старые удаляются автоматически).
4. Сервер с нуля (главный проект). Чистая Ubuntu Server: создайте пользователя, настройте вход по SSH-ключу, отключите вход по паролю и по root, поставьте файрвол с открытыми только нужными портами, установите fail2ban, поднимите веб-сервер. Это базовая «боевая» настройка любого сервера.
5. Анализатор логов. Скрипт, который из лога веб-сервера выводит топ-10 IP, топ запрашиваемых страниц и количество ошибок 404/500.

Этот блок — для тех, кто освоил основы и хочет работать быстрее и увереннее. Здесь собраны приёмы, которые отличают уверенного пользователя от новичка: они экономят минуты на каждой операции и спасают в нестандартных ситуациях. Разбирайте по одному и сразу пробуйте в терминале.

sudo !!              # повторить ПРЕДЫДУЩУЮ команду с sudo (забыли sudo — не набирайте заново)
!$                   # последний аргумент прошлой команды: mkdir /opt/app && cd !$
!*                   # все аргументы прошлой команды
^foo^bar             # повторить прошлую команду, заменив первое foo на bar
cd -                 # вернуться в предыдущую папку (переключатель между двумя)

Alt+. вставляет последний аргумент предыдущей команды — нажимайте несколько раз, чтобы листать аргументы более старых команд. Один из самых недооценённых приёмов: вы почти никогда не должны набирать длинный путь дважды.

Оболочка разворачивает {...} ещё до запуска команды — это экономит тонну набора:

mkdir -p project/{src,tests,docs}        # три папки одной командой
touch file{1..5}.txt                     # file1.txt … file5.txt
cp config.yml config.yml{,.bak}          # быстрый бэкап: создаёт config.yml.bak
mv report.txt{,.old}                     # переименовать в report.txt.old
echo {a,b,c}{1,2}                         # a1 a2 b1 b2 c1 c2 (декартово произведение)

Приём cp file{,.bak} разворачивается в cp file file.bak — самый быстрый способ сделать резервную копию перед правкой конфига.

Файл с именем -rf или с пробелами способен испортить день. Приёмы:

rm ./-rf             # имя, начинающееся с дефиса: добавьте ./ , чтобы это был не флаг
rm -- -rf            # или -- означает «дальше только аргументы, не флаги»
find . -name "* *" -type f   # найти файлы с пробелами в имени

Золотое правило: в скриптах всегда заключайте переменные с путями в кавычки — "$file", а не $file. Иначе пробел в имени разорвёт аргумент на два.

xargs берёт список из stdin и подставляет его как аргументы другой команде. Связка с find — рабочая лошадка администратора:

find . -name "*.log" -print0 | xargs -0 rm        # удалить все .log (безопасно к пробелам)
find . -name "*.txt" | xargs grep -l "TODO"       # в каких файлах есть TODO
echo "1 2 3" | xargs -n1 echo "число:"            # по одному аргументу за вызов
ls *.png | xargs -I{} cp {} backup/{}             # {} — место подстановки имени
find . -name "*.jpg" | xargs -P4 -I{} convert {} {}.webp   # -P4 = 4 процесса параллельно

Флаг -print0/-0 использует нулевой разделитель вместо перевода строки — единственный надёжный способ обработать имена с пробелами и спецсимволами.

<(команда) превращает вывод команды в «временный файл», который можно скормить туда, где ждут файл:

diff <(ls dir1) <(ls dir2)                  # сравнить содержимое двух папок без temp-файлов
diff <(sort a.txt) <(sort b.txt)            # сравнить отсортированные версии
comm -13 <(sort a) <(sort b)                # строки, которые есть только в b

Это любимый приём для сравнения вывода двух команд напрямую — без создания и последующей уборки временных файлов.

Потеряли SSH-соединение — и долгая команда умерла вместе с сессией. Решения:

nohup ./long.sh &> out.log &     # переживёт выход из сессии
disown -h %1                     # «отвязать» уже запущенную фоновую задачу от сессии

Но правильный инструмент для долгой удалённой работы — терминальный мультиплексор tmux (или screen):

tmux new -s work     # создать сессию с именем work
# Ctrl+b затем d      — отсоединиться (команды продолжают работать)
tmux attach -t work  # вернуться к сессии (хоть с другого компьютера)
tmux ls              # список сессий

Запустили обновление сервера в tmux, связь оборвалась — переподключились и продолжили как ни в чём не бывало. На реальных серверах это обязательная привычка.

После cat бинарного файла или сбоя терминал может показывать «кракозябры» и не реагировать нормально:

reset                # полный сброс состояния терминала
stty sane            # вернуть нормальные настройки ввода
Ctrl+C затем reset   # если ввод вообще сломан, наберите вслепую

sudoedit /etc/nginx/nginx.conf   # (или sudo -e) правильный способ править системные файлы под sudo
visudo                            # ЕДИНСТВЕННЫЙ верный способ править /etc/sudoers
                                  # — проверяет синтаксис и не даёт сохранить ошибку
nginx -t && systemctl reload nginx   # проверить конфиг ДО перезапуска
sshd -t                           # проверить конфиг SSH перед рестартом (иначе рискуете доступом)

Главный принцип безопасности: для критичных служб (sudoers, sshd, nginx) сначала проверяйте конфиг, потом перезапускайте. Сохранённая опечатка в /etc/sudoers может лишить вас sudo, а в sshd_config — доступа к серверу.

lsof /var/log/app.log        # какой процесс открыл этот файл
lsof -i :80                  # кто слушает порт 80
fuser -k 8080/tcp            # убить процесс, занявший порт 8080
lsof +D /mnt                 # почему не размонтируется: кто держит файлы в /mnt

Классическая ситуация «device is busy» при umount решается через lsof +D — он покажет процесс, который не даёт отмонтировать раздел.

watch -n 2 df -h             # раз в 2 секунды обновлять вывод df
watch -d free -h             # -d подсвечивает, что изменилось
watch -n1 'ss -tunp | grep :443'   # наблюдать за соединениями в реальном времени

du -ah / 2>/dev/null | sort -rh | head -20    # топ-20 самых больших объектов в системе
ncdu /                                         # интерактивный анализ диска (нужно установить)
find /tmp -type f -atime +30 -delete           # удалить файлы, к которым не обращались 30+ дней
journalctl --vacuum-size=200M                  # обрезать журнал systemd до 200 МБ

Если df -h показывает 100%, но du не находит виновника — возможно, удалённый, но всё ещё открытый процессом файл. Найти: lsof | grep deleted. Освобождается рестартом процесса.

alias rm='rm -i'                    # переспрашивать перед удалением (в ~/.bashrc)
set -euo pipefail                   # в начало bash-скриптов: падать при первой ошибке
trap 'echo "Ошибка на строке $LINENO"' ERR   # ловушка ошибок в скрипте

Строка set -euo pipefail в начале скрипта — признак зрелого автора: -e останавливает скрипт при ошибке, -u запрещает необъявленные переменные (ловит опечатки в именах), pipefail ловит ошибку в любом звене конвейера, а не только в последнем.

Задание: потренируйте три приёма на выбор: сделайте бэкап конфига через cp file{,.bak}, найдите через lsof -i :22 процесс, слушающий SSH-порт, и запустите долгую команду в сессии tmux, отсоединитесь и подключитесь обратно.

Сервер с белым IP сканируют боты уже через минуты после включения. Этот раздел — практический минимум, который превращает «голую» систему в защищённую. Идите по порядку: каждый шаг закрывает конкретный вектор атаки. Всё отрабатывайте сначала в виртуалке, и только поняв — применяйте на боевом сервере.

Золотое правило удалённой настройки безопасности: никогда не закрывайте текущий канал доступа, пока не проверили новый. Меняете порт SSH или правила файрвола — держите второй открытый сеанс и проверяйте вход из него, прежде чем разрывать первый.

📜 Готовый скрипт: все шаги этого раздела собраны в один автоматический сценарий — secure-server-setup.sh. Он обновляет систему и включает авто-обновления безопасности, создаёт пользователя с sudo, переносит ему SSH-ключ, усиливает SSH (вход только по ключу, без root, нестандартный порт), настраивает файрвол ufw по принципу default-deny и поднимает fail2ban. Перед запуском обязательно откройте файл, прочитайте шапку и отредактируйте блок настроек (имя пользователя, порт SSH, публичный ключ). Запускать только на виртуалке для обкатки, держа второй SSH-сеанс открытым:

# сначала отредактируйте переменные в начале файла!
sudo bash secure-server-setup.sh

⚠️ Скрипт меняет доступ к серверу. Это учебный шаблон — понимайте каждую строку, а не запускайте вслепую.

Прежде чем настраивать, поймите, что атакуют чаще всего: перебор паролей по SSH (brute-force); эксплуатация устаревшего софта с известными уязвимостями; открытые наружу службы, которые должны были слушать только localhost; слабые права на файлы и утечка секретов; повышение привилегий через неправильный sudo. Почти вся базовая защита — это закрытие именно этих пяти дверей.

Большинство взломов используют уже известные и исправленные уязвимости. Свежая система закрывает их автоматически.

sudo apt update && sudo apt upgrade -y        # вручную обновить всё
sudo apt install unattended-upgrades          # автоматические security-обновления
sudo dpkg-reconfigure unattended-upgrades     # включить их

На RHEL/Fedora аналог — dnf-automatic. Включённые автоматические обновления безопасности — первое, что стоит сделать на новом сервере.

SSH — главная дверь в сервер и главная цель ботов. Правим /etc/ssh/sshd_config (через sudoedit), затем обязательно sshd -t и только потом перезапуск.

# Ключевые директивы в /etc/ssh/sshd_config:
PermitRootLogin no              # запрет прямого входа под root
PasswordAuthentication no       # только ключи, никаких паролей (бруту нечего перебирать)
PubkeyAuthentication yes        # вход по ключу
Port 2222                       # нестандартный порт убирает 99% шумовых сканов
AllowUsers alex                 # белый список тех, кому вообще можно входить
MaxAuthTries 3                  # меньше попыток на сессию
ClientAliveInterval 300         # рвать зависшие сессии

sudo sshd -t                          # ПРОВЕРИТЬ конфиг (иначе рискуете доступом!)
sudo systemctl restart ssh            # применить

Порядок безопасной смены: сначала убедитесь, что вход по ключу работает (зайдите в новой вкладке), и только потом отключайте PasswordAuthentication. Иначе можно закрыть себе доступ.

ssh-keygen -t ed25519 -C "ваш-комментарий"   # на СВОЕЙ машине: создать пару
ssh-copy-id -p 2222 alex@server               # положить публичный ключ на сервер
ssh -p 2222 alex@server                       # проверить вход без пароля

Приватный ключ (~/.ssh/id_ed25519) никогда не покидает вашу машину и не передаётся никому. На сервер кладётся только публичный (.pub). Защитите приватный ключ парольной фразой при генерации — тогда даже украденный файл бесполезен.

Принцип «default deny»: по умолчанию запрещено всё, открываем точечно.

sudo ufw default deny incoming        # входящее запрещено по умолчанию
sudo ufw default allow outgoing       # исходящее разрешено
sudo ufw allow 2222/tcp               # СНАЧАЛА разрешите свой SSH-порт!
sudo ufw allow 80,443/tcp             # веб, если нужен
sudo ufw enable                       # включить
sudo ufw status verbose               # проверить

КРИТИЧНО: на удалённом сервере разрешите SSH-порт до ufw enable, иначе мгновенно отрежете себе доступ. Если используете нестандартный порт SSH — открывайте именно его.

fail2ban читает логи и временно банит IP, которые перебирают пароли.

sudo apt install fail2ban
sudo systemctl enable --now fail2ban
sudo fail2ban-client status sshd      # сколько IP забанено и кто

Базовая настройка — в /etc/fail2ban/jail.local (создаётся копией jail.conf): число попыток (maxretry), время бана (bantime), окно отслеживания (findtime). Уже с дефолтами он отсекает основную массу ботов.

Не работайте под root в повседневности. Создайте обычного пользователя с правом sudo и заходите под ним.

sudo adduser alex
sudo usermod -aG sudo alex            # право выполнять sudo
sudo visudo                            # ЕДИНСТВЕННЫЙ верный способ править sudoers

visudo проверяет синтаксис и не даёт сохранить ошибку — сломанный /etc/sudoers способен лишить sudo всех. Давайте каждому пользователю и службе ровно столько прав, сколько нужно, и не больше.

chmod 600 ~/.ssh/id_ed25519           # приватный ключ — только владельцу
chmod 700 ~/.ssh                       # каталог ключей закрыт
find / -perm -4000 -type f 2>/dev/null # все SUID-файлы (потенциальный вектор эскалации)
find / -perm -0002 -type f 2>/dev/null # файлы, доступные на запись всем (опасно)

Никогда не храните пароли, токены и приватные ключи в коде, в истории команд или в публичных репозиториях. Секреты — в переменных окружения или в защищённых хранилищах с правами 600.

sudo ss -tulpn                         # все слушающие порты и какие службы их заняли

Пройдитесь по списку и спросите по каждой строке: «должна ли эта служба быть доступна из интернета?». База данных, Redis, внутренние API почти всегда должны слушать только 127.0.0.1, а не 0.0.0.0. Открытый наружу порт без необходимости — это лишняя дверь.

last                                   # история удачных входов
sudo lastb                             # история НЕудачных попыток входа
journalctl -u ssh | grep -i "failed"   # неудачные SSH-логины
sudo grep -i sudo /var/log/auth.log    # кто и что делал через sudo
who                                     # кто в системе прямо сейчас

Регулярный взгляд в lastb и auth.log показывает, кто стучится в дверь. Резкий рост неудачных попыток — повод проверить настройки и fail2ban.

Бэкап — это часть безопасности: защита от шифровальщиков и от собственных ошибок. Храните копии вне самого сервера, проверяйте, что они восстанавливаются, и шифруйте чувствительные данные. Для дисков с приватными данными используйте LUKS (cryptsetup); для передачи файлов — уже зашифрованный канал SSH (scp/rsync/sftp).

• Система обновлена, включены автоматические security-обновления
• Создан обычный пользователь с sudo, работа не под root
• Настроен вход по SSH-ключу, пароли отключены (PasswordAuthentication no)
• Запрещён прямой вход root (PermitRootLogin no)
• Файрвол включён по принципу default-deny, открыты только нужные порты
• Установлен и работает fail2ban
• Проверено ss -tulpn: наружу не торчит ничего лишнего
• Права на ключи и секреты — 600/700
• Настроены резервные копии вне сервера

Задание (в виртуалке): поднимите чистую Ubuntu Server и пройдите весь чек-лист по пунктам. Затем с другой машины попробуйте зайти по паролю (должно быть отказано) и по ключу (должно пустить). Посмотрите sudo lastb — увидите попытки, которые отсёк сервер.

Этичный хакинг (пентест) — это поиск уязвимостей с разрешения владельца, чтобы их закрыли раньше злоумышленников. От «чёрного» хакинга его отличает ровно одно: разрешение и закон. Те же инструменты в руках без разрешения — это преступление. Этот раздел учит мыслить как защитник, который понимает атаку.

⚖️ Главное правило: сканировать, атаковать и тестировать можно только свои системы или те, на которые у вас есть письменное разрешение (scope). Чужой сервер, сайт, Wi-Fi соседа — это статьи УК (в РФ — ст. 272–274), независимо от ваших намерений. Когда сомневаетесь — значит, разрешения нет.

• Своя лаборатория — связка виртуалок (Kali + Metasploitable/DVWA) в изолированной сети. Полный контроль, ничего не нарушаете.
• TryHackMe, HackTheBox, PortSwigger Web Security Academy — площадки с намеренно уязвимыми машинами и пошаговыми заданиями.
• Bug bounty (HackerOne, Bugcrowd) — легальный поиск уязвимостей за вознаграждение, но строго в рамках scope конкретной программы.
• CTF-соревнования — задачи на безопасность в игровом формате.

1. Разведка (reconnaissance) — сбор открытой информации о цели (домены, поддомены, технологии). Бывает пассивная (без касания цели) и активная.
2. Сканирование (scanning) — поиск живых хостов, открытых портов и версий сервисов.
3. Получение доступа (exploitation) — проверка найденных уязвимостей. В учебной лаборатории — на намеренно уязвимых мишенях.
4. Закрепление и пост-эксплуатация — что злоумышленник смог бы сделать дальше (для оценки риска).
5. Отчёт (reporting) — самый важный этап: что нашли, как воспроизвести, как починить. Без отчёта пентест бесполезен.

1. Разведка хоста и портов — что вообще открыто у мишени:

# Узнать живые хосты в своей лабораторной подсети
nmap -sn 192.168.56.0/24

# Просканировать порты и версии сервисов на своей мишени
nmap -sV -p- 192.168.56.101

# Определить ОС и запустить базовые скрипты разведки
nmap -A 192.168.56.101

2. Разведка веб-приложения — какие технологии и пути есть:

# HTTP-заголовки и сервер (своего тестового сайта)
curl -I http://192.168.56.101

# Поиск типовых директорий/файлов (на своей мишени)
gobuster dir -u http://192.168.56.101 -w /usr/share/wordlists/dirb/common.txt

# Какие технологии использует сайт
whatweb http://192.168.56.101

3. Анализ — взгляд защитника. На каждую находку сразу думайте, как это закрыть: открытый лишний порт → закрыть файрволом; старая версия сервиса → обновить; директория с листингом → отключить листинг; дефолтные пароли → сменить. Это и есть смысл этичного хакинга — превратить находку в задачу для защиты.

• Не трогает системы без письменного разрешения — даже «просто посмотреть».
• Не выходит за рамки scope (нашли соседний сервер вне задания — не лезете).
• Не разрушает данные и не мешает работе сервисов ради «доказательства».
• Не сливает и не использует найденные данные — сообщает владельцу и удаляет у себя.
• Не публикует уязвимость до того, как её успели исправить (responsible disclosure).

• Сертификации: CompTIA Security+ (база), CEH, OSCP (практический, ценится высоко).
• Темы: веб-уязвимости (OWASP Top 10), сети, Active Directory, анализ вредоносного ПО, форензика.
• Главная связка навыков: Linux + сети + скриптинг (Python/Bash) — без них инструменты остаются «чёрным ящиком».

Задание: разверните в своей изолированной сети Kali и Metasploitable 2. Выполните по этапам: nmap -sn (найти хост) → nmap -sV -p- (порты и версии) → выпишите 3 устаревших сервиса и для каждого опишите в конспекте, как бы вы это закрыли на месте администратора. Отчёт (находка → риск → как починить) — обязательная часть задания.

Это не справочник, а самопроверка навыка. Отмечайте пункт, только когда можете выполнить его по памяти, не подглядывая, и понимаете, что и почему происходит. Если на каком-то пункте спотыкаетесь — вернитесь к соответствующему разделу. Цель курса — закрыть все галочки.

• Понять, где я и что вокруг: pwd, ls -lah, cd
• Получить справку по любой команде: man, --help, type
• Создавать, копировать, переименовывать, удалять файлы и папки
• Читать файлы и логи: cat, less, head, tail -f
• Пользоваться историей и автодополнением: Tab, Ctrl+R, !!
• Выйти из vim, не запаниковав (Esc → :q!)

• Объяснить строку прав -rwxr-xr-- и выставить нужные через chmod
• Сменить владельца через chown
• Установить, удалить и найти пакет своим менеджером
• Найти файл (find) и текст в файлах (grep -r)
• Построить конвейер из 3+ команд через |
• Перенаправить вывод и ошибки: >, >>, 2>, 2>&1
• Создать постоянный алиас и переменную окружения в ~/.bashrc

• Найти и завершить процесс: ps, top/htop, kill, pkill
• Управлять службой: systemctl start/stop/restart/enable
• Читать логи службы и ядра: journalctl -u, journalctl -p err, dmesg
• Диагностировать сеть по шагам: ip a, ping, ss -tulpn, dig
• Проверить место и память: df -h, du -sh, free -h
• Создать и распаковать архив: tar -czf / tar -xzf
• Настроить задачу по расписанию: crontab -e
• Подключиться по SSH и настроить вход по ключу

• Написать bash-скрипт с shebang, переменными и аргументами ($1, $#)
• Использовать if, for, while и проверки [ -f ], [ -d ]
• Применить set -euo pipefail для надёжности скрипта
• Связать find с xargs для массовых операций
• Сравнить вывод двух команд через diff <(...) <(...)

• Усилить SSH (ключи, без паролей, без root, нестандартный порт)
• Настроить файрвол по принципу default-deny
• Поставить и проверить fail2ban
• Найти, какой процесс держит файл/порт: lsof, fuser
• Пройти весь чек-лист защиты сервера из раздела 30
• Сломать конфиг службы, найти причину по логам и починить

Задание: распечатайте или сохраните этот чек-лист и возвращайтесь к нему раз в неделю. Закрытые по памяти галочки — честный показатель того, что навык действительно ваш, а не «прочитан».

• Ядро (kernel) — сердце ОС, управляет железом, памятью и процессами.
• Дистрибутив — сборка из ядра Linux и набора программ (Ubuntu, Debian, Fedora).
• Оболочка (shell) — программа, читающая и выполняющая ваши команды (bash, zsh).
• Терминал — окно, в котором вы вводите команды.
• root — суперпользователь с неограниченными правами.
• sudo — выполнить одну команду с правами root.
• Демон (daemon) — фоновая программа-служба (например, sshd, nginx).
• PID — числовой идентификатор процесса.
• Монтирование — подключение диска/раздела к папке в дереве файлов.
• Репозиторий — хранилище пакетов, откуда менеджер ставит софт.
• Конвейер (pipe) — передача вывода одной команды на вход другой через |.
• stdin/stdout/stderr — потоки ввода, вывода и ошибок программы.

Эти разделы выходят за рамки базового администрирования. Они нужны, когда вы уже уверенно работаете в терминале и хотите расти в сторону DevOps, SRE или системного инженера. Проходите их практически: разворачивайте всё в виртуалке или на тестовом сервере и обязательно ломайте, чтобы понять, как оно устроено.

Контейнер — это изолированный процесс, который использует ядро хост-системы, но имеет собственную файловую систему, сеть и набор процессов. В отличие от виртуальной машины, контейнер не запускает отдельное ядро, поэтому стартует за доли секунды и почти не тратит ресурсы на изоляцию.

Под капотом контейнеры построены на двух механизмах ядра Linux: namespaces изолируют то, что процесс «видит» (PID, сеть, точки монтирования, пользователей), а cgroups ограничивают то, что процесс может «потратить» (CPU, память, ввод-вывод). Понимание этой пары — ключ к осознанной работе с любым контейнерным движком.

Начните с Docker: научитесь писать Dockerfile, собирать образы через docker build, запускать контейнеры через docker run, пробрасывать порты и тома, а затем описывать многоконтейнерные приложения в docker-compose.yml. Параллельно посмотрите на Podman — он совместим с Docker по командам, но работает без демона и умеет запускать контейнеры без root-прав.

Задание. Соберите образ простого веб-приложения, запустите его с проброшенным портом и постоянным томом, затем опишите связку «приложение + база данных» в docker-compose и поднимите её одной командой.

Когда контейнеров много и они работают на нескольких машинах, ими нужно управлять автоматически: запускать, перезапускать упавшие, балансировать нагрузку, обновлять без простоя. Эту задачу решают оркестраторы, и стандартом стал Kubernetes (k8s).

Базовые понятия: Pod — минимальная единица запуска; Deployment описывает желаемое состояние (сколько реплик должно работать); Service даёт стабильную сетевую точку входа к подам; ConfigMap и Secret хранят конфигурацию и секреты отдельно от образа. Главная идея Kubernetes — декларативность: вы описываете нужное состояние кластера в YAML, а контроллеры постоянно приводят реальность к этому описанию.

Для учёбы не нужен кластер из серверов: поднимите локальный кластер через minikube или kind и управляйте им утилитой kubectl.

Задание. Разверните в minikube приложение из раздела A1: создайте Deployment на три реплики, откройте к нему доступ через Service, затем измените число реплик и образ и понаблюдайте, как кластер сам приводит состояние к новому описанию.

Настраивать серверы руками через SSH медленно и ненадёжно. Подход Infrastructure as Code предлагает описывать желаемое состояние машин в виде кода, который можно хранить в git, проверять и повторно применять.

Ansible удобен для старта: он не требует агента на управляемых машинах и работает поверх обычного SSH. Задачи описываются в YAML-файлах (playbook), серверы группируются в inventory, наборы задач переиспользуются через роли. Ключевое свойство хорошего playbook — идемпотентность: повторный запуск не делает лишней работы, если система уже в нужном состоянии.

Задание. Напишите playbook, который на чистом сервере ставит nginx, кладёт ваш конфиг и гарантирует, что служба запущена и в автозагрузке. Прогоните его дважды и убедитесь, что второй запуск ничего не меняет.

Работающий сервер должен быть прозрачным: вы должны видеть проблему раньше пользователей. Наблюдаемость раскладывают на три части — метрики (числовые показатели во времени), логи (записи о событиях) и трейсы (путь одного запроса через систему).

Классический бесплатный стек — Prometheus для сбора метрик и Grafana для дашбордов. Prometheus сам периодически опрашивает (scrape) экспортёры, а оповещения настраиваются через Alertmanager. Хорошая отправная точка для метрик — «золотые сигналы»: задержка, трафик, доля ошибок и насыщенность ресурсов.

Задание. Поднимите Prometheus и node_exporter, подключите Grafana, соберите дашборд с CPU, памятью и диском и настройте оповещение при свободном месте меньше 10 процентов.

Когда сервер тормозит, узкое место нужно искать, а не угадывать. Начните с осмотра: top/htop для общей картины, vmstat и free по памяти, iostat по дискам, ss по соединениям. Для глубокого анализа: strace показывает системные вызовы процесса, perf — на что тратится процессорное время. Параметры ядра настраиваются через sysctl и /proc/sys.

Золотое правило тюнинга: измеряйте до и после и меняйте по одному параметру за раз.

Задание. Сымитируйте нагрузку через stress-ng, найдите перегруженный ресурс, измените один параметр sysctl и зафиксируйте эффект.

На продакшене нужно понимать, как пакет проходит через систему. В современных дистрибутивах фильтрацию выполняет nftables (раньше — iptables), поверх работают надстройки ufw и firewalld. Стоит разобраться с маршрутизацией (ip route), NAT, а также с туннелями и VPN — например WireGuard. Для диагностики пригодятся tcpdump и mtr.

Задание. Настройте nftables так, чтобы извне были доступны только SSH и HTTPS, поднимите туннель WireGuard между двумя машинами и проверьте трафик через tcpdump.

LVM (Logical Volume Manager) добавляет слой абстракции над дисками: физические разделы объединяются в группу томов, из которой нарезаются логические тома, которые можно расширять и переносить без переразметки. RAID объединяет несколько дисков ради надёжности или скорости (зеркало RAID1, чередование с чётностью RAID5/6). Снапшоты LVM позволяют делать мгновенные согласованные копии для бэкапа.

Задание. Соберите из двух виртуальных дисков группу томов LVM, создайте логический том, смонтируйте его, заполните данными, расширьте том и сделайте снапшот.

KVM — это встроенная в ядро Linux технология аппаратной виртуализации, а QEMU эмулирует оборудование для гостевых машин. Вместе с libvirt и утилитой virsh они дают полноценную платформу для запуска виртуальных машин на сервере без проприетарного софта. Это фундамент, на котором строятся облачные провайдеры.

Задание. Создайте через libvirt виртуальную машину с минимальным дистрибутивом, настройте ей сеть и проверьте управление через virsh (старт, пауза, снапшот).

Раздел-«копилка»: реальные однострочники, которые экономят часы, и спокойный разбор аварий, которые рано или поздно случаются у каждого. Все команды — для тренировки в виртуалке.

# Топ-10 процессов по памяти и по CPU
ps aux --sort=-%mem | head -n 11
ps aux --sort=-%cpu | head -n 11

# Кто и сколько занимает места в текущей папке (по убыванию)
du -sh ./* 2>/dev/null | sort -rh | head

# Найти 20 самых больших файлов на диске
find / -type f -printf '%s %p\n' 2>/dev/null | sort -rn | head -20

# Массовое переименование: .txt -> .md
for f in *.txt; do mv -- "$f" "${f%.txt}.md"; done

# Сколько файлов каждого расширения в дереве
find . -type f | sed 's/.*\.//' | sort | uniq -c | sort -rn

# Быстро поднять веб-сервер из текущей папки (раздать файлы)
python3 -m http.server 8000

# Заменить текст во всех файлах рекурсивно (с бэкапом .bak)
grep -rl 'старое' . | xargs sed -i.bak 's/старое/новое/g'

# Показать только уникальные IP из лога веб-сервера (топ-10)
awk '{print $1}' access.log | sort | uniq -c | sort -rn | head

grep -rni 'error' /var/log      # рекурсивно, без учёта регистра, с номерами строк
grep -A3 -B2 'panic' system.log # 2 строки до и 3 после совпадения (контекст)
grep -c 'failed' auth.log       # просто посчитать количество совпадений
grep -vE '^\s*(#|$)' file.conf   # конфиг без комментариев и пустых строк
grep -oE '[0-9]+\.[0-9]+\.[0-9]+\.[0-9]+' file  # вытащить все IP-адреса

Полезно знать: grep -v инвертирует поиск (показать всё, КРОМЕ совпадений), -E включает расширенные регулярки, -o печатает только совпавшую часть, а не всю строку.

Закончилось место на диске (No space left on device). Сначала найти, где именно: df -h покажет переполненный раздел, дальше du -sh /var/* | sort -rh | head спускается вглубь. Чаще всего виноваты разросшиеся логи (/var/log), кэш пакетов или забытые большие файлы. Логи journald чистятся через journalctl --vacuum-size=200M. Опасная ловушка: место может «не освобождаться» после rm, если файл всё ещё держит запущенный процесс — найти такие можно через lsof | grep deleted и перезапустить процесс.

Система не загружается до конца / падает в emergency. Не паникуйте: в меню GRUB можно выбрать предыдущее ядро или дописать к строке запуска параметр для входа в аварийный режим. После загрузки смотрите journalctl -b -p err (ошибки текущей загрузки) и systemctl --failed (какие службы не стартовали). Самая частая причина — битая строка в /etc/fstab: система пытается смонтировать несуществующий диск и зависает. Поэтому после правки fstab всегда проверяйте её командой mount -a ДО перезагрузки.

Высокая нагрузка, сервер «тормозит». uptime покажет load average, top (или htop) — кто ест CPU и память, iostat -x 1 — не упёрлись ли в диск, free -h — не ушли ли в swap. Если load высокий, а CPU простаивает — почти наверняка процессы ждут диск (состояние D в top). Память кончилась и пришёл OOM killer? Загляните в dmesg | grep -i oom.

Случайно удалили нужное / сломали конфиг. Лучшая защита — привычки: перед правкой делайте копию (cp file file.bak), а перед опасными операциями — снапшот виртуалки. Если под рукой git, держите /etc под версионным контролем (etckeeper) — тогда любое изменение конфига можно откатить.

Забыли, что вообще запущено и слушает порты. ss -tulpn покажет все слушающие сокеты с именами процессов, systemctl list-units --type=service --state=running — активные службы, ps aux — полную картину процессов.

• Перед rm -rf дважды посмотрите на путь; для массового удаления сначала прогоните find ... -print, а -delete добавьте, только убедившись в списке.
• Опасные команды (mkfs, dd, rm -rf) никогда не копируйте вслепую из интернета — разберите каждый аргумент.
• Делайте снапшоты ДО эксперимента, а не после поломки.
• Бэкап, который ни разу не восстанавливали, — это не бэкап, а надежда. Регулярно проверяйте восстановление.

Задание. Сымитируйте аварию в виртуалке: заполните диск файлом-заглушкой (fallocate -l 5G /tmp/big), убедитесь, что df -h показывает переполнение, найдите «виновника» через du, удалите его и проверьте, что место вернулось. Затем намеренно впишите несуществующий диск в /etc/fstab, проверьте его через mount -a (НЕ перезагружаясь) и откатите изменение.

двигаться дальше

• DevOps / администрирование: Docker и docker-compose, оркестрация (Kubernetes), Ansible для автоматизации, мониторинг (Prometheus, Grafana), nginx как reverse proxy, CI/CD.
• Безопасность: fail2ban, аудит прав, SELinux/AppArmor, разбор логов, настройка VPN.
• Сети: глубже в маршрутизацию, VPN (WireGuard), свой DNS-сервер, балансировка нагрузки.
• Базы данных и веб: развёртывание PostgreSQL/MySQL, настройка веб-приложений, SSL-сертификаты (Let's Encrypt).
• Программирование под Linux: компиляция из исходников, написание своих systemd-юнитов, работа с сигналами, системные вызовы.

Сертификации для резюме: LFCS (Linux Foundation, начальный уровень) и RHCSA (Red Hat, ценится работодателями).

Когда базовые команды освоены, начинается настоящая работа администратора: автоматизация, диагностика под нагрузкой, изоляция сервисов и контроль ресурсов. Этот раздел — мост между «умею пользоваться Linux» и «умею держать на нём боевые сервисы». Каждый подраздел объясняет, зачем инструмент нужен, а не только как его запустить.

systemd — это не только start/stop. Он управляет порядком запуска, ограничивает ресурсы и изолирует процессы.

systemctl list-dependencies nginx     # дерево зависимостей юнита
systemctl cat nginx                    # итоговый юнит со всеми override
systemd-analyze blame                  # что дольше всего грузится при загрузке
systemd-analyze critical-chain         # критическая цепочка запуска
systemctl edit nginx                   # создать drop-in override, не трогая оригинал

Ограничение ресурсов прямо в юните (cgroups под капотом):

[Service]
MemoryMax=512M
CPUQuota=50%
TasksMax=100

Почему это важно: один взбесившийся сервис не должен утянуть весь сервер. MemoryMax и CPUQuota — это страховка на уровне ядра, а не «понадеемся, что не сожрёт всё».

Подводный камень: не редактируйте юниты в /lib/systemd/system/ напрямую — обновление пакета их перезапишет. Всегда используйте systemctl edit (drop-in в /etc/systemd/system/<unit>.d/).

htop                # интерактивный обзор (раскраска, дерево процессов: F5)
btop                # современная замена, графики CPU/RAM/сети/диска
iotop               # кто грузит диск (нужен root)
iftop / nload       # кто грузит сеть
ss -tulpn           # открытые порты и процессы за ними (замена netstat)
vmstat 1            # очередь, swap, прерывания в динамике
dstat -tcmnd        # сводная статистика по всему сразу
journalctl -fu nginx  # живой лог конкретного сервиса

Метод «USE» для диагностики узких мест: для каждого ресурса (CPU, память, диск, сеть) проверяйте Utilization (загрузку), Saturation (насыщение/очередь) и Errors (ошибки). Это системный подход вместо хаотичного тыканья команд.

uptime                          # load average за 1/5/15 мин
cat /proc/loadavg
sar -u 1 5                      # историческая статистика CPU (пакет sysstat)
perf top                        # какие функции едят CPU прямо сейчас
strace -p <pid>                 # системные вызовы живого процесса
ltrace -p <pid>                 # вызовы библиотек
lsof -p <pid>                   # что открыл процесс (файлы, сокеты)

Как читать load average: число должно быть ниже количества ядер. load 8.0 на 4-ядерном сервере = очередь вдвое длиннее, чем система успевает обрабатывать. nproc покажет число ядер.

Контейнер — это не виртуалка, а процесс с собственными namespace и cgroup. Понимание этого спасает при отладке.

unshare --fork --pid --mount-proc bash   # свой PID namespace вручную
lsns                                      # список всех namespace в системе
nsenter -t <pid> -n ss -tulpn             # заглянуть в сеть чужого namespace
systemd-nspawn -D /path/to/rootfs         # лёгкий «контейнер» средствами systemd

Почему полезно: когда контейнер «не видит сеть» или «не находит файл», вы понимаете, что дело в namespace/маунтах, а не в чёрной магии Docker.

Ручная настройка не масштабируется. Правило: конфигурация как код.

# Ansible: ad-hoc команда на группу серверов без единого ssh-захода руками
ansible web -m apt -a "name=nginx state=present" --become

# Идемпотентный bash: безопасно запускать повторно
grep -qxF 'net.ipv4.ip_forward=1' /etc/sysctl.conf \
  || echo 'net.ipv4.ip_forward=1' >> /etc/sysctl.conf

Идемпотентность — ключевое слово продвинутого админа: скрипт можно запустить 100 раз, и результат будет тот же, без дублей и поломок. >> без проверки — антипаттерн.

rsync -aAXH --delete /data/ /backup/data/   # сохраняет права, ACL, xattr, hardlink
restic backup /data                          # дедупликация + шифрование

Золотое правило 3-2-1: 3 копии данных, на 2 разных носителях, 1 — вне площадки. И главное: бэкап, который ни разу не восстанавливали, — это не бэкап, а надежда. Регулярно делайте тестовое восстановление.

• SELinux / AppArmor — мандатный контроль доступа; ausearch, audit2allow, aa-status.
• LVM и снапшоты — гибкие тома, мгновенные снимки перед рискованными операциями.
• tuned / sysctl-тюнинг — профили под БД, сеть, виртуализацию.
• eBPF (bcc, bpftrace) — трассировка ядра без перекомпиляции; будущее наблюдаемости.
• Конфиг-менеджмент — Ansible/Terraform для воспроизводимой инфраструктуры.

Принцип продвинутого админа: автоматизируй то, что делаешь дважды; логируй то, что может сломаться; и никогда не трогай прод без отрепетированного отката.

Задание: возьмите любой работающий сервис на вашей виртуалке, ограничьте ему память через systemctl edit (MemoryMax=128M), затем нагрузите его и посмотрите в journalctl, как ядро убивает процесс при превышении лимита. Поймите, почему это произошло.

Книги дают системность, которой не хватает разрозненным статьям. Все перечисленное ниже доступно бесплатно и легально — это официально открытые источники, переводы и материалы с открытой лицензией.

Фундамент и философия Unix/Linux

• «The Linux Command Line» (William Shotts) — лучшая бесплатная книга для старта. Доступна в PDF на сайте автора (linuxcommand.org). Проводит от первой команды до написания скриптов.
• «The Art of Unix Programming» (Eric S. Raymond) — про философию Unix: почему всё устроено через маленькие инструменты и текстовые потоки. Полностью доступна онлайн.
• «GNU Bash Reference Manual» — официальная документация bash. Сухо, но это первоисточник: здесь точные ответы про подстановки, расширения и поведение оболочки.

Администрирование и сети

• «The Linux System Administrator's Guide» (TLDP) — классический материал The Linux Documentation Project. Местами устарел, но базовые концепции вечны.
• «Securing Debian Manual» — официальное руководство Debian по защите системы. Отлично дополняет раздел про безопасность серверов.
• «Beej's Guide to Network Programming» — если хочется понять сети глубже, на уровне сокетов. Бесплатно на сайте автора.

Углублённо: ядро и внутренности

• «Linux Kernel Documentation» (kernel.org/doc) — первоисточник по работе ядра, подсистем и интерфейсов.
• «Operating Systems: Three Easy Pieces» (OSTEP) — бесплатный университетский учебник по ОС (процессы, память, файловые системы). Объясняет фундамент, на котором стоит Linux.
• «Advanced Programming in the Unix Environment» — справочник по системным вызовам и низкоуровневому программированию под Unix (часть материалов доступна онлайн).

Где искать ещё

• man-страницы и tldr — самая недооценённая «литература»: всегда под рукой и всегда актуальна для вашей версии системы.
• The Linux Documentation Project (tldp.org) — архив HOWTO и руководств.
• Arch Wiki (wiki.archlinux.org) — даже если вы не на Arch, это одна из лучших технических вики по Linux в мире.

Совет: не пытайтесь прочитать книгу целиком за раз. Читайте раздел — сразу повторяйте в терминале — возвращайтесь. Книга без практики забывается за неделю.

Задание: скачайте «The Linux Command Line» в PDF, прочитайте главу про перенаправление потоков и сверьте её с разделом 13 этого курса — найдите, что объясняется иначе, и запишите выводы.

Каналы хороши тем, что держат вас «в потоке»: короткие разборы, свежие приёмы и подборки попадаются в ленте регулярно. Ниже — тематическая подборка для прокачки по Linux, безопасности и смежным областям.

• 🖥 Linux Academy — сложные концепции через понятные схемы и короткие видео; помогает выстроить профессиональный подход к работе с Linux.
• ⚡️ Kali Linux — авторский канал по хакингу и защите информации с нуля: практические разборы атак и способов им противостоять.
• 🧠 Machine Learning — про ИИ на практике: как генерировать базы данных и код с помощью AI и что вообще нужно знать в этой области.
• 📚 Linux Books — большая подборка книг по Linux: порядка 320 книг бесплатно, удобно искать по темам.
• 🔝 Подборка Linux-ресурсов — целая папка каналов с полезными материалами для прокачки сразу по нескольким направлениям.

Как извлечь пользу: подпишитесь на 2–3 канала, а не на все сразу. Лента из десятков источников превращается в шум, который вы перестаёте читать. Лучше меньше, но регулярно — и сразу проверять приёмы в своей виртуалке.

Задание: выберите из любого канала один незнакомый приём или команду, разберите, что он делает (через man/--help), и примените в учебной системе.

Не заучивайте команды наизусть — учитесь искать. У каждой команды есть встроенная справка (man, --help, tldr). Профессионал отличается не тем, что помнит всё, а тем, что быстро находит ответ и понимает, что происходит в системе. Устанавливайте, ломайте в виртуалке, чините — и навык придёт. Удачи.