# 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).

```console
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:

```yaml {hl_lines="17-20",linenos=true}
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:

```console
$ 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:

```bash
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`.

![Pantalla de configuraciones opcionales con las opciones especificadas.](/guides/images/grafana-dash.png)

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](https://grafana.com/docs/grafana/latest/) 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.

![Pantalla de configuraciones opcionales con las opciones especificadas.](/guides/images/grafana-panel.png)

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.