Développer votre application

Dans la dernière section, vous avez vu comment utiliser Docker Compose pour connecter vos services ensemble. Dans cette section, vous apprendrez comment développer l'application Golang avec Docker. Vous verrez également comment utiliser Docker Compose Watch pour reconstruire l'image chaque fois que vous apportez des modifications au code. Enfin, vous testerez l'application et visualiserez les métriques dans Grafana en utilisant Prometheus comme source de données.

Développer l'application

Maintenant, si vous apportez des modifications à votre application Golang localement, elles doivent être reflétées dans le conteneur, n'est-ce pas ? Pour ce faire, une approche consiste à utiliser l'indicateur --build dans Docker Compose après avoir apporté des modifications au code. Cela reconstruira tous les services qui ont l'instruction build dans le fichier compose.yml, dans votre cas, le service api (application Golang).

docker compose up --build

Mais ce n'est pas la meilleure approche. Ce n'est pas efficace. Chaque fois que vous apportez une modification au code, vous devez reconstruire manuellement. Ce n'est pas un bon flux de travail pour le développement.

La meilleure approche consiste à utiliser Docker Compose Watch. Dans le fichier compose.yml, sous le service api, vous avez ajouté la section develop. C'est donc plus comme un rechargement à chaud. Chaque fois que vous apportez des modifications au code (défini dans path), il reconstruira l'image (ou redémarrera en fonction de l'action). Voici comment vous pouvez l'utiliser :

 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

Une fois que vous avez ajouté la section develop dans le fichier compose.yml, vous pouvez utiliser la commande suivante pour démarrer le serveur de développement :

$ docker compose watch

Maintenant, si vous modifiez votre main.go ou tout autre fichier du projet, le service api sera reconstruit automatiquement. Vous verrez la sortie suivante dans le 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

Tester l'application

Maintenant que votre application est en cours d'exécution, rendez-vous sur le tableau de bord Grafana pour visualiser les métriques que vous enregistrez. Ouvrez votre navigateur et accédez à http://localhost:3000. Vous serez accueilli par la page de connexion de Grafana. Les informations de connexion sont celles fournies dans le fichier Compose.

Une fois connecté, vous pouvez créer un nouveau tableau de bord. Lors de la création du tableau de bord, vous remarquerez que la source de données par défaut est Prometheus. C'est parce que vous avez déjà configuré la source de données dans le fichier grafana.yml.

Vous pouvez utiliser différents panneaux pour visualiser les métriques. Ce guide n'entre pas dans les détails de Grafana. Vous pouvez vous référer à la documentation de Grafana pour plus d'informations. Il existe un panneau de jauge à barres pour visualiser le nombre total de requêtes provenant de différents points de terminaison. Vous avez utilisé les métriques api_http_request_total et api_http_request_error_total pour obtenir les données.

Vous avez créé ce panneau pour visualiser le nombre total de requêtes provenant de différents points de terminaison afin de comparer les requêtes réussies et échouées. Pour toutes les bonnes requêtes, la barre sera verte, et pour toutes les requêtes échouées, la barre sera rouge. De plus, il montrera également de quel point de terminaison provient la requête, qu'il s'agisse d'une requête réussie ou d'une requête échouée. Si vous souhaitez utiliser ce panneau, vous pouvez importer le fichier dashboard.json à partir du référentiel que vous avez cloné.

Résumé

Vous êtes arrivé à la fin de ce guide. Vous avez appris à développer l'application Golang avec Docker. Vous avez également vu comment utiliser Docker Compose Watch pour reconstruire l'image chaque fois que vous apportez des modifications au code. Enfin, vous avez testé l'application et visualisé les métriques dans Grafana en utilisant Prometheus comme source de données.