1-Tutorial Docker: Servir una página web -volumes: - ./ruta/local:/ruta/en/contenedor

El . significa "busca el Dockerfile en la carpeta actual".

¿Qué hace - ./:/var/www/html?

./ es la carpeta actual de tu host (donde está el docker-compose.yml).
/var/www/html es la ruta dentro del contenedor.
Efecto: Todo lo que esté en ./ se ve dentro del contenedor en /var/www/html, y todo lo que se cree dentro del contenedor en /var/www/html aparecerá automáticamente en tu ./. Es una sincronización bidireccional y en tiempo real.

******************************************

Instalar Docker desde el repositorio oficial

Sigue estos pasos para configurar el repositorio oficial e instalar Docker .

Actualiza los paquetes e instala las dependencias necesarias:
bash
```
sudo apt update
sudo apt install ca-certificates curl -y
```

Agrega la clave GPG oficial de Docker:

sudo install -m 0755 -d /etc/apt/keyrings
sudo curl -fsSL https://download.docker.com/linux/ubuntu/gpg -o /etc/apt/keyrings/docker.asc
sudo chmod a+r /etc/apt/keyrings/docker.asc

Agrega el repositorio oficial de Docker a las fuentes de APT:

echo \
  "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.asc] https://download.docker.com/linux/ubuntu \
  $(. /etc/os-release && echo "$VERSION_CODENAME") stable" | \
  sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

Actualiza el índice de paquetes e instala Docker:
bash
```
sudo apt update
sudo apt install docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin -y
```
- docker-ce: El motor de Docker (Community Edition).
- docker-compose-plugin: El plugin de Docker Compose, que es la forma moderna de usarlo (ya no necesitas instalar docker-compose por separado).

***********************

Instalar docker y grupo de usuraio

Tutorial Docker: Servir una página web personalizada con imagen oficial

En este tutorial aprenderás a usar una imagen oficial de Docker, estructurar tus archivos y visualizar tu propia página HTML en un contenedor. Utilizaremos la imagen oficial de Nginx, una de las más populares para servir contenido estático.

Requisitos previos

Tener Docker instalado en tu sistema.
(Comprueba con docker --version)
Conocimientos básicos de línea de comandos.

Paso 1: Crear la estructura de archivos

Crea una carpeta para tu proyecto, por ejemplo mi-web-docker, y dentro de ella coloca tu archivo HTML personalizado.

mkdir mi-web-docker
cd mi-web-docker

Dentro de esta carpeta, crea tu archivo index.html con el siguiente contenido:

echo "<html><body><h1>¡Mi Web Personalizada!</h1><p>Usando imagen oficial</p></body></html>" > index.html

La estructura de archivos quedará así:

mi-web-docker/
└── index.html

Paso 2: Elegir la imagen oficial

Usaremos la imagen oficial de Nginx disponible en Docker Hub: nginx:latest. Esta imagen viene con una configuración por defecto que sirve los archivos estáticos desde /usr/share/nginx/html.

Paso 3: Ejecutar el contenedor con montaje de volumen

Para que Nginx sirva nuestro archivo index.html, debemos montar la carpeta local dentro del contenedor, reemplazando el contenido por defecto.

Ejecuta el siguiente comando:

docker run -d -p 8080:80 --name mi-web -v $(pwd):/usr/share/nginx/html nginx:latest

Explicación de cada parte:

Parámetro	Descripción
`docker run`	Comando para crear y ejecutar un contenedor.
`-d`	Modo detached (en segundo plano).
`-p 8080:80`	Mapea el puerto 80 del contenedor al puerto 8080 de tu máquina.
`--name mi-web`	Asigna un nombre al contenedor para manejarlo fácilmente.
`-v $(pwd):/usr/share/nginx/html`	Monta la carpeta actual (`pwd`) dentro del contenedor en la ruta donde Nginx busca los archivos.
`nginx:latest`	Imagen oficial de Nginx.

Paso 4: Verificar que el contenedor está corriendo

Lista los contenedores activos:

docker ps

Deberías ver algo como:

CONTAINER ID   IMAGE          COMMAND                  CREATED         STATUS         PORTS                                   NAMES
abcd1234...    nginx:latest   "/docker-entrypoint.…"   5 seconds ago   Up 4 seconds   0.0.0.0:8080->80/tcp, :::8080->80/tcp   mi-web

Paso 5: Acceder a la página web

Abre tu navegador y ve a:

http://localhost:8080

Verás el mensaje:

¡Mi Web Personalizada!
Usando imagen oficial

¡Ya tienes tu sitio funcionando con Docker!

Paso 6: Modificar el contenido en tiempo real

Gracias al montaje de volumen, cualquier cambio que hagas en index.html se reflejará inmediatamente sin necesidad de reiniciar el contenedor.

Por ejemplo, edita el archivo:

echo "<html><body><h1>Hola desde Docker</h1><p>Actualizado al instante</p></body></html>" > index.html

Refresca la página y verás los cambios al instante.

Paso 7: Detener y eliminar el contenedor

Cuando hayas terminado, detén y elimina el contenedor:

docker stop mi-web
docker rm mi-web

O si quieres eliminar el contenedor al detenerlo:

docker rm -f mi-web

Estructura final de archivos (resumen)

mi-web-docker/
└── index.html        # Tu archivo HTML personalizado

Variantes con otras imágenes oficiales

Puedes usar otras imágenes oficiales de servidores web:

Apache HTTP Server (httpd:latest): el punto de montaje es /usr/local/apache2/htdocs/.
Python HTTP Server (python:3-alpine): usa python -m http.server y monta en el directorio de trabajo.

Ejemplo con Apache:

docker run -d -p 8080:80 --name mi-web-apache -v $(pwd):/usr/local/apache2/htdocs/ httpd:latest

Conclusión

Has aprendido a:

Crear una estructura de archivos local.
Usar una imagen oficial de Docker (Nginx).
Montar un volumen para servir contenido personalizado.
Visualizar la página en tu navegador.
Modificar el contenido sin reconstruir el contenedor.

Este flujo es la base para desarrollar y probar sitios web estáticos con Docker de manera ágil y profesional.

**************************************************

Tal como lo dices, gracias al volumen tipo bind (el -v $(pwd):/usr/share/nginx/html), tu carpeta local mi-web-docker/ está enlazada directamente dentro del contenedor.

Si quieres ingresar al contenedor para ver dónde está físicamente la página, la ruta interna es:

/usr/share/nginx/html/

Aquí te explico paso a paso cómo entrar y verificarlo:

1. Ingresar al contenedor (shell interactivo)

Como tu contenedor se llama mi-web (por el --name que usaste), ejecuta:

docker exec -it mi-web /bin/bash

Nota: Si te da error porque no encuentra bash, prueba con sh (las versiones más ligeras de Nginx a veces solo traen sh):
bash
docker exec -it mi-web /bin/sh

2. Navegar hasta la carpeta de la página

Una vez dentro, ve a la ruta donde Nginx sirve los archivos por defecto:

cd /usr/share/nginx/html

3. Listar los archivos

Ejecuta un ls -la y verás tu index.html:

ls -la

La salida mostrará algo como:

total 4
drwxr-xr-x 2 root root 4096 ... .
drwxr-xr-x 1 root root 4096 ... ..
-rw-r--r-- 1 root root  100 ... index.html

4. Ver el contenido desde dentro

Puedes leerlo directamente con cat:

cat index.html

Verás el texto: <html><body><h1>¡Mi Web Personalizada!</h1>...

Dato curioso (y muy útil)

Como es un volumen montado, cualquier cambio que hagas desde dentro del contenedor en esa ruta, se reflejará automáticamente en tu carpeta local mi-web-docker/ (y viceversa).

Por ejemplo, desde dentro del contenedor puedes modificar el archivo:

echo "<h1>Editado desde dentro</h1>" > index.html

Sal del contenedor (exit), y si abres tu archivo index.html en tu máquina local, verás que también cambió.

Alternativa: Ver la ruta sin entrar al shell

Si solo quieres confirmar que el archivo existe sin necesidad de abrir una terminal interactiva, puedes ejecutar este comando directo desde tu máquina host:

docker exec mi-web cat /usr/share/nginx/html/index.html

¡Así de sencillo! La magia de Docker es que esa carpeta es el punto de encuentro entre tu computadora y el contenedor

***********************************************SIN VOLUMENES

Cuando no usas volúmenes, el contenedor queda aislado y no tiene acceso a tu carpeta local. Para meter tu página ahí tienes dos formas principales (una más casual y otra profesional):

Método 1: Copiar el archivo al contenedor en marcha (`docker cp`)

Este método es rápido para hacer pruebas puntuales, pero no es permanente (si eliminas el contenedor, la página desaparece).

Paso a paso:

Ejecuta un contenedor Nginx normal (sin montar nada):

docker run -d -p 8080:80 --name mi-web-sin-vol nginx:latest

Copia tu index.html desde tu máquina hacia adentro del contenedor:
bash
```
docker cp index.html mi-web-sin-vol:/usr/share/nginx/html/
```
Abre el navegador en http://localhost:8080 y verás tu página.

⚠️ Limitaciones:

Si el contenedor se reinicia, el archivo sigue ahí (porque el sistema de archivos del contenedor persiste mientras existe).
Si eliminas el contenedor (docker rm), el archivo se pierde para siempre.
No hay sincronización: si cambias el archivo en tu PC, no se actualiza dentro del contenedor a menos que vuelvas a ejecutar docker cp.

Método 2: Construir tu propia imagen personalizada (¡La recomendada!)

Aquí empaquetas tu HTML dentro de la imagen. Es la forma profesional y portátil: puedes subir esa imagen a un registro (Docker Hub) y funcionará en cualquier lado sin depender de archivos externos.

Paso a paso:

Crea un archivo llamado Dockerfile (sin extensión) en tu carpeta mi-web-docker/ con este contenido:

# Usamos la imagen oficial de Nginx como base
FROM nginx:latest

# Copiamos nuestro index.html desde la carpeta local hacia la ruta interna de Nginx
COPY index.html /usr/share/nginx/html/

Construye (build) tu imagen personalizada:
bash
```
docker build -t mi-web-personalizada .
```
El . significa "busca el Dockerfile en la carpeta actual".

Ejecuta un contenedor basado en tu nueva imagen (sin volúmenes):

docker run -d -p 8080:80 --name mi-web-propia mi-web-personalizada

Abre el navegador en http://localhost:8080 y ¡voilá!

Ventajas de este método:

La página viaja dentro de la imagen. Puedes compartirla con otros o desplegarla en producción sin carpetas externas.
Es idempotente: cada vez que crees un contenedor de esta imagen, tendrá tu página.

Desventaja:

Si quieres cambiar el texto del HTML, tienes que reconstruir la imagen (docker build de nuevo) y reiniciar el contenedor. No es "en caliente" como con los volúmenes.

Comparativa rápida

Característica	Con Volumen (`-v`)	Con `docker cp`	Con `Dockerfile` (COPY)
Sincronización	Inmediata (en ambos sentidos)	No sincroniza	No sincroniza
Persistencia al eliminar	Los archivos quedan en tu PC	Se pierden	Viajan dentro de la imagen
Ideal para	Desarrollo / Live-reload	Pruebas rápidas y puntuales	Producción / Distribución
Cambios en caliente	Sí (editas en PC y se ve al refrescar)	No (toca copiar de nuevo)	No (toca reconstruir)

¿Y si quiero inspeccionar dónde quedó la página sin volúmenes?

El procedimiento es idéntico al que te expliqué antes: la ruta interna siempre es /usr/share/nginx/html/ (en Nginx). Si entras al contenedor con:

docker exec -it mi-web-propia /bin/bash
cd /usr/share/nginx/html
cat index.html

Verás tu archivo, pero si intentas modificarlo desde dentro, no se reflejará en tu carpeta local porque no hay un enlace (volumen) entre ambas.

En resumen:
Sin volúmenes, el contenedor es una "cápsula" cerrada. Si solo es para probar, usa docker cp. Si es para un proyecto serio o desplegar, construye tu propia imagen con un Dockerfile (Método 2). ¿Cuál de los dos te gustaría probar primero

Buscar este blog

SOTELO-DOCKER