Перейти к основному содержанию Перейти к навигации Перейти к нижнему колонтитулу

Сервисы

Развертывание и управление контейнеризированными сервисами с помощью Rediaccfiles, сетевого взаимодействия и автозапуска.

Сервисы

На этой странице описывается развертывание и управление контейнеризированными сервисами, включая Rediaccfiles, сетевое взаимодействие сервисов, запуск/остановка, массовые операции и автозапуск.

Rediaccfile

Rediaccfile - это Bash-скрипт, определяющий, как ваши сервисы запускаются и останавливаются. Он исходится (не выполняется как отдельный процесс), поэтому его функции используют один контекст оболочки и имеют доступ ко всем экспортированным переменным окружения. Он должен называться Rediaccfile или rediaccfile (регистр не имеет значения) и размещаться внутри смонтированной файловой системы репозитория.

Rediaccfiles обнаруживаются в двух местах:

  1. В корне пути монтирования репозитория
  2. В поддиректориях первого уровня пути монтирования (не рекурсивно)

Скрытые директории (имена начинаются с .) пропускаются.

Функции жизненного цикла

renet выполняет следующие функции Rediaccfile:

ФункцияКогда выполняетсяНазначениеПоведение при ошибке
up()При запускеЗапуск сервисов (например, renet compose -- up -d)Ошибка корневого Rediaccfile критическая (останавливает всё). Ошибки в поддиректориях некритические (логируются, продолжение работы)
down()При остановкеОстановка сервисов (например, renet compose -- down)Максимальные усилия - ошибки логируются, но все Rediaccfiles всегда обрабатываются
health()При rdc repo health, при rdc machine health и в проверке состояния при развёртыванииСообщить о собственном состоянии репозитория: код выхода 0 в порядке, 1 предупреждение, 2 ошибкаВыполняется health() каждого Rediaccfile, учитывается худший уровень. Код 75 означает, что репозиторий ещё прогревается (предупреждение). Любой другой код выхода, сигнал или превышение времени считается ошибкой (проверка здоровья при деплое читает превышение времени как «ещё прогревается» и повторяет попытку, см. Тайм-ауты и порядок выключения). Репозиторий, в котором ни один Rediaccfile не определяет health(), сообщает проверки нет, но никогда не «исправен»
repair()При rdc repo repair и при rdc machine repair для репозитория, чей health() не в порядкеИсправить то, о чём сообщил health() того же файлаВыполняется, только если health() его файла не в порядке и объявленный класс разрешён (см. ниже). health(), завершившийся с кодом 75 (ещё прогревается), считается предупреждением, поэтому repair() не должен трогать репозиторий, который ещё запускается. После этого health() выполняется снова. repair(), который завершился с ошибкой или превысил время, считается ошибкой

Каждая функция необязательна. Если функция не определена, она молча пропускается.

Объявление класса ремонта

repair() получает REDIACC_HEALTH_LEVEL (warning или error, уровень, о котором сообщил health() его собственного файла) и REDIACC_HEALTH_OUTPUT (конец вывода этого health()). Строка-комментарий объявляет, насколько функция безопасна:

# rediacc:repair class=auto-safe
# rediacc:repair class=auto-with-backup window=only
КлассКто выполняет
auto-saferdc machine repair и rdc repo repair выполняют её сами
auto-with-backupВыполняется только с --with-backup, после успешного снимка репозитория
operator-onlyСама никогда не выполняется. rdc repo repair сначала спрашивает (или принимает --yes); rdc machine repair её не выполняет никогда

repair() без объявления считается operator-only, поэтому ни один инструмент не запускает код репозитория без присмотра, пока сам репозиторий не заявит, что он безопасен. window=only добавляет второе условие: функция выполняется только внутри окна обслуживания машины (Мониторинг) или с --window-override. Если класс объявлен в нескольких строках, действует самый строгий.

Порядок выполнения

  • Запуск (up): Сначала корневой Rediaccfile, затем поддиректории в алфавитном порядке (от A до Z).
  • Остановка (down): Поддиректории в обратном алфавитном порядке (от Z до A), затем корневой последним.

Переменные окружения

Когда выполняется функция Rediaccfile, доступны следующие переменные окружения:

ПеременнаяОписаниеПример
REDIACC_WORKING_DIRПуть монтирования репозитория/mnt/rediacc/mounts/abc123
REDIACC_REPOSITORYGUID репозиторияa1b2c3d4-e5f6-...
REDIACC_NETWORK_IDИдентификатор сети (целое число)2816
DOCKER_HOSTDocker-сокет для изолированного демона данного репозиторияunix:///var/run/rediacc/net-2816/docker-2816.sock
{SERVICE}_IPLoopback IP для каждого сервиса, определенного в .rediacc.jsonPOSTGRES_IP=127.0.11.2

Переменные {SERVICE}_IP автоматически генерируются из слотов, определенных в .rediacc.json, и экспортируются перед выполнением функций Rediaccfile. Соглашение об именовании преобразует имя сервиса в верхний регистр с заменой дефисов на подчеркивания, затем добавляет _IP. Например, сервис с именем listmonk-app и слотом 0 становится LISTMONK_APP_IP=127.0.11.2.

Предупреждение: Не используйте sudo docker в Rediaccfiles. Команда sudo сбрасывает переменные окружения, из-за чего теряется DOCKER_HOST и команды Docker обращаются к системному демону вместо изолированного демона репозитория. Это нарушает изоляцию контейнеров и может вызвать конфликты портов. Rediacc блокирует выполнение при обнаружении sudo docker.

Используйте renet compose в своих Rediaccfiles - он автоматически обрабатывает DOCKER_HOST, внедряет сетевые метки для обнаружения маршрутов и настраивает сетевое взаимодействие сервисов. Подробнее о том, как сервисы предоставляются через обратный прокси, см. в разделе Сетевое взаимодействие. При прямом вызове Docker используйте docker без sudo - функции Rediaccfile обращаются к Docker-демону репозитория как универсальный пользователь, без root (см. Привилегии).

renet - это удалённый инструмент низкого уровня. Для обычных рабочих процессов с вашей рабочей станции предпочитайте команды rdc, такие как rdc repo up и rdc repo down. См. rdc vs renet.

Привилегии

up() и down() выполняются от универсального пользователя (rediacc), а не от root, внутри песочницы, которая ограничивает, где они могут читать и писать. Окружение собирается для функции, а не наследуется, поэтому в нём есть перечисленные выше переменные, значения REDIACC_SECRET_* репозитория и минимальный PATH. sudo недоступен ни на одном уровне: песочница выставляет no_new_privs, так что строка Rediaccfile с sudo завершается ошибкой, и sudo из неё нужно убрать. Машина без Landlock отказывается выполнять up() и down(), вместо того чтобы запускать их без ограничений.

Строка, которой нужно больше, чем даёт значение по умолчанию, завершается ошибкой, которую возвращает песочница, а журнал и CLI выводят соответствующую строку Rediaccfile вместе с командой выдачи разрешения.

Что делает RediaccfileЧто он видитРешение
sudo xsudo: The "no new privileges" flag is setУберите sudo. Шагу либо не нужен root, либо нужно разрешение
chown 5050 ... или rm -rf каталога, которым владеет контейнерOperation not permitted или Permission deniedВыполните шаг в одноразовом контейнере (root внутри контейнера; Docker-демон репозитория отклоняет привязки вне собственных корней репозитория): renet compose -- run --rm --no-deps --user 0 --entrypoint chown <service> -R 5050:5050 /data
Записывает .env и другие файлы в точку монтированияРаботает; файлы принадлежат универсальному пользователюНичего не нужно
Читает /etc/rediacc/*, /proc/kcore или блочное устройствоPermission deniedЗапросите разрешение на путь
Напрямую читает файловый секретPermission deniedИспользуйте secrets: в compose или секрет в режиме env
nvidia-smi без разрешения на устройствоУстройство отсутствуетВыдайте разрешение на устройство, см. GPU
sysctl -wPermission deniedЗадайте один раз на машине от имени администратора

Запрос разрешения

Разрешение расширяет то, до чего могут дотянуться up() и down(). Выдаёт его только оператор, снаружи репозитория:

rdc repo permission grant <repo-ref> --path /srv/data:rw
rdc repo permission grant <repo-ref> --root
rdc repo permission show <repo-ref>
rdc repo permission revoke <repo-ref> --path /srv/data

--path добавляет одно правило Landlock, по умолчанию только для чтения, если не указано :rw, а машина отклоняет путь, который выходит на другой репозиторий, хранилище данных или /etc/rediacc. --root запускает функции от root без понижения привилегий, а холодное резервное копирование отказывается работать с таким репозиторием. Агенты не могут выдать --root, если оператор не задал REDIACC_ALLOW_GRAND_REPO до запуска агента. У форка новый идентификатор сети, и он стартует без разрешений, а разрешение, найденное при повторно использованном идентификаторе сети, отбрасывается.

Rediaccfile может объявить, что ему нужно, строкой-комментарием, но только как запрос:

# rediacc:needs root
# rediacc:needs path=/srv/data
# rediacc:needs device=nvidia.com/gpu=all

up() сравнивает объявление с выданным разрешением. Если разрешения нет, up() отклоняется до выполнения любой строки, а в сообщении выводится точная команда выдачи разрешения. down() объявление не проверяет, поэтому комментарий, изменённый внутри репозитория, не может помешать repo down оператора; down(), которому разрешение действительно нужно, завершается ошибкой на своём шаге. machine converge пропускает такой репозиторий как needs_lifecycle_grant, вместо того чтобы перезапускать его в отказ.

Тайм-ауты и порядок выключения

Контейнеры репозитория не останавливаются, пока его down() не отработал и не завершился. Это относится к systemctl stop и restart Docker-юнита репозитория, machine converge, repo down --unmount, перезаписи юнита и выключению хоста. Исключения: сбой демона Docker или хоста, отключение питания и down(), превысивший тайм-аут, будь то при выключении хоста или при systemctl stop либо restart. Такой down() убивается, и остановка продолжается, как описано ниже.

Перед отправкой сигнала демону каждый Docker-юнит запускает хук остановки. Хук выполняет down() на ещё работающем демоне, если renet уже не сделал это для текущего запуска демона, и пропускает его, когда демон не отвечает или у репозитория нет Rediaccfile. При выключении хоста сначала останавливаются Docker-юниты, каждый выполняет down() параллельно, затем юнит-уборщик размонтирует все смонтированные репозитории, с автозапуском и без. Бюджет остановки юнита составляет 17 минут, что укладывается в 30-минутный лимит задания перезагрузки. Если down() превышает тайм-аут внутри этого хука, его группа процессов получает SIGTERM, а через 10 секунд SIGKILL (FunctionKillGrace, pkg/orchestration/procgroup.go), пишется предупреждение, а хук завершается с кодом 0, поэтому systemd продолжает остановку. Таким образом, down() с превышением тайм-аута задерживает systemctl stop или перезапуск на срок до его тайм-аута плюс 10 секунд (15 минут 10 секунд на максимуме), а остановка остаётся ограниченной 17-минутным TimeoutStopSec юнита. Отказ от остановки действует только на собственных путях renet, например repo down --unmount.

По умолчанию up() и down() получают по 10 минут; значение задаётся через RENET_UP_TIMEOUT и RENET_DOWN_TIMEOUT или --up-timeout и --down-timeout. По тайм-ауту группа процессов получает SIGTERM, а через 10 секунд SIGKILL. Операция, которой сначала нужен down(), например repo down --unmount или перезапуск при converge, оставляет контейнеры работать, если down() превысил тайм-аут; --force продолжает. Rediaccfile может поднять лимит строкой-комментарием:

# rediacc:timeout up=20m down=15m backup=120s health=60s repair=10m
КлючПо умолчаниюМаксимум
up10 минут60 минут
down10 минут15 минут
backup30 секунд300 секунд
health30 секунд300 секунд
repair5 минут30 минут

health() ограничен так же: значение по умолчанию задаётся через RENET_HEALTH_TIMEOUT, а при превышении времени его группа процессов получает SIGTERM, а через 10 секунд SIGKILL. Проверка состояния при развёртывании считает health() с превышением времени всё ещё прогревающимся и повторяет попытку; rdc repo health и rdc machine health сообщают об этом как об ошибке. repair() работает по той же модели с RENET_REPAIR_TIMEOUT, и repair() с превышением времени считается неудавшимся.

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

Демоны репозиториев держат live-restore Docker выключенным. Контейнеры пережили бы перезапуск демона, но shim-процессы находятся в cgroup юнита и гибнут вместе с ним, так что восстановленный демон не смог бы к ним подключиться, а контейнеры удерживали бы точку монтирования при плановой остановке.

RAM-том для каждого репозитория под управлением renet (# rediacc:ram size=6G, оперативную память хоста выделяет оператор) пока существует только как проект и не реализован.

Пример

#!/bin/bash

up() {
    echo "Starting services..."
    renet compose -- up -d
}

down() {
    echo "Stopping services..."
    renet compose -- down
}

Важно: Всегда используйте renet compose -- вместо docker compose. Обёртка renet compose обеспечивает host-сеть, распределение IP-адресов и метки обнаружения сервисов, необходимые для renet-proxy. Возможности CRIU checkpoint/restore добавляются к контейнерам с меткой rediacc.checkpoint=true. Прямое использование docker compose отклоняется валидацией Rediaccfile. Подробнее см. в разделе Сетевое взаимодействие.

Метки возможностей

По умолчанию контейнеры запускаются с минимальным набором Linux capabilities. Сервис подключает дополнительные capabilities, добавив метку в docker-compose.yml:

МеткаПредоставляетДля чего
rediacc.checkpoint=trueCHECKPOINT_RESTORE, SYS_PTRACE, NET_ADMINCRIU checkpoint/restore (живая миграция, сохранение и возобновление)
rediacc.wireguard=trueNET_ADMIN и устройство /dev/net/tunЗапуск WireGuard-клиента внутри контейнера
services:
  vpn:
    image: alpine
    labels:
      - "rediacc.wireguard=true"

rediacc.wireguard позволяет сервису поднять WireGuard-туннель, например для маршрутизации отдельного процесса через удалённый endpoint. Поскольку все сервисы работают с host-сетью, изолируйте туннель в сетевом пространстве имён внутри контейнера, чтобы не затрагивать маршрутизацию хоста. Широкие привилегированные параметры, такие как privileged: true, pid: host и ipc: host, отклоняются вне зависимости от меток, и при валидации compose, и через Docker API, где демон репозитория отвечает 403.

Расположение нескольких сервисов

Для проектов с несколькими независимыми группами сервисов используйте поддиректории:

/mnt/rediacc/repos/my-app/
├── Rediaccfile              # Корневой: общая настройка
├── docker-compose.yml
├── database/
│   ├── Rediaccfile          # Сервисы базы данных
│   └── docker-compose.yml
├── backend/
│   ├── Rediaccfile          # API-сервер
│   └── docker-compose.yml
└── monitoring/
    ├── Rediaccfile          # Prometheus, Grafana и т.д.
    └── docker-compose.yml

Порядок выполнения для up: корневой, затем backend, database, monitoring (A-Z). Порядок выполнения для down: monitoring, database, backend, затем корневой (Z-A).

Сетевое взаимодействие сервисов (.rediacc.json)

Каждый репозиторий получает подсеть /26 (64 IP-адреса) в loopback-диапазоне 127.x.x.x. Сервисы привязываются к уникальным loopback IP-адресам, что позволяет им работать на одних и тех же портах без конфликтов.

Файл .rediacc.json

Сопоставляет имена сервисов с номерами слотов. Каждый слот соответствует уникальному IP-адресу в подсети репозитория.

{
  "services": {
    "api": {"slot": 0},
    "postgres": {"slot": 1},
    "redis": {"slot": 2}
  }
}

Автоматическая генерация из Docker Compose

Вам не нужно создавать .rediacc.json вручную. При выполнении rdc repo up Rediacc автоматически:

  1. Сканирует все директории, содержащие Rediaccfile, на наличие compose-файлов (docker-compose.yml, docker-compose.yaml, compose.yml или compose.yaml)
  2. Извлекает имена сервисов из секции services:
  3. Назначает следующий доступный слот каждому новому сервису
  4. Сохраняет результат в {repository}/.rediacc.json

Вычисление IP-адресов

IP-адрес сервиса вычисляется из идентификатора сети репозитория и слота сервиса. Идентификатор сети распределяется по второму, третьему и четвёртому октетам loopback-адреса 127.x.y.z. Сервисы начинают со смещения 2:

OffsetAddressPurpose
.0127.0.11.0Network address (reserved)
.1127.0.11.1Gateway (reserved)
.2 – .62127.0.11.2 – 127.0.11.62Services (slot + 2)
.63127.0.11.63Broadcast (reserved)

Пример для идентификатора сети 2816 (0x0B00), базовый адрес 127.0.11.0:

СервисСлотIP-адрес
api0127.0.11.2
postgres1127.0.11.3
redis2127.0.11.4

Каждый репозиторий поддерживает до 61 сервиса (слоты от 0 до 60).

Использование IP-адресов сервисов в Docker Compose

Поскольку каждый репозиторий работает с изолированным Docker-демоном, renet compose автоматически настраивает network_mode: host для всех сервисов. Ядро прозрачно перезаписывает вызовы bind() на назначенный loopback IP-адрес сервиса, поэтому сервисы могут привязываться к 0.0.0.0 или localhost без конфликтов. Для подключения к другим сервисам используйте имя сервиса. renet внедряет каждое имя сервиса как имя хоста, которое всегда разрешается в правильный IP, даже в форках:

services:
  postgres:
    image: postgres:16
    environment:
      PGDATA: /var/lib/postgresql/data
      POSTGRES_PASSWORD: secret
    # No explicit listen_addresses needed - the kernel rewrites bind to the correct loopback IP

  api:
    image: my-api:latest
    environment:
      DATABASE_URL: postgresql://postgres:secret@postgres:5432/mydb  # use service name
      LISTEN_ADDR: 0.0.0.0:8080                                      # kernel rewrites to service IP

Имена сервисов для подключений: Используйте имя сервиса (например, postgres, redis) для подключения к другим сервисам - renet автоматически сопоставляет каждое имя сервиса с его loopback IP через /etc/hosts. Встраивание ${POSTGRES_IP} в строки подключения, хранящиеся в базах данных или файлах конфигурации, зафиксирует необработанный IP, что нарушит изоляцию форков и является ошибкой валидации. Переменные ${SERVICE_IP} по-прежнему доступны для явного использования, но привязка обрабатывается автоматически ядром.

Примечание: Не добавляйте network_mode: host вручную - renet compose внедряет его автоматически. Политики перезапуска (например, restart: always) безопасны для использования, renet автоматически удаляет их для совместимости с CRIU, а watchdog маршрутизатора управляет восстановлением контейнеров.

Восстановление контейнеров и политика перезапуска

renet и Docker намеренно расходятся во мнении о том, как обрабатывать перезапуски контейнеров. Понимание этого разделения важно при диагностике причин, по которым контейнер вернулся или не вернулся.

Трансляция политики перезапуска. Когда вы пишете restart: always (или unless-stopped, или on-failure) в файле compose, renet удаляет её при синтезировании фактического compose-развертывания и заменяет на restart: no. Исходное значение сохраняется в .rediacc.json репозитория под services.<name>.restart_policy. Это предотвращает вмешательство автоматического перезапуска на уровне Docker-демона в работу CRIU checkpoint/restore (перезапуск, управляемый демоном, возобновился бы с устаревшего состояния до checkpoint).

Применение watchdog. Watchdog маршрутизатора периодически запускается на каждой машине. При каждом тике:

  1. Читает .rediacc.json для каждого репозитория и находит сервисы с восстанавливаемой restart_policy.
  2. Перечисляет все контейнеры для демона этого репозитория, определяет остановленные и перезапускает их согласно сохранённой политике. Льготный период 30 секунд предотвращает конфликт с оператором, который только что выполнил docker stop.
  3. Та же петля также обрабатывает /var/run/rediacc/cold-backup-<guid>.running.json (см. семантику cold backup). Перечисленные контейнеры перезапускаются независимо от сохранённой политики, поскольку sidecar означает “renet намеренно остановил их и обязан оператору перезапуском.”

Почему on-failure может выглядеть сломанным. Политика on-failure Docker перезапускается только когда контейнер завершается с ненулевым кодом. Штатная остановка (exit 0) от docker stop или завершения демона не является “сбоем” и НЕ запускает перезапуск ни по нативной логике Docker, ни по пути сохранённой политики watchdog. Cold backup sidecar является страховочной сетью: любой контейнер, который мы остановили намеренно, перезапускается независимо от его политики.

Как интерпретировать состояние во время выполнения:

  • docker inspect <container> → RestartPolicy.Name: всегда будет no для контейнеров, управляемых renet. Не полагайтесь на это для семантической политики.
  • .rediacc.json в корне монтирования репозитория → services.<name>.restart_policy: реальное намерение.
  • docker ps --format '{{.Status}}': состояние во время выполнения.

Как исправить расхождение. Если сохранённая политика контейнера в .rediacc.json неверна (например, потому что вы изменили compose, но никогда не пересоздавали контейнер), повторно запустите rdc repo up <repo>. Контейнер будет пересоздан с записанной обновлённой политикой.

Экспериментально: Восстановление на основе cold backup sidecar и флаг --sync-certs в rdc machine status появились в renet 0.9+. Более старые версии полностью полагаются на сохранённую restart_policy для восстановления watchdog, что может оставить контейнеры on-failure зависшими после cold backup.

Сетевой мост Docker отключён для демонов, отвечающих за отдельные репозитории. Каждый такой демон (FlavorRediacc) настроен с "bridge": "none" и "iptables": false. Обычный docker run <image> внутри оболочки репозитория всё равно запустится, но контейнер получит только loopback-интерфейс и не будет иметь DNS или исходящего сетевого подключения. Это сделано намеренно, поскольку изоляция loopback между репозиториями обеспечивается eBPF cgroup-хуками, которые обойдёт контейнер в режиме bridge. Для production-сервисов используйте renet compose (который сам внедряет host-сеть); для разовой отладки передавайте --network host явно: docker run --rm --network host -it ubuntu bash.

Hub-демоны для каждого пользователя (FlavorHub, используются в средах разработки) являются исключением: они задают bridge="docker0", iptables=true и live-restore=true, чтобы контейнеры, запускаемые пользователем, получали обычную сетевую связность через bridge и исходящее подключение.

Примечание: Форк-репозитории получают автоматические маршруты под поддоменом родителя: {service}-fork-{tag}.{repo}.{machine}.{baseDomain}. Пользовательские домены для форков пропускаются.

Запуск сервисов

Смонтируйте репозиторий и запустите все сервисы:

rdc repo up my-app
ОпцияОписание
--no-waitВернуть управление сразу после запуска контейнеров; проверки готовности продолжаются в фоне
--skip-router-restartПропустить перезапуск сервера маршрутов после операции

Последовательность выполнения:

  1. Монтирование LUKS-зашифрованного репозитория (автоматически, если не смонтирован)
  2. Запуск изолированного Docker-демона
  3. Автоматическая генерация .rediacc.json из compose-файлов
  4. Выполнение up() во всех Rediaccfiles (в алфавитном порядке)

После развертывания в выводе отображается раздел PROXY ROUTES с фактическими URL для каждого сервиса. Сервисы с пользовательскими метками Traefik показывают свои пользовательские домены в качестве основных URL:

HTTP services (accessible via proxy after ~3s):
  gitlab-server:
    HTTPS: https://gitlab.example.com  (custom)
    Auto:  https://gitlab-server.gitlab.server-1.example.com
    IP:    127.0.11.130

Сервисы без пользовательских меток Traefik показывают только автоматически созданный маршрут. Используйте эти URL (а не универсальный шаблон, выводимый CLI) для доступа в браузере, вызовов API и настройки кросс-сервисной коммуникации.

Отсоединённый запуск

С флагом --no-wait команда возвращает управление сразу после старта контейнеров, не дожидаясь завершения проверок готовности. Запуск продолжается в фоне: прокси повторяет попытки подключения к апстриму, пока каждый сервис не ответит; маршруты восстанавливаются автоматически. Для отслеживания прогресса используйте rdc machine status <machine> --containers. Идеально подходит для одноразовых форков и скриптовых циклов, где следующий шаг не требует полной готовности сервисов.

Проверка готовности

После выполнения up() renet опрашивает каждый HTTP-сервис, пока он не примет TCP-соединение, что предотвращает ошибку 502 от прокси при первом браузерном запросе. Контейнеры с настроенной в Docker проверкой состояния считаются надёжным источником: здоровый контейнер пропускает опрос, а контейнер в периоде start_period регистрирует информационную запись вместо предупреждения. Таймаут опроса составляет 15 секунд (переопределите через переменную REDIACC_READINESS_TIMEOUT в секундах на машине); отсоединённый запуск пропускает опрос полностью.

Остановка сервисов

rdc repo down my-app
ОпцияОписание
--unmountРазмонтировать зашифрованный репозиторий после остановки сервисов.
--skip-router-restartПропустить перезапуск сервера маршрутов после операции

Последовательность выполнения:

  1. Выполнение down() во всех Rediaccfiles (в обратном алфавитном порядке, максимальные усилия)
  2. Остановка изолированного Docker-демона (если указан --unmount)
  3. Размонтирование и закрытие LUKS-зашифрованного тома (если указан --unmount)

Массовые операции

Запуск или остановка всех репозиториев на машине одновременно:

rdc repo up --all -m server-1
ОпцияОписание
--include-forksВключить форкнутые репозитории
--no-startТолько смонтировать и подготовить, не выполнять шаги up() репозитория
--dry-runПоказать, что будет выполнено
--parallelВыполнять операции параллельно
--concurrency <n>Максимальное количество параллельных операций (по умолчанию: 3)
--skip-router-restartПропустить перезапуск сервера маршрутов после операции

Автозапуск при загрузке

По умолчанию репозитории необходимо вручную монтировать и запускать после перезагрузки сервера. Автозапуск настраивает репозитории на автоматическое монтирование, запуск Docker и выполнение Rediaccfile up() при загрузке сервера.

Как это работает

При включении автозапуска для репозитория:

  1. Генерируется случайный LUKS-ключевой файл размером 256 байт и добавляется в LUKS-слот 1 репозитория (слот 0 остается для пользовательской парольной фразы)
  2. Ключевой файл сохраняется по пути {datastore}/.credentials/keys/{guid}.key с правами 0600 (только root)
  3. Устанавливается systemd-сервис (rediacc-autostart), который при загрузке монтирует все включенные репозитории и запускает их сервисы

При завершении работы сервис корректно останавливает все сервисы (Rediaccfile down()), останавливает Docker-демоны и закрывает тома LUKS.

Примечание по безопасности: Включение автозапуска сохраняет LUKS-ключевой файл на диске сервера. Любой пользователь с root-доступом к серверу может смонтировать репозиторий без парольной фразы. Оцените это с учетом вашей модели угроз.

Включение

rdc repo admin autostart enable my-app

Вам будет предложено ввести парольную фразу репозитория.

Включение для всех репозиториев

rdc repo admin autostart enable

Отключение

rdc repo admin autostart disable my-app

Эта команда удаляет ключевой файл и деактивирует LUKS-слот 1.

Обновление ключевого файла при развертывании

Когда автозапуск включён, rdc repo up проверяет ключевой файл LUKS-слота 1. Если ключевой файл на диске всё ещё совпадает со слотом LUKS, изменения не вносятся.

После переноса репозитория между машинами через repo push / repo pull ключевой файл на новой машине не совпадёт. В этом случае repo up автоматически перегенерирует ключевой файл и обновит LUKS-слот 1. Вы увидите следующие сообщения в журнале:

Refreshing keyfile credential for <guid>
Killing LUKS slot 1: /mnt/rediacc/repositories/<guid>
Adding keyfile to LUKS slot 1: /mnt/rediacc/repositories/<guid>

Это безопасно - слот 0 (парольная фраза) никогда не изменяется. Если автозапуск не включён, проверка молча пропускается. Сбои не критичны и не блокируют развертывание.

Список статусов

rdc repo admin autostart list -m server-1

Подробнее о том, как периодический реконсилятор восстанавливает репозитории, остановившиеся после загрузки, см. Автозапуск и восстановление.

Полный пример

Этот пример развертывает веб-приложение с PostgreSQL, Redis и API-сервером.

1. Настройка

curl -fsSL https://www.rediacc.com/install.sh | bash
rdc config init production --ssh-key ~/.ssh/id_ed25519
rdc machine add prod-1 --ip 203.0.113.50 --user deploy
rdc machine setup prod-1
rdc repo create webapp -m prod-1 --size 10G

2. Монтирование и подготовка

rdc repo up webapp --no-start

3. Создание файлов приложения

Внутри репозитория создайте:

docker-compose.yml:

services:
  postgres:
    image: postgres:16
    volumes:
      - ./data/postgres:/var/lib/postgresql/data
    environment:
      POSTGRES_DB: webapp
      POSTGRES_USER: app
      POSTGRES_PASSWORD: changeme

  redis:
    image: redis:7-alpine

  api:
    image: myregistry/api:latest
    environment:
      DATABASE_URL: postgresql://app:changeme@postgres:5432/webapp
      REDIS_URL: redis://redis:6379
      LISTEN_ADDR: 0.0.0.0:8080

Rediaccfile:

#!/bin/bash

up() {
    mkdir -p data/postgres
    renet compose -- up -d

    echo "Waiting for PostgreSQL..."
    for i in $(seq 1 30); do
        if renet compose -- exec postgres pg_isready -q 2>/dev/null; then
            echo "PostgreSQL is ready."
            return 0
        fi
        sleep 1
    done
    echo "Warning: PostgreSQL did not become ready within 30 seconds."
}

down() {
    renet compose -- down
}

4. Запуск

rdc repo up webapp

5. Включение автозапуска

rdc repo admin autostart enable webapp

Использование per-repo secrets в compose

Placeholder POSTGRES_PASSWORD: changeme выше подходит для учебного примера, но в реальных приложениях нужны реальные учетные данные. Коммит их в compose-файл (или в .env файл внутри репозитория) означает, что форк унаследует их тоже. Для учетных данных на этапе развертывания используйте rdc repo secret. Значения хранятся вне зашифрованного образа репозитория, поэтому форки начинают с пустой карты secrets.

В compose поддерживаются два режима доставки:

Режим env. Интерполяция через ${REDIACC_SECRET_<KEY>} в значениях environment:. Обёртка renet передает значение в переменные окружения контейнера во время развертывания.

Режим file. Значение записывается в tmpfs-файл на хост-стороне по пути /var/run/rediacc/net-<networkID>/secrets/<KEY>, а затем монтируется в контейнер через стандартный блок secrets: Docker Compose. Контейнер читает из /run/secrets/<key>. Предпочитайте этот режим для чувствительных данных. Значения никогда не появятся в выводе docker inspect или /proc/<pid>/environ.

services:
  api:
    image: myregistry/api:latest
    environment:
      DATABASE_URL: ${REDIACC_SECRET_DATABASE_URL}
    secrets:
      - stripe_live_key

secrets:
  stripe_live_key:
    file: /var/run/rediacc/net-${REDIACC_NETWORK_ID}/secrets/STRIPE_LIVE_KEY

Установите значения командой rdc repo secret set <repo> --key DATABASE_URL --value <val> --mode env --current "" и аналогичной для режима file. Полную инструкцию см. в разделе Repositories § Secrets, справку по командам - в разделе Per-repo secrets на шпаргалке.

Кросс-репо пути отклоняются при валидации. Если в compose указана secrets: file: (или configs: file:, или env_file:), указывающая на директорию /var/run/rediacc/net-<other-networkID>/secrets/ другого репозитория, то она будет жестко отклонена оберткой renet до запуска docker compose. --unsafe не переопределяет это. Defense-in-depth: Landlock-sandbox вокруг Rediaccfile-shell ограничивает доступ на чтение текущей сетевой директорией secrets, поэтому выполнение cat /var/run/rediacc/net-<other>/secrets/X из bash Rediaccfile завершится с ошибкой EACCES, даже если это обойдет YAML-валидатор. Не требует явного согласия - эта проверка включена по умолчанию для каждого вызова repo up.