Laboratorio 2

Enunciado

Te proporcionan el código fuente de una landing page simple (HTML, CSS y JavaScript). Tu tarea es crear un Dockerfile y construir una imagen que copie los archivos del sitio al directorio adecuado y exponga el puerto 80.

Debes construir la imagen localmente, probar que el sitio se ve correctamente en tu navegador y, finalmente, publicar la imagen en tu cuenta de Docker Hub con una etiqueta semántica (ej: laboratorio2:v1.0). El repositorio de código debe incluir el Dockerfile y un README con los comandos para construir y ejecutar el contenedor.

Herramientas

• Docker
• Docker Hub
• Nginx

Requisitos previos

Para resolver este caso necesitamos tener instalado docker en nuestra estacion de trabajo para realizar pruebas y una cuenta en Docker Hub para subir la imagen.

Ejecución

Para resolver un problema siempre hay varios caminos para tomar, se podria usa una imagen oficial de Nginx pero yo prefiero crear una desde cero instalando sus dependencias y personalizando sus configuraciones:

Dockerfile

FROM alpine:3.23.0

# Instalar NGINX y dependencias necesarias
RUN apk add --no-cache nginx 

# Eliminar binarios peligrosos
RUN find / -xdev \( \
    -name 'ssh*' \
    -o -name '*ftp*' \
    -o -name 'telnet*' \
    -o -name 'socat*' \
    -o -name 'netcat*' \
    -o -name 'nc' \
    -o -name 'ping' \
    -o -name 'traceroute*' \
    -o -name 'wget*' \
    -o -name 'nslookup' \
    -o -name 'dig' \
    -o -name 'python*' \
    -o -name 'perl*' \
    -o -name 'ruby*' \
    -o -name 'scp' \
    -o -name 'sftp' \
    -o -name 'rsync' \
    -o -name 'tcpdump' \
    -o -name 'strace' \
    -o -name 'gdb' \
    -o -name 'nmap' \
    -o -name 'arpspoof' \
    -o -name 'ip' \
    -o -name 'arping' \
    -o -name 'systemctl' \
    -o -name 'crontab' \
    -o -name 'vim' \
    -o -name 'nano' \
    -o -name 'tar' \
    -o -name 'gzip' \
    -o -name 'zcat' \
    -o -name 'base64' \
    -o -name 'xxd' \
    -o -name 'ssh-agent' \
    -o -name 'ssh-keygen' \
    -o -name 'curl' -o -name 'curl-config' \
    \) \
    -delete 2>/dev/null || true


# Copiar configuración de NGINX Y APLICACION
COPY site/ /usr/share/nginx/html
COPY default.conf /etc/nginx/http.d/default.conf

# Ajustar permisos
RUN chown -R nginx:nginx \
    /usr/share/nginx/html 
# Cambiar al usuario no root
USER nginx
WORKDIR /usr/share/nginx/html

# Exponer puerto 
EXPOSE 80

# Iniciar NGINX
CMD ["nginx", "-g", "daemon off;"]

Flujo del archivo Dockerfile

• Tomo como base la version de Alpine 3.22.4.
• Con el comando RUN apk add --no-cache nginx instalo Nginx.
• Seguidamente elimino los binarios peligrosos dentro de Alpine que pueden servir para escalar privilegios o ejecutar comandos si se compromete el contenedor.
• Creo los directorios de configuracion necesarios para Nginx.
• Ajusto los permisos al usuario Nginx, es importante nunca usar root al ejecutar un contenedor.
• Copio las configuraciones de Nginx a su carpeta correspondientey los archivos de la aplicacion.
• Cambio al usuario nginx.
• Expongo el puerto 80.
• Inicio el servicio Nginx.

Archivo de configuracion de Nginx

server {
    listen  80 default_server;
    root   /usr/share/nginx/html;
    index  index.html;

    location / {
        try_files $uri $uri/ /index.html;
    }
}

Este archivo especifica la configuracion de Nginx, el puerto a escuchar, directorio y archivo principal a servir y la directiva location que indica si no encuentra un archivo intente buscar un directorio y en caso fallido que nos envie al index.html

.dockerignore

README.md
Dockerfile

Este archivo indica a docker a no incluir archivos o directorios dentro de la imagen, de la misma forma que un .gitignore a un repositorio Git.

README.md

Archivo con las instrucciones solicitado en el enunciado.

Construccion de Imagen

Luego de verificar el Dockerfiel que no tenga errores procedemos a construir la imagen con:

docker build -t landing-page:v1.0 .

Esto crea la imagen localmente para realizar pruebas, deberia terminar sin inconvenientes:

Verificamos la imagen creada con el comando

docker image ls

Como vemos la imagen pesa menos de 25MB gracias a Alpine, para iniciar el contenedor y probarlo localmente ejecutamos:

docker run -d --name landing-page -p 8080:80  landing-page:v1.0 

Comprobamos la ejecucion del contenedor con la web:

Como vemos ya tenemos la pagina ejecutandose localmente ahora como nos indica el enunciado hay que subir la imagen a Docker Hub para que otros usuarios puedan usarla, con eso se modulariza e independiza esta aplicacion del sistema o ambiente donde se ejecute.

Docker Hub

Ingresamos a nuestra cuenta en Docker hub y creamos un repositorio para alojar la imagen:

Luego ejecutamos en nuestra terminal:

docker login 

Esto nos loguea a Docker hub

Luego tagueamos la imagen para subirla al repo con este comando:

docker tag landing-page:v1.0 shabby376/laboratorio2:v1.0

Y procedemos a subirla:

docker push shabby376/laboratorio2:v1.0 

En Docker Hub:

Con estos pasos ya tendriamos el objetivo del enunciado completado con nuestra web en un repositorio remoto lista para descargar y usar.

Repositorio

Laboratorio 2

Este es el fin del laboratorio numero 2, si quieres dejame un comentario o tu opinion por Linkedin.

Saludos!