Перевод сделан автором сайта goxpert.ru

Краткое содежание перевода

• Пространство имен в Linux является абстракцией от ресурсов операционной системы.
• Пространства имен инкапсулируют системные ресурсы, связанные с различными аспектами системы.
• Пространства имен являются необходимым условием для запуска любого процесса в системе.
• Коробки позволяют добавлять и удалять содержимое без влияния на другие коробки.
• Пространства имен могут содержать одну и ту же копию ресурсов, что может привести к изменениям, видимым во всех других пространствах имен.
• Контейнеры являются обычными процессами с разными пространствами имен, отличными от других процессов.
• Изоляция в контейнерах достигается с помощью пространств имен, чем меньше количество совместно используемых ресурсов, тем более изолированным является процесс.
• В оставшейся части поста будет рассмотрена реализация программы isolate, которая запускает командный процесс в новом процессе, изолированном от остальной системы.

Глубокое погружение в пространства имен Linux

В этой серии постов мы внимательно рассмотрим один из основных компонентов контейнера - пространства имен. В процессе мы создадим более простой клон docker run команды - нашу собственную программу, которая примет в качестве входных данных команду (вместе с ее аргументами, если таковые имеются) и запустит процесс в контейнере для ее запуска, изолированный от остальной системы, подобно тому, как вы сделали бы docker run это из image - образа.

Что такое пространство имен?(What is a namespace?)

Пространство имен Linux - это абстракция над ресурсами операционной системы. Мы можем представить пространство имен как коробку. Внутри этого блока находятся системные ресурсы, которые в точности зависят от типа блока (пространства имен - namespaces). В настоящее время существует 7 типов пространств имен Cgroup, IPC, Network, Mount, PID, User, UTS.

Например, Network пространство имен инкапсулирует системные ресурсы, связанные с сетью, такие как сетевые интерфейсы (например, wlan0, eth0), таблицы маршрутов(route tables) и т.д., Mount пространство имен инкапсулирует файлы и каталоги в системе, PID содержит идентификаторы процессов и так далее. Итак, два экземпляра Network пространства имен A и B (соответствующие двум блокам одного типа в нашей аналогии) могут содержать разные ресурсы - возможно, A содержит wlan0, тогда как B содержит eth0 и другую копию таблицы маршрутов(route table).

Пространства имен - это не какая-то дополнительная функция или библиотека, которую вам нужно установить apt, они предоставляются самим ядром Linux и уже являются необходимым условием для запуска любого процесса в системе. В любой данный момент любой процесс P принадлежит ровно одному экземпляру каждого типа пространства имен - поэтому, когда ему нужно сказать, обновить таблицу маршрутов в системе, Linux показывает ему копию таблицы маршрутов пространства имен, к которому он принадлежит в этот момент.

Для чего это нужно? (What is it good for?)

Абсолютно ни для чего… шучу. Одна хорошая вещь с ящиками заключается в том, что вы можете добавлять и удалять содержимое из одного ящика, и это не повлияет на содержимое других ящиков. Здесь та же идея с пространствами имен - процесс P может сойти с ума и выплнить sudo rm -rf / но другой процесс, Q который принадлежит другому Mount пространству имен, не пострадает, поскольку они используют разные копии этих файлов.

Однако обратите внимание, что ресурс, инкапсулированный в пространство имен, не обязательно означает, что это уникальная копия. В ряде случаев, либо по замыслу, либо из-за бреши в системе безопасности, два или более пространств имен будут содержать одну и ту же копию, например, одного и того же файла, так что изменения, внесенные в этот файл в одном Mount пространстве имен, фактически будут видны во всех других Mount пространствах имен, которые также ссылаются на него. По этой причине мы удаляем нашу аналогию с ящиками, поскольку элемент не может одновременно существовать в двух разных ящиках 😞.

Неразделенность - это забота (Unsharing is caring)

Мы можем видеть пространства имен, к которым принадлежит процесс! В типичном для Linux виде они отображаются в виде файлов в каталоге /proc/$pid/ns для данного процесса с идентификатором процесса $pid:

1
2
3
4
5
6
7
8
9

$ ls -l /proc/$$/ns
total 0
lrwxrwxrwx 1 iffy iffy 0 May 18 12:53 cgroup -> cgroup:[4026531835]
lrwxrwxrwx 1 iffy iffy 0 May 18 12:53 ipc -> ipc:[4026531839]
lrwxrwxrwx 1 iffy iffy 0 May 18 12:53 mnt -> mnt:[4026531840]
lrwxrwxrwx 1 iffy iffy 0 May 18 12:53 net -> net:[4026531957]
lrwxrwxrwx 1 iffy iffy 0 May 18 12:53 pid -> pid:[4026531836]
lrwxrwxrwx 1 iffy iffy 0 May 18 12:53 user -> user:[4026531837]
lrwxrwxrwx 1 iffy iffy 0 May 18 12:53 uts -> uts:[4026531838]

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

Давайте немного разберемся в этом. Во втором терминале мы можем запустить что-то вроде:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

$ hostname
iffy
$ sudo unshare -u bash
$ ls -l /proc/$$/ns
lrwxrwxrwx 1 root root 0 May 18 13:04 cgroup -> cgroup:[4026531835]
lrwxrwxrwx 1 root root 0 May 18 13:04 ipc -> ipc:[4026531839]
lrwxrwxrwx 1 root root 0 May 18 13:04 mnt -> mnt:[4026531840]
lrwxrwxrwx 1 root root 0 May 18 13:04 net -> net:[4026531957]
lrwxrwxrwx 1 root root 0 May 18 13:04 pid -> pid:[4026531836]
lrwxrwxrwx 1 root root 0 May 18 13:04 user -> user:[4026531837]
lrwxrwxrwx 1 root root 0 May 18 13:04 uts -> uts:[4026532474]
$ hostname
iffy
$ hostname coke
$ hostname
coke

Команда unshare запускает программу (необязательно) в новом пространстве имен. -u Флаг сообщает ей о запуске bash в новом UTS пространстве имен. Обратите внимание, как наш новый bash процесс указывает на другой uts файл, в то время как все остальные остаются прежними.

• Для создания новых пространств имен обычно требуется доступ суперпользователя. С этого момента мы будем предполагать, что оба unshare или наша реализация выполняются с sudo.

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

Но, например, что такое контейнер? (But like, what is a container though?)

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

Например, когда вы docker run –net=host redis, все, что вы делаете, это говорите docker не создавать новое Network пространство имен для redis процесса, и, как мы видели, Linux добавит этот процесс в качестве члена пространства имен по умолчанию Network, как и любой другой обычный процесс. Итак, процесс redis точно такой же, как и все остальные, с точки зрения сетевого взаимодействия. Сетевое взаимодействие здесь не является чем-то особенным,docker run давайте сделаем эту настройку для большинства пространств имен. Возникает вопрос о том, что вообще такое контейнер? Является ли процесс, который разделяет все пространства имен, кроме одного, все еще контейнером? _(ツ)_/
Обычно контейнеры поставляются с концепцией изоляции, достигаемой с помощью пространств имен - чем меньше количество пространств имен и ресурсов, совместно используемых процессом, тем более изолированным является процесс, и это все, что действительно имеет значение.

Программа Isolate (Isolate)

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

С точки зрения области применения мы сосредоточимся на User, Mount, PID и Network пространствах имен. Остальные относительно тривиальны для реализации после того, как мы закончим (фактически, здесь мы добавляем UTS поддержку в начальной реализации) и, Cgroup например, интересны только с точки зрения, выходящей за рамки этой серии (изучение cgroups - другого ингредиента в контейнерах, который используется для контроля того, какой объем ресурсов разрешено использовать процессу).

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

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

Реализация (Implementation)

Исходный код этого поста можно найти здесь.

Наша isolate реализация изначально будет представлять собой простую программу, которая считывает путь к команде из stdin и клонирует новый процесс, который выполняет команду с указанными аргументами. Клонированный командный процесс будет выполняться в своем собственном UTS пространстве имен точно так же, как мы делали с unshare ранее. В последующих публикациях мы увидим, что пространства имен не обязательно работают (или даже обеспечивают изоляцию) “из коробки”, и нам нужно будет выполнить некоторые настройки после их создания (но перед выполнением фактической команды), чтобы команда действительно выполнялась изолированно.

Эта комбинация создания и настройки пространства имен потребует некоторого взаимодействия между основным isolate процессом и дочерним командным процессом. В результате частью основной работы здесь будет настройка канала связи между обоими процессами - мы будем использовать Linux pipe из-за его простоты с учетом нашего варианта использования.

Нам нужно сделать три вещи:

1. Создайте основной isolate процесс, который считывает данные из stdin.
2. Клонируйте новый процесс, который выполнит команду в новом UTS пространстве имен.
3. Настройте канал таким образом, чтобы командный процесс начинал выполнение команды только после получения сигнала от основного процесса о том, что настройка пространства имен завершена.

Вот основной процесс:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65

struct params {
    int fd[2];
    char **argv;
};

static void parse_args(int argc, char **argv,
                       struct params *params)
{
#define NEXT_ARG() do { argc--; argv++; } while (0)
    // Skip binary path
    NEXT_ARG();

    if (argc < 1) {
        printf("Nothing to do!\n");
        exit(0);
    }

    params->argv = argv;
#undef NEXT_ARG
}

#define STACKSIZE (1024*1024)
static char cmd_stack[STACKSIZE];
....

int main(int argc, char **argv)
{

    struct params params;
    memset(&params, 0, sizeof(struct params));
    parse_args(argc, argv, &params);

    // Create pipe to communicate between main and command process.
    // Создание пайпа для связи между основным и командным процессом.
    if (pipe(params.fd) < 0)
        die("Failed to create pipe: %m");

    // Clone command process.
    // Клонирование командного процесса.
    int clone_flags = SIGCHLD | CLONE_NEWUTS ;
    int cmd_pid = clone(cmd_exec, cmd_stack + STACKSIZE, clone_flags, &params);

    if (cmd_pid < 0)
        die("Failed to clone: %m\n");

    // Get the writable end of the pipe.
    // Получить доступный к записи конец пайпа.
    int pipe = params.fd[1];

    // Some namespace setup will take place here ...
    // Тут будут размещаться некоторые настройки namespace ...

    // Signal to the command process we're done with setup.
    // Сигнал командному процессу, что мы закончили с настройкой.
    if (write(pipe, "OK", 2) != 2)
        die("Failed to write to pipe: %m");
    if (close(pipe))
        die("Failed to close pipe: %m");

    if (waitpid(cmd_pid, NULL, 0) == -1)
        die("Failed to wait pid %d: %m\n", cmd_pid);

    return 0;
}

Обратите внимание на clone_flags, которые мы передаем в наш вызов clone. Видите, как просто создать процесс в его собственном namespace? Всё, что нам нужно сделать, это установить флаг для типа namespace (CLONE_NEWUTS флаг соответствует UTS namespace), а Linux позаботится об остальном.

Далее процесс команды ожидает сигнала перед её запуском:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

static int cmd_exec(void *arg)
{
    // Kill the cmd process if the isolate process dies.
    // Убить процесс cmd если процесс isolate умирает.
    if (prctl(PR_SET_PDEATHSIG, SIGKILL))
        die("cannot PR_SET_PDEATHSIG for child process: %m\n");

    struct params *params = (struct params*) arg;
    // Wait for 'setup done' signal from the main process.
    // Ожидание сигнала 'настройка завершена' от основного процесса.    
    await_setup(params->fd[0]);

    char **argv = params->argv;
    char *cmd = argv[0];
    printf("===========%s============\n", cmd);

    if (execvp(cmd, argv) == -1)
        die("Failed to exec %s: %m\n", cmd);

    die("¯\\_(ツ)_/¯");
    return 1;
}

Наконец, мы может попробовать это запустить:

1
2
3
4
5
6
7
8
9
10
11

$ ./isolate sh
===========sh============
$ ls
isolate  isolate.c  isolate.o  Makefile
$ hostname
iffy
$ hostname coke
$ hostname
coke
 # Verify in a new terminal that hostname hasn't been updated
 # Проверьте в новом окне терминала, что имя хоста не изменилось

В настоящее время isolate - это немного больше, чем программа, которая просто разветвляет команду (у нас есть UTS то, что работает для нас). В следующем посте мы сделаем еще один шаг вперед, рассмотрев User пространства имен и заставим isolate запустить команду в ее собственном User пространстве имен. Там мы увидим, что нам действительно нужно проделать некоторую работу, чтобы иметь полезное пространство имен, в котором может выполняться команда.