① 固件阶段：BIOS 或 UEFI
   - 加电自检（POST），初始化硬件
   - BIOS：读磁盘第一个扇区的 MBR（512 字节）
   - UEFI：读 ESP 分区（FAT32）里的 .efi 文件      <- 现代机器都是这个
        v
② 引导加载器：GRUB2
   - 显示启动菜单，加载内核和 initramfs 到内存
   - 传递内核启动参数（root=、ro、quiet 等）
        v
③ 内核阶段
   - 解压自身，初始化内存管理、调度器、中断
   - 挂载 initramfs 作为【临时】根文件系统
        v
④ initramfs 阶段
   - 加载访问真正根分区所需的驱动（磁盘控制器、LVM、加密卷、网络存储）
   - 挂载真正的根分区
   - switch_root：切换到真正的根，执行 /sbin/init
        v
⑤ systemd（PID 1）
   - 读取 default.target（通常是 multi-user.target 或 graphical.target）
   - 按依赖关系【并行】启动所有 unit
        v
⑥ 登录：getty / sshd / display manager

# 看 initramfs 里有什么
lsinitramfs /boot/initrd.img-$(uname -r) | grep -E "\.ko" | head -5     # Debian
lsinitrd /boot/initramfs-$(uname -r).img | head -20                     # RHEL

# 内核启动参数（排查启动问题时必看）
cat /proc/cmdline
# BOOT_IMAGE=/vmlinuz root=UUID=xxx ro quiet splash

# 重建 initramfs（改了驱动、加了 LVM 之后需要）
update-initramfs -u -k all       # Debian/Ubuntu
dracut -f --regenerate-all       # RHEL 系

# 看上一次启动的完整日志（-b -1 = 上一次启动）
journalctl -b -1 -p err

# 看本次启动的所有日志
journalctl -b

# 内核环形缓冲（硬件、驱动问题都在这）
dmesg -T | grep -iE "error|fail|warn" | head -20

# 哪些服务启动失败了
systemctl --failed
# UNIT                LOAD   ACTIVE SUB    DESCRIPTION
# myapp.service       loaded failed failed My Application

systemd.unit=rescue.target       单用户模式，最小服务集
systemd.unit=emergency.target    只挂载根分区（只读），连 systemd 服务都不启
init=/bin/bash                   完全绕过 systemd，直接进 shell（终极手段）
rd.break                         在 initramfs 阶段就停下（RHEL，重置 root 密码用）

# 看某个服务的 cgroup 树
systemd-cgls /system.slice/nginx.service
# nginx.service
# +-1234 nginx: master process /usr/sbin/nginx
# +-1235 nginx: worker process
# +-1236 nginx: worker process

# 看资源占用（类似 top 但按服务聚合）
systemd-cgtop

/etc/systemd/system/          <- 【管理员写的，优先级最高】你应该改这里
/run/systemd/system/          <- 运行时生成的，临时
/usr/lib/systemd/system/      <- 软件包自带的，【不要直接改】

# 只覆盖某几个配置项，不动原文件
systemctl edit nginx.service
# 会创建 /etc/systemd/system/nginx.service.d/override.conf

# 完整替换（复制一份到 /etc/systemd/system/）
systemctl edit --full nginx.service

# 看最终生效的完整配置（合并了所有 drop-in）
systemctl cat nginx.service

mkdir -p /etc/systemd/system/nginx.service.d/
cat > /etc/systemd/system/nginx.service.d/limits.conf <<'EOF'
[Service]
LimitNOFILE=65535
EOF
systemctl daemon-reload

systemctl get-default
# multi-user.target

# 切换（临时）
systemctl isolate multi-user.target

# 设置默认
systemctl set-default multi-user.target

# /etc/systemd/system/myapp.service
[Unit]
Description=My Go Application
Documentation=https://wiki.internal/myapp
# 依赖：网络就绪之后再启动
After=network-online.target
Wants=network-online.target
# 如果依赖数据库在同机
After=postgresql.service
# 重启频率限制 —— 注意这两项属于 [Unit] 段，不是 [Service]
# 10 秒内启动失败超过 5 次就放弃（防止无限重启风暴）
StartLimitIntervalSec=10
StartLimitBurst=5

[Service]
Type=notify
NotifyAccess=main

# ---------- 身份与目录 ----------
User=myapp
Group=myapp
WorkingDirectory=/opt/myapp/current

# ---------- 启动命令 ----------
# 必须用绝对路径，不走 PATH 查找
ExecStart=/opt/myapp/current/bin/myapp --config=/etc/myapp/config.yaml
ExecReload=/bin/kill -HUP $MAINPID

# ---------- 环境变量 ----------
Environment="GOMAXPROCS=4"
Environment="GOMEMLIMIT=3500MiB"
EnvironmentFile=-/etc/myapp/env
#              ^ 前缀 - 表示文件不存在也不报错

# ---------- 重启策略 ----------
Restart=always
RestartSec=3
# 频率限制在上面的 [Unit] 段

# ---------- 优雅关闭（第 8 篇）----------
KillSignal=SIGTERM
KillMode=mixed
TimeoutStopSec=45

# ---------- 资源限制 ----------
LimitNOFILE=65535
MemoryMax=4G
CPUQuota=400%
OOMScoreAdjust=-500
UMask=0027

# ---------- 安全加固 ----------
NoNewPrivileges=true
PrivateTmp=true
ProtectSystem=strict
ProtectHome=true
ReadWritePaths=/var/log/myapp /var/lib/myapp
ProtectKernelTunables=true
ProtectControlGroups=true
RestrictSUIDSGID=true

[Install]
WantedBy=multi-user.target

systemctl daemon-reload           # 改了 unit 文件必须先 reload
systemctl enable --now myapp
systemctl status myapp

// Go 里用 sd_notify（不需要 CGO）
import "github.com/coreos/go-systemd/v22/daemon"

func main() {
    srv := setupServer()
    go srv.ListenAndServe()
    
    // 所有初始化完成后再通知 systemd
    warmupCache()
    checkDBConnection()
    daemon.SdNotify(false, daemon.SdNotifyReady)      // <- 现在才算 ready
    
    // 配合 WatchdogSec 做健康上报
    go func() {
        interval, _ := daemon.SdWatchdogEnabled(false)
        if interval == 0 { return }
        for {
            if healthy() {
                daemon.SdNotify(false, daemon.SdNotifyWatchdog)
            }
            time.Sleep(interval / 2)
        }
    }()
    
    waitForShutdown(srv)
}

[Service]
Type=notify
WatchdogSec=30           # 30 秒没收到心跳就认为服务挂了，触发重启
Restart=always

always      -> 即使程序正常退出（码 0）也重启。适合「本来就该一直跑」的服务
on-failure  -> 只在异常时重启。适合「正常退出就是完成了工作」的场景

[Unit]
# ⚠️ 这两项在 [Unit] 段，不是 [Service] —— 写错位置会被静默忽略
StartLimitIntervalSec=10
StartLimitBurst=5
# 含义：10 秒内如果重启超过 5 次，就【彻底放弃】，进入 failed 状态

[Service]
Restart=always
RestartSec=3

# 触发限制后需要手动重置
systemctl reset-failed myapp
systemctl start myapp

[Service]
KillSignal=SIGTERM       # 先发这个（第 8 篇讲的优雅关闭）
KillMode=mixed
TimeoutStopSec=45        # 等 45 秒，超时后 SIGKILL

After / Before        -> 【顺序】：先启动谁，后启动谁
Requires / Wants      -> 【依赖】：需不需要另一个 unit 也被启动

两者【完全独立】！

# ❌ 只写 Requires 不写 After
[Unit]
Requires=postgresql.service
# 结果：postgresql 会被【同时】启动，但不保证它先就绪
#       你的服务可能在 pg 还没准备好时就尝试连接

# ✅ 两个都要写
[Unit]
Requires=postgresql.service
After=postgresql.service

# ❌ network.target 只表示「网络栈已初始化」，不代表【IP 已配好】
After=network.target

# ✅ network-online.target 才表示网络真正可用
After=network-online.target
Wants=network-online.target        # <- 必须加 Wants，否则这个 target 不会被激活

[Service]
# 基础三项，建议所有服务都加
NoNewPrivileges=true        # 禁止通过 SUID 提权（第 3 篇）
PrivateTmp=true             # 独立的 /tmp，看不到别人的临时文件
ProtectSystem=strict        # 整个文件系统只读，除了下面显式放开的路径
ReadWritePaths=/var/log/myapp /var/lib/myapp

# 进阶
ProtectHome=true            # 看不到 /home、/root
ProtectKernelTunables=true  # /proc/sys 只读
ProtectKernelModules=true   # 禁止加载内核模块
ProtectControlGroups=true   # /sys/fs/cgroup 只读
RestrictSUIDSGID=true       # 禁止创建 SUID 文件
RestrictNamespaces=true     # 禁止创建 namespace
LockPersonality=true
MemoryDenyWriteExecute=true # 禁止可写可执行的内存页（防 shellcode）

# 限制能力
CapabilityBoundingSet=CAP_NET_BIND_SERVICE
AmbientCapabilities=CAP_NET_BIND_SERVICE     # 让非 root 也能绑 80/443 端口

# 检查一个服务的加固程度，systemd 会给出评分和建议
systemd-analyze security myapp.service
# NAME                          DESCRIPTION                    EXPOSURE
# PrivateNetwork=               Service has access to network  0.5
# User=/DynamicUser=            Service runs as root user      0.4  <- 建议改
# ...
# -> Overall exposure level for myapp.service: 6.2 EXPOSED 🙁

# 生命周期
systemctl start|stop|restart|reload myapp
systemctl reload-or-restart myapp        # 支持 reload 就 reload，否则 restart

# 开机自启
systemctl enable myapp                   # 只设置，不启动
systemctl enable --now myapp             # 设置并立即启动
systemctl disable myapp
systemctl is-enabled myapp

# 状态
systemctl status myapp
systemctl is-active myapp                # 脚本里用，只输出 active/inactive
systemctl --failed                       # 所有失败的服务

# 查看配置
systemctl cat myapp                      # 最终生效的配置（含 drop-in）
systemctl show myapp                     # 所有属性的当前值
systemctl show -p MemoryMax,LimitNOFILE myapp    # 只看几项

# 依赖关系
systemctl list-dependencies myapp
systemctl list-dependencies --reverse myapp      # 谁依赖它

# 屏蔽（比 disable 更彻底，连手动 start 也不行）
systemctl mask myapp
systemctl unmask myapp

systemctl daemon-reload      # 重新读取所有 unit 文件
# 忘了这一步的表现：修改完全不生效，status 显示的还是旧配置
# systemd 会在 status 里提示：Warning: The unit file has changed on disk

# 看某个服务的日志
journalctl -u myapp
journalctl -u myapp -f                   # 跟随（相当于 tail -f）
journalctl -u myapp -n 100               # 最后 100 行
journalctl -u myapp --no-pager           # 不分页，脚本里用

# 按时间
journalctl -u myapp --since "1 hour ago"
journalctl -u myapp --since "2026-08-06 14:00" --until "2026-08-06 15:00"
journalctl -u myapp --since today

# 按优先级（0=emerg 到 7=debug）
journalctl -p err                        # 只看 error 及以上
journalctl -p warning..err

# 按启动次数
journalctl -b                            # 本次启动
journalctl -b -1                         # 上一次启动  <- 排查重启原因
journalctl --list-boots

# 内核日志
journalctl -k
journalctl -k -b -1 | grep -i oom        # 上次启动的 OOM 记录（第 10 篇）

# 结构化查询（journald 的独门功夫）
journalctl _PID=1234
journalctl _UID=1000
journalctl _COMM=sshd
journalctl _SYSTEMD_UNIT=myapp.service

# 输出格式
journalctl -u myapp -o json-pretty       # JSON，便于用 jq 处理
journalctl -u myapp -o cat               # 只有消息正文，不带时间戳前缀

# 检查
journalctl --disk-usage
# Archived and active journals take up 1.2G in the file system.
# 如果显示 "in the runtime"，说明只在内存里（/run/log/journal）

# 开启持久化
mkdir -p /var/log/journal
systemd-tmpfiles --create --prefix /var/log/journal
systemctl restart systemd-journald

# /etc/systemd/journald.conf
[Journal]
Storage=persistent           # 持久化到 /var/log/journal
SystemMaxUse=2G              # 总大小上限
SystemMaxFileSize=200M       # 单文件上限
MaxRetentionSec=2week        # 保留时长
ForwardToSyslog=no           # 关掉转发到 syslog，避免日志写两份
RateLimitIntervalSec=30s
RateLimitBurst=10000         # 限流，防止日志风暴打满磁盘

# 手动清理
journalctl --vacuum-size=500M
journalctl --vacuum-time=7d

# 总耗时
systemd-analyze
# Startup finished in 3.821s (kernel) + 12.453s (userspace) = 16.274s
#                                        ^^^^^^^ 用户态花了 12 秒，偏慢

# 按耗时排序看哪些服务慢
systemd-analyze blame | head -10
# 8.234s NetworkManager-wait-online.service      <- 罪魁祸首
# 2.103s docker.service
# 1.234s containerd.service

# 关键路径（真正决定总时长的依赖链）
systemd-analyze critical-chain
# multi-user.target @12.453s
# +-docker.service @10.350s +2.103s
#   +-network-online.target @10.348s
#     +-NetworkManager-wait-online.service @2.114s +8.234s
#                                                  ^^^^^^ 等网络等了 8 秒

# 生成可视化图
systemd-analyze plot > boot.svg

# 如果不需要等网络完全就绪，可以禁用
systemctl disable NetworkManager-wait-online.service
# 但要确认没有服务依赖 network-online.target

useradd --system --no-create-home --shell /usr/sbin/nologin myapp

install -d -o myapp -g myapp -m 0750 /var/log/myapp
install -d -o myapp -g myapp -m 0750 /var/lib/myapp
install -d -o root  -g myapp -m 0750 /etc/myapp

# 配置文件含密钥，只给读权限
install -o root -g myapp -m 0640 config.yaml /etc/myapp/config.yaml

func main() {
    cfg := loadConfig()
    db := mustConnectDB(cfg)
    srv := &http.Server{Addr: cfg.Addr, Handler: buildRouter(db)}

    go func() {
        if err := srv.ListenAndServe(); err != nil && err != http.ErrServerClosed {
            log.Fatalf("listen: %v", err)
        }
    }()

    // 初始化全部完成后才通知 systemd 就绪
    warmupCache()
    daemon.SdNotify(false, daemon.SdNotifyReady)
    log.Println("service ready")

    // watchdog 心跳
    go func() {
        iv, err := daemon.SdWatchdogEnabled(false)
        if err != nil || iv == 0 { return }
        t := time.NewTicker(iv / 2)
        defer t.Stop()
        for range t.C {
            if db.PingContext(context.Background()) == nil {
                daemon.SdNotify(false, daemon.SdNotifyWatchdog)
            }
        }
    }()

    // 优雅关闭（第 8 篇）
    quit := make(chan os.Signal, 1)
    signal.Notify(quit, syscall.SIGINT, syscall.SIGTERM)
    <-quit
    daemon.SdNotify(false, daemon.SdNotifyStopping)

    ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
    defer cancel()
    _ = srv.Shutdown(ctx)
    _ = db.Close()
}

# /etc/systemd/system/myapp.service
[Unit]
Description=My Go API Service
After=network-online.target postgresql.service
Wants=network-online.target
StartLimitIntervalSec=30
StartLimitBurst=5

[Service]
Type=notify
NotifyAccess=main
WatchdogSec=30

User=myapp
Group=myapp
WorkingDirectory=/opt/myapp/current
ExecStart=/opt/myapp/current/bin/myapp --config=/etc/myapp/config.yaml

Environment="GOMEMLIMIT=3500MiB"
EnvironmentFile=-/etc/myapp/env

Restart=always
RestartSec=3

KillSignal=SIGTERM
KillMode=mixed
TimeoutStopSec=45

LimitNOFILE=65535
MemoryMax=4G
CPUQuota=400%
UMask=0027
OOMScoreAdjust=-500

NoNewPrivileges=true
PrivateTmp=true
ProtectSystem=strict
ProtectHome=true
ReadWritePaths=/var/log/myapp /var/lib/myapp
ProtectKernelTunables=true
RestrictSUIDSGID=true
AmbientCapabilities=CAP_NET_BIND_SERVICE

[Install]
WantedBy=multi-user.target

systemctl daemon-reload
systemctl enable --now myapp

# 验证 ① 服务真的 ready 了（不是 simple 的假就绪）
systemctl show -p ActiveState,SubState myapp
# ActiveState=active
# SubState=running          <- notify 型服务收到 READY=1 才会是 running

# 验证 ② 资源限制生效（第 11 篇讲的：只信 /proc/<pid>/limits）
MAINPID=$(systemctl show -p MainPID --value myapp)
grep -i "open files" /proc/$MAINPID/limits
# Max open files            65535     65535     files     ✅

# 验证 ③ 内存限制（cgroup）
cat /sys/fs/cgroup/system.slice/myapp.service/memory.max
# 4294967296                ✅ 4GB

# 验证 ④ 以非 root 运行
ps -o user= -p $MAINPID
# myapp                     ✅

# 验证 ⑤ 优雅关闭：观察停止耗时和退出码
time systemctl stop myapp
# real 0m2.134s             <- 远小于 TimeoutStopSec，说明是主动退出的
systemctl show -p ExecMainStatus,ExecMainCode myapp
# ExecMainStatus=0          <- 退出码 0 = 优雅退出  ✅
# ExecMainCode=1            （1=exited 正常退出；2=killed 被信号杀）

# 如果 ExecMainStatus=143（128+15）说明没捕获 SIGTERM
# 如果耗时正好等于 TimeoutStopSec 说明优雅关闭超时了，被 SIGKILL 打断

# 验证 ⑥ 崩溃自动重启
kill -9 $MAINPID
sleep 5
systemctl is-active myapp
# active                    ✅ 已自动拉起
journalctl -u myapp -n 5 | grep -i "scheduled restart"

# 验证 ⑦ 安全加固评分
systemd-analyze security myapp.service | tail -3
# -> Overall exposure level for myapp.service: 2.1 OK 🙂

# 确认没有遗留的进程在跑（否则会有两个实例抢端口）
pgrep -af myapp
# 只应该看到 systemd 管的那一个

# 清掉 crontab 里的 @reboot 启动项
crontab -l | grep -v myapp | crontab -

After=network-online.target
Wants=network-online.target