Tutorial Completo de Dockerfile

 

Tutorial Completo de Dockerfile: De Cero a Experto

📚 Introducción a Dockerfile

Un Dockerfile es un script de texto que contiene todas las instrucciones necesarias para construir una imagen de Docker. Es como una receta que le dice a Docker exactamente cómo crear tu aplicación y su entorno.

🎯 Las Instrucciones Más Comunes

1. FROM - Imagen Base

dockerfile
# Sintaxis
FROM <imagen>:<tag>

# Ejemplos
FROM ubuntu:20.04
FROM python:3.9-slim
FROM node:16-alpine
FROM nginx:alpine

¿Para qué sirve?

  • Define la imagen base sobre la que construirás

  • Siempre debe ser la primera instrucción en un Dockerfile

  • Usa imágenes oficiales cuando sea posible

2. RUN - Ejecutar Comandos

dockerfile
# Sintaxis
RUN <comando>

# Ejemplos
RUN apt-get update && apt-get install -y python3
RUN pip install -r requirements.txt
RUN mkdir /app && chmod 755 /app

¿Para qué sirve?

  • Ejecuta comandos durante la construcción de la imagen

  • Cada RUN crea una nueva capa en la imagen

  • Combina comandos relacionados con && para reducir capas

💡 Mejor Práctica:

dockerfile
# MAL - Múltiples capas
RUN apt-get update
RUN apt-get install -y python3
RUN pip install flask

# BIEN - Una sola capa
RUN apt-get update && \
    apt-get install -y python3 && \
    pip install flask

3. COPY - Copiar Archivos

dockerfile
# Sintaxis
COPY <origen> <destino>

# Ejemplos
COPY . /app
COPY requirements.txt /tmp/
COPY script.sh /usr/local/bin/

¿Para qué sirve?

  • Copia archivos y directorios desde tu máquina local a la imagen

  • Los paths son relativos al contexto de construcción

4. WORKDIR - Directorio de Trabajo

dockerfile
# Sintaxis
WORKDIR <ruta>

# Ejemplos
WORKDIR /app
WORKDIR /usr/src/app

¿Para qué sirve?

  • Establece el directorio de trabajo para las instrucciones siguientes

  • Equivale a cd <directorio> en Linux

  • Si el directorio no existe, lo crea automáticamente

5. CMD - Comando por Defecto

dockerfile
# Sintaxis (3 formas)
CMD ["executable","param1","param2"]  # Forma exec (recomendada)
CMD command param1 param2              # Forma shell
CMD ["param1","param2"]                # Como parámetros para ENTRYPOINT

# Ejemplos
CMD ["nginx", "-g", "daemon off;"]
CMD ["python", "app.py"]
CMD npm start

¿Para qué sirve?

  • Define el comando que se ejecutará al iniciar el contenedor

  • Puede ser sobrescrito al ejecutar docker run

  • Solo puede haber un CMD por Dockerfile

6. ENTRYPOINT - Punto de Entrada

dockerfile
# Sintaxis
ENTRYPOINT ["executable", "param1", "param2"]
ENTRYPOINT command param1 param2

# Ejemplos
ENTRYPOINT ["/docker-entrypoint.sh"]
ENTRYPOINT ["python"]

¿Para qué sirve?

  • Define el comando principal del contenedor

  • No puede ser sobrescrito fácilmente (solo con --entrypoint)

  • Se combina con CMD para pasar parámetros

🚀 Tutorial Práctico: Crear un Servidor Web con Nginx

Paso 1: Crear la Estructura de Archivos

bash
# Crear directorio del proyecto
mkdir mi-contenedor-web
cd mi-contenedor-web

# Crear Dockerfile
touch Dockerfile

# Crear archivo HTML de ejemplo
echo "<html><body><h1>¡Hola Docker!</h1></body></html>" > index.html

Paso 2: Crear el Dockerfile

dockerfile
# Usar la imagen oficial de Nginx como base
FROM nginx:alpine

# Copiar el archivo HTML al directorio de Nginx
COPY index.html /usr/share/nginx/html/index.html

# Exponer el puerto 80
EXPOSE 80

# Comando para iniciar Nginx
CMD ["nginx", "-g", "daemon off;"]

Paso 3: Construir la Imagen

bash
# Construir la imagen
docker build -t mi-contenedor-web .

# Ver imágenes disponibles
docker images

📝 Explicación del comando build:

  • -t mi-contenedor-web: Le da un nombre (tag) a la imagen

  • .: Indica que el contexto de construcción es el directorio actual

Paso 4: Ejecutar el Contenedor

bash
# Ejecutar el contenedor
docker run -d -p 8080:80 --name mi-servidor-web mi-contenedor-web

📝 Explicación del comando run:

  • -d: Ejecuta en segundo plano (detached mode)

  • -p 8080:80: Mapea puerto 8080 del host al puerto 80 del contenedor

  • --name mi-servidor-web: Asigna un nombre al contenedor

Paso 5: Verificar que Funciona

Abre tu navegador y visita: http://localhost:8080

🛠️ Comandos Esenciales de Docker

1. Gestionar Contenedores

bash
# Ver contenedores en ejecución
docker ps

# Ver todos los contenedores (incluyendo detenidos)
docker ps -a

# Detener un contenedor
docker stop mi-servidor-web

# Iniciar un contenedor detenido
docker start mi-servidor-web

# Eliminar un contenedor
docker rm mi-servidor-web

# Ver logs de un contenedor
docker logs mi-servidor-web

2. Gestionar Imágenes

bash
# Listar imágenes
docker images

# Eliminar una imagen
docker rmi mi-contenedor-web

# Limpiar recursos no utilizados
docker system prune

3. Acceder a un Contenedor en Ejecución

bash
# Acceder con bash
docker exec -it mi-servidor-web bash

# Si no tiene bash, usar sh
docker exec -it mi-servidor-web sh

# Ejecutar un comando específico
docker exec mi-servidor-web ls -la /usr/share/nginx/html

¿Por qué acceder a un contenedor?

  • 🔍 Depurar problemas: Ver logs, configuraciones o estados

  • 🛠️ Tareas administrativas: Instalar paquetes, modificar archivos

  • 📊 Inspeccionar el entorno: Ver cómo está configurado

  • 🐛 Solucionar errores: Diagnosticar por qué no funciona algo

🎯 Ejemplo Avanzado: Dockerfile para Desarrollo vs Producción

Dockerfile para Desarrollo (Dockerfile.dev)

dockerfile
FROM node:16

WORKDIR /app

COPY package*.json ./
RUN npm install

COPY . .

# Instalar herramientas de desarrollo
RUN npm install -g nodemon

EXPOSE 3000

CMD ["nodemon", "app.js"]

Dockerfile para Producción (Dockerfile.prod)

dockerfile
FROM node:16-alpine

WORKDIR /app

COPY package*.json ./
RUN npm install --only=production

COPY . .

EXPOSE 3000

CMD ["node", "app.js"]

Construir con Dockerfiles Específicos

bash
# Para desarrollo
docker build -t mi-app:dev -f Dockerfile.dev .

# Para producción
docker build -t mi-app:prod -f Dockerfile.prod .

📋 Resumen de Buenas Prácticas

  1. Usa imágenes base oficiales y específicas

    dockerfile
    # BIEN
FROM python:3.9-slim

# MAL
FROM python:latest

  2. Minimiza el número de capas

    dockerfile
    # BIEN
RUN apt-get update && \
    apt-get install -y python3 && \
    pip install flask

# MAL
RUN apt-get update
RUN apt-get install -y python3
RUN pip install flask

  3. Usa .dockerignore

    bash
    # Crear archivo .dockerignore
echo "node_modules\n.git\n.env\n*.log" > .dockerignore

  4. Ordena las instrucciones inteligentemente

    • Coloca las instrucciones que cambian menos frecuentemente al inicio

    • Coloca las que cambian más al final

🎉 ¡Felicidades!

Ahora sabes:

  • ✅ Qué es un Dockerfile y cómo funciona

  • ✅ Las instrucciones principales (FROM, RUN, COPY, WORKDIR, CMD, ENTRYPOINT)

  • ✅ Cómo construir y ejecutar contenedores

  • ✅ Cómo gestionar contenedores e imágenes

  • ✅ Cómo acceder y depurar contenedores

  • ✅ Buenas prácticas para Dockerfiles

Comentarios

Publicar un comentario

Entradas más populares de este blog

ejercicios-Crear Carpeta y Archivo de Texto en Ubuntu

https://copy.sh/v86/?profile=linux26 Ejercicios para Practicar en Terminales Online Ejercicio Básico 1 - Práctica Inicial bash # En la terminal online, escribe estos comandos: whoami pwd ls mkdir practica cd practica touch archivo1.txt ls -l Ejercicio Básico 2 - Crear y Copiar bash # Continuación del ejercicio anterior echo "Hola mundo desde terminal online" > archivo1.txt cat archivo1.txt mkdir copias cp archivo1.txt copias/ ls copias/ cat copias/archivo1.txt Ejercicio Básico 3 - Exploración bash # Explorar el sistema cd / ls cd home ls cd ~ pwd Te voy a guiar paso a paso en un ejercicio muy básico y fácil para principiantes. ¡Vamos a hacerlo juntos! Paso a Paso del Ejercicio Paso 1: Abrir la Terminal Presiona  Ctrl + Alt + T  para abrir la terminal en Ubuntu. Paso 2: Crear una Carpeta Principal bash mkdir mi_primer_ejercicio Paso 3: Entrar a la Carpeta bash cd mi_primer_ejercicio Paso 4: Crear un Archivo de Texto bash touch mi_archivo.txt Paso 5...
Leer más

Tutorial de Carpetas y Directorios en Ubuntu Linux

En Linux, todo es un archivo. A medida que te adentres en Linux, lo comprenderás, pero por ahora, tenlo en cuenta. Cada archivo está organizado en un árbol de directorios jerárquico. El primer directorio del sistema de archivos se denomina, acertadamente, directorio raíz. El directorio raíz contiene muchas carpetas y archivos, que pueden almacenar más carpetas y archivos, etc   Introducción a los Directorios en Linux En Linux (incluyendo Ubuntu), los directorios (carpetas) siguen una estructura jerárquica que comienza desde el directorio raíz ( / ). Este sistema organiza todos los archivos y programas del sistema. Estructura Básica del Sistema de Archivos text / ├── bin -> Comandos esenciales del sistema ├── etc -> Archivos de configuración ├── home -> Directorios de usuarios ├── var -> Archivos variables (logs, etc.) ├── tmp -> Archivos temporales ├── usr -> Programas y aplicaciones └── ... Comandos Básicos para Trabajar con Directorios 1. Navegación e...
Leer más

Claves SSH en Ubuntu Server - Guía Completa

  Introducción Al iniciar Ubuntu Server por primera vez, es común ver mensajes sobre la generación de claves SSH. Este tutorial explica  qué significan esos mensajes  y  cómo configurar correctamente  tu conexión SSH. 🖥️ ¿Qué estás viendo en la pantalla? La Generación de Claves del Servidor bash Generating public/private rsa key pair. Generating public/private ed25519 key pair. Generating public/private ecdsa key pair. Esto NO son tus claves personales  - son las  "huellas digitales" del servidor  generadas automáticamente por  cloud-init . 🔑 Entendiendo los Dos Tipos de Claves SSH 1.  Claves del Servidor (Host Keys) ¿Quién las usa?  El servidor ¿Dónde están?   /etc/ssh/ ¿Para qué sirven?  Identificar que el servidor es auténtico 2.  Claves del Usuario (User Keys) ¿Quién las usa?  Tú (el usuario) ¿Dónde están?   ~/.ssh/  en tu computadora ¿Para qué sirven?  Autenticarte sin contraseña 🚀 Guía Pas...
Leer más