Docker para Jrs #2: Imágenes y Contenedores 🍰

En el primer post te conté lo básico sobre Docker y por qué puede ser tu mejor amigo para contenerizar apps. Ahora vamos a dar un paso más y entender dos conceptos clave: imágenes y contenedores.

Spoiler: si los entendés bien, el resto será pan comido. 😉

¿Qué es una Imagen de Docker?

Las imágenes son como una receta: definen qué ingredientes (archivos, dependencias) y pasos (comandos) necesita tu app para correr.

• Cada imagen es inmutable (una vez creada, no se modifica).
• Se pueden construir usando un archivo llamado Dockerfile.

Ejemplo:
Si querés una app basada en Python, tu receta incluiría Python, librerías, y tu código.

¿Y qué es un Contenedor?

Un contenedor es la app lista y funcionando, creada a partir de una imagen. Es como seguir una receta y tener el plato servido. 🍝

Los contenedores son efímeros: viven mientras los necesitás.
Podés correr, pausar o eliminar contenedores sin afectar la imagen original.

Capas en las Imágenes: el truco de la magia 🎩

Cada imagen se construye en capas. Cada comando en un Dockerfile crea una nueva capa.
Esto hace que las imágenes sean eficientes:

• Si actualizás algo, Docker reutiliza las capas que no cambiaron.
• Resultado: builds más rápidos y menos espacio usado.

Comandos Básicos para Trabajar con Imágenes y Contenedores

Gestión de Imágenes

• docker pull <imagen>: Bajate una imagen del registry (como Docker Hub).
• docker images: Listá las imágenes locales.
• docker rmi <id>: Eliminá una imagen que no necesitás.
• docker tag <id_imagen> <nuevo_nombre>: Renombrá una imagen local.
• docker save -o <archivo.tar> <imagen>: Guardá una imagen como archivo.
• docker load -i <archivo.tar>: Cargá una imagen desde un archivo.

Gestión de Contenedores

• docker run <imagen>: Crea y corre un contenedor.
• docker stop <id>: Paramos un contenedor.
• docker ps -a: Lista todos los contenedores (corriendo o no).
• docker rm <id>: Eliminá un contenedor parado.
• docker logs <id>: Mirá los logs de un contenedor.
• docker exec -it <id> bash: Ingresá a un contenedor corriendo.

Ejemplo práctico:

docker pull nginx
docker run -d --name mi-nginx -p 8080:80 nginx

Con esto, ya tenés un servidor web corriendo en http://localhost:8080. 🚀

Bonus: Contenerizá tu Primera App en Go

Creamos una app simple que devuelve "¡Hola, Docker!" cuando accedemos a localhost:8080.

/mi-app
│── Dockerfile
│── main.go

main.go

package main

import (
    "fmt"
    "net/http"
)

func main() {
    http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
        fmt.Fprintln(w, "¡Hola, Docker!")
    })
    http.ListenAndServe(":8080", nil)
}

Dockerfile

# Imagen base
FROM golang:1.20

# Configuración del contenedor
WORKDIR /app
COPY . .

# Build de la app
RUN go build -o app .

# Comando que ejecuta el contenedor
CMD ["./app"]

Pasos para Correr la App

• Navegá al directorio donde está tu app (mi-app).
• Construí la imagen:

docker build -t mi-app .

• Corré un contenedor basado en la imagen:

docker run -d -p 8080:8080 mi-app

• Probalo en el navegador o con curl:

curl localhost:8080

Próximos Pasos

¡Ya entendiste cómo funcionan las imágenes y los contenedores en Docker! Ahora podés empezar a experimentar construyendo tus propias imágenes y lanzando aplicaciones contenerizadas. Pero acá no termina el viaje: en el próximo post vamos a hablar de algo igual de importante que los contenedores mismos, los volúmenes.

Vas a aprender cómo guardar y compartir datos entre tus contenedores, algo fundamental si querés que tus aplicaciones sean más que "efímeras". Desde un servidor web que mantiene sus logs hasta una base de datos que conserva información entre reinicios, los volúmenes son clave para llevar tus contenedores al próximo nivel. 🚀

Nos vemos en la próxima entrega: "Docker para Jrs #3: Guardá tus Datos con Volúmenes 📂". ¡A seguir aprendiendo! 🙌