SSD Nodes Learn Hosting plans →
Руководства Matt ConnorАвтор: Matt Connor · Обновлено 2026-10-12

Как продолжить выполнение команды после разрыва SSH

При разрыве SSH ядро отправляет сигнал SIGHUP, что приводит к завершению процессов. Используйте nohup, disown, tmux или systemd-run, чтобы сохранить работу при обрыве связи.

Почему команда завершается при разрыве SSH-соединения

Чтобы команда продолжала выполняться после разрыва SSH-соединения, она должна оказаться там, куда не доходит сигнал завершения сеанса. Каждый из описанных ниже методов предлагает свой способ реализации этого механизма.

Ваш сеанс работает через pty (псевдотерминал) — виртуальное терминальное устройство, которое sshd создает на сервере для вашей сессии. Это управляющий терминал для вашей оболочки и всех команд, которые вы из неё запускаете. Подробности этого процесса описаны в том, как SSH настраивает окружение при входе. Когда TCP-соединение разрывается, sshd закрывает свою сторону, и pty уничтожается. Ядро интерпретирует это как закрытие терминала и отправляет сигнал SIGHUP группе процессов переднего плана этого терминала и лидеру сессии, то есть вашей оболочке. Стандартное действие для SIGHUP — завершение процесса. Ваша команда находилась в группе процессов переднего плана, поэтому она завершается.

Фоновые задачи также не защищены. Задача, запущенная с помощью &, находится в собственной группе процессов, поэтому ядро не посылает ей сигнал напрямую. Это делает Bash. При получении SIGHUP интерактивный bash перед выходом пересылает SIGHUP каждой задаче из своей таблицы. Для вас результат выглядит одинаково: задача исчезает, а запись в лог-файл обрывается на полуслове.

Здесь существует асимметрия, которая часто сбивает с толку. Нажатие exit не завершает фоновые задачи, так как bash делает это только при включенной опции huponexit, которая по умолчанию выключена. Однако разрыв соединения завершает их. Задача, которая благополучно пережила закрытие терминала, может завершиться при потере Wi-Fi.

Из этого следуют два вывода, которые составляют суть проблемы. Процесс, который игнорирует SIGHUP или вообще не имеет управляющего терминала, не будет завершен. Но если стандартный вывод процесса всё ещё направлен в уничтоженный pty, процессу некуда писать: операция записи завершается с ошибкой EIO (input/output error), и большинство программ в этот момент прекращают работу. Вам нужно решить обе части задачи. Многие рецепты решают только первую, поэтому пользователи часто жалуются, что «nohup не сработал».

Если соединение обрывается несколько раз в день, устраните и эту причину. Параметр ServerAliveInterval 60 в ~/.ssh/config предотвращает сброс простаивающего сеанса из-за тайм-аута NAT (network address translation) на пути следования пакетов. Если сеанс не устанавливается вовсе, это другая неисправность с иными причинами, где важно понимать разницу между connection refused и connection timed out.

Какой метод позволяет команде продолжать работу после отключения SSH?

Четыре способа, упорядоченные по степени важности задачи.

  • nohup или setsid: для разовой задачи, которую вы запускаете сейчас, а результат просматриваете позже. Вывод необходимо перенаправить самостоятельно.
  • disown: для задачи, которую вы уже запустили, но забыли защитить от завершения. Этот инструмент позволяет «подхватить» процесс, но не возвращает его вывод в текущую сессию.
  • tmux или screen: для работы, которую нужно отслеживать, прерывать и возобновлять в течение нескольких дней.
  • systemd-run или полноценный unit file: для всего, что должно работать дольше вашего сеанса, например, шестичасовой rsync или ночной импорт базы данных.

Правило, которое стоит запомнить: если забыть о задаче — это проблема, значит, она должна управляться через systemd, а не через tmux. Окно tmux — это то, о чем человек должен помнить сам. У unit есть имя, статус, лог и политика перезапуска, которые может найти другой администратор без дополнительных указаний.

nohup и setsid: запуск и отключение от терминала

nohup ./import.sh > ~/import.log 2>&1 &
echo $! > ~/import.pid

nohup устанавливает игнорирование сигнала SIGHUP и затем выполняет вашу команду, поэтому сигнал завершения работы терминала (hangup) от ядра не оказывает никакого эффекта. Перенаправление вывода вы должны настроить самостоятельно. Если оставить стандартный вывод направленным в терминал, nohup перенаправит его в файл nohup.out в текущем каталоге (или в $HOME/nohup.out, если запись в первый невозможна) и выведет сообщение:

nohup: ignoring input and appending output to 'nohup.out'

Этот файл легко потерять из виду, поэтому лучше задать имя самостоятельно. Переменная $! содержит PID (идентификатор процесса) последней фоновой задачи, и сохранение этого значения позволит вам проверить состояние задачи после повторного входа в систему.

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

setsid --fork ./import.sh > ~/import.log 2>&1

Используйте --fork. Без этого флага setsid вызывает setsid() на месте, если процесс не является лидером группы процессов (что происходит при выполнении внутри shell-скрипта), и ваш скрипт зависает в ожидании. С флагом --fork поведение остается одинаковым как в скрипте, так и при вводе в командной строке.

Проверьте результат:

ps -o pid,ppid,sid,tty,stat,cmd -p "$(cat ~/import.pid)"

Значение TTY в столбце ? означает, что у процесса нет управляющего терминала, поэтому ничто не может его завершить при закрытии сессии. В nohup столбец TTY все еще может показывать что-то вроде pts/0, пока вы остаетесь в системе, и меняется на ? после уничтожения pty. Оба результата означают, что процесс работает корректно. Задача успешно пережила отключение.

disown: спасение уже запущенной задачи

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

# press Ctrl-Z to suspend the job first
bg
jobs -l
disown -h %1

Ctrl-Z приостанавливает задачу, bg переводит её в фоновый режим, а jobs -l выводит номер задачи рядом с её PID. disown -h %1 помечает задачу, чтобы bash не отправлял ей SIGHUP. Обычная команда disown %1 полностью удаляет задачу из таблицы bash, что дает тот же эффект при разрыве соединения, но после этого jobs перестает её отображать.

Чего disown не может сделать, так это перенаправить вывод. Процесс по-прежнему использует pty в качестве стандартного вывода, и когда pty закрывается, следующая операция записи возвращает EIO. Поэтому disown надежно сохраняет «тихую» задачу, например, компиляцию, которая пишет в файл, но часто приводит к потере «разговорчивой» задачи. Процесс либо продолжает работу, не имея места для вывода данных, либо завершается при попытке вывести следующую строку.

Существует инструмент для спасения файловых дескрипторов. reptyr переносит запущенный процесс в ваш текущий терминал: установите его с помощью sudo apt install -y reptyr, а затем запустите reptyr <pid> из окна tmux. Он работает через ptrace, а в Ubuntu поставляется kernel.yama.ptrace_scope = 1, который разрешает отладку только собственных дочерних процессов, поэтому для процесса, который вы унаследовали, требуется sudo reptyr <pid>. Используйте это как аварийный инструмент. Не стройте на нём повседневные рабочие процессы.

tmux: работа, за которой нужно следить и к которой нужно возвращаться

tmux (терминальный мультиплексор) решает эту задачу иначе. Вместо защиты процесса от pty, он предоставляет процессу pty, который не привязан к вашей SSH-сессии. Сервер tmux работает вне этой сессии и владеет терминалами всех запущенных внутри процессов. Ваше SSH-соединение выступает лишь в роли средства просмотра. Разорвите соединение, и сервер этого даже не заметит.

sudo apt update && sudo apt install -y tmux
tmux new -s import

Запустите задачу в этом окне, затем нажмите Ctrl-b, а после — d, чтобы отсоединиться. Войдите в систему позже и вернитесь к работе:

tmux ls
tmux attach -t import

Команда tmux ls должна вывести строку, начинающуюся с import: 1 windows. Если выводится no server running on /tmp/tmux-1000/default, значит, сессии для подключения нет: либо она не была создана, либо что-то завершило работу сервера.

screen выполняет ту же задачу с другими сочетаниями клавиш. screen -S import создает сессию, а Ctrl-a, затем d отсоединяют от неё. screen -ls выводит список существующих сессий, а screen -r import позволяет вернуться в одну из них. Оба инструмента подходят для этой цели. Клавиша отсоединения — это то, что пользователи часто забывают.

Мультиплексор также является подходящим инструментом для интерактивной работы, которая должна пережить разрыв соединения. Именно поэтому запуск Claude Code на VPS внутри tmux является стандартной настройкой, и именно это делает управление серверной сессией с телефона удобным в мобильных сетях, где соединение может прерываться каждые несколько минут.

systemd-run: передача задачи PID 1

Для задачи, которая не должна зависеть от вас, передайте её системе инициализации.

sudo systemd-run --unit=bigsync --collect /usr/bin/rsync -aH --stats /srv/data/ /mnt/backup/

Это создаст временный юнит службы с именем bigsync.service. Он получит собственную cgroup, у него не будет управляющего терминала и связи с вашим сеансом входа. Команда завершится немедленно и выведет Running as unit: bigsync.service. Отслеживайте её с помощью одной из следующих команд:

systemctl status bigsync
journalctl -u bigsync -f

Флаг --collect указывает systemd удалить юнит после завершения, даже в случае ошибки. Без него упавший временный юнит останется загруженным, а его имя будет занято, поэтому следующий запуск завершится ошибкой о том, что юнит уже существует. Вывод направляется в журнал с метками времени для каждой строки. Записи в журнале сохраняются после перезагрузки только при наличии /var/log/journal, поэтому выполните sudo mkdir -p /var/log/journal и перезапустите systemd-journald, если вам это нужно.

При вызове systemd-run от обычного пользователя без sudo система запросит авторизацию через polkit и выведет ==== AUTHENTICATING FOR org.freedesktop.systemd1.manage-units ===. Используйте sudo для системных юнитов.

Вы также можете запустить задачу под управлением вашего пользовательского менеджера:

systemd-run --user --unit=bigsync --collect /usr/bin/rsync -aH /srv/data/ /mnt/backup/

Здесь есть нюанс. Ваш пользовательский менеджер user@1000.service обычно останавливается при завершении последнего сеанса, и он завершает все пользовательские юниты вместе с собой. Включите режим ожидания (lingering) один раз:

loginctl enable-linger "$USER"
loginctl show-user "$USER" --property=Linger

Вторая команда должна вывести Linger=yes. При включенном режиме ожидания ваш пользовательский менеджер запускается при загрузке и продолжает работать независимо от того, вошли ли вы в систему. Без этого systemd-run --user не дает преимуществ перед nohup.

systemd-run --scope — это другое. Она запускает команду на переднем плане, привязывая её к вашему терминалу, поэтому сама по себе она здесь не поможет.

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

Постоянный юнит для задачи, которую вы будете запускать снова

User=deploy ниже — это пользователь, от имени которого выполняется задача. Укажите там свое имя пользователя или создайте системного пользователя для этой задачи:

sudo useradd --system --shell /usr/sbin/nologin deploy
[Unit]
Description=Nightly data sync
Wants=network-online.target
After=network-online.target

[Service]
Type=oneshot
User=deploy
WorkingDirectory=/srv/data
ExecStart=/usr/local/bin/nightly-sync.sh

Сохраните это как /etc/systemd/system/nightly-sync.service, выполните sudo systemctl daemon-reload, затем запустите службу с помощью sudo systemctl start nightly-sync и проверьте её состояние через journalctl -u nightly-sync. Добавьте соответствующий файл .timer, если задача должна выполняться по расписанию, а не по требованию.

Написание systemd service unit и таймера подробно описывает формат файла и синтаксис расписания.

Куда направляется вывод и почему он пропадает

Порядок перенаправления имеет значение. > file 2>&1 направляет стандартный вывод в файл, а затем направляет стандартный поток ошибок в то же место. 2>&1 > file делает это в обратном порядке: стандартный поток ошибок продолжает идти в терминал, а терминал — это то, что вот-вот исчезнет. Bash также поддерживает &> file для обоих потоков одновременно.

Второй сюрприз — буферизация. Когда стандартный вывод направлен в терминал, библиотека C выполняет сброс буфера на каждой строке. Когда стандартный вывод направлен в файл, он переключается на блочный буфер размером в несколько килобайт, поэтому tail -f ~/import.log ничего не показывает в течение нескольких минут, и задача выглядит зависшей. Принудительно включите построчную буферизацию с помощью stdbuf -oL ./import.sh > ~/import.log 2>&1. Это работает для программ, которые пишут через стандартные потоки библиотеки C и не меняют собственную буферизацию, но не работает для таких программ, как dd или tee. В противном случае используйте собственный флаг программы, например python3 -u или grep --line-buffered.

Избегайте следующего шаблона:

nohup ./import.sh 2>&1 | tee ~/import.log &

nohup защищает только import.sh и ничего больше. tee — это отдельный процесс в том же конвейере, и он по-прежнему завершается при разрыве соединения. import.sh в этот момент пишет в канал без читателя, поэтому он получает SIGPIPE и останавливается. Поместите весь конвейер внутрь setsid bash -c '...' или пишите напрямую в файл и запускайте tail -f для него после повторного подключения.

Еще одна деталь, касающаяся именно rsync. --info=progress2 записывает поток символов возврата каретки, который корректно отображается в терминале, но превращается в одну огромную строку в лог-файле. Журнал разделяет записи только по символам новой строки, поэтому тот же вывод попадает туда как последовательность фрагментов по 48K (значение по умолчанию LineMax=). Для фонового выполнения откажитесь от этого и используйте --stats.

Почему задача, работающая в вашей оболочке, завершается ошибкой в systemd или cron

Ваша оболочка входа SSH считывает /etc/profile, а затем первый из файлов ~/.bash_profile, ~/.bash_login и ~/.profile, который удастся найти. Интерактивная оболочка без входа считывает ~/.bashrc. В результате ваша оболочка имеет доступ к PATH, прослойкам (shims) менеджера версий и экспортированным переменным. Юнит systemd не считывает ничего из этого. Cron также не считывает эти файлы: в Debian и Ubuntu cron выполняет задачи с SHELL=/bin/sh и PATH=/usr/bin:/bin.

Симптомом в systemd является сообщение systemctl status об ошибке (code=exited, status=203/EXEC). Это означает, что systemd вообще не смог выполнить файл, так как путь был указан неверно или у файла нет прав на выполнение. В cron это обычно приводит к command not found, которое доставляется локальной почтой или не доставляется вовсе, если почтовая система не установлена.

Прежде чем тратить час на догадки, проверьте текущее окружение:

sudo systemd-run --collect --wait --unit=envtest /usr/bin/env
journalctl -u envtest --no-pager

Эта команда выведет точное окружение, в котором будет выполняться ваша задача. Затем устраните разрыв. Используйте абсолютные пути для всех своих файлов, так как systemd ищет обычную команду rsync в фиксированном системном списке путей, а не в PATH вашей оболочки. Передавайте необходимые переменные с помощью -p Environment="KEY=value" в командной строке или через EnvironmentFile=/etc/default/myjob в файле юнита. Если задаче действительно требуется ваше окружение входа, запускайте её как /bin/bash -lc 'my-command' и учитывайте, что теперь задача зависит от ваших конфигурационных файлов (dotfiles).

Что еще может завершить фоновый процесс

  • Перезагрузка. Ничто в tmux не сохраняется после перезагрузки, так как сервер является обычным процессом, а сессии хранятся в оперативной памяти. Обновления ядра требуют перезагрузки, поэтому задачу, которую нельзя легко перезапустить, следует оформить в виде юнита systemctl enable.
  • OOM killer (убийца процессов при нехватке памяти). dmesg -T | grep -i 'killed process' показывает его действия, включая имя выбранного процесса. Тяжелый импорт данных на небольшом VPS часто становится целью.
  • Очистка через logind. Если в /etc/systemd/logind.conf установлено KillUserProcesses=yes, процессы, оставшиеся в области видимости сессии входа, завершаются при выходе из системы, включая сервер tmux, запущенный из этой сессии. Проверьте текущую настройку с помощью loginctl show-session --property=KillUserProcesses. Одной лишь настройки lingering недостаточно. Запускайте tmux вне области видимости сессии с помощью systemd-run --scope --user tmux new -s import и включите lingering через loginctl enable-linger "$USER", либо попросите администратора добавить вашего пользователя в KillExcludeUsers=.
  • Переполнение диска. Задача останавливается, потому что лог, в который вы перенаправляли вывод, заполнил файловую систему, а не из-за вашего выхода из системы. Выполните df -h, прежде чем винить сигналы завершения.

Запуск задачи по SSH без поддержания соединения

ssh vps 'sudo systemd-run --unit=import --collect /usr/local/bin/import.sh'

systemd-run завершается сразу после запуска юнита, поэтому команда ssh также возвращает управление, а задача теряет связь с сессией, из которой она была запущена. Это корректный способ.

Вариант с nohup требует больше внимания:

ssh vps 'nohup ./import.sh > ~/import.log 2>&1 < /dev/null &'

Без перенаправления потоков выполнение команды кажется зависшим. sshd удерживает канал открытым, пока любой процесс использует стандартный вывод или стандартный поток ошибок удаленной команды, а фоновая задача наследует оба этих потока. Один лишь nohup не решает проблему, так как nohup перенаправляет вывод только в том случае, если он направлен в терминал, а в данном случае это канал (pipe), ведущий обратно к вашему клиенту. Добавление < /dev/null также закрывает входной поток. ssh -n выполняет ту же задачу со стороны клиента.

FAQ

Почему моя команда завершается при разрыве SSH-соединения?

Псевдотерминал (pty), который использовала ваша сессия, уничтожается, и ядро отправляет SIGHUP группе процессов переднего плана в этом терминале. Стандартное действие для SIGHUP — завершение процесса. Фоновые задачи также завершаются, так как bash перед выходом отправляет SIGHUP всем задачам из своей таблицы. Команда, которая игнорирует SIGHUP, например запущенная через nohup, или команда, которая изначально не была связана с вашей сессией (например, systemd unit), продолжит работу.

Что лучше для шестичасового rsync: tmux или systemd-run?

systemd-run. Сессия tmux зависит от серверного процесса, который вы запустили, поэтому она завершается при перезагрузке и невидима для тех, кто не знает о команде tmux ls. Использование sudo systemd-run --unit=bigsync --collect /usr/bin/rsync -aH --stats /srv/data/ /mnt/backup/ предоставляет systemctl status bigsync для отслеживания состояния и journalctl -u bigsync для вывода, которые следующий администратор обнаружит без дополнительных указаний. Используйте tmux для работы, где необходимо наблюдать за экраном и вводить данные.

Как увидеть вывод задачи, если я забыл перенаправить его в файл?

Обычно это невозможно, так как вывод был направлен в терминал, который больше не существует. Пока процесс работает, можно изучить его открытые файлы с помощью sudo ls -l /proc/<pid>/fd или отследить системные вызовы через sudo strace -p <pid>, но уже записанный текст будет потерян. reptyr <pid> позволяет перенести процесс в новый терминал, однако в Ubuntu kernel.yama.ptrace_scope = 1 требует sudo для процессов, не являющихся вашими дочерними. Чтобы избежать подобных ситуаций, возьмите за правило перенаправлять вывод в файл при запуске и использовать tail -f для чтения этого файла.

Сохраняется ли отсоединенная сессия tmux после перезагрузки?

Нет. Сервер tmux — это обычный процесс, а сессии хранятся в его оперативной памяти, поэтому перезагрузка завершает их работу. Он также завершается, когда /etc/systemd/logind.conf устанавливает KillUserProcesses=yes, и вы выходите из сессии, в которой он был запущен. Одной настройки lingering недостаточно: запускайте tmux вне области действия сессии с помощью systemd-run --scope --user tmux new -s import при включенном lingering или добавьте пользователя в KillExcludeUsers=. Для задач, которые должны автоматически возобновляться после перезагрузки, создайте systemd unit и выполните systemctl enable.

Почему мой скрипт работает в оболочке, но не запускается как systemd unit?

Unit не считывает /etc/profile или ~/.bashrc, поэтому у него нет ни ваших дополнений в PATH, ни экспортированных переменных. Ошибка systemctl status с кодом (code=exited, status=203/EXEC) означает, что systemd не смог выполнить файл; используйте абсолютные пути и проверьте наличие прав на исполнение. Запустите sudo systemd-run --collect --wait --unit=envtest /usr/bin/env, прочитайте вывод через journalctl -u envtest, и вы увидите точное окружение, в котором работает ваша задача. Добавьте недостающие параметры с помощью Environment= или EnvironmentFile=.

Была ли эта статья полезной?

#ssh#tmux#nohup#systemd#long-running-jobs