# Contenedorizar una aplicación Golang


La contenedorización te ayuda a empaquetar la aplicación y sus dependencias en un solo paquete llamado contenedor. Este paquete se puede ejecutar en cualquier plataforma sin preocuparte por el entorno. En esta sección, aprenderás cómo contenedorizar una aplicación Golang usando Docker.

Para contenedorizar una aplicación Golang, primero debes crear un Dockerfile. El Dockerfile contiene las instrucciones para construir y ejecutar la aplicación en un contenedor. Además, al crear un Dockerfile, puedes seguir diferentes conjuntos de mejores prácticas para optimizar el tamaño de la imagen y hacerla más segura.

## Creación de un Dockerfile

Crea un nuevo archivo llamado `Dockerfile` en el directorio raíz de tu aplicación Golang. El Dockerfile contiene las instrucciones para construir y ejecutar la aplicación en un contenedor.

A continuación se muestra un Dockerfile para una aplicación Golang. También encontrarás este archivo en el directorio `go-prometheus-monitoring`.

```dockerfile
# Usar la imagen oficial de Golang como base
FROM golang:1.24-alpine AS builder

# Configurar variables de entorno
ENV CGO_ENABLED=0 \
    GOOS=linux \
    GOARCH=amd64

# Configurar el directorio de trabajo dentro del contenedor
WORKDIR /build

# Copiar los archivos go.mod y go.sum para la instalación de dependencias
COPY go.mod go.sum ./

# Descargar dependencias
RUN go mod download

# Copiar todo el código fuente de la aplicación
COPY . .

# Compilar el binario de Go
RUN go build -o /app .

# Etapa final ligera
FROM alpine:3.21 AS final

# Copiar el binario compilado desde la etapa de construcción (builder)
COPY --from=builder /app /bin/app

# Exponer el puerto de la aplicación
EXPOSE 8000

# Ejecutar la aplicación
CMD ["bin/app"]
```

## Entendiendo el Dockerfile

El Dockerfile consta de dos etapas:

1. **Etapa de construcción (Build stage)**: Esta etapa utiliza la imagen oficial de Golang como base y configura las variables de entorno necesarias. También establece el directorio de trabajo dentro del contenedor, copia los archivos `go.mod` y `go.sum` para la instalación de dependencias, descarga las dependencias, copia todo el código fuente de la aplicación y compila el binario de Go.

   Utilizas la imagen `golang:1.24-alpine` como imagen base para la etapa de construcción. La variable de entorno `CGO_ENABLED=0` deshabilita CGO, lo cual es útil para compilar binarios estáticos. También configuras las variables de entorno `GOOS` y `GOARCH` en `linux` y `amd64`, respectivamente, para compilar el binario para la plataforma Linux.

2. **Etapa final (Final stage)**: Esta etapa utiliza la imagen oficial de Alpine como base y copia el binario compilado desde la etapa de construcción. También expone el puerto de la aplicación y la ejecuta.

   Utilizas la imagen `alpine:3.21` como imagen base para la etapa final. Copias el binario compilado de la etapa de construcción a la imagen final. Expones el puerto de la aplicación mediante la instrucción `EXPOSE` y ejecutas la aplicación con la instrucción `CMD`.

   Además de la construcción multi-etapa, el Dockerfile sigue mejores prácticas como el uso de imágenes oficiales, la configuración del directorio de trabajo y la copia únicamente de los archivos necesarios a la imagen final. Puedes optimizar aún más el Dockerfile aplicando otras mejores prácticas.

## Construcción de la imagen Docker y ejecución de la aplicación

Una vez que tengas el Dockerfile, puedes construir la imagen Docker y ejecutar la aplicación en un contenedor.

Para construir la imagen Docker, ejecuta el siguiente comando en la terminal:

```console
$ docker build -t go-api:latest .
```

Después de construir la imagen, puedes ejecutar la aplicación en un contenedor con el siguiente comando:

```console
$ docker run -p 8000:8000 go-api:latest
```

La aplicación comenzará a ejecutarse dentro del contenedor y podrás acceder a ella en `http://localhost:8000`. También puedes verificar los contenedores que están en ejecución mediante el comando `docker ps`.

```console
$ docker ps
```

## Resumen

En esta sección, aprendiste a contenedorizar una aplicación Golang utilizando un Dockerfile. Creaste un Dockerfile de múltiples etapas para construir y ejecutar la aplicación en un contenedor. También aprendiste sobre las mejores prácticas para optimizar el tamaño de la imagen Docker y hacerla más segura.

Información relacionada:

- [Referencia de Dockerfile](/reference/dockerfile/)
- [Archivo .dockerignore](/reference/dockerfile/#dockerignore-file)

## Próximos pasos

En la siguiente sección, aprenderás a usar Docker Compose para conectar y ejecutar múltiples servicios juntos con el fin de monitorear una aplicación Golang con Prometheus y Grafana.