Cómo aprender Docker desde cero: Guía para profesionales de los datos

Paso 3: Ejecuta tu primer contenedor

Ahora que Docker está instalado, es hora de ejecutar tu primer contenedor. Empezaremos con la imagen simple hola-mundo, perfecta para principiantes.

1. Abre tu terminal (o Símbolo del sistema en Windows) y ejecuta el siguiente comando:

sudo docker run hello-world

Este comando indica a Docker que busque localmente la imagen hello-world. Si no la encuentra, Docker extraerá la imagen de Docker Hub y la ejecutará.

Si Docker está instalado correctamente, verás un mensaje que dice "¡Hola desde Docker!" junto con detalles sobre cómo funciona el proceso Docker. Esta salida confirma que Docker extrajo correctamente la imagen, creó un nuevo contenedor y ejecutó el código dentro de él.

Paso 4: Construye tu primera imagen Docker

En este paso, crearás una imagen Docker personalizada para un sencillo proyecto de ciencia de datos. Esta imagen incluirá Python y bibliotecas comunes de ciencia de datos como pandas, NumPy y scikit-learn.

1. Crea un directorio nuevo:

• • Empieza por crear un nuevo directorio para tu proyecto y navega hasta él:

mkdir my-data-science-app
cd my-data-science-app

2. Crea un archivo Dockerfile:

Dentro de este directorio, crea un archivo llamado Dockerfile (sin ninguna extensión de archivo):

# Use an official Python runtime as a parent image
FROM python:3.8-slim
 
# Set the working directory in the container
WORKDIR /app
 
# Copy the current directory contents into the container at /app
COPY . /app
 
# Install any needed packages specified in requirements.txt
RUN pip install --no-cache-dir -r requirements.txt
 
# Make port 8888 available to the world outside this container
EXPOSE 8888
 
# Run a Jupyter notebook server when the container launches
CMD ["jupyter", "notebook", "--ip=0.0.0.0", "--port=8888", "--no-browser", "--allow-root"]

El Dockerfile hace lo siguiente:

• FROM python:3.8-slim: Esto establece la imagen base en Python 3.8 en su variante slim, una versión mínima de Python, ideal para un entorno ligero de ciencia de datos.
• WORKDIR /app: Esto establece el directorio de trabajo dentro del contenedor en /app. Todos los comandos posteriores se ejecutarán dentro de este directorio.
• COPY . /app: Esto copia todos los archivos de tu directorio actual en la máquina anfitriona y los coloca en el directorio /app del contenedor. Esto suele incluir tus scripts de ciencia de datos y archivos de configuración.
• RUN pip install --no-cache-dir -r requirements.txt: Esto instala las bibliotecas Python que aparecen en requirements.txt. Las bibliotecas habituales para la ciencia de datos son pandas, NumPy y scikit-learn.
• EXPOSE 8888: Esto hace que el puerto 8888 esté disponible para la máquina anfitriona, el puerto por defecto para los cuadernos Jupyter.
• CMD ["jupyter", "notebook", "--ip=0.0.0.0", "--port=8888", "--no-browser", "--allow-root"]: Este comando lanza un servidor de cuadernos Jupyter cuando se inicia el contenedor, haciéndolo accesible desde tu navegador web.

3. Crea un archivo requirements.txt:

En el mismo directorio, crea un archivo requirements.txt para listar los paquetes de Python que necesita tu aplicación:

pandas
numpy
scikit-learn
matplotlib

Este archivo enumera las bibliotecas Python que se instalarán en tu contenedor Docker.

4. Construye la imagen Docker:

• Con el Dockerfile y requirements.txt listos, construye tu imagen Docker utilizando el siguiente comando:

sudo docker build -t my-data-science-app .

El comando anterior hace lo siguiente:

• docker build: Inicia el proceso de construcción de una imagen Docker.
• -t my-data-science-app: La opción -t etiqueta la imagen como "mis-datos-ciencia-app".
• .: El punto al final especifica el contexto de construcción, que es el directorio actual. Docker utilizará los archivos de este directorio para construir la imagen.

5. Ejecuta la imagen Docker:

Una vez finalizado el proceso de compilación, puedes ejecutar tu nueva imagen Docker como contenedor:

sudo docker run -p 8888:8888 my-data-science-app

Vamos a desglosar el comando:

• docker run: Ejecuta un contenedor basado en la imagen especificada.
• -p 8888:8888: La opción -p asigna el puerto 8888 de tu máquina local al puerto 8888 dentro del contenedor, lo que te permite acceder al servidor de Jupyter Notebook navegando a localhost:8888 en tu navegador web.
• my-data-science-app: Especifica la imagen que se va a ejecutar.

Paso 5: Utiliza Docker Compose

Docker Compose es una herramienta esencial para gestionar aplicaciones multicontenedor. En un proyecto de ciencia de datos, puedes necesitar contenedores separados para distintos componentes, como un cuaderno Jupyter, una base de datos para almacenar datos y una herramienta de visualización de datos.

Docker Compose te permite definir estos servicios en un único archivo YAML, lo que facilita la puesta en marcha de todo tu entorno de ciencia de datos con un solo comando.

1. Crea un archivo docker-compose.yml:

• En el directorio de tu proyecto, crea un archivo llamado docker-compose.yml y escribe en él las siguientes líneas:

version: '3.8'
services:
  jupyter:
        image: jupyter/scipy-notebook:latest
        volumes:
        - ./notebooks:/home/joelwembo/work
        ports:
        - "8888:8888"
        environment:
        - JUPYTER_ENABLE_LAB=yes
 
  postgres:
        image: postgres:13-alpine
        environment:
        POSTGRES_USER: myuser
        POSTGRES_PASSWORD: mypassword
        POSTGRES_DB: mydatabase
        volumes:
        - postgres_data:/var/lib/postgresql/data
        ports:
        - "5432:5432"
 
  redis:
        image: redis:alpine
        ports:
        - "6379:6379"
 
volumes:
  postgres_data:
 

Vamos a desglosar lo que hace el archivo Docker Compose:

• version: '3.8': Especifica la versión del formato de archivo Docker Compose. La versión 3.8 es una versión de uso común que admite muchas funciones.
• services:: La sección de servicios define los distintos contenedores (servicios) que componen tu aplicación.
• jupyter:: Este servicio representa un entorno de cuaderno Jupyter esencial para el análisis interactivo de datos.
• image: jupyter/scipy-notebook:latest: Especifica la imagen Docker que se utilizará para el cuaderno Jupyter, que incluye bibliotecas populares de ciencia de datos como NumPy, pandas y matplotlib.
• volumes: - ./notebooks:/home/joelwembo/work: Esto monta el directorio de cuadernos de tu máquina anfitriona en /home/joelwembo/work dentro del contenedor, permitiéndote persistir y compartir tus cuadernos. Nota: Este es mi camino personal y el tuyo debe ser diferente.
• ports: - "8888:8888": Esto asigna el puerto 8888 de tu máquina anfitriona al puerto 8888 del contenedor, que es el puerto por defecto para los cuadernos Jupyter.
• environment: - JUPYTER_ENABLE_LAB=yes: Esto habilita JupyterLab, una interfaz más potente para trabajar con cuadernos Jupyter.
• postgres:: Este servicio ejecuta una base de datos PostgreSQL, que suele utilizarse para almacenar y gestionar grandes conjuntos de datos en proyectos de ciencia de datos.
• image: postgres:13-alpine: Aquí se especifica la imagen Docker para la versión 13 de PostgreSQL, basada en la distribución ligera Alpine Linux.
• environment:: Estas variables de entorno configuran la base de datos con un usuario, una contraseña y un nombre de base de datos.
• volumes: - postgres_data:/var/lib/postgresql/data: Esto monta un volumen Docker para persistir los datos de la base de datos fuera del contenedor, de modo que tus datos no se pierdan cuando se detenga el contenedor.
• ports: - "5432:5432": Esto asigna el puerto 5432 de tu máquina anfitriona al puerto 5432 del contenedor, el puerto por defecto para PostgreSQL.
• redis:: Este servicio ejecuta un servidor Redis, que puede utilizarse como almacén o caché rápido de datos en memoria.
• image: redis:alpine: Especifica la imagen Redis utilizando la variante ligera Alpine.
• ports: - "6379:6379": Esto asigna el puerto 6379 de tu máquina anfitriona al puerto 6379 del contenedor, el puerto por defecto para Redis.
• volumes:: Esta sección define volúmenes con nombre que pueden ser compartidos entre servicios o persistir datos a través de los reinicios de los contenedores.
• postgres_data:: Esto crea un volumen con nombre para la persistencia de datos PostgreSQL.

Para iniciar tu aplicación multicontenedor, simplemente ejecuta lo siguiente:

sudo docker compose up

Este comando construye las imágenes (si es necesario) e inicia los contenedores definidos en tu archivo docker-compose.yml. Hace que aparezcan tanto la aplicación web como el servicio Redis, permitiéndoles comunicarse entre sí según lo definido.

¡Ya has desplegado tu primera aplicación Docker! ¿No es estupendo? Ahora, vamos a elaborar un plan para tu aprendizaje continuo.

Un ejemplo de plan de aprendizaje para Docker

Aquí tienes un plan semanal que puedes seguir. Siéntete libre de adaptarlo a tus necesidades específicas. 

Si necesitas un camino más definido, el curso de Containerización y Virtualización con Docker y Kubernetesck es perfecto para ti. Contiene cuatro cursos esenciales.

Semana 1: Familiarízate con los conceptos básicos de Docker

• Objetivo: Comprende los conceptos básicos de Docker y los comandos básicos.
• Tareas:
• Instala Docker y configura Docker Desktop.
• Aprende los comandos de Docker: docker run, docker ps, docker stop, docker rm, etc.
• Ejecuta contenedores sencillos para herramientas de exploración de datos como Ubuntu o Alpine y prueba comandos básicos.
• Explora imágenes Docker oficiales y ejecuta contenedores para herramientas básicas de visualización (por ejemplo, un simple contenedor matplotlib).
• Recursos: Curso Conceptos de Containerización y Virtualización, Curso Introducción a Docker.

Semana 2: Construye y ejecuta imágenes Docker para herramientas de datos

• Objetivo: Aprende a crear y gestionar imágenes Docker personalizadas.
• Tareas:
• Escribe un Dockerfile para un entorno básico de análisis de datos (por ejemplo, Python con Pandas y NumPy).
• Construye la imagen Docker con docker build.
• Ejecuta contenedores desde tu imagen personalizada y prueba herramientas de datos como Jupyter Notebook.
• Crea Dockerfiles para TensorFlow y PostgreSQL, asegurando una configuración y vinculación adecuadas.
• Recursos: Curso de Introducción a Docker.

Semana 3: Explora Docker Compose

• Objetivo: Comprende y utiliza Docker Compose para configuraciones multicontenedor.
• Tareas:
• Instala Docker Compose y aprende sus fundamentos.
• Escribe archivos docker-compose.yml para definir aplicaciones multicontenedor.
• Practica con ejemplos como la configuración de una aplicación web con una base de datos backend (por ejemplo, una aplicación Flask con PostgreSQL).
• Experimenta con distintas configuraciones y dependencias de servicios.
• Recursos: Curso intermedio de Docker.

Semana 4: Profundiza en las redes y volúmenes de Docker

• Objetivo: Domina las capacidades de red y almacenamiento de Docker.
• Tareas:
• Conoce las redes Docker y cómo crearlas (bridge, host, overlay).
• Practica la creación de redes personalizadas y la conexión de contenedores a ellas.
• Explora los volúmenes Docker para el almacenamiento persistente y practica su creación y gestión.
• Implementa una configuración en la que los contenedores se comuniquen a través de una red personalizada y utilicen volúmenes para la persistencia de los datos.
• Recursos: Curso intermedio de Docker.

Semana 5: Despliega y gestiona contenedores Docker en producción

• Objetivo: Comprender el despliegue y la gestión de contenedores en producción.
• Tareas:
• Aprende las mejores prácticas para desplegar contenedores Docker (por ejemplo, utilizando Docker Hub o un registro privado).
• Explora la orquestación de contenedores con Docker Swarm: creación y gestión de servicios.
• Comprender el escalado de contenedores y la gestión de registros.
• Experimenta con el despliegue de una aplicación en contenedores en un entorno de ensayo o de producción.
• Recursos: Curso intermedio de Docker.

Semana 6: Introducción a Kubernetes para la orquestación de contenedores

• Objetivo: Familiarízate con Kubernetes para escalar y gestionar aplicaciones en contenedores.
• Tareas:
• Instala y configura un entorno local de Kubernetes (por ejemplo, Minikube o Kind).
• Aprende los conceptos básicos de Kubernetes: pods, servicios, despliegues y espacios de nombres.
• Despliega una aplicación sencilla en contenedores sobre Kubernetes.
• Explora el escalado y la gestión de aplicaciones con Kubernetes, centrándote en el manejo de una herramienta de datos en contenedores como Jupyter.
• Recursos: Curso de Introducción a Kubernetes.

Consejos y formas de aprender Docker

Por último, aquí tienes algunos consejos y buenas prácticas que te ayudarán a acelerar tu camino de aprendizaje de Docker.

Practica regularmente

La clave para dominar Docker es la práctica constante y práctica. Empieza trabajando en proyectos personales, como contenerizar un sitio web sencillo o crear un entorno de desarrollo local. 

A medida que te sientas más cómodo, desafíate a ti mismo con tareas más complejas, como crear una aplicación multicontenedor o desplegar un servidor web. 

La experimentación regular con diferentes casos de uso -como la creación de imágenes Docker personalizadas o la configuraciónde un canal CI/CD-deepen tu comprensión y te ayudará a solidificar los conceptos clave. Además, participar en retos o ejercicios Docker en línea es una forma estupenda de poner a prueba y mejorar tus habilidades de una forma estructurada y orientada a objetivos.

Utiliza recursos online

Los recursos en línea son inestimables para aprender Docker. La documentación oficial de Docker es un lugar excelente para empezar, ya que ofrece información autorizada y actualizada. 

Además, hay un montón de cursos completos disponibles en plataformas como DataCamp, que pueden ayudarte a guiarte en el proceso de aprendizaje. 

Para los que prefieren el aprendizaje visual, los tutoriales de YouTube del canal oficial de Docker y de otros educadores ofrecen contenidos útiles y accesibles para reforzar tu comprensión.

Únete a la comunidad Docker

Participar en la comunidad Docker es otra forma poderosa de avanzar en tu aprendizaje. Participa en foros como Docker Community Forums y Reddit para intercambiar ideas, hacer preguntas y compartir experiencias con otros estudiantes y profesionales. 

Asistir a reuniones, seminarios web o conferencias sobre Docker también es una forma estupenda de estar al día de las tendencias del sector y ampliar tu red de contactos.

Trabaja en proyectos de código abierto

Contribuir a proyectos de código abierto que utilizan Docker puede ser una forma fantástica de adquirir experiencia práctica en el mundo real. 

Sitios web como GitHub ofrecen oportunidades para colaborar en proyectos relacionados con Docker, lo que te permite aprender de otros y aplicar tus habilidades en diversos contextos. La colaboración inherente al trabajo de código abierto ayuda a exponerte a diferentes enfoques y soluciones, fomentando una comprensión más profunda de las capacidades de Docker.

Mantente informado

Por último, mantenerse al día de los últimos avances de Docker es esencial para mantener la competencia. Mantente atento al blog oficial de Docker y a las notas de la versión para estar al día de las nuevas funciones o cambios. Participar en los debates de la comunidad en foros y redes sociales también te informará sobre las tendencias emergentes y las mejores prácticas, ayudándote a perfeccionar continuamente tus conocimientos sobre Docker.

Con la práctica regular, la participación activa en la comunidad y el aprendizaje continuo, construirás una base sólida en Docker y permanecerás equipado para manejar los últimos avances en el campo.

Conclusión

Docker ha revolucionado el despliegue de aplicaciones y la gestión de datos empaquetando las aplicaciones y sus dependencias en contenedores aislados. Esto resuelve retos comunes como las incoherencias del entorno y garantiza que los flujos de trabajo sigan siendo coherentes, escalables y eficientes para los profesionales de los datos.

Esta guía ha proporcionado los pasos fundamentales para dominar Docker, desde los conceptos básicos hasta las implementaciones prácticas. Para profundizar aún más en tus conocimientos, considera la posibilidad de explorar recursos adicionales como los cursos Introducción a Docker y Docker Intermedio en DataCamp. A medida que avances, ampliar tus habilidades con herramientas de orquestación como Kubernetes es igualmente importante: consulta el curso Introducción a Kubernetes para empezar.

Practicando con regularidad, utilizando los recursos disponibles y manteniéndote comprometido con la comunidad desbloquearás todo el potencial de Docker para gestionar entornos de datos complejos.