LENGUAJES DE PROGRAMACIÓN

Docker: primeros pasos

Contenedores desde 0.

01 CONCEPTOS BASE

Imagen vs. contenedor

Una imagen es una plantilla de solo lectura: sistema de archivos + dependencias + comando de arranque. Un contenedor es una instancia de esa imagen corriendo como proceso aislado.

Imagen

Se construye una sola vez con docker build. Es estática: si cambia el código, hay que reconstruirla.

Contenedor

Se crea con docker run. Vive mientras el proceso principal esté activo; al salir, se detiene.

Volumen (-v)

Conecta una carpeta del host con una del contenedor. Los cambios se ven en ambos lados sin reconstruir la imagen.

Puerto (-p)

Expone un puerto interno del contenedor hacia el host, para poder acceder desde el navegador o Postman.

02 CONSTRUYENDO UNA IMAGEN

docker build

$ docker build -t ldp .

Lee el Dockerfile del directorio actual y arma la imagen paso a paso, capa sobre capa, cacheando lo que no cambió.

buildSubcomando que construye una imagen a partir de un Dockerfile.

-t ldpEtiqueta (tag) con la que quedará guardada la imagen: ldp.

.Contexto de build: la carpeta cuyo contenido se envía al daemon de Docker (busca ./Dockerfile ahí).

03 CORRIENDO UN CONTENEDOR

docker run · imagen mínima

$ docker run -it alpine /bin/bash

Descarga (si hace falta) y ejecuta alpine, una distro Linux de ~5 MB, abriendo una terminal interactiva adentro.

runCrea y arranca un contenedor nuevo a partir de una imagen.

-it-i mantiene stdin abierto, -t asigna una pseudo‑terminal. Juntas dan una sesión interactiva de verdad.

alpineLa imagen a usar. Al no llevar tag, Docker asume alpine:latest.

/bin/bashComando que reemplaza el CMD por defecto de la imagen: abre bash en vez del entrypoint original.

04 VOLÚMENES Y PUERTOS

docker run · con -v y -p

$ docker run -it -v .:/api -p 8000:8000 python:3.12 /bin/bash

Mismo patrón que antes, pero ahora el contenedor ve nuestro código y expone un puerto hacia afuera.

-v .:/apiMonta el directorio actual del host (.) en /api dentro del contenedor. Editar un archivo local lo edita también ahí adentro, en vivo.

-p 8000:8000Mapea host:contenedor. Lo que el servidor levante en el puerto 8000 del contenedor queda accesible en localhost:8000.

python:3.12Imagen oficial con Python 3.12 ya instalado — no hace falta instalarlo a mano.

05 ENTRAR A UN CONTENEDOR ACTIVO

docker exec

$ docker exec -it api /bin/bash

A diferencia de run, no crea un contenedor nuevo: abre una terminal dentro de uno que ya está corriendo. Sirve para revisar logs, archivos o probar algo sin bajar el servicio.

execEjecuta un comando dentro de un contenedor que ya está en ejecución.

-itIgual que en run: abre una sesión interactiva con terminal asignada.

apiNombre o ID del contenedor destino, visible con docker ps.

/bin/bashComando a ejecutar adentro; puede ser cualquier otro, no solo una shell.

06 NUESTRA IMAGEN

El Dockerfile

Dockerfile

1FROM python:3.14
2WORKDIR /api
3COPY . /api
4RUN pip install -r requirements.txt
5ENTRYPOINT ["python", "main.py"]

1

FROM python:3.14Imagen base: parte de un Linux con Python 3.14 ya instalado. Todo lo demás se apila sobre esto.

2

WORKDIR /apiCrea (si no existe) y se posiciona en /api. Los pasos siguientes corren desde ahí.

3

COPY . /apiCopia el contenido del contexto de build (nuestro proyecto) adentro de la imagen.

4

RUN pip install...Instala las dependencias dentro de la imagen, en tiempo de build — quedan listas para cuando corra el contenedor.

5

ENTRYPOINT [...]Comando fijo que se ejecuta al arrancar el contenedor, escrito como lista de strings (formato exec, no shell).

07 ORQUESTANDO SERVICIOS

docker-compose.yml

1services:
2  api:
3    build: .
4    ports: ["8000:8000"]
5    depends_on: [db]
6  db:
7    image: postgres:16
8    environment:
9      POSTGRES_PASSWORD: ldp
10    volumes: ["db_data:/var/lib/postgresql/data"]
11volumes:
12  db_data:

api

build: .Este servicio no usa una imagen ya hecha: la construye desde nuestro Dockerfile, igual que docker build -t ldp ..

db

image: postgres:16Este sí usa una imagen oficial lista, sin Dockerfile propio.

↔

depends_onCompose levanta primero db y después api — no espera a que Postgres esté listo, solo a que arranque.

💾

volumes: db_dataVolumen nombrado y gestionado por Docker: los datos de la base persisten aunque el contenedor se borre.

Se levanta todo junto con docker compose up -d, y ambos servicios comparten una red donde api puede llegar a la base como db:5432. El -d lo deja corriendo en segundo plano, sin ocupar la terminal.

08 CHEATSHEET

Para tener a mano

Comando	Qué hace
docker build -t nombre .	Construye una imagen desde el Dockerfile del directorio actual.
docker run -it imagen	Crea y corre un contenedor nuevo en modo interactivo.
docker run -v host:cont	Monta una carpeta del host dentro del contenedor.
docker run -p host:cont	Expone un puerto del contenedor hacia el host.
docker exec -it cont bash	Abre una terminal dentro de un contenedor que ya está corriendo.
docker ps	Lista los contenedores corriendo.
docker compose up -d	Construye (si hace falta) y levanta todos los servicios del compose en segundo plano.
docker compose down	Detiene y elimina los contenedores del compose (los volúmenes nombrados quedan).

→Imagen = receta estática. Contenedor = proceso corriendo a partir de esa receta.

→-v para código que cambia; COPY en el Dockerfile para lo que va fijo en la imagen.

→Compose reemplaza varios docker run largos por un archivo declarativo y reproducible.

09 FLAGS ADICIONALES

Otros flags útiles

Algunos más que aparecen seguido junto a docker run.

Comando	Qué hace
docker run -d imagen	Corre el contenedor en segundo plano (modo detached), sin bloquear la terminal.
docker run --rm imagen	Elimina el contenedor automáticamente al terminar; útil para pruebas rápidas.
docker run --name api imagen	Asigna un nombre fijo al contenedor en vez de uno generado al azar.
docker run -e VAR=valor imagen	Define una variable de entorno dentro del contenedor.
docker network create red	Crea una red para que varios contenedores se encuentren entre sí por nombre.
docker run --network red imagen	Conecta el contenedor a una red existente.