![\"\"](\"https:\/\/media.jfrog.com\/wp-content\/uploads\/2019\/07\/20130640\/GlangCICDemail.png\")
<\/p>\n<\/p>\n
Pour les d\u00e9veloppeurs utilisant des langages \u00e9tablis de longue date comme Java, JavaScript ou Python, la meilleure fa\u00e7on d\u2019assembler des workflow d\u2019int\u00e9gration et de livraison continues (CI\/CD) avec <\/span>Artifactory <\/span><\/a>est assez famili\u00e8re. Un ensemble mature de syst\u00e8mes de gestion des d\u00e9pendances pour ces langages et des solutions de conteneurs comme Docker<\/a> fournissent une feuille de route claire.<\/span><\/p>\n Mais si vous programmez vos applications en GoLang, est-il difficile de mettre en place un syst\u00e8me CI\/CD avec la m\u00eame efficacit\u00e9\u00a0?<\/span><\/p>\n Il s\u2019av\u00e8re que le processus est bien plus facile, notamment gr\u00e2ce aux derni\u00e8res innovations de Go. Avec<\/span>\u00a0<\/span>le support natif d\u2019Artifactory pour GoLang,<\/span><\/a> le chemin vers un CI\/CD de qualit\u00e9 est beaucoup plus d\u00e9gag\u00e9.<\/span><\/p>\n\u00ab <\/a><\/span>Click To Tweet<\/a><\/span>\n Chez JFrog, nous sommes de grands fans de GoLang, que nous utilisons comme langage pour plusieurs de nos solutions phares. Et nous pratiquons aussi ce que nous recommandons, en utilisant Artifactory au c\u0153ur de notre CI\/CD. Voici quelques-unes des pratiques que nous pouvons recommander\u00a0:<\/span><\/p>\n Contrairement \u00e0 de nombreux langages de programmation \u00e9tablis, les premi\u00e8res versions de GoLang ne fournissaient pas de m\u00e9canisme commun permettant de g\u00e9rer les d\u00e9pendances versionn\u00e9es. Au lieu de cela, l\u2019\u00e9quipe Go a encourag\u00e9 d\u2019autres personnes \u00e0 d\u00e9velopper des outils additionnels pour le contr\u00f4le de version des packages Go.<\/span><\/p>\n Cela a chang\u00e9 avec la sortie de Go\u00a01.11 en ao\u00fbt\u00a02018, avec la prise en charge des <\/span>modules Go<\/span>. Les modules Go, qui constituent d\u00e9sormais la solution de gestion des d\u00e9pendances native de GoLang, sont des collections de packages Go apparent\u00e9s qui sont versionn\u00e9s ensemble comme une seule entit\u00e9. Cela permet aux d\u00e9veloppeurs de partager du code sans avoir \u00e0 le t\u00e9l\u00e9charger de fa\u00e7on r\u00e9p\u00e9t\u00e9e.\u00a0<\/span><\/p>\n Un module Go est d\u00e9fini par un fichier Si vous n\u2019avez pas encore opt\u00e9 pour les modules Go, vous devez suivre les \u00e9tapes ci-dessous\u00a0:<\/span><\/p>\n Par exemple, voici un fichier Notez que les num\u00e9ros de version doivent \u00eatre conformes \u00e0 la <\/span>convention semver <\/span><\/a> (par exemple, v1.2.1 ou 1.2.1 au lieu de 20190812) comme requis par la commande go. Vous devez \u00e9viter d\u2019utiliser des pseudo-versions comme celle pr\u00e9sent\u00e9e ci-dessus (v0.0.0-yyyymmddhhmmss-abcdefabcdef)\u00a0\u2013\u00a0bien que les pseudo-versions de type \u00ab\u00a0commit hash\u00a0\u00bb aient \u00e9t\u00e9 introduites pour assurer la prise en charge des modules Go dans les projets non balis\u00e9s, elles ne doivent \u00eatre utilis\u00e9es que comme m\u00e9canisme de repli. Si les d\u00e9pendances dont vous avez besoin ont des balises de version, utilisez ces balises dans votre fichier.<\/span><\/p>\n Vous pouvez importer ce module Go dans votre propre code, ainsi que d\u2019autres d\u00e9pendances\u00a0:<\/span><\/p>\n Vous pouvez alors r\u00e9f\u00e9rencer les fonctions du module dans votre code GoLang\u00a0:<\/span><\/p>\n D\u00e8s lors que vous g\u00e9rez vos d\u00e9pendances GoLang en tant que modules versionn\u00e9s, vous pouvez les conserver en tant qu\u2019entit\u00e9s immuables en configurant un GOPROXY. De cette fa\u00e7on, vous pouvez toujours vous assurer de ce que contient une version sp\u00e9cifique d\u2019un module, afin que vos builds soient toujours reproductibles.<\/span><\/p>\n Utiliserez-vous des modules Go qui sont des packages open source accessibles au public\u00a0? Ceux que vous cr\u00e9ez et partagez avec la communaut\u00e9 OSS\u00a0? Les modules que vous r\u00e9servez \u00e0 votre \u00e9quipe uniquement\u00a0? Voici comment proc\u00e9der pour chacun d\u2019eux, ou pour tous en m\u00eame temps, et faire en sorte que ces modules versionn\u00e9s immuables soient toujours disponibles pour vos builds.<\/span><\/p>\n L\u2019\u00e9quipe Go de Google g\u00e8re un ensemble de services GOPROXY pour les modules accessibles au public. \u00c0 partir de Go 1.13, le serveur de modules Le <\/span>site go.dev <\/span><\/a>est \u00e9galement g\u00e9r\u00e9 par l\u2019\u00e9quipe Go, il est la plaque tournante pour les utilisateurs Go fournissant des ressources centralis\u00e9es et organis\u00e9es de l\u2019ensemble de l\u2019\u00e9cosyst\u00e8me Go. Une interface utilisateur conviviale vous permet d\u2019explorer <\/span>pkg.go.dev<\/span><\/a> pour effectuer des recherches parmi des milliers de packages Go open source.<\/span><\/p>\n Le partage est une bonne chose, mais vous devrez probablement limiter l\u2019utilisation de certains modules Go que vous cr\u00e9ez au sein de votre organisation. Avec Artifactory, vous pouvez configurer des <\/span>registres Go<\/span><\/a> locaux et distants, rendant ainsi des modules publics et priv\u00e9s \u00e9galement disponibles pour vos builds.<\/span><\/p>\n Vous pouvez relayer le service central Go en tant que registre Go distant dans Artifactory, fournissant \u00e0 votre syst\u00e8me de g\u00e9n\u00e9ration un cache local qui acc\u00e9l\u00e8re encore plus vos builds et vous prot\u00e8ge contre les pannes de connexion r\u00e9seau. La mise en place est simple.<\/span><\/p>\n Vous pouvez \u00e9galement configurer un ou plusieurs registres Go locaux pour les modules que vous devez g\u00e9rer en priv\u00e9 au sein de votre organisation.<\/span><\/p>\n Lorsque vous combinez des registres locaux et distants dans un <\/span>d\u00e9p\u00f4t virtuel<\/span><\/a>, vos builds peuvent r\u00e9soudre les d\u00e9pendances des modules Go provenant \u00e0 la fois d\u2019une source publique et des modules que vous cr\u00e9ez et g\u00e9rez en priv\u00e9.<\/span><\/p>\n Vous pouvez en savoir plus sur la fa\u00e7on de configurer vos d\u00e9p\u00f4ts GOPROXY pour Artifactory gr\u00e2ce \u00e0 cet article de blog sur comment <\/span>Choisir votre GOPROXY pour les modules Go<\/span><\/a>.<\/span><\/p>\n Lorsque vous assemblez votre application (\u00e0 l\u2019aide de Pour ces artefacts Go interm\u00e9diaires, vous utiliserez les d\u00e9p\u00f4ts g\u00e9n\u00e9riques d\u2019Artifactory. En structurant ces d\u00e9p\u00f4ts de mani\u00e8re intelligente, vous pouvez contr\u00f4ler le flux de vos fichiers binaires pour le d\u00e9veloppement, les tests et la production, gr\u00e2ce \u00e0 des d\u00e9p\u00f4ts distincts pour chacune de ces \u00e9tapes. Pour ce faire, utilisez la fonctionnalit\u00e9 <\/span>Topologie du d\u00e9p\u00f4t personnalis\u00e9 (Custom Layout)<\/span><\/a> pour Artifactory avec ces d\u00e9p\u00f4ts g\u00e9n\u00e9riques.<\/span><\/p>\n Cr\u00e9er une topologie personnalis\u00e9e similaire \u00e0 la suivante\u00a0:<\/span><\/p>\n Lorsque vous <\/span>configurez la topologie personnalis\u00e9e<\/span><\/a>, il convient de tester la r\u00e9solution du chemin d\u2019acc\u00e8s \u00e0 l\u2019artefact pour confirmer comment Artifactory g\u00e9n\u00e9rera les informations du module \u00e0 partir du chemin d\u2019acc\u00e8s en utilisant les d\u00e9finitions de la topologie.<\/span><\/p>\n Une fois vos d\u00e9p\u00f4ts configur\u00e9s comme il se doit pour vos builds Go, vous pouvez commencer \u00e0 les d\u00e9placer efficacement dans vos \u00e9tapes de pipeline.\u00a0<\/span><\/p>\n De nombreuses proc\u00e9dures de d\u00e9veloppement logiciel n\u00e9cessitent un nouveau build complet ou partiel \u00e0 chaque transition interm\u00e9diaire de d\u00e9veloppement, de test et de production. Mais comme les d\u00e9veloppeurs continuent de modifier le code partag\u00e9, chaque nouveau build introduit de nouvelles incertitudes\u00a0; vous ne pouvez pas \u00eatre certain de son contenu. M\u00eame avec des sauvegardes pour garantir des builds d\u00e9terministes, les m\u00eames contr\u00f4les de qualit\u00e9 doivent \u00eatre r\u00e9p\u00e9t\u00e9s \u00e0 chaque \u00e9tape.\u00a0<\/span><\/p>\n Au lieu de cela, cr\u00e9ez vos microservices bas\u00e9s sur Go une fois, puis promouvez-les \u00e0 l\u2019\u00e9tape suivante une fois que les crit\u00e8res de promotion tels que les tests ou les analyses sont remplis. Si vous pr\u00e9voyez de conteneuriser votre microservice Go, le m\u00eame principe s\u2019applique\u00a0: assemblez chaque image Docker une fois et promouvez-la via une s\u00e9rie de d\u00e9p\u00f4ts de staging De cette fa\u00e7on, vous vous assurez que ce qui a \u00e9t\u00e9 test\u00e9 est exactement ce qui sera mis en production.<\/span><\/p>\n Au lieu d\u2019un pipeline unique et monolithique pour votre application, il est pr\u00e9f\u00e9rable d\u2019en avoir plusieurs, chacun assemblant, testant, analysant et promouvant une couche diff\u00e9rente. Cela contribue \u00e0 rendre votre processus CI\/CD plus flexible, avec diff\u00e9rentes \u00e9quipes responsables de chaque couche, et favorise un syst\u00e8me \u00ab\u00a0fail fast\u00a0\u00bb qui permet une r\u00e9action rapide aux erreurs.<\/span><\/p>\n Par exemple, le d\u00e9ploiement d\u2019une application conteneuris\u00e9e peut g\u00e9n\u00e9ralement \u00eatre compos\u00e9 de cinq pipelines\u00a0:<\/span><\/p>\n Artifactory agit comme votre \u00ab\u00a0source de v\u00e9rit\u00e9\u00a0\u00bb pour vos builds Go, en fournissant un GOPROXY pour les modules publics et priv\u00e9s, ainsi qu\u2019en stockant les fichiers binaires compil\u00e9s. L\u2019utilisation de JFrog\u00a0CLI pour assembler votre application Go aide le processus de g\u00e9n\u00e9ration \u00e0 interagir avec Artifactory et \u00e0 capturer les informations de build qui rendent vos builds enti\u00e8rement tra\u00e7ables. Voici un exemple d\u2019extrait\u00a0:<\/span><\/p>\n <\/p>\n Pour en savoir plus, jetez un coup d\u2019\u0153il \u00e0 notre <\/span>exemple de fichiers de d\u00e9monstration pour GoLang CI\/CD<\/span><\/a> que nous utiliserons \u00e0 GopherCon.<\/span><\/p>\nMeilleures Pratiques<\/span><\/h1>\n
1. Utiliser des Modules Go<\/span><\/h2>\n
go.mod<\/code> qui se trouve dans le r\u00e9pertoire racine du projet et qui sp\u00e9cifie le nom du module ainsi que ses d\u00e9pendances. La d\u00e9pendance d\u2019un module est repr\u00e9sent\u00e9e par son nom et son <\/span>num\u00e9ro de version<\/span><\/a>.<\/span><\/p>\n\n
go mod init<\/code> pour g\u00e9n\u00e9rer un fichier go.mod<\/code> .<\/span><\/li>\ngo mod tidy<\/code> . Cette commande g\u00e9n\u00e8re un fichier go.mod d\u00e9j\u00e0 rempli.<\/span><\/li>\n.proto<\/code> , doivent \u00eatre mis \u00e0 jour pour refl\u00e9ter le nouveau chemin d\u2019importation.<\/span><\/li>\n<\/ol>\ngo.mod<\/code> pour un module Go accessible au public <\/span>pour un logger structur\u00e9<\/span><\/a>\u00a0:<\/span><\/p>\n\nmodule github.com\/sirupsen\/logrus\r\n\r\nrequire (\r\n\tgithub.com\/davecgh\/go-spew v1.1.1 \/\/ indirect\r\n\tgithub.com\/konsorten\/go-windows-terminal-sequences v1.0.1\r\n\tgithub.com\/pmezard\/go-difflib v1.0.0 \/\/ indirect\r\n\tgithub.com\/stretchr\/objx v0.1.1 \/\/ indirect\r\n\tgithub.com\/stretchr\/testify v1.2.2\r\n\tgolang.org\/x\/sys v0.0.0-20190422165155-953cdadca894\r\n)<\/span><\/pre>\n<\/div>\n\nimport (\r\n\t("fmt"\r\n\t"io\/ioutil"\r\n\t"net\/http"\r\n\t"os"\r\n\r\n\/\/ Public Go Module for logging\r\n\tlog "github.com\/sirupsen\/logrus")\r\n<\/span><\/pre>\n<\/div>\n\n \/\/ Send text to the log\r\n log.Printf("Hello Log!")<\/span><\/pre>\n<\/div>\n2. Utiliser GOPROXY pour Garantir l\u2019Immuabilit\u00e9 et la Disponibilit\u00e9<\/span><\/h2>\n
GOLANG.ORG<\/span><\/h3>\n
proxy.golang.org<\/code> est automatiquement d\u00e9fini comme le GOPROXY par d\u00e9faut lorsque Go est install\u00e9 ou mis \u00e0 jour. Ce service est \u00e9galement pris en charge par un service d\u2019index pour d\u00e9couvrir les nouveaux modules (index.golang.org<\/code>), et une base de donn\u00e9es globale go.sum pour authentifier le contenu des modules (sum.golang.org<\/code>).<\/span><\/p>\n![\"\"](\"https:\/\/media.jfrog.com\/wp-content\/uploads\/2019\/07\/28005948\/GoLangCICD_go_dev.png\")
<\/p>\nRegistres Go\u00a0Artifactory<\/span><\/h3>\n
![\"Artifactory](\"https:\/\/media.jfrog.com\/wp-content\/uploads\/2019\/07\/28010145\/GoLangCICD_GoRegistry.png\")
<\/p>\n3. Utiliser les Topologies du D\u00e9p\u00f4t\u00a0Artifactory<\/span><\/h2>\n
go build<\/code>), o\u00f9 les artefacts binaires g\u00e9n\u00e9r\u00e9s seront-ils stock\u00e9s\u00a0? Votre processus de g\u00e9n\u00e9ration peut envoyer ces r\u00e9sultats interm\u00e9diaires aux d\u00e9p\u00f4ts dans un gestionnaire de d\u00e9p\u00f4ts binaires tel qu\u2019Artifactory.<\/span><\/p>\n[org]\/[name<.+>]\/[module]-[arch<.+>]-[baseRev].[ext]<\/pre>\n
![\"\"](\"https:\/\/media.jfrog.com\/wp-content\/uploads\/2019\/07\/20130640\/GoLangCICD_TestCustomLayout-1024x523.png\")
<\/p>\n4. Assembler une Fois et Promouvoir<\/span><\/h2>\n
![\"Build](\"https:\/\/media.jfrog.com\/wp-content\/uploads\/2017\/12\/20133601\/DockerPipeline2.png\")
<\/p>\n5. \u00c9viter les Pipelines Monolithiques<\/span><\/h2>\n
\n
alpine:3.10<\/code> est utilis\u00e9 comme couche de base de l\u2019infrastructure Docker, alors toutes les mises \u00e0 jour de correctifs seront incluses chaque fois que l\u2019infrastructure Docker est g\u00e9n\u00e9r\u00e9e. Ce pipeline comprendra des \u00e9tapes de build, de test et de promotion.<\/span><\/li>\n\n\/\/ Configure Artifactory\r\njfrog rt c\r\n\r\n\/\/ Configure the project\u2019s repositories\r\njfrog rt go-config\r\n\r\n\/\/ Build the project with go and resolve the project dependencies\r\nfrom Artifactory.\r\nJfrog rt go build --build-name=my-build --build-number=1\r\n\r\n\/\/ Publish the package we build to Artifactory.\r\njfrog rt gp go v1.0.0 --build-name=my-build --build-number=1\r\n\r\n\/\/ Collect environment variables and add them to the build info.\r\njfrog rt bce my-build 1\r\n\r\n\/\/ Publish the build info to Artifactory.\r\njfrog rt bp my-build 1<\/span><\/pre>\n<\/div>\nBoldly Go<\/span><\/h1>\n