Cómo crear un Dockerfile basado en Ubuntu: Guía completa para principiantes y desarrolladores

1. Introducción

¿Qué son Docker y Dockerfile?

En los últimos años, Docker se ha popularizado rápidamente como una forma eficiente de configurar entornos de desarrollo y desplegar aplicaciones. Docker permite empaquetar una aplicación y sus dependencias en un único «contenedor», garantizando que pueda ejecutarse en el mismo entorno en cualquier lugar.

Para construir un contenedor de Docker, se necesita un plano llamado «Dockerfile«. Un Dockerfile es un archivo de texto donde se especifica la imagen base del sistema operativo, el software a instalar, las variables de entorno y otras configuraciones. Con este archivo, los desarrolladores pueden automatizar la creación de entornos personalizados.

¿Por qué usar Ubuntu como base?

Al crear un Dockerfile, lo primero es definir la imagen base del sistema operativo. Entre las más populares se encuentra Ubuntu. Ubuntu es una distribución de Linux basada en Debian que permite construir entornos flexibles gracias a su facilidad de uso y a su amplia disponibilidad de paquetes.

Las ventajas de usar un Dockerfile basado en Ubuntu incluyen:

• Existe abundante documentación oficial y de la comunidad, lo que reduce el costo de aprendizaje
• Numerosos paquetes y herramientas pueden instalarse fácilmente con APT
• Se ofrecen imágenes mínimas y ligeras de manera oficial (ubuntu:20.04, ubuntu:24.04, etc.)

Objetivo y público de este artículo

En este artículo, con el tema «Dockerfile Ubuntu«, explicaremos de forma sencilla cómo crear un Dockerfile basado en Ubuntu.

Concretamente, revisaremos la estructura básica de un Dockerfile, los pasos para construir un entorno Ubuntu, ejemplos de instalación de entornos como Python, y la solución de errores comunes.

Este contenido está recomendado para:

• Quienes crean un entorno con Dockerfile por primera vez
• Quienes desean reproducir con precisión un entorno de desarrollo en Ubuntu
• Quienes quieren aprender también las soluciones a problemas comunes

2. Estructura básica de un Dockerfile

¿Qué es un Dockerfile y cuál es su función?

Un Dockerfile es como una receta para crear una imagen de Docker. Es un archivo de texto donde se describe qué sistema operativo base usar, qué software instalar y qué configuraciones aplicar.

A partir de este archivo, al ejecutar el comando docker build, se puede construir fácilmente un entorno de desarrollo o ejecución reproducible.

Ventajas de usar Dockerfile:

• Automatización en la configuración del entorno (sin necesidad de repetir manualmente los pasos)
• Eliminación de diferencias entre entornos en un equipo de desarrollo
• Integración sencilla en pipelines CI/CD

Instrucciones básicas más usadas en un Dockerfile

Un Dockerfile contiene varias instrucciones (directivas). Estas son las más comunes, que se combinan para crear un Dockerfile basado en Ubuntu:

Ejemplo mínimo de un Dockerfile basado en Ubuntu

Este es un ejemplo básico de Dockerfile con Ubuntu como base:

FROM ubuntu:24.04

RUN apt-get update && apt-get install -y 
    curl 
    vim

CMD ["/bin/bash"]

Este Dockerfile usa Ubuntu 24.04 como base, instala curl y vim, y finalmente inicia la shell bash.

Selección de etiquetas de Ubuntu

Las imágenes de Ubuntu están disponibles en el repositorio oficial de Docker Hub. Aunque ubuntu:latest apunta a la versión más reciente, se recomienda especificar la versión.

Ejemplos:

• ubuntu:22.04 (LTS: versión de soporte extendido, más estable)
• ubuntu:24.04 (última candidata LTS, con características más nuevas)

Elige en función de si priorizas estabilidad o nuevas funcionalidades.

3. Práctica: creación de un Dockerfile basado en Ubuntu

Instalar paquetes necesarios en un entorno Ubuntu

Al construir un entorno Ubuntu con Dockerfile, en muchos casos será necesario instalar paquetes adicionales. Para preparar un entorno de desarrollo, se suelen usar utilidades como estas:

• curl: para descargar archivos o probar APIs
• vim: editor de texto básico
• git: herramienta de control de versiones
• build-essential: conjunto de herramientas básicas para compilar en C/C++

En un Dockerfile, estos paquetes se instalan con la instrucción RUN:

FROM ubuntu:24.04

RUN apt-get update && apt-get install -y 
    curl 
    vim 
    git 
    build-essential

Ejecutar apt-get update primero asegura que la lista de paquetes esté actualizada antes de instalar.

Configuración de instalación no interactiva

En Ubuntu, algunos apt-get install pueden requerir interacción del usuario, lo cual no es posible durante la construcción de una imagen. Para evitarlo, se recomienda configurar la variable de entorno para habilitar el modo no interactivo:

ENV DEBIAN_FRONTEND=noninteractive

De este modo, se omiten preguntas como la configuración regional y la instalación se realiza sin interrupciones.

Eliminar caché innecesario para aligerar la imagen

APT deja archivos temporales (caché) que incrementan el tamaño de la imagen. Para reducirlo, se pueden eliminar con:

RUN apt-get update && apt-get install -y 
    curl 
    vim 
    && rm -rf /var/lib/apt/lists/*

Además, combinar varios comandos en una sola instrucción RUN evita la creación de capas innecesarias.

Buenas prácticas para escribir un Dockerfile

En proyectos reales, se recomiendan estas mejores prácticas:

• Agrupar comandos RUN para reducir el número de capas
• Definir versiones y configuraciones explícitamente con ENV
• Usar comentarios para explicar el propósito de cada paso
• Evitar archivos innecesarios con rm o la opción --no-install-recommends

Ejemplo:

RUN apt-get update && apt-get install -y --no-install-recommends 
    curl 
    git 
    && rm -rf /var/lib/apt/lists/*

Esto permite construir un Dockerfile más ligero y fácil de mantener.

4. Construcción y verificación de imágenes Docker

Construir una imagen Docker desde un Dockerfile

Una vez escrito el Dockerfile, el siguiente paso es construir la imagen con el comando docker build. Ejecútalo en el directorio donde está el Dockerfile:

docker build -t my-ubuntu-image .

• -t asigna un nombre (tag) a la imagen, en este caso my-ubuntu-image.
• . indica que el Dockerfile está en el directorio actual.

Docker leerá las instrucciones del Dockerfile y construirá una nueva imagen.

Verificar la imagen construida

Una vez terminada la construcción, confirma la existencia de la imagen con:

docker images

Mostrará una lista de imágenes locales con información como:

• REPOSITORY (nombre de la imagen)
• TAG (etiqueta)
• IMAGE ID (identificador único)
• CREATED (fecha de creación)
• SIZE (tamaño)

Ejemplo:

REPOSITORY        TAG       IMAGE ID       CREATED          SIZE
my-ubuntu-image   latest    abcd1234abcd   5 minutes ago    189MB

Esto confirma que la imagen está registrada correctamente.

Ejecutar un contenedor para verificar la imagen

Para comprobar que la imagen funciona, arranca un contenedor Docker:

docker run -it my-ubuntu-image

• La opción -it abre el contenedor en modo interactivo con terminal.
• Si funciona, verás un prompt bash dentro del contenedor Ubuntu.

Dentro del contenedor, prueba los comandos instalados:

curl --version
vim --version

Si todo funciona, el Dockerfile está configurado correctamente.

Limpiar imágenes y contenedores innecesarios

Al repetir pruebas, pueden acumularse imágenes y contenedores que ocupan espacio. Límpialos regularmente:

• Eliminar contenedores detenidos:

docker container prune

• Eliminar imágenes no usadas:

docker image prune

• Eliminar todos los datos no usados (¡cuidado!):

docker system prune

Así ahorrarás espacio en disco y evitarás problemas.

5. Aplicación: construcción de un entorno Python

Habilitar Python en un Dockerfile basado en Ubuntu

Al construir un entorno Ubuntu con Dockerfile, añadir un entorno de ejecución de Python permite abarcar tareas de desarrollo, pruebas y machine learning. Aunque algunas versiones de Ubuntu incluyen Python, lo más común es instalarlo explícitamente para controlar la versión y la gestión de paquetes.

Instalar Python con APT

El método más simple es instalar Python con los paquetes APT. Ejemplo:

FROM ubuntu:24.04

RUN apt-get update && apt-get install -y 
    python3 
    python3-pip 
    && rm -rf /var/lib/apt/lists/*

Esto instala la versión estable de Python disponible en Ubuntu (por ejemplo, Python 3.10 o 3.12). Además, con pip se pueden añadir paquetes Python adicionales.

Gestionar versiones de Python con pyenv

Si necesitas una versión específica de Python o cambiar entre varias, pyenv es una herramienta muy práctica.

Ejemplo de Dockerfile para instalar Python 3.11.6 con pyenv:

FROM ubuntu:24.04

ENV DEBIAN_FRONTEND=noninteractive

RUN apt-get update && apt-get install -y 
    git 
    curl 
    make 
    build-essential 
    libssl-dev 
    zlib1g-dev 
    libbz2-dev 
    libreadline-dev 
    libsqlite3-dev 
    wget 
    llvm 
    libncurses5-dev 
    libncursesw5-dev 
    xz-utils 
    tk-dev 
    libffi-dev 
    liblzma-dev 
    && rm -rf /var/lib/apt/lists/*

# Instalar pyenv
RUN git clone https://github.com/pyenv/pyenv.git ~/.pyenv

ENV PYENV_ROOT="$HOME/.pyenv"
ENV PATH="$PYENV_ROOT/bin:$PATH"

RUN echo 'eval "$(pyenv init --path)"' >> ~/.bashrc

# Instalar una versión específica de Python
RUN pyenv install 3.11.6 && pyenv global 3.11.6

Así podrás gestionar versiones de Python con más flexibilidad.

Gestión de paquetes con requirements.txt

En proyectos reales, suelen necesitarse múltiples librerías Python. Para gestionarlas se usa requirements.txt.

Primero, crea un archivo requirements.txt en el directorio raíz del proyecto:

flask==2.3.2
requests>=2.25.1
pandas

En el Dockerfile:

COPY requirements.txt /app/requirements.txt
WORKDIR /app

RUN pip install --no-cache-dir -r requirements.txt

Esto permite instalar todas las dependencias de forma reproducible.

Buenas prácticas

• Usar virtualenv o venv para evitar conflictos de dependencias.
• Instalar paquetes con la opción --no-cache-dir para reducir el tamaño de la imagen.
• Actualizar pip antes de instalar librerías con pip install --upgrade pip.

6. Problemas comunes y soluciones

Error de permisos

Ejemplo:

Permission denied

Esto ocurre cuando un archivo copiado no tiene permisos de ejecución o el usuario no es correcto.

Soluciones:

• Dar permisos de ejecución:

  RUN chmod +x script.sh

• Cambiar usuario o grupo si es necesario:

  RUN chown root:root /path/to/file

Error al instalar paquetes

Ejemplo:

E: Unable to locate package xxx

Ocurre cuando no se ejecutó apt-get update o el nombre del paquete es incorrecto.

Soluciones:

• Siempre ejecutar apt-get update antes de install:

  RUN apt-get update && apt-get install -y curl

• Verificar que el nombre del paquete esté escrito correctamente.

Error de red

Ejemplo:

Temporary failure resolving 'deb.debian.org'

Este error ocurre por problemas de DNS durante la construcción.

Soluciones:

• Reiniciar el servicio Docker:

  sudo systemctl restart docker

• Añadir configuración de DNS en /etc/docker/daemon.json:

  {
    "dns": ["8.8.8.8", "8.8.4.4"]
  }

Problemas por caché

Docker usa caché por capas, lo que puede impedir que se apliquen cambios recientes.

Solución:

  docker build --no-cache -t my-image .

El contenedor se detiene inmediatamente

Causas:

• El comando en CMD o ENTRYPOINT falla.
• CMD ["/bin/bash"] se cierra si no está en modo interactivo.

Soluciones:

• Ejecutar en modo debug:

  docker run -it my-image /bin/bash

• Entender las diferencias entre CMD y ENTRYPOINT y usarlos según el caso.

Resolver estos problemas ayuda a mejorar la habilidad en diseño de Dockerfiles.

7. Resumen

Revisión de los puntos clave al crear un Dockerfile basado en Ubuntu

En este artículo hemos explicado paso a paso cómo construir un entorno Ubuntu usando Dockerfile. Resumamos los puntos principales:

• Comprender la estructura básica de un Dockerfile
  FROM, RUN, CMD, ENV, entre otros, permiten automatizar la configuración del entorno.
• Ubuntu es una imagen base estable y flexible
  Gracias a sus paquetes abundantes, su gran comunidad y sus versiones LTS, es una excelente base para entornos de desarrollo.
• Gestión práctica de paquetes
  El uso correcto de apt-get, la eliminación de caché y la instalación no interactiva son claves para un entorno reproducible.
• Construcción de entornos aplicados como Python
  Con pyenv, pip y requirements.txt es posible crear entornos Python reproducibles y flexibles.
• La capacidad de resolver problemas asegura una operación estable
  Errores de permisos, red o caché son comunes, y conocer sus soluciones mejora la eficiencia en el desarrollo.

Próximos pasos en el aprendizaje de Dockerfile

Dominar Dockerfile permite no solo configurar entornos de desarrollo, sino también preparar despliegues de prueba y producción. Para seguir avanzando, se recomienda estudiar:

• Docker Compose: gestión de arquitecturas multi-contenedor
• Integración con CI/CD (GitHub Actions, GitLab CI, etc.)
• Orquestadores de contenedores como Kubernetes

Documentación oficial y enlaces de referencia

• Documentación oficial de Docker (en japonés)
• Docker Hub – Imágenes oficiales de Ubuntu
• Repositorio oficial de pyenv en GitHub

8. FAQ (Preguntas frecuentes)

Q1. ¿Qué versión de Ubuntu debería elegir en mi Dockerfile?

A1. Lo más común es usar una versión LTS (Long Term Support) para asegurar estabilidad y soporte prolongado. Ejemplos: ubuntu:22.04 o ubuntu:20.04, que cuentan con 5 años de soporte. Si prefieres versiones más nuevas de paquetes o lenguajes, puedes usar ubuntu:24.04, aunque conviene probarla previamente.

Q2. ¿Por qué aparece el error “paquete no encontrado” al usar apt-get install?

A2. Generalmente ocurre porque no ejecutaste apt-get update antes de instalar. Esto provoca que la lista de paquetes esté desactualizada.

Ejemplo correcto:

RUN apt-get update && apt-get install -y curl

También revisa que el nombre del paquete esté bien escrito. Por ejemplo, usar python3 en lugar de python.

Q3. ¿Cómo se configuran variables de entorno en un Dockerfile?

A3. Se utiliza la instrucción ENV, válida tanto en la construcción como en la ejecución del contenedor.

Ejemplo:

ENV DEBIAN_FRONTEND=noninteractive

Esto evita prompts interactivos durante instalaciones. También puede usarse para definir configuraciones de aplicaciones o claves de API.

Q4. ¿Cuál es la diferencia entre CMD y ENTRYPOINT?

A4. Ambas instrucciones definen qué comando se ejecuta al iniciar un contenedor, pero tienen diferencias:

Ejemplo:

CMD ["python3", "app.py"]
# vs
ENTRYPOINT ["python3"]
CMD ["app.py"]

Con el segundo enfoque, puedes ejecutar docker run my-image another_script.py y pasarlo como argumento.

Q5. Edité mi Dockerfile pero los cambios no se aplican. ¿Por qué?

A5. Docker usa caché en cada capa. Si cambias poco el archivo, puede reutilizar capas previas.

Solución:

docker build --no-cache -t my-image .

Así fuerzas a reconstruir la imagen desde cero y aplicas todos los cambios.