Cómo ejecutar un script de Python usando Docker

Ejecutar scripts de Python es una de las tareas más comunes en la automatización. Sin embargo, gestionar dependencias en diferentes sistemas puede ser un desafío. Ahí es donde entra Docker. Docker te permite empaquetar tu script de Python junto con todas sus dependencias necesarias en un contenedor, asegurando que se ejecute de la misma manera en cualquier máquina. En esta guía paso a paso, recorreremos el proceso de crear un script de Python en la vida real y ejecutarlo dentro de un contenedor Docker.

Por qué usar Docker para scripts de Python

Cuando trabajas con scripts de Python, las cosas pueden volverse desordenadas/complicadas muy rápido. Diferentes proyectos necesitan diferentes bibliotecas, y lo que funciona en tu máquina puede fallar en la de otra persona. Docker soluciona eso empaquetando tu script y su entorno juntos. Así que en lugar de decir “Funciona en mi máquina”, puedes estar seguro de que funciona igual en todas partes.

También mantiene tu sistema limpio. No tienes que instalar cada paquete de Python globalmente ni preocuparte por conflictos de versiones. Todo permanece dentro del contenedor.

Si estás implementando o entregando tu script a otra persona, Docker también facilita eso. Sin instrucciones de configuración, sin “instala esto y aquello”. Solo un comando, y se ejecuta.

Escribir el script de Python

Vamos a crear un directorio de proyecto para mantener tu script de Python y el Dockerfile. Una vez creado, navega a este directorio usando el comando cd:

mkdir docker_file_organizer  
cd docker_file_organizer

Crea un script llamado “organize_files.py” para escanear un directorio y agrupar archivos en carpetas según sus extensiones:

nano organize_files.py

Pega el siguiente código en el archivo “organize_file.py”. Aquí, usamos dos módulos de Python preconstruidos, llamados os y shutil, para manejar archivos y crear directorios dinámicamente:

import os  
import shutil  
  
SOURCE_DIR = "/files"  
  
def organize_by_extension(directory):  
    try:  
        for fname in os.listdir(directory):  
            path = os.path.join(directory, fname)  
            if os.path.isfile(path):  
                ext = fname.split('.')[-1].lower() if '.' in fname else 'no_extension'  
                dest_dir = os.path.join(directory, ext)  
                os.makedirs(dest_dir, exist_ok=True)  
                shutil.move(path, os.path.join(dest_dir, fname))  
                print(f"Movido: {fname} → {ext}/")  
    except Exception as e:  
        print(f"Error organizando archivos: {e}")  
  
if __name__ == "__main__":  
    organize_by_extension(SOURCE_DIR)

En este script, organizamos archivos en un directorio dado según sus extensiones. Usamos el módulo os para listar los archivos, verificar si cada elemento es un archivo, extraer su extensión y crear carpetas nombradas según esas extensiones (si no existen ya). Luego, usamos el módulo shutil para mover cada archivo a su carpeta correspondiente. Por cada movimiento, imprimimos un mensaje que muestra la nueva ubicación del archivo.

Crear el Dockerfile

Ahora, crea un Dockerfile para definir el entorno en el que se ejecutará tu script:

FROM python:latest  
LABEL maintainer="[email protected]"  
WORKDIR /usr/src/app  
COPY organize_files.py .  
CMD ["python", "./organize_files.py"]

Usamos este Dockerfile para crear un contenedor con Python, agregar nuestro script a él y asegurarnos de que el script se ejecute automáticamente cuando el contenedor se inicie:

Construir la imagen de Docker

Antes de que puedas construir la imagen de Docker, primero necesitas instalar Docker. Después de eso, ejecuta el siguiente comando para empaquetar todo en una imagen de Docker:

sudo docker build -t file-organizer .

Lee nuestro Dockerfile y junta la configuración de Python y nuestro script para que estén listos para ejecutarse en una sola imagen de contenedor:

Crear una carpeta de muestra con archivos

Para ver nuestro script en acción, creamos una carpeta de prueba llamada “sample_files” con algunos archivos de diferentes tipos. Creamos estos archivos solo para hacer que la carpeta esté un poco desordenada y ver cómo maneja nuestro script de Python:

mkdir ~/sample_files  
touch ~/sample_files/test.txt  
touch ~/sample_files/image.jpg  
touch ~/sample_files/data.csv

Ejecutar el script dentro de Docker

Finalmente, ejecutamos nuestro contenedor Docker y montamos la carpeta de muestra en él. La opción -v monta tu directorio local “~/sample_files” en el directorio “/files” en el contenedor, lo que permite que el script de Python lea y organice archivos en tu máquina host:

docker run --rm -v ~/sample_files:/files file-organizer

Aquí, usamos la opción --rm para eliminar el contenedor automáticamente después de que termine de ejecutarse, lo que ahorra espacio en disco:

Al final, usamos el comando tree para verificar si los archivos han sido ordenados en carpetas según sus extensiones:

tree sample_files

Nota: El comando tree no está preinstalado en la mayoría de los sistemas. Puedes instalarlo fácilmente usando un gestor de paquetes como apt en Ubuntu, brew en macOS, y así sucesivamente.

Reflexiones finales

Con tu script de Python ejecutándose dentro de Docker, estás listo para aprovechar al máximo un entorno de desarrollo limpio, portátil y consistente. Puedes reutilizar fácilmente este flujo de trabajo en contenedores para otras tareas de automatización, compartir tu script sin preocuparte por las dependencias y mantener tu sistema libre de desorden. Como siguiente paso, considera explorar cómo construir imágenes de Docker con múltiples scripts, programar contenedores con trabajos cron, o integrar tus scripts con otras herramientas como Git, Jenkins, o incluso plataformas en la nube para optimizar tu proceso de automatización e implementación.