Deploy or Die: tu primer servidor web con nginx
Tus primeros pasos en DevOps: explorá un servidor Ubuntu, instalá nginx, publicá a mano el juego Roxs Runner y automatizá el deploy con un script en bash que podés correr las veces que quieras.

Objetivo del laboratorio
Te toca una máquina Ubuntu recién creada, vacía, y un juego que tiene que estar online antes de que termine la sesión. En el camino vas a hacer lo mismo que hace cualquier persona de DevOps el primer día con un servidor nuevo:
- Conocer la máquina: quién sos, qué sistema es, cuánto disco y memoria tiene, y dónde vive cada cosa.
- Instalar un servidor web (nginx) y entender qué archivos agregó y dónde.
- Publicar a mano el juego Roxs Runner, un arcade hecho con HTML, CSS y JavaScript, sin build ni backend.
- Automatizar lo que hiciste a mano con un script en bash,
deploy.sh, que podés correr una y otra vez y siempre deja el sitio en el mismo estado.
Cuando termines vas a tener el juego corriendo en una URL que podés abrir desde tu navegador y compartir, y un script que lo vuelve a publicar con un solo comando.
Dónde estás en el camino. Para aprender DevOps paso a paso, el roadmap que siempre recomendamos es el de roadmap.sh/devops. Este lab es el primer tramo. El diagrama sigue las etapas de ese roadmap: en naranja, las cinco que tocás hoy; en amarillo, dos que vas a ver de pasada.



Lo que vas a dejar armado
El diagrama de arriba muestra qué pasa cuando alguien abre la URL. Este muestra todo lo que queda en la máquina cuando terminás: el repo clonado, tu deploy.sh, la configuración del sitio en /etc/nginx, el web root, los logs y cómo llega tu navegador. Abajo, en rosa, los extras de los desafíos, que son opcionales.

Este laboratorio es para explorar. Cada vez que toques una ruta del sistema (/etc/nginx, /var/www, /var/log...) te vamos a contar qué es y para qué sirve. Las cajas 🧭 Para explorar son opcionales: si te sobra un minuto, metete. Romper cosas en esta máquina está permitido: es descartable.
Cómo usar esta guía
El playground es el oficial Ubuntu 24.04 de iximiuz Labs: una única máquina virtual llamada ubuntu-01, con el usuario laborant, que puede usar sudo sin contraseña. Todos los comandos se ejecutan ahí, salvo que se indique otra cosa.
Cada paso tiene la misma forma: el comando, lo que deberías ver y una tabla 🔍 que explica sus partes. Los bloques ::simple-task verifican solos, sobre la máquina, que cada bloque quedó resuelto.
En este laboratorio la IA trabaja como un copiloto: te puede ayudar a escribir el script de deploy, y vos decidís qué entra y qué no. Usá el asistente que prefieras (ChatGPT, Claude, Gemini, Copilot o Kiro) y seguí siempre el mismo ciclo: pedir con un contrato claro, revisar lo que genera y probar con un comando. Nunca pegues secretos en un prompt.
El reloj
La sesión del playground dura 50 minutos. Cuando se termina, la máquina se borra con todo lo que tenga adentro. El recorrido principal está pensado para unos 40 minutos y deja el resto para los desafíos:
| Bloque | Qué hacés | Tiempo |
|---|---|---|
| A | Conocer la máquina | ~5 min |
| B | Instalar nginx y recorrerlo por dentro | ~10 min |
| C | Publicar el juego a mano | ~10 min |
| D | Automatizar el deploy con deploy.sh | ~15 min |
| E | Desafíos 🟢🟡🔴 | ~10 min o más |
Si querés guardar tu deploy.sh, antes de que termine la sesión mostralo con cat ~/deploy.sh y copialo a tu computadora.
Leé antes de arrancar. El reloj empieza a correr cuando hacés clic en START TUTORIAL, el botón de arriba de la página que levanta el playground. Antes de apretarlo, recorré la guía completa y los desafíos del Bloque E: así sabés a dónde vas a llegar y aprovechás mejor los 50 minutos.
Ver el juego en tu navegador
El juego va a correr dentro de la máquina, así que localhost solo funciona desde su terminal. Para abrirlo en tu navegador tenés que exponer el puerto. Hay dos formas:
- Con un clic: cuando llegues al Paso 06, usá el enlace Abrir el puerto 80 de ubuntu-01.
- Desde el menú: abrí el menú ⋮ (o el botón de exponer puertos) de la esquina superior derecha del playground, elegí Expose HTTP port, la máquina
ubuntu-01y el puerto80. En Exposed ports aparece una URL: abrila.

Qué conviene saber sobre la exposición de puertos. La URL es privada por defecto: solo la abrís vos, con tu sesión. Con la opción Public podés compartirla con otras personas para que jueguen. Solo se pueden exponer servicios que escuchen en la interfaz de red principal de la máquina (o en todas, 0.0.0.0), no los que escuchan solo en localhost. Para comprobarlo, corré curl http://ubuntu-01 desde la terminal: si responde, se puede exponer.
Vocabulario mínimo
- Servidor web: programa que recibe pedidos HTTP (por ejemplo, de tu navegador) y devuelve archivos o respuestas. Acá vas a usar nginx, uno de los servidores web más usados del mundo.
- Paquete: programa empaquetado para instalarse con el gestor del sistema. En Ubuntu el gestor es apt.
- Servicio: programa que corre en segundo plano y arranca solo con la máquina. Los maneja systemd con el comando
systemctl. - Web root: la carpeta de donde el servidor web saca los archivos que sirve.
- Deploy: llevar una versión de tu aplicación al servidor donde la gente la usa.
- Idempotente: que lo podés repetir muchas veces y el resultado final es siempre el mismo.
Bloque A · Conocer la máquina
Antes de instalar nada en un servidor, conviene saber dónde estás parado. Son comandos que solo leen: no cambian nada.
Paso 01 · ¿Quién soy y en qué máquina estoy?
whoami
hostname
cat /etc/os-release
Deberías ver: laborant, ubuntu-01, y varias líneas sobre el sistema, entre ellas PRETTY_NAME="Ubuntu 24.04..." y VERSION_CODENAME=noble.
🔍 Qué hace cada comando
| Comando | Qué hace |
|---|---|
whoami | Muestra con qué usuario estás trabajando. laborant es un usuario común; para tareas de administración vas a anteponer sudo. |
hostname | Muestra el nombre de la máquina en la red. Otras máquinas la encuentran por ese nombre. |
cat /etc/os-release | cat muestra el contenido de un archivo. /etc/os-release es el archivo donde el sistema declara qué distribución y versión es. |
Paso 02 · ¿Cuánto disco, memoria y red tengo?
df -h /
free -h
ip -br a
Deberías ver: el tamaño del disco y cuánto está usado, la memoria total y disponible, y una lista de interfaces de red. lo es la interfaz de loopback (127.0.0.1, o sea localhost: la máquina hablando consigo misma). La otra (por ejemplo eth0) tiene una IP privada del estilo 172.16.0.x: por ahí entra el tráfico de la red.
🔍 Qué hace cada comando
| Comando | Qué hace |
|---|---|
df -h / | Espacio en disco del sistema de archivos montado en /. -h muestra los tamaños en un formato legible (G, M) en vez de bloques. |
free -h | Memoria RAM total, usada y disponible. Mirá la columna available: es la que de verdad podés usar. |
ip -br a | Las interfaces de red y sus direcciones IP, en formato breve (-br). Sin -br (ip a) ves el detalle completo. |
Paso 03 · El mapa de carpetas
En Linux todo cuelga de una única raíz, /. No hay C: ni D:: discos, configuraciones y programas aparecen como carpetas dentro de ese árbol.
ls /
ls /etc | head
ls /var
ls /home
ls /usr/bin | wc -l
Deberías ver: las carpetas de la raíz (bin, etc, home, usr, var...), los primeros archivos de configuración de /etc, el contenido de /var, tu carpeta en /home y la cantidad de programas instalados en /usr/bin (son cientos).
Estas son las carpetas que vas a tocar en este laboratorio:
| Ruta | Qué es | Para qué la vas a usar |
|---|---|---|
/ | La raíz de todo el sistema de archivos. | Punto de partida de cualquier ruta absoluta. |
/etc | Configuración del sistema y de los programas instalados. Son archivos de texto. | La configuración de nginx vive en /etc/nginx. |
/var | Datos que cambian mientras el sistema corre: logs, cachés, sitios web. | Los archivos del juego van a /var/www y los logs están en /var/log. |
/home | Las carpetas personales de cada usuario. ~ es un atajo a la tuya: /home/laborant. | Ahí clonás el código y guardás tu deploy.sh. |
/usr | Programas y librerías instalados por el sistema. /usr/bin y /usr/sbin tienen los ejecutables. | Ahí va a quedar el ejecutable de nginx. |

Para cerrar el bloque, guardá un resumen de tu máquina en un archivo:
{ whoami; hostname; grep PRETTY_NAME /etc/os-release; df -h / | tail -n 1; free -h | grep Mem; } > ~/mi-maquina.txt
cat ~/mi-maquina.txt
Deberías ver: cinco líneas con tu usuario, el nombre de la máquina, la versión de Ubuntu, el disco y la memoria.
🔍 Qué hace cada parte
| Parte | Qué hace |
|---|---|
{ ...; ...; } | Agrupa varios comandos para tratar su salida como una sola. |
> | Redirige la salida a un archivo en vez de a la pantalla. Si el archivo existe, lo reemplaza. |
grep PRETTY_NAME | Filtra y deja solo las líneas que contienen ese texto. |
tail -n 1 | Se queda con la última línea. |
🧭 Para explorar · ¿Qué más hay en la raíz?
ls -la ~: los archivos que empiezan con.están ocultos..bashrcconfigura tu terminal.cat /etc/hostname: el nombre de la máquina también es un archivo en/etc.ls /tmp: archivos temporales. Cualquiera puede escribir ahí y se borra al reiniciar.uptime: hace cuánto está prendida la máquina y cuánta carga tiene.
Bloque B · Instalar nginx
Paso 04 · Instalar paquetes con apt
sudo apt update
sudo apt install -y nginx git curl
nginx -v
which nginx
Deberías ver: apt update descargando las listas de paquetes, después la instalación de nginx (y de git y curl si faltaban), y al final algo como nginx version: nginx/1.24.0 (Ubuntu) y la ruta /usr/sbin/nginx.
🔍 Qué hace cada comando
| Comando | Qué hace |
|---|---|
sudo | Ejecuta el comando como root, el administrador. Instalar programas cambia el sistema, por eso lo necesita. |
apt update | Actualiza la lista de paquetes disponibles (se guarda en /var/lib/apt/lists). No instala nada. |
apt install -y nginx git curl | Instala los tres paquetes. -y responde "sí" a la confirmación. |
which nginx | Dice en qué carpeta está el ejecutable. /usr/sbin es donde van los programas de administración. |
Paso 05 · nginx como servicio
nginx funciona como servicio: un proceso en segundo plano que maneja systemd. En muchos servidores queda corriendo apenas se instala, pero en este playground no. Comprobalo:
systemctl is-active nginx
cat /usr/sbin/policy-rc.d
Deberías ver: inactive, y un script corto que termina en exit 101. Ese archivo le avisa a apt que no arranque servicios al instalarlos. Es común en imágenes de contenedores y máquinas de laboratorio, donde no conviene que algo se encienda sin que lo pidas.
Arrancalo vos, y dejalo habilitado para que arranque solo cada vez que se prende la máquina:
sudo systemctl enable --now nginx
systemctl status nginx --no-pager
sudo ss -lntp | grep nginx
curl -s localhost | head -n 5
Deberías ver: Active: active (running) en verde, nginx escuchando en 0.0.0.0:80 (todas las interfaces, puerto 80) y el comienzo de un HTML con el título Welcome to nginx!.
🔍 Qué hace cada comando
| Comando | Qué hace |
|---|---|
systemctl is-active nginx | Responde en una palabra si el servicio está corriendo: active o inactive. |
/usr/sbin/policy-rc.d | Si existe y termina con exit 101, apt instala los servicios pero no los arranca. |
systemctl enable --now nginx | enable lo deja configurado para arrancar cada vez que se prende la máquina; --now además lo arranca en este momento. |
systemctl status nginx | Estado del servicio: si está activo, desde cuándo, sus procesos y las últimas líneas de su log. --no-pager imprime todo de una, sin quedarse esperando. |
ss -lntp | Lista los puertos que están escuchando (-l), TCP (-t), en números (-n) y con el proceso dueño (-p, por eso el sudo). |
curl -s localhost | Hace un pedido HTTP a esta misma máquina, como lo haría un navegador, y muestra la respuesta. -s oculta la barra de progreso. |
head -n 5 | Muestra solo las primeras 5 líneas. |
El puerto 80 es el puerto estándar de HTTP. Cuando escribís una dirección http:// sin puerto, el navegador va al 80. Por eso curl localhost y curl localhost:80 son lo mismo.
Paso 06 · Verlo en tu navegador
Exponé el puerto 80 (ver Ver el juego en tu navegador) o usá el enlace Abrir el puerto 80 de ubuntu-01.
Deberías ver: la página Welcome to nginx!. Es tu servidor, sirviendo una página de ejemplo a través de internet. Dejá esa pestaña abierta: en el Bloque C se va a convertir en el juego.
Si la URL no carga, probá desde la terminal curl -s http://ubuntu-01 | head -n 5: si eso responde, el problema está en la exposición del puerto y no en nginx.
Paso 07 · Recorrer nginx por dentro
Instalar un paquete no es magia: deja archivos en lugares concretos. Vamos a encontrarlos.
ls -la /etc/nginx/
ls -la /etc/nginx/sites-available/ /etc/nginx/sites-enabled/
grep -vE '^\s*(#|$)' /etc/nginx/sites-available/default
ls -la /var/www/html/
ls -la /var/log/nginx/
sudo tail -n 3 /var/log/nginx/access.log
Deberías ver:
- En
/etc/nginx/el archivo principalnginx.confy las carpetassites-available,sites-enabledyconf.d, entre otras. - En
sites-enabled/,defaultaparece como un enlace (default -> /etc/nginx/sites-available/default). - La configuración del sitio
defaultsin comentarios:listen 80 default_server,root /var/www/htmleindex index.html index.htm index.nginx-debian.html. - En
/var/www/html/el archivoindex.nginx-debian.html: la página de bienvenida que viste en el navegador. - En
/var/log/nginx/los archivosaccess.logyerror.log, y en las últimas líneas del primero, tus pedidos concurl.
Estas son las rutas que acabás de recorrer:
| Ruta | Qué es | Para qué sirve |
|---|---|---|
/etc/nginx/nginx.conf | La configuración principal de nginx. | Define cosas globales (con qué usuario corre, dónde escribe los logs) e incluye el resto de los archivos. |
/etc/nginx/sites-available/ | Los sitios disponibles: un archivo por sitio. | Acá escribís la configuración de cada sitio. Estar acá no lo activa. |
/etc/nginx/sites-enabled/ | Los sitios habilitados: enlaces a archivos de sites-available. | nginx solo carga lo que está acá. Habilitar un sitio es crear el enlace; deshabilitarlo, borrarlo. |
/var/www/html/ | El web root del sitio default. | De ahí salen los archivos que viste en el navegador. |
/var/log/nginx/access.log | Un renglón por cada pedido que recibe nginx. | Saber quién pidió qué, cuándo y qué respuesta recibió. |
/var/log/nginx/error.log | Los errores y advertencias de nginx. | El primer lugar donde mirar cuando algo no anda. |
🔍 Qué hace cada comando
| Comando | Qué hace |
|---|---|
ls -la | Lista todo (-a, incluso ocultos) en formato largo (-l): permisos, dueño, tamaño, fecha. Una l al principio de la línea indica un enlace. |
grep -vE '^\s*(#|$)' | Muestra las líneas que no (-v) son comentarios ni líneas vacías. Sirve para leer configuraciones llenas de comentarios. |
sudo tail -n 3 archivo | Las últimas 3 líneas de un archivo. Los logs de nginx solo los puede leer root (o el grupo adm), por eso el sudo. |
🧭 Para explorar · ¿Con qué usuario corre nginx?
grep -E '^\s*(user|include|access_log|error_log)' /etc/nginx/nginx.conf
ps -o user,pid,cmd -C nginx
Vas a ver que hay un proceso master que corre como root (para poder abrir el puerto 80) y varios worker que corren como www-data, un usuario sin privilegios creado para servidores web. Los workers son los que leen los archivos que servís: tenelo en mente para el Bloque C.
Bloque C · Publicar el juego a mano
El juego son cuatro archivos estáticos: index.html, style.css, game.js y la imagen roxsfest.png. No hace falta compilar nada: alcanza con que nginx los sirva. El único requisito es que roxsfest.png quede en la misma carpeta que index.html, porque el código la carga como ./roxsfest.png.
Paso 08 · Traer el código con git
cd ~
git clone https://github.com/roxsross/roxs-runner-fest.git
ls -la ~/roxs-runner-fest
Deberías ver: la carpeta ~/roxs-runner-fest con index.html, style.css, game.js, roxsfest.png, un README.md, un PROMPT.md y la carpeta oculta .git.
🔍 Qué hace cada comando
| Comando | Qué hace |
|---|---|
cd ~ | Te mueve a tu carpeta personal (/home/laborant). |
git clone <url> | Descarga el repositorio completo, con su historia, en una carpeta con el mismo nombre. |
.git | La carpeta donde git guarda la historia del proyecto. No la vamos a publicar: no es parte del sitio. |
Para pensar: ¿por qué no servimos el juego directamente desde ~/roxs-runner-fest? Pista: ¿qué otros archivos hay ahí que no querés que vea todo el mundo?
Paso 09 · Copiar al web root con el dueño correcto
sudo mkdir -p /var/www/runner
sudo cp ~/roxs-runner-fest/{index.html,style.css,game.js,roxsfest.png} /var/www/runner/
sudo chown -R www-data:www-data /var/www/runner
sudo chmod -R u=rwX,go=rX /var/www/runner
ls -la /var/www/runner
Deberías ver: los cuatro archivos con dueño www-data www-data y permisos -rw-r--r--. La carpeta misma aparece como drwxr-xr-x.
🔍 Qué hace cada comando
| Comando | Qué hace |
|---|---|
mkdir -p /var/www/runner | Crea la carpeta del sitio. -p no falla si ya existe. /var/www es donde, por convención, viven los sitios web. |
cp ~/roxs-runner-fest/{a,b,c} | Copia solo los archivos que nombrás. Las llaves {} son un atajo de bash: se expanden a una ruta por cada nombre. |
chown -R www-data:www-data | Cambia el dueño (usuario:grupo) de la carpeta y de todo lo que tiene adentro (-R). |
chmod -R u=rwX,go=rX | Permisos: el dueño (u) lee y escribe; el grupo (g) y el resto (o) solo leen. La X mayúscula da permiso de entrar a las carpetas, sin volver ejecutables a los archivos. |
Cómo leer -rw-r--r--: el primer carácter es el tipo (- archivo, d carpeta, l enlace). Después vienen tres grupos de tres letras, para el dueño, el grupo y el resto: r leer, w escribir, x ejecutar (o entrar, en una carpeta).
Para pensar: los workers de nginx corren como www-data y solo necesitan leer estos archivos. ¿Qué podría pasar si alguien lograra que nginx escriba en esa carpeta?
Paso 10 · Configurar el sitio
Ahora le decís a nginx que hay un sitio nuevo y de qué carpeta salen sus archivos. Escribí la configuración en sites-available:
sudo tee /etc/nginx/sites-available/runner > /dev/null << 'EOF'
server {
listen 80 default_server;
listen [::]:80 default_server;
server_name _;
root /var/www/runner;
index index.html;
location / {
try_files $uri $uri/ =404;
}
}
EOF
🔍 Qué dice cada línea
| Línea | Qué hace |
|---|---|
server { ... } | Un bloque por sitio. Todo lo de adentro aplica a este sitio. |
listen 80 default_server; | Escucha en el puerto 80 (IPv4) y es el sitio que responde si ningún otro coincide. La línea con [::] hace lo mismo en IPv6. |
server_name _; | _ es un comodín: responde a cualquier nombre de dominio. |
root /var/www/runner; | La carpeta de donde salen los archivos. Si piden /game.js, nginx busca /var/www/runner/game.js. |
index index.html; | Qué archivo servir cuando piden una carpeta, por ejemplo /. |
try_files $uri $uri/ =404; | Busca el archivo pedido; si no existe, busca una carpeta con ese nombre; si tampoco existe, responde 404. |
sudo tee archivo > /dev/null | tee escribe en el archivo lo que recibe. Se usa con sudo porque sudo cat > archivo no funciona: la redirección > la hace tu usuario, no root. > /dev/null descarta la copia que tee imprime en pantalla. |
Habilitá el sitio nuevo, deshabilitá el de bienvenida, validá y recargá:
sudo ln -sf /etc/nginx/sites-available/runner /etc/nginx/sites-enabled/runner
sudo rm -f /etc/nginx/sites-enabled/default
ls -la /etc/nginx/sites-enabled/
sudo nginx -t
sudo systemctl reload-or-restart nginx
sleep 1
curl -s localhost | grep -o '<title>.*</title>'
Deberías ver: en sites-enabled solo el enlace runner -> /etc/nginx/sites-available/runner; después syntax is ok y test is successful; y al final <title>ROXS RUNNER · Deploy or Die!</title>.
🔍 Qué hace cada comando
| Comando | Qué hace |
|---|---|
ln -sf origen enlace | Crea un enlace simbólico: un acceso directo que apunta al archivo original. Así habilitás el sitio sin copiar su configuración. -f lo reemplaza si ya existe, así podés repetir el paso sin error. |
rm -f /etc/nginx/sites-enabled/default | Borra solo el enlace. -f evita el error si ya lo habías borrado. El archivo original sigue en sites-available/default: lo podés volver a habilitar cuando quieras. Hace falta porque dos sitios no pueden ser default_server en el mismo puerto. |
nginx -t | Valida la configuración sin aplicarla. Si hay un error, te dice en qué archivo y en qué línea. Correlo siempre antes de recargar. |
systemctl reload-or-restart nginx | Aplica la configuración nueva sin cortar las conexiones abiertas. Si nginx estaba detenido, lo arranca: un reload solo fallaría con nginx.service is not active, cannot reload. |
sleep 1 | Espera un segundo. El reload es gradual: nginx arranca procesos nuevos con la configuración nueva y deja que los viejos terminen lo que estaban atendiendo. Un pedido hecho en ese instante todavía puede ver la configuración anterior. |
🧭 Para explorar · Romper la configuración a propósito
sudo sed -i 's/index index.html;/index index.html/' /etc/nginx/sites-available/runner
sudo nginx -t
Le sacaste un ;. nginx -t te dice exactamente qué archivo y qué línea fallan, y como no recargaste, el sitio sigue funcionando con la configuración anterior. Arreglalo y volvé a validar:
sudo sed -i 's/index index.html$/index index.html;/' /etc/nginx/sites-available/runner
sudo nginx -t
Esa es la razón de validar antes de recargar: un error de tipeo no te tira el sitio.
Paso 11 · Jugar y mirar los logs en vivo
Recargá la pestaña del navegador donde estaba Welcome to nginx! (o volvé a abrir el puerto 80). Ahora tenés el juego.
Deberías ver: la pantalla de ROXS RUNNER con el personaje de Roxs en pixel art. Si en lugar de la imagen aparece un cuadro vacío, roxsfest.png no llegó a /var/www/runner.

Mientras jugás, mirá lo que registra el servidor:
sudo tail -f /var/log/nginx/access.log
Deberías ver: una línea nueva por cada archivo que pide el navegador: GET /, GET /style.css, GET /game.js, GET /roxsfest.png, cada una con el código de respuesta (200 si salió bien, 304 si el navegador ya lo tenía guardado). Recargá la página y mirá cómo aparecen. Salí con Ctrl+C.
🔍 Cómo leer una línea del access.log
172.16.0.1 - - [30/Sep/2026:14:02:11 +0000] "GET /game.js HTTP/1.1" 200 14295 "https://..." "Mozilla/5.0 ..."
| Parte | Qué es |
|---|---|
172.16.0.1 | La IP desde donde vino el pedido. Por la exposición del puerto, vas a ver la del proxy del playground. |
[30/Sep/2026:14:02:11 +0000] | Fecha y hora del pedido. |
"GET /game.js HTTP/1.1" | El método, el archivo pedido y la versión de HTTP. |
200 | El código de respuesta: 200 bien, 304 sin cambios, 404 no existe, 403 prohibido, 5xx error del servidor. |
14295 | Bytes enviados. |
"Mozilla/5.0 ..." | El programa que hizo el pedido (navegador, curl...). |

Bloque D · Automatizar el deploy con bash
Paso 12 · De pasos sueltos a un contrato
Repasá lo que hiciste en el Bloque C. Si mañana hay una versión nueva del juego, tendrías que repetir: traer el código, copiar los archivos, arreglar dueño y permisos, validar nginx, recargar y comprobar que anda. Seis pasos, cada uno con su oportunidad de olvidarte de algo.
Un script de deploy convierte esa lista en un solo comando. Antes de escribirlo (o de pedírselo a tu copiloto de IA), fijá el contrato: qué tiene que hacer, en qué orden y cuándo tiene que frenar.
| # | Paso | Si falla... |
|---|---|---|
| 1 | Si ~/roxs-runner-fest ya existe, actualizarlo con git pull; si no, clonarlo. | Frena. |
| 2 | Verificar que estén los cuatro archivos del juego antes de tocar el sitio. | Frena sin tocar nada. |
| 3 | Copiarlos a /var/www/runner, con dueño www-data y permisos de solo lectura para los demás. | Frena. |
| 4 | Validar la configuración con nginx -t y recargar nginx. | Frena: no recarga una configuración rota. |
| 5 | Pedir el sitio con curl y comprobar que devuelve el juego y la imagen. | Termina con error. |
Y una regla más: correrlo dos veces seguidas tiene que dejar todo igual. Eso es la idempotencia, y es lo que te permite correr el deploy sin miedo.

Paso 13 · Escribir deploy.sh
Escribilo a mano copiando este bloque en la terminal. Leelo con calma: cada parte corresponde a una fila del contrato.
cat > ~/deploy.sh << 'EOF'
#!/usr/bin/env bash
# deploy.sh · publica roxs-runner-fest en nginx
# Uso: ./deploy.sh (se puede correr las veces que quieras)
set -euo pipefail
# --- Configuración -------------------------------------------------------
REPO_URL="https://github.com/roxsross/roxs-runner-fest.git"
SRC_DIR="$HOME/roxs-runner-fest" # dónde vive el código clonado
WEB_ROOT="/var/www/runner" # carpeta que sirve nginx
ARCHIVOS="index.html style.css game.js roxsfest.png"
SITE_URL="http://localhost"
log() { echo "[deploy $(date +%H:%M:%S)] $*"; }
# --- 1. Traer el código --------------------------------------------------
if [ -d "$SRC_DIR/.git" ]; then
log "1/5 Actualizando el código en $SRC_DIR"
git -C "$SRC_DIR" pull --ff-only --quiet
else
log "1/5 Clonando $REPO_URL"
git clone --quiet "$REPO_URL" "$SRC_DIR"
fi
# --- 2. Verificar que no falte nada ANTES de tocar el sitio -------------
log "2/5 Verificando archivos"
for archivo in $ARCHIVOS; do
[ -f "$SRC_DIR/$archivo" ] || { echo "ERROR: falta $archivo en $SRC_DIR" >&2; exit 1; }
done
# --- 3. Copiar al web root con dueño y permisos correctos ---------------
log "3/5 Copiando a $WEB_ROOT"
sudo mkdir -p "$WEB_ROOT"
for archivo in $ARCHIVOS; do
sudo cp "$SRC_DIR/$archivo" "$WEB_ROOT/"
done
sudo chown -R www-data:www-data "$WEB_ROOT"
sudo chmod -R u=rwX,go=rX "$WEB_ROOT"
# --- 4. Validar la configuración y recargar nginx -----------------------
log "4/5 Validando y recargando nginx"
sudo nginx -t -q
sudo systemctl reload-or-restart nginx
sleep 1 # el reload es gradual: le damos un segundo
# --- 5. Comprobar que el sitio responde ---------------------------------
log "5/5 Verificando $SITE_URL"
curl -fsS "$SITE_URL/" | grep -q "ROXS RUNNER" \
|| { echo "ERROR: el sitio no devuelve el juego" >&2; exit 1; }
curl -fsS -o /dev/null "$SITE_URL/roxsfest.png" \
|| { echo "ERROR: no se sirve roxsfest.png" >&2; exit 1; }
log "Deploy OK · commit $(git -C "$SRC_DIR" rev-parse --short HEAD)"
EOF
chmod +x ~/deploy.sh
ls -la ~/deploy.sh
Deberías ver: ~/deploy.sh con permisos -rwxr-xr-x: la x indica que ahora es ejecutable.
🤖 Prompt · Generar deploy.sh con tu copiloto de IA
Si preferís que tu copiloto de IA escriba el script, pasale el contrato completo. Cuanto más preciso el pedido, menos tenés que corregir después.
Escribí un script en bash llamado deploy.sh para Ubuntu 24.04 que publique un
sitio estático en nginx. Lo corre el usuario laborant, que tiene sudo sin
contraseña. El script NO configura nginx: el sitio ya existe en
/etc/nginx/sites-available/runner y sirve /var/www/runner.
Contrato, en este orden:
1. Si $HOME/roxs-runner-fest ya es un repositorio git, actualizarlo con
git pull --ff-only. Si no, clonar https://github.com/roxsross/roxs-runner-fest.git ahí.
2. Verificar que existan index.html, style.css, game.js y roxsfest.png en el
repositorio ANTES de tocar el sitio. Si falta alguno, terminar con error.
3. Copiar SOLO esos cuatro archivos a /var/www/runner (crearla si no existe),
con dueño www-data:www-data y permisos u=rwX,go=rX.
4. Validar la configuración con "sudo nginx -t" y recargar con
"sudo systemctl reload-or-restart nginx".
5. Comprobar con curl que http://localhost/ contiene el texto "ROXS RUNNER" y
que http://localhost/roxsfest.png responde sin error. Si no, terminar con error.
Requisitos:
- Primera línea #!/usr/bin/env bash y después set -euo pipefail.
- Las rutas, la URL del repo y la URL del sitio en variables al principio.
- Un mensaje corto por cada paso (1/5, 2/5...) y, al final, el commit desplegado.
- Tiene que poder correrse muchas veces seguidas y dejar siempre el mismo resultado.
- Nada de rm -rf, nada de git reset --hard, sin dependencias además de git, curl y nginx.
Devolvé solo el script, en un bloque de código.
Antes de correr lo que te devuelva, revisalo contra esta lista:
- ¿Empieza con
#!/usr/bin/env bashyset -euo pipefail? - ¿Verifica los archivos antes de copiar? Si copia primero y verifica después, un repo incompleto te rompe el sitio.
- ¿Corre
nginx -tantes dereload? - ¿Tiene algún
rm -rfcon una variable? Si la variable quedara vacía, podría borrar algo que no querías. Sacalo. - ¿Usa
sudosolo donde hace falta (escribir en/var/wwwy manejar nginx)?
Si algo no cumple, devolvéselo citando el requisito. Guardalo en ~/deploy.sh (con nano ~/deploy.sh, o con cat > ~/deploy.sh << 'EOF' como en el bloque de arriba) y hacelo ejecutable con chmod +x ~/deploy.sh. Si después de un par de intentos no cumple el contrato, usá el script de arriba.
🔍 Las piezas clave de deploy.sh
| Pieza | Qué hace |
|---|---|
#!/usr/bin/env bash | El shebang: le dice al sistema que este archivo se ejecuta con bash. |
set -e | Si cualquier comando falla, el script termina ahí. Sin esto, seguiría como si nada. |
set -u | Usar una variable que no existe es un error. Te salva de tipeos como $WEB_ROT. |
set -o pipefail | En una cadena a | b, si falla a, falla toda la cadena (normalmente solo cuenta b). |
REPO_URL=..., WEB_ROOT=... | Variables: si algo cambia, lo cambiás en un solo lugar. Siempre usalas entre comillas: "$WEB_ROOT". |
log() { ... } | Una función: un mensaje con la hora, para seguir en qué paso va el script. |
if [ -d "$SRC_DIR/.git" ] | ¿Ya está clonado? Entonces pull; si no, clone. Es lo que lo hace repetible. |
git pull --ff-only | Trae los cambios nuevos solo si no hay conflictos. Si los hubiera, falla en vez de mezclar código. |
[ -f archivo ] || { ...; exit 1; } | "Si no existe el archivo, mostrá el error y salí". >&2 manda el mensaje a la salida de errores. |
nginx -t -q | Valida la configuración en modo silencioso: solo habla si hay un error. |
curl -fsS | -f hace que un 404 o un 500 cuenten como error; -sS oculta el progreso pero muestra los errores. |
Paso 14 · Correrlo dos veces
cd ~
./deploy.sh
Deberías ver: los cinco pasos, del 1/5 al 5/5, y al final Deploy OK · commit con el identificador corto del commit desplegado. Como el repositorio ya existía del Bloque C, el paso 1 dice Actualizando en vez de Clonando.
Ahora correlo otra vez y comprobá que el resultado es el mismo:
./deploy.sh
echo "Código de salida: $?"
sha256sum ~/roxs-runner-fest/index.html /var/www/runner/index.html
Deberías ver: la misma salida, Código de salida: 0 y dos hashes idénticos: lo que está publicado es exactamente lo que está en el repositorio. Correrlo una vez o diez da el mismo estado final.
🔍 Qué hace cada comando
| Comando | Qué hace |
|---|---|
./deploy.sh | Ejecuta el script que está en la carpeta actual (./). Sin el ./, bash lo buscaría en las carpetas de programas del sistema. |
echo $? | $? guarda el código de salida del último comando: 0 es éxito; cualquier otro número, error. Es lo que leen las herramientas de CI/CD para saber si un deploy salió bien. |
sha256sum | Calcula una huella del contenido de cada archivo. Si los hashes coinciden, el contenido es idéntico. |
Paso 15 · Romperlo a propósito
Un buen script de deploy falla rápido y sin romper lo que ya funciona. Escondé la imagen del repositorio y corré el deploy:
mv ~/roxs-runner-fest/roxsfest.png /tmp/
./deploy.sh
echo "Código de salida: $?"
curl -s -o /dev/null -w '%{http_code}\n' localhost/roxsfest.png
Deberías ver: el script se detiene en 2/5 con ERROR: falta roxsfest.png, el código de salida es 1, y el sitio sigue respondiendo 200 con la imagen, porque el script frenó antes de tocar /var/www/runner.
Devolvé la imagen a su lugar y verificá que todo vuelve a la normalidad:
mv /tmp/roxsfest.png ~/roxs-runner-fest/
./deploy.sh
Para pensar: ¿qué hubiera pasado si el script copiaba primero y verificaba después? ¿Y si no tuviera set -e?
Bloque E · Desafíos
Elegí los que quieras, en el orden que quieras. Están graduados: 🟢 se resuelven en un par de minutos, 🟡 requieren combinar lo que viste y 🔴 son para quien quiere ir más allá. Cada uno tiene su verificación y una solución escondida: intentalo primero sin abrirla.
🟢 Desafío 1 · Mudar el juego al puerto 8080
Hacé que nginx sirva el juego en el puerto 8080 en lugar del 80, y exponé el 8080 para jugarlo desde el navegador. Después corré ./deploy.sh: algo va a fallar. Arreglalo.
Ver la solución
sudo sed -i 's/listen 80 default_server;/listen 8080 default_server;/; s/listen \[::\]:80 default_server;/listen [::]:8080 default_server;/' /etc/nginx/sites-available/runner
sudo nginx -t && sudo systemctl reload-or-restart nginx
sleep 1
curl -s localhost:8080 | grep -o '<title>.*</title>'
./deploy.sh
El deploy falla en el paso 5/5: el script sigue verificando http://localhost, y en el puerto 80 ya no escucha nadie. Es un error real y frecuente: cambiás la infraestructura y te olvidás del script que la verifica. Actualizá la variable:
sed -i 's|^SITE_URL="http://localhost"|SITE_URL="http://localhost:8080"|' ~/deploy.sh
./deploy.sh
Exponé el puerto con Abrir el puerto 8080 de ubuntu-01.
Los desafíos siguientes usan localhost (puerto 80). Si te quedás en el 8080, agregá :8080 a las URLs. Para volver al 80:
sudo sed -i 's/listen 8080 default_server;/listen 80 default_server;/; s/listen \[::\]:8080 default_server;/listen [::]:80 default_server;/' /etc/nginx/sites-available/runner
sed -i 's|^SITE_URL="http://localhost:8080"|SITE_URL="http://localhost"|' ~/deploy.sh
sudo nginx -t && sudo systemctl reload-or-restart nginx
./deploy.sh
🟢 Desafío 2 · Una página 404 con onda
Pedí una ruta que no existe (curl -i localhost/no-existe) y mirá la página de error genérica de nginx. Creá tu propio 404.html en el web root y configurá nginx para que lo use.
Ver la solución
sudo tee /var/www/runner/404.html > /dev/null << 'EOF'
<!DOCTYPE html>
<html lang="es">
<head><meta charset="utf-8"><title>404 · Game Over</title></head>
<body style="background:#0b1020;color:#e8ecf5;font-family:monospace;text-align:center;padding-top:15vh">
<h1>404 · GAME OVER</h1>
<p>Esta ruta no existe. <a href="/" style="color:#ff6b35">Volvé a jugar</a></p>
</body>
</html>
EOF
sudo sed -i 's|^\(\s*\)index index.html;|&\n\1error_page 404 /404.html;|' /etc/nginx/sites-available/runner
grep -n 'error_page' /etc/nginx/sites-available/runner
sudo nginx -t && sudo systemctl reload-or-restart nginx
sleep 1
curl -i localhost/no-existe
error_page 404 /404.html; le dice a nginx qué archivo mostrar cuando algo no existe. La respuesta tiene que seguir siendo HTTP/1.1 404 Not Found, pero con tu HTML. Si preferís editar a mano, abrí el archivo con sudo nano /etc/nginx/sites-available/runner y agregá la línea debajo de index index.html;.
Para pensar: tu deploy.sh copia solo cuatro archivos. ¿Qué tendrías que cambiar para que el 404.html también viva en el repositorio y se publique con el deploy?
🟡 Desafío 3 · ¿Cuántas veces cargaron el juego?
Compartí la URL pública con alguien (o recargá varias veces) y respondé con el access.log: ¿cuántas veces se cargó la página principal? ¿Cuántas respuestas hubo de cada código (200, 304, 404)? ¿Cuántas de esas cargas las hizo tu propio deploy.sh?
Ver la solución
# Cargas de la página principal (el campo 7 es la ruta pedida)
sudo awk '$7 == "/"' /var/log/nginx/access.log | wc -l
# Respuestas por código (el campo 9 es el código)
sudo awk '{print $9}' /var/log/nginx/access.log | sort | uniq -c | sort -rn
# Cargas hechas por curl (tu deploy.sh) y por navegadores
sudo grep -c '"curl/' /var/log/nginx/access.log
sudo awk '$7 == "/"' /var/log/nginx/access.log | grep -vc '"curl/'
| Herramienta | Qué hace |
|---|---|
awk '$7 == "/"' | Parte cada línea en campos separados por espacios y se queda con las que tienen / en el campo 7. |
awk '{print $9}' | Imprime solo el campo 9 de cada línea. |
sort | uniq -c | sort -rn | Ordena, cuenta los repetidos y ordena por cantidad, de mayor a menor. Es la receta clásica para "¿cuántos hay de cada uno?". |
grep -c / grep -vc | Cuenta las líneas que coinciden (o las que no coinciden, con -v). |
Para pensar: tu script de deploy hace pedidos con curl que también quedan en el log. Si tuvieras que medir visitas reales, ¿cómo las separarías?
🟡 Desafío 4 · ¿Qué versión está publicada?
Modificá deploy.sh para que en cada deploy genere /var/www/runner/version.txt con el commit desplegado y la fecha. Así cualquiera puede consultar curl localhost/version.txt y saber exactamente qué está corriendo.
Ver la solución
Agregá esta línea en el paso 3 de deploy.sh, después del for que copia los archivos y antes del chown:
echo "commit=$(git -C "$SRC_DIR" rev-parse HEAD) deployed_at=$(date -Iseconds)" | sudo tee "$WEB_ROOT/version.txt" > /dev/null
Con nano ~/deploy.sh es lo más cómodo. Después:
./deploy.sh
curl -s localhost/version.txt
git -C ~/roxs-runner-fest rev-parse HEAD
Los dos hashes tienen que coincidir. sudo tee hace falta porque tu usuario no puede escribir en /var/www/runner.
Para pensar: ¿es buena idea publicar el commit exacto en un sitio público? ¿Qué ganás y qué información le das a cualquiera que lo mire?
🔴 Desafío 5 · Releases y rollback
Hoy cada deploy pisa los archivos anteriores. Si una versión sale mal, no tenés a dónde volver. Cambiá la estrategia:
- Cada deploy crea una carpeta nueva
/srv/runner/releases/<fecha-hora>/con los archivos. - Un enlace simbólico
/srv/runner/currentapunta a la release activa, y nginx sirve desde/srv/runner/current. - Un script
~/rollback.shmuevecurrenta la release anterior.

/srv es la carpeta que el estándar de Linux reserva para los datos que el servidor ofrece a otros (sitios, archivos para descargar). Es un buen lugar para algo que manejás vos y no un paquete del sistema.
Ver la solución
Apuntá nginx a la release activa:
sudo sed -i 's|root /var/www/runner;|root /srv/runner/current;|' /etc/nginx/sites-available/runner
Reemplazá el paso 3 de deploy.sh (desde log "3/5 ..." hasta el chmod) por este bloque. Si hiciste el Desafío 4, la línea de version.txt ya está incluida:
RELEASES_DIR="/srv/runner/releases"
CURRENT_LINK="/srv/runner/current"
RELEASE_DIR="$RELEASES_DIR/$(date +%Y%m%d-%H%M%S)"
log "3/5 Creando la release $RELEASE_DIR"
sudo mkdir -p "$RELEASE_DIR"
for archivo in $ARCHIVOS; do
sudo cp "$SRC_DIR/$archivo" "$RELEASE_DIR/"
done
echo "commit=$(git -C "$SRC_DIR" rev-parse HEAD) deployed_at=$(date -Iseconds)" | sudo tee "$RELEASE_DIR/version.txt" > /dev/null
sudo chown -R www-data:www-data "$RELEASE_DIR"
sudo chmod -R u=rwX,go=rX "$RELEASE_DIR"
sudo ln -sfn "$RELEASE_DIR" "$CURRENT_LINK"
Si hiciste el Desafío 2, tu 404.html quedó en /var/www/runner y las releases nuevas no lo van a tener. Llevalo al código y sumalo a la lista de archivos que publica el script:
cp /var/www/runner/404.html ~/roxs-runner-fest/
sed -i 's|^ARCHIVOS="index.html style.css game.js roxsfest.png"|ARCHIVOS="index.html style.css game.js roxsfest.png 404.html"|' ~/deploy.sh
Corré el deploy dos veces (con un par de segundos de diferencia) y mirá cómo quedan las releases:
./deploy.sh && sleep 2 && ./deploy.sh
ls -la /srv/runner/ /srv/runner/releases/
Ahora el rollback:
cat > ~/rollback.sh << 'EOF'
#!/usr/bin/env bash
# rollback.sh · vuelve a la release anterior
set -euo pipefail
RELEASES_DIR="/srv/runner/releases"
CURRENT_LINK="/srv/runner/current"
SITE_URL="http://localhost"
ACTUAL="$(basename "$(readlink -f "$CURRENT_LINK")")"
ANTERIOR="$(ls -1 "$RELEASES_DIR" | sort | grep -B1 -x "$ACTUAL" | head -n 1 || true)"
if [ -z "$ANTERIOR" ] || [ "$ANTERIOR" = "$ACTUAL" ]; then
echo "No hay una release anterior a $ACTUAL" >&2
exit 1
fi
sudo ln -sfn "$RELEASES_DIR/$ANTERIOR" "$CURRENT_LINK"
echo "Rollback: $ACTUAL -> $ANTERIOR"
curl -fsS "$SITE_URL/" | grep -q "ROXS RUNNER" && echo "El sitio responde"
EOF
chmod +x ~/rollback.sh
~/rollback.sh
readlink /srv/runner/current
| Pieza | Qué hace |
|---|---|
ln -sfn destino enlace | Crea el enlace o lo reemplaza si ya existe (-f), tratando el enlace viejo como un archivo y no como la carpeta a la que apunta (-n). |
readlink -f | Muestra a dónde apunta de verdad un enlace. |
grep -B1 -x "$ACTUAL" | Busca la línea exacta (-x) de la release actual y muestra también la anterior (-B1). Como las carpetas tienen la fecha en el nombre, ordenadas alfabéticamente quedan en orden cronológico. |
No hace falta recargar nginx: resuelve el enlace en cada pedido, así que el cambio de current se ve al instante. Si usás el puerto 8080 del Desafío 1, cambiá SITE_URL en rollback.sh.
Para pensar: cada deploy deja una carpeta nueva. ¿Cuántas releases guardarías? ¿Cómo borrarías las más viejas sin tocar la que está activa?
Si algo falla
| Síntoma | Causa habitual | Qué hacer |
|---|---|---|
Could not get lock /var/lib/dpkg/lock-frontend | Otro proceso de apt está corriendo (a veces el sistema se actualiza solo al arrancar). | Esperá un minuto y volvé a intentar. |
curl: (7) Failed to connect to localhost port 80 | nginx no está corriendo o escucha en otro puerto. | systemctl status nginx --no-pager y sudo ss -lntp. Si está detenido, sudo systemctl start nginx. |
curl no responde en el puerto 80 justo después de instalar nginx | apt lo instaló pero no lo arrancó, por /usr/sbin/policy-rc.d. | sudo systemctl enable --now nginx (Paso 05). |
nginx.service is not active, cannot reload | nginx está detenido, y reload solo funciona con el servicio andando. | sudo nginx -t y después sudo systemctl start nginx. Si no arranca, mirá el motivo con sudo journalctl -u nginx -n 20 --no-pager. |
ln: ... File exists o rm: cannot remove ... No such file or directory | Ya habías corrido ese paso. | No pasa nada: el enlace ya existe o ya estaba borrado. Seguí con sudo nginx -t. |
a duplicate default server for 0.0.0.0:80 | default y runner siguen habilitados a la vez. | sudo rm /etc/nginx/sites-enabled/default y sudo nginx -t. |
nginx: [emerg] ... in /etc/nginx/sites-enabled/runner:7 | Error de sintaxis en esa línea (casi siempre falta un ; o una }). | Abrí el archivo con sudo nano /etc/nginx/sites-available/runner, corregí y validá con sudo nginx -t. |
403 Forbidden | nginx no puede leer los archivos, o la carpeta no tiene index.html. | ls -la /var/www/runner y sudo tail /var/log/nginx/error.log. |
| El juego carga pero falta la imagen de Roxs | roxsfest.png no está junto a index.html. | ls /var/www/runner/roxsfest.png y volvé a correr ./deploy.sh. |
| Sigue apareciendo Welcome to nginx! | El sitio default sigue habilitado, o no recargaste. | ls -la /etc/nginx/sites-enabled/ y sudo systemctl reload-or-restart nginx. |
bash: ./deploy.sh: Permission denied | El script no es ejecutable. | chmod +x ~/deploy.sh. |
$'\r': command not found | El script tiene saltos de línea de Windows (pasa al copiar desde algunos editores). | sed -i 's/\r$//' ~/deploy.sh. |
unbound variable | Escribiste mal el nombre de una variable y set -u lo detectó. | Buscá el nombre que indica el error y comparalo con la sección de configuración. |
fatal: Not possible to fast-forward | Modificaste archivos dentro de ~/roxs-runner-fest. | git -C ~/roxs-runner-fest status para ver qué cambió, y git -C ~/roxs-runner-fest restore . para descartarlo. |
La URL expuesta da error 502 | nginx no responde en ese puerto. | curl http://ubuntu-01:<puerto> desde la terminal; si falla, revisá listen y el servicio. |
Mapa de rutas del laboratorio
| Ruta | Qué es | Dónde la usaste |
|---|---|---|
/etc/os-release | Qué sistema operativo y versión es la máquina. | Bloque A |
/home/laborant (~) | Tu carpeta personal. | Código clonado, deploy.sh, rollback.sh |
/usr/sbin/nginx | El ejecutable de nginx. | Bloque B |
/etc/nginx/nginx.conf | Configuración principal de nginx. | Bloque B |
/etc/nginx/sites-available/ | Configuraciones de sitios, habilitados o no. | Bloque C: runner |
/etc/nginx/sites-enabled/ | Enlaces a los sitios que nginx carga. | Bloque C |
/var/www/html/ | Web root de la página de bienvenida. | Bloque B |
/var/www/runner/ | Web root del juego. | Bloques C y D |
/var/log/nginx/access.log | Un renglón por cada pedido. | Bloque C y Desafío 3 |
/var/log/nginx/error.log | Errores de nginx. | Cuando algo falla |
/srv/runner/ | Releases y enlace current. | Desafío 5 |
/tmp | Archivos temporales. | Paso 15 |
Limpieza
No hace falta: al terminar la sesión, la máquina se borra entera. Si hiciste este recorrido en una máquina propia y querés dejarla como estaba:
sudo rm /etc/nginx/sites-enabled/runner
sudo ln -s /etc/nginx/sites-available/default /etc/nginx/sites-enabled/default
sudo nginx -t && sudo systemctl reload-or-restart nginx
sudo rm -r /var/www/runner /srv/runner /etc/nginx/sites-available/runner
rm -r ~/roxs-runner-fest ~/deploy.sh ~/rollback.sh ~/mi-maquina.txt
Revisá cada ruta antes de borrarla: rm -r no tiene papelera. Para desinstalar nginx del todo: sudo apt purge -y nginx nginx-common.
Cierre
- Exploré un servidor Linux y sé para qué sirven
/etc,/var,/homey/usr. - Instalé nginx con apt y lo manejé como servicio con
systemctl. - Encontré su configuración, su web root y sus logs.
- Publiqué un sitio a mano: copiar, dar permisos, configurar, validar y recargar.
- Automaticé todo en un script de bash que frena ante el primer error y se puede correr muchas veces.
- Rompí el deploy a propósito y comprobé que el sitio siguió funcionando.
La idea que atraviesa el laboratorio: lo que hacés a mano dos veces, lo escribís una vez en un script. Hoy fue deploy.sh en una sola máquina. Los contenedores, los pipelines de CI/CD y Kubernetes resuelven el mismo problema a mayor escala.
Para seguir: en el laboratorio Contenedores desde cero: de local a tu primera imagen Docker vas a empaquetar una aplicación en una imagen, y nginx vuelve a aparecer, ahora dentro de un contenedor.
Hecho por Roxs 🔥 · Build with Fire
Learn by doing, not just by reading or watching
Sign up for a free account to start a VM playground right on this page, track your progress, and get notified about new learning materials.

Gitless GitOps with Flux: Plugins, Mirrors, and Schema Validation
In this tutorial, we will learn how to use the new plugin system in Flux 2.9 to: validate manifests, mirror charts into local registries and deploy using Gitless GitOps principles.

Secure Machine-to-Machine Access with mTLS and Pomerium
Run a GitHub Actions-compatible continuous integration (CI) job on a private runner and protect its internal API call with mutual TLS (mTLS) and Pomerium. Build separate server and client trust chains, authorize one machine certificate by fingerprint, then revoke, restore, and rotate its credentials through live policy changes.

Running Dagger Pipelines on GitHub Actions
Learn how to integrate Dagger into your existing CI pipelines on GitHub Actions.

Testing and Releasing Helm Charts with Dagger
Learn how to test, package and release Helm charts using Dagger.