Conceptos básicos de la CLI de Linux

10 ejemplos para empezar con la CLI de Linux para ingenieros de Go: 7 básicos y 3 intermedios.

Prerrequisitos

• Una shell de Linux (Linux nativo, WSL2 o Terminal de macOS para la mayoría de los ejemplos).
• Go 1.26.x o posterior instalado y en tu PATH (go version).
• Un módulo de ejemplo: mkdir goshell && cd goshell && go mod init example.com/goshell.
• Opcional: acceso sudo si pruebas el ejemplo journalctl en un host con systemd.

Ejemplos básicos

1. Encuentra la raíz de tu módulo

pwd imprime el directorio de trabajo; combínalo con ls para confirmar que go.mod está presente.

pwd
ls -la go.mod

• Ejecuta comandos desde la raíz del módulo para que go test ./... resuelva los paquetes correctamente.
• ls -la muestra archivos ocultos como .env que herramientas como direnv pueden cargar.
• La autocompletación con Tab en los nombres de directorio reduce los errores tipográficos en rutas largas de monorepos.

Relacionado: Go Toolchain en Linux: Instalación y cambio de versión - PATH y disposición de la toolchain

2. Lista paquetes y binarios

tree (o find) muestra la disposición antes de ejecutar pruebas generales.

# instala tree si falta: sudo apt install tree
tree -L 2 -I vendor
go build -o bin/api ./cmd/api 2>/dev/null || echo "ajusta ./cmd/api a tu disposición"
ls -lh bin/

• -L 2 limita la profundidad para que los repositorios enormes sigan siendo legibles.
• -I vendor omite los árboles empaquetados durante una orientación rápida.
• go build -o coloca los artefactos en un directorio bin/ predecible para systemd o docker COPY.

Relacionado: Compilar, probar y perfilar desde la shell - bucles de compilación y prueba

3. Localiza un símbolo con ripgrep

Busca código Go más rápido que grep recursivo.

# instala: sudo apt install ripgrep  # o brew install ripgrep
rg -n "func main" --glob '*.go'
rg -n "ListenAndServe" cmd/ internal/

• -n imprime números de línea para saltos rápidos en el editor.
• --glob '*.go' ignora el ruido de markdown y YAML.
• ripgrep respeta .gitignore por defecto, omitiendo vendor/ cuando está ignorado.

Relacionado: Buscar, ripgrep y jq para depurar - patrones de búsqueda avanzados

4. Sigue los logs de la aplicación

Sigue los logs en tiempo real mientras pruebas un endpoint.

# la app escribe en un archivo
touch app.log
tail -f app.log
 
# otra terminal: curl -s localhost:8080/healthz >> app.log

• tail -f se bloquea hasta que llegan nuevas líneas, ideal mientras reproduces un error.
• Prefiere logs JSON estructurados para que un pase posterior de jq pueda filtrar por nivel.
• Rota archivos grandes con logrotate o límites de volumen en contenedores.

Relacionado: Buscar, ripgrep y jq para depurar - jq en logs JSON

5. Inspecciona un proceso Go en ejecución

Encuentra el PID y qué puerto ocupa.

pgrep -a api          # reemplaza 'api' con el nombre de tu binario
PID=$(pgrep -n api)
ps -p "$PID" -o pid,cmd,%cpu,%mem,etime
ss -ltnp | grep "$PID"    # o: lsof -Pan -p "$PID" -i

• pgrep -a muestra la línea de comandos, confirma que te has adjuntado al binario correcto.
• ss -ltnp mapea sockets a PIDs en Linux moderno (netstat es obsoleto).
• Coincide con el nombre del binario que estableciste con go build -o api.

Relacionado: systemd y archivos de unidad de servicio para binarios Go - procesos supervisados

6. Envía señales de apagado elegante y forzado

Practica SIGTERM antes de recurrir a kill -9.

PID=$(pgrep -n api)
kill -TERM "$PID"     # la misma señal que systemd stop usa primero
sleep 2
kill -0 "$PID" 2>/dev/null && echo "sigue en ejecución" || echo "ha salido"
# último recurso solamente:
# kill -KILL "$PID"

• Los servidores Go deben capturar SIGTERM y llamar a http.Server.Shutdown.
• kill -0 comprueba la existencia sin enviar una señal.
• SIGKILL no se puede capturar; úsalo solo cuando el apagado elegante se cuelgue.

Relacionado: Habilidades de la CLI de Linux para ingenieros de Go - señales y operaciones

7. Exporta variables de entorno de compilación

Compila cruzado desde la shell sin editar código.

export GOOS=linux GOARCH=amd64 CGO_ENABLED=0
go build -o dist/api-linux-amd64 ./cmd/api
file dist/api-linux-amd64
unset GOOS GOARCH

• CGO_ENABLED=0 produce un binario estático amigable para imágenes de contenedor mínimas.
• file confirma ELF vs Mach-O para que no envíes el artefacto incorrecto.
• Restablece las variables después de la compilación para que go test local use tu plataforma nativa.

Relacionado: Go Toolchain en Linux: Instalación y cambio de versión - GOTOOLCHAIN y versiones

Ejemplos intermedios

8. Lee el Journal de systemd para un servicio

Correlaciona reinicios de servicio con mensajes del kernel o OOM.

sudo systemctl status api.service
sudo journalctl -u api.service -n 100 --no-pager
sudo journalctl -u api.service -f

• -u filtra por nombre de unidad; coincide con tu archivo .service.
• -n 100 limita la salida inicial antes del modo de seguimiento.
• Las marcas de tiempo del Journal ayudan a alinear las trazas de pila de pánico de Go con los eventos de despliegue.

Relacionado: systemd y archivos de unidad de servicio para binarios Go - archivos de unidad

9. Filtra logs JSON con jq

Cuenta líneas de nivel de error y muestra un campo de traza de pila de ejemplo.

cat app.json.log | jq -c 'select(.level=="ERROR")' | head
cat app.json.log | jq -s 'map(select(.level=="ERROR")) | length'

• -c imprime un objeto JSON compacto por línea para su posterior canalización.
• -s carga el archivo en un array para agregados (funciona bien para archivos modestos).
• Para logs enormes, usa primero rg '"level":"ERROR"', luego jq en el subconjunto.

Relacionado: Buscar, ripgrep y jq para depurar - recetas de jq

10. Canaliza la salida de pruebas a un archivo y busca fallos

Captura la salida similar a CI localmente, luego busca fallos con ripgrep.

go test ./... -count=1 2>&1 | tee test.out
rg -n "FAIL:|panic:" test.out
rg -n "--- FAIL:" test.out -A 3

• 2>&1 fusiona stderr en stdout para que los pánicos no se pierdan.
• -count=1 deshabilita la caché de pruebas cuando necesitas una señal fresca.
• tee mantiene un archivo para informes de errores mientras observas la terminal.

Relacionado: Compilar, probar y perfilar desde la shell - bucles de prueba y perfilado

Versiones de la pila: Esta página fue escrita para Go 1.26.x (predeterminado Green Tea GC, go fix modernizers - verifica el parche en la compilación), chi (última versión - verifica en la compilación), gin (última versión - verifica en la compilación), echo (última versión - verifica en la compilación), google.golang.org/grpc (última versión - verifica en la compilación), sigs.k8s.io/controller-runtime (última versión - verifica en la compilación), kubebuilder (última versión - verifica en la compilación), tinygo (última versión - verifica objetivos de placa en la compilación), wazero (última versión - verifica en la compilación) y golangci-lint (última versión - verifica el conjunto de linters en la compilación).