Tutoriales de VPS
Go en una VPS: compilación cruzada, systemd, Nginx y memoria
Compile Go para Linux, publique recursos, supervise con systemd y configure Nginx HTTPS. Ajuste GOMEMLIMIT, revise CPU de contenedores, implemente apagado ordenado y compruebe la reversión de versiones.

Una aplicación escrita íntegramente en Go puede desplegarse como un binario sin instalar el compilador en la VPS. Compile localmente o en CI, transfiera el resultado y supervise el proceso. El enlace estático tiene condiciones: CGO, archivos externos, certificados y datos horarios necesitan atención. Los fallos habituales incluyen Exec format error, cargadores o recursos ausentes y presión de memoria.
Esta guía para Ubuntu 24.04 cubre compilación cruzada, recursos, systemd, memoria, apagado ordenado, Nginx y publicaciones recuperables. Un despliegue basado en reiniciar puede interrumpir brevemente el servicio; la continuidad requiere una estrategia adicional probada.
Ventajas:
- La VPS de ejecución no necesita el compilador Go.
- Las dependencias compiladas no cambian cuando se actualiza un paquete remoto; conserve binario, archivos de bloqueo e identidad del build.
- Inicio y memoria pueden ajustarse a máquinas pequeñas, según la aplicación.
- macOS y Windows pueden generar binarios Linux si las dependencias admiten el destino.
Límites:
- Plantillas y archivos frontend requieren incorporación o publicación explícita.
- CGO puede exigir cargador y bibliotecas dinámicas.
- Un presupuesto de memoria ayuda, pero no evita cualquier OOM.
- La aplicación debe gestionar el apagado; systemd no termina solicitudes por ella.
Ejemplo para Linux:
CGO_ENABLED=0 GOOS=linux GOARCH=amd64 \
go build \
-trimpath \
-ldflags="-s -w -X main.version=$(git rev-parse --short HEAD)" \
-o dist/myapp ./cmd/myapp
CGO_ENABLED=0 desactiva CGO. Con dependencias compatibles de Go puro evita necesitar una biblioteca C. Con CGO puede haber dependencia de glibc y su cargador; Ubuntu, Debian y Alpine con musl no son intercambiables automáticamente. Inspeccione el binario generado.
GOOS=linux GOARCH=amd64 selecciona plataforma:
| Arquitectura VPS | GOARCH |
|---|---|
| x86_64 / amd64 | amd64 |
| ARM64 | arm64 |
En la VPS ejecute uname -m: x86_64 indica amd64 y aarch64 arm64. Véase elección de ARM.
-trimpath elimina rutas locales y facilita reproducibilidad. -s -w elimina símbolos y secciones de depuración; la reducción del 20–30% citada es ilustrativa y las trazas normales de panic suelen seguir disponibles. Conserve un build de depuración cuando lo necesite.
-X main.version=... establece una variable string con el commit:
var version = "dev"
func main() {
log.Printf("starting myapp version=%s", version)
// ...
}
Ajuste la ruta real del paquete y conserve fuentes y dependencias. Si necesita CGO, compile en un entorno compatible o configure una cadena C de compilación cruzada, incluido musl cuando busque un estático compatible. CGO sí puede compilarse de forma cruzada con las herramientas adecuadas; cambiar solo GOARCH no basta.
Un binario normal no incluye automáticamente plantillas, CSS, imágenes ni builds frontend.
import (
"embed"
"html/template"
"net/http"
)
//go:embed templates/*.html static/*
var assets embed.FS
func main() {
tpl := template.Must(template.ParseFS(assets, "templates/*.html"))
http.Handle("/static/", http.FileServer(http.FS(assets)))
_ = tpl
http.ListenAndServe("127.0.0.1:3000", nil)
}
Incorporarlos une recursos y binario para simplificar reversión. Con //go:embed:
../no puede salir del árbol permitido;- el recorrido suele excluir nombres que empiezan por
_o.; use//go:embed all:staticsi necesita incluirlos deliberadamente.
Revise patrones y rutas; no incluya credenciales ni archivos de desarrollo por accidente.
Nginx puede servir el frontend en lugar de http.FileServer de Go. El rendimiento depende de caché, disco y carga; no es una superioridad universal.
| Elección | Recursos incorporados | Archivos externos con Nginx |
|---|---|---|
| Despliegue | Un artefacto conjunto | Coordinar binario y archivos |
| Entrega | Proceso Go | Proxy directamente |
| Cambios frontend | Recompilar | Publicar archivos versionados |
| Tamaño del binario | Incluye recursos | No aumenta por archivos externos |
Una opción práctica usa go:embed para plantillas y frontend externo versionado. Retenga los recursos de la versión de reversión.
Un programa en primer plano encaja con Type=simple. Guarde /etc/systemd/system/myapp.service:
[Unit]
Description=Go App
After=network.target
[Service]
Type=simple
User=appuser
Group=appuser
WorkingDirectory=/srv/app/current
EnvironmentFile=/srv/app/shared/.env
Environment=GOMEMLIMIT=400MiB
ExecStart=/srv/app/current/myapp
Restart=always
RestartSec=3
# 优雅退出:给 15 秒处理完在途请求
KillSignal=SIGTERM
TimeoutStopSec=15
StandardOutput=journal
StandardError=journal
SyslogIdentifier=myapp
# 资源与安全限制
MemoryMax=512M
LimitNOFILE=65535
NoNewPrivileges=true
PrivateTmp=true
ProtectSystem=strict
ProtectHome=true
ReadWritePaths=/srv/app/shared
[Install]
WantedBy=multi-user.target
Antes de habilitarlo, cree appuser, /srv/app/releases y /srv/app/shared, instale el ejecutable con propietario adecuado, prepare current y un archivo de variables protegido. La cuenta de despliegue necesita permisos limitados para reiniciar el servicio.
WorkingDirectoryimporta para./config.yamly./templates; rutas absolutas ogo:embedevitan confusiones.EnvironmentFileapunta ashared/.envpara conservar secretos. systemd lo lee; Go debe consumir las variables previstas.ProtectSystem=strictvuelve casi todo de solo lectura. Declare directorios de subidas/logs/caché enReadWritePathspara evitarRead-only file system. Proteja.envcontra escritura de la aplicación.
sudo systemctl daemon-reload
sudo systemctl enable --now myapp
sudo systemctl status myapp
GOGC=100 establece un objetivo de crecimiento del recolector, no una regla de que solo recoja cuando se duplique todo el RSS. GOMEMLIMIT, introducido en Go 1.19, fija un límite flexible de memoria administrada por el runtime:
Environment=GOMEMLIMIT=400MiB
El original sugiere margen del 20–30% bajo el límite de proceso/cgroup, como MemoryMax=512M y GOMEMLIMIT=400MiB. Mídalo: stacks y estructuras administrados por Go ya se incluyen; memoria de CGO, mmap directo y algunos recursos del sistema quedan fuera. Un heap vivo grande puede exceder el límite flexible, y uno demasiado bajo puede provocar mucho trabajo de GC.
El límite duro sigue siendo MemoryMax de systemd o --memory de Docker. Coordine ambos y supervise OOM.
El ejemplo pprof original:
import _ "net/http/pprof"
go func() {
log.Println(http.ListenAndServe("127.0.0.1:6060", nil))
}()
Use túnel SSH para http://localhost:6060/debug/pprof/heap, con el listener de depuración solo en 127.0.0.1. Use un ServeMux de depuración separado: importar pprof registra handlers en DefaultServeMux; usar el mismo mux en la aplicación puede exponerlos mediante Nginx aunque 6060 sea privado. Los perfiles revelan información sensible: proteja el acceso y retire exposición innecesaria.
Los runtimes anteriores podían usar las CPU del host pese a una cuota inferior, motivando GOMAXPROCS=1. Go 1.25 incorpora valores Linux basados en cgroups y ajuste periódico de GOMAXPROCS.
Una cuota de una CPU no garantiza un valor predeterminado de uno: el cálculo normalmente tiene mínimo de dos salvo límites inferiores de CPU lógicas/afinidad, y redondea cuotas fraccionarias hacia arriba. También influyen la versión de lenguaje y los valores explícitos. Evalúe si sigue necesitando GOMAXPROCS. GODEBUG=containermaxprocs=0 desactiva la consideración de cuota y establecer GOMAXPROCS manualmente altera el automatismo. Consulte Go 1.25.
Go mantiene las dos familias más recientes. 1.27.1/1.26.8 y la retirada de 1.25 del artículo de septiembre son datos históricos. La lista oficial consultada el 16 de noviembre de 2026 muestra 1.27.4 y 1.26.11. Construya con una versión soportada y actualizada, pruebe y despliegue: un binario existente no recibe parches por sí solo.
systemctl restart detiene el proceso anterior con SIGTERM. Sin manejar señales se interrumpen peticiones activas:
srv := &http.Server{
Addr: "127.0.0.1:3000",
Handler: mux,
ReadTimeout: 15 * time.Second,
WriteTimeout: 30 * time.Second,
IdleTimeout: 60 * time.Second,
}
go func() {
if err := srv.ListenAndServe(); err != nil && err != http.ErrServerClosed {
log.Fatalf("listen: %v", err)
}
}()
quit := make(chan os.Signal, 1)
signal.Notify(quit, syscall.SIGINT, syscall.SIGTERM)
<-quit
log.Println("shutting down...")
ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
defer cancel()
if err := srv.Shutdown(ctx); err != nil {
log.Fatal("forced shutdown:", err)
}
log.Println("server exited")
srv.Shutdown(ctx)deja de aceptar conexiones y espera solicitudes HTTP activas normales.- El plazo debe ser menor que
TimeoutStopSec; aquí 10 segundos caben en 15, pero solicitudes largas requieren plan de drenaje. - Gestione
SIGTERM, no soloSIGINT. http.Servertiene plazos cero por defecto. ConfigureReadTimeout,WriteTimeouty límites de cabeceras/inactividad; streaming necesita otros plazos.
Shutdown no cierra automáticamente WebSockets secuestrados ni termina todo trabajo en background. Contrólelos aparte. El cierre ordenado ayuda a solicitudes en curso, pero reiniciar una única instancia deja un intervalo sin listener.
Go escucha en 127.0.0.1:3000; Nginx publica HTTP/HTTPS:
upstream goapp {
server 127.0.0.1:3000;
keepalive 32;
}
server {
listen 80;
listen [::]:80;
server_name app.example.com;
client_max_body_size 20m;
access_log /var/log/nginx/app.access.log;
error_log /var/log/nginx/app.error.log warn;
location / {
proxy_pass http://goapp;
proxy_http_version 1.1;
proxy_set_header Host $host;
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_set_header X-Forwarded-Proto $scheme;
proxy_set_header Connection "";
proxy_connect_timeout 5s;
proxy_read_timeout 60s;
}
# WebSocket / SSE(Go 里很常见)
location /ws/ {
proxy_pass http://goapp;
proxy_http_version 1.1;
proxy_set_header Upgrade $http_upgrade;
proxy_set_header Connection "upgrade";
proxy_set_header Host $host;
proxy_read_timeout 3600s;
proxy_buffering off;
}
}
sudo nginx -t && sudo systemctl reload nginx
Añada HTTPS con Certbot tras comprobar DNS y 80/443 públicos, pruebe la renovación o consulte Caddy. Guarde el archivo en un directorio que Nginx cargue y revise firewalls del proveedor/UFW.
Reenvíe X-Forwarded-For, pero r.RemoteAddr sigue identificando al proxy conectado, a menudo 127.0.0.1. La aplicación debe interpretar cabeceras únicamente de proxies de confianza; enviarlas no cambia RemoteAddr automáticamente. /ws/ también necesita las cabeceras de cliente/protocolo pertinentes. SSE no requiere Upgrade de WebSocket, pero sí buffering y plazos adecuados.
Script original:
#!/usr/bin/env bash
set -euo pipefail
HOST=deploy@your-vps
RELEASE=$(date +%Y%m%d-%H%M%S)
TARGET=/srv/app/releases/$RELEASE
# 1. 本地编译
CGO_ENABLED=0 GOOS=linux GOARCH=amd64 go build \
-trimpath \
-ldflags="-s -w -X main.version=$(git rev-parse --short HEAD)" \
-o /tmp/myapp ./cmd/myapp
# 2. 传输
ssh "$HOST" "mkdir -p $TARGET"
scp /tmp/myapp "$HOST:$TARGET/myapp"
# 3. 切换并重启
ssh "$HOST" "chmod +x $TARGET/myapp && \
ln -sfn $TARGET /srv/app/current && \
sudo systemctl restart myapp"
# 4. 清理旧版本,保留最近 5 个
ssh "$HOST" "ls -1dt /srv/app/releases/* | tail -n +6 | xargs -r rm -rf"
Mantenga set -euo pipefail para no cambiar current a un archivo antiguo o ausente tras fallar el build. Sustituya host y rutas, verifique claves SSH, registre commit/hash y asegure permisos del usuario de ejecución.
Guarde el destino anterior antes de cambiar. Tras reiniciar, compruebe versión activa y salud local/pública. Si falla, restaure el enlace y reinicie la versión anterior. Limpie solamente después de validar salud, reteniendo versiones activa y de reversión; conservar cinco no garantiza recuperación. Para continuidad, arranque otra instancia en un puerto privado distinto, valide disponibilidad, cambie el proxy y drene la anterior. Véase runner GitHub Actions para builds CI.
cannot execute binary file: Exec format error suele indicar amd64 frente a arm64. Compruebe uname -m y reconstruya para el destino.
No such file or directory puede significar ausencia del cargador dinámico o intérprete. Inspeccione:
file ./myapp # 看是 statically linked 还是 dynamically linked
ldd ./myapp # 动态链接的话,看依赖什么
Use CGO_ENABLED=0 solo si las dependencias admiten Go puro; de lo contrario aporte el entorno compatible de bibliotecas/cargador.
Para permission denied, revise propietario, chmod +x myapp, política noexec, directorios y escritura bloqueada por ProtectSystem=strict. Consulte journalctl -u myapp para identificar la operación.
Revise WorkingDirectory, rutas absolutas y archivos desplegados. go:embed puede facilitar su publicación conjunta.
Configure GOMEMLIMIT y perfile asignaciones/goroutines. Cuerpos de respuesta sin Close() y time.Ticker sin Stop() pueden retener recursos; revise sus ciclos de vida reales. Swap/ZRAM amortigua presión pero no repara fugas.
Las ocho horas del original corresponden al ejemplo Asia/Shanghai frente a UTC, no a la zona de todo lector. Elija UTC o la zona IANA requerida y aporte datos horarios. Puede incorporarlos con -tags timetzdata:
go build -tags timetzdata -o dist/myapp ./cmd/myapp
Mantenga los demás flags de plataforma y enlace estático; este ejemplo horario no los sustituye.
Revise systemctl status myapp y si localhost resuelve de forma distinta a 127.0.0.1. Véase diagnóstico 502/504.
sudo ss -lntp 'sport = :3000' identifica al propietario; no mate servicios ajenos. Consulte conflictos de puertos y registros.
FROM scratch permite una imagen pequeña de Go puro, pero menos de 20 MB es un ejemplo condicionado al proyecto. Incluya certificados CA, datos horarios y archivos necesarios. Un único servicio puede ser más sencillo con systemd; Compose ayuda a coordinar varios.
| Elección | systemd | Docker |
|---|---|---|
| Artefacto | Binario y archivos necesarios | Imagen |
| Aislamiento | Sandbox de servicio configurado | Aislamiento configurado; privilegios/montajes pueden debilitarlo |
| Tamaño | Depende de la aplicación | Un ejemplo scratch puede ser menor de 20 MB |
| Varios servicios | Unidades y configuración separadas | Compose |
| Diagnóstico | Servicio del host | Capa adicional de contenedor/red |
Elija por necesidades operativas, no una clasificación universal de seguridad. Véase límites Compose. La CPU depende del trabajo: GC y planificación pueden usar varios núcleos y no hay garantía de poca memoria. RackNerd anual y Vultr por horas son opciones a verificar; CN2 GIA de DMIT responde específicamente a conectividad con China continental. Consulte dimensionamiento.
- Node.js para otro servicio;
- Python para Django/FastAPI;
- Dimensionamiento VPS para recursos medidos;
- Docker para contenedores;
- Ensayos de recuperación para banco, subidas y secretos: revertir el binario no restaura datos ni deshace migraciones.