10 ideas de proyectos Docker: De principiante a avanzado

Proyectos Docker de nivel intermedio

Los siguientes proyectos son para quienes tienen un sólido conocimiento de los fundamentos de Docker. En ellos se introducirán conceptos más complejos, como las construcciones multietapa y las técnicas de optimización.

Proyecto 4: Creación en varias fases de una aplicación Node.js

Las compilaciones multietapa ayudan a reducir el tamaño de las imágenes Docker al separar los entornos de compilación y ejecución. En este proyecto, vas a contenerizar una aplicación Node.js utilizando compilaciones multietapa.

Nivel de dificultad: Intermediate

Tecnologías utilizadas: Docker, Node.js, Nginx

Instrucciones paso a paso

• Crea una aplicación Node.js sencilla: Escribe un servidor Node.js básico que devuelva un mensaje sencillo. He aquí un ejemplo:

const express = require('express');
const app = express();
 
app.get('/', (req, res) => res.send('Hello from Node.js'));
 
app.listen(3000, () => console.log('Server running on port 3000'));

• Escribe el archivo Dockerfile con construcción multietapa: La primera etapa construye la aplicación, y la segunda la ejecuta con una imagen base más ligera.

# Stage 1: Build
FROM node:14 as build-stage
WORKDIR /app
COPY package*.json ./
RUN npm install
COPY . .
# Add the following line if there's a build step for the app
# RUN npm run build

# Stage 2: Run
FROM node:14-slim
WORKDIR /app
COPY --from=build-stage /app .
EXPOSE 3000
ENV NODE_ENV=production
CMD ["node", "server.js"]

• Construye la imagen:

docker build -t node-multi-stage .

• Ejecuta el contenedor:

docker run -p 3000:3000 node-multi-stage

Proyecto 5: Dockerizar un modelo de aprendizaje automático con TensorFlow

Este proyecto consistirá en contenerizar un modelo de aprendizaje automático utilizando TensorFlow. El objetivo es crear un entorno portátil en el que puedas ejecutar modelos TensorFlow en varios sistemas sin preocuparte de la configuración subyacente.

Nivel de dificultad: Intermediate

Tecnologías utilizadas: Docker, TensorFlow, Python

Instrucciones paso a paso

• Instala TensorFlow en un script de Python: Crea un script Python model.py que cargue y ejecute un modelo TensorFlow preentrenado:

import tensorflow as tf
model = tf.keras.applications.MobileNetV2(weights='imagenet')
print("Model loaded successfully")

• Escribe el archivo Dockerfile: Define el entorno para TensorFlow dentro de Docker:

FROM tensorflow/tensorflow:latest
WORKDIR /app
COPY . .
CMD ["python", "model.py"]

• Construye la imagen:

docker build -t tensorflow-model .

• Ejecuta el contenedor:

docker run tensorflow-model

Proyecto 6: Crear un entorno de ciencia de datos con Jupyter y Docker

Este proyecto se centra en crear un entorno reproducible de ciencia de datos utilizando Docker y cuadernos Jupyter. El entorno incluirá bibliotecas populares de Python como pandas, NumPy y scikit-learn.

Nivel de dificultad: Intermediate

Tecnologías utilizadas: Docker, Jupyter, Python, scikit-learn

Instrucciones paso a paso

• Crea el archivo docker-compose.yml: Define el servicio Jupyter Notebook y las bibliotecas necesarias. He aquí un ejemplo:

version: '3'
services:
  jupyter:
    	image: jupyter/scipy-notebook
    	ports:
    	- "8888:8888"
    	volumes:
    	- ./notebooks:/home/joelwembo/work

• Inicia el Cuaderno Jupyter: Utiliza Docker Compose para iniciar Jupyter Notebook.

docker-compose up

• Accede al Cuaderno Jupyter: Abre tu navegador y ve a http://localhost:8888.

Proyectos Docker de nivel avanzado

Estos proyectos de nivel avanzado se centrarán en aplicaciones del mundo real y conceptos avanzados de Docker, como canalizaciones de aprendizaje profundo y canalizaciones de datos automatizadas.

Proyecto 7: Reducir el tamaño de una imagen Docker para una aplicación Python

En este proyecto, optimizarás una imagen Docker para una aplicación Python utilizando imágenes base mínimas como Alpine Linux e implementando compilaciones multietapa para mantener el tamaño de la imagen lo más pequeño posible.

Nivel de dificultad: Avanzado

Tecnologías utilizadas: Docker, Python, Alpine Linux

Instrucciones paso a paso

• Escribe el script de Python: Crea un script que analice datos utilizando pandas. Aquí tienes un script de ejemplo:

import pandas as pd
df = pd.read_csv('data.csv')
print(df.head())

• Optimiza el archivo Dockerfile: Utiliza compilaciones multietapa y Alpine Linux para crear una imagen ligera.

# Stage 1: Build stage
FROM python:3.9-alpine as build-stage
WORKDIR /app
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
COPY script.py .

# Stage 2: Run stage
FROM python:3.9-alpine
WORKDIR /app
COPY --from=build-stage /app/script.py .
CMD ["python", "script.py"]

• Construye la imagen:

docker build -t optimized-python-app .

Proyecto 8: Dockerizar un pipeline de aprendizaje profundo con PyTorch

Este proyecto consiste en contenerizar una canalización de aprendizaje profundo utilizando PyTorch. El objetivo es optimizar el Dockerfile en cuanto a rendimiento y tamaño, facilitando la ejecución de modelos de aprendizaje profundo en distintos entornos.

Nivel de dificultad: Avanzado

Tecnologías utilizadas: Docker, PyTorch, Python

Instrucciones paso a paso

• Instala PyTorch en un script de Python: Crea un script que cargue un modelo PyTorch preentrenado y realice la inferencia. He aquí un ejemplo:

import torch
model = torch.hub.load('pytorch/vision', 'resnet18', pretrained=True)
print("Model loaded successfully")

• Escribe el archivo Dockerfile: Define el entorno para PyTorch:

FROM pytorch/pytorch:1.9.0-cuda11.1-cudnn8-runtime
WORKDIR /app
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
COPY model.py .
CMD ["python", "model.py"]

• Construye la imagen:

docker build -t pytorch-model .

• Ejecuta el contenedor:

docker run pytorch-model 

Proyecto 9: Automatización de canalizaciones de datos con Apache Airflow y Docker

En este proyecto, configurarás y pondrás en contenedores un entorno Apache Airflow para automatizar canalizaciones de datos. Apache Airflow es una popular herramienta para orquestar flujos de trabajo complejos muy utilizada en ingeniería de datos.

Nivel de dificultad: Avanzado

Tecnologías utilizadas: Docker, Apache Airflow, Python, PostgreSQL

Instrucciones paso a paso

• Crea el archivo docker-compose.yml: Define los servicios Airflow y la base de datos PostgreSQL:

version: '3'
services:
  postgres:
    image: postgres:latest
    environment:
      POSTGRES_USER: airflow
      POSTGRES_PASSWORD: airflow
      POSTGRES_DB: airflow
    ports:
      - "5432:5432"
    volumes:
      - postgres_data:/var/lib/postgresql/data

  webserver:
    image: apache/airflow:latest
    environment:
      AIRFLOW__CORE__SQL_ALCHEMY_CONN: postgresql+psycopg2://airflow:airflow@postgres/airflow
      AIRFLOW__CORE__EXECUTOR: LocalExecutor
    depends_on:
      - postgres
    ports:
      - "8080:8080"
    volumes:
      - ./dags:/opt/airflow/dags
    command: ["webserver"]

  scheduler:
    image: apache/airflow:latest
    environment:
      AIRFLOW__CORE__SQL_ALCHEMY_CONN: postgresql+psycopg2://airflow:airflow@postgres/airflow
      AIRFLOW__CORE__EXECUTOR: LocalExecutor
    depends_on:
      - postgres
      - webserver
    volumes:
      - ./dags:/opt/airflow/dags
    command: ["scheduler"]

volumes:
  postgres_data:

• Inicia el entorno Flujo de aire: Utiliza Docker Compose para activar el entorno Airflow:

docker-compose up

• Accede a la interfaz de usuario de Airflow: Abre tu navegador y ve a http://localhost:8080.

Proyecto 10: Desplegar una API de ciencia de datos con FastAPI y Docker

Construye y despliega una API de ciencia de datos utilizando FastAPI. Containerizarás la API utilizando Docker y te centrarás en optimizarla para entornos de producción.

Nivel de dificultad: Avanzado

Tecnologías utilizadas: Docker, FastAPI, Python, scikit-learn

Instrucciones paso a paso

• Escribe la aplicación FastAPI: Crea una API sencilla que utilice un modelo de aprendizaje automático para las predicciones. He aquí un ejemplo:

from fastapi import FastAPI
import pickle
 
app = FastAPI()
with open("model.pkl", "rb") as f:
   model = pickle.load(f)
 
@app.post("/predict/")
def predict(data: list):
   return {"prediction": model.predict(data)}

• Escribe el archivo Dockerfile: Crea un Dockerfile que defina el entorno para FastAPI:

FROM python:3.9-slim
WORKDIR /app
COPY requirements.txt .
RUN pip install -r requirements.txt
COPY . .
CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "8000"]

• Construye la imagen:

docker build -t fastapi-app .

• Ejecuta el contenedor:

docker run -p 8000:8000 fastapi-app

Consejos para trabajar en proyectos Docker

Mientras trabajas en estos proyectos, ten en cuenta los siguientes consejos:

• Empieza poco a poco: Empieza con proyectos poco exigentes, y luego pasa a tareas más complejas. Crear confianza con tareas más sencillas es fundamental.
• Documenta tus progresos: Lleva un registro detallado de tus proyectos para realizar un seguimiento de tu aprendizaje y utilizarlo como referencia para futuros esfuerzos.
• Únete a las comunidades Docker: Participa en foros en línea y reuniones locales para compartir tus experiencias, hacer preguntas y aprender de los demás.
• Experimenta y personaliza: No tengas miedo de modificar los proyectos, probar distintos enfoques y explorar nuevas funciones de Docker.
• Sigue aprendiendo: Sigue ampliando tus conocimientos sobre Docker explorando temas y herramientas avanzados como Kubernetes, Docker Swarm o la arquitectura de microservicios.

Conclusión

Dominar Docker implica algo más que aprender comandos y configuraciones. Se trata de comprender cómo encaja Docker en el desarrollo de aplicaciones modernas, en los flujos de trabajo de la ciencia de datos y en la gestión de infraestructuras.

Los proyectos que he compartido en esta guía proporcionan algunas ideas para desarrollar las habilidades básicas y la experiencia práctica necesarias para sobresalir finalmente en escenarios del mundo real.

Llegados a este punto, te sugiero que solidifiques tus conocimientos siguiendo estos cursos:

• Docker intermedio
• Introducción a Kubernetes