Dans le développement logiciel moderne, l’automatisation efficace de la compilation est cruciale pour le succès d’un projet. Makefiles, un outil populaire d’automatisation de la compilation, fournit aux développeurs de toutes les piles un moyen concis et puissant de gérer des processus de compilation complexes.
En intégrant et en interopérant Makefiles avec Go, vous pouvez automatiser les tâches répétitives, rationaliser les processus de construction et améliorer la productivité.
Comprendre les Makefiles
Comprendre le fonctionnement des Makefiles est essentiel pour organiser et automatiser efficacement la construction de vos projets.
Les Makefiles suivent une structure et une syntaxe spécifiques pour définir les règles de construction et de maintenance des projets. A la base, un Makefile consiste en des règles spécifiant des cibles, des dépendances et des commandes. Chaque règle commence par une cible, suivie de ses dépendances et des commandes nécessaires pour construire ou exécuter la cible.
Les cibles représentent les fichiers de sortie ou les actions souhaitées pour le Makefile. Les cibles peuvent être des noms de fichiers ou des étiquettes qui décrivent la tâche. Par exemple, une cible nommée nettoie peut supprimer les fichiers inutiles générés pendant le processus de construction.
Les dépendances sont des fichiers ou des tâches nécessaires à la construction d’une cible. Si une dépendance est modifiée, le Makefile reconstruira les cibles associées pour s’assurer que les parties nécessaires du projet fonctionnent. Vous spécifierez les dépendances après la cible, séparées par des espaces.
Les commandes sont des actions ou des commandes shell qui doivent être exécutées pour construire ou réaliser des cibles spécifiques. Les commandes sont généralement écrites dans un langage de script shell du système d’exploitation.
Chaque commande doit commencer par une tabulation pour être reconnue.
build: main.go utils.go
go build -o myapp main.go utils.go
clean:
rm myapp
Dans le Makefile ci-dessus, il y a deux cibles : construire et propre.
Les construire la cible dépend de l’option main.go et utils.go et la commande associée s’exécute sur le compilateur Go pour construire un exécutable nommé monapp.
D’autre part, le propre la cible supprime le myapp exécutable.
Pour compiler votre code Go, accédez au répertoire de travail et exécutez la commande make build commande.
make build
L’outil Make se chargera de la compilation, ce qui vous permettra de vous concentrer sur l’écriture du code.
Configurer les Makefiles pour vos projets Go
Vous pouvez utiliser Makefiles pour construire et compiler vos programmes, effectuer des tests de code et des contrôles de qualité, ainsi que pour l’intégration et le déploiement continus.
Exécutez cette commande pour créer un Makefile pour votre projet dans le répertoire racine. Le fichier Makefile servira de point d’entrée pour définir vos tâches de construction.
touch Makefile
Votre Makefile ne devrait pas avoir d’extensions.
Après avoir créé le Makefile, vous pouvez écrire des commandes, des dépendances et des cibles dans le fichier pour les opérations de votre projet.
Voici un exemple de Makefile qui sert d’outil d’automatisation de la construction pour votre projet :
# Makefile
# Variables
GOCMD=go
GOBUILD=$(GOCMD) build
GOTEST=$(GOCMD) test
GOCLEAN=$(GOCMD) clean
# Targets
build:
$(GOBUILD) -o app .
test:
$(GOTEST) ./...
clean:
$(GOCLEAN)
rm -f app
Vous pouvez personnaliser votre Makefile en fonction des besoins spécifiques de votre projet.
Voici une version modifiée du Makefile pour passer des drapeaux et des variables d’environnement supplémentaires pendant le processus de test ou de construction de votre projet :
# Makefile
# Variables
GOCMD=go
GOBUILD=$(GOCMD) build
GOTEST=$(GOCMD) test
GOCLEAN=$(GOCMD) clean
BINARY_NAME=app
TEST_FLAGS=-v
# Targets
build:
$(GOBUILD) -o $(BINARY_NAME) .
test:
$(GOTEST) $(TEST_FLAGS) ./...
clean:
$(GOCLEAN)
rm -f $(BINARY_NAME)
Dans ce Makefile, il y a deux nouvelles variables nommées NOM_BINAIRE et TEST_FLAGS. Les NOM_BINAIRE spécifie le nom du fichier exécutable généré.
La variable TEST_FLAGS permet de spécifier des drapeaux supplémentaires lors de l’exécution des tests (dans ce cas, la variable -v permet d’activer la sortie verbeuse pendant l’exécution du test).
Makefiles fournit également un moyen facile de configurer les variables d’environnement et les drapeaux pour votre projet.
Vous pouvez ajouter ces lignes à votre Makefile si vous avez besoin de définir la variable d’environnement GOOS et GOARCH variables pour construire votre projet pour un système d’exploitation ou une architecture spécifique.
# Makefile
# Variables
GOCMD=go
GOBUILD=$(GOCMD) build
GOTEST=$(GOCMD) test
GOCLEAN=$(GOCMD) clean
BINARY_NAME=app
TEST_FLAGS=-v
GOOS=linux
GOARCH=amd64
# Targets
build:
$(GOBUILD) -o $(BINARY_NAME) .
test:
$(GOTEST) $(TEST_FLAGS) ./...
clean:
$(GOCLEAN)
rm -f $(BINARY_NAME)
Dans le Makefile mis à jour, il y a deux nouvelles variables pour l’option GOOS et GOARCH variables d’environnement qui vous permettent de spécifier le système d’exploitation et l’architecture cibles pour votre compilation (dans ce cas, la variable d’environnement GOOS la variable est fixée à linux et GOARCH à amd64 pour construire le projet pour Linux sur l’architecture x86-64).
N’oubliez pas d’adapter ces variables en fonction des besoins spécifiques de votre projet.
Vous pouvez vous référer à la documentation Go pour la liste des valeurs supportées pour les variables GOOS et GOARCH si vous avez besoin de construire pour une plateforme différente.
Automatisation de la construction avec Makefiles
Les Makefiles sont également pratiques pour compiler du code, générer de la documentation et gérer les dépendances.
Avec Makefiles, vous pouvez automatiser la compilation, ce qui vous permet d’économiser du temps et des efforts.
Voici un Makefile qui compile un programme Go :
# Define variables
GOCMD = go
GOBUILD = $(GOCMD) build
BINARY_NAME = myprogram
# Default target
all: build
# Build target
build:
$(GOBUILD) -o $(BINARY_NAME)
# Clean target
clean:
rm -f $(BINARY_NAME)
Le Makefile définit des variables comme le GOCMD (la commande Go) et GOBUILD (la commande de construction). La commande build la cible invoque la fonction go build pour compiler notre programme Go et produire le binaire avec le nom spécifié (monprogramme dans ce cas). Le programme propre target supprime le binaire généré du projet.
Vous pouvez utiliser les Makefiles pour automatiser l’installation des dépendances et maintenir à jour les dépendances externes de votre projet.
# Define variables
GOCMD = go
GOBUILD = $(GOCMD) build
GOGET = $(GOCMD) get
BINARY_NAME = myprogram
# Default target
all: build
# Build target
build:
$(GOBUILD) -o $(BINARY_NAME)
# Install dependencies
deps:
$(GOGET) -u
# Clean target
clean:
rm -f $(BINARY_NAME)
Le Makefile a un deps cible qui utilise l’option aller chercher pour installer ou mettre à jour les dépendances du projet. Vous pouvez exécuter la commande make deps pour installer les dépendances de votre projet.
Les Makefiles peuvent automatiser la génération de la documentation et améliorer votre processus docs as code.
Voici comment vous pouvez générer automatiquement de la documentation pour vos projets Go avec l’outil godoc et Makefile :
# Define variables
GODOC = godoc
DOCS_DIR = docs
# Default target
all: docs
# Generate documentation
docs:
$(GODOC) -html -dir . > $(DOCS_DIR)/index.html
# Clean target
clean:
rm -rf $(DOCS_DIR)
Dans le Makefile, l’option docs La cible invoque la fonction godoc avec la commande -html pour générer de la documentation HTML pour votre code go et enregistre la documentation dans le répertoire docs répertoire.
Vous exécuterez le programme docs make pour générer une documentation à jour pour votre projet Go.
Les Makefiles sont pratiques pour travailler avec les systèmes d’exploitation basés sur Unix
En tirant parti de la flexibilité des Makefiles, vous pouvez définir des commandes de compilation personnalisées et exécuter des tâches complexes en quelques minutes. Makefile permet de gagner du temps et d’assurer la cohérence et la reproductibilité des environnements de construction.
Un autre avantage de Makefiles est sa compatibilité avec les systèmes basés sur Unix. Make est un utilitaire largement supporté par les systèmes d’exploitation basés sur Unix, y compris Linux et macOS, ce qui en fait un outil portable et fiable pour les développeurs.
