6 · Herramientas del oficioLección 1 de 6
La terminal y la shell
The terminal and the shell
Qué es la pantalla negra donde se escriben comandos, cómo los lee la shell, qué hereda cada programa que lanzas y cómo se encadenan comandos chicos para encontrar una aguja en un log de 3 GB.
Secciones14
- 01La terminal y la shell
- 02Cómo lee la shell una línea
- 03Lo que hereda cada proceso: carpeta, variables y PATH
- 04Tres flujos y cómo desviarlos
- 05Tuberías: comandos chicos que se encadenan
- 06Scripts: shebang, permisos y set -euo pipefail extra
- 07Entrar al servidor: ssh, sudo y kubectl logs
- 08Procesos desde la terminal extra
- 09Errores comunes
- 10En la vida real extra
- 11Ejercicios
- 12Lo que sigue
- 13Palabras que vas a oír
- 14Chequeo
Cuando un ML engineer entra a la máquina donde corre el gateway de Alba, ¿qué es esa pantalla donde escribe, qué pasa entre que teclea `kubectl logs gateway-7f9c` y ve las líneas, y cómo junta comandos chicos para encontrar los errores de una sola request?
Alba, la empresa que seguimos en todo el curso, es un marketplace: recibe ≈ 2.5 millones de publicaciones al día y le sugiere a quien vende la categoría de cada foto, entre 500 posibles. Su gateway, el servicio que recibe cada foto y se la pasa al modelo, atiende ≈ 10 millones de requests al día, una por foto: ≈ 7.5 millones de las publicaciones (≈ 3 fotos cada una) y ≈ 2.5 millones que piden otros equipos de Alba.
Son las 3 de la mañana y suena una alerta: el gateway de Alba está respondiendo más errores 504 que de costumbre. Marta, que está de guardia, no abre una página web ni una app con botones. Abre una ventana con fondo oscuro y escribe:
kubectl logs -n classifier gateway-7f9c --since=10m | grep '"status":504' | wc -lUn segundo después aparece un número: 37. En diez minutos, 37 requests de ese pod (una de las copias del gateway que corren en Kubernetes) terminaron en 504. (Esta línea necesita un clúster de Kubernetes, así que aquí no se corre: el 37 es de ejemplo.) Con otra línea encuentra la request 9f2c41d0 que un usuario reportó y lee qué le pasó.
Para quien no lo ha visto, eso parece magia o un idioma secreto. No es ninguna de las dos. Son cuatro ideas: una ventana, un programa que lee lo que escribes, unos programas chicos que hacen una sola cosa y unos tubos que los conectan. Al terminar esta lección vas a poder leer esa línea palabra por palabra, y escribir las tuyas.
La terminal y la shell
EsencialThe terminal and the shell
En la lección «Qué es un programa y qué es un proceso» viste que una terminal es una de esas ventanas donde se escriben comandos en vez de usar el mouse. Aquí la abrimos por dentro, porque en realidad son dos programas distintos que trabajan juntos.
La ventana: la terminal
La terminal (terminal, o terminal emulator) es el programa que dibuja la ventana. Hace dos cosas: manda a otro programa lo que tecleas y dibuja en pantalla el texto que ese programa le regresa. Nada más. No sabe qué es ls ni qué es un archivo.
Cada sistema trae la suya:
- macOS trae la app Terminal; mucha gente usa también iTerm2 o la terminal de su editor de código.
- Windows 11 trae Windows Terminal (en Windows 10 se instala aparte, desde la Microsoft Store). Para tener un Linux de verdad dentro de Windows existe WSL2 (Windows Subsystem for Linux): corre un kernel de Linux en una máquina virtual ligera, y su terminal se ve igual que la de un servidor.
- Linux trae varias, como GNOME Terminal.
Se llama «emulador» porque imita a las terminales de los años setenta: un teclado con pantalla, conectado por cable a una computadora grande.
El programa que lee: la shell
La shell (shell, «concha») es el programa que corre dentro de la ventana. Lee la línea que escribes, la interpreta y lanza los programas que pediste. Se llama así porque es la capa de afuera del sistema operativo: la que tocas tú, alrededor del kernel.
Hay varias, y casi todas entienden lo mismo:
| Shell | Dónde la vas a ver |
|---|---|
| bash | La de casi todos los servidores Linux y la de las imágenes de Debian y Ubuntu, como la python:3.13-slim del gateway de Alba |
| zsh | La de macOS desde Catalina (2019), en las cuentas nuevas. Entiende casi todo lo de bash, con algunas diferencias que verás aquí |
| sh | La más básica, la que exige POSIX, el estándar que comparten los sistemas tipo Unix, como Linux y macOS. En los contenedores chicos (Alpine, o los que solo traen BusyBox, un solo programa que imita a cientos de comandos) a veces es la única |
Hay imágenes que no traen ninguna: una imagen distroless, que trae solo el programa y lo mínimo para correrlo, no trae shell, así que no hay dónde escribir comandos adentro.
El prompt y el ciclo
Cuando la shell está lista para recibir algo, escribe el prompt (prompt, «invitación»): un texto corto al principio de la línea, como marta@laptop ~ % en zsh o marta@gw-node:~$ en bash. Casi siempre dice quién eres, en qué máquina estás y en qué carpeta (~ es tu carpeta personal). Léelo siempre: es la forma más rápida de saber si estás en tu laptop o en un servidor de producción. Para un usuario normal termina en $ en bash y en % en zsh; si eres root, en #.
Desde ahí, la shell repite el mismo ciclo para cada línea:
- 1
Lee
Espera a que aprietes Enter y lee la línea completa.
- 2
Parte y expande
Corta la línea en palabras y reemplaza lo que haya que reemplazar: variables, comodines,
~. Lo ves en la siguiente sección. - 3
Busca
Toma la primera palabra y averigua qué es: algo que ella misma sabe hacer o un programa en el disco.
- 4
Lanza
Si es un programa, crea un proceso nuevo con
forkyexec, como viste en la lección de procesos, y le pasa las demás palabras. - 5
Espera
Se queda esperando a que ese proceso termine, guarda su código de salida y vuelve a escribir el prompt.
El comando: un programa o algo de la shell
Un comando (command) es lo que escribes en una línea para pedir algo: una palabra con un significado, seguida de lo que le quieras pasar. En ls /models, el comando es ls (lista una carpeta) y /models es lo que le pasas.
La primera palabra puede ser dos cosas:
- Un programa en el disco, un binario ejecutable o un script.
ls,grep,python3ykubectlson archivos que viven en alguna carpeta, como/usr/bin/ls. - Un builtin (builtin, «integrado»): algo que la shell hace por sí misma, sin lanzar ningún proceso.
cd,export,echo(imprime lo que le pases) ytypeson builtins.
¿Por qué cd no puede ser un programa aparte? Porque cambia la carpeta del proceso que lo corre. Si fuera un programa, cambiaría la carpeta de un hijo que muere un instante después, y la shell seguiría donde estaba.
Para saber qué es cada palabra hay dos comandos. type es un builtin que te dice cómo la va a entender la shell: type cd responde cd is a shell builtin, y type ls, ls is /usr/bin/ls. which ls responde solo la ruta del programa. En bash, which es un programa aparte que no sabe de builtins; en zsh viene integrado.
Cómo lee la shell una línea
EsencialHow the shell reads a line
Antes de lanzar nada, la shell convierte tu línea en una lista de palabras. Entender ese paso evita la mitad de los sustos de la terminal.
Argumentos y opciones
Todo lo que va después del comando son sus argumentos (arguments). La shell los separa por los espacios y se los entrega al programa como una lista de textos. El programa decide qué significa cada uno. Por costumbre hay dos clases:
- Opciones o flags: empiezan con guion y cambian cómo trabaja el programa. Las cortas llevan un guion y una letra,
-n; las largas, dos guiones y una palabra,--lines. Son la misma opción:tail -n 20 gateway.logytail --lines=20 gateway.logmuestran las últimas 20 líneas. Muchas cortas se pueden juntar:ls -laesls -l -a(lista larga, con permisos y tamaños, y con los archivos ocultos). - Argumentos posicionales: lo demás, casi siempre los archivos o las cosas sobre las que trabaja. En
tail -n 20 gateway.log, el20es el valor de-nygateway.loges el posicional.
Las opciones largas son, sobre todo, cosa de los programas de GNU, los que trae Linux. Los de macOS vienen de BSD, otra familia, y muchas veces solo entienden las cortas: en una Mac (macOS 26), wc --lines gateway.log (wc cuenta; con -l, las líneas) falla con illegal option, aunque wc -l gateway.log funciona. Algunos, como head y tail, ya aceptan --lines: no adivines, pregúntale al programa. Para saber qué acepta un programa, casi todos responden a --help, y man tail abre su manual. Un buen consejo: no memorices los flags de docker run; --help existe.
Las comillas: un espacio es un separador
Como el espacio separa argumentos, un nombre con espacios se parte. Si tienes un archivo que se llama mis fotos y escribes rm mis fotos, el programa rm (borra archivos) recibe dos argumentos, mis y fotos, y trata de borrar dos archivos que no son el tuyo. Si existen, los borra. Para que un texto con espacios sea un solo argumento, va entre comillas.
- Comillas dobles
"…": juntan todo en un argumento, pero la shell todavía reemplaza las variables de adentro. - Comillas simples
'…': juntan todo y no reemplazan nada. Lo que escribes llega tal cual.
Una variable de la shell es un nombre que guarda un texto: nombre="mis fotos" la crea y $nombre la lee. La sección que sigue las cuenta a fondo.
El programa printf '[%s]\n' imprime cada argumento que recibe entre corchetes, en su propia línea. Es la forma más honesta de ver qué palabras armó la shell. Este bloque, y todos los de la lección, corre en un contenedor de Linux con bash 5, en una carpeta vacía:
touch "mis fotos" mis fotos # touch crea archivos vacíos: aquí, tres
ls
printf '[%s]\n' mis fotos # sin comillas: dos argumentos
printf '[%s]\n' "mis fotos" # con comillas: uno
rm mis fotos # borra «mis» y «fotos»…
ls # …y deja «mis fotos»
nombre="mis fotos"
printf '[%s]\n' $nombre "$nombre" '$nombre'fotos
mis
mis fotos
[mis]
[fotos]
[mis fotos]
mis fotos
[mis]
[fotos]
[mis fotos]
[$nombre]La última línea es la regla de oro: una variable sin comillas se parte en los espacios que traiga. Escribe siempre "$variable", entre comillas dobles. El # empieza un comentario: lo que sigue hasta el final de la línea, la shell lo ignora.
Una línea larga, partida
Los comandos largos, como los de Docker, a veces no caben en una línea, y se parten con una diagonal invertida \ al final:
docker run --rm --gpus all mi-servicio:3f9c2ab \
python -c "import torch; print(torch.cuda.is_available())"La \ le dice a la shell «la línea sigue abajo». Tiene que ser lo último de la línea: si después de ella queda un espacio invisible, la \ protege ese espacio en vez del salto de línea, el comando termina ahí y la línea de abajo se vuelve otro comando. Este de arriba es una ilustración (lanza un contenedor y le pregunta a PyTorch si ve la GPU): necesita Docker y una GPU.
Comodines: la shell completa los nombres
Un comodín (wildcard, y al proceso se le dice globbing) es un carácter que la shell reemplaza por los nombres de archivo que coinciden con un patrón:
*coincide con cualquier texto, incluso vacío:*.logson todos los nombres que terminan en.log.?coincide con exactamente un carácter:gateway-?.log.[12]coincide con uno de los caracteres de la lista:gateway-[12].log.
Lo importante: el reemplazo lo hace la shell, antes de lanzar el programa. ls nunca ve el asterisco: recibe la lista de nombres ya hecha. Por eso ls *.log y ls "*.log" no son lo mismo: con comillas, la shell no toca el patrón y ls busca un archivo que se llame literalmente *.log.
touch gateway-1.log gateway-2.log triton.log notas.txt
echo *.log
echo gateway-?.log
echo "*.log"
printf '[%s]\n' *.log
ls *.csv
echo "código: $?"gateway-1.log gateway-2.log triton.log
gateway-1.log gateway-2.log
*.log
[gateway-1.log]
[gateway-2.log]
[triton.log]
ls: cannot access '*.csv': No such file or directory
código: 2Fíjate en el *.csv: no había ningún archivo así, y bash le pasó el patrón tal cual a ls, que no encontró un archivo con ese nombre. zsh, la shell de la Mac, se porta distinto: con un patrón que no coincide con nada, ni siquiera lanza el comando y responde zsh: no matches found: *.csv. Los mensajes de error salen en inglés porque así viene configurado el contenedor; $? es el código de salida del último comando, que verás de nuevo más adelante.
Lo que hereda cada proceso: carpeta, variables y PATH
EsencialWhat every process inherits: folder, variables and PATH
Cada vez que la shell lanza un programa, el proceso nuevo nace con tres cosas copiadas de ella: la carpeta donde está parada, sus variables de entorno y los tres flujos de texto. Esta sección cuenta las dos primeras; la que sigue, los flujos.
La carpeta donde estás
En la lección del sistema operativo viste la carpeta de trabajo de un proceso: desde ahí se leen las rutas relativas, las que no empiezan con /. En la terminal se le dice directorio de trabajo (working directory), y la shell lo cambia por ti:
pwd(print working directory) imprime dónde estás.cd carpeta(change directory) te mueve.cd ..sube una;cdsolo te lleva a tu carpeta personal,~;cd -te regresa a donde estabas.lslista lo que hay;mkdir -p a/bcrea carpetas, con todo y las de en medio.
Cada programa que lances arranca en esa carpeta. Si python3 entrenar.py abre datos/train.csv, lo busca dentro de la carpeta donde estabas al lanzarlo, no junto al archivo entrenar.py. Y como cada proceso tiene la suya, un cd dentro de un hijo no mueve al padre. Los paréntesis lanzan una copia de la shell, una subshell:
pwd
mkdir -p proyecto/datos
cd proyecto/datos
pwd
cd ../..
(cd /tmp && pwd)
pwd/home/ana/trabajo
/home/ana/trabajo/proyecto/datos
/tmp
/home/ana/trabajo/tmp es la carpeta de archivos temporales. El && encadena dos comandos: el de la derecha corre solo si el de la izquierda salió bien, con código 0.
Variables de entorno: un diccionario que se hereda
La lección del sistema operativo te presentó PYTHONUNBUFFERED=1 como «un ajuste que el proceso recibe al arrancar». Aquí está el mecanismo completo. Una variable de entorno (environment variable) es un par nombre-valor, los dos de texto, que cada proceso lleva consigo y hereda de su padre al nacer. Juntas forman un diccionario: HOME=/home/ana, USER=ana, LANG=C.UTF-8.
La shell distingue dos clases de variables:
- Variable de la shell:
MODELO=resnet50, sin espacios junto al=. Vive solo en esa shell. Los hijos no la ven. - Variable exportada, o de entorno:
export MODELOla marca para que la hereden todos los hijos que se lancen después.export MODELO=resnet50hace las dos cosas de una vez.
Para leer una variable se le pone $ adelante: echo "$HOME". Para ver todas las de entorno está env. Y si escribes una variable justo antes de un comando, INFER_TIMEOUT_S=0.15 python3 app.py, ese valor entra al entorno de ese proceso y de nadie más.
MODELO=resnet50
bash -c 'echo "el hijo ve: [$MODELO]"'
export MODELO
bash -c 'echo "el hijo ve: [$MODELO]"'
python3 -c 'import os; print("Python ve:", os.environ["MODELO"])'
INFER_TIMEOUT_S=0.15 bash -c 'echo "solo este: [$INFER_TIMEOUT_S]"'
bash -c 'echo "el siguiente: [$INFER_TIMEOUT_S]"'
LINEAS=$(printf 'a\nb\nc\n' | wc -l)
echo "el comando dio $LINEAS líneas · HOME es $HOME"el hijo ve: []
el hijo ve: [resnet50]
Python ve: resnet50
solo este: [0.15]
el siguiente: []
el comando dio 3 líneas · HOME es /home/anabash -c '…' lanza una bash hija que corre ese texto: es la forma más corta de preguntar «¿qué ve un hijo?». El $( … ) de la penúltima línea es la sustitución de comando: la shell corre lo de adentro y pone en su lugar lo que imprimió. Se usa todo el tiempo, por ejemplo TAG=$(git rev-parse --short=7 HEAD) para guardar el id del último cambio del código en una variable.
La herencia va en una sola dirección: de padre a hijo, como una copia al nacer. Un hijo que cambia su variable no cambia la del padre, y un padre que la cambia después no cambia la de un hijo que ya nació. Por eso, si cambias una variable de un servidor que ya está corriendo, hay que reiniciarlo para que la vea.
PATH: dónde busca la shell los programas
Cuando escribes kubectl, ¿cómo sabe la shell en qué carpeta está ese programa? Lee una variable de entorno especial, PATH: una lista de carpetas separadas por :, que la shell revisa en orden. El primer archivo ejecutable que se llame kubectl es el que corre. Si recorre la lista y no lo encuentra, se rinde con command not found y el código 127, el que ya viste en la lección de procesos.
Si la primera palabra trae una /, como ./bin/saluda o /usr/bin/ls, la shell no busca en PATH: va directo a esa ruta. Por eso un script de la carpeta actual se corre con ./.
mkdir bin
printf '#!/bin/sh\necho "hola desde saluda"\n' > bin/saluda
chmod +x bin/saluda
saluda
echo "código: $?"
./bin/saluda
PATH="$HOME/trabajo/bin:$PATH"
type saluda
saluda
echo "$PATH" | tr ':' '\n' | head -n 3bash: line 4: saluda: command not found
código: 127
hola desde saluda
saluda is /home/ana/trabajo/bin/saluda
hola desde saluda
/home/ana/trabajo/bin
/usr/local/bin
/usr/local/sbinLas líneas 2 y 3 del bloque fabrican un programa de una línea y le dan el permiso x, el de ejecución de la lección del sistema operativo. El > escribe en el archivo lo que imprime printf (lo ves en la sección que sigue), y la primera línea del programa, #!/bin/sh, dice con qué se corre (la sección de scripts lo explica). La línea de PATH= pone la carpeta nueva al principio de la lista: así gana sobre cualquier otro saluda del sistema. En la última, cada | le pasa lo que imprime un comando al siguiente (las tuberías tienen su sección): tr cambia cada : por un salto de línea y head -n 3 deja las tres primeras. El mensaje de error dice line 4 porque el bloque corre como script; en una terminal normal, bash dice bash: saluda: command not found y zsh, zsh: command not found: saluda.
Así funciona también un entorno de Python: activarlo pone su carpeta bin al principio de PATH, y por eso python3 pasa a ser el de ese entorno. El gateway de Alba tiene el suyo en /opt/venv. Lo verás en «Python, paquetes y entornos».
Tres flujos y cómo desviarlos
EsencialThree streams and how to redirect them
stdin, stdout y stderr
En la lección del sistema operativo viste que el kernel numera los archivos que tiene abiertos cada proceso, y que a cada número le dice descriptor; que el 1 es la salida del programa, y que hasta un print termina en write(1, …). Todo proceso nace con tres descriptores ya abiertos, que hereda de su padre. Son los flujos estándar (standard streams):
| Descriptor | Nombre | Para qué | En una terminal, va a |
|---|---|---|---|
| 0 | stdin (standard input) | Lo que el programa lee | El teclado |
| 1 | stdout (standard output) | Los resultados | La pantalla |
| 2 | stderr (standard error) | Los errores y los avisos | La pantalla |
¿Por qué dos salidas, si las dos van a la pantalla? Para poder separarlas. Si guardas los resultados de un programa en un archivo, quieres que los errores sigan apareciendo frente a ti y no se mezclen con los datos. Un buen programa escribe su resultado en stdout y todo lo demás, el progreso, los avisos, los errores, en stderr.
El programa no sabe a dónde van sus flujos. Escribe en el 1 y ya. Que el 1 sea la pantalla, un archivo o la entrada de otro programa lo decide quien lo lanzó. En un contenedor, el 1 y el 2 los captura el runtime (el programa que corre los contenedores en la máquina) y los guarda en un archivo de log: por eso docker logs y kubectl logs muestran los dos. Un log (log, «bitácora») es eso: el registro, línea por línea, de lo que un programa va contando. El gateway de Alba escribe una línea JSON por request a stdout y otro programa, Fluent Bit, la recoge y la manda a S3, el almacenamiento de objetos de AWS.
Para ir más hondoLo mismo desde Python+
Python muestra los tres flujos con su módulo subprocess, que lanza un programa hijo como lo haría la shell y captura sus flujos por separado. sys.executable es la ruta del mismo Python que corre el código, -I lo aísla (no carga módulos de tu carpeta ni lee las variables PYTHON…), y repr muestra el texto con sus \n a la vista:
import subprocess, sys
hijo = """
import os, sys
print("top1: Tenis 0.83") # stdout: el flujo 1
print("aviso: Triton tardó 152 ms", file=sys.stderr) # stderr: el flujo 2
print("versión:", os.environ.get("MODEL_VERSION"))
sys.exit(3)
"""
r = subprocess.run([sys.executable, "-I", "-c", hijo], capture_output=True, text=True,
env={"MODEL_VERSION": "resnet50-2026-10-01"})
print("stdout:", repr(r.stdout))
print("stderr:", repr(r.stderr))
print("código de salida:", r.returncode)
r = subprocess.run("printf 'b\\na\\nb\\n' | sort | uniq -c", shell=True,
capture_output=True, text=True)
print("la tubería por /bin/sh:", r.stdout.split())stdout: 'top1: Tenis 0.83\nversión: resnet50-2026-10-01\n'
stderr: 'aviso: Triton tardó 152 ms\n'
código de salida: 3
la tubería por /bin/sh: ['1', 'a', '2', 'b']Tres cosas salen por tres caminos distintos: los resultados, el aviso y el código. Y el env= muestra la herencia: el hijo ve exactamente el entorno que le dio su padre. La última parte, con shell=True, le pasa el texto a /bin/sh, y es la shell la que arma la tubería que verás en la sección que sigue.
Redirección: mandar un flujo a otro lado
La redirección (redirection) le pide a la shell que, antes de lanzar el programa, conecte uno de sus descriptores a un archivo en vez de a la terminal:
| Escribes | Qué hace |
|---|---|
cmd > salida.txt | stdout va al archivo. Si ya existía, lo vacía primero |
cmd >> salida.txt | stdout se agrega al final del archivo |
cmd < datos.txt | stdin sale del archivo en vez del teclado |
cmd 2> errores.txt | stderr va al archivo |
cmd > todo.txt 2>&1 | stdout va al archivo y stderr va a donde vaya stdout: los dos al archivo |
cmd 2> /dev/null | stderr se tira. /dev/null es un archivo especial que se traga todo |
El 2>&1 se lee «que el 2 apunte a donde apunta el 1 en este momento». Y ahí está la trampa: la shell aplica las redirecciones de izquierda a derecha, así que el orden importa.
Aquí ls lista un archivo que existe y otro que no, así que escribe en sus dos salidas:
touch existe.txt
ls existe.txt noexiste.txt > salida.txt
echo "--- salida.txt:"; cat salida.txt
ls existe.txt noexiste.txt > todo.txt 2>&1
echo "--- todo.txt:"; cat todo.txt
ls existe.txt noexiste.txt 2>&1 > alreves.txt
echo "--- alreves.txt:"; cat alreves.txt
ls existe.txt noexiste.txt 2> /dev/null
echo "uno" > a.txt
echo "dos" >> a.txt
wc -l < a.txt
echo "tres" > a.txt
cat a.txtls: cannot access 'noexiste.txt': No such file or directory
--- salida.txt:
existe.txt
--- todo.txt:
ls: cannot access 'noexiste.txt': No such file or directory
existe.txt
ls: cannot access 'noexiste.txt': No such file or directory
--- alreves.txt:
existe.txt
existe.txt
2
trescat imprime el contenido de un archivo, wc -l cuenta líneas y el ; separa dos comandos en la misma línea. Con > solo, el error no entró al archivo: salió en la pantalla. Con > todo.txt 2>&1, los dos entraron. Con el orden al revés, el error volvió a la pantalla. Y la última línea muestra lo peligroso de >: el archivo perdió el «uno» y el «dos» sin preguntar. bash tiene un atajo, &> todo.txt, que manda los dos flujos al archivo sin pensar en el orden.
Tuberías: comandos chicos que se encadenan
EsencialPipes: small commands chained together
El tubo
Una tubería (pipe) conecta el stdout de un programa con el stdin del siguiente. Se escribe con una barra vertical: cmd1 | cmd2. Lo que cmd1 imprime no aparece en la pantalla; entra a cmd2 como si lo estuvieras tecleando.
Por dentro, la shell le pide al kernel un tubo, un pedacito de memoria con dos extremos (en Linux, de 64 KiB), lanza los dos procesos y conecta el descriptor 1 del primero a un extremo y el 0 del segundo al otro. Los dos procesos corren al mismo tiempo. El primero escribe mientras el segundo lee; si el tubo se llena, el que escribe espera, y si se vacía, el que lee espera. Ninguno guarda la salida completa en un archivo intermedio, así que una tubería puede procesar un archivo mucho más grande que la memoria.
Así se trabaja en la terminal desde los años setenta: programas chicos que hacen una sola cosa, unidos por tubos. Los de uso diario:
| Comando | Qué hace con las líneas que le llegan |
|---|---|
grep patrón | Deja pasar solo las que contienen el patrón. -c las cuenta; -v deja pasar las que no lo contienen; -o imprime solo el pedazo que coincidió |
sort | Las ordena. -n como números; -r al revés |
uniq -c | Junta las líneas iguales que vienen seguidas y dice cuántas eran. Por eso casi siempre va después de sort |
wc -l | Cuenta las líneas |
head -n 5, tail -n 5 | Deja pasar las primeras o las últimas 5. tail -f se queda esperando las nuevas |
cut -d: -f2 | Corta cada línea en el carácter : y deja el campo 2 |
awk | Un lenguaje chico para hacer cuentas por columnas: awk '{s += $1} END {print s}' suma la primera columna |
jq | Entiende JSON: jq -r .status saca el campo status de cada línea |
El ejemplo central: los códigos de estado de Alba
El gateway de Alba escribe una línea JSON Lines por request, con su código de estado HTTP. Aquí va una versión chica y simplificada: el log real trae más campos y ≈ 300 bytes por línea, y este agrega una línea con "level":"error" cuando algo falla. El comando cat > gateway.log <<'FIN' escribe en el archivo las líneas que siguen, hasta la palabra FIN (a eso se le dice heredoc).
cat > gateway.log <<'FIN'
{"request_id":"a71e09b2","level":"info","status":200,"ms":41}
{"request_id":"c3d58f10","level":"info","status":200,"ms":38}
{"request_id":"5b90e7aa","level":"info","status":413,"ms":2}
{"request_id":"e4f1c2d9","level":"info","status":200,"ms":44}
{"request_id":"9f2c41d0","level":"error","msg":"Triton no respondió en 0.15 s"}
{"request_id":"9f2c41d0","level":"info","status":504,"ms":152}
{"request_id":"77ab3e01","level":"info","status":200,"ms":40}
{"request_id":"0d6e9b44","level":"info","status":400,"ms":5}
{"request_id":"b18f6c27","level":"info","status":200,"ms":43}
{"request_id":"2c7a0f93","level":"error","msg":"Triton no respondió en 0.15 s"}
{"request_id":"2c7a0f93","level":"info","status":504,"ms":151}
{"request_id":"f05d3a6e","level":"info","status":200,"ms":39}
FIN
wc -l < gateway.log
grep -o '"status":[0-9]*' gateway.log | cut -d: -f2 | sort | uniq -c | sort -rn
grep 9f2c41d0 gateway.log
grep 9f2c41d0 gateway.log | grep -c '"level":"error"'
jq -r 'select(.status) | .status' gateway.log | sort | uniq -c | sort -rn | head -n 212
6 200
2 504
1 413
1 400
{"request_id":"9f2c41d0","level":"error","msg":"Triton no respondió en 0.15 s"}
{"request_id":"9f2c41d0","level":"info","status":504,"ms":152}
1
6 200
2 504Lee la tubería de la segunda línea de izquierda a derecha, como una línea de ensamble:
grep -o '"status":[0-9]*'saca de cada línea solo el pedazo"status":200. El[0-9]*del patrón quiere decir «cualquier cantidad de dígitos». Las líneas de error no tienenstatusy no dejan nada.cut -d: -f2corta en los dos puntos y deja200.sortpone juntos los iguales: los 200, después los 400…uniq -ccuenta cada grupo:6 200.sort -rnordena por ese conteo, del mayor al menor.
La versión con jq hace lo mismo, pero leyendo el JSON de verdad: select(.status) se queda con las líneas que tienen ese campo y .status lo saca. Es más segura, porque grep busca texto exacto: si el log escribiera "status": 200, con un espacio, el patrón de grep no encontraría nada, y jq seguiría funcionando.
- grep -o · saca "status":NNN
grep -o '"status":[0-9]*'lee el archivo línea por línea y, de cada una, deja pasar solo el pedazo que coincide, como"status":504. Las líneas de error no tienenstatus: no dejan nada. Es el filtro: lo pone primero para que a los demás les llegue poco. - cut -d: -f2 · deja el número
Corta cada línea en los dos puntos y deja el segundo pedazo: de"status":504queda504. Trabaja una línea a la vez y la suelta enseguida. - sort · pone juntos los iguales
Ordena las líneas. Es el único de la fila que no puede soltar nada hasta leer la última: la línea más chica podría ser la que falta. Si son muchas, GNUsortusa archivos temporales en el disco. - uniq -c · cuenta cada grupo
Junta las líneas iguales que vienen seguidas y dice cuántas eran:6 200. Por eso va después desort: sin ordenar, dos 200 separados por un 504 contarían como dos grupos. - sort -rn · del mayor al menor
Ordena otra vez, ahora por el conteo, como número (-n) y al revés (-r): el código más común queda arriba. - gateway.log · una línea JSON por request
El log del gateway en JSON Lines.greplo abre como archivo; los demás nunca lo ven: reciben lo que les manda el de su izquierda por su stdin. - Tu terminal · solo ve el resultado
Solo el stdout del último proceso llega a la terminal. Lo de en medio viaja por los tubos y nunca se dibuja. Los errores (stderr) de cualquiera de los cinco sí salen aquí, porque no van por los tubos.
De 12 líneas a 3 GB
Con 12 líneas cualquier cosa funciona. El log de verdad es otra historia. Para saber cuánto pesa y cuánto tarda en leerse, o en bajarse por la red, bastan tres ecuaciones:
- donde
- R
- requests al día; el log escribe una línea por request
- b
- bytes por línea, en B
- D
- días de log (1 para el log de un día)
- S
- tamaño del log, en bytes
- vleer
- qué tan rápido leen el disco y grep, en bytes por segundo (aquí, una suposición: ≈ 500 MB/s)
- tleer
- segundos que tarda grep en leer el log completo
- vred
- qué tan rápida es la red, en bits por segundo; el 8 de la fórmula son los bits de cada byte
- tbajar
- segundos que tarda el log en llegar completo a tu laptop
grep 9f2c41d0las 2 líneas entre las R del díaDos reglas salen de esa cuenta. Primero, filtra lo antes posible: grep al principio de la tubería, para que a sort (el único que necesita ver todo antes de soltar algo) le lleguen 2 líneas y no 10 millones. Segundo, corre el comando donde están los datos: lo ves en la sección de ssh.
Un log de JSON Lines tiene una línea por request. Para encontrar una sola request, grep lee el archivo completo. Compara leerlo en el servidor contra bajarlo a tu laptop. Arranca con un día de Alba: ≈ 10 millones de requests, de ≈ 300 B cada una. La calculadora aplica S=
La red casi siempre es más lenta que el disco: por eso se lleva el comando a los datos. Con 30 días, el log de Alba pesa 90 GB, y bajarlo tarda horas aunque grep lo lea en 3 minutos.
Prueba un mes completo: 30 veces el día. Y baja la red a 20 Mb/s, la de un café: ¿cuánto tardaría en llegar el log a tu laptop?
Para ir más hondoQué pasa cuando head se cansa+
En jq … | sort | uniq -c | sort -rn | head -n 2, head imprime dos líneas y termina. El tubo que lo une con el sort de su izquierda queda sin nadie que lea. La siguiente vez que ese sort intenta escribir, el kernel le manda la señal SIGPIPE, que lo termina sin ruido. Así, head puede cortar una tubería larga sin que nadie tenga que leer el resto. Es también por qué, en un script con pipefail (en la sección siguiente), una tubería que termina en head puede dar un código distinto de 0 aunque todo haya salido bien: el que murió por SIGPIPE sale con 128 + 13 = 141.
Scripts: shebang, permisos y set -euo pipefail
ExtraScripts: shebang, permissions and set -euo pipefail
Un archivo con comandos
Un script de shell (shell script) es un archivo de texto con comandos, uno por línea, que la shell corre de arriba abajo como si los fueras tecleando. Sirve para no repetir a mano una receta de diez comandos y para que otra persona, o un pipeline de CI (la máquina que corre las pruebas en cada cambio del código), la corra igual. En Alba, bash model/build_engine.sh construye el engine de TensorRT (el modelo compilado para una GPU concreta) en una T4, y otro script, el de publicación (release), firma la imagen y la sube.
Dentro de un script se usan las mismas cosas de la terminal, más un par de piezas:
"$@"son todos los argumentos que recibió el script, cada uno respetado, y$1,$2… cada uno por separado.for x in …; do …; donerepite algo para cada elemento, eif comando; then …; fidecide según el código de salida de un comando: 0 es «sí».
El shebang: con qué se corre
La primera línea de un script suele ser algo como #!/usr/bin/env bash. Es el shebang (de cómo se leen # y ! en inglés, hash o sharp y bang; el origen exacto no se sabe). Cuando le pides al kernel que ejecute un archivo de texto, el kernel lee esos dos primeros caracteres, toma el resto de la línea como el programa que debe leer el archivo y lo lanza con el script como argumento.
#!/bin/bashpide la bash de/bin/bash, exactamente esa. En una Mac, esa ruta tiene una bash muy vieja, de la serie 3.2.#!/usr/bin/env bashle pide al programaenvque busquebashen el PATH. Corre la primera bash que encuentre, la que tú instalaste si está antes en la lista. Es la forma más portátil, y la más común.#!/bin/shpide la shell básica. Si usas cosas que solo tiene bash, en Debian falla, porque ahíshes otra shell, más chica (dash).
Para que el kernel acepte ejecutarlo, el archivo necesita el permiso x, el de ejecución que viste en la lección de permisos: chmod +x script.sh. Sin él, ./script.sh da Permission denied y el código 126. Siempre puedes saltarte el shebang y el permiso escribiendo bash script.sh: así el programa que corres es bash, y el script es solo un archivo que lee.
cat > contar.sh <<'FIN'
#!/usr/bin/env bash
# Cuenta las líneas de cada archivo que le pasen.
for archivo in "$@"; do
echo "$archivo: $(wc -l < "$archivo") líneas"
done
FIN
printf 'a\nb\nc\n' > tres.txt
printf 'x\ny\n' > dos.txt
./contar.sh tres.txt
echo "código: $?"
bash contar.sh tres.txt
chmod +x contar.sh
./contar.sh tres.txt dos.txt
ls -l contar.sh | cut -c1-10bash: line 10: ./contar.sh: Permission denied
código: 126
tres.txt: 3 líneas
tres.txt: 3 líneas
dos.txt: 2 líneas
-rwxr-xr-xEl primer intento dio 126 porque el archivo no tenía la x; bash contar.sh funcionó igual. Ya con chmod +x, ./contar.sh corre, y la última línea deja los primeros 10 caracteres de ls -l (eso hace cut -c1-10): los permisos, ahora con sus x.
set -euo pipefail: que el script se detenga al fallar
Por omisión, un script de bash es optimista: si un comando falla, imprime el error y sigue con el siguiente, como si nada. En un script que borra el modelo viejo después de copiar el nuevo, «seguir como si nada» es una catástrofe. Por eso casi todo script serio empieza, justo después del shebang, con set -euo pipefail. Cada letra apaga una forma de fallar en silencio:
| Opción | Qué hace |
|---|---|
-e | Si un comando sale con un código distinto de 0, el script se detiene ahí, con ese código |
-u | Usar una variable que no existe es un error. Sin esto, si CARPETA no existe (basta un error de dedo en su nombre), rm -rf "$CARPETA"/* se vuelve rm -rf /*: borrar todo lo que se pueda |
-o pipefail | El código de una tubería es el del último comando que falló, no solo el del último comando. Sin esto, grep … | wc -l «sale bien» aunque grep no haya encontrado el archivo, porque wc sí terminó bien |
cat > sin.sh <<'FIN'
grep 9f2c41d0 no-existe.log | wc -l
echo "sigo, como si nada"
FIN
cat > con.sh <<'FIN'
set -euo pipefail
grep 9f2c41d0 no-existe.log | wc -l
echo "esto ya no se imprime"
FIN
bash sin.sh; echo "código de sin.sh: $?"
bash con.sh; echo "código de con.sh: $?"
bash -c 'false | true; echo "sin pipefail: $?"'
bash -c 'set -o pipefail; false | true; echo "con pipefail: $?"'grep: no-existe.log: No such file or directory
0
sigo, como si nada
código de sin.sh: 0
grep: no-existe.log: No such file or directory
0
código de con.sh: 2
sin pipefail: 0
con pipefail: 1false es un comando que no hace nada y sale con 1; true, con 0. Y bash sin.sh; echo … corre el script y, al terminar, imprime su código. sin.sh falló y terminó con 0: un pipeline de CI lo habría dado por bueno. con.sh se detuvo y salió con el 2 de grep.
Para revisar que un script no tenga errores de escritura sin correrlo está bash -n script.sh. Así se revisa en Alba el script del engine: en una máquina sin GPU no se puede correr, y lo único que se le pide ahí es que pase bash -n.
Para ir más hondoLas trampas de set -e+
-e ayuda, pero no es una red completa. Tres casos donde no hace lo que esperas:
- Dentro de una condición no cuenta. En
if grep -q x log; then …, quegrepfalle es una respuesta («no»), no un error. Lo mismo con lo que va antes de&&o de||. - grep sin coincidencias es un fallo.
grepsale con 1 cuando no encuentra nada. Con-eypipefail,errores=$(grep ERROR app.log | wc -l)mata el script justo el día que no hubo errores. Si «nada» es una respuesta válida, escribe{ grep ERROR app.log || true; } | wc -l. local x=$(cmd)se traga el error. Dentro de una función (un bloque de comandos con nombre),localcrea una variable que solo vive ahí, y sale con 0 aunquecmdhaya fallado. Se escribe en dos líneas:local x, y abajox=$(cmd).
Y -u tampoco es completa: solo detecta las variables que no existen. Una que existe pero está vacía (CARPETA="") pasa sin aviso. Para exigir que traiga algo se escribe "${CARPETA:?}": si está vacía o no existe, el script se detiene con un error.
Hay una herramienta, ShellCheck, que revisa scripts y encuentra estas trampas, y muchas más.
Entrar al servidor: ssh, sudo y kubectl logs
EsencialGetting into the server: ssh, sudo and kubectl logs
ssh: una terminal en otra máquina
ssh (secure shell) te da una shell en otra computadora a través de la red, con todo cifrado. Escribes ssh marta@gw-node y, si te deja entrar, el prompt cambia: lo que tecleas ahora lo lee una shell en gw-node, y los procesos que lances corren allá. Tu terminal solo dibuja lo que esa shell le manda. Por omisión usa el puerto 22.
Para probar quién eres, en vez de una contraseña se usa casi siempre un par de llaves: dos archivos que se crean juntos con ssh-keygen. La llave privada se queda en tu laptop (por ejemplo, ~/.ssh/id_ed25519) y nunca se comparte; es la que la lección del sistema operativo pidió guardar con permisos 600. La llave pública se copia al servidor. Con ellas, tu laptop demuestra que tiene la privada sin mandarla nunca por la red. Cómo funciona eso por dentro es tema de la fase de seguridad.
Para ir más hondoLas llaves y los permisos que exige ssh+
Ed25519 es el tipo de llave que ssh-keygen crea por omisión desde OpenSSH 9.5, de 2023. Los permisos 600 no son un consejo: si otros usuarios pueden leer tu llave privada, ssh se niega a usarla y avisa UNPROTECTED PRIVATE KEY FILE!. Del lado del servidor, la carpeta ~/.ssh y el archivo authorized_keys (la lista de llaves públicas que dejan entrar) no deben poder escribirlos otros, o el servidor ignora tus llaves.
Tres usos que vas a ver:
ssh marta@gw-nodeabre una shell allá.ssh marta@gw-node 'grep 9f2c41d0 /var/log/gateway.log'corre un solo comando allá y te trae su salida. Las comillas simples importan: con ellas, la tubería o el comodín los resuelve la shell de allá; sin ellas, tu shell local se los come primero.ssh -L 8000:localhost:8000 marta@gw-nodeabre un túnel: lo que tu laptop mande a su propio puerto 8000 viaja por ssh y sale en el puerto 8000 degw-node. Así puedes hacercurl localhost:8000(curlhace una request HTTP desde la terminal) desde tu laptop y llegarle a un servicio que no está expuesto a internet.kubectl port-forwardhace lo mismo para un pod de Kubernetes.
sudo: un comando como root
En la lección del sistema operativo conociste a root, el usuario que puede todo. Entrar como root a un servidor es mala idea: cualquier error de dedo tiene poder total. Lo normal es entrar como tu usuario y, solo para el comando que lo necesita, pedir permiso con sudo (superuser do): sudo systemctl restart docker reinicia el servicio de Docker como root (systemctl arranca y detiene los servicios de Linux, los programas que corren en el fondo). sudo te pide tu contraseña, revisa en una lista si tienes permiso y anota quién hizo qué.
Dentro de un contenedor casi nunca hay sudo, y no hace falta. La imagen se arma con lo que necesita, y el proceso corre como el usuario que dice su receta, el Dockerfile: root, si no dice otra cosa, o un usuario sin privilegios, que es lo recomendado. Agregar sudo a una imagen solo le da a un atacante un camino para subir de privilegios. Si escribes sudo en el contenedor de esta lección, la respuesta es bash: sudo: command not found, con el código 127.
Qué pasa cuando tecleas kubectl logs gateway-7f9c
Ahora junta todo. En Alba, el gateway corre como varios pods (el pod es la unidad que Kubernetes arranca: uno o más contenedores juntos, en una máquina del clúster) dentro del namespace classifier, un espacio de nombres para separar las cosas de cada equipo. kubectl es el programa de la línea de comandos para hablar con Kubernetes, el sistema de orquestación que usa Alba. Marta escribe kubectl logs -n classifier gateway-7f9c (el nombre real de un pod es más largo, algo como gateway-7f9c…-x2kq4; aquí va acortado).
- Terminal · dibuja y pasa las teclas
La terminal manda lo que tecleas a la shell y dibuja lo que le llega. No sabe qué eskubectl. - Shell · parte, busca en PATH y lanza
La shell parte la línea en palabras:kubectl,logs,-n,classifier,gateway-7f9c. Buscakubectlen las carpetas de PATH y lo lanza como proceso hijo, conforkyexec. - kubectl · un proceso hijo de la shell
Un programa que habla con Kubernetes. Hereda de la shell la carpeta, las variables y los tres flujos: su stdout es tu terminal, o el tubo haciagrepsi pusiste uno. - ~/.kube/config · a qué clúster y con qué credenciales
El kubeconfig: un archivo YAML con la dirección del clúster, tus credenciales y el namespace por omisión. La variable de entornoKUBECONFIGpuede apuntar a otro. - API server · la puerta de entrada
Recibe la request HTTPS (HTTP cifrado) dekubectl, revisa quién eres y si puedes leer los logs de ese pod en el namespaceclassifier, y se la pasa al kubelet de la máquina correcta. - kubelet · uno en cada máquina
El programa de Kubernetes que corre en cada máquina del clúster: arranca los contenedores y sabe dónde quedaron sus logs. Lee el archivo y manda las líneas de vuelta. - Archivo de log del pod · en el disco de la máquina
El runtime de contenedores guarda aquí, línea por línea y con su hora, lo que el contenedor escribe en stdout y stderr. Al llegar a 10 MiB se rota: se guarda aparte y empieza uno nuevo.kubectl logssolo lee el más reciente. - Contenedor del gateway · uvicorn escribe en stdout
El gateway de Alba escribe una línea JSON por request en su stdout, conPYTHONUNBUFFERED=1para que salga al instante. No sabe que alguien la está leyendo.
En palabras: la shell parte la línea, encuentra kubectl en el PATH y lo lanza. kubectl lee su configuración (el kubeconfig, en ~/.kube/config: a qué clúster hablar y con qué credenciales) y le hace una request HTTPS (HTTP cifrado) al API server, la puerta de entrada de Kubernetes. El API server se la pasa al kubelet, el programa de Kubernetes que corre en cada máquina del clúster, en la máquina donde vive ese pod. El kubelet lee el archivo donde el runtime fue guardando el stdout y el stderr del contenedor, y la respuesta hace el camino de regreso. kubectl escribe las líneas en su stdout, que es tu terminal, o el tubo hacia grep si pusiste uno.
Las opciones que más se usan: -f se queda siguiendo las líneas nuevas (Ctrl+C deja de seguir; el pod sigue igual), --tail=50 trae solo las últimas 50, --since=10m las de los últimos diez minutos, --previous las del contenedor anterior, el que murió, y --timestamps agrega la hora que anotó el runtime al guardar cada línea.
Cuánto tiempo hacia atrás alcanzan esas opciones depende de cuántas líneas escribe cada pod por segundo:
- donde
- λ
- requests por segundo que llegan al gateway en total (la letra griega lambda)
- k
- pods del gateway que se reparten ese tráfico
- f
- líneas por segundo que escribe cada pod, una por request
- m
- líneas que pides con
--tail - ttail
- segundos de tráfico que cubren esas m líneas
- M
- tamaño al que se rota el archivo del pod, en bytes
- b
- bytes por línea, la misma b del log (≈ 300 B)
- trot
- segundos de tráfico que caben en el archivo antes de rotarlo
--tail=50, ttailm = 50--since=10m.kubectl logs lee el log de un pod. En el pico, el tráfico se reparte entre los pods del gateway, y cada uno escribe una línea por request. Arranca con el pico de diseño de Alba, 500 requests por segundo, y los 5 pods del gateway en ese pico. La calculadora aplica f=
Con 12 pods, el máximo del autoescalado, el mismo --tail=50 cubre 1.2 s en vez de 0.5 s, y el archivo del pod dura ≈ 14 minutos en vez de ≈ 6. Para ir más atrás, se busca en el log del día guardado en S3.
Sube los pods a 12, el máximo del autoescalado: cada pod recibe menos tráfico y el mismo --tail cubre más tiempo.
Ojo con lo que kubectl logs no tiene: solo ve lo que sigue guardado en la máquina del pod. El kubelet rota ese archivo cuando crece (por omisión, al llegar a 10 MiB, y guarda hasta 5), kubectl logs solo lee el más reciente, y si el pod se borra, sus logs se van con él. Además, cada línea guardada pesa unos 40 bytes más que la original, por la hora y el nombre del flujo que le agrega el runtime: el archivo dura un poco menos de lo que dio la cuenta. Para buscar en el día completo, los ≈ 3 GB, se va a donde Fluent Bit los guardó: en Alba, un bucket de S3.
Para ir más hondoLos comandos de Docker y Kubernetes, leídos+
Con lo que ya sabes, los comandos de Docker y de Kubernetes se leen solos: el programa, un verbo, opciones y argumentos. Docker y Kubernetes se presentan a fondo en sus lecciones, «Empaquetado con Docker» y «Kubernetes»; aquí solo hay que reconocer su forma.
| Comando | Cómo se lee |
|---|---|
docker build -t classifier-gateway:3f9c2ab gateway/ | Arma una imagen con la receta de la carpeta gateway/ y le pone ese nombre |
docker run --rm -p 8080:8080 classifier-gateway:3f9c2ab | Corre un contenedor de esa imagen, conecta su puerto 8080 al tuyo y lo borra al terminar |
docker logs -f gw · docker exec -it gw sh | Sigue el stdout y el stderr del contenedor gw · abre una shell sh adentro |
kubectl get pods -n classifier | Lista los pods, con su estado y sus reinicios |
kubectl describe pod POD | Todo sobre un pod, con sus eventos y su último código de salida |
kubectl apply -f k8s/gateway.yaml | Le pide a Kubernetes que deje todo como dice ese archivo |
kubectl rollout undo deploy/gateway | Regresa a la versión anterior del gateway |
curl -sS localhost:8080/healthz | Hace una request HTTP. -s quita la barra de progreso (y también calla los errores); -S vuelve a mostrar los errores |
nvidia-smi | Muestra las GPUs de la máquina: memoria usada, utilización y procesos |
grpcurl | Como curl, pero para gRPC |
Procesos desde la terminal
ExtraProcesses from the terminal
La shell espera a que termine cada comando antes de escribir el prompt. Eso es correrlo en primer plano (foreground). A veces quieres otra cosa: dejarlo corriendo y seguir escribiendo, pararlo o que sobreviva aunque cierres la ventana.
Ver y detener
pslista procesos:ps aux, todos los de la máquina, con su PID, su usuario y su comando.toplos muestra en vivo, ordenados por cuánta CPU usan; se sale conq.kill PIDle manda una señal a un proceso: SIGTERM por omisión, que pide terminar en orden.kill -9 PIDmanda SIGKILL, que no se puede atrapar.- Ctrl+C hace que la terminal le mande SIGINT al proceso de primer plano: «interrumpe lo que haces».
- Ctrl+Z le manda SIGTSTP: lo pausa y te devuelve el prompt.
fglo regresa al primer plano ybglo deja seguir en segundo plano.
El orden de esas señales es una costumbre que vas a ver en todos lados: primero se pide (SIGTERM, para que el proceso termine lo que traía, vacíe sus buffers y cierre sus archivos) y solo si no obedece se obliga (SIGKILL). kill -9 de entrada es como desconectar la computadora: funciona, pero lo que estaba a medias se pierde. Kubernetes hace lo mismo al apagar un pod, como viste en la lección de procesos: SIGTERM, un plazo de gracia y, si el proceso sigue vivo, SIGKILL. Para buscar un PID sin leer toda la lista de ps está pgrep: pgrep -f uvicorn imprime el PID de cada proceso cuyo comando contiene uvicorn.
Segundo plano y sesiones que sobreviven
Un & al final de la línea lanza el comando en segundo plano (background): la shell no espera y te devuelve el prompt al instante. $! guarda el PID del último que lanzaste así, y wait espera a que termine y te da su código.
sleep 30 &
pid=$!
ps -o comm= -p "$pid"
kill "$pid"
wait "$pid"
echo "sleep terminó con $?"
timeout 1 sleep 5
echo "timeout: $?"sleep
sleep terminó con 143
timeout: 124sleep 30 espera 30 segundos sin hacer nada, y ps -o comm= -p imprime solo el nombre del programa de ese PID. El kill le mandó SIGTERM y salió con 143. timeout 1 sleep 5 corre un comando con un tiempo límite: al segundo lo detiene, y sale con 124, su forma de decir «se acabó el tiempo».
Hay un problema con &: si cierras la terminal o se corta tu ssh, los procesos de esa sesión reciben la señal SIGHUP (de hang up, «colgar»), y por omisión eso los mata. Dos salidas:
nohup comando > salida.log 2>&1 &lanza el comando ignorando SIGHUP. Sobrevive a que cierres la sesión, y su salida queda en el archivo.- tmux (terminal multiplexer) abre sesiones de terminal que viven en el servidor. Te desconectas, te vas a dormir, vuelves a entrar con
sshytmux attachte regresa a la misma pantalla, con todo corriendo. Es como se cuida un entrenamiento de 8 horas en una máquina con GPU.
Errores comunes
EsencialCommon mistakes
1. Un espacio que parte un argumento
rm mis fotos, o un script con cp $origen $destino y un archivo que se llama datos de octubre.csv. El programa recibe más argumentos de los que creías y trabaja sobre archivos que no eran.
Cómo evitarlo: comillas dobles alrededor de toda variable ("$origen") y de todo nombre con espacios. Antes de un rm, cambia el rm por printf '[%s]\n' y mira qué argumentos arma la shell.
2. Un comodín que se expande donde no querías
rm *.log en la carpeta equivocada borra lo que coincida ahí. Y un patrón que debía llegarle a otro programa, como find . -name *.log (find busca archivos en una carpeta y todas las de adentro), lo expande antes la shell: si en tu carpeta hay un solo .log, find busca solo ese nombre.
Cómo evitarlo: revisa el prompt o pwd antes de un comodín peligroso, prueba primero con echo *.log, y pon entre comillas los patrones que son para el programa: find . -name "*.log".
3. Vaciar el archivo que estás leyendo, o mezclar el orden
sort gateway.log > gateway.log deja el archivo vacío: la shell lo vacía al preparar el >, antes de que sort lo lea. Y cmd 2>&1 > log deja los errores en la pantalla.
Cómo evitarlo: escribe a un archivo nuevo (sort gateway.log > ordenado.log) y renómbralo después. Para juntar los dos flujos, > log 2>&1, en ese orden, o &> log en bash.
4. «command not found» con el programa instalado
El programa está, pero no en una carpeta de PATH: el entorno de Python no está activado, o la imagen no puso /opt/venv/bin en PATH. En un contenedor se ve así: exec: "uvicorn": executable file not found in $PATH.
Cómo evitarlo: type programa para ver qué encuentra la shell, echo "$PATH" para ver dónde busca, y en la imagen, una línea que agregue la carpeta del entorno a PATH.
5. Un script que falla y sigue
Un paso falla, el script sigue, y el siguiente trabaja sobre lo que quedó a medias: publica un modelo sin terminar de copiarlo o borra la versión vieja sin tener la nueva.
Cómo evitarlo: set -euo pipefail al principio de todo script, y bash -n o ShellCheck antes de usarlo. Si un grep sin resultados es normal, dilo explícito con || true.
6. Estar en la máquina equivocada
El comando correcto en el lugar equivocado: un kubectl delete en el clúster de producción cuando creías estar en el de pruebas, o un sudo que pegaste de internet sin leerlo.
Cómo evitarlo: lee el prompt antes de cada comando con poder; con Kubernetes, kubectl config current-context te dice a qué clúster le hablas. Y nunca corras con sudo un comando que no entiendas palabra por palabra.
En la vida real
ExtraIn real life
Alba: la guardia de las 3 de la mañana
Regresa a Marta y su alerta de 504. Con lo que ya sabes, su noche se lee comando por comando:
- 1
¿Están vivos los pods?
kubectl get pods -n classifierlista los pods del gateway y de Triton con sus reinicios. Si uno reinició muchas veces,kubectl describe podda su último código: 137 apunta a memoria. - 2
¿Cuántos 504 y desde cuándo?
kubectl logs -n classifier gateway-7f9c --since=10m | grep '"status":504' | wc -lda el número. Cambiando elwc -lporjq -r .request_id | head, saca unos ids para seguir. - 3
¿Qué le pasó a la request del usuario?
El reporte trae el id
9f2c41d0, que viaja en el headerX-Request-ID. Esa request es de hace dos horas: ya no está en el archivo del pod, sino en S3, donde Fluent Bit va subiendo el log en pedazos (un archivo nuevo cada pocos minutos, y aquí comprimido con gzip para que ocupe menos). Marta lee el pedazo de esa hora sin bajarlo a disco, en una tubería:aws s3 cp s3://…/2026/11/06/01/….gz - | gunzip | grep 9f2c41d0.awses el programa de línea de comandos de AWS, y el-le dice que escriba en stdout en vez de en un archivo, ygunzipdescomprime al vuelo. - 4
¿Y Triton?
kubectl port-forward -n classifier svc/triton-v14 8002:8002abre un túnel al puerto de métricas, ycurl -sS localhost:8002/metrics | grep nv_inference_queuemuestra cuánto esperan las requests en la fila de Triton.
La lección de procesos te contó otra historia del gateway de Alba que es de shell: el CMD del Dockerfile en forma shell arranca /bin/sh -c …, y si esa sh se queda como PID 1 (con un tubo, por ejemplo), no le pasa el SIGTERM a uvicorn. Ahora sabes qué es esa sh: una shell, lanzada solo para leer una línea.
CI: scripts que corre una máquina
Cada paso run: de GitHub Actions, el sistema que corre las pruebas de un repositorio en cada cambio, es un script de shell. En Linux, si no dices otra cosa, lo corre bash con -e; si escribes shell: bash, le agrega pipefail. Ahí set -euo pipefail no es estilo: un código distinto de 0 es lo que pone la marca roja y detiene la publicación. Alba lo usa en su script de seguridad: un escáner de vulnerabilidades, que busca fallas ya conocidas en lo que trae la imagen, sale con --exit-code 1 si encuentra alguna, y eso detiene la publicación. Lo verás en «Pruebas y CI/CD».
Entrenar en una máquina rentada
Mucho del trabajo de entrenar modelos se hace por ssh a una máquina con GPU en la nube. El ritual es casi siempre el mismo: ssh a la máquina, tmux para que el entrenamiento sobreviva si se corta la conexión, python3 -u entrenar.py 2>&1 | tee entrenar.log para ver el progreso y guardarlo a la vez (tee copia lo que le llega a un archivo y también a su stdout; el -u es lo mismo que PYTHONUNBUFFERED=1: sin él, como stdout es un tubo, Python juntaría las líneas y el progreso llegaría a saltos), y en otra ventana nvidia-smi cada tanto para ver la memoria de la GPU. Cuando un LLM no cabe en la GPU, ahí lo ves primero.
Explorar datos antes de abrir un notebook
Con un CSV de ventas de 2 GB (el de un sistema de pronóstico de demanda, o las transacciones de uno de detección de fraude), antes de cargarlo en Python o en un notebook (un cuaderno de Jupyter, donde el código se corre por pedazos): head -n 3 ventas.csv muestra las columnas, wc -l cuenta las filas, y cut -d, -f4 ventas.csv | sort | uniq -c | sort -rn | head dice qué tiendas tienen más filas, si la cuarta columna es la tienda. Son segundos, sin llenar la RAM.
Fuera de ML
La forma de trabajar con programas chicos y tubos viene de Unix, que se empezó a escribir en los Laboratorios Bell en 1969; los tubos los propuso Doug McIlroy y se agregaron en 1973. Medio siglo después, la misma barra vertical conecta los comandos de un administrador de sistemas, de un científico que procesa genomas o de quien mantiene un sitio web. Y ssh es como se administran casi todos los servidores del mundo.
Ejercicios
EsencialExercises
Intenta cada uno antes de abrir la solución. Los de bash puedes correrlos en una terminal de Linux o en WSL2. En una Mac casi todos funcionan igual, con detalles: el wc -l de la Mac pone espacios antes del número, timeout no viene instalado y jq viene desde macOS 15.
- 1Fácil
En una carpeta con
a.csv,b.csvynotas.txt, escribesls -l "reportes de octubre" *.csv. ¿Cuántos argumentos recibels, y cuáles son?Ver la solución paso a paso
- La shell parte por los espacios, pero lo que va entre comillas es uno solo:
-lyreportes de octubre. - El comodín
*.csvse expande antes de lanzarls:a.csvyb.csv. - Recibe 4 argumentos:
-l,reportes de octubre,a.csvyb.csv.lsnunca ve el asterisco.
- La shell parte por los espacios, pero lo que va entre comillas es uno solo:
- 2Fácil
¿Quién hace cada cosa, la terminal o la shell? (a) Cambiar el tamaño de las letras. (b) Reemplazar
$HOMEpor/home/ana. (c) Buscarkubectlen las carpetas de PATH. (d) Dibujar en verde el texto que imprime un programa.Ver la solución paso a paso
- (a) La terminal: es la ventana, y dibujar letras es su trabajo.
- (b) La shell: expande las variables antes de lanzar el programa.
- (c) La shell: busca la primera palabra en PATH.
- (d) La terminal. El programa solo manda unos códigos especiales junto con el texto; la terminal los interpreta como colores.
- 3Fácil
¿Qué imprime
cat a.txtdespués de estos tres comandos?echo "uno" > a.txt,echo "dos" >> a.txtyecho "tres" > a.txt. ¿Y si el tercero fuera>>?Ver la solución paso a paso
>vacía el archivo antes de escribir;>>agrega al final.- Después de los tres, el archivo tiene solo tres: el último
>borró lo anterior. - Con
>>en el tercero, tiene uno, dos y tres, en tres líneas.
- 4Fácil
Escribes
entrenary la shell respondecommand not found. Pero el archivoentrenarestá en la carpeta donde estás y tiene permiso de ejecución. ¿Por qué no lo encuentra, qué código de salida dejó, y cómo lo corres?Ver la solución paso a paso
- Una palabra sin
/se busca solo en las carpetas de PATH, y la carpeta actual no está en PATH (por seguridad: así nadie te cuela unlsfalso en una carpeta). - El código es 127, el de «el comando no existe».
- Se corre con una ruta:
./entrenar. O agregando su carpeta a PATH.
- Una palabra sin
- 5Medio
Con un log como el de la sección de tuberías, escribe una tubería que diga cuántas requests terminaron en 504 y otra que liste sus
request_id, sin repetir.Ver la solución paso a paso
Una forma, con
jqpara leer el JSON:printf '%s\n' '{"request_id":"9f2c41d0","level":"error","msg":"timeout"}' \ '{"request_id":"9f2c41d0","status":504,"ms":152}' '{"request_id":"a71e09b2","status":200,"ms":41}' \ '{"request_id":"2c7a0f93","status":504,"ms":151}' > gateway.log jq -r 'select(.status == 504) | .request_id' gateway.log | wc -l jq -r 'select(.status == 504) | .request_id' gateway.log | sort -u2 2c7a0f93 9f2c41d0select(.status == 504)deja pasar solo las líneas con ese código, y.request_idsaca el id.wc -lcuenta: 2.sort -uordena y quita los repetidos, comosort | uniq.- Con grep también se puede (
grep '"status":504' gateway.log | wc -l), pero depende de que el log no tenga espacios.
- 6Medio
Un compañero corre
python3 entrenar.py 2>&1 > entrenar.logy se queja: «los errores no quedan en el log». ¿Qué pasó y cómo se arregla?Ver la solución paso a paso
- Las redirecciones se aplican de izquierda a derecha.
2>&1hizo que el 2 apuntara a donde apuntaba el 1 en ese momento: la pantalla. - Después,
> entrenar.logmovió solo el 1 al archivo. Los errores siguieron en la pantalla. - Arreglo:
python3 entrenar.py > entrenar.log 2>&1, o&> entrenar.logen bash. Si además quiere verlo en vivo:python3 -u entrenar.py 2>&1 | tee entrenar.log, con-upara que Python no junte las líneas en el buffer del tubo.
- Las redirecciones se aplican de izquierda a derecha.
- 7Medio
De la sección extra de scripts: un script con
set -euo pipefailtiene la líneaerrores=$(grep ERROR app.log | wc -l). Un día el log no trae ningún ERROR y el script muere sin imprimir nada útil. ¿Por qué? ¿Cómo lo arreglas?Ver la solución paso a paso
grepsale con 1 cuando no encuentra nada. Conpipefail, la tubería entera sale con 1 aunquewchaya contado 0 sin problema.- Con
-e, ese 1 detiene el script en esa línea. - Arreglo: decir que «nada» está bien:
errores=$({ grep ERROR app.log || true; } | wc -l). Ojo:grep -cno lo arregla, porque también sale con 1 cuando el conteo es 0.
- 8Medio
Llegan 500 requests por segundo y el autoescalado está en su máximo: 12 pods (más de los 5 que pide el pico). ¿Cuánto tiempo cubren las últimas 200 líneas de un pod (
--tail=200)? ¿Cuántas líneas trae--since=5m, y cuánto pesan a ≈ 300 B cada una?Ver la solución paso a paso
- Las ecuaciones de la sección de
kubectl logs: f=λ÷ y ttail=k m÷ , con λ = 500, k = 12 y m = 200.f - Por pod: f = 500 ÷ 12 ≈ 41.7 líneas por segundo.
--tail=200: ttail = 200 ÷ 41.7 ≈ 4.8 s de tráfico.--since=5m: líneas = 300 s × f = 300 × 41.7 ≈ 12,500 líneas, y pesan líneas × b = 12,500 × 300 B ≈ 3.75 MB. Cabe de sobra en una tubería congrep; es demasiado para leerlo a ojo.
- Las ecuaciones de la sección de
- 9Reto
Con este log, ¿cuál es el promedio de
msy cuál es la request más lenta? Hazlo con una tubería y comprueba el promedio a mano.Ver la solución paso a paso
printf '%s\n' '{"request_id":"a71e09b2","status":200,"ms":41}' '{"request_id":"9f2c41d0","status":504,"ms":152}' \ '{"request_id":"e4f1c2d9","status":200,"ms":44}' '{"request_id":"77ab3e01","status":200,"ms":39}' > gateway.log jq -r '.ms' gateway.log | awk '{ s += $1 } END { printf "promedio: %.1f ms en %d requests\n", s / NR, NR }' jq -r '[.ms, .request_id] | @tsv' gateway.log | sort -n | tail -n 1promedio: 69.0 ms en 4 requests 152 9f2c41d0jq -r '.ms'saca un número por línea.awkva sumando cada uno ens; al final (END),NRes cuántas líneas leyó.- A mano, con promedio=
(x1+ , donde xi son los ms de cada request: (41 + 152 + 44 + 39) ÷ 4 = 276 ÷ 4 = 69 ms.x2+ x3+ x4)÷ 4 - Para la más lenta,
jqarma «ms, tabulador, id»,sort -nordena por el número ytail -n 1deja la última: 9f2c41d0, con 152 ms. Fíjate en que un solo 504 sube el promedio de ≈ 41 a 69: por eso la latencia se mide con percentiles.
- 10Reto
El log del día, ≈ 3 GB, está en una máquina a la que entras por
sshcomomarta@gw-node, en/var/log/gateway/hoy.jsonl. Estás en un café, con una red de 20 Mb/s. Compara (a)ssh marta@gw-node 'cat /var/log/gateway/hoy.jsonl' | grep 9f2c41d0con (b)ssh marta@gw-node 'grep 9f2c41d0 /var/log/gateway/hoy.jsonl'. ¿Dónde corre cadagrep? ¿Cuánto tarda cada uno, aproximadamente, si grep lee 500 MB/s?Ver la solución paso a paso
- En (a),
catcorre allá y manda el archivo completo por la red; elgrepcorre en tu laptop. Viajan 3 GB: con tbajar=8× , S = 3 × 10⁹ B y vred = 20 Mb/s = 2 × 10⁷ bits/s, tbajar = 8 × 3 × 10⁹ ÷ (2 × 10⁷) = 1,200 s, 20 minutos.S÷ vred - En (b), lo que va entre comillas es el comando remoto completo:
grepcorre allá. Con tleer=S÷ : 3 GB ÷ 500 MB/s ≈ 6 s, y por la red viajan un par de líneas.vleer - (b) es ≈ 200 veces más rápido (tbajar÷
tleer = 1,200 ÷ 6); con la red de 100 Mb/s de la sección de ssh eran ≈ 40. La regla: lleva el comando a los datos, no los datos al comando. - Cuidado con
ssh marta@gw-node grep 9f2c41d0 /var/log/gateway/hoy.jsonl | wc -l: elgrepcorre allá, pero el| wc -llo resuelve tu shell local, porque no está entre comillas. Aquí da lo mismo; con un>o un comodín, no.
- En (a),
Lo que sigue
EsencialWhat comes next
- La siguiente lección, «Python, paquetes y entornos», explica qué hace
pip instally por qué activar un entorno es cambiar PATH. - Después, «Git: versiones del código» y «Pruebas y CI/CD» son casi todo comandos, y «Configuración: YAML, variables de entorno y secretos» usa las variables de entorno de esta lección para configurar el gateway de Alba.
- «Empaquetado con Docker» y «Kubernetes» se trabajan desde la terminal: construir la imagen del gateway, correrla, leer sus logs con
docker logsykubectl logs, y entrar condocker exec.
Palabras que vas a oír
EsencialWords you will hear
Estos son los conceptos que presentó esta lección. Cada uno tiene su tarjeta con la definición completa.
Terminalterminal · terminal emulatorLa ventana de texto donde se escriben comandos en vez de usar el mouse. Solo pasa lo que tecleas a otro programa, la shell, y dibuja el texto que ese programa le regresa.Más +
La terminal no entiende los comandos: eso lo hace la shell que corre adentro. Su trabajo es dibujar letras, colores y el cursor, y mandar las teclas, incluidas combinaciones como Ctrl+C, que le pide al kernel convertir en la señal SIGINT para el proceso de primer plano. Cada sistema trae la suya: la app Terminal en macOS, Windows Terminal en Windows 11 (con WSL2 para tener un Linux de verdad) y GNOME Terminal en muchos Linux. Se le dice «emulador de terminal» porque imita a los aparatos de teclado y pantalla que en los años setenta se conectaban por cable a una computadora grande.
Analogía. El vidrio de una ventanilla de banco: por ahí pasan tus papeles y por ahí te regresan la respuesta, pero el que atiende es otro (la shell). Se rompe en que la terminal sí hace un trabajo propio: dibuja colores, guarda lo que ya salió y convierte teclas como Ctrl+C en avisos.
Ejemplo. Marta abre la app Terminal de su Mac. Lo que escribe lo lee zsh, la shell; la Terminal solo lo dibuja. Si cambia el tamaño de las letras, eso es cosa de la Terminal.
ShellshellEl programa que lee los comandos que escribes en la terminal, los parte en palabras, encuentra cada programa y lo lanza como un proceso nuevo. bash, zsh y sh son shells.Más +
Para cada línea, la shell repite un ciclo: la lee, la parte en palabras (respetando las comillas), reemplaza las variables y los comodines, busca la primera palabra como builtin o en las carpetas de PATH, lanza el proceso con fork y exec, conecta sus flujos y espera su código de salida. bash es la de casi todos los servidores Linux; zsh, la de macOS desde Catalina (2019); sh, la más básica, a veces la única en un contenedor chico. Una imagen distroless no trae ninguna. También corre archivos de comandos, los scripts.
Analogía. El que atiende en la ventanilla: lee tu papel, entiende qué pides, se lo pasa a la oficina que corresponde y te regresa la respuesta. Se rompe en que la shell no hace casi nada por sí misma: casi todo lo hacen otros programas que ella lanza.
Ejemplo. En kubectl logs gateway-7f9c | grep 504, la shell parte la línea en dos comandos, lanza kubectl y grep a la vez y conecta la salida del primero con la entrada del segundo con un tubo.
ComandocommandLo que escribes en una línea de la terminal para pedir algo: una primera palabra, que es un programa o algo que la shell (el programa que lee lo que escribes) sabe hacer, seguida de sus argumentos.Más +
La primera palabra puede ser un programa en el disco (ls es el archivo /usr/bin/ls, kubectl, python3) o un builtin, que la shell hace sin lanzar ningún proceso (cd, export, echo). cd tiene que ser builtin porque cambia la carpeta de la propia shell. type ls dice cómo va a entender la shell una palabra; which ls dice la ruta del programa. Lo demás de la línea son sus argumentos.
Ejemplo. type cd responde cd is a shell builtin; type ls responde ls is /usr/bin/ls. Si la palabra no es ninguna de las dos, la shell dice «command not found» y deja el código 127.
Argumentoargument · command-line argument · flagCada palabra que va después del comando. La shell las separa por los espacios y se las pasa al programa como una lista de textos; las que empiezan con guion son opciones (flags).Más +
Las opciones cortas llevan un guion y una letra (-n 20) y las largas, dos guiones y una palabra (--lines=20); varias cortas se juntan (ls -la). Lo demás son argumentos posicionales, casi siempre archivos. Como el espacio separa, un texto con espacios va entre comillas: las dobles todavía reemplazan variables, las simples no reemplazan nada. Una \ al final de la línea dice que el comando sigue abajo. Las opciones largas son sobre todo de los programas de GNU (Linux); los de macOS muchas veces solo aceptan las cortas. Casi todo programa explica las suyas con --help.
Ejemplo. rm mis fotos le pasa a rm dos argumentos, mis y fotos; rm "mis fotos" le pasa uno. En tail -n 20 gateway.log, -n 20 es una opción con su valor y gateway.log es el posicional.
Directorio de trabajoworking directory · current directoryLa carpeta donde está parado un proceso: desde ahí se leen las rutas relativas, las que no empiezan con /. En la terminal, pwd la muestra y cd la cambia.Más +
Cada proceso tiene el suyo y lo hereda de quien lo lanzó, así que un programa arranca en la carpeta donde estaba la shell. Una ruta relativa como datos/train.csv se busca ahí, no junto al archivo del programa. cd .. sube una carpeta, cd solo va a la carpeta personal (~) y cd - regresa a la anterior. Como cada proceso tiene su copia, un cd dentro de un hijo o de una subshell ( … ) no mueve al padre. En una imagen de contenedor, lo fija la línea WORKDIR. También se le dice «carpeta de trabajo».
Ejemplo. Parada en /home/ana/trabajo, python3 entrenar.py abre datos/train.csv como /home/ana/trabajo/datos/train.csv. (cd /tmp && pwd) imprime /tmp, y el pwd siguiente vuelve a dar /home/ana/trabajo.
Variable de entornoenvironment variable · env varUn ajuste que el proceso recibe al arrancar: un par nombre-valor, los dos de texto, que cada proceso hereda de su padre. Juntas forman un diccionario, como HOME=/home/ana o PYTHONUNBUFFERED=1.Más +
En la shell, MODELO=resnet50 crea una variable que solo vive ahí; export MODELO la pasa al entorno, y desde entonces la heredan los hijos. VAR=valor comando la pone solo para ese comando. Se lee con $VAR (mejor "$VAR") y env las lista todas; en Python están en os.environ. La herencia es una copia al nacer: un proceso que ya corre no ve los cambios del padre, y hay que reiniciarlo. Son la forma más común de configurar un servicio sin cambiar su código; la variable más famosa es PATH.
Analogía. La mochila que cada proceso recibe al nacer, con una copia de las notas de su padre. Lo que el hijo escriba en sus notas no cambia las del padre. Se rompe en que las notas son solo texto: un número o una lista hay que leerlos y convertirlos.
Ejemplo. El gateway de Alba (el marketplace que sigue el curso) arranca con PYTHONUNBUFFERED=1, TRITON_URL, INFER_TIMEOUT_S=0.15 y PREPROCESS_CONCURRENCY=2. INFER_TIMEOUT_S=0.15 python3 app.py se lo da solo a ese proceso.
PATHPATH · search pathLa variable de entorno con la lista de carpetas, separadas por :, donde la shell busca los programas, en orden. Si un programa no está en ninguna, sale «command not found» con el código 127.Más +
Cuando la primera palabra de un comando no trae /, la shell revisa cada carpeta de PATH, de izquierda a derecha, y corre el primer archivo ejecutable con ese nombre. Con / (./entrenar, /usr/bin/ls) no busca: va directo a esa ruta. La carpeta actual no está en PATH, por seguridad. Poner una carpeta al principio (PATH="$HOME/bin:$PATH") hace que sus programas ganen; activar un entorno de Python hace justo eso con su carpeta bin. No es lo mismo que una ruta: la ruta es la dirección de un archivo; PATH, una lista de carpetas donde buscar.
Ejemplo. Con PATH=/usr/local/bin:/usr/bin:/bin, python3 corre /usr/local/bin/python3 si existe, aunque también haya uno en /usr/bin. En una imagen sin /opt/venv/bin en PATH, Kubernetes reporta exec: "uvicorn": executable file not found in $PATH.
Flujos estándarstandard streams · stdin · stdout · stderrLos tres canales de texto con que nace todo proceso, numerados 0, 1 y 2: stdin para leer, stdout para los resultados y stderr para los errores y avisos. En una terminal, el 0 es el teclado y los otros dos, la pantalla.Más +
El kernel numera los archivos abiertos de cada proceso; esos números son los descriptores, y los tres primeros vienen abiertos y heredados del padre. El programa escribe en el 1 sin saber a dónde va: una terminal, un archivo con redirección o la entrada de otro programa con un tubo lo decide quien lo lanza. Separar stdout de stderr permite guardar los datos sin mezclar los errores. En un contenedor, el runtime guarda los dos en un archivo de log, y por eso docker logs y kubectl logs los muestran. Cuando stdout no es una terminal, Python lo guarda en un buffer: de ahí PYTHONUNBUFFERED=1.
Ejemplo. El gateway de Alba (el marketplace que sigue el curso) escribe una línea JSON por request a stdout; Fluent Bit la recoge y la manda a S3. Un print("aviso", file=sys.stderr) sale por el 2 y no se mezcla con esos datos.
RedirecciónredirectionPedirle a la shell que, antes de lanzar un programa, conecte uno de sus flujos (stdin, stdout o stderr) a un archivo: > manda stdout a un archivo (vaciándolo), >> agrega al final, < lee de un archivo y 2> manda los errores.Más +
2>&1 hace que el descriptor 2 apunte a donde apunta el 1 en ese momento, y la shell aplica las redirecciones de izquierda a derecha: cmd > log 2>&1 manda los dos flujos al archivo, pero cmd 2>&1 > log deja los errores en la pantalla. &> log es el atajo de bash para los dos. /dev/null es un archivo especial que se traga todo. > vacía el archivo al prepararse, antes de que corra el programa: sort log > log deja log vacío.
Ejemplo. python3 entrenar.py > entrenar.log 2>&1 guarda en el archivo los resultados y los errores; ls existe.txt noexiste.txt 2> /dev/null muestra solo existe.txt.
Tuberíapipe · pipelineConectar la salida de un programa con la entrada del siguiente con una barra vertical: cmd1 | cmd2. Los dos corren a la vez, y lo que imprime el primero no sale en la pantalla: entra al segundo.Más +
La shell le pide al kernel un tubo, un pedazo de memoria con dos extremos (64 KiB en Linux), y conecta el stdout de uno al stdin del otro. Si el tubo se llena, el que escribe espera; si se vacía, espera el que lee. Nada se guarda en un archivo intermedio, así que una tubería procesa archivos más grandes que la memoria. Así se arman herramientas con programas chicos: grep filtra, sort ordena, uniq -c cuenta repetidos seguidos, wc -l cuenta líneas, head y tail recortan, cut y awk trabajan por columnas y jq lee JSON. El código de una tubería es el del último comando, salvo con set -o pipefail.
Analogía. Una línea de ensamble: cada estación hace una sola cosa y le pasa la pieza a la siguiente, y todas trabajan al mismo tiempo. Se rompe con sort: esa estación no puede soltar nada hasta haber visto todas las piezas.
Ejemplo. grep -o '"status":[0-9]*' gateway.log | cut -d: -f2 | sort | uniq -c | sort -rn cuenta los códigos de estado de un log del gateway de Alba: 6 200, 2 504…
Comodínwildcard · glob · globbingUn carácter que la shell reemplaza por los nombres de archivo que coinciden con un patrón: * es cualquier texto, ? un carácter y [12] uno de la lista. El reemplazo pasa antes de lanzar el programa.Más +
El programa nunca ve el patrón: recibe la lista de nombres ya hecha. Por eso ls *.log y ls "*.log" no son lo mismo: entre comillas, el patrón llega tal cual. Si no coincide con nada, bash pasa el patrón literal y zsh se niega a correr el comando (no matches found). Los patrones que son para otro programa van entre comillas: find . -name "*.log". Y un rm * en la carpeta equivocada borra todo lo que ahí coincida.
Ejemplo. Con gateway-1.log, gateway-2.log y triton.log en la carpeta, echo *.log imprime los tres y echo gateway-?.log, solo los dos primeros.
Script de shellshell scriptUn archivo de texto con comandos, uno por línea, que la shell corre de arriba abajo como si los fueras tecleando. Sirve para repetir una receta igual cada vez.Más +
Dentro se usan las mismas cosas de la terminal, más "$@" (los argumentos del script), for, if y la sustitución $( … ). Se corre con bash script.sh, o con ./script.sh si tiene shebang y permiso de ejecución. Por omisión, bash sigue aunque un comando falle; por eso los scripts serios empiezan con set -euo pipefail: -e se detiene en el primer error, -u prohíbe variables que no existen (una vacía sí pasa) y -o pipefail hace que una tubería falle si falla cualquiera de sus comandos. bash -n revisa la sintaxis sin correrlo y ShellCheck encuentra trampas comunes. Cada paso run: de un CI (las pruebas automáticas de cada cambio) es un script.
Ejemplo. En Alba, bash model/build_engine.sh construye el engine de TensorRT y se niega a correr si la GPU no es una T4. Sin pipefail, grep x no-existe.log | wc -l termina con 0 aunque grep haya fallado.
Shebangshebang · hashbang · #!La primera línea de un script (un archivo de comandos) que empieza con #! y dice con qué programa se corre, como #!/usr/bin/env bash. La lee el kernel al ejecutar el archivo.Más +
Al ejecutar un archivo de texto, el kernel ve los caracteres #!, toma el resto de la línea como el intérprete y lo lanza con el script como argumento. #!/bin/bash pide exactamente esa bash (en una Mac, una muy vieja, de la serie 3.2); #!/usr/bin/env bash busca bash en PATH, y es la forma más portátil; #!/bin/sh pide la shell básica, que en Debian es dash y no entiende todo lo de bash. Para que ./script.sh funcione, el archivo necesita el permiso x (chmod +x); sin él, sale «Permission denied» con el código 126. El nombre probablemente viene de sharp o hash (#) y bang (!); su origen exacto no se sabe.
Ejemplo. Un contar.sh que empieza con #!/usr/bin/env bash: ./contar.sh tres.txt da 126 hasta que chmod +x contar.sh lo vuelve ejecutable (-rwxr-xr-x). bash contar.sh funciona siempre, porque ahí el programa que corre es bash.
sudosudo · superuser doEl comando para correr otro comando como root, el usuario que puede todo, sin entrar como root: sudo systemctl restart docker. Pide tu contraseña, revisa si tienes permiso y anota quién hizo qué.Más +
Entrar a un servidor como root le da poder total a cualquier error de dedo; con sudo, el poder se pide comando por comando y queda registrado. En un contenedor casi nunca hay sudo: la imagen ya trae lo que necesita y el proceso corre con el usuario que dice su receta (root si no dice otra cosa; mejor, uno sin privilegios). Agregarlo solo le daría a un atacante una forma de subir de privilegios. Nunca se corre con sudo un comando pegado de internet sin entenderlo.
Ejemplo. En un nodo con GPU, sudo systemctl restart docker reinicia Docker después de instalar el NVIDIA Container Toolkit. En un contenedor típico, que no trae sudo, el comando da command not found y el código 127.
sshssh · secure shellEl programa para abrir una shell en otra computadora a través de la red, con todo cifrado: ssh marta@gw-node. Para probar quién eres usa casi siempre un par de llaves, una privada que no sale de tu laptop y una pública en el servidor.Más +
Lo que tecleas lo lee una shell en la otra máquina, y los procesos corren allá; tu terminal solo dibuja. Usa el puerto 22 por omisión. La llave privada (por ejemplo ~/.ssh/id_ed25519, el tipo que ssh-keygen crea por omisión desde OpenSSH 9.5) se guarda con permisos 600, y ssh se niega a usarla si otros la pueden leer; la pública se copia al servidor. ssh host 'comando' corre un solo comando allá: lo que va entre comillas lo resuelve la shell remota, y lo de afuera, la tuya. ssh -L 8000:localhost:8000 host abre un túnel desde tu puerto 8000 hasta el 8000 del servidor. Si se corta la conexión, los procesos de la sesión reciben SIGHUP; por eso los trabajos largos van en tmux o con nohup.
Analogía. Un control remoto con cable largo: los botones están en tu mano, pero la tele que obedece está en otro cuarto. Se rompe en que el cable va cifrado y en que puedes pedirle a la tele de allá que te mande solo lo que te interesa, en vez de todo.
Ejemplo. Buscar 9f2c41d0 en un log de 3 GB: ssh marta@gw-node 'grep 9f2c41d0 /var/log/gateway.log' lo lee allá en ≈ 6 s y trae dos líneas; bajarlo con una red de 100 Mb/s tardaría ≈ 4 minutos.
Chequeo
EsencialCheck
Intenta responder en tu cabeza antes de abrir cada respuesta.
1¿Cuál es la diferencia entre la terminal y la shell?Ver respuesta
La terminal es la ventana: pasa lo que tecleas y dibuja el texto que recibe. La shell es el programa que corre adentro: lee la línea, la parte en palabras, busca el programa y lo lanza. bash, zsh y sh son shells.
2¿Por qué
rm mis fotosno borra el archivo «mis fotos»?Ver respuestaPorque la shell separa los argumentos por los espacios:
rmrecibemisyfotos, dos nombres distintos. Para que sea uno, va entre comillas:rm "mis fotos".3¿Qué es PATH y qué pasa si un programa no está en ninguna de sus carpetas?Ver respuesta
Una variable de entorno con una lista de carpetas, separadas por
:, donde la shell busca los programas en orden. Si no lo encuentra en ninguna, responde «command not found» con el código 127.4Si haces
export MODELO=resnet50en tu terminal, ¿lo ve un servidor que ya estaba corriendo?Ver respuestaNo. Las variables se copian al nacer cada proceso, de padre a hijo. Un proceso que ya existía tiene su propia copia; hay que reiniciarlo para que vea el valor nuevo.
5¿Qué hace
grep 504 gateway.log | wc -l, y cuántos procesos corren?Ver respuestaDos procesos a la vez, unidos por un tubo:
grepdeja pasar las líneas que contienen 504 ywc -llas cuenta. Lo que imprimegrepno sale en la pantalla: entra awc.6¿Qué pide cada letra de
set -euo pipefail?Ver respuesta-e: detenerse en el primer comando que falle.-u: error si se usa una variable que no existe.-o pipefail: que una tubería falle si falla cualquiera de sus comandos, no solo el último.7¿Por qué no hay
sudodentro de un contenedor?Ver respuestaPorque la imagen ya trae lo que necesita y el proceso corre con el usuario que dice su receta. No hay nada que instalar como root mientras corre, y agregar
sudosolo le daría a un atacante una forma de subir de privilegios.