Desarrollo de tu aplicación

En la última sección, viste cómo puedes conectar tus servicios mediante Docker Compose. En esta sección, aprenderás cómo desarrollar la aplicación Golang con Docker. También verás cómo 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.

Desarrollando la aplicación

Ahora bien, si realizas algún cambio local en tu aplicación Golang, este debe verse reflejado en el contenedor, ¿verdad? Para lograrlo, un enfoque consiste en usar la opción --build en Docker Compose después de hacer cambios en el código. Esto reconstruirá todos los servicios que tengan la instrucción build en el archivo compose.yml; en tu caso, el servicio api (la aplicación Golang).

docker compose up --build

Sin embargo, este no es el mejor enfoque ni el más eficiente. Cada vez que realizas un cambio en el código, debes reconstruir manualmente. Este no es un buen flujo para el desarrollo.

El mejor enfoque es usar Docker Compose Watch. En el archivo compose.yml, bajo el servicio api, has agregado la sección develop. Esto funciona de forma similar a una recarga en caliente (hot reloading). Cada vez que realizas cambios en el código (definido en path), se reconstruirá la imagen (o se reiniciará el contenedor según la acción). Así es como puedes usarlo:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

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:8080/health"]
      interval: 30s
      timeout: 10s
      retries: 5
    develop:
      watch:
        - path: .
          action: rebuild

Una vez que hayas agregado la sección develop en el archivo compose.yml, puedes usar el siguiente comando para iniciar el servidor de desarrollo:

$ docker compose watch

Ahora, si modificas tu archivo main.go o cualquier otro archivo en el proyecto, el servicio api se reconstruirá automáticamente. Verás la siguiente salida en la terminal:

Rebuilding service(s) ["api"] after changes were detected...
[+] Building 8.1s (15/15) FINISHED                                                                                                        docker:desktop-linux
 => [api internal] load build definition from Dockerfile                                                                                                  0.0s
 => => transferring dockerfile: 704B                                                                                                                      0.0s
 => [api internal] load metadata for docker.io/library/alpine:3.17                                                                                        1.1s
  .
 => => exporting manifest list sha256:89ebc86fd51e27c1da440dc20858ff55fe42211a1930c2d51bbdce09f430c7f1                                                    0.0s
 => => naming to docker.io/library/go-api:latest                                                                                                          0.0s
 => => unpacking to docker.io/library/go-api:latest                                                                                                       0.0s
 => [api] resolving provenance for metadata file                                                                                                          0.0s
service(s) ["api"] successfully built

Probando la aplicación

Ahora que tienes tu aplicación en ejecución, dirígete al tablero de Grafana para visualizar las métricas que estás registrando. Abre tu navegador y navega a http://localhost:3000. Te recibirá la página de inicio de sesión de Grafana. Las credenciales de acceso son las que proporcionaste en el archivo Compose.

Una vez que hayas iniciado sesión, puedes crear un nuevo tablero. Al crear el tablero, notarás que la fuente de datos predeterminada es Prometheus. Esto se debe a que ya configuraste la fuente de datos en el archivo grafana.yml.

Puedes usar diferentes paneles para visualizar las métricas. Esta guía no profundiza en los detalles de Grafana. Puedes consultar la documentación de Grafana para obtener más información. Hay un panel de tipo Bar Gauge para visualizar el número total de solicitudes desde diferentes endpoints. Utilizaste las métricas api_http_request_total y api_http_request_error_total para obtener los datos.

Creaste este panel para visualizar el número total de solicitudes desde diferentes endpoints con el fin de comparar las solicitudes exitosas y fallidas. Para todas las solicitudes correctas, la barra será verde y para las solicitudes fallidas, la barra será roja. Además, mostrará desde qué endpoint proviene la solicitud y si fue exitosa o fallida. Si quieres usar este panel, puedes importar el archivo dashboard.json desde el repositorio que clonaste.

Resumen

Has llegado al final de esta guía. Aprendiste cómo desarrollar la aplicación Golang con Docker. También viste cómo usar Docker Compose Watch para reconstruir la imagen cada vez que realices cambios en el código. Por último, probaste la aplicación y visualizaste las métricas en Grafana utilizando Prometheus como fuente de datos.