Chapitre 1: Introduction au rechargement en direct

Qu'est-ce que le rechargement en direct ?

Le rechargement en direct est une fonctionnalité qui permet à votre environnement de développement de surveiller les modifications apportées à votre code et de recharger automatiquement votre application. Lorsque vous enregistrez un fichier, l'outil de rechargement en direct détecte la modification, reconstruit l'application et la redémarre. Cela vous évite le processus manuel d'arrêt du serveur, de reconstruction de l'application et de redémarrage après chaque modification.

Avantages du rechargement en direct pour le développement en Go

Le rechargement en direct peut accélérer considérablement le processus de développement. Pour les développeurs Go, habitués à compiler leur code avant de l'exécuter, le rechargement en direct signifie un flux de travail amélioré avec un retour immédiat. Les avantages incluent :

  1. Productivité accrue : Les développeurs peuvent rester concentrés sans interruption, car ils n'ont pas besoin d'effectuer de reconstructions manuelles.
  2. Économie de temps : Le rechargement en direct réduit le délai de turnaround pour voir les modifications apportées au code reflétées dans l'application en cours d'exécution.
  3. Détection d'erreurs : Les reconstructions et redémarrages instantanés permettent aux développeurs de détecter et de corriger les erreurs plus rapidement.
  4. Flux de travail rationalisé : S'intègre de manière transparente dans le processus de développement, le rendant plus fluide et efficace.

Chapitre 2: Qu'est-ce que Air?

Air est un utilitaire en ligne de commande conçu pour offrir des capacités de rechargement en direct pour les applications Go. Il surveille les modifications apportées à votre code source et reconstruit et redémarre automatiquement votre application Go. Cela vous permet de vous concentrer davantage sur le développement de fonctionnalités et moins sur les tâches répétitives.

Fonctionnalités

Air offre toute une gamme de fonctionnalités adaptées à un environnement de développement Go moderne :

  • Reconstructions automatiques : Détecte les modifications de fichiers et déclenche des reconstructions.
  • Commandes de construction personnalisables : Vous permet de personnaliser les commandes de construction en fonction des besoins de votre projet.
  • Exclusions de répertoires : Vous permet de spécifier les répertoires à exclure de la surveillance.
  • Prise en charge des nouveaux répertoires : Peut surveiller les nouveaux répertoires ajoutés après le démarrage d'Air.
  • Journaux colorés et lisibles : Améliore la lisibilité des journaux de sortie avec un codage couleur.
  • Arguments de l'interface en ligne de commande : Les champs de configuration peuvent être définis directement via des arguments de ligne de commande pour des ajustements rapides.

Consultez le contexte fourni par le développeur pour une liste complète des fonctionnalités et des fonctionnalités disponibles avec Air.

Chapitre 3: Installation de air

3.1 Installation via go install

Pour installer Air à l'aide de l'outillage Go version 1.18 ou ultérieure :

go install github.com/cosmtrek/air@latest

Cela rendra air disponible dans votre GOPATH/bin.

3.2 Utilisation du script install.sh

Une autre méthode consiste à utiliser un script d'installation fourni :

curl -sSfL https://raw.githubusercontent.com/cosmtrek/air/master/install.sh | sh -s -- -b $(go env GOPATH)/bin

Après l'installation, vérifiez en exécutant :

air -v

3.3 Installations spéciales (Docker/Podman et chemin personnalisé)

Pour ceux qui utilisent Docker ou Podman, il existe un moyen simplifié d'inclure Air :

docker run -it --rm \
    -w "/chemin/vers/projet" \
    -v $(pwd):/chemin/vers/projet \
    -p port:port \
    cosmtrek/air

Remplacez /chemin/vers/projet par le chemin de votre projet et port:port par le mappage de port souhaité.

Alternativement, pour une installation dans un chemin spécifique :

curl -sSfL https://goblin.run/github.com/cosmtrek/air | PREFIX=/chemin/personnalisé sh

Chapitre 4: Configuration de air pour votre projet Go

4.1 Compréhension de la configuration .air.toml

.air.toml est le fichier de configuration pour Air. Il vous permet de spécifier des paramètres relatifs au processus de construction, à la surveillance des répertoires et à la sortie de journal. Voici un bref aperçu des sections clés :

  • root : Définit le répertoire de travail pour Air.
  • build : Contient les paramètres liés à la construction tels que les commandes à exécuter avant/après la construction et la commande de construction principale.
  • tmp_dir : Le répertoire où les fichiers de construction temporaires sont stockés.
  • log : Configure les paramètres du fichier journal.
  • color : Personnalise la couleur de chaque partie de la sortie du journal.

4.2 Génération et Modification du Fichier de Configuration

Pour générer un fichier de configuration .air.toml par défaut, exécutez la commande suivante :

air init

Cela créera un fichier .air.toml avec les paramètres par défaut dans votre répertoire actuel. Vous pourrez ensuite le modifier pour qu'il convienne aux besoins de votre projet. Pour référence, vous pouvez consulter le fichier air_example.toml fourni dans le contexte.

4.3 Écrasement de la configuration avec des arguments de CLI

Pour des tests rapides ou des modifications mineures, vous pouvez remplacer la configuration dans .air.toml en passant des arguments de CLI. Par exemple :

air --build.cmd "go build -o myapp" --build.bin "./myapp"

Cette flexibilité vous permet de personnaliser facilement le comportement de Air sans modifier le fichier de configuration.

Chapitre 5 : Exécution de air dans Votre Environnement de Développement

6.1 Démarrage de air dans Votre Projet

Pour commencer avec air dans votre projet, accédez au répertoire racine de votre projet dans votre terminal et exécutez la commande air. Si un fichier de configuration .air.toml est présent, air l'utilisera automatiquement. Sinon, il utilisera les paramètres par défaut.

cd /chemin/vers/votre_projet
air

Astuce : Si vous rencontrez des problèmes de permission avec l'exécutable air, assurez-vous qu'il possède les permissions d'exécution nécessaires (chmod +x $(go env GOPATH)/bin/air).

6.2 Personnalisation des Commandes de Construction et d'Exécution avec air

Vous pouvez personnaliser les commandes de construction et d'exécution utilisées par air en modifiant le fichier .air.toml, notamment dans la section [build]. Par exemple, pour changer la commande de construction et spécifier un fichier binaire différent :

[build]
cmd = "go build -o ./tmp/my-custom-binary ."
bin = "tmp/my-custom-binary"

Pour des exigences de construction plus complexes, les tableaux pre_cmd et post_cmd dans le fichier de configuration vous permettent d'exécuter des commandes avant et après le processus de construction, respectivement.

Astuces : Un exemple complet de configuration de air

6.3 Exclusion de Répertoires et Surveillance des Modifications

air vous permet également d'exclure des répertoires de la surveillance des modifications, ce qui peut être utile pour les répertoires contenant des ressources ou des dépendances qui ne nécessitent pas de déclencher une nouvelle construction.

Pour configurer cela, mettez à jour le champ exclude_dir dans .air.toml :

[build]
exclude_dir = ["assets", "tmp", "vendor", "node_modules"]

Vous pouvez également indiquer à air d'inclure des répertoires supplémentaires à l'aide de include_dir, ou de surveiller des extensions de fichier spécifiques à l'aide de include_ext.

Chapitre 6 : Utilisation Avancée

6.1 Configuration de air avec des Conteneurs Docker

L'utilisation de air dans un conteneur Docker peut rationaliser votre configuration de développement, surtout en travaillant en équipe. Pour inclure air dans votre environnement Docker, mettez à jour votre Dockerfile pour installer air et copier votre fichier .air.toml dans le conteneur :

FROM golang:1.18-alpine AS builder

RUN go install github.com/cosmtrek/air@latest

WORKDIR /app

COPY go.mod .
COPY go.sum .
RUN go mod download

COPY . .

CMD ["air", "-c", ".air.toml"]

6.3 Utilisation de air dans un Environnement Docker-compose

Pour intégrer air dans un service géré par docker-compose, définissez un service dans votre fichier docker-compose.yaml :

version: '3.8'
services:
  app:
    build: .
    ports:
      - "808:808"
    volumes:
      - .:/app
    command: ["air", "-c", ".air.toml"]

Assurez-vous que la directive volumes mappe correctement le répertoire de votre projet vers le répertoire de travail dans le conteneur afin que air puisse détecter les modifications de fichier.

Chapitre 7 : Dépannage Courant et FAQ

7.1 Résolution de l'erreur command not found: air

Si vous rencontrez une erreur command not found: air, cela signifie généralement que le binaire air n'est pas dans le PATH de votre système. Pour résoudre cela, ajoutez le chemin des binaires Go à votre variable d'environnement PATH :

export PATH=$PATH:$(go env GOPATH)/bin

7.2 Problèmes dans les environnements WSL

Dans un environnement Windows Subsystem for Linux (WSL), assurez-vous d'échapper les caractères spéciaux dans votre fichier .air.toml. Par exemple, utilisez \\ pour échapper les barres obliques dans les chemins de fichier.

7.3 Conseils sur la compilation à chaud sans exécuter le binaire

Si vous souhaitez que air compile votre application Go sans l'exécuter, définissez la commande cmd dans la section [build] de votre fichier .air.toml sur une commande sans opération (comme /bin/true sur les systèmes de type Unix) :

[build]
cmd = "/bin/true"

En faisant cela, air observera toujours les modifications de fichiers et déclenchera le processus de compilation, mais il ne tentera pas d'exécuter le fichier binaire résultant.