1. Qué es Docker Compose

Docker Compose es un orquestador local. Permite definir varios contenedores y sus relaciones en un único archivo docker-compose.yml. Es como dirigir una pequeña obra de teatro donde cada servicio tiene su papel, y Compose levanta el escenario entero con un comando.

Puntos clave:

• Escritura declarativa: defines lo que quieres, Compose lo monta.
• Multi-servicio: web, base de datos, caches, workers… todo junto.
• Entornos replicables: mismo resultado en cualquier máquina.

2. Componentes del archivo docker-compose.yml

Cada service es un contenedor.

Los atributos más habituales:

• image: Imagen a usar.
• build: Directorio donde está el Dockerfile.
• ports: Mapeo de puertos HOST:CONTAINER.
• volumes: Persistencia o montajes locales.
• environment: Variables de entorno.
• depends_on: Orden de arranque.
• networks: Redes personalizadas.

Ejemplo:

services:
  web:
    image: nginx
    ports:
      - "8080:80"
  db:
    image: mysql:8
    environment:
      - MYSQL_ROOT_PASSWORD=atriosecreto
    volumes:
      - dbdata:/var/lib/mysql

volumes:
  dbdata:

3. Comandos esenciales de Docker Compose

• docker compose up → Levanta todo (añade -d para modo demonio).
• docker compose down → Apaga y borra contenedores, redes.
• docker compose ps → Ver contenedores activos del proyecto.
• docker compose logs -f → Logs en directo.
• docker compose exec <servicio> <cmd> → Ejecutar dentro del contenedor.
• docker compose build → Construir imágenes indicadas.

4. Redes y volúmenes en Compose

Compose crea:

• Una red por defecto para todos los servicios.
• Volúmenes declarados que sobreviven a los up/down.

Beneficio práctico: un contenedor puede llamar a otro simplemente por su nombre de servicio, por ejemplo:

mysql://usuario:pass@db:3306

5. Buenas prácticas

• Evitar meter passwords en el YAML → usar .env.
• Un contenedor, un rol.
• Mantener separado docker-compose.yml y docker-compose.override.yml.
• Versionar siempre el YAML en Git.
• Usar volúmenes en lugar de bind-mounts para producción.

PRÁCTICA GUIADA:
Web + Base de datos con PHPMyAdmin y Apache

montar un stack clásico LAMP con un archivo docker-compose.yml.

Paso 1: crear carpeta del proyecto

mkdir proyecto_compose
cd proyecto_compose

Paso 2: Crear el archivo docker-compose.yml

services:
  db:
    image: mysql:8
    container_name: mysql_compose
    environment:
      - MYSQL_ROOT_PASSWORD=curso2025
      - MYSQL_DATABASE=tienda
    volumes:
      - dbdata:/var/lib/mysql

  phpmyadmin:
    image: phpmyadmin/phpmyadmin
    container_name: pma_compose
    ports:
      - "8081:80"
    environment:
      - PMA_HOST=db
    depends_on:
      - db

  web:
    build: ./web
    container_name: apache_compose
    ports:
      - "8080:80"
    volumes:
      - ./web:/var/www/html
    depends_on:
      - db

volumes:
  dbdata:

Paso 3: Crear la carpeta web con un HTML/PHP mínimo

mkdir web
nano web/index.php

Contenido:

<?php
$mysqli = new mysqli("db", "root", "curso2025", "tienda");
echo $mysqli->connect_error ? "Error de conexión" : "Conexión OK a la BD";
?>
<h1>Hola desde Apache en Docker Compose</h1>

Paso 4: Crear Dockerfile para Apache + PHP

Dentro de web/:

FROM php:8.2-apache
RUN docker-php-ext-install mysqli

Paso 5: Levantar el proyecto

docker compose up -d

• Web → http://localhost:8080
• phpMyAdmin → http://localhost:8081
• MySQL interno → servicio db en el puerto 3306 dentro de la red Docker.

Paso 6: Probar que todo funciona

Entra al web:

curl localhost:8080

En docker:

docker compose logs web 
docker compose exec db mysql -uroot -p

Montando Wordpres desde la terminal (CLI)

1) Requisitos previos

1.1 Verificar Docker instalado

docker --versiondocker ps

Si docker ps da error de permisos, añade tu usuario al grupo docker:

sudo usermod -aG docker $USER
newgrp docker
docker ps

2) Crear la red para comunicar contenedores

Vamos a crear una red llamada wp-net. Esto permite que WordPress encuentre a MySQL por nombre de contenedor.

docker network create wp-net
docker network ls

3) Crear volúmenes para persistencia

Necesitamos guardar:

• Datos de MySQL (bases de datos)
• Archivos de WordPress (plugins, temas, subidas)

docker volume create wp-db
docker volume create wp-html
docker volume ls

4) Levantar la base de datos (MySQL)

4.1 Ejecutar MySQL con variables de entorno

Crea un contenedor llamado wp-mysql:

docker run -d \
  --name wp-mysql \
  --network wp-net \
  -v wp-db:/var/lib/mysql \
  -e MYSQL_DATABASE=wordpress \
  -e MYSQL_USER=wpuser \
  -e MYSQL_PASSWORD=wp-pass-123 \
  -e MYSQL_ROOT_PASSWORD=root-pass-123 \
  mysql:8.0

4.2 Comprobar que está vivo

docker ps
docker logs wp-mysql --tail 30

Si ves mensajes de “ready for connections” (o similar), perfecto.

5) Levantar WordPress

5.1 Ejecutar WordPress apuntando a la DB

Creamos el contenedor wp-web y lo publicamos en el puerto 8080:

docker run -d \
  --name wp-web \
  --network wp-net \
  -p 8080:80 \
  -v wp-html:/var/www/html \
  -e WORDPRESS_DB_HOST=wp-mysql:3306 \
  -e WORDPRESS_DB_NAME=wordpress \
  -e WORDPRESS_DB_USER=wpuser \
  -e WORDPRESS_DB_PASSWORD=wp-pass-123 \
  wordpress:latest

5.2 Verificar logs

docker logs wp-web --tail 30

6) Acceso por navegador y asistente de instalación

Abre:

• http://localhost:8080

Completa el instalador:

• Idioma
• Título del sitio
• Usuario admin
• Password
• Email

7) Verificación técnica (para alumnos curiosos)

7.1 Ver la red y quién está conectado

docker network inspect wp-net

7.2 Ver volúmenes y dónde se usan

docker inspect wp-mysql | grep -i mount -n
docker inspect wp-web   | grep -i mount -n

8) Parar, arrancar y reiniciar (operaciones típicas)

8.1 Parar todo

docker stop wp-web wp-mysql

8.2 Arrancar todo

docker start wp-mysql wp-web

8.3 Reiniciar WordPress

docker restart wp-web

9) Limpieza (sin perder datos)

Si borras contenedores, los datos siguen porque están en volúmenes.

9.1 Borrar contenedores

docker rm-f wp-web wp-mysql

9.2 Volver a crearlos usando los mismos volúmenes

Repite los docker run de los pasos 4 y 5 y verás que todo sigue.

10) Limpieza total (borrado completo)

⚠️ Esto elimina la web y la base de datos.

docker rm -f wp-web wp-mysql 2>/dev/null
docker volume rm wp-db wp-html 2>/dev/null
docker network rm wp-net 2>/dev/null

Anexo A: Diagnóstico de fallos típicos

A1) WordPress no conecta con MySQL

1. Ver logs de WordPress:

docker logs wp-web --tail80

2. Ver logs de MySQL:

docker logs wp-mysql --tail80

3. Asegúrate de que WORDPRESS_DB_HOST=wp-mysql:3306 y que ambos están en wp-net.

A2) Puerto 8080 ocupado

Cambia el puerto:

docker rm -f wp-web
docker run -d \
  --name wp-web \
  --network wp-net \
  -p 8081:80 \
  -v wp-html:/var/www/html \
  -e WORDPRESS_DB_HOST=wp-mysql:3306 \
  -e WORDPRESS_DB_NAME=wordpress \
  -e WORDPRESS_DB_USER=wpuser \
  -e WORDPRESS_DB_PASSWORD=wp-pass-123 \
  wordpress:latest

Y entra a http://localhost:8081.

A3) “Access denied” en MySQL

Suele ser contraseña/usuario mal puestos. Revisa variables. Si ya creaste la base con datos erróneos, recuerda que MySQL guarda usuarios en el volumen: o corriges dentro, o borras volumen (Anexo 10).

Montando Wordpres usando DokerFile

los Dockerfiles listos para hacer docker build directamente (sin Compose) y luego docker run.

Te dejo estructura + archivos y los comandos exactos.

wp-docker-build/
├─ mysql/
│  └─ Dockerfile
└─ wordpress/
   └─ Dockerfile

mysql/Dockerfile (build directo)

Este Dockerfile crea una imagen de MySQL “lista”, y el usuario/DB/contraseñas las seguirás pasando en el docker run (porque eso es configuración de despliegue, no de imagen).

FROM mysql:8.0

# Opcional: configuración extra (descomenta si la necesitas)
# COPY my.cnf /etc/mysql/conf.d/my.cnf

EXPOSE 3306

Nota: MySQL oficial ya trae su entrypoint; aquí no necesitas más si vas a usar variables en docker run.

wordpress/Dockerfile (build directo)

Imagen WordPress basada en la oficial. Si quieres meter ajustes PHP, te lo dejo ya incluido sin depender de un archivo externo (para que sea “build directo” de verdad).

FROM wordpress:latest

# Ajustes PHP típicos (subidas, memoria, tiempo)
RUN set -eux; \
  { \
    echo "upload_max_filesize = 64M"; \
    echo "post_max_size = 64M"; \
    echo "memory_limit = 256M"; \
    echo "max_execution_time = 120"; \
  } > /usr/local/etc/php/conf.d/zzz-custom.ini

EXPOSE 80

Builds

Desde la carpeta wp-docker-build/:

docker build -t wp-mysql:local ./mysql
docker build -t wp-web:local  ./wordpress

Run (igual que tu artículo, sin Compose)

Red + volúmenes

docker network create wp-net
docker volume create wp-db
docker volume create wp-html

MySQL

docker run -d \
  --name wp-mysql \
  --network wp-net \
  -v wp-db:/var/lib/mysql \
  -e MYSQL_DATABASE=wordpress \
  -e MYSQL_USER=wpuser \
  -e MYSQL_PASSWORD=wp-pass-123 \
  -e MYSQL_ROOT_PASSWORD=root-pass-123 \
  wp-mysql:local

WordPress

docker run -d \
  --name wp-web \
  --network wp-net \
  -p 8080:80 \
  -v wp-html:/var/www/html \
  -e WORDPRESS_DB_HOST=wp-mysql:3306 \
  -e WORDPRESS_DB_NAME=wordpress \
  -e WORDPRESS_DB_USER=wpuser \
  -e WORDPRESS_DB_PASSWORD=wp-pass-123 \
  wp-web:local

Verificación rápida

docker ps
docker logs wp-mysql --tail 30
docker logs wp-web --tail 30

Y navega a:

• http://localhost:8080

Montando Wordpres con Docker Compose

un docker-compose.yml (WordPress + MySQL) bien comentado para alumnos, con red y volúmenes, y usando las imágenes oficiales (lo más limpio para clase).

docker-compose.yml

version: "3.9"

services:
  db:
    image: mysql:8.0
    container_name: wp-mysql
    restart: unless-stopped

    # Variables de entorno que MySQL usa para inicializar la BD
    environment:
      MYSQL_DATABASE: wordpress
      MYSQL_USER: wpuser
      MYSQL_PASSWORD: wp-pass-123
      MYSQL_ROOT_PASSWORD: root-pass-123

    # Volumen para que la base de datos NO se pierda al borrar el contenedor
    volumes:
      - wp-db:/var/lib/mysql

    # Conectamos el servicio a una red privada de Docker
    networks:
      - wp-net

  wordpress:
    image: wordpress:latest
    container_name: wp-web
    restart: unless-stopped

    # Mapeo de puertos: HOST:CONTENEDOR
    # En el navegador: http://localhost:8080
    ports:
      - "8080:80"

    # Variables de entorno para que WordPress sepa cómo conectar con MySQL
    environment:
      WORDPRESS_DB_HOST: db:3306
      WORDPRESS_DB_NAME: wordpress
      WORDPRESS_DB_USER: wpuser
      WORDPRESS_DB_PASSWORD: wp-pass-123

    # Volumen para que WordPress (wp-content, plugins, uploads…) se mantenga
    volumes:
      - wp-html:/var/www/html

    # Dependencia: arranca db antes (no garantiza “lista”, pero sí orden)
    depends_on:
      - db

    networks:
      - wp-net

# Definimos volúmenes "named" (persisten aunque pares/borras contenedores)
volumes:
  wp-db:
  wp-html:

# Red interna para que los contenedores se vean por nombre (db, wordpress)
networks:
  wp-net:
    driver: bridge

Ahora

docker compose up -d
docker compose ps
docker compose logs -f

Parar y limpiar (sin borrar volúmenes)

docker compose down

Borrar TODO incluyendo datos (cuidado)

docker compose down -v

Ya hemos llegado, la democracia se ha convertido en un recuerdo, poco a poco los organismos oficiales han implementado diferentes sistemas de control a la población, primero en las calles, luego en la prensa y televisión y ahora le toca a internet.

Tú anque estas infiltrado en el Incibe, demomento tienes que hacerte pasar por un escoria-censurador. 

Te han encargado hacerel prototipo. Como deberas instalar diferentes tipos de herramientas de control y vigilancia, te han pedido que utilices Docker para ir montando los diferentes servicios.

Lo primero, decidir que podra y que no ver los ciudadanos y asi poder adoctirnar a lo mas jovenes e identificar a los mas adultos para someterlos a una dura vigilancia.

Entregar el README con toda la documentación necesaria para su instalación en Raspberry y Ubuntu. Adjuntar comentarios, instrucciones de uso de las acciones mas comunes con el programa Hole y añadir biblioteca de direcciones. 

1. Instalar Docker

Actualiza el sistema y añade Docker:

sudo apt update && sudo apt upgrade -y
curl -sSL https://get.docker.com | sh
sudo usermod -aG docker $USER

Reinicia para aplicar permisos:

sudo reboot

Comprueba que funciona:

docker run hello-world

⚙️ 2. Crear el volumen y red para Pi-hole

Esto permite que los datos persistan aunque elimines el contenedor.

docker volume create pihole_etc
docker volume create pihole_dnsmasq

🧩 3. Ejecutar Pi-hole con Docker (modo manual)

Puedes hacerlo con un solo comando o con docker-compose.
Empiezo por el comando directo (útil para enseñar):

docker run -d \
    --name pihole \
    --restart=unless-stopped \
    -e TZ="Europe/Madrid" \
    -e WEBPASSWORD="tu_contraseña_segura" \
    -e DNSMASQ_LISTENING=all \
    -v pihole_etc:/etc/pihole \
    -v pihole_dnsmasq:/etc/dnsmasq.d \
    -p 53:53/tcp -p 53:53/udp \
    -p 80:80/tcp \
    --hostname pi-hole \
    --dns=127.0.0.1 --dns=1.1.1.1 \
    pihole/pihole:latest

Después de unos segundos, abre en el navegador:

http://<IP_de_tu_Raspberry>/admin

🧭 4. Configurar IP estática

Tu Raspberry necesita una IP fija, por ejemplo:

sudo nano /etc/dhcpcd.conf

Y añade:

interface eth0 static ip_address=192.168.0.200/24 static routers=192.168.0.1 static domain_name_servers=1.1.1.1

📦 5. (Opcional) Usar Docker Compose

Es mucho más limpio para mantener el servicio.
Crea un archivo docker-compose.yml en /home/pi/pihole:

version: "3"
services:
  pihole:
    container_name: pihole
    image: pihole/pihole:latest
    restart: unless-stopped
    network_mode: "host"
    environment:
      TZ: 'Europe/Madrid'
      WEBPASSWORD: 'tu_contraseña_segura'
    volumes:
      - ./etc-pihole:/etc/pihole
      - ./etc-dnsmasq.d:/etc/dnsmasq.d

Y lánzalo:

docker compose up -d

Usar network_mode: host es muy recomendable en Raspberry, porque simplifica el uso de los puertos 53 y 80 (evitas conflictos con el firewall de Docker).

🌐 6. Configurar el router

Ahora tu Pi-hole está sirviendo DNS en la IP fija (ejemplo: 192.168.0.200).

Entra en tu router y en Configuración WAN o DNS manual, pon:

DNS primario: 192.168.0.200 (ojo las ips mostradas son las de este ejemplo)

DNS secundario: 1.1.1.1

7. Pruebas

Desde cualquier dispositivo en la red:

nslookup google.com

Debería mostrar como servidor DNS tu Pi-hole.
Y desde el panel web (http://192.168.0.200/admin) verás todas las peticiones y bloqueos.

🧠 Preguntas de ejemplo para reflexionar (añadir al Readme.me)

1. ¿Qué diferencia hay entre cambiar el DNS en un solo dispositivo y hacerlo en el router?
2. ¿Por qué es importante que la Raspberry tenga una IP fija?
3. ¿Qué ventajas de privacidad aporta Pi-hole frente a usar DNS públicos?
4. ¿Qué limitaciones podría tener Pi-hole en una red grande?

LISTAS DE SERVIDORES

Estas se añaden desde la interfaz de Holi o Pi-hole en Group Management → Adlists.

1. General (publicidad y rastreadores):

https://raw.githubusercontent.com/StevenBlack/hosts/master/hosts https://adaway.org/hosts.txt https://v.firebog.net/hosts/Easyprivacy.txt https://v.firebog.net/hosts/Easylist.txt https://v.firebog.net/hosts/AdguardDNS.txt https://v.firebog.net/hosts/Admiral.txt

2. Malware y phishing:

https://v.firebog.net/hosts/Prigent-Malware.txt https://v.firebog.net/hosts/Prigent-Phishing.txt https://mirror.cedia.org.ec/malwaredomains/justdomains https://malware-filter.gitlab.io/malware-filter/urlhaus-filter-hosts.txt

3. SmartTV y telemetría:

https://raw.githubusercontent.com/Perflyst/PiHoleBlocklist/master/SmartTV.txt https://raw.githubusercontent.com/Perflyst/PiHoleBlocklist/master/AmazonFireTV.txt

4. Redes sociales (si quieres bloquearlas):

🧩 Listas de permiso (Allowlists)

Estas son útiles para evitar falsos positivos.

https://raw.githubusercontent.com/anudeepND/whitelist/master/domains/whitelist.txt https://raw.githubusercontent.com/StevenBlack/hosts/master/whitelist/whitelist.txt

⚡ Servidores DNS recomendados para Holi

Estos son servidores DNS upstream (los que Holi consulta cuando no tiene la respuesta en caché):

En esta nueva práctica vamos a explotar al máximo las capacidades de nuestros contenedores. Hasta crear un autentico LAB de pentesting

Paso 1

EMPEZAREMOS TRABAJANDO EN NUESTRA MAQUINA VIRTUAL Kali (o Ubuntu)
Primero vamos a Crear un entorno de red simple con servidores web para la busqueda de vulnerabilidades y monitorización.

Crea un directorio para tu proyecto:

Ejemplo mkdir red1 

Dentro crea las carpetas httpd y firewall

Dentro de la carpeta httpd crea un archivo Dockerfile-httpd

y inserta el siguiente código:

# Dockerfile para httpd
FROM httpd:latest
COPY ./public-html/ /usr/local/apache2/htdocs/

Crea otro  Dockerfile-firewall en la carpeta del firewall y pon:

# Dockerfile para el firewall
FROM ubuntu:latest
RUN apt-get update && apt-get install -y iptables
COPY ./firewall-rules.sh /usr/local/bin/firewall-rules.sh
RUN chmod +x /usr/local/bin/firewall-rules.sh
ENTRYPOINT ["/usr/local/bin/firewall-rules.sh"]

Crea un archivo llamado firewall-rules.sh dentro del subdirectorio firewall:

#!/bin/bash
# Limpiar reglas existentes
iptables -F

# Permitir tráfico desde el host
iptables -A INPUT -i eth0 -s 192.168.1.0/24 -j ACCEPT

# Bloquear todo el tráfico restante
iptables -A INPUT -j DROP


Ejemplos y manual de iptables: https://binariocero.com/linux/guia-de-uso-de-iptables-opciones-y-ejemplos
Links to an external site.
OJO, ajusta las direcciones ip (la del host) a tu red actual

Ahora vamos hacer el compose para el arranque de los contenedores.

Crea un archivo llamado docker-compose.yml en el directorio principal del proyecto

version: '3.8'

services:
  web1:
    build:
      context: ./httpd
      dockerfile: Dockerfile-httpd
    networks:
      mynetwork:
        ipv4_address: 172.20.0.2

  web2:
    build:
      context: ./httpd
      dockerfile: Dockerfile-httpd
    networks:
      mynetwork:
        ipv4_address: 172.20.0.3

  firewall:
    build:
      context: ./firewall
      dockerfile: Dockerfile-firewall
    cap_add:
      - NET_ADMIN
    networks:
      mynetwork:
        ipv4_address: 172.20.0.4

networks:
  mynetwork:
    driver: bridge
    ipam:
      config:
        - subnet: 172.20.0.0/16

docker-compose up --build

* Realiza pruebas de conexion entre el host y los contenedores.
* En cada servidor web modifica el index.html para que ponga server1, server2 o lo que quieras.

Paso 2

Configurar un entorno de laboratorio con Parrot 

Crea una nueva carpeta para parrot y crea el dockerfile

Dockerfile para Parrot Security OS

# Usar la imagen oficial de Parrot Security OS
FROM parrotsec/security:latest

# Actualizar y instalar herramientas
RUN apt-get update && apt-get install -y \
    metasploit-framework \
    nmap \
    burpsuite \
    wireshark \
    john \
    hydra \
    git \
    vim \
    wget && 

 # Establecer el punto de entrada CMD ["/bin/bash"]

Además de las herramientas mencionadas anteriormente, aquí tienes algunas adicionales que podrías considerar:

1. Aircrack-ng: Suite de herramientas para evaluar la seguridad de redes Wi-Fi.
2. SQLmap: Herramienta para detectar y explotar vulnerabilidades de inyección SQL.
3. Nikto: Escáner de servidores web para detectar vulnerabilidades.
4. Gobuster: Herramienta para la enumeración de directorios y archivos en servidores web.

Ejecución del Contenedor

Para construir y ejecutar el contenedor:

# Construir la imagen
docker build -t parrot-pentest .

# Ejecutar el contenedor
docker run -it parrot-pentest

Paso 3

En los pasos anteriores has creado un docker-composer para montar 3 contenedores (dos de web y el firewall). Luego has creado un contenedor parrot con herramientas, pero si te fijas, este esta en una red diferente.

Ahora debes modificar el YML del paso 1 para que cree todo el proceso del paso 1 y 2. Es decir los dos de web, el firewall y el parrot con los dokerfiles ya creados.

Como vamos a usar parrot para administrar la red, debemos indicarle tanot que sea interactivo como que es una maquina administradora.

Ejemplo:

version: '3.8'

services:
  # Servicio web1
  web1:
    build:
      context: ./httpd
      dockerfile: Dockerfile-httpd
    networks:
      mynetwork:
        ipv4_address: 172.20.0.2

  # Servicio web2
  web2:
    build:
      context: ./httpd
      dockerfile: Dockerfile-httpd
    networks:
      mynetwork:
        ipv4_address: 172.20.0.3

  # Servicio de firewall
  firewall:
    build:
      context: ./firewall
      dockerfile: Dockerfile-firewall
    cap_add:
      - NET_ADMIN  # Esto otorga privilegios para manipular la red
    networks:
      mynetwork:
        ipv4_address: 172.20.0.4

  # Nuevo contenedor Parrot Security OS
  parrot:
    build:
      context: ./parrotsec  # Ubicación del Dockerfile para Parrot Security OS
      dockerfile: Dockerfile-parrot  # Nombre del Dockerfile que contiene las instrucciones
    networks:
      mynetwork:
        ipv4_address: 172.20.0.5
    cap_add:
      - SYS_ADMIN  # Permite algunos privilegios elevados si es necesario para Parrot OS
    stdin_open: true  # Mantiene la terminal abierta para interacciones
    tty: true  # Habilita un terminal interactivo

# Definición de la red "mynetwork"
networks:
  mynetwork:
    driver: bridge
    ipam:
      config:
        - subnet: 172.20.0.0/16  # Subred definida para la red interna

El dockerfile, tambien tenemos que prepararlo para el yml, cambiando o poniendo el nombre del archivo. Crea una carpeta llamada parrotsec en tu proyecto y dentro de ella coloca el Dockerfile-parrot

# Usar la imagen oficial de Parrot Security OS
FROM parrotsec/security:latest

# Actualizar y instalar herramientas
RUN apt-get update && apt-get install -y \
    metasploit-framework \
    nmap \
    burpsuite \
    wireshark \
    john \
    hydra \
    git \
    vim \
    wget \
    && apt-get clean

# Establecer el directorio de trabajo
WORKDIR /root

# Ejecutar un comando para mantener el contenedor activo
CMD [ "bash" ]

docker-compose up en el directorio de tu proyecto. Docker Compose construirá y levantará todos los contenedores

Dentro del conetenedor de parrot ejecuta un nmap para rastrear todas las ips de la red en la que se encuentra.

nmap -sn direccionRed/mascara
Ejemplo: nmap -sn 172.10.0.0/24

Ayuda

Si necesitas borrar la red: sudo docker network  rm  nombreRed
Para eliminar un contenedor sudo docker rm nombre o id del contened

Paso 4

Ahora vamos a realizar  diferentes rastreos con nmap en la subred.
 

1. Escaneo básico de una dirección IP en la red:

Supongamos que quieres escanear la dirección IP 172.20.0.2 (que es la dirección IP de tu contenedor web1). Puedes ejecutar el siguiente comando en el contenedor de Parrot:

nmap 172.20.0.2

Este comando realiza un escaneo básico de los puertos más comunes del contenedor web1.

2. Escaneo de todos los puertos:

Si quieres hacer un escaneo de todos los puertos de una máquina en la red, puedes usar la opción -p- para escanear todos los puertos (del 1 al 65535):

nmap -p- 172.20.0.2

Este comando escaneará todos los puertos de la IP 172.20.0.2 (el contenedor web1) para verificar cuáles están abiertos.

3. Escaneo detallado con información de servicios:

Si quieres obtener más información acerca de los servicios que están corriendo en un contenedor (por ejemplo, versión del servicio), puedes usar la opción -sV que realiza un escaneo de versión de servicios:

nmap -sV 172.20.0.2

Esto no solo escaneará los puertos, sino que también intentará detectar la versión de los servicios que están corriendo en esos puertos.

4. Escaneo con detección de sistema operativo:

Puedes agregar la opción -O para intentar detectar el sistema operativo que está ejecutando el contenedor o la máquina objetivo:

nmap -O 172.20.0.2

Este comando intentará identificar el sistema operativo basado en el comportamiento de los puertos y las respuestas de red.

5. Escaneo en una subred completa:

Si deseas escanear toda la red para encontrar qué dispositivos están activos y qué puertos están abiertos, puedes especificar una subred completa. Por ejemplo, si quieres escanear la subred 172.20.0.0/24, puedes usar el siguiente comando:

nmap 172.20.0.0/24

Este comando escaneará todas las direcciones IP de 172.20.0.1 a 172.20.0.254 dentro de la subred 172.20.0.0/24 para ver qué máquinas están activas y qué puertos tienen abiertos.

6. Escaneo de puertos específicos:

Si solo te interesa escanear puertos específicos, puedes usar la opción -p para definir los puertos que quieres escanear. Por ejemplo, si solo te interesa saber si el puerto 80 (HTTP) y 443 (HTTPS) están abiertos en web1, puedes hacer lo siguiente:

nmap -p 80,443 172.20.0.2

Este comando solo escaneará los puertos 80 y 443 en la IP 172.20.0.2.

7. Escaneo silencioso (sin descubrimiento de hosts):

Si quieres escanear sin enviar demasiada información a la red (es decir, hacer un escaneo «silencioso»), puedes usar la opción -Pn que desactiva el descubrimiento de hosts (es decir, no verificará si la máquina está en línea antes de hacer el escaneo):

nmap -Pn 172.20.0.2

Esto puede ser útil si deseas realizar un escaneo sin alertar a sistemas de monitoreo de red, ya que nmap no enviará un paquete de «descubrimiento» al objetivo.

8. Escaneo de una máquina con múltiples servicios (ejemplo de escaneo en Parrot):

Si quisieras escanear tu red en busca de múltiples servicios o máquinas y visualizar la topología de red de manera más detallada, puedes usar el comando siguiente para hacer un escaneo más avanzado:

nmap -sS -sV -O -T4 172.20.0.0/24

Este comando hace lo siguiente:

• -sS: Escaneo de tipo «SYN» (más sigiloso).
• -sV: Detección de versiones de servicios.
• -O: Detección del sistema operativo.
• -T4: Ajusta la velocidad del escaneo para hacerlo más rápido.

Escaneará toda la subred 172.20.0.0/24 buscando máquinas activas y proporcionando información detallada sobre los servicios y sistemas operativos detectados.

9. Escaneo de vulnerabilidades con scripts Nmap (NSE):

Nmap incluye una gran cantidad de scripts de detección de vulnerabilidades que puedes ejecutar con el parámetro --script. Por ejemplo, para detectar posibles vulnerabilidades relacionadas con SMB, puedes ejecutar el siguiente comando:

nmap --script smb-vuln* 172.20.0.2

Esto ejecutará todos los scripts de vulnerabilidades SMB que están disponibles en Nmap y tratará de detectar cualquier posible problema en el puerto SMB (445).

Cómo ejecutar los comandos en tu contenedor Parrot:

1. Accede al contenedor Parrot desde tu máquina host con el siguiente comando:docker exec -it <nombre_o_id_del_contenedor_parrot> bashEl nombre del contenedor lo puedes obtener con docker ps.
2. Una vez dentro del contenedor, simplemente ejecuta los comandos de nmap como si estuvieras en cualquier otra máquina Linux.

• Red interna de Docker: Todos estos escaneos solo serán visibles dentro de la red interna de Docker. Si estás ejecutando estos escaneos desde el contenedor Parrot, solo podrás escanear los contenedores que estén en la misma red (en este caso, mynetwork).

Paso 5 de 80

Vamos a ver ahora el trafico que se produce dentro de la red, para ello usremos wiresark desde la terminal del contenedor de parrot.

Primero verifica las interfaces de red dentro del contenedor:

ip a

Normalmente, la interfaz  será eth0. Puedes verificar el tráfico de la subred capturando paquetes en esta interfaz.

3️⃣ Capturar tráfico con Wireshark

Dentro del contenedor Parrot, puedes iniciar Wireshark en modo terminal con tshark:

tshark -i eth0

4️⃣ Generar tráfico entre los contenedores

Desde otro terminal, puedes generar tráfico entre los servicios. Por ejemplo, desde web1 puedes hacer peticiones a web2:

docker exec -it web1 curl http://172.20.0.3

O puedes hacer un ping desde Parrot a web2:

ping -c 4 172.20.0.3

Si quieres capturar únicamente tráfico HTTP (puerto 80), puedes ejecutar:

tshark -i eth0 port 80

Para tráfico ICMP (pings):

tshark -i eth0 icmp

5️⃣ Filtrar tráfico en Wireshark

En la interfaz gráfica de Wireshark, puedes filtrar paquetes con:

• ip.addr == 172.20.0.2 → Para ver solo tráfico de web1
• ip.addr == 172.20.0.3 → Para ver tráfico de web2
• http → Para capturar solo tráfico HTTP
• icmp → Para capturar solo tráfico de ping

Paso 6 de 80

Ahora vamos a hacerlo, pero fuera de la subred

Identificar la interfaz de Docker en el host

Docker usa una interfaz virtual llamada bridge para manejar redes internas. Para encontrar la interfaz de la red mynetwork (172.20.0.0/16), ejecuta:

ip a | grep docker

Verás algo como esto:

3: docker0: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc noqueue state UP inet 172.17.0.1/16 brd 172.17.255.255 scope global docker0

• Si la red mynetwork no usa la interfaz docker0, identifica su nombre con:

docker network inspect mynetwork | grep Gateway

El resultado te dará el Gateway y te ayudará a identificar la interfaz.

Capturar tráfico con Wireshark en el host

Abre Wireshark en tu sistema Parrot y selecciona la interfaz de red de Docker, por ejemplo:

• docker0
• br-xxxxxxxxxxxx (si Docker creó una interfaz bridge específica)

Puedes verificar qué interfaces están activas con:

ip link show

Filtrar tráfico de la subred Docker

Usa estos filtros en Wireshark para ver solo el tráfico de la subred 172.20.0.0/16:

• Capturar todo el tráfico de Docker:ip.addr == 172.20.0.0/16
• Capturar tráfico HTTP entre los contenedores:tcp.port == 80
• Capturar pings (ICMP) entre contenedores:icmp

No olvides generar trafico entre los contenedores mientras haces el rastreo.

Paso 7

En el contenedor Web 1 vamos a instalar PHP para Apache, y vamos a poner una pagina que identifique la ubicación del usuario que hace la petición.

Aquí tienes un ejemplo de como hacerlo.

Para acceder desde el navegador del host a la página PHP alojada en uno de tus contenedores web1 o web2, sigue estos pasos:

Exponer el puerto del servidor web en Docker Compose

Actualmente, en tu docker-compose.yml, los servicios web1 y web2 no tienen puertos expuestos al host. Para hacerlo, edita el archivo y agrega la sección ports:

Con esta configuración:

• web1 será accesible desde el host en http://localhost:8080
• web2 será accesible desde el host en http://localhost:8081

Aplicar los cambios y reiniciar los contenedores

Después de editar docker-compose.yml, aplica los cambios reiniciando los contenedores:

docker-compose down

docker-compose up -d

Paso 8  

Ahora vamos a subir un conjunto de contenedores a Docker Hub junto con su docker-compose.yml

Si no tienes una cuenta en Docker Hub, regístrate en https://hub.docker.com/.

Luego, inicia sesión en Docker desde la terminal: 

docker login

Docker Compose usa imágenes personalizadas (build), así que primero debes crear y etiquetar las imágenes correctamente con tu usuario de Docker Hub.

Edita el docker-compose.yml para usar imágenes con nombres de Docker Hub:

services:
  web1:
    build:
      context: ./httpd
      dockerfile: Dockerfile-httpd
    image: tu_usuario_docker/web1:latest  # Define la imagen con tu usuario
    networks:
      mynetwork:
        ipv4_address: 172.20.0.2
    ports:
      - "8080:80"

  web2:
    build:
      context: ./httpd
      dockerfile: Dockerfile-httpd
    image: tu_usuario_docker/web2:latest
    networks:
      mynetwork:
        ipv4_address: 172.20.0.3
    ports:
      - "8081:80"

  firewall:
    build:
      context: ./firewall
      dockerfile: Dockerfile-firewall
    image: tu_usuario_docker/firewall:latest
    cap_add:
      - NET_ADMIN
    networks:
      mynetwork:
        ipv4_address: 172.20.0.4

  parrot:
    build:
      context: ./parrotsec
      dockerfile: Dockerfile-parrot
    image: tu_usuario_docker/parrotsec:latest
    networks:
      mynetwork:
        ipv4_address: 172.20.0.5
    cap_add:
      - SYS_ADMIN
    stdin_open: true
    tty: true

networks:
  mynetwork:
    driver: bridge
    ipam:
      config:
        - subnet: 172.20.0.0/16

Con esta configuración, cada servicio tendrá una imagen específica en Docker Hub.

Ejecuta los siguientes comandos para construir y etiquetar cada imagen:

docker build -t tu_usuario_docker/web1:latest ./httpd -f Dockerfile-httpd
docker build -t tu_usuario_docker/web2:latest ./httpd -f Dockerfile-httpd
docker build -t tu_usuario_docker/firewall:latest ./firewall -f Dockerfile-firewall
docker build -t tu_usuario_docker/parrotsec:latest ./parrotsec -f Dockerfile-parrot

Una vez construidas las imágenes, súbelas a Docker Hub con:

docker push tu_usuario_docker/web1:latest
docker push tu_usuario_docker/web2:latest
docker push tu_usuario_docker/firewall:latest
docker push tu_usuario_docker/parrotsec:latest

Subir el docker-compose.yml a un repositorio

Docker Hub no almacena archivos de configuración, por lo que es recomendable subir el docker-compose.yml a GitHub

Debes crear un repositorio Git o trasladar el archivo yml a un repositorio que tengas.

Luego lo añades y haces el push como siempre

Paso 9

 Pidele la url del repositorio donde tenga el compose a un compañero.

Crea una nueva carpeta y ejecuta el compose

git clone https://github.com/tu_usuario/docker-compose-repo.git
cd docker-compose-repo
docker-compose up -d

Nota: como lo que estas descargando es el yml, puedes modificarlo a tu gusto antes de hacer el up.

Ejemplo de solución

Contexto: JEE sin frameworks, sin Maven, WAR exportado desde Eclipse (Dynamic Web Project).
Front: HTML/JS con fetch consumiendo JSON.

Requisitos

• Docker instalado (Docker Desktop o Engine)
• Tener el .war exportado desde Eclipse
• Driver MySQL dentro del WAR en WEB-INF/lib (esto es clave sin Maven)

Preparar el WAR desde Eclipse

1. Click derecho al proyecto → Export…
2. Web → WAR file
3. Guarda TuApp.war (lo usaremos en ambos métodos)

Checklist rápido:

• Abre el WAR como zip → existe WEB-INF/lib/mysql-connector-*.jar

PARTE 1 — Docker SIN Compose (a mano, entendiendo todo)

1.1 Crear una red Docker (para que “se vean” por nombre)

docker network create jee-net

1.2 Crear un volumen para MySQL (persistencia real)

docker volume create jee-mysql-data

1.3 Levantar MySQL en contenedor

docker run -d \
  --name jee-mysql \
  --network jee-net \
  -e MYSQL_ROOT_PASSWORD=root1234 \
  -e MYSQL_DATABASE=jee_app \
  -e MYSQL_USER=jee \
  -e MYSQL_PASSWORD=jee1234 \
  -v jee-mysql-data:/var/lib/mysql \
  -p 3306:3306 \
  mysql:8.0 \
  --default-authentication-plugin=mysql_native_password

Verificar logs:

docker logs -f jee-mysql

(espera a que salga algo tipo “ready for connections”.)

1.4 Crear base/tablas (opción guiada en vivo)

Entrar a MySQL:

docker exec -it jee-mysql mysql -u jee -pjee1234 jee_app

Ejemplo de SQL (hazlo con tus tablas reales):

CREATE TABLE IF NOT EXISTS alumnos (
  id INT AUTO_INCREMENT PRIMARY KEY,
  nombre VARCHAR(100) NOT NULL
);INSERT INTO alumnos(nombre) VALUES ('Ada'), ('Alan');
SELECT * FROM alumnos;

Salir:

exit

1.5 Preparar Tomcat 10 con tu WAR (sin construir imagen)

Aquí hay dos formas. La más didáctica es montar el WAR como volumen.

Crea carpeta local:

mkdir -p app
cp TuApp.war app/ROOT.war

Levanta Tomcat 10 y monta el WAR:

docker run -d \
  --name jee-tomcat \
  --network jee-net \
  -p 8080:8080 \
  -e DB_HOST=jee-mysql \
  -e DB_PORT=3306 \
  -e DB_NAME=jee_app \
  -e DB_USER=jee \
  -e DB_PASS=jee1234 \
  -v "$(pwd)/app/ROOT.war:/usr/local/tomcat/webapps/ROOT.war:ro" \
  tomcat:10.1-jdk17-temurin

Logs:

docker logs -f jee-tomcat

1.6 Punto crucial: JDBC en Docker (host ≠ localhost)

En tu código, la URL debe usar el nombre del contenedor:

• ❌ localhost
• ✅ jee-mysql (porque ese es el --name del contenedor en la misma red)

1.7 Probar la API

curl http://localhost:8080/tu-endpoint

o en navegador.

1.8 Parar y limpiar (para enseñar “ciclo de vida”)

Parar:

docker stop jee-tomcat jee-mysql

Borrar contenedores:

docker rm jee-tomcat jee-mysql

Volumen (¡ojo, borra datos!):

docker volume rm jee-mysql-data

PARTE 2 — Docker CON Compose (modo “un comando y listo”)

Aquí el objetivo es:
✅ 1 carpeta, ✅ 1 compose, ✅ build opcional, ✅ init automático con SQL.

2.1 Estructura

taller-compose/
├─ docker-compose.yml
├─ app/
│  ├─ Dockerfile
│  └─ ROOT.war
└─ db/
   └─ init.sql

Copia tu WAR:

mkdir -p taller-compose/app taller-compose/db
cp TuApp.war taller-compose/app/ROOT.war

2.2 app/Dockerfile (Tomcat 10 + WAR)

FROM tomcat:10.1-jdk17-temurin

RUN rm -rf /usr/local/tomcat/webapps/*

COPY ROOT.war /usr/local/tomcat/webapps/ROOT.war

EXPOSE 8080

2.3 db/init.sql (carga automática al primer arranque)

CREATE TABLE IF NOT EXISTS alumnos (
  id INT AUTO_INCREMENT PRIMARY KEY,
  nombre VARCHAR(100) NOT NULL
);INSERT INTO alumnos(nombre) VALUES ('Ada'), ('Alan');

2.4 docker-compose.yml (MySQL + Tomcat)

services:
  db:
    image: mysql:8.0
    container_name: jee-mysql

    environment:
      MYSQL_ROOT_PASSWORD: root1234
      MYSQL_DATABASE: jee_app
      MYSQL_USER: jee
      MYSQL_PASSWORD: jee1234

    ports:
      - "3306:3306"

    volumes:
      - dbdata:/var/lib/mysql
      - ./db/init.sql:/docker-entrypoint-initdb.d/01_init.sql:ro

    command: --default-authentication-plugin=mysql_native_password

  app:
    build: ./app
    container_name: jee-tomcat

    depends_on:
      - db

    ports:
      - "8080:8080"

    environment:
      DB_HOST: db
      DB_PORT: 3306
      DB_NAME: jee_app
      DB_USER: jee
      DB_PASS: jee1234

volumes:
  dbdata:

Ojo al detalle nerd importante:
En Compose, el hostname correcto es db (nombre del servicio), no el container_name.

2.5 Arranque

Dentro de taller-compose/:

docker compose up -d --build
docker compose ps

Logs:

docker compose logs -f db
docker compose logs -f app

2.6 Probar

curl http://localhost:8080/tu-endpoint

2.7 Parar

docker compose down

Parar y borrar volúmenes (reinicio total):

docker compose down -v