systemctl list-units                        # 当前【已加载】的 unit
systemctl list-units --type=service         # 只看服务
systemctl list-units --state=failed         # ✅ 失败的（排查第一步）
systemctl list-unit-files                   # 所有【已安装】的 unit 文件及其启用状态
systemctl list-unit-files --type=timer      # 所有定时器
systemctl --failed                          # 等价 --state=failed

systemctl cat nginx                         # ✅ 看实际生效的完整配置（含所有 drop-in）
systemctl show nginx                        # 看所有属性的最终值（很长）
systemctl show nginx -p ExecStart -p Type -p Restart   # 只看关心的
systemctl status nginx                      # 运行状态 + 最近日志

# ❌ 只写 Requires 不写 After：两者会【同时】启动，可能数据库还没就绪
[Unit]
Requires=postgresql.service

# ✅ 依赖 + 顺序都要写
[Unit]
Requires=postgresql.service
After=postgresql.service

# ✅ 更常见的生产写法：用 Wants（数据库暂时不可用时服务仍启动，靠应用自己重试）
[Unit]
Wants=postgresql.service
After=postgresql.service network-online.target

systemctl list-dependencies nginx           # 看它依赖谁（树形）
systemctl list-dependencies --reverse nginx # ✅ 看谁依赖它（改动前必查）
systemctl list-dependencies --all nginx
systemctl list-dependencies multi-user.target   # 看这个 target 拉起哪些服务

systemctl get-default                       # multi-user.target（服务器默认）
systemctl set-default multi-user.target     # 设置默认启动目标
systemctl list-units --type=target          # 当前激活的 target

# ⚠️ network.target 与 network-online.target 的区别（常见错误来源）
# network.target        = 网络【栈】已初始化（不保证有 IP、不保证能连外网）
# network-online.target = 网络【真正可用】（有 IP、路由就绪）

# 需要联网的服务必须用后者，且要启用对应的等待服务
[Unit]
Wants=network-online.target
After=network-online.target
# 并确保 systemd-networkd-wait-online 或 NetworkManager-wait-online 已启用
systemctl is-enabled systemd-networkd-wait-online.service

sudo systemctl start nginx          # 【立即】启动（重启后不会自动启动）
sudo systemctl enable nginx         # 设置【开机自启】（现在不启动）
sudo systemctl enable --now nginx   # ✅ 两件事一起做（最常用）

sudo systemctl enable nginx
# Created symlink /etc/systemd/system/multi-user.target.wants/nginx.service
#              → /usr/lib/systemd/system/nginx.service
#                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ 就是往 target 的 .wants 目录里放个链接

ls -l /etc/systemd/system/multi-user.target.wants/
# 这个链接放在哪个 target 的 .wants 里，由 unit 的 [Install] 段决定：
# [Install]
# WantedBy=multi-user.target

sudo systemctl start myapp
sudo systemctl stop myapp
sudo systemctl restart myapp                # 停止再启动（有服务中断）
sudo systemctl reload myapp                 # 重载配置（需 unit 定义了 ExecReload）
sudo systemctl reload-or-restart myapp      # ✅ 能 reload 就 reload，否则 restart
sudo systemctl try-restart myapp            # 只在【正在运行】时才重启
sudo systemctl kill myapp                   # 发信号（默认 SIGTERM）
sudo systemctl kill -s SIGQUIT myapp        # 指定信号（Go 服务打 goroutine 栈）
sudo systemctl kill --kill-whom=main -s HUP myapp   # 只发给主进程

# reload vs restart 的区别（生产上很重要）
# reload  = 不中断服务，通常是给进程发 SIGHUP 让它重读配置
# restart = 进程真的退出再启动，会有中断窗口
systemctl show nginx -p ExecReload           # 看它支持什么 reload 方式

sudo systemctl enable myapp
sudo systemctl disable myapp
sudo systemctl disable --now myapp          # 禁用并立即停止
sudo systemctl is-enabled myapp             # 查询（脚本用，看退出码）
sudo systemctl reenable myapp               # 先 disable 再 enable（修复错乱的链接）

# mask：比 disable 更彻底
sudo systemctl mask myapp                   # 软链接到 /dev/null，【任何方式都无法启动】
sudo systemctl unmask myapp
# 用途：彻底禁止某个服务（如禁掉发行版自带的 apache 防止它抢 80 端口）
#      disable 只是不自动启动，但依赖它的服务仍可能拉起它；mask 能彻底阻止

systemctl status myapp                      # ✅ 状态 + 最近 10 行日志
systemctl status myapp -l --no-pager        # 不截断、不分页
systemctl status myapp -n 50                # 显示 50 行日志
systemctl is-active myapp                   # active / inactive / failed（脚本用）
systemctl is-failed myapp
systemctl cat myapp                         # ✅ 看完整配置（含 drop-in，标注来源文件）
systemctl show myapp                        # 所有属性的最终值
systemctl show myapp -p MainPID -p Type -p Restart -p LimitNOFILE
systemctl help myapp                        # 打开该服务的 man 页

# 找出所有失败的服务（登录机器后的例行检查）
systemctl --failed
systemctl list-units --state=failed
sudo systemctl reset-failed                 # 清除失败计数（被 StartLimit 挡住时需要）
sudo systemctl reset-failed myapp

systemd-analyze                             # 总启动时间
# Startup finished in 3.２s (kernel) + 8.5s (userspace) = 11.7s

systemd-analyze blame                       # ✅ 按耗时排序，找出拖慢启动的服务
# 4.521s NetworkManager-wait-online.service
# 2.103s snapd.service
# 1.234s docker.service

systemd-analyze critical-chain              # 关键路径（真正影响启动时间的链条）
systemd-analyze critical-chain myapp.service
systemd-analyze plot > boot.svg             # 生成可视化时序图
systemd-analyze verify /etc/systemd/system/myapp.service    # ✅ 语法检查
systemd-analyze security myapp.service      # ✅ 安全加固评分（0~10，越低越好）
systemd-analyze calendar 'Mon *-*-* 02:30'  # ✅ 验证 OnCalendar 表达式
systemd-analyze timespan '2h 30min'         # 验证时间跨度表达式

sudo vim /etc/systemd/system/myapp.service
sudo systemctl restart myapp
# Warning: The unit file, source configuration file or drop-ins of myapp.service changed
#          on disk. Run 'systemctl daemon-reload' to reload units.

sudo systemctl daemon-reload                # ✅ 让 systemd 重新读取所有 unit 文件
sudo systemctl restart myapp

# 记忆规则
# 改了 unit 【文件】        -> daemon-reload + restart
# 改了服务自己的【配置文件】 -> 只需 reload（如 nginx.conf → systemctl reload nginx）
# 升级了 systemd 本身       -> daemon-reexec（重新执行 systemd 自己，不重启系统）

sudo systemctl daemon-reload                # 重新加载 unit 定义
sudo systemctl daemon-reexec                # 重新执行 systemd 进程本身

sudo systemctl reboot                       # 重启
sudo systemctl poweroff                     # 关机
sudo systemctl suspend / hibernate          # 挂起/休眠
sudo systemctl rescue                       # 切到救援模式
sudo systemctl isolate multi-user.target    # 切换到指定 target（停掉不属于它的服务）
sudo systemctl list-jobs                    # 正在进行的启动/停止任务（卡住时看它）

[Unit]
Description=My Go API Service              # 一句话描述（systemctl status 会显示）
Documentation=https://wiki.internal/myapp  # 文档链接（systemctl help 会用）
After=network-online.target postgresql.service
Wants=network-online.target
Requires=                                  # 强依赖（慎用）
PartOf=                                    # 被谁的 restart 带动
Conflicts=                                 # 与谁互斥
OnFailure=notify-failure@%n.service        # ✅ 失败时触发告警服务（%n = 本 unit 名）
StartLimitIntervalSec=300                  # 在 300 秒窗口内
StartLimitBurst=5                          # 最多允许启动 5 次（超了就拒绝再启动）
ConditionPathExists=/etc/myapp/config.yaml # 条件：文件不存在则跳过（不算失败）
AssertPathExists=/var/lib/myapp            # 断言：不满足则【失败】

# 服务反复崩溃 -> 达到启动次数限制 -> systemd 拒绝再启动
systemctl status myapp
# Active: failed (Result: start-limit-hit)
#                         ^^^^^^^^^^^^^^^ 撞上了启动频率限制

sudo systemctl reset-failed myapp           # ✅ 清除计数后才能再启动
sudo systemctl start myapp

[Service]
Type=notify                                # 见第 4 章
User=myapp                                 # 以哪个用户运行（10 篇讲的专用账号）
Group=myapp

WorkingDirectory=/var/lib/myapp            # cwd
ExecStartPre=/usr/local/bin/myapp check    # 启动前执行（失败则不启动）
ExecStart=/usr/local/bin/myapp --config /etc/myapp/config.yaml
ExecStartPost=/bin/sleep 1                 # 启动后执行
ExecReload=/bin/kill -HUP $MAINPID         # ✅ 定义 reload 行为
ExecStop=                                  # 自定义停止命令（默认发 SIGTERM）
ExecStopPost=                              # 停止后清理

Restart=on-failure                         # 重启策略，见 3.3
RestartSec=5                               # 重启前等 5 秒
TimeoutStartSec=30                         # 启动超时（Type=notify 时超时算失败）
TimeoutStopSec=30                          # ✅ 停止超时（超了发 SIGKILL）
KillSignal=SIGTERM                         # 停止时先发什么信号
KillMode=mixed                             # 主进程发 TERM，其余发 KILL
SendSIGKILL=yes                            # 超时后是否强杀（默认 yes）

Environment=GOMAXPROCS=4                   # 环境变量
Environment="LOG_LEVEL=info" "TZ=Asia/Shanghai"
EnvironmentFile=-/etc/default/myapp        # 从文件读（- 表示文件不存在也不报错）

StandardOutput=journal                     # stdout 去哪（journal/null/file:/path/append:/path）
StandardError=journal
SyslogIdentifier=myapp                     # 日志里的标识名

# 目录：systemd 自动创建 + 设好属主，停止时按需清理
RuntimeDirectory=myapp                     # /run/myapp（停止时删除）
RuntimeDirectoryMode=0750
StateDirectory=myapp                       # /var/lib/myapp（保留）
CacheDirectory=myapp                       # /var/cache/myapp
LogsDirectory=myapp                        # /var/log/myapp
ConfigurationDirectory=myapp               # /etc/myapp

# 资源限制（底层是 cgroup）
LimitNOFILE=65535                          # ✅ fd 上限（limits.conf 对服务无效！见 13 篇）
LimitNPROC=4096
LimitCORE=infinity
CPUQuota=200%                              # 最多用 2 核
MemoryMax=2G                               # 内存硬限制
MemoryHigh=1.5G                            # 软限制（超了激进回收）
TasksMax=4096
OOMScoreAdjust=-500                        # 降低被 OOM 杀的概率
Nice=0
IOWeight=100

[Install]
WantedBy=multi-user.target                 # enable 时链接到哪个 target

# 长驻服务的典型配置
Restart=always
RestartSec=5
StartLimitIntervalSec=300
StartLimitBurst=5
# 含义：崩了就重启，间隔 5 秒；但 5 分钟内超过 5 次就停止尝试（避免无意义的疯狂重启）

# 一次性任务（数据库迁移、初始化）
Type=oneshot
RemainAfterExit=yes                        # 执行完仍显示 active（表示"已完成"）
Restart=no

# 排除特定退出码不触发重启
RestartPreventExitStatus=42                # 退出码 42 时不重启（应用用它表达"配置错误，别重试"）
SuccessExitStatus=143                      # 把 143（SIGTERM）也视为成功

# /etc/systemd/system/myapp.service
[Unit]
Description=MyApp Go API Service
Documentation=https://wiki.internal/myapp
Wants=network-online.target
After=network-online.target postgresql.service
OnFailure=alert@%n.service
StartLimitIntervalSec=300
StartLimitBurst=5

[Service]
Type=notify                                # 用 sd_notify 精确上报就绪状态（见第 4 章）
NotifyAccess=main
WatchdogSec=30                             # 应用需每 <30s 发一次心跳，否则被判定为卡死并重启

User=myapp
Group=myapp
WorkingDirectory=/var/lib/myapp

ExecStartPre=/usr/local/bin/myapp validate --config /etc/myapp/config.yaml
ExecStart=/usr/local/bin/myapp serve --config /etc/myapp/config.yaml
ExecReload=/bin/kill -HUP $MAINPID

Restart=always
RestartSec=5
TimeoutStopSec=45                          # 要大于代码里 srv.Shutdown 的超时
KillMode=mixed
KillSignal=SIGTERM

EnvironmentFile=-/etc/default/myapp
Environment=GOMAXPROCS=4
Environment=GOMEMLIMIT=1800MiB             # ✅ 略小于 MemoryMax，让 GC 提前工作
Environment=TZ=Asia/Shanghai

StandardOutput=journal
StandardError=journal
SyslogIdentifier=myapp

RuntimeDirectory=myapp
StateDirectory=myapp
LogsDirectory=myapp
ConfigurationDirectory=myapp

LimitNOFILE=65535
MemoryMax=2G
MemoryHigh=1800M
CPUQuota=400%
TasksMax=4096
OOMScoreAdjust=-500

# 安全加固（10 篇 8 章讲过，用 systemd-analyze security 检查评分）
NoNewPrivileges=yes
ProtectSystem=strict
ProtectHome=yes
PrivateTmp=yes
PrivateDevices=yes
ProtectKernelTunables=yes
ProtectKernelModules=yes
ProtectControlGroups=yes
RestrictSUIDSGID=yes
RestrictNamespaces=yes
RestrictRealtime=yes
LockPersonality=yes
MemoryDenyWriteExecute=no                  # ⚠️ Go 不需要 JIT，可以设 yes；但 cgo/某些库会崩
SystemCallFilter=@system-service
SystemCallErrorNumber=EPERM
ReadWritePaths=/var/lib/myapp /var/log/myapp
CapabilityBoundingSet=CAP_NET_BIND_SERVICE # 只保留绑定低端口的能力
AmbientCapabilities=CAP_NET_BIND_SERVICE

[Install]
WantedBy=multi-user.target

# 部署流程
sudo systemd-analyze verify /etc/systemd/system/myapp.service   # ① 语法检查
sudo systemctl daemon-reload                                     # ② 重新加载
sudo systemctl enable --now myapp                                # ③ 启用并启动
systemctl status myapp                                           # ④ 确认
sudo systemd-analyze security myapp                              # ⑤ 看加固评分
journalctl -u myapp -f                                           # ⑥ 跟随日志

# ❌ 错误一：程序自己 fork 到后台，但写了 Type=simple
Type=simple
ExecStart=/usr/sbin/mydaemon         # 这个程序会 fork 然后父进程退出
# 后果：systemd 看到"主进程"退出了，认为服务挂了 -> 立即报 failed 并（按策略）重启
#      形成无限重启循环

# ✅ 修法一：改成 forking
Type=forking
PIDFile=/run/mydaemon.pid            # 告诉 systemd 去哪找真正的主进程 PID

# ✅ 修法二（更好）：让程序【不要 fork】，以前台方式运行
Type=simple
ExecStart=/usr/sbin/mydaemon --foreground
# 现代最佳实践：程序前台运行，进程管理交给 systemd
# nginx: daemon off;    /  php-fpm: --nodaemonize  /  Go 服务天然前台

# ❌ 错误二：服务需要 10 秒才能就绪，但用了 Type=simple
Type=simple
ExecStart=/usr/local/bin/myapp       # 启动后要 10 秒才能接受请求
After=myapp.service                  # 依赖它的服务
# 后果：systemd 一 fork 出进程就认为"启动完成"，
#      依赖它的服务立即启动 -> 连不上 -> 失败

# ✅ 用 Type=notify，让应用自己上报就绪
Type=notify

import "github.com/coreos/go-systemd/v22/daemon"

func main() {
    srv := &http.Server{Addr: ":8080", Handler: router}

    // 先完成所有初始化：连数据库、加载配置、预热缓存
    if err := initEverything(); err != nil {
        log.Fatalf("初始化失败: %v", err)
    }

    ln, err := net.Listen("tcp", ":8080")     // 端口已经在监听
    if err != nil { log.Fatal(err) }

    // ✅ 到这里才算真正就绪，通知 systemd
    if sent, err := daemon.SdNotify(false, daemon.SdNotifyReady); err != nil {
        log.Printf("sd_notify 失败: %v", err)
    } else if sent {
        log.Println("已上报 READY=1")
    }

    // 看门狗心跳（配合 WatchdogSec=30）
    if interval, err := daemon.SdWatchdogEnabled(false); err == nil && interval > 0 {
        go func() {
            tick := time.NewTicker(interval / 2)    // 按间隔的一半发送
            defer tick.Stop()
            for range tick.C {
                // ✅ 这里应该做真实的健康检查，而不是无脑发心跳
                if healthy() {
                    daemon.SdNotify(false, daemon.SdNotifyWatchdog)
                }
            }
        }()
    }

    go srv.Serve(ln)

    // 优雅退出（13 篇 5.3）
    quit := make(chan os.Signal, 1)
    signal.Notify(quit, syscall.SIGTERM, syscall.SIGINT)
    <-quit

    daemon.SdNotify(false, daemon.SdNotifyStopping)   // 上报「正在停止」
    ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
    defer cancel()
    srv.Shutdown(ctx)
}

func sdNotify(state string) error {
    addr := os.Getenv("NOTIFY_SOCKET")
    if addr == "" { return nil }               // 不在 systemd 下运行时静默跳过
    if addr[0] == '@' { addr = "\x00" + addr[1:] }   // 抽象命名空间
    conn, err := net.DialUnix("unixgram", nil, &net.UnixAddr{Name: addr, Net: "unixgram"})
    if err != nil { return err }
    defer conn.Close()
    _, err = conn.Write([]byte(state))
    return err
}
// sdNotify("READY=1")
// sdNotify("STATUS=处理中 1234 个请求")     // 会显示在 systemctl status 里
// sdNotify("WATCHDOG=1")
// sdNotify("STOPPING=1")

sudo systemctl edit nginx                   # ✅ 自动创建 drop-in 并打开编辑器
# 它会创建 /etc/systemd/system/nginx.service.d/override.conf

sudo systemctl edit --full nginx            # 完整复制原文件到 /etc/（整体覆盖）
sudo systemctl revert nginx                 # ✅ 撤销所有 drop-in 与覆盖，回到原始状态

# 手动创建 drop-in
sudo mkdir -p /etc/systemd/system/nginx.service.d/
sudo tee /etc/systemd/system/nginx.service.d/override.conf > /dev/null <<'EOF'
[Service]
LimitNOFILE=65535
Environment=MY_VAR=value
EOF
sudo systemctl daemon-reload
systemctl cat nginx                         # ✅ 能看到原文件 + drop-in，并标注来源

# ❌ 直接写会【追加】而不是替换（ExecStart 会变成两条，systemd 直接报错）
[Service]
ExecStart=/usr/local/bin/mynginx

# ✅ 先用空值清空，再赋新值
[Service]
ExecStart=
ExecStart=/usr/local/bin/mynginx

# 同样需要这样处理的字段：ExecStartPre、ExecStartPost、ExecReload、
#                       Environment、After、Wants、ReadWritePaths 等

journalctl                                  # 全部日志（从最早开始，按 q 退出）
journalctl -e                               # ✅ 跳到【末尾】
journalctl -r                               # 倒序（最新在前）
journalctl -n 100                           # 最近 100 行
journalctl -f                               # ✅ 跟随（等价 tail -f）
journalctl --no-pager                        # 不分页（脚本/管道用）

# ── 按服务 ──
journalctl -u myapp                         # ✅ 最常用
journalctl -u myapp -f                      # 跟随某个服务
journalctl -u myapp -n 50 --no-pager
journalctl -u nginx -u php-fpm              # 多个服务
journalctl -u 'myapp*'                      # 通配

# ── 按时间 ──
journalctl --since today
journalctl --since yesterday --until today
journalctl --since '1 hour ago'
journalctl --since '2026-08-12 14:00' --until '2026-08-12 15:00'
journalctl --since '-30min'                 # 30 分钟内
journalctl -u myapp --since '10 min ago'

# ── 按优先级 ──
journalctl -p err                           # ✅ 只看 error 及以上
journalctl -p warning..err                  # 区间
# 级别：emerg(0) alert(1) crit(2) err(3) warning(4) notice(5) info(6) debug(7)

# ── 按其他维度 ──
journalctl -k                               # ✅ 只看内核消息（等价 dmesg）
journalctl -k -p err --since today          # 今天的内核错误
journalctl _PID=1234                        # 按 PID
journalctl _UID=1000                        # 按用户
journalctl _COMM=sshd                       # 按命令名
journalctl -t myapp                         # 按 SyslogIdentifier
journalctl /usr/local/bin/myapp             # 按可执行文件路径
journalctl -b                               # 本次启动以来
journalctl -b -1                            # ✅ 【上一次】启动的日志（排查崩溃重启必用）
journalctl --list-boots                     # 列出所有启动记录
journalctl -u myapp --grep 'timeout'        # ✅ 内置正则过滤（比 | grep 高效）
journalctl -u myapp --grep 'error' -p err

# ── 输出格式 ──
journalctl -u myapp -o short                # 默认
journalctl -u myapp -o cat                  # ✅ 只输出消息本身（**给 jq 用**）
journalctl -u myapp -o json                 # JSON（一行一条）
journalctl -u myapp -o json-pretty          # 格式化 JSON
journalctl -u myapp -o verbose              # 显示所有字段（看有哪些字段可过滤）
journalctl -u myapp -o short-iso            # ISO 时间格式
journalctl -u myapp -o short-precise        # 微秒精度

# ── 结构化日志：Go 服务输出 JSON 时的组合 ──
journalctl -u myapp -o cat -f | jq -r 'select(.level=="error") | "\(.time) \(.msg)"'
journalctl -u myapp -o cat --since '1h ago' | jq -s 'group_by(.level) | map({level: .[0].level, n: length})'

journalctl --disk-usage                     # 当前占用
# Archived and active journals take up 1.2G in the file system.

sudo journalctl --vacuum-size=500M          # ✅ 压到 500MB 以内
sudo journalctl --vacuum-time=7d            # 只保留 7 天
sudo journalctl --vacuum-files=5            # 只保留 5 个归档文件
journalctl --verify                         # 校验日志完整性

# 持久化配置（默认可能只存在内存里，重启就没了！）
sudo mkdir -p /var/log/journal              # ✅ 这个目录存在 = 持久化
sudo systemd-tmpfiles --create --prefix /var/log/journal
sudo systemctl restart systemd-journald

sudo vim /etc/systemd/journald.conf
# [Journal]
# Storage=persistent        # volatile(仅内存) / persistent(落盘) / auto(有目录就落盘) / none
# SystemMaxUse=2G           # 最多用多少磁盘
# SystemKeepFree=1G         # 至少保留多少空闲
# SystemMaxFileSize=128M    # 单个文件最大
# MaxRetentionSec=1month    # 最长保留时间
# MaxFileSec=1week          # 单文件最长时间跨度
# RateLimitIntervalSec=30s  # ⚠️ 限流窗口
# RateLimitBurst=10000      # ⚠️ 窗口内最多多少条（超了会【丢日志】并提示 "Suppressed N messages"）
# ForwardToSyslog=no        # 是否转发给 rsyslog（不需要就关，省一半 IO）
sudo systemctl restart systemd-journald

# /etc/systemd/system/backup.service
[Unit]
Description=Nightly backup
OnFailure=alert@%n.service           # ✅ 失败时告警（cron 做不到）

[Service]
Type=oneshot
User=backup
ExecStart=/usr/local/bin/backup.sh
Nice=19                              # 降低优先级，别影响线上
IOSchedulingClass=idle               # IO 也降到最低
TimeoutStartSec=2h                   # 超过 2 小时算失败

# /etc/systemd/system/backup.timer
[Unit]
Description=Run backup nightly

[Timer]
OnCalendar=*-*-* 02:30:00            # 每天 02:30
Persistent=true                      # ✅ 关机期间错过的任务，开机后补跑
RandomizedDelaySec=600               # ✅ 随机延迟 0~600 秒（避免集群同时打爆存储）
AccuracySec=1m                       # 精度（默认 1min，越大越省电）
Unit=backup.service                  # 触发哪个 service（默认同名）

[Install]
WantedBy=timers.target

sudo systemctl daemon-reload
sudo systemctl enable --now backup.timer    # ✅ enable 的是 .timer，不是 .service
systemctl list-timers                       # ✅ 看所有定时器与下次触发时间
# NEXT                        LEFT     LAST                        PASSED  UNIT          ACTIVATES
# Wed 2026-08-13 02:30:00 CST 9h left  Tue 2026-08-12 02:30:12 CST 14h ago backup.timer  backup.service
systemctl list-timers --all
sudo systemctl start backup.service         # ✅ 手动触发一次（测试用）
journalctl -u backup.service -n 50          # 看执行日志

OnCalendar=*-*-* 02:30:00              # 每天 02:30
OnCalendar=*-*-* *:00:00               # 每小时整点
OnCalendar=*-*-* *:*:00                # 每分钟
OnCalendar=*-*-* *:0/15:00             # 每 15 分钟（0,15,30,45）
OnCalendar=Mon-Fri 09:00               # 工作日 09:00
OnCalendar=Mon *-*-* 02:00:00          # 每周一 02:00
OnCalendar=Sat,Sun 03:00               # 周末
OnCalendar=*-*-01 04:00:00             # 每月 1 号
OnCalendar=*-01,04,07,10-01 05:00:00   # 每季度第一天
OnCalendar=2026-12-25 00:00:00         # 一次性
OnCalendar=daily                       # 简写：每天 00:00
OnCalendar=weekly                      # 每周一 00:00
OnCalendar=monthly / yearly / hourly / minutely
OnCalendar=*-*-* 02:30:00 Asia/Shanghai   # ✅ 指定时区（systemd 249+）

# ✅ 写完一定要验证
systemd-analyze calendar '*-*-* 02:30:00'
# Normalized form: *-*-* 02:30:00
#     Next elapse: Wed 2026-08-13 02:30:00 CST
#        From now: 9h left
systemd-analyze calendar 'Mon-Fri 09:00' --iterations=5    # 看接下来 5 次触发时间

[Timer]
OnBootSec=5min                       # 开机后 5 分钟
OnStartupSec=10min                   # systemd 启动后 10 分钟
OnUnitActiveSec=1h                   # ✅ 上次【运行完】之后 1 小时（避免任务重叠）
OnUnitInactiveSec=30min              # 上次停止后 30 分钟
OnActiveSec=1h                       # timer 激活后 1 小时

crontab -e                           # ✅ 编辑当前用户的 crontab（会做语法检查）
crontab -l                           # 列出
crontab -r                           # ⚠️ 删除【全部】（没有确认提示，容易误操作）
crontab -l > backup.cron             # ✅ 改之前先备份
crontab -u app -l                    # 查看其他用户的（需 root）
crontab file                         # 从文件导入（会覆盖现有的！）

30 2 * * *      /usr/local/bin/backup.sh        # 每天 02:30
0 * * * *       /usr/local/bin/hourly.sh        # 每小时整点
*/15 * * * *    /usr/local/bin/check.sh         # 每 15 分钟
0 9 * * 1-5     /usr/local/bin/workday.sh       # 工作日 09:00
0 0 1 * *       /usr/local/bin/monthly.sh       # 每月 1 号
0 3 * * 0       /usr/local/bin/weekly.sh        # 每周日 03:00
0 2,14 * * *    /usr/local/bin/twice.sh         # 每天 02:00 和 14:00
0 0-6 * * *     /usr/local/bin/night.sh         # 0~6 点每小时

# 特殊字符串
@reboot         /usr/local/bin/on-boot.sh       # ✅ 开机时执行一次
@daily / @midnight    = 0 0 * * *
@hourly               = 0 * * * *
@weekly               = 0 0 * * 0
@monthly              = 0 0 1 * *
@yearly / @annually   = 0 0 1 1 *

# ⚠️ 「日」和「星期」同时指定时是【或】关系，不是与！
0 0 13 * 5      # 每月 13 号【或】每个周五都执行（不是"13 号且是周五"）

crontab -e                           # 用户级：存在 /var/spool/cron/crontabs/<user>
sudo vim /etc/crontab                # 系统级：⚠️ 多一个【用户名】字段
# 30 2 * * * root /usr/local/bin/backup.sh
#            ^^^^ 系统级 crontab 要指定运行用户

sudo vim /etc/cron.d/myapp           # ✅ 推荐：一个任务一个文件（便于自动化投放）
# 格式同 /etc/crontab（有用户名字段）
# 30 2 * * * app /usr/local/bin/backup.sh

ls /etc/cron.{hourly,daily,weekly,monthly}/       # 放【可执行脚本】（不是 crontab 格式）
# 由 run-parts 执行；文件名不能有点（.）否则被忽略！
sudo run-parts --test /etc/cron.daily             # 测试哪些脚本会被执行

# 亲自看看 cron 里的环境有多简陋
* * * * * env > /tmp/cron-env.txt
# 一分钟后
cat /tmp/cron-env.txt
# HOME=/home/lhx
# LOGNAME=lhx
# PATH=/usr/bin:/bin                    <- ⚠️ 只有这两个！
# SHELL=/bin/sh                         <- ⚠️ 是 sh 不是 bash！
# PWD=/home/lhx
# 就这么几个，没有 LANG、没有你 .bashrc 里的一切

# ① PATH 太短 -> command not found
30 2 * * * /usr/local/bin/mytool                      # ✅ 用绝对路径
PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin
30 2 * * * mytool                                      # ✅ 或在 crontab 顶部设 PATH

# ② SHELL 是 sh 不是 bash -> bash 特有语法失效
#    （[[ ]]、数组、进程替换 <()、$'...' 全都不能用）
SHELL=/bin/bash                                        # ✅ 在 crontab 顶部声明
30 2 * * * /bin/bash /path/script.sh                   # ✅ 或显式用 bash 执行
# 脚本里也要写 #!/bin/bash 而不是 #!/bin/sh

# ③ 不读 .bashrc/.profile -> 你配的环境变量全都没有
30 2 * * * . /etc/profile; . ~/.bashrc; /path/script.sh    # 显式 source
30 2 * * * bash -lc '/path/script.sh'                      # ✅ 或用登录 shell
# 更好的做法：让脚本自己 source 需要的配置，不依赖交互式环境

# ④ 没有 LANG/LC_ALL -> 中文乱码、日期格式不同、sort 顺序不同
LANG=en_US.UTF-8
LC_ALL=en_US.UTF-8

# ⑤ cwd 是家目录 -> 相对路径全错
30 2 * * * cd /opt/myapp && ./run.sh                   # ✅ 显式 cd

# ① 让任务把输出和错误都记下来（cron 的默认行为是发邮件，而机器通常没配邮件）
30 2 * * * /path/script.sh >> /var/log/myjob.log 2>&1
30 2 * * * /path/script.sh 2>&1 | logger -t myjob      # ✅ 或者送进 syslog/journal

# ② 用最小环境模拟 cron 来测试
env -i SHELL=/bin/sh PATH=/usr/bin:/bin HOME="$HOME" /bin/sh -c '/path/script.sh'
#   ^^ -i 清空所有环境变量，最接近 cron 的真实环境

# ③ 看 cron 自己的日志（确认任务有没有被触发）
sudo journalctl -u cron -f                             # Debian
sudo journalctl -u crond -f                            # RHEL
sudo grep CRON /var/log/syslog | tail
# Aug 12 02:30:01 host CRON[12345]: (lhx) CMD (/path/script.sh)
#                                          ^^^ 有这行说明触发了，问题在脚本内部

# ④ 检查任务有没有被邮件"吞掉"
MAILTO=ops@example.com                                  # 有输出时发到这
MAILTO=""                                               # 不发邮件（丢弃输出）
sudo cat /var/mail/$USER                                # 看本地邮件里的错误信息

# ① % 必须转义（cron 里 % 是换行的意思）
0 2 * * * echo $(date +%Y-%m-%d)                        # ❌ 会被截断
0 2 * * * echo $(date +\%Y-\%m-\%d)                     # ✅ 转义
0 2 * * * /path/script.sh                                # ✅ 更好：复杂逻辑放脚本里

# ② 任务重叠（上一次没跑完，下一次又启动了）
*/5 * * * * flock -n /tmp/myjob.lock /path/script.sh    # ✅ 用 flock 加锁
#                  ^^ -n 表示拿不到锁就立即退出（不等待）
*/5 * * * * flock -w 10 /tmp/myjob.lock /path/script.sh # 或等 10 秒

# ③ 超时失控（任务卡死后永远占着资源）
0 2 * * * timeout 3600 /path/script.sh                  # ✅ 最多跑 1 小时

# ④ 时区与 DST
timedatectl                                              # 确认系统时区
CRON_TZ=Asia/Shanghai                                    # ✅ 在 crontab 里指定时区
0 2 * * * /path/script.sh
# ⚠️ 夏令时切换那天，凌晨 2:00~3:00 的任务可能【不执行或执行两次】
#    关键任务避开 0:00~4:00，或用 UTC

# ⑤ crontab -r 手滑删掉全部
crontab -l > ~/crontab.bak                               # ✅ 改前必备份
# 更好的做法：crontab 内容进 git，用 /etc/cron.d/ 投放

# ⑥ 用户被删/被锁后 crontab 仍然存在（但执行失败）
sudo ls -l /var/spool/cron/crontabs/

# ⑦ 脚本没有执行权限、或 shebang 写错
chmod +x /path/script.sh
head -1 /path/script.sh                                  # #!/bin/bash 且【无 CRLF】（05 篇）

# anacron：为「不常开机的机器」设计 —— 错过的任务开机后补跑
cat /etc/anacrontab
# period  delay  job-identifier  command
# 1       5      cron.daily      run-parts --report /etc/cron.daily
#  ^ 天数  ^ 开机后延迟几分钟
# 服务器 7×24 开机通常用不到；systemd timer 的 Persistent=true 是它的现代替代

# at：一次性延迟任务
echo "/path/script.sh" | at 02:30                # 今天 02:30 执行一次
echo "reboot" | at now + 2 hours
at -l                                            # 列出待执行的（等价 atq）
at -c 5                                          # 查看任务 5 的内容
atrm 5                                           # 删除任务 5
sudo systemctl enable --now atd                  # 需要 atd 服务在跑

# systemd 的等价物（不需要 atd）
sudo systemd-run --on-active=2h /path/script.sh          # 2 小时后执行一次
sudo systemd-run --on-calendar='02:30' /path/script.sh   # 指定时刻
sudo systemd-run --unit=myjob --on-active=30min /path/x  # 命名，便于取消

# /etc/systemd/system/myapp.socket
[Unit]
Description=MyApp socket

[Socket]
ListenStream=8080
Accept=no                            # no = 把监听 fd 传给服务（服务自己 accept）

[Install]
WantedBy=sockets.target

sudo systemctl enable --now myapp.socket     # 只启用 socket，service 暂不运行
curl localhost:8080                          # 第一次访问时 systemd 才启动 myapp.service

import "github.com/coreos/go-systemd/v22/activation"

listeners, err := activation.Listeners()     // 从 systemd 继承的监听 fd
if err != nil || len(listeners) == 0 {
    // 没有的话自己监听（便于本地开发）
    ln, _ = net.Listen("tcp", ":8080")
} else {
    ln = listeners[0]
}
http.Serve(ln, handler)

journalctl -u myapp -f                       # 跟随某服务
journalctl -u myapp -n 100 --no-pager        # 最近 100 行
journalctl -u myapp --since '1h ago' -p err  # 一小时内的错误
journalctl -u myapp --grep 'timeout'         # 内置正则过滤
journalctl -b -1 -u myapp                    # 【上次启动】的日志（查崩溃原因）
journalctl -k -p err                         # 内核错误
journalctl -u myapp -o cat | jq .            # 结构化日志给 jq
journalctl --disk-usage                      # 占用
sudo journalctl --vacuum-time=7d             # 清理

%n    完整 unit 名（myapp.service）
%N    unit 名（不含后缀，myapp）
%p    实例化 unit 的前缀部分
%i    实例化 unit 的参数部分（myapp@prod.service 里的 prod）
%I    同 %i 但反转转义
%H    主机名
%u    User= 指定的用户名
%U    对应的 uid
%h    用户家目录
%t    运行时目录（/run 或 /run/user/UID）
%S    状态目录（/var/lib）
%C    缓存目录（/var/cache）
%L    日志目录（/var/log）
%E    配置目录（/etc）
%%    字面的百分号

# /etc/systemd/system/myapp@.service        <- 注意文件名里的 @
[Service]
ExecStart=/usr/local/bin/myapp --env %i --port 80%i
EnvironmentFile=/etc/myapp/%i.env
StateDirectory=myapp-%i

sudo systemctl enable --now myapp@prod.service      # %i = prod
sudo systemctl enable --now myapp@staging.service   # %i = staging
systemctl status 'myapp@*'

*/5 * * * * flock -n /tmp/myjob.lock /path/script.sh    # ✅ 拿不到锁就跳过
*/5 * * * * timeout 240 flock -w 10 /tmp/x.lock /path/script.sh   # 锁 + 超时