Technical Solutions for Keeping Python Scripts Running After SSH Session Termination

SSH Session and Process Management Fundamentals

In Linux systems, SSH (Secure Shell) session termination typically sends SIGHUP (hang up) signals to all child processes, causing them to terminate. This mechanism presents significant challenges for web service components requiring long-term execution. Understanding signal handling mechanisms is crucial for addressing this issue.

Core Principles of nohup Command

The nohup (no hang up) command is specifically designed to ignore SIGHUP signals. When executing commands with nohup, the system detaches the process from the current shell's job control and redirects standard output and standard error to the nohup.out file.

Basic syntax:

nohup command [arguments] &

Specific application for Python scripts:

nohup python bgservice.py &

The execution process of this command involves several key steps: first, nohup sets up signal handlers to ignore SIGHUP signals; then, it places the process in background execution; finally, it redirects output streams to ensure log integrity.

Output Redirection and Log Management

By default, nohup redirects standard output and standard error to the nohup.out file in the current directory. For production environments, more refined output control is recommended:

nohup python bgservice.py > service.log 2>&1 &

This command redirects standard output to service.log file while also redirecting standard error to the same file. Regular log rotation prevents disk space from being consumed by indefinitely growing log files.

Process Monitoring and Automatic Restart

While nohup can maintain process execution, it cannot automatically restart processes upon unexpected termination. Process monitoring tools like supervise can be considered, as they monitor specified process status and automatically restart upon process exit.

Basic usage pattern of supervise:

supervise /path/to/service/directory

Create run script in service directory:

#!/bin/sh
exec python /path/to/bgservice.py

Alternative Solutions with Terminal Multiplexers

Terminal multiplexing tools like tmux and screen provide another method for maintaining process execution. These tools create independent session environments where processes continue running even after SSH connection disconnection.

Basic tmux usage workflow:

# Start new session
tmux new-session -s webservice

# Run script within tmux session
python bgservice.py

# Detach session (Ctrl+b, d)
# Reattach session
tmux attach-session -t webservice

Background Processing for Already Running Processes

For processes already running, use Ctrl+Z to suspend the process, then use bg command to place it in background, finally use disown command to detach it from current shell control:

# Suspend current process (Ctrl+Z)
# Place in background execution
bg

# Detach from shell control
disown -h

The -h parameter of disown command is particularly important, ensuring that even if the shell receives SIGHUP signal, it won't pass this signal to disowned processes.

Production Environment Best Practices

In real web service deployment scenarios, a layered strategy is recommended: for simple scripts, nohup provides a quick and effective solution; for production services requiring high reliability, systemd services or professional process monitoring tools should be considered.

Systemd service configuration example:

[Unit]
Description=Python Web Service
After=network.target

[Service]
Type=simple
User=www-data
ExecStart=/usr/bin/python /path/to/bgservice.py
Restart=always

[Install]
WantedBy=multi-user.target

Performance Monitoring and Troubleshooting

Maintaining long-term process execution requires comprehensive monitoring mechanisms. Tools like ps and top can monitor process status, while log analysis helps identify potential issues. For memory leaks or performance degradation, appropriate monitoring alerts should be established.

Process status checking commands:

ps aux | grep bgservice.py
pgrep -f bgservice.py

Security Considerations

When configuring long-running services, security best practices must be considered: run services with non-privileged users, restrict filesystem access permissions, regularly update dependency libraries to fix security vulnerabilities. Additionally, ensure log files don't contain sensitive information.

By comprehensively applying these technologies, reliable and secure web service background processes can be constructed, ensuring continuous service availability.