# Tema 2 · 6 · Laboratorio de recapitulación: la cafetería (EC2 + EBS + EFS)

Presentación del Tema 2: desde «Contenido Scripts» hasta «Todos los pasos del laboratorio, en orden» (los ejercicios, en «Ejercicios propuestos»). Resolución con capturas: `Anexo - Tema 2 - Resolución Laboratorio recapitulación.docx`. Es la actividad que junta las dos anteriores: [`02.04-EBSSnapshotDetachAmpliar.md`](../02.04-EBSSnapshotDetachAmpliar.md) (bloques) y [`02.05-EFSCarpetaCompartida.md`](../02.05-EFSCarpetaCompartida.md) (archivos).

Este laboratorio junta dos tipos de almacenamiento que has visto por separado: **bloques (EBS)**, el disco de una máquina, y **archivos (EFS)**, una carpeta que comparten varias máquinas. Lo harás con un caso sencillo: una cafetería con dos pequeños ordenadores en tu propia cuenta de AWS, que crea **un solo script** (`gestionar-cafeteria.sh`) desde CloudShell: sin instalar nada en tu PC y sin copiar ni pegar ficheros.

- La máquina **caja** registra las ventas. Guarda el histórico en su **disco EBS de 4 GiB**: es un dato privado de esa máquina y no debe perderse aunque se apague.
- Cuando termina, la caja publica un **resumen** del día en una carpeta compartida (**EFS**).
- La máquina **oficina**, la del gerente, lee ese resumen. No tiene disco propio: solo ve lo que hay en la carpeta compartida.

```
 Máquina caja (EC2 micro)                       Máquina oficina (EC2 micro)
 ./caja.sh                                      ./oficina.sh
   |- disco EBS de 4 GiB en /mnt/datos            (sin disco EBS)
   |    ventas.csv   <- histórico, privado de la caja
   |
   |- EFS en ~/efs  <---- carpeta compartida ---->  EFS en ~/efs
        resumen-del-dia.txt   (lo escribe la caja, lo lee la oficina)
        oficina-ha-leido.txt  (lo escribe la oficina, lo lee la caja)
```

No necesitas credenciales de AWS dentro de las máquinas ni `aws configure`. Los scripts `caja.sh` y `oficina.sh` ya llegan dentro de cada máquina, y las dos **se apagan solas a las 4 horas** (se paran, no se borran). Tampoco tienes que formatear el disco a mano: `caja.sh` detecta el disco, mira si ya tiene formato, lo formatea **solo si está en blanco** y te explica en pantalla qué ha hecho y por qué.

> **¿Dudas con un script?** Todos los scripts de esta carpeta traen su propia ayuda: `./gestionar-cafeteria.sh --ayuda` (en CloudShell) · `./caja.sh ayuda` · `./oficina.sh ayuda` (dentro de las máquinas; también valen `--ayuda`, `--help` o `-h`) explica los pasos y las opciones. Este `README.md` es el paso a paso de la actividad: tenlo a mano y consúltalo antes de preguntar.

> **Etiquetas de lo que creas.** Todo recurso que crees a mano (máquina, volumen, bucket, base de datos, tabla, función...) ponle estas etiquetas, al crearlo (apartado *Tags* / *Etiquetas*) o después desde su pestaña de etiquetas: `curso` = `G214`, `universidad` = `CUNEF` y `actividad` = `02.06-laboratoriocafeteria`. Si algún día hay que borrar recursos a mano, se localizan todos de golpe con `aws resourcegroupstaggingapi get-resources --region eu-north-1 --tag-filters Key=actividad,Values=02.06-laboratoriocafeteria`. Más detalle (cómo etiquetar con la CLI, cómo buscar y qué hacer en una emergencia): [README principal](../../README.md), sección «Etiquetas».

## 1. Qué se crea en AWS

Lo crea `./gestionar-cafeteria.sh crear` (todo con las etiquetas del curso):

| Recurso | Nombre | Detalle |
|---|---|---|
| Security Group | `g214-tienda-sg` | SSH (22) y NFS (2049) con origen el propio grupo |
| Sistema de archivos EFS | `efs-tienda` | Con un mount target en cada zona; se monta en las dos máquinas, en `~/efs` |
| Instancia EC2 | `caja` | Amazon Linux 2023, `t3.micro`, con un volumen EBS extra de 4 GiB (gp3, no se borra al terminar la máquina) y `caja.sh` ya copiado en tu carpeta personal |
| Instancia EC2 | `oficina` | Amazon Linux 2023, `t3.micro`, sin volumen extra y con `oficina.sh` ya copiado |
| Bucket temporal | `g214-carga-<tu cuenta>` | Solo para entregar los scripts a las máquinas; `eliminar` lo borra |

Lo que hacen los scripts: `caja.sh` formatea el disco EBS si es nuevo y lo monta en `/mnt/datos`; crea `/mnt/datos/ventas.csv` en el disco y, en el EFS, `resumen-del-dia.txt` (lo escribe la caja) y `oficina-ha-leido.txt` (lo escribe la oficina).

## 2. Coste y duración aproximados

- Duración: unos 45 a 60 minutos la primera vez (crear con el script, montar, ejecutar los scripts y hacer los ejercicios).
- Coste: céntimos si borras todo el mismo día. Las máquinas micro son lo que más pesa si se olvidan encendidas: una `t3.micro` con Linux cuesta unos 0,0108 USD por hora en eu-north-1 (unos 8 USD al mes encendida las 24 horas del mes; el cálculo de las dos está en el ejercicio 5). Las máquinas se apagan solas a las 4 horas, pero el volumen EBS de 4 GiB y el EFS siguen facturando aunque estén apagadas: solo dejan de costar cuando ejecutas `./gestionar-cafeteria.sh eliminar` (sección 10). Los precios de lista cambian: compruébalos en calculator.aws.

## 3. Requisitos previos (checklist)

- [ ] Cuenta de AWS operativa y la región **eu-north-1 (Estocolmo)** seleccionada arriba a la derecha de la consola.
- [ ] Has hecho los laboratorios de EBS (con Windows) y de EFS de este tema. El formato y el montaje del disco en Linux no los haces a mano: los hace `caja.sh` y te lo explica por pantalla.
- [ ] CloudShell abierto (icono `>_` de la consola) con la región **eu-north-1**.
- [ ] La carpeta `02.06-laboratoriocafeteria` subida a CloudShell (sección 5). No necesitas editor de texto ni `nano`.
- [ ] Para conectarte a las máquinas basta el botón *Connect* de la consola (EC2 Instance Connect); un par de claves `.pem` no hace falta.

## 4. Ficheros de esta carpeta

| Fichero | Qué es | Dónde y cuándo se usa |
|---|---|---|
| `gestionar-cafeteria.sh` | Crea, consulta, amplía el plazo de apagado y borra todo el laboratorio (máquinas, disco, EFS, Security Group). Lleva dentro `caja.sh` y `oficina.sh` y se los entrega a las máquinas | En CloudShell: al empezar y al terminar |
| `caja.sh` | Prepara el disco EBS (lo formatea solo si está en blanco y lo monta), comprueba el EFS en 8 pasos, registra 5 ventas en el disco y publica el resumen en el EFS | Dentro de la máquina `caja` (ya está en su carpeta personal) |
| `oficina.sh` | Comprueba 5 pasos (EFS) y lee el resumen que ha publicado la caja | Dentro de la máquina `oficina` (ya está en su carpeta personal) |
| `README.md` | Esta guía | En tu PC |

`caja.sh` y `oficina.sh` de esta carpeta son la copia de referencia (para leerlos): **no hace falta llevarlos a ningún sitio**, ya están dentro de las máquinas. Sin argumentos hacen la comprobación completa (no hay menú) y se pueden repetir las veces que haga falta. Además entienden `ayuda` y `estado` (solo muestran: no modifican nada) y `caja.sh` entiende `limpiar` (sección 10). `oficina.sh` no toca ningún disco. `caja.sh` solo formatea un disco que esté **en blanco**: si el disco ya tiene formato, no lo toca; y nunca toca el disco del sistema ni un disco con particiones. Ejecútalos con tu usuario normal, **sin poner `sudo` delante**: los dos lo comprueban y se detienen con un mensaje si lo haces; `caja.sh` usa `sudo` por dentro, solo donde hace falta.

## 5. Cómo llevar los ficheros (no hay que copiar ni pegar nada)

Todo se hace desde **CloudShell**. En tu PC comprime la carpeta `02.06-laboratoriocafeteria` (clic derecho > *Comprimir en ZIP*), en CloudShell usa **Actions > Upload file** y descomprime:

```bash
unzip -o 02.06-laboratoriocafeteria.zip
cd 02.06-laboratoriocafeteria
chmod -R u+rwX . && chmod +x gestionar-cafeteria.sh
./gestionar-cafeteria.sh --ayuda
```

> Si ya subiste `g214-materiales.zip` (README principal), no necesitas este zip: entra con `cd ~/g214-materiales/tema2/02.06-laboratoriocafeteria` y, si algún fichero da `Permission denied`, ejecuta allí `chmod -R u+rwX . && chmod +x *.sh`.

El script sube `caja.sh` y `oficina.sh` a un bucket temporal y cada máquina los descarga sola al arrancar, ya con permiso de ejecución y en su carpeta personal. Así no hay pegados incompletos ni dobles, ni ficheros con las comillas cambiadas por Word. Si algún día quieres los ficheros en CloudShell, `./gestionar-cafeteria.sh extraer` los escribe en la carpeta actual.

## 6. Paso a paso

### Fase A. Crear el laboratorio (en CloudShell)

**A0. Comprueba la región.** Arriba a la derecha debe poner *Europe (Stockholm) eu-north-1*.

**A1. Crea todo con el script.** En CloudShell, dentro de la carpeta del laboratorio:

```bash
./gestionar-cafeteria.sh crear
```

Qué verás: el Security Group creado (SSH y NFS solo entre tus máquinas), el EFS creado y esperando sus puntos de montaje (1-2 minutos), los scripts subidos al bucket temporal, las máquinas `caja` y `oficina` lanzadas, `Apagado automático: se apagará a las HH:MM UTC (dentro de 4 h 0 min)` y un recuadro **Tu cafetería** con los IDs, las IPs y el comando para montar el EFS. Tarda unos 4 minutos. Es seguro repetir el comando: lo que ya existe se reutiliza (y si las máquinas se pararon, las arranca y renueva el plazo).

**A2. Mira el resultado.** `./gestionar-cafeteria.sh estado` te dice qué hay creado, si las máquinas están en marcha y cuándo se apagarán. Si necesitas más tiempo: `./gestionar-cafeteria.sh extender --horas 8` (o `--permanente`, que cuesta dinero si te olvidas).

### Fase B. En la máquina `caja`

**B1. Conéctate.** EC2, Instances, selecciona `caja`, *Connect, EC2 Instance Connect, Connect* (terminal en el navegador).
Qué verás: un prompt `[ec2-user@ip-172-31-x-y ~]$`. Escribe `ls`: ya está ahí `caja.sh`.

**B2. Mira los discos de la máquina (solo mirar, no hay que formatear nada).** Ejecuta:
```bash
lsblk
```
Qué verás: `nvme0n1` de 8G (el disco del sistema, con particiones: una de ellas está montada en `/`) y `nvme1n1` de 4G, sin particiones ni punto de montaje: es tu volumen EBS, todavía en blanco. Si el tuyo tiene otro nombre (`nvme2n1`, `xvdb`...), no pasa nada.

No tienes que formatearlo ni montarlo tú: lo hará `caja.sh` en el paso B4 y te explicará qué hace. Lo que sí tienes que saber es esto:
- **Formatear** es preparar un disco para guardar ficheros (aquí con el sistema de archivos `ext4`). Un disco nuevo viene en blanco, como un cuaderno sin estrenar, y hay que formatearlo **una sola vez**. Formatear borra todo lo que hubiera en el disco, por eso el script solo formatea discos en blanco.
- **Montar** es enlazar el disco con una carpeta (`/mnt/datos`): lo que guardes en esa carpeta se guarda en el disco. El montaje se pierde cuando la máquina se para o se reinicia; el formato y los datos no.

**B3. Monta el EFS en tu carpeta personal.** El script ya instaló `amazon-efs-utils` y creó la carpeta `~/efs`. Desde tu carpeta personal, ejecuta el comando que te dio `crear` (o `estado`) con **tu** `fs-...`:
```bash
cd ~
sudo mount -t efs -o tls fs-XXXXXXXX:/ efs
sudo chown ec2-user:ec2-user efs
```
Qué verás: al ejecutar `df -h | grep efs`, una línea `127.0.0.1:/  8.0E  0  8.0E  0% /home/ec2-user/efs` (EFS no tiene tamaño fijo, 8,0E es normal). Ejecútalo desde tu carpeta personal: `efs` es una ruta relativa (`~/efs`, que es `/home/ec2-user/efs`).

Dos fallos típicos de este paso (están también en la sección 8):
- **Falla al instante** con `Failed to resolve "fs-...efs.eu-north-1.amazonaws.com" - check that your file system ID is correct, and ensure that the VPC has an EFS mount target for this file system ID`: el identificador `fs-...` está mal copiado, o el EFS es muy reciente: el nombre DNS puede tardar **hasta 5-7 minutos** en resolverse; repite el comando cada minuto. La línea sobre `botocore` que añade después no importa. **No sigas con `chown` hasta que `df -h | grep efs` muestre `127.0.0.1:/`**.
- **Se queda esperando** tras `Mount attempt 1/3 failed due to timeout after 15 sec`: es el Security Group (NFS 2049). `Ctrl+C` no siempre lo corta. Lo normal es que el script lo haya dejado bien: ejecuta `./gestionar-cafeteria.sh estado` en CloudShell y avisa al profesor si algo no cuadra.

**B4. Ejecuta el script:**
```bash
./caja.sh
```
Qué verás la primera vez (resumido; los mensajes `[INFO]` son explicaciones, no errores):
```
=== caja.sh: preparación y comprobación de la máquina CAJA ===

[1/8] Sistema operativo, usuario y tipo de máquina
   [OK] Amazon Linux 2023
   [OK] Usuario ec2-user, con permiso para usar sudo
   [OK] Tipo de instancia: t3.micro

[2/8] Disco EBS de datos conectado a esta máquina
   [OK] Disco EBS de datos encontrado: /dev/nvme1n1 (4.0GiB)

[3/8] Formato del disco: ¿es un disco nuevo o ya estaba formateado?
   [INFO] DISCO NUEVO: /dev/nvme1n1 está en blanco, todavía no tiene formato.
          ... (te explica qué es formatear y que lo hace una sola vez) ...
   [OK] Disco formateado con ext4. Falta montarlo (siguiente paso).

[4/8] Disco montado en /mnt/datos
   [INFO] El disco todavía no está montado en /mnt/datos.
          ... (te explica qué es montar) ...
   [OK] /dev/nvme1n1 montado en /mnt/datos

[5/8] Permiso de escritura en /mnt/datos
   [INFO] Tu usuario aún no puede escribir en /mnt/datos: la carpeta es de root.
          ... (te da permisos con sudo chown) ...
   [OK] Puedes escribir en el disco
...
[8/8] Permiso de escritura en ~/efs
   [OK] Puedes escribir en el EFS

Todas las comprobaciones han ido bien. Registrando las ventas de la cafetería...
   Venta 1: Tostada (2.20 EUR)
   ... (5 ventas, una por segundo)

Histórico guardado en el disco EBS:   /mnt/datos/ventas.csv (5 ventas en total)
Resumen publicado en el EFS:          /home/ec2-user/efs/resumen-del-dia.txt
Estado del disco EBS:                 DISCO NUEVO: lo he formateado ahora (una sola vez)
La oficina todavía no lo ha leído:    ejecuta ./oficina.sh en la máquina oficina.
```
Fíjate en el paso 3: la **primera vez** dice `DISCO NUEVO` y formatea. **Las siguientes veces** dice `YA TENÍA FORMATO` y **no** lo formatea, para no borrar tus ventas. Si un paso falla, verás `[FALLO]`, la explicación, el comando para arreglarlo y `Paso que debes revisar: el N de 8`. Corrígelo y vuelve a ejecutar `./caja.sh` (sección 8).

### Fase C. En la máquina `oficina`

**C1. Conéctate** como en B1.

**C2. Monta el mismo EFS.** Igual que en B3, desde tu carpeta personal, con el **mismo** identificador `fs-...`:
```bash
cd ~
sudo mount -t efs -o tls fs-XXXXXXXX:/ efs
sudo chown ec2-user:ec2-user efs
```
Comprueba con `df -h | grep efs` y con `ls ~/efs`: verás los ficheros que ha escrito la caja.

**C3. Ejecuta el script** (ya está en tu carpeta personal):
```bash
./oficina.sh
```
Qué verás: 5 comprobaciones con `[OK]` y, después, el resumen que ha publicado la caja:
```
Resumen que ha publicado la caja:
------------------------------------------------------------
Resumen publicado por la máquina: ip-172-31-x-y
Actualizado: 2026-10-02T10:15:30
Ventas registradas: 5
Importe total: 13.30 EUR
Última venta: 2026-10-02T10:15:30,Tostada,2.20
------------------------------------------------------------
He dejado un aviso en el EFS (oficina-ha-leido.txt): la caja lo verá la próxima vez que ejecute ./caja.sh.

Fíjate: aquí NO existe /mnt/datos/ventas.csv. El histórico está en el disco EBS de la caja y
solo esa máquina lo ve. El resumen sí lo has podido leer porque está en el EFS, compartido.
```
Si el resumen todavía no existe, el script no falla: te dice que ejecutes antes `./caja.sh` en la caja (termina con código 2).

**C4. Cierra el círculo.** Vuelve a la máquina `caja` y ejecuta `./caja.sh` otra vez. Al final verás `La oficina ha confirmado: La oficina (...) leyó el resumen a las ...`: has demostrado que lo que escribe una máquina en el EFS lo ve la otra, y al revés. La confirmación es la de la **última vez que ejecutaste `./oficina.sh`**, no necesariamente la de este resumen: si la caja ha publicado datos nuevos después de esa lectura, la hora que ves puede ser anterior (ejecuta `./oficina.sh` otra vez si quieres una confirmación al día).

## 7. Qué comprueba cada script

**`caja.sh`** (se detiene en el primer paso que falla):

| Paso | Qué comprueba | Si falla te indica |
|---|---|---|
| 1 | Amazon Linux 2023, que no lo hayas ejecutado con `sudo`, que tu usuario pueda usar `sudo` y, como aviso, que el tipo sea micro | Crear la instancia de nuevo con la AMI correcta; ejecutarlo sin `sudo` delante |
| 2 | Hay un disco extra conectado: busca uno de unos 4 GiB, distinto del disco del sistema. Si ve varios discos extra y no sabe cuál es el tuyo, no toca ninguno | Revisar en la consola que el volumen está *In-use*, asociado a esta instancia y en la misma zona de disponibilidad; dejar conectado solo el volumen del laboratorio |
| 3 | Si el disco está en blanco (el sistema no detecta ningún formato ni particiones), lo **formatea** (ext4) y te explica que es un disco nuevo. Si ya tiene formato, **no lo toca** y te explica que no hace falta formatearlo. Si tiene particiones, está montado en otra carpeta o tiene un formato que no es de datos, se detiene sin tocar nada | Seguir lo que indica el mensaje; nunca formatees a mano un disco que tenga datos |
| 4 | El disco está montado en `/mnt/datos`; si no lo está (primera vez, o tras parar y arrancar la máquina), lo monta y te lo explica | Si hay otro dispositivo montado en esa carpeta: `sudo umount /mnt/datos` |
| 5 | Puedes escribir en `/mnt/datos`; si la carpeta es de root (siempre con un disco recién formateado), te da permisos con `sudo chown` | `sudo chown ec2-user:ec2-user /mnt/datos` si el script no puede hacerlo solo |
| 6 | `amazon-efs-utils` instalado | `sudo dnf install -y amazon-efs-utils` |
| 7 | Hay un EFS montado en `~/efs` (tipo `nfs4`) | Ejecutar el montaje (`sudo mount -t efs -o tls fs-...:/ efs`) desde la carpeta personal; si no funciona, `./gestionar-cafeteria.sh crear` recompone el Security Group |
| 8 | Puedes escribir en `~/efs` | `sudo chown ec2-user:ec2-user ~/efs` |

**El disco, en palabras sencillas.** Los pasos 3 y 4 dependen del estado del disco, y el script te lo cuenta cada vez:

| Situación | Qué dice el paso 3 | Qué hace el script |
|---|---|---|
| Disco nuevo, en blanco (la primera vez) | `DISCO NUEVO` | Lo formatea una vez (`mkfs`), lo monta y te da permisos |
| Disco que ya tenía formato (segunda ejecución, o lo habías formateado a mano) | `YA TENÍA FORMATO` | No lo formatea; solo se asegura de que está montado |
| Disco formateado, pero la máquina se paró y arrancó | `YA TENÍA FORMATO` y, en el paso 4, que no estaba montado | No lo formatea; lo vuelve a montar. Tus ventas siguen ahí |
| Disco con particiones, montado en otra carpeta, o con un formato que no es de datos | `[FALLO]` | No toca nada y te dice qué revisar |

Si todo está bien: registra 5 ventas aleatorias en `/mnt/datos/ventas.csv` (cada ejecución añade 5 más), calcula el resumen con todas las ventas y lo publica en `~/efs/resumen-del-dia.txt`. Después te dice si la oficina ya ha confirmado la lectura.

**`oficina.sh`**:

| Paso | Qué comprueba |
|---|---|
| 1 | Amazon Linux 2023, que no lo hayas ejecutado con `sudo` y, como aviso, tipo micro |
| 2 | `amazon-efs-utils` instalado |
| 3 | Hay un EFS montado en `~/efs` |
| 4 | Puedes escribir en `~/efs` |
| 5 | Como aviso, que esta máquina **no** tenga el disco de datos (es solo de la caja) |

Después lee `~/efs/resumen-del-dia.txt`, lo muestra, deja `oficina-ha-leido.txt` en el EFS y te enseña que `/mnt/datos/ventas.csv` no existe en esta máquina.

Códigos de salida de los dos: `0` todo bien, `1` un paso ha fallado, `2` (solo la oficina) todo está bien montado pero la caja aún no ha publicado el resumen.

## 8. Si un script marca [FALLO]

Lee el número de paso, haz lo que indica y vuelve a ejecutar el script: es la forma de trabajar de este laboratorio, y repetirlo no rompe nada. Los casos más habituales:

| Qué ves | Causa | Solución |
|---|---|---|
| `[2/8] No veo ningún disco extra` | El volumen de 4 GiB no está asociado a esta instancia (por ejemplo, tras el ejercicio 6) o está en otra zona de disponibilidad | EC2 > Volumes: debe estar *In-use* y asociado a `caja` (*Actions > Attach volume*). Si está en otra zona, crea otro en la zona de la caja |
| `[1/8] Has ejecutado el script como administrador` (caja) o `[1/5] ...` (oficina) | Pusiste `sudo` delante (`sudo ./caja.sh`, `sudo ./oficina.sh`) | Ejecútalo sin `sudo`: `./caja.sh` o `./oficina.sh` |
| `[2/8] Veo N discos extra ...` | Hay más de un volumen extra conectado y el script no sabe cuál es el tuyo; por seguridad no toca ninguno | Compara la columna `SERIAL` de la tabla (es el ID del volumen, sin guion) con EC2 > Volumes. Desmonta lo que esté montado (`sudo umount carpeta`) y usa *Actions > Detach volume* en los que no sean de este laboratorio; si aún no has creado el tuyo, *Create volume* de 4 GiB en la misma zona y *Attach volume* |
| `[3/8] El disco ... tiene particiones o una tabla de particiones` | Es un disco con otro uso (por ejemplo, uno que preparaste en Windows en otro laboratorio) | No lo formatees. Desmonta sus carpetas, desconéctalo (*Detach volume*) y usa un volumen nuevo de 4 GiB en la misma zona de la caja |
| `[3/8] ... señales de más de un formato` | Es un disco reutilizado, con restos de más de un formato | No lo formatea, para no borrar nada. Usa un volumen nuevo |
| `[3/8] El disco ... ya está en uso, pero montado en ...` | Montaste el disco a mano en otra carpeta | No pierdes nada. Sal de esa carpeta (`cd ~`), `sudo umount` esa carpeta y vuelve a ejecutar el script |
| `[3/8] ... un formato (...) que no es el de un disco de datos normal` | El disco tiene otro tipo de contenido (swap, LVM...) | No lo toques; desconéctalo (*Detach volume*) y usa un volumen nuevo |
| `[3/8] No he podido formatear` / `No he podido examinar` | Error del sistema al acceder al disco | Mira el mensaje y `lsblk -f`; comprueba que el volumen sigue *In-use* |
| `[4/8] No he podido montar` | El disco no se deja montar | Mira el mensaje; el script no ha formateado nada. Avisa al profesor si persiste |
| `[4/8] En /mnt/datos hay montado ... y no ...` | Montaste otro dispositivo en esa carpeta | `sudo umount /mnt/datos` y vuelve a ejecutar el script |
| `[5/8] No puedes escribir en /mnt/datos ni dándote permisos` | `sudo chown` falló | `sudo chown ec2-user:ec2-user /mnt/datos` a mano y vuelve a ejecutar |
| `[7/8] La carpeta ~/efs existe, pero no hay ningún EFS montado` | No has ejecutado el comando de montaje, lo ejecutaste desde otra carpeta, o se paró y arrancó la máquina | `cd ~` y vuelve a ejecutar `sudo mount -t efs -o tls fs-...:/ efs` (te lo repite `./gestionar-cafeteria.sh estado`) |
| `[7/8] En ~/efs hay montado un sistema de archivos de tipo ...` | Montaste otra cosa en `~/efs` | `sudo umount ~/efs` y monta el EFS con el comando de B3 |
| `[8/8] No puedes escribir en ~/efs` | La raíz del EFS es de root | `sudo chown ec2-user:ec2-user ~/efs` |
| `[AVISO] Tu máquina es ... y el laboratorio pide una micro` | Creaste el laboratorio con `--tipo` de otro tamaño | No es un error, pero cuesta más: bórralo al terminar (`eliminar`) |
| `[AVISO] El laboratorio pide un volumen de 4 GiB; este mide ...` | El volumen extra tiene otro tamaño (por ejemplo, uno que creaste a mano en el ejercicio 6) | No es un error y el script sigue. Si es mayor, cuesta más |
| (CloudShell) `crear` termina con `✗` | Falta algún permiso o el entorno no es CloudShell de tu cuenta | Lee el mensaje; vuelve a ejecutar `./gestionar-cafeteria.sh crear` (repetir no duplica nada) |
| La máquina no responde o no abre la terminal | Se apagó sola (4 horas) | `./gestionar-cafeteria.sh crear` la arranca y renueva el plazo; la IP cambia y hay que **montar el EFS de nuevo** |
| `Failed to resolve "fs-...efs..."` al montar | El `fs-...` está mal copiado, o el EFS es reciente | Compara el ID con el de `./gestionar-cafeteria.sh estado`; en un EFS recién creado el DNS puede tardar hasta 5-7 minutos: repite el montaje |
| `Mount attempt 1/3 failed due to timeout` (o el `mount` se queda colgado) | El Security Group de los mount targets no permite NFS (2049) desde la máquina (el script lo deja bien; solo pasa si alguien cambió el grupo a mano) | `./gestionar-cafeteria.sh crear` lo recompone; si el comando no vuelve, abre otra terminal de la máquina y repite el montaje |
| (oficina) `Todavía no hay ningún resumen en el EFS` | La caja no ha publicado nada, o las dos máquinas montaron EFS distintos | Ejecuta `./caja.sh` en la caja; comprueba que el montaje usa el mismo `fs-...` en las dos |

## 9. Ejercicios propuestos

Los enunciados 1 a 5 están en la presentación del Tema 2 (el 6 es opcional y solo aparece aquí). Aquí tienes cómo comprobar cada resultado; el razonamiento (qué dato va a qué almacenamiento y por qué) lo pones tú.

1. **Ejercicio 1: tabla de decisión.** Antes de crear nada, escribe qué dato va a EBS y qué dato va a EFS, y por qué. Respuesta esperada: el histórico de ventas (`ventas.csv`) es privado de la caja, hay que conservarlo y solo lo usa una máquina, así que va en EBS; el resumen lo escribe una máquina y lo lee otra a la vez, así que va en EFS.
2. **Ejercicio 2: tres ejecuciones completas (15 ventas).** Haz que `caja.sh` sume **tres ejecuciones completas en total**: ya llevas dos, la de B4 y la de C4, así que basta una más (una ejecución cuenta solo si termina sin `[FALLO]`). Comprueba `wc -l /mnt/datos/ventas.csv` (16 líneas: la cabecera y 15 ventas; en general, 1 + 5 × ejecuciones completas) y `cat ~/efs/resumen-del-dia.txt` (`Ventas registradas: 15`). Después ejecuta `./oficina.sh` en la otra máquina: debe mostrar también 15.
3. **Ejercicio 3: privado frente a compartido.** Ejecuta `oficina.sh`. ¿Puede ver `ventas.csv`? ¿Y el resumen? Compruébalo con `ls /mnt/datos` (`No such file or directory`) y `ls ~/efs` (ves `resumen-del-dia.txt` y `oficina-ha-leido.txt`). Explica por qué: el EBS pertenece a una sola máquina; el EFS lo ven todas las que lo montan.
4. **Ejercicio 4: parar y arrancar la caja.** En la consola, *Instance state > Stop instance*; cuando esté parada, *Start instance* (o `./gestionar-cafeteria.sh crear` en CloudShell, que además renueva el plazo de apagado). La IP pública cambia: conéctate con la nueva. Ejecuta `./caja.sh`: en el paso 3 dirá `YA TENÍA FORMATO` (no lo formatea) y en el paso 4 que el disco no estaba montado, y lo monta; después se detendrá en el paso 7, porque el EFS tampoco está montado. Vuelve a ejecutar el montaje del EFS desde `cd ~` (B3) y repite. Al terminar, `wc -l /mnt/datos/ventas.csv` sigue contando desde donde estaba: el disco EBS conserva el formato y los datos aunque la máquina se pare; lo que se pierde son los montajes. Responde: ¿qué dice del disco y por qué no lo formatea esta vez? ¿Qué habría pasado si lo hubiera formateado? ¿En qué paso se detiene y por qué?
5. **Ejercicio 5: estimación de costes.** En calculator.aws → *Create estimate*, región Europe (Stockholm): añade EC2 (2 instancias `t3.micro` Linux, On-Demand, todo el mes), EBS (1 volumen gp3 de 4 GB) y EFS (Standard, 1 GB) y *Export → PDF*. Compara el precio del GB en EBS y en EFS. Resultado de referencia (precios de lista de eu-north-1 consultados el 2 de octubre de 2026; cambian): cómputo 2 × 0,0108 USD/h × 730 h = **15,77 USD/mes**; almacenamiento 4 × 0,0836 + 1 × 0,30 = **0,63 USD/mes** (el GB de EFS es unas 3,6 veces el de EBS); total sin IP pública **unos 16,4 USD/mes** (unos 197 USD al año). Si la calculadora incluye una IPv4 pública por máquina (0,005 USD/h cada una, 7,30 USD/mes las dos): **unos 23,7 USD/mes**. Los dos volúmenes raíz de 8 GiB que el enunciado no cuenta añaden 1,34 USD/mes. El almacenamiento es solo el 4 % del total: lo que cuesta son las máquinas encendidas.
6. **Ejercicio 6 (opcional): destruir la caja y reconectar el disco.** El script crea el volumen extra de la caja con *Delete on termination = No*, así que sobrevive a la máquina. Antes de nada, copia el script al EFS desde la `caja`: `cp ~/caja.sh ~/efs/`. Termina la instancia `caja` (consola, *Instance state > Terminate*) y anota la zona de disponibilidad del volumen (EC2 > Volumes, estado *Available*). Lanza `caja-v2` desde *Launch instances* en esa misma zona (en *Network settings, Edit* elige la subred de esa zona) con la AMI *Amazon Linux 2023*, `t3.micro`, el Security Group `g214-tienda-sg`, sin volumen extra, y asocia el volumen (*Actions > Attach volume*). Conéctate a `caja-v2`, instala el cliente (`sudo dnf install -y amazon-efs-utils`), monta el EFS (`mkdir -p efs` y B3) y trae el script: `cp ~/efs/caja.sh ~ && chmod +x caja.sh`. Antes de ejecutarlo, mira con `lsblk -f` que el disco ya muestra `ext4`: tiene tu histórico. Ejecuta `./caja.sh`: dirá `YA TENÍA FORMATO`, lo montará sin formatear y seguirá contando ventas desde el histórico. `caja-v2` no la ha creado el script: termínala tú al acabar (sección 10).

## 10. Limpieza

Un solo comando, desde CloudShell (carpeta del laboratorio):

```bash
./gestionar-cafeteria.sh eliminar
```

Te enseña lo que va a borrar y pide confirmación (`--si` no la pide). Borra las dos máquinas, el volumen de 4 GiB (espera a que quede libre), el EFS con sus puntos de montaje, el Security Group y los ficheros temporales. Si algo se resiste, repite el comando: es repetible y no deja nada a medias. Antes, `caja.sh limpiar` (dentro de la caja) borra `ventas.csv` y los resúmenes y desmonta el disco y el EFS, pero **no es necesario** si vas a ejecutar `eliminar`.

Si hiciste el ejercicio 6, termina antes `caja-v2` desde la consola (EC2, Instances, *Terminate*): `eliminar` no la conoce, pero sí borra el volumen cuando queda libre.

Verifica: `./gestionar-cafeteria.sh estado` no debe encontrar nada; en la consola, EC2 *Instances* sin nada en *Running*, *Volumes* vacío y EFS sin sistemas de archivos.

## 11. Cómo sabes que has terminado

- [ ] `caja.sh` termina sin `[FALLO]` y ha sumado tres ejecuciones completas (15 ventas).
- [ ] `oficina.sh` termina sin `[FALLO]` y muestra `Ventas registradas: 15`.
- [ ] Al volver a ejecutar `caja.sh`, ves `La oficina ha confirmado: ...`.
- [ ] Sabes explicar por qué la oficina ve el resumen pero no `ventas.csv`.
- [ ] Has visto `DISCO NUEVO` la primera vez que ejecutaste `caja.sh` y `YA TENÍA FORMATO` en las siguientes, y sabes explicar la diferencia. (Si la primera ejecución falló en el paso 7 por no tener el EFS montado, ya había formateado el disco: el `DISCO NUEVO` lo viste en esa ejecución y la siguiente completa dirá `YA TENÍA FORMATO`; es normal.)
- [ ] Has hecho el ejercicio 4 (parar y arrancar la caja) y tienes el PDF del ejercicio 5.
- [ ] Has ejecutado `./gestionar-cafeteria.sh eliminar` (sección 10) y lo has comprobado en la consola.

Anterior: [`02.05-EFSCarpetaCompartida.md`](../02.05-EFSCarpetaCompartida.md)  ·  Siguiente: [`02.07-ejercicioaciclodevida`](../02.07-ejercicioaciclodevida/README.md)