systemd服务管理架构实战：systemctl服务控制、开机启动与企业级服务编排

一、systemd概述

1.1 systemd简介

systemd是现代化的系统和服务管理器，已成为主流Linux发行版的标准。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
systemd核心优势:
  统一管理:
    - 系统服务
    - 用户服务
    - 定时器任务
  
  并行启动:
    - 依赖图优化
    - 并行执行
    - 快速启动
  
  功能强大:
    - 依赖管理
    - 资源控制
    - 日志集成
  
  服务监控:
    - 健康检查
    - 自动重启
    - 状态监控

1.2 systemctl基础命令

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
# 查看服务状态
systemctl status service_name

# 启动服务
systemctl start service_name

# 停止服务
systemctl stop service_name

# 重启服务
systemctl restart service_name

# 重新加载配置
systemctl reload service_name

# 启用开机启动
systemctl enable service_name

# 禁用开机启动
systemctl disable service_name

# 查看服务是否启用
systemctl is-enabled service_name

# 查看服务是否运行
systemctl is-active service_name

# 查看所有服务
systemctl list-units --type=service

# 查看所有启用的服务
systemctl list-unit-files --state=enabled

二、服务文件配置

2.1 服务文件结构

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
# /etc/systemd/system/myapp.service
[Unit]
Description=MyApp Service
Documentation=https://example.com
After=network.target mysql.service
Requires=mysql.service

[Service]
Type=simple
User=appuser
Group=appuser
WorkingDirectory=/opt/myapp
ExecStart=/opt/myapp/bin/myapp start
ExecStop=/opt/myapp/bin/myapp stop
ExecReload=/bin/kill -HUP $MAINPID
Restart=always
RestartSec=10s
StandardOutput=journal
StandardError=journal
SyslogIdentifier=myapp

[Install]
WantedBy=multi-user.target

2.2 常见服务类型

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
# Type=simple (默认)
[Service]
Type=simple
ExecStart=/usr/bin/myapp

# Type=forking
[Service]
Type=forking
PIDFile=/var/run/myapp.pid
ExecStart=/usr/bin/myapp daemon

# Type=oneshot
[Service]
Type=oneshot
ExecStart=/usr/bin/setup-script.sh
RemainAfterExit=yes

# Type=notify
[Service]
Type=notify
ExecStart=/usr/bin/myapp
NotifyAccess=all

# Type=idle
[Service]
Type=idle
ExecStart=/usr/bin/batch-job

三、开机启动配置

3.1 配置开机启动

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
# 方式1: 使用enable命令
systemctl enable myapp.service

# 方式2: 创建链接
ln -s /etc/systemd/system/myapp.service \
    /etc/systemd/system/multi-user.target.wants/

# 查看开机启动的服务
systemctl list-unit-files --type=service --state=enabled

# 禁用开机启动
systemctl disable myapp.service

# 查看服务依赖关系
systemctl list-dependencies myapp.service

# 查看反向依赖
systemctl list-dependencies --reverse myapp.service

3.2 系统启动级别

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
systemd目标:
  multi-user.target:
    - 多用户命令行模式
    - 系统默认目标
    - 适合服务器
  
  graphical.target:
    - 图形界面模式
    - 桌面系统
  
  rescue.target:
    - 救援模式
    - 单用户维护
  
  管理命令:
    - systemctl get-default  # 查看当前目标
    - systemctl set-default multi-user.target  # 设置默认目标
    - systemctl isolate graphical.target  # 切换到图形界面

四、高级服务配置

4.1 环境变量配置

1
2
3
4
5
6
7
8
9
10
11
12
13
14
[Service]
# 环境变量
Environment=PORT=8080
Environment=HOST=0.0.0.0
EnvironmentFile=/etc/myapp/conf.env

# 使用环境文件
EnvironmentFile=-/etc/myapp/conf.env  # 文件不存在也不报错

# 清除环境
ClearEnvironment=yes

# 内嵌环境变量
Environment="VAR1=value1" "VAR2=value2"

4.2 资源限制

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
[Service]
# CPU限制
CPUQuota=50%
CPUWeight=100

# 内存限制
MemoryLimit=512M
MemoryHigh=256M

# I/O限制
IOWeight=100
IODeviceWeight=/dev/sda1=200

# 任务数限制
TasksMax=1000

# 安全配置
User=appuser
Group=appuser
NoNewPrivileges=true
PrivateTmp=yes
ProtectSystem=strict
ProtectHome=yes

4.3 重启策略

1
2
3
4
5
6
7
8
9
10
11
12
13
14
[Service]
# 重启条件
Restart=always              # 总是重启
# Restart=on-failure       # 失败时重启
# Restart=on-abnormal       # 异常时重启
# Restart=on-watchdog       # watchdog触发重启
# Restart=on-success        # 成功退出时重启

# 重启延迟
RestartSec=10s             # 重启前等待时间

# 重启次数限制
StartLimitIntervalSec=60s
StartLimitBurst=5          # 60秒内最多5次重启

4.4 健康检查

1
2
3
4
5
6
7
8
9
10
11
12
13
[Service]
# 定期执行健康检查
ExecStart=/usr/bin/myapp

# 健康检查命令
ExecStartPost=/usr/local/bin/health-check.sh

# Type=notify 服务发送sd_notify
Type=notify
NotifyAccess=all

# Watchdog
WatchdogSec=30

五、依赖管理

5.1 服务依赖

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
[Unit]
# 硬依赖 - 一起启动
Requires=mysql.service redis.service

# 弱依赖 - 如果存在则依赖
Wants=network-online.target

# 启动顺序
After=network.target mysql.service
Before=webapp.service

# 冲突服务
Conflicts=old-app.service

# 启动前置条件
Requisite=mysql.service

5.2 依赖示例

1
2
3
4
5
6
7
8
9
10
11
12
# Web应用依赖数据库
[Unit]
Description=Web Application
After=mysql.service redis.service
Requires=mysql.service redis.service

[Service]
Type=notify
ExecStart=/usr/bin/webapp

[Install]
WantedBy=multi-user.target

六、实战案例

6.1 自定义应用服务

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
# /etc/systemd/system/myapp.service
[Unit]
Description=MyApp Application Service
Documentation=https://github.com/myorg/myapp
After=network.target mysql.service

[Service]
Type=simple
User=myapp
Group=myapp

# 工作目录
WorkingDirectory=/opt/myapp

# 启动命令
ExecStart=/opt/myapp/bin/myapp \
    --config /etc/myapp/config.yml \
    --log-level info

# 停止命令
ExecStop=/bin/kill -SIGTERM $MAINPID

# 重载命令
ExecReload=/bin/kill -HUP $MAINPID

# 环境变量
Environment=NODE_ENV=production
EnvironmentFile=/etc/myapp/env

# 资源限制
MemoryLimit=1G
CPUQuota=100%

# 重启策略
Restart=on-failure
RestartSec=10s

# 日志
StandardOutput=journal
StandardError=journal
SyslogIdentifier=myapp

# 安全
NoNewPrivileges=true
PrivateTmp=true

[Install]
WantedBy=multi-user.target

6.2 Python应用服务

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
# /etc/systemd/system/pyapp.service
[Unit]
Description=Python Web Application
After=network.target

[Service]
Type=simple
User=pyapp
Group=pyapp
WorkingDirectory=/opt/pyapp

# 使用虚拟环境
ExecStart=/opt/pyapp/venv/bin/python /opt/pyapp/app.py

# 环境变量
Environment="PATH=/opt/pyapp/venv/bin"
Environment="FLASK_ENV=production"

# 重启策略
Restart=always
RestartSec=10s

# 日志
StandardOutput=append:/var/log/pyapp/stdout.log
StandardError=append:/var/log/pyapp/stderr.log

[Install]
WantedBy=multi-user.target

6.3 Docker容器服务

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
# /etc/systemd/system/dockerapp.service
[Unit]
Description=MyApp Docker Container
After=docker.service
Requires=docker.service

[Service]
Type=simple
ExecStart=/usr/bin/docker run \
    --name myapp \
    --rm \
    -p 8080:8080 \
    -v /opt/data:/data \
    myapp:latest

ExecStop=/usr/bin/docker stop myapp

# 清理
ExecStopPost=/usr/bin/docker rm -f myapp

# 重启策略
Restart=always
RestartSec=10s

[Install]
WantedBy=multi-user.target

七、服务管理脚本

7.1 批量服务管理

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
#!/bin/bash
# service_manager.sh - 服务批量管理

check_services() {
    local services=(
        nginx
        mysql
        redis
        myapp
    )
    
    echo "=== 服务状态检查 ==="
    
    for service in "${services[@]}"; do
        if systemctl is-active --quiet "$service"; then
            echo "✓ $service: 运行中"
        else
            echo "✗ $service: 未运行"
        fi
    done
}

start_services() {
    local services=("$@")
    
    for service in "${services[@]}"; do
        if ! systemctl is-active --quiet "$service"; then
            echo "启动 $service..."
            systemctl start "$service"
        fi
    done
}

stop_services() {
    local services=("$@")
    
    for service in "${services[@]}"; do
        if systemctl is-active --quiet "$service"; then
            echo "停止 $service..."
            systemctl stop "$service"
        fi
    done
}

main() {
    case "$1" in
        check)
            check_services
            ;;
        start)
            shift
            start_services "$@"
            ;;
        stop)
            shift
            stop_services "$@"
            ;;
        *)
            echo "用法: $0 {check|start|stop} [services...]"
            ;;
    esac
}

main "$@"

7.2 服务监控脚本

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
#!/bin/bash
# service_monitor.sh - 服务监控

CRITICAL_SERVICES=(
    "nginx"
    "mysql"
    "redis"
)

monitor_services() {
    local failed_services=()
    
    for service in "${CRITICAL_SERVICES[@]}"; do
        if ! systemctl is-active --quiet "$service"; then
            failed_services+=("$service")
        fi
    done
    
    if [ ${#failed_services[@]} -gt 0 ]; then
        echo "❌ 以下服务未运行: ${failed_services[*]}"
        send_alert "服务故障" "服务: ${failed_services[*]}"
        
        # 尝试自动重启
        for service in "${failed_services[@]}"; do
            echo "尝试重启 $service..."
            systemctl restart "$service"
        done
    else
        echo "✓ 所有关键服务运行正常"
    fi
}

send_alert() {
    local subject=$1
    local message=$2
    
    # 发送邮件
    echo "$message" | mail -s "$subject" admin@example.com
    
    # 发送钉钉
    curl -X POST "$WEBHOOK_URL" \
        -H 'Content-Type: application/json' \
        -d "{\"msgtype\":\"text\",\"text\":{\"content\":\"$subject: $message\"}}"
}

# 定时监控
while true; do
    monitor_services
    sleep 60
done

八、服务编排

8.1 服务依赖链

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
# 示例：应用启动顺序
# 1. 网络 -> 2. 数据库 -> 3. Redis -> 4. 应用

# network.service
[Unit]
Description=Network Configuration

[Service]
Type=oneshot
ExecStart=/usr/bin/network-setup.sh
RemainAfterExit=yes

# mysql.service
[Unit]
Description=MySQL Database
After=network.service
Requires=network.service

[Service]
Type=notify
ExecStart=/usr/bin/mysqld

# redis.service
[Unit]
Description=Redis Cache
After=mysql.service
Wants=mysql.service

[Service]
Type=simple
ExecStart=/usr/bin/redis-server

# myapp.service
[Unit]
Description=Web Application
After=redis.service mysql.service
Requires=redis.service mysql.service

[Service]
Type=notify
ExecStart=/usr/bin/myapp

8.2 并行启动优化

1
2
3
4
5
6
7
8
9
10
11
12
13
14
# 使用target组织服务
# /etc/systemd/system/app.target
[Unit]
Description=Application Services
Requires=mysql.service redis.service
After=mysql.service redis.service

[Install]
WantedBy=multi-user.target

# 服务配置中
[Unit]
Wants=app.target
After=app.target

九、开机启动优化

9.1 分析启动时间

1
2
3
4
5
6
7
8
9
10
11
12
13
14
# 查看启动时间
systemd-analyze

# 查看各服务启动时间
systemd-analyze blame

# 查看关键路径
systemd-analyze critical-chain

# 生成启动图表
systemd-analyze plot > startup.svg

# 测试关闭服务的影响
systemd-analyze security service_name.service

9.2 优化启动速度

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
启动优化策略:
  1. 禁用不必要服务:
    - 使用systemctl disable
    - 使用mask完全禁用
  
  2. 服务延迟启动:
    - Type=idle
    - 等待系统空闲后启动
  
  3. 并行启动:
    - 优化依赖关系
    - 减少阻塞启动
  
  4. 使用oneshot:
    - 一次性任务
    - RemainAfterExit=yes

9.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
#!/bin/bash
# optimize_boot.sh - 启动优化脚本

echo "=== systemd启动优化 ==="

# 1. 分析启动时间
echo "1. 分析启动时间..."
systemd-analyze
echo ""

# 2. 查看最慢的服务
echo "2. 最慢的10个服务:"
systemd-analyze blame | head -10
echo ""

# 3. 建议禁用的服务
echo "3. 建议禁用的服务:"
systemctl list-unit-files --type=service --state=enabled | \
    grep -E "bluetooth|cups|avahi" | \
    while read service; do
        echo "  $service"
    done
echo ""

# 4. 启动优化建议
echo "4. 优化建议:"
echo "  运行: systemctl disable <service_name>"
echo "  禁用: systemctl mask <service_name>"

十、服务日志管理

10.1 查看服务日志

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
# 查看服务日志
journalctl -u service_name

# 实时查看
journalctl -u service_name -f

# 查看最近日志
journalctl -u service_name -n 100

# 按时间过滤
journalctl -u service_name --since "1 hour ago"
journalctl -u service_name --since "2024-01-01" --until "2024-01-02"

# 查看错误日志
journalctl -u service_name -p err

# 导出日志
journalctl -u service_name > service.log

10.2 日志轮转

1
2
3
4
5
6
7
8
9
10
11
12
13
# 配置日志轮转
# /etc/systemd/journald.conf
[Journal]
SystemMaxUse=500M
SystemKeepFree=1G
SystemMaxFileSize=100M
MaxRetentionSec=30day

# 限制日志大小
journalctl --vacuum-size=200M

# 限制日志保留天数
journalctl --vacuum-time=7d

十一、最佳实践

11.1 服务配置最佳实践

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
systemd最佳实践:
  1. 服务文件编写:
    - 明确描述和依赖
    - 设置合适的用户和组
    - 配置资源限制
  
  2. 安全配置:
    - 使用非特权用户
    - 启用NoNewPrivileges
    - 限制文件系统访问
  
  3. 重启策略:
    - 根据服务特性设置
    - 设置重启延迟
    - 限制重启次数
  
  4. 日志管理:
    - 使用journald
    - 配置日志轮转
    - 定期清理日志
  
  5. 监控告警:
    - 监控服务状态
    - 配置告警通知
    - 自动化故障处理

11.2 常用命令速查

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
# 服务管理
systemctl start|stop|restart|reload service
systemctl enable|disable service
systemctl status service

# 系统信息
systemctl list-units --all --type=service
systemctl list-unit-files --state=enabled
systemctl list-dependencies service

# 性能分析
systemd-analyze
systemd-analyze blame
systemd-analyze critical-chain

# 日志查看
journalctl -u service
journalctl -xe
journalctl --since today

# 调试
systemctl daemon-reload
systemctl reset-failed
systemctl edit service

十二、总结

systemd服务管理是现代化Linux系统的基础。本文涵盖：

核心要点

  1. systemctl命令：服务控制与状态查询
  2. 服务文件配置：单元文件、依赖、资源限制
  3. 开机启动：enable/disable、系统目标
  4. 服务编排：依赖管理、并行启动

技术要点

  • 服务配置：多种Type、环境变量、资源限制
  • 依赖管理：Requires、Wants、After、Before
  • 重启策略：多种Restart条件、延迟配置
  • 日志管理：journalctl、日志轮转

实践建议

  1. 使用结构化服务文件
  2. 合理设置依赖关系
  3. 配置资源与安全
  4. 监控服务状态
  5. 优化启动速度

通过systemd服务管理，可提升系统的可靠性与可维护性。