Este completo tutorial de Docker proporciona a los desarrolladores y profesionales DevOps conocimientos esenciales sobre la creación, gestión y comprensión de imágenes Docker. Al explorar los componentes de las imágenes, las estructuras de capas y las técnicas de implementación prácticas, los participantes adquirirán habilidades prácticas en la contenedorización y el empaquetado de aplicaciones.
Las imágenes Docker son plantillas de solo lectura utilizadas para crear contenedores. Contienen entornos de software preconfigurados, código de aplicación, dependencias y configuraciones de tiempo de ejecución. Las imágenes Docker sirven como planos para desplegar entornos de aplicación consistentes y reproducibles en diferentes sistemas.
| Componente | Descripción | Ejemplo |
|---|---|---|
| Capa Base | Sistema operativo fundamental | Ubuntu 22.04 |
| Capa de Aplicación | Software y dependencias | Python 3.9, nginx |
| Capa de Configuración | Configuraciones de tiempo de ejecución | Variables de entorno |
Aquí hay un ejemplo de la creación de una imagen simple de una aplicación web Python:
## Crear directorio del proyecto
mkdir docker-demo
cd docker-demo
## Crear Dockerfile
touch Dockerfile
## Contenido del Dockerfile
cat > Dockerfile << EOL
FROM ubuntu:22.04
RUN apt-get update && apt-get install -y python3 python3-pip
WORKDIR /app
COPY app.py .
RUN pip3 install flask
EXPOSE 5000
CMD ["python3", "app.py"]
EOL
## Crear la aplicación Flask de muestra
cat > app.py << EOL
from flask import Flask
app = Flask(__name__)
@app.route('/')
def hello():
return "Ejemplo de Imagen Docker"
if __name__ == '__main__':
app.run(host='0.0.0.0', port=5000)
EOL
## Construir la imagen Docker
docker build -t python-web-app .Las imágenes Docker están compuestas de múltiples capas de solo lectura. Cada instrucción en el Dockerfile crea una nueva capa, lo que permite un almacenamiento eficiente y una creación rápida de la imagen. Cuando se construye una imagen, Docker guarda en caché estas capas para optimizar los tiempos de construcción y reducir el uso del espacio en disco.
Las imágenes Docker se identifican de forma única por:
Ejemplo: ubuntu:22.04 o python-web-app:latest
Dockerfile es un archivo de texto que contiene instrucciones para construir una imagen Docker. Cada instrucción crea una nueva capa en la imagen, definiendo el entorno, las dependencias y la configuración de la aplicación.
| Instrucción | Propósito | Ejemplo |
|---|---|---|
| FROM | Especificar la imagen base | FROM ubuntu:22.04 |
| RUN | Ejecutar comandos | RUN apt-get update |
| COPY | Copiar archivos a la imagen | COPY app/ /application |
| WORKDIR | Establecer directorio de trabajo | WORKDIR /app |
| EXPOSE | Definir puertos de red | EXPOSE 8080 |
| CMD | Comando predeterminado del contenedor | CMD ["python", "app.py"] |
## Crear la estructura del proyecto
mkdir -p /tmp/docker-nodejs-app
cd /tmp/docker-nodejs-app
## Crear Dockerfile
cat > Dockerfile << EOL
FROM node:16-alpine
WORKDIR /app
COPY package.json .
RUN npm install
COPY . .
EXPOSE 3000
CMD ["node", "server.js"]
EOL
## Crear package.json
cat > package.json << EOL
{
"name": "nodejs-docker-app",
"version": "1.0.0",
"dependencies": {
"express": "^4.17.1"
}
}
EOL
## Crear un servidor Express simple
cat > server.js << EOL
const express = require('express');
const app = express();
const PORT = 3000;
app.get('/', (req, res) => {
res.send('Ejemplo de Construcción de Imagen Docker');
});
app.listen(PORT, () => {
console.log($(Servidor ejecutándose en el puerto ${PORT}));
});
EOL
## Construir la imagen Docker
docker build -t nodejs-web-app .
## Verificar la creación de la imagen
docker imagesEl contexto de construcción es el directorio que contiene el Dockerfile y los archivos referenciados. Docker envía este directorio completo al demonio Docker durante la construcción de la imagen, permitiendo una creación completa de la imagen.
Las construcciones multietapa permiten crear imágenes más pequeñas y eficientes utilizando varias instrucciones FROM en un solo Dockerfile, separando las dependencias de tiempo de compilación del entorno de tiempo de ejecución.
La administración eficiente de imágenes implica reducir el tamaño de las imágenes, minimizar el número de capas y aplicar las mejores prácticas para la creación y el almacenamiento de imágenes.
| Técnica | Descripción | Ejemplo |
|---|---|---|
| Imágenes Base Alpine | Distribución Linux mínima | FROM alpine:3.15 |
| Construcciones Multietapa | Entornos de compilación y ejecución separados | Múltiples instrucciones FROM |
| .dockerignore | Excluir archivos innecesarios | Evitar transferencias de archivos grandes |
## Listar imágenes locales
docker images
## Eliminar imágenes no utilizadas
docker image prune
## Etiquetar y versionar imágenes
docker tag original-image:latest myregistry/image:v1.0
## Empujar a un Registro Docker
docker push myregistry/image:v1.0
## Extraer una versión específica de la imagen
docker pull myregistry/image:v1.0## Crear Dockerfile optimizado
cat > Dockerfile << EOL
## Construcción multietapa para aplicación Python
FROM python:3.9-alpine AS builder
WORKDIR /app
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
FROM python:3.9-alpine
WORKDIR /app
COPY --from=builder /usr/local/lib/python3.9/site-packages /usr/local/lib/python3.9/site-packages
COPY . .
RUN addgroup -S appgroup && adduser -S appuser -G appgroup
USER appuser
CMD ["python", "app.py"]
EOL
## Crear archivo de requisitos
cat > requirements.txt << EOL
flask==2.1.0
gunicorn==20.1.0
EOL
## Construir imagen optimizada
docker build -t optimized-python-app:slim .
## Analizar tamaño de la imagen
docker images | grep optimized-python-appLos registros Docker proporcionan almacenamiento y distribución centralizados de imágenes. Permiten el versionado, el control de acceso y el intercambio eficiente de imágenes entre equipos de desarrollo y entornos.
Docker guarda en caché las capas de las imágenes para acelerar las construcciones posteriores. Ordenar las instrucciones del Dockerfile de menos a más cambios frecuentes minimiza el tiempo de reconstrucción y optimiza el proceso de creación de imágenes.
Las imágenes Docker son fundamentales en la implementación moderna de software, ofreciendo una forma consistente y eficiente de empaquetar aplicaciones con sus dependencias. Dominando las técnicas de creación de imágenes, comprendiendo el funcionamiento de las capas y aprovechando las instrucciones de Dockerfile, los desarrolladores pueden optimizar sus flujos de trabajo y asegurar entornos de aplicación confiables y portables en diferentes sistemas.
