Какие знаешь лимиты в Linux?

Лимиты (limits) в Linux: концепция и управление

В Linux под лимитами понимаются ограничения на потребление системных ресурсов отдельным процессом или пользователем. Это ключевой механизм для обеспечения стабильности системы, предотвращения истощения ресурсов (например, памяти, CPU) одним процессом и реализации политик многопользовательской среды.

Категории лимитов

Лимиты в Linux традиционно делятся на два основных типа:

1. Мягкие лимиты (Soft Limits) — текущее действующее ограничение. Процесс может временно превысить его, но получит соответствующий сигнал (например, SIGXCPU или SIGXFSZ). Эти лимиты могут быть увеличены процессом самостоятельно, но только до значения жесткого лимита.
2. Жесткие лимиты (Hard Limits) — абсолютный максимум, который не может быть превышен. Для повышения жесткого лимита требуются права суперпользователя (root).

Основные типы ограничиваемых ресурсов (по ulimit и getrlimit)

• Количество процессов и потоков:

    *   `nproc` — максимальное число процессов (и, как правило, потоков), которые может создать пользователь.

• Работа с файлами:

    *   `nofile` — максимальное количество **дескрипторов открытых файлов**, которые могут быть открыты одновременно.
    *   `fsize` — максимальный размер файла, который может создать процесс (в блоках).

• Память:

    *   `as` (address space) или `vmemory` — максимальный размер **виртуальной памяти** (адресного пространства) процесса.
    *   В современных системах управление памятью часто осуществляется через **cgroups** (control groups), которые предоставляют более тонкий контроль (`memory.limit_in_bytes`).

• ЦП (процессорное время):

    *   `cpu` — максимальное количество **процессорного времени** (в секундах), которое может использовать процесс. По истечении лимита процесс получает сигнал `SIGXCPU`.
    *   Более современное и гибкое ограничение задается через **cgroups** (`cpu.shares`, `cpu.cfs_quota_us`).

• Прочее:

    *   `core` — максимальный размер **core---

файла** (дамп памяти после сбоя), который может быть создан (0 — запрещает создание).

    *   `locks` — максимальное количество **файловых блокировок**.
    *   `sigpending` — максимальное количество **отложенных сигналов**.
    *   `msgqueue` — максимальный объем памяти для **очередей сообщений POSIX**.

Управление лимитами

1. Команда ulimit (в shell)

Позволяет просматривать и изменять лимиты для текущей сессии shell и всех процессов, запущенных из него.

# Просмотр всех текущих лимитов
ulimit -a

# Просмотр лимита на количество открытых файлов
ulimit -n

# Установка мягкого лимита на открытые файлы для текущей сессии
ulimit -Sn 4096

# Установка жесткого лимита (требует прав root или уже повышенного жесткого лимита)
ulimit -Hn 8192

2. Файлы конфигурации limits.conf и limits.d/

Для установки глобальных лимитов для пользователей и групп при входе в систему используется PAM (Pluggable Authentication Modules). Основной файл — /etc/security/limits.conf. Также можно использовать файлы в директории /etc/security/limits.d/, которые имеют приоритет.

Формат строки в limits.conf:

<domain> <type> <item> <value>

Пример:

# Для пользователя "appuser" установить мягкий и жесткий лимит на открытые файлы
appuser soft nofile 65535
appuser hard nofile 65535

# Для всех пользователей группы "developers" увеличить лимит процессов
@developers soft nproc 2048
@developers hard nproc 4096

# Для всех пользователей (*) запретить core.---
файлы
* hard core 0

3. Системные вызовы и библиотека C

Программа может управлять своими лимитами напрямую с помощью функций getrlimit() и setrlimit().

Пример на C:

#include <sys/resource.h>
#include <stdio.h>

int main() {
    struct rlimit rlim;

    // Получить текущий лимит на открытые файлы
    if (getrlimit(RLIMIT_NOFILE, &rlim) == 0) {
        printf("Текущий мягкий лимит: %ld\n", (long) rlim.rlim_cur);
        printf("Текущий жесткий лимит: %ld\n", (long) rlim.rlim_max);
    }

    // Попытаться увеличить мягкий лимит до 2048 (но не выше жесткого)
    rlim.rlim_cur = 2048;
    if (setrlimit(RLIMIT_NOFILE, &rlim) != 0) {
        perror("setrlimit failed");
    }
    return 0;
}

4. Современный механизм: cgroups (v2)

Для контейнеризации (Docker, Kubernetes) и сложных сценариев изоляции ресурсов традиционных лимитов (ulimit) уже недостаточно. cgroups (Control Groups) — основной механизм в современных дистрибутивах (с использованием cgroups v2).

Он позволяет ограничивать и изолировать:

• Память (memory.max — абсолютный лимит)
• ЦП (cpu.max — квота и период)
• Диск I/O (io.max)
• Сеть (через классы трафика)
• Количество процессов (pids.max)

Пример просмотра лимитов cgroup для текущего процесса (в системе с cgroups v2):

# Лимит на память
cat /sys/fs/cgroup/memory.max

# Лимит на ЦП (формат: $MAX $PERIOD)
cat /sys/fs/cgroup/cpu.max

# Лимит на количество процессов
cat /sys/fs/cgroup/pids.max

Почему лимиты критически важны для DevOps-инженера?

1. Стабильность системы: Предотвращают ситуацию, когда один "сбежавший" процесс исчерпывает всю память или файловые дескрипторы, вызывая падение всей системы или других сервисов.
2. Безопасность: Ограничивают потенциал DoS-атак (случайных или злонамеренных) со стороны одного пользователя или процесса.
3. Изоляция в контейнерах: Базовый механизм, на котором строятся Docker и другие контейнерные технологии — это cgroups и namespaces. Правильная настройка лимитов CPU и памяти для контейнеров — ежедневная задача.
4. Производительность приложений: Многие приложения (например, СУБД, веб-серверы типа Nginx) требуют очень высокого лимита на открытые файлы (nofile) для обработки тысяч одновременных соединений. Неправильная настройка приводит к ошибкам "Too many open files".
5. Отладка: Умение быстро проверить ulimit -a, понять конфигурацию в limits.conf или найти соответствующий cgroup контейнера — необходимо для оперативного решения инцидентов.

Таким образом, глубокое понимание лимитов — это не просто знание команд, а понимание механизмов управления ресурсами ОС, что является фундаментом для построения отказоустойчивых, безопасных и производительных систем.