Introduction à la gestion des dépendances en Go
La gestion des dépendances est un aspect essentiel de tout projet logiciel, car elle permet de gérer les versions des bibliothèques et des paquets sur lesquels votre projet s'appuie. En Go (Golang), la gestion des dépendances garantit la reproductibilité et la maintenance de vos projets Go en facilitant la résolution des problèmes de version, en maintenant la compatibilité avec d'autres paquets et en rationalisant le processus de développement global.
Avant Go Modules, la gestion des dépendances en Go était moins rationalisée. Les développeurs avaient souvent recours à des outils tels que dep, glide ou govendor pour gérer leurs dépendances. Bien que ces outils soient utiles, ils ne faisaient pas partie du projet Go officiel et, par conséquent, créaient des frictions dans l'adoption de Go comme langage pour certains développeurs.
L'ère des modules Go
En 2018, l'équipe Go a introduit le concept de "modules", une nouvelle norme pour la gestion des dépendances dans les projets Go. Les modules sont des collections de paquets liés qui sont versionnés ensemble, fournissant toutes les dépendances nécessaires à votre base de code. Avec l'introduction des modules Go dans Go 1.11, la gestion des dépendances est devenue plus simple, plus polyvalente et officiellement soutenue par le projet Go. Les modules Go ont introduit des fonctionnalités telles que
- Versionnement des dépendances à l'aide du Semantic Versioning (SemVer)
- Des commandes de gestion des dépendances simplifiées (par exemple,
go get,go mod tidy) - la génération automatique d'un fichier manifeste
(go.mod) contenant des informations détaillées sur les dépendances - Téléchargement automatique et mise en cache des dépendances requises
Avec les modules Go, vous n'êtes plus obligé de placer votre code dans le répertoire $GOPATH, ce qui était auparavant une contrainte dans le développement Go. Ce nouveau système permet une structure de projet plus flexible, facilitant le travail sur les projets Go lorsque l'on passe d'un dépôt à l'autre.
Configuration de votre projet de module Go
Les premiers pas avec les modules Go sont simples. Suivez les étapes ci-dessous pour configurer un nouveau projet Go Modules.
- Tout d'abord, assurez-vous d'avoir installé la version 1.11 ou ultérieure de Go sur votre système. Vous pouvez vérifier votre version de Go en lançant
go versiondans le terminal. - Allez à l'endroit de votre choix et créez un nouveau dossier de projet avec un nom descriptif, par exemple,
my-go-project. - Naviguez vers le dossier nouvellement créé dans la ligne de commande.
- Initialisez un nouveau module Go en exécutant la commande
go mod init, suivie du chemin du module. Par exemple, vous pouvez exécutergo mod init github.com/votre-nom-d'utilisateur/mon-projetgosi vous avez l'intention d'héberger le projet sur GitHub. Cette commande génère un nouveau fichier nommégo.moddans le dossier de votre projet.
Le fichier go.mod est le cœur de votre projet Go Modules. Il contient des métadonnées sur le module, comme son nom, et liste toutes les dépendances dont il a besoin. Vous interagirez avec le fichier go.mod tout au long du cycle de vie de votre projet Go pour gérer vos dépendances. Maintenant que votre projet de module Go est configuré, vous êtes prêt à ajouter et à gérer des dépendances à l'aide du système de modules Go.
Gestion des dépendances dans les modules Go
Les modules Go fournissent une approche simple et efficace pour gérer les dépendances de votre projet. Ils vous permettent d'ajouter, de mettre à jour ou de supprimer des versions de dépendances spécifiques, vous aidant ainsi à garder le contrôle de votre projet et de ses interactions avec d'autres paquets. Cette section vous guidera dans le processus de gestion des dépendances au sein de votre projet Go Modules.
Ajouter une dépendance
Pour ajouter une nouvelle dépendance, il vous suffit d'importer le paquetage souhaité dans votre code Go. Par exemple, si vous voulez ajouter github.com/gorilla/mux à votre projet, importez-le comme ceci :
import ("github.com/gorilla/mux" )La prochaine fois que vous lancerez go build ou go test, Go téléchargera automatiquement le paquetage requis, mettra à jour les fichiers go.mod et go.sum, et configurera votre projet pour qu'il utilise le paquetage spécifié. Vous pouvez également utiliser la commande go get pour ajouter explicitement une nouvelle dépendance :
go get github.com/gorilla/mux
Cela permettra non seulement de récupérer le paquet, mais aussi de mettre à jour les fichiers go.mod et go.sum de votre projet.
Mise à jour d'une dépendance
Pour mettre à jour une dépendance spécifique vers une nouvelle version, utilisez la commande go get suivie du chemin d'importation du paquet et du numéro de version souhaité :
go get github.com/gorilla/[email protected]
Cette commande mettra à jour le fichier go.mod avec la nouvelle version du paquetage et téléchargera son code source. Notez que si le paquet mis à jour introduit des changements importants, vous devrez peut-être ajuster votre code en conséquence.
Suppression d'une dépendance
Pour supprimer une dépendance de votre projet, commencez par supprimer les instructions d'importation correspondantes de votre code source. Ensuite, lancez la commande go mod tidy pour nettoyer le fichier go.mod :
go mod tidy
Cette commande supprimera toutes les dépendances inutilisées du fichier go.mod et veillera à ce que votre projet reste propre et organisé.
Versionnement sémantique et modules Go
Le Semantic Versioning (SemVer) est un système de versionnement largement adopté qui attribue des numéros de version uniques aux versions de logiciels. Il utilise un format de numérotation en trois parties : Major.Minor.Patch (par exemple, 1.2.3). Dans SemVer :
- Les changements de version majeurs indiquent des ruptures et nécessitent des ajustements manuels du code.
- Les changements de version mineurs introduisent de nouvelles fonctionnalités tout en restant compatibles avec les versions antérieures.
- Les changements de version correctifs comprennent des corrections de bogues et des améliorations mineures des performances, également rétrocompatibles.
Go Modules intègre le Semantic Versioning pour gérer les versions des dépendances, ce qui permet aux développeurs de gérer plus facilement les mises à jour, la rétrocompatibilité et les ruptures. Lorsque vous spécifiez les versions des dépendances avec Go Modules, vous pouvez utiliser des plages de versions ou des numéros de versions spécifiques. Par exemple : - Pour récupérer la dernière version stable d'un paquetage, utilisez le chemin d'importation du paquetage sans numéro de version : go get github.com/gorilla/mux. - Pour récupérer une version spécifique, ajoutez le numéro de version après le symbole @: go get github.com/gorilla/[email protected].- Pour récupérer la dernière mise à jour mineure ou corrective d'une version majeure spécifique, utilisez le symbole ^ (caret) : go get github.com/gorilla/mux@^v1.0.0.
Commandes courantes des modules Go et leur utilisation
Voici quelques unes des commandes les plus utilisées de Go Modules et leurs scénarios d'utilisation :
go mod init
go mod init initialise un nouveau projet Go Modules dans le répertoire courant. Il génère un fichier go.mod, qui contient des informations sur le module, ses dépendances et les contraintes de version.
go mod init exemple.com/myprojet
Remplacez example.com/myproject par le chemin de votre module.
go get
go get est une commande polyvalente utilisée pour ajouter, mettre à jour ou supprimer une dépendance. Fournissez le chemin d'importation du paquetage, éventuellement suivi d'un numéro de version ou d'un intervalle.
go get github.com/gorilla/[email protected]
Cette commande ajoute ou met à jour le paquet github.com/gorilla/mux à la version v1.8.0.
go mod tidy
go mod tidy supprime les dépendances inutilisées du fichier go.mod et le met à jour pour refléter les déclarations d'importation dans le code source de votre projet.
go mod tidy
Exécutez cette commande après avoir supprimé les déclarations d'importation des dépendances non désirées.
go mod graph
go mod graph affiche l'arbre des dépendances du projet, en montrant les dépendances directes et indirectes dans un format lisible. Cette commande peut être utile lors du débogage de problèmes de dépendances complexes.
go mod graph
go mod verify
go mod verify vérifie l'intégrité des dépendances listées dans le fichier go.sum. Si la somme de contrôle d'une dépendance ne correspond pas à la valeur enregistrée, la commande signale une erreur.
go mod verify
Résoudre les conflits de dépendances
Les conflits de dépendances peuvent survenir lorsque votre projet dépend de plusieurs paquets avec des exigences de versions différentes pour les dépendances partagées. Les modules Go fournissent un mécanisme intégré pour gérer ces conflits en utilisant les directives replace et exclude dans le fichier go.mod.
La directive replace
La directive replace vous permet de changer la version d'un module ou de la faire correspondre à un chemin local. Cela peut être utile dans les situations où vous avez besoin de tester des versions spécifiques, des projets forkés, ou des changements locaux avant de s'engager dans un dépôt distant. Pour utiliser la directive replace, ajoutez la ligne suivante à votre fichier go.mod:
replace example.com/original/module v1.2.3 => example.com/new/module v1.4.0
Cela remplace exemple. com/original/module version v1.2.3 par exemple.com/nouveau/module version v1.4.0. Vous pouvez également remplacer un module par un chemin local :
replace example.com/original/module v1.2.3 => ../local/path/to/new/module
La directive Exclude
Vous pouvez utiliser la directive exclude pour empêcher que des versions spécifiques d'un module soient utilisées dans votre projet. Cette directive est utile lorsque vous savez qu'une version particulière présente des problèmes de compatibilité ou des failles de sécurité. Pour exclure une version de module, ajoutez la ligne suivante à votre fichier go.mod:
exclude example.com/target/module v1.2.3
N'oubliez pas de lancer go mod tidy après avoir appliqué ces changements pour mettre à jour le fichier go.sum et recalculer l'arbre des dépendances.
Modules Go privés et gestion des référentiels
Travailler avec des modules et des dépôts Go privés est similaire à travailler avec des modules et des dépôts publics, mais il y a quelques étapes supplémentaires pour assurer une authentification et une confidentialité correctes.
Configuration de GOPRIVATE
Pour empêcher la fuite des chemins d'importation vers des serveurs publics, configurez la variable d'environnement GOPRIVATE. Cette variable spécifie une liste de chemins d'importation séparés par des virgules pour les dépôts privés.
go env -w GOPRIVATE=exemple.com/private/path/*
Utilisation de jetons d'accès
Pour utiliser des dépôts privés, vous devez généralement vous authentifier auprès de votre service d'hébergement de code source, tel que GitHub ou GitLab. Créez un jeton d'accès personnel avec les permissions appropriées (telles que l'étendue du repo pour GitHub). Reportez-vous à la documentation de votre service d'hébergement pour connaître les étapes spécifiques à la création d'un jeton d'accès. Après avoir obtenu le jeton d'accès, configurez la variable d'environnement pour l'authentification. Utilisez la variable d'environnement appropriée en fonction de votre service VCS.
export GIT_TERMINAL_PROMPT=0 export GITHUB_TOKEN=Votre_jeton_d'accès
Cela permet à la commande go de télécharger et d'authentifier des dépôts privés en tant que modules Go. Si vous travaillez avec plusieurs services VCS, vous pouvez configurer des jetons d'accès individuels pour chacun d'entre eux en définissant des variables d'environnement distinctes.
Migration à partir des systèmes de gestion des dépendances précédents
Avant Go Modules, il existait différents systèmes de gestion des dépendances tels que Dep, glide, ou des solutions d'annuaire de fournisseurs personnalisées. Si vous utilisez encore ces systèmes, il est temps de migrer vers Go Modules pour rester à jour et profiter des avantages de la gestion moderne des dépendances de Golang. Pour migrer d'un ancien système de gestion des dépendances vers Go Modules, suivez les étapes suivantes :
- Créez une sauvegarde de votre projet original pour vous assurer que vous pouvez revenir à l'état précédent si nécessaire.
- Supprimez tous les fichiers de gestion des dépendances existants (par exemple,
Gopkg.tomlouGopkg.lock). - Naviguez jusqu'à la racine de votre projet dans un terminal, et exécutez
go mod initpour créer un nouveau fichiergo.mod. Cela tentera également de convertir votre fichier de dépendances précédent, s'il est présent, en entrées Go Modules. - Exécutez
go mod tidypour remplir le fichiergo.modavec les dépendances de votre ancien système. Cette commande permet de s'assurer que seuls les paquets nécessaires font partie de l'arbre des dépendances. - À ce stade, il se peut que vous deviez apporter des modifications à votre fichier
go.modpour résoudre des conflits de dépendances ou pour appliquer des versions spécifiques. Utilisez les directivesreplaceetexcludesi nécessaire pour gérer ces problèmes. - Vérifiez que votre projet se construit et passe les tests comme prévu.
En suivant ces étapes, votre projet devrait maintenant fonctionner avec les modules Go, ce qui simplifiera la gestion des dépendances et rendra votre projet plus facile à maintenir à long terme. Tout problème persistant doit être résolu en ajustant le fichier go.mod ou en vérifiant les chemins d'importation pour s'assurer qu'ils suivent le bon format.
AppMaster: Accélérer le développement d'applications basées sur Golang
Incorporer les modules Go et les meilleures pratiques de gestion des dépendances dans votre flux de travail quotidien est essentiel pour assurer la maintenance et l'évolutivité d'un projet logiciel basé sur Golang. Mais que se passerait-il si vous pouviez accélérer l'ensemble du processus de développement d'applications tout en continuant à tirer parti de la puissance de Golang ?
AppMaster.io est une plateforme complète sans code qui met l'accent sur la génération d'applications backend basées sur Golang à l'aide d'un environnement de développement visuel. Outre les applications dorsales, AppMaster permet de créer des applications web et mobiles à l'aide d'une approche intégrée conçue pour rationaliser le processus de développement.
Avec AppMaster, les utilisateurs peuvent créer des modèles de données (schéma de base de données), concevoir des processus d'entreprise et définir des API REST et des WebSocket endpoints à l'aide d'une interface utilisateur visuelle. Les applications web sont créées à l'aide d'une interface "glisser-déposer" et d'un concepteur de processus d'entreprise web pour une expérience utilisateur entièrement interactive. Les applications mobiles sont conçues de la même manière, avec un concepteur de processus d'affaires mobiles et une capacité de conception d'interface utilisateur.
AppMasterLa plateforme d'EMC prend vos plans et génère le code source de vos applications une fois que vous avez appuyé sur le bouton "Publier". Elle compile les applications, exécute des tests, les emballe dans des conteneurs Docker (pour les applications dorsales) et déploie le tout dans le nuage, le tout en quelques secondes.
Les applications dorsales sont générées à l'aide de Golang (Go), bénéficiant ainsi des performances, de la simplicité et de la facilité de maintenance qu'offre Golang. Les applications web sont générées à l'aide du framework Vue3 et de JavaScript/TypeScript, tandis que les applications mobiles utilisent le framework orienté serveur AppMaster, Kotlin et Jetpack Compose pour Android, et SwiftUI pour les applications iOS.
Grâce à la puissante plateforme AppMaster, même ceux qui n'ont pas d'expérience en matière de codage peuvent créer une solution logicielle complète et évolutive qui englobe des serveurs, des sites web, des portails clients et des applications mobiles natives. AppMaster accélère non seulement l'ensemble du processus de développement logiciel, mais élimine aussi complètement la dette technique en générant des applications à partir de zéro à chaque fois que les exigences sont modifiées.
Si vous envisagez d'adopter une plateforme no-code pour vos besoins en développement logiciel, en particulier une plateforme qui exploite les avantages de Golang, AppMaster devrait figurer en tête de votre liste. Créez un compte gratuit et explorez l'avenir du développement d'applications avec une solution 10 fois plus rapide et 3 fois plus rentable.
