# Conectando servicios con Docker Compose


Ahora que has contenedorizado la aplicación Golang, utilizarás Docker Compose para conectar tus servicios. Conectarás la aplicación Golang, Prometheus y Grafana para monitorear la aplicación Golang con Prometheus y Grafana.

## Creación de un archivo Docker Compose

Crea un nuevo archivo llamado `compose.yml` en el directorio raíz de tu aplicación Golang. El archivo Docker Compose contiene las instrucciones para ejecutar múltiples servicios y conectarlos entre sí.

A continuación se muestra un archivo Docker Compose para un proyecto que utiliza Golang, Prometheus y Grafana. También encontrarás este archivo en el directorio `go-prometheus-monitoring`.

```yaml
services:
  api:
    container_name: go-api
    build:
      context: .
      dockerfile: Dockerfile
    image: go-api:latest
    ports:
      - 8000:8000
    networks:
      - go-network
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:8000/health"]
      interval: 30s
      timeout: 10s
      retries: 5
    develop:
      watch:
        - path: .
          action: rebuild

  prometheus:
    container_name: prometheus
    image: prom/prometheus:v2.55.0
    volumes:
      - ./Docker/prometheus.yml:/etc/prometheus/prometheus.yml
    ports:
      - 9090:9090
    networks:
      - go-network

  grafana:
    container_name: grafana
    image: grafana/grafana:11.3.0
    volumes:
      - ./Docker/grafana.yml:/etc/grafana/provisioning/datasources/datasource.yaml
      - grafana-data:/var/lib/grafana
    ports:
      - 3000:3000
    networks:
      - go-network
    environment:
      - GF_SECURITY_ADMIN_USER=admin
      - GF_SECURITY_ADMIN_PASSWORD=password

volumes:
  grafana-data:

networks:
  go-network:
    driver: bridge
```

## Entendiendo el archivo Docker Compose

El archivo Docker Compose consta de tres servicios:

- **Servicio de la aplicación Golang**: Este servicio construye la aplicación Golang utilizando el Dockerfile y la ejecuta en un contenedor. Expone el puerto `8000` de la aplicación y se conecta a la red `go-network`. También define una verificación de estado (health check) para monitorear la salud de la aplicación. Has utilizado `healthcheck` para este monitoreo. La verificación de estado se ejecuta cada 30 segundos y se reintenta 5 veces si llega a fallar. Utiliza el comando `curl` para verificar el endpoint `/health` de la aplicación. Además del health check, has agregado una sección `develop` para vigilar (watch) los cambios en el código fuente de la aplicación y reconstruirla utilizando la función Docker Compose Watch.

- **Servicio de Prometheus**: Este servicio ejecuta el servidor de Prometheus en un contenedor. Utiliza la imagen oficial de Prometheus `prom/prometheus:v2.55.0`. Expone el servidor de Prometheus en el puerto `9090` y se conecta a la red `go-network`. También has montado el archivo `prometheus.yml` desde el directorio `Docker` que se encuentra en la raíz de tu proyecto. El archivo `prometheus.yml` contiene la configuración de Prometheus para extraer las métricas de la aplicación Golang. De esta manera conectas el servidor de Prometheus a la aplicación Golang.

  ```yaml
  global:
    scrape_interval: 10s
    evaluation_interval: 10s

  scrape_configs:
    - job_name: myapp
      static_configs:
        - targets: ["api:8000"]
  ```

  En el archivo `prometheus.yml`, has definido una tarea (job) llamada `myapp` para extraer las métricas de la aplicación Golang. El campo `targets` especifica el objetivo del cual extraer las métricas. En este caso, el objetivo es la aplicación Golang que se ejecuta en el puerto `8000`. `api` es el nombre del servicio de la aplicación Golang en el archivo Docker Compose. El servidor de Prometheus extraerá las métricas de la aplicación Golang cada 10 segundos.

- **Servicio de Grafana**: Este servicio ejecuta el servidor de Grafana en un contenedor. Utiliza la imagen oficial de Grafana `grafana/grafana:11.3.0`. Expone el servidor de Grafana en el puerto `3000` y se conecta a la red `go-network`. También has montado el archivo `grafana.yml` desde el directorio `Docker` que está en el directorio raíz de tu proyecto. El archivo `grafana.yml` contiene la configuración de Grafana para agregar la fuente de datos (data source) de Prometheus. Así es como conectas el servidor de Grafana al de Prometheus. En las variables de entorno, has establecido el usuario administrador y la contraseña de Grafana, que se utilizarán para iniciar sesión en el tablero de Grafana.

  ```yaml
  apiVersion: 1
  datasources:
    - name: Prometheus (Main)
      type: prometheus
      url: http://prometheus:9090
      isDefault: true
  ```

  En el archivo `grafana.yml`, has definido una fuente de datos de Prometheus llamada `Prometheus (Main)`. El campo `type` especifica el tipo de la fuente de datos, que es `prometheus`. El campo `url` especifica la URL del servidor de Prometheus para obtener las métricas. En este caso, la URL es `http://prometheus:9090`. `prometheus` es el nombre del servicio del servidor de Prometheus en el archivo Docker Compose. El campo `isDefault` especifica si esta fuente de datos es la predeterminada en Grafana.

Además de los servicios, el archivo Docker Compose también define un volumen llamado `grafana-data` para persistir los datos de Grafana y una red llamada `go-network` para conectar los servicios. Has creado una red personalizada `go-network` para conectar los servicios entre sí. El campo `driver: bridge` especifica el controlador de red que se utilizará.

## Construcción y ejecución de los servicios

Ahora que tienes el archivo Docker Compose, puedes construir los servicios y ejecutarlos juntos usando Docker Compose.

Para construir y ejecutar los servicios, ejecuta el siguiente comando en la terminal:

```console
$ docker compose up
```

El comando `docker compose up` construye los servicios definidos en el archivo Docker Compose y los ejecuta juntos. Verás una salida similar en la terminal:

```console
 ✔ Network go-prometheus-monitoring_go-network  Created                                                           0.0s
 ✔ Container grafana                            Created                                                           0.3s
 ✔ Container go-api                             Created                                                           0.2s
 ✔ Container prometheus                         Created                                                           0.3s
Attaching to go-api, grafana, prometheus
go-api      | [GIN-debug] [WARNING] Creating an Engine instance with the Logger and Recovery middleware already attached.
go-api      |
go-api      | [GIN-debug] [WARNING] Running in "debug" mode. Switch to "release" mode in production.
go-api      |  - using env:     export GIN_MODE=release
go-api      |  - using code:    gin.SetMode(gin.ReleaseMode)
go-api      |
go-api      | [GIN-debug] GET    /metrics                  --> main.PrometheusHandler.func1 (3 handlers)
go-api      | [GIN-debug] GET    /health                   --> main.main.func1 (4 handlers)
go-api      | [GIN-debug] GET    /v1/users                 --> main.main.func2 (4 handlers)
go-api      | [GIN-debug] [WARNING] You trusted all proxies, this is NOT safe. We recommend you to set a value.
go-api      | Please check https://pkg.go.dev/github.com/gin-gonic/gin#readme-don-t-trust-all-proxies for details.
go-api      | [GIN-debug] Listening and serving HTTP on :8000
prometheus  | ts=2025-03-15T05:57:06.676Z caller=main.go:627 level=info msg="No time or size retention was set so using the default time retention" duration=15d
prometheus  | ts=2025-03-15T05:57:06.678Z caller=main.go:671 level=info msg="Starting Prometheus Server" mode=server version="(version=2.55.0, branch=HEAD, revision=91d80252c3e528728b0f88d254dd720f6be07cb8)"
grafana     | logger=settings t=2025-03-15T05:57:06.865335506Z level=info msg="Config overridden from command line" arg="default.log.mode=console"
grafana     | logger=settings t=2025-03-15T05:57:06.865337131Z level=info msg="Config overridden from Environment variable" var="GF_PATHS_DATA=/var/lib/grafana"
grafana     | logger=ngalert.state.manager t=2025-03-15T05:57:07.088956839Z level=info msg="State
.
.
grafana     | logger=plugin.angulardetectorsprovider.dynamic t=2025-03-15T05:57:07.530317298Z level=info msg="Patterns update finished" duration=440.489125ms
```

Los servicios comenzarán a ejecutarse y podrás acceder a la aplicación Golang en `http://localhost:8000`, a Prometheus en `http://localhost:9090/health` y a Grafana en `http://localhost:3000`. 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 conectar servicios entre sí mediante Docker Compose. Creaste un archivo Docker Compose para ejecutar múltiples servicios juntos y conectarlos usando redes. También aprendiste a construir y ejecutar los servicios con Docker Compose.

Información relacionada:

- [Descripción general de Docker Compose](/compose/)
- [Referencia del archivo Compose](/reference/compose-file/)

A continuación, aprenderás a desarrollar la aplicación Golang con Docker Compose y a monitorizarla con Prometheus y Grafana.

## Próximos pasos

En la siguiente sección, aprenderás a desarrollar la aplicación Golang con Docker. También aprenderás a usar Docker Compose Watch para reconstruir la imagen cada vez que realices cambios en el código. Por último, probarás la aplicación y visualizarás las métricas en Grafana utilizando Prometheus como fuente de datos.