有一次大促前，我被一通电话从床上拽起来。运维大哥的声音都在抖："支付服务挂了，nohup进程没了，日志里啥都没有。"我迷迷糊糊连上VPN，看到那台服务器上空空如也——没有systemd，没有supervisor，只有一个孤零零的nohup.out文件，最后一条记录停留在三小时前。那天晚上我们花了四十分钟手动重启服务，损失了大概两千单。从那以后，我在所有项目里第一件事就是配好systemd。
说实话，很多Go开发者对部署这事儿不上心。本地go run跑得欢，上线就用nohup &一挂了事。等真出了事才发现，进程没了就是没了，连是谁杀的都不知道。systemd这玩意儿，说白了就是Linux给你配的一个"保姆"：进程死了自动拉起来，开机自动跑，日志统一管，资源还能限制。你花二十分钟配好它，它能帮你省下半夜被叫醒的次数。
先把二进制文件准备好
部署之前，编译这一步就有讲究。如果你是在Mac或Windows上开发，要交叉编译成Linux可执行文件：
# 本地编译（开发环境）
go build -o myapp main.go
# 交叉编译（Mac/Windows编译Linux程序）
CGO_ENABLED=0 GOOS=linux GOARCH=amd64 go build -o myapp main.go
# 优化编译（减小体积，去掉符号表和调试信息）
go build -ldflags="-s -w" -o myapp main.go
# 静态编译（不依赖动态库，部署更省心）
CGO_ENABLED=0 go build -a -installsuffix cgo -o myapp main.go
# 加上版本信息，方便排查问题
VERSION=v1.0.0
BUILD_TIME=$(date +%Y%m%d-%H%M%S)
GIT_COMMIT=$(git rev-parse --short HEAD)
go build -ldflags="-X main.Version=$VERSION -X main.BuildTime=$BUILD_TIME -X main.GitCommit=$GIT_COMMIT" -o myapp main.go
我强烈建议你在main.go里加上版本信息打印，线上排查问题时能救命：
package main
import (
"fmt"
"flag"
)
var (
Version = "unknown"
BuildTime = "unknown"
GitCommit = "unknown"
)
funcmain() {
version := flag.Bool("version", false, "显示版本信息")
flag.Parse()
if *version {
fmt.Printf("Version: %s\n", Version)
fmt.Printf("Build Time: %s\n", BuildTime)
fmt.Printf("Git Commit: %s\n", GitCommit)
return
}
// 启动应用...
}
服务器上的目录我建议按这个结构来，清晰好维护：
/opt/myapp/
├── bin/ # 可执行文件
│ └── myapp
├── configs/ # 配置文件
│ └── config.yaml
├── logs/ # 日志文件
├── data/ # 数据文件
└── scripts/ # 脚本文件
├── start.sh
├── stop.sh
└── restart.sh
systemd到底是个啥
systemd是Linux系统的"大管家"，从CentOS 7、Ubuntu 16.04开始就是默认的初始化系统。它能干的事很多，但对我们Go开发者来说，核心就这几样：
systemd的配置文件叫"单元"（unit），最常用的就是.service文件。存放位置有两个：
# 系统服务目录（系统自带的服务放这里）
/usr/lib/systemd/system/
# 用户自定义服务目录（你自己的服务放这里）
/etc/systemd/system/
写一个能跑的服务配置
最基础的配置长这样，保存到/etc/systemd/system/myapp.service：
[Unit]
Description=My Go Application
Documentation=https://example.com/docs
After=network.target
[Service]
Type=simple
User=myapp
Group=myapp
WorkingDirectory=/opt/myapp
ExecStart=/opt/myapp/bin/myapp
Restart=always
RestartSec=5s
[Install]
WantedBy=multi-user.target
这几行的意思是：等网络起来之后再启动，用myapp用户跑，工作目录设在/opt/myapp，执行命令是/opt/myapp/bin/myapp，挂了之后等5秒自动重启。
但生产环境我建议用完整版，把该配的都配上：
[Unit]
Description=My Go Application
Documentation=https://example.com/docs
After=network.target mysql.service redis.service
Wants=mysql.service redis.service
[Service]
Type=simple
User=myapp
Group=myapp
WorkingDirectory=/opt/myapp
# 环境变量
Environment="APP_ENV=production"
Environment="LOG_LEVEL=info"
EnvironmentFile=/opt/myapp/configs/env
# 启动命令
ExecStart=/opt/myapp/bin/myapp -config /opt/myapp/configs/config.yaml
ExecReload=/bin/kill -HUP $MAINPID
ExecStop=/bin/kill -SIGTERM $MAINPID
# 重启策略
Restart=always
RestartSec=5s
StartLimitInterval=0
# 资源限制
LimitNOFILE=65535
LimitNPROC=65535
# 日志输出到journald
StandardOutput=journal
StandardError=journal
SyslogIdentifier=myapp
# 安全加固
PrivateTmp=true
NoNewPrivileges=true
[Install]
WantedBy=multi-user.target
这里有几个坑我踩过，提醒你一下：
After=network.target mysql.service redis.service：确保网络、MySQL、Redis都就绪了再启动你的服务，否则可能会连不上数据库EnvironmentFile：把敏感信息放文件里，而不是直接写在service文件里，权限可以设成600Restart=always：不管什么原因退出，都自动重启。如果只想在异常退出时重启，用Restart=on-failureStartLimitInterval=0：取消重启次数限制，默认10秒内重启5次就会标记为失败
常用命令记牢
配置写完后，这几条命令是你每天都要用的：
# 重载systemd配置（修改了service文件后必须执行）
sudo systemctl daemon-reload
# 启动服务
sudo systemctl start myapp
# 停止服务
sudo systemctl stop myapp
# 重启服务
sudo systemctl restart myapp
# 重新加载配置（不重启进程，需要程序支持信号处理）
sudo systemctl reload myapp
# 查看服务状态（最常用）
sudo systemctl status myapp
# 查看服务是否运行
sudo systemctl is-active myapp
# 查看服务是否开机自启
sudo systemctl is-enabled myapp
开机自启的配置也很简单：
# 启用开机自启动
sudo systemctl enable myapp
# 禁用开机自启动
sudo systemctl disable myapp
# 启用并立即启动（一步到位）
sudo systemctl enable --now myapp
# 禁用并立即停止
sudo systemctl disable --now myapp
日志查询是门手艺
systemd把日志都收进了journald，查询比翻log文件方便多了：
# 查看服务日志
sudo journalctl -u myapp
# 实时查看（类似tail -f）
sudo journalctl -u myapp -f
# 查看最近100行
sudo journalctl -u myapp -n 100
# 查看今天的日志
sudo journalctl -u myapp --since today
# 查看指定时间段
sudo journalctl -u myapp --since "2024-01-01 00:00:00" --until "2024-01-02 00:00:00"
# 只看错误级别
sudo journalctl -u myapp -p err
# 清理日志（保留7天）
sudo journalctl --vacuum-time=7d
# 清理日志（保留1GB）
sudo journalctl --vacuum-size=1G
我习惯把日志输出到journald而不是文件，因为journalctl的查询能力太强了，按时间、按级别、按服务名过滤都是一行命令的事。但如果你需要把日志传给ELK或Loki分析，也可以直接输出到文件：
[Service]
StandardOutput=append:/opt/myapp/logs/stdout.log
StandardError=append:/opt/myapp/logs/stderr.log
优雅关闭不是可选项
如果你的服务在重启时直接杀进程，正在处理的请求就会中断。Go里实现优雅关闭很简单，捕获SIGINT和SIGTERM信号，给正在跑的请求留点收尾时间：
package main
import (
"context"
"fmt"
"net/http"
"os"
"os/signal"
"syscall"
"time"
"github.com/gin-gonic/gin"
)
funcmain() {
r := gin.Default()
r.GET("/health", func(c *gin.Context) {
c.JSON(200, gin.H{"status": "ok"})
})
srv := &http.Server{
Addr: ":8080",
Handler: r,
}
gofunc() {
if err := srv.ListenAndServe(); err != nil && err != http.ErrServerClosed {
fmt.Printf("服务器启动失败: %v\n", err)
}
}()
fmt.Println("服务器启动在 :8080")
quit := make(chan os.Signal, 1)
signal.Notify(quit, syscall.SIGINT, syscall.SIGTERM)
<-quit
fmt.Println("正在关闭服务器...")
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
defer cancel()
if err := srv.Shutdown(ctx); err != nil {
fmt.Printf("服务器强制关闭: %v\n", err)
}
fmt.Println("服务器已关闭")
}
如果你的服务还连了数据库、Redis、消息队列，记得在Shutdown里一起清理：
type App struct {
db *sql.DB
cache *redis.Client
mq *amqp.Connection
}
func(app *App)Shutdown(ctx context.Context)error {
fmt.Println("开始清理资源...")
if app.db != nil {
fmt.Println("关闭数据库连接...")
if err := app.db.Close(); err != nil {
return err
}
}
if app.cache != nil {
fmt.Println("关闭Redis连接...")
if err := app.cache.Close(); err != nil {
return err
}
}
if app.mq != nil {
fmt.Println("关闭消息队列连接...")
if err := app.mq.Close(); err != nil {
return err
}
}
fmt.Println("资源清理完成")
returnnil
}
自动化部署脚本
手动复制文件、重启服务太low了，写个脚本一键搞定。下面这个deploy.sh我用了快两年，稳定可靠：
#!/bin/bash
# deploy.sh
set -e
APP_NAME="myapp"
APP_DIR="/opt/myapp"
SERVICE_NAME="myapp.service"
echo"开始部署 $APP_NAME..."
# 1. 停止服务
echo"停止服务..."
sudo systemctl stop $SERVICE_NAME || true
# 2. 备份旧版本
if [ -f "$APP_DIR/bin/$APP_NAME" ]; then
echo"备份旧版本..."
sudo cp "$APP_DIR/bin/$APP_NAME""$APP_DIR/bin/${APP_NAME}.bak.$(date +%Y%m%d%H%M%S)"
fi
# 3. 复制新版本
echo"复制新版本..."
sudo cp "$APP_NAME""$APP_DIR/bin/"
sudo chmod +x "$APP_DIR/bin/$APP_NAME"
# 4. 复制配置文件
if [ -f "config.yaml" ]; then
echo"复制配置文件..."
sudo cp config.yaml "$APP_DIR/configs/"
fi
# 5. 重载systemd
echo"重载systemd..."
sudo systemctl daemon-reload
# 6. 启动服务
echo"启动服务..."
sudo systemctl start $SERVICE_NAME
# 7. 检查状态
sleep 2
if sudo systemctl is-active --quiet $SERVICE_NAME; then
echo"✅ 部署成功！"
sudo systemctl status $SERVICE_NAME
else
echo"❌ 部署失败！"
sudo journalctl -u $SERVICE_NAME -n 50
exit 1
fi
回滚脚本也备一个，万一新版本有问题，秒切回去：
#!/bin/bash
# rollback.sh
set -e
APP_NAME="myapp"
APP_DIR="/opt/myapp"
SERVICE_NAME="myapp.service"
echo"开始回滚 $APP_NAME..."
BACKUP=$(ls -t "$APP_DIR/bin/${APP_NAME}.bak."* 2>/dev/null | head -n 1)
if [ -z "$BACKUP" ]; then
echo"❌ 没有找到备份文件！"
exit 1
fi
echo"找到备份: $BACKUP"
echo"停止服务..."
sudo systemctl stop $SERVICE_NAME
echo"恢复备份..."
sudo cp "$BACKUP""$APP_DIR/bin/$APP_NAME"
sudo chmod +x "$APP_DIR/bin/$APP_NAME"
echo"启动服务..."
sudo systemctl start $SERVICE_NAME
sleep 2
if sudo systemctl is-active --quiet $SERVICE_NAME; then
echo"✅ 回滚成功！"
sudo systemctl status $SERVICE_NAME
else
echo"❌ 回滚失败！"
sudo journalctl -u $SERVICE_NAME -n 50
exit 1
fi
再加个健康检查脚本，部署完自动验证：
#!/bin/bash
# health_check.sh
APP_NAME="myapp"
HEALTH_URL="http://localhost:8080/health"
MAX_RETRIES=5
RETRY_INTERVAL=2
echo"开始健康检查..."
for i in $(seq 1 $MAX_RETRIES); do
echo"尝试 $i/$MAX_RETRIES..."
if curl -f -s "$HEALTH_URL" > /dev/null; then
echo"✅ 健康检查通过！"
exit 0
fi
if [ $i -lt $MAX_RETRIES ]; then
echo"健康检查失败，等待 ${RETRY_INTERVAL}s 后重试..."
sleep $RETRY_INTERVAL
fi
done
echo"❌ 健康检查失败！"
exit 1
安全加固别忽略
跑服务的用户别用root，单独建一个权限最小的用户：
# 创建专用用户，不能登录
sudo useradd -r -s /bin/false myapp
# 设置目录权限
sudo chown -R myapp:myapp /opt/myapp
sudo chmod 755 /opt/myapp/bin/myapp
sudo chmod 644 /opt/myapp/configs/*
# 敏感配置文件单独设权限
sudo chmod 600 /opt/myapp/configs/secret.yaml
资源限制也建议加上，防止某个服务把整台机器拖垮：
[Service]
CPUQuota=50%
MemoryLimit=1G
LimitNOFILE=65535
LimitNPROC=65535
LimitCORE=0
几种方案怎么选
| | | |
|---|
| systemd | | | |
| Supervisor | | | |
| Docker | | | |
| nohup | | | |
我的建议是：Linux生产环境无脑systemd，如果已经上了K8s那就用容器编排，nohup和supervisor只留在开发机里。
今晚就给你的服务配个"保姆"
别等到半夜被电话叫醒才想起配systemd。现在就花二十分钟，给你的Go服务写个service文件，测试一下启动、停止、重启、开机自启。然后写一个deploy.sh，下次发版的时候一键搞定。
你现在的Go服务是怎么部署的？还在用nohup吗？还是已经上了Docker或K8s？评论区聊聊你的部署方案，我看看有没有比systemd更省心的姿势。
💡 systemd守护进程是Linux服务管理的标准，掌握它让你的Go程序稳定运行！
