{"id":81038,"date":"2021-07-24T13:55:28","date_gmt":"2021-07-24T11:55:28","guid":{"rendered":"https:\/\/jfrog.com\/?p=81038"},"modified":"2021-09-12T14:00:05","modified_gmt":"2021-09-12T12:00:05","slug":"5-best-practices-for-golang-ci-cd","status":"publish","type":"post","link":"https:\/\/jfrog.com\/de\/blog\/5-best-practices-for-golang-ci-cd\/","title":{"rendered":"5 Best Practices f\u00fcr GoLang-CI\/CD"},"content":{"rendered":"

\"\"<\/p>\n

Entwicklern, die in etablierten Sprachen wie Java, JavaScript oder Python programmieren, ist die optimale Art und Weise Continuous-Integration- und Continuous-Delivery-Workflows (CI\/CD) mit <\/span>Artifactory <\/span><\/a>aufzubauen, ziemlich vertraut. Eine ausgereifte Reihe von Systemen zur Verwaltung von Abh\u00e4ngigkeiten f\u00fcr diese Sprachen und Container-L\u00f6sungen wie Docker<\/a> bieten eine klare Roadmap.<\/span><\/p>\n

Aber wie schwer ist es, wenn Sie Ihre Anwendungen in GoLang programmieren, CI\/CD mit der gleichen Effizienz zu betreiben?<\/span><\/p>\n

Wie sich herausstellt, ist es viel einfacher geworden, besonders mit einigen der neuesten Innovationen in Go. Mit<\/span>\u00a0<\/span>der nativen Unterst\u00fctzung von Artifactory f\u00fcr GoLang<\/span><\/a> ist der Weg zu einwandfreier CI\/CD viel klarer.<\/span><\/p>\nMit den neuesten Innovationen in Go, wie der nativen Unterst\u00fctzung von Artifactory, ist der Weg zu einwandfreier CI\/CD viel klarer. <\/a><\/span>Klick um zu Tweeten<\/a><\/span>\n

Best Practices<\/span><\/h1>\n

Wir bei JFrog sind gro\u00dfe Fans von GoLang und verwenden es als Sprache f\u00fcr mehrere unserer renommiertesten L\u00f6sungen. Und wir praktizieren auch, was wir propagieren, indem wir Artifactory als Herzst\u00fcck unserer CI\/CD einsetzen. Hier sind einige der Praktiken, die wir empfehlen k\u00f6nnen:<\/span><\/p>\n

1. Go-Module verwenden<\/span><\/h2>\n

Anders als viele etablierte Programmiersprachen haben die ersten Versionen von GoLang keinen gemeinsamen Mechanismus f\u00fcr die Verwaltung von versionierten Abh\u00e4ngigkeiten bereitgestellt. Stattdessen hatte das Go-Team andere Entwickler aufgefordert, Zusatz-Tools f\u00fcr die Versionierung von Go-Paketen zu entwickeln.<\/span><\/p>\n

Das \u00e4nderte sich mit der Ver\u00f6ffentlichung von Go 1.11 im August 2018, da ab diesem Zeitpunkt <\/span>Go-Module<\/span> unterst\u00fctzt werden. Go-Module sind Sammlungen von zusammengeh\u00f6rigen Go-Paketen, die als eine Einheit versioniert werden, und bilden nun die native L\u00f6sung zur Verwaltung von Abh\u00e4ngigkeiten f\u00fcr GoLang. Dies erm\u00f6glicht es Entwicklern, Code gemeinsam zu nutzen, ohne ihn wiederholt herunterzuladen. <\/span><\/p>\n

Ein Go-Modul wird durch eine go.mod<\/code> -Datei im Stammverzeichnis des Projekts definiert, die den Modulnamen zusammen mit seinen Modulabh\u00e4ngigkeiten angibt. Die Modulabh\u00e4ngigkeit wird durch Modulname und <\/span>Versionsnummer<\/span><\/a> angegeben.<\/span><\/p>\n

Wenn Sie Go-Module noch nicht \u00fcbernommen haben, m\u00fcssen Sie die folgenden Schritte ausf\u00fchren:<\/span><\/p>\n

    \n
  1. Verwenden Sie go mod init<\/code> , um eine go.mod<\/code> -Datei zu erzeugen, wenn fr\u00fchere Paketmanager verwendet wurden.<\/span><\/li>\n
  2. Verwenden Sie go mod tidy<\/code> , wenn keine anderen Paketmanager verwendet wurden. Mit diesem Befehl wird eine ausgef\u00fcllte go.mod-Datei erzeugt.<\/span><\/li>\n
  3. Wenn es sich um Version v2 und h\u00f6her handelt, dann ist die \u00c4nderung des Modulnamens erforderlich, um das entsprechende Suffix hinzuzuf\u00fcgen, Aktualisierungen des Importpfads, die Verwendung von modulorientierten statischen Analysetools und schlie\u00dflich die Aktualisierung von Codegenerator-Dateien wie zum Beispiel .proto<\/code> -Dateien, um den neuen Importpfad wiederzugeben.<\/span><\/li>\n<\/ol>\n

    Hier ist zum Beispiel eine go.mod<\/code> -Datei f\u00fcr ein \u00f6ffentlich verf\u00fcgbares <\/span>Go-Modul f\u00fcr einen strukturierten Logger<\/span><\/a>:<\/span><\/p>\n

    \n
    modul 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
    Beachten Sie, dass die Versionsnummern der <\/span>Semver-Konvention<\/span><\/a> entsprechen m\u00fcssen (z. B. v1.2.1 anstelle von 20190812 oder 1.2.1) gem\u00e4\u00df go-Befehl. Sie sollten es vermeiden, Pseudo-Versionen wie die oben gezeigt (v0.0.0-yyyymmddhhmmss-abcdefabcdef) zu verwenden \u2013 obwohl Pseudo-Versionen mit Commit-Hash eingef\u00fchrt wurden, um Go-Module-Support f\u00fcr nicht markierte Projekte zu erm\u00f6glichen, sollten sie nur als Fallback-Mechanismus verwendet werden. Wenn die Abh\u00e4ngigkeiten, die Sie ben\u00f6tigen, Release-Tags haben, verwenden Sie diese Tags in Ihren require-Anweisungen.<\/span><\/p>\n
    In Ihrem eigenen Code k\u00f6nnen Sie dieses Go-Modul zusammen mit anderen Abh\u00e4ngigkeiten importieren:<\/span><\/p>\n
    \n
    import (\r\n\t"fmt"\r\n\t"io\/ioutil"\r\n\t"net\/http"\r\n\t"os"\r\n\r\n\/\/ \u00d6ffentliches Go-Modul f\u00fcr das Logging\r\n\tlog "github.com\/sirupsen\/logrus"\r\n)<\/span><\/pre>\n<\/div>\n
    Dann k\u00f6nnen Sie die Modulfunktionen in Ihrem GoLang-Code referenzieren:<\/span><\/p>\n
    \n
       \/\/ Text zum Log senden\r\n   log.Printf("Hello Log!")<\/span><\/pre>\n<\/div>\n
    2. Verwenden Sie GOPROXY, um die Unver\u00e4nderlichkeit und Verf\u00fcgbarkeit sicherzustellen<\/span><\/h2>\n
    Sobald Sie Ihre GoLang-Abh\u00e4ngigkeiten als versionierte Module pflegen, k\u00f6nnen Sie sie als unver\u00e4nderliche Instanzen behalten, indem Sie eine GOPROXY einrichten. Auf diese Weise k\u00f6nnen Sie immer garantieren, was eine bestimmte Version eines Moduls enth\u00e4lt, sodass Ihre Builds immer wiederholbar sind.<\/span><\/p>\n
    Werden Sie Go-Module verwenden, die \u00f6ffentlich verf\u00fcgbare Open Source-Pakete sind? Solche, die Sie erstellen und mit der OSS-Community teilen? Module, die Sie nur f\u00fcr Ihr Team privat vorhalten? Hier finden Sie M\u00f6glichkeiten, wie Sie schrittweise vorgehen oder alles auf einmal machen k\u00f6nnen und sicherstellen, dass diese unver\u00e4nderten versionierten Module immer f\u00fcr Ihre Builds verf\u00fcgbar sind.<\/span><\/p>\n
    GOLANG.ORG<\/span><\/h3>\n
    Das Go-Team bei Google unterh\u00e4lt einen Satz von GOPROXY-Diensten f\u00fcr \u00f6ffentlich verf\u00fcgbare Module. Ab Go 1.13 wird der Modulspiegel proxy.golang.org<\/code> automatisch als Standard-GOPROXY festgelegt, wenn Go installiert oder aktualisiert wird. Dieser Dienst wird auch durch einen Indexdienst zum Auffinden neuer Module unterst\u00fctzt (index.golang.org<\/code>) sowie durch eine globale go.sum-Datenbank zur Authentifizierung von Modulinhalten (sum.golang.org<\/code>).<\/span><\/p>\n
    Die <\/span>go.dev<\/span><\/a>-Website wird ebenfalls vom Go-Team gepflegt und ist der Hub f\u00fcr Go-Benutzer, der zentralisierte und kuratierte Ressourcen aus dem gesamten Go-\u00d6kosystem bereitstellt. Auf dieser Website k\u00f6nnen Sie <\/span>pkg.go.dev<\/span><\/a> unter Tausenden von Open-Source-Go-Paketen \u00fcber eine bedienungsfreundliche Benutzeroberfl\u00e4che suchen.<\/span><\/p>\n
    \"\"<\/p>\n
    Artifactory Go-Registries<\/span><\/h3>\n
    Auch wenn es gut ist, sie gemeinsam zu nutzen, m\u00fcssen Sie wahrscheinlich auch die Verwendung einiger von Ihnen erstellter Go-Module auf Ihre Organisation beschr\u00e4nken. Mit Artifactory k\u00f6nnen Sie sowohl lokale als auch externe <\/span>Go-Registries<\/span><\/a> einrichten, sodass \u00f6ffentliche und private Module gleicherma\u00dfen f\u00fcr Ihre Builds verf\u00fcgbar sind.<\/span><\/p>\n
    Sie k\u00f6nnen den Go-Spiegeldienst als Proxy f\u00fcr eine externe Go-Registrierung in Artifactory verwenden, um Ihrem Build-System einen lokalen Cache zur Verf\u00fcgung zu stellen. Dieser beschleunigt Ihre Builds und tr\u00e4gt zum Schutz vor Ausf\u00e4llen der Netzwerkverbindung bei. Das Einrichten ist einfach.<\/span><\/p>\n
    \"Artifactory<\/p>\n
    Sie k\u00f6nnen auch eine oder mehrere lokale Go-Registrierungen f\u00fcr Module konfigurieren, die Sie innerhalb Ihrer Organisation privat pflegen m\u00fcssen.<\/span><\/p>\n
    Wenn Sie lokale und externe Registries in einem <\/span>virtuellen Repository<\/span><\/a> kombinieren, k\u00f6nnen Ihre Builds Go-Modulabh\u00e4ngigkeiten aufl\u00f6sen, die sowohl von einer \u00f6ffentlichen Quelle stammen als auch von Modulen, die Sie privat erstellen und pflegen.<\/span><\/p>\n
    Mehr dar\u00fcber, wie Sie Ihre GOPROXY for Artifactory-Repositories konfigurieren, erfahren Sie in diesem Blogbeitrag \u00fcber die <\/span>Auswahl Ihrer GOPROXY for Go-Module<\/span><\/a>.<\/span><\/p>\n
    3. Artifactory-Repository-Layouts verwenden<\/span><\/h2>\n
    Wo werden, wenn Sie Ihre App erstellen (mit go build<\/code>), die erzeugten bin\u00e4ren Artefakte gespeichert? Ihr Build-Prozess kann diese Zwischenergebnisse an Repositories in einem Bin\u00e4rdatei-Repository-Manager wie Artifactory \u00fcbergeben.<\/span><\/p>\n
    F\u00fcr diese dazwischenliegenden Go-Artefakte werden Sie die generischen Repositories von Artifactory verwenden. Eine intelligente Strukturierung dieser Repositories kann Ihnen dabei helfen, den Fluss Ihrer Bin\u00e4rdateien durch Entwicklung, Test und Produktion mit separaten Repositories f\u00fcr jede dieser Phasen zu kontrollieren. Um Sie dabei zu unterst\u00fctzen, verwenden Sie die <\/span>benutzerdefinierte Repository-Layout-Funktion<\/span><\/a> von Artifactory mit diesen generischen Repositories.<\/span><\/p>\n
    Erstellen Sie ein benutzerdefiniertes Layout, das \u00e4hnlich wie das folgende aussieht:<\/span><\/p>\n
    [org]\/[name<.+>]\/[module]-[arch<.+>]-[baseRev].[ext]<\/pre>\n
    Wenn Sie <\/span>das benutzerdefinierte Layout konfigurieren<\/span><\/a>, sollten Sie die Artefakt-Pfadaufl\u00f6sung testen, um zu best\u00e4tigen, wie Artifactory die Modulinformationen aus dem Pfad unter Verwendung der Layoutdefinitionen aufbaut.<\/span><\/p>\n
    \"\"<\/p>\n
    4. Einmal bauen und heraufstufen<\/span><\/h2>\n
    Wenn Sie Ihre Repositories f\u00fcr Ihre Go-Builds richtig eingerichtet haben, k\u00f6nnen Sie damit beginnen, diese effizient durch Ihre Pipeline-Stufen zu bewegen. <\/span><\/p>\n
    Viele Software-Entwicklungsverfahren erfordern bei jedem Staging-\u00dcbergang von Entwicklung, Test und Produktion einen vollst\u00e4ndig oder teilweise neuen Build. Aber da die Entwickler den gemeinsam genutzten Code immer wieder \u00e4ndern, bringt jeder neue Build neue Ungewissheiten mit sich; Sie k\u00f6nnen nicht sicher sein, was darin enthalten ist. Selbst mit Sicherheitsvorkehrungen zur Sicherstellung deterministischer Builds kann es erforderlich sein, die gleichen Qualit\u00e4tspr\u00fcfungen in jeder Phase zu wiederholen. <\/span><\/p>\n
    Erstellen Sie stattdessen Ihre Go-basierten Microservices einmal und bef\u00f6rdern Sie sie dann auf die n\u00e4chste Stufe, sobald Bef\u00f6rderungskriterien wie Tests oder Scans erf\u00fcllt sind. Wenn Sie planen, Ihren Go-Microservice zu containerisieren, gilt das gleiche Prinzip: Jedes Docker-Image einmal zu erstellen und es \u00fcber eine Reihe von Staging-Repositories heraufzustufen. Auf diese Weise k\u00f6nnen Sie garantieren, dass das, was getestet wurde, genau das ist, was f\u00fcr die Produktion freigegeben wird.<\/span><\/p>\n
    \"Build<\/p>\n
    5. Vermeiden Sie monolithische Pipelines<\/span><\/h2>\n
    Anstelle einer einzigen, monolithischen Pipeline f\u00fcr Ihre App ist es besser, mehrere zu haben, wobei jede eine andere Schicht erstellt, testet, pr\u00fcft und heraufstuft. Dadurch k\u00f6nnen Sie Ihren CI\/CD-Prozess flexibler gestalten, wobei unterschiedliche Teams f\u00fcr jede Schicht verantwortlich sind. Au\u00dferdem wird ein ein "Fail Fast"-System gef\u00f6rdert, das hilft, Fehler fr\u00fchzeitig zu erkennen.<\/span><\/p>\n
    Beispielsweise kann die Bereitstellung einer containerisierten Anwendung aus f\u00fcnf Pipelines bestehen, was in der Regel der Fall ist:<\/span><\/p>\n
      \n
    1. Erstellen Sie die Go-Anwendung mit der JFrog CLI<\/span><\/a>. Diese Pipeline zieht den Quellcode, erstellt die Anwendung mit Artifactory-Repositories f\u00fcr Abh\u00e4ngigkeiten und Ausgabe-Bin\u00e4rdateien, testet und stuft von einem Dev-Repository zu einem Staging-Repository in Artifactory herauf.<\/span><\/li>\n
    2. Erstellen Sie eine Basisschicht der containerisierten App, z. B. ein Docker-Framework. Je nach den Risiko- und Upgrade-Richtlinien des Unternehmens k\u00f6nnen statische oder dynamische Tags verwendet werden. Wenn zum Beispiel ein dynamisches Tag wie alpine:3.10<\/code> als Basisschicht des Docker-Frameworks verwendet wird, werden alle Patch-Updates bei jeder Erstellung des Docker-Frameworks einbezogen. Diese Pipeline umfasst die Phasen Erstellung, Test und Heraufstufung.<\/span><\/li>\n
    3. Rufen Sie die heraufgestuften Artefakte ab, die von den vorherigen Pipelines erzeugt wurden, und erstellen Sie eine containerisierte App, zu der ebenfalls die Phasen Erstellung, Test, Scan und Heraufstufen geh\u00f6ren.<\/span><\/li>\n
    4. Erstellen Sie ein Helm-Chart<\/a> , das auf eine statisch getaggte und heraufgestufte Version einer containerisierten App verweist, die von einer vorherigen Pipeline produziert wurde.<\/span><\/li>\n
    5. Stellen Sie die containerisierte Go-App mithilfe des Helm-Diagramms in Kubernetes bereit.<\/span><\/li>\n<\/ol>\n
      Artifactory fungiert als "Quelle der Wahrheit" f\u00fcr Ihre Go-Builds und bietet eine GOPROXY f\u00fcr \u00f6ffentliche und private Module sowie die Speicherung kompilierter Bin\u00e4rdateien. Die Verwendung der JFrog CLI zur Erstellung Ihrer Go-App hilft dem Build-Prozess, mit Artifactory zu interagieren und die Build-Informationen zu erfassen, die Ihre Builds vollst\u00e4ndig nachvollziehbar machen. Hier ist ein Beispiel-Snippet:<\/span><\/p>\n
      \n
      \/\/ Configure Artifactory\r\njfrog rt c\r\n\r\n\/\/ Configure the project's 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>\n
       <\/p>\n
      Um mehr dar\u00fcber zu erfahren, werfen Sie einen Blick auf unsere <\/span>Beispiel-Demo-Dateien f\u00fcr GoLang CI\/CD<\/span><\/a>, die wir auf der GopherCon verwenden werden.<\/span><\/p>\n
      Go – Einfach<\/span><\/h1>\n
      Wie Sie sehen, k\u00f6nnen einige einfache Best Practices bei der Verwaltung Ihrer GoLang-Anwendungen den Weg zu effektivem CI\/CD erleichtern. Artifactory kann als der wesentliche Manager Ihrer Software-Artefakt-Lieferkette eine zentrale Rolle dabei spielen, diese Methoden in Ihre Software-Entwicklungspipeline einzuf\u00fchren.<\/span><\/p>\n
      Noch Fragen? Wir beantworten sie gerne auf Gophercon. Tauchen Sie mit uns ein, um die besten M\u00f6glichkeiten zu erkunden, wie Sie Ihre Go-Anwendungen schnell und in h\u00f6chster Qualit\u00e4t ver\u00f6ffentlichen k\u00f6nnen. Sie k\u00f6nnen aber auch die <\/span>kostenlose Testversion von Artifactory<\/span><\/a> nutzen, um die M\u00f6glichkeiten in der Praxis umzusetzen!<\/span><\/p>\n","protected":false},"excerpt":{"rendered":"
      Entwicklern, die in etablierten Sprachen wie Java, JavaScript oder Python programmieren, ist die optimale Art und Weise Continuous-Integration- und Continuous-Delivery-Workflows (CI\/CD) mit Artifactory aufzubauen, ziemlich vertraut. Eine ausgereifte Reihe von Systemen zur Verwaltung von Abh\u00e4ngigkeiten f\u00fcr diese Sprachen und Container-L\u00f6sungen wie Docker bieten eine klare Roadmap. Aber wie schwer ist es, wenn Sie Ihre Anwendungen …<\/p>\n","protected":false},"author":140,"featured_media":47309,"comment_status":"closed","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"inline_featured_image":false,"footnotes":""},"categories":[9450,9435,9424,9245],"tags":[9453,9451,9452,9439,9437,9419],"class_list":["post-81038","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-pakete","category-jfrog-cli-de","category-gocenter-de","category-artifactory-de","tag-ci-cd-de","tag-continuous-delivery-de","tag-ci-de","tag-go-de","tag-go-module","tag-best-practices-de"],"yoast_head":"\n5 Best Practices f\u00fcr den Aufbau von CI\/CD Pipelines f\u00fcr GoLang-Apps | JFrog<\/title>\n<meta name=\"description\" content=\"Lernen Sie Techniken wie: Verwendung von Go-Modulen f\u00fcr Go-Pakete, Registries mit GOPROXY, Artefakt-Repositories, Build-Bereitstellung und mehr mit JFrog Artifactory.\" \/>\n<meta name=\"robots\" content=\"index, follow, max-snippet:-1, max-image-preview:large, max-video-preview:-1\" \/>\n<link rel=\"canonical\" href=\"https:\/\/jfrog.com\/de\/wp-json\/wp\/v2\/posts\/81038\" \/>\n<meta property=\"og:locale\" content=\"de_DE\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"5 Best Practices f\u00fcr GoLang CI\/CD-Pipelines\" \/>\n<meta property=\"og:description\" content=\"Lernen Sie, wie Sie Go-Module, Artifactory-Registries und -Repositories und mehr verwenden, um schnelle, leistungsf\u00e4hige CI\/CD zu erstellen.\" \/>\n<meta property=\"og:url\" content=\"https:\/\/jfrog.com\/de\/blog\/5-best-practices-for-golang-ci-cd\/\" \/>\n<meta property=\"og:site_name\" content=\"JFrog\" \/>\n<meta property=\"article:publisher\" content=\"https:\/\/www.facebook.com\/artifrog\" \/>\n<meta property=\"article:published_time\" content=\"2021-07-24T11:55:28+00:00\" \/>\n<meta property=\"article:modified_time\" content=\"2021-09-12T12:00:05+00:00\" \/>\n<meta property=\"og:image\" content=\"https:\/\/jfrog.com\/wp-content\/uploads\/2019\/07\/GlangCICDsocial.png\" \/>\n<meta name=\"author\" content=\"giannit\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:title\" content=\"5 Best Practices f\u00fcr GoLang CI\/CD-Pipelines\" \/>\n<meta name=\"twitter:description\" content=\"Lernen Sie, wie Sie Go-Module, Artifactory-Registries und -Repositories und mehr verwenden, um schnelle, leistungsf\u00e4hige CI\/CD zu erstellen.\" \/>\n<meta name=\"twitter:creator\" content=\"@jfrog\" \/>\n<meta name=\"twitter:site\" content=\"@jfrog\" \/>\n<meta name=\"twitter:label1\" content=\"Written by\" \/>\n\t<meta name=\"twitter:data1\" content=\"giannit\" \/>\n\t<meta name=\"twitter:label2\" content=\"Est. reading time\" \/>\n\t<meta name=\"twitter:data2\" content=\"9 minutes\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\/\/schema.org\",\"@graph\":[{\"@type\":\"Article\",\"@id\":\"https:\/\/jfrog.com\/de\/blog\/5-best-practices-for-golang-ci-cd\/#article\",\"isPartOf\":{\"@id\":\"https:\/\/jfrog.com\/de\/blog\/5-best-practices-for-golang-ci-cd\/\"},\"author\":{\"name\":\"giannit\",\"@id\":\"https:\/\/jfrog.com\/de\/#\/schema\/person\/b554ace14b37da5eed75bbfc7dd1c1af\"},\"headline\":\"5 Best Practices f\u00fcr GoLang-CI\/CD\",\"datePublished\":\"2021-07-24T11:55:28+00:00\",\"dateModified\":\"2021-09-12T12:00:05+00:00\",\"mainEntityOfPage\":{\"@id\":\"https:\/\/jfrog.com\/de\/blog\/5-best-practices-for-golang-ci-cd\/\"},\"wordCount\":1652,\"publisher\":{\"@id\":\"https:\/\/jfrog.com\/de\/#organization\"},\"image\":{\"@id\":\"https:\/\/jfrog.com\/de\/blog\/5-best-practices-for-golang-ci-cd\/#primaryimage\"},\"thumbnailUrl\":\"https:\/\/speedmedia2.jfrog.com\/08612fe1-9391-4cf3-ac1a-6dd49c36b276\/media.jfrog.com\/wp-content\/uploads\/2019\/07\/20130638\/GlangCICD_204x148.png\",\"keywords\":[\"CI\/CD\",\"Continuous Delivery\",\"CI\",\"Go\",\"Go-Module\",\"Best Practices\"],\"articleSection\":[\"Pakete\",\"JFrog CLI\",\"GoCenter\",\"Artifactory\"],\"inLanguage\":\"de-DE\"},{\"@type\":\"WebPage\",\"@id\":\"https:\/\/jfrog.com\/de\/blog\/5-best-practices-for-golang-ci-cd\/\",\"url\":\"https:\/\/jfrog.com\/de\/blog\/5-best-practices-for-golang-ci-cd\/\",\"name\":\"5 Best Practices f\u00fcr den Aufbau von CI\/CD Pipelines f\u00fcr GoLang-Apps | JFrog\",\"isPartOf\":{\"@id\":\"https:\/\/jfrog.com\/de\/#website\"},\"primaryImageOfPage\":{\"@id\":\"https:\/\/jfrog.com\/de\/blog\/5-best-practices-for-golang-ci-cd\/#primaryimage\"},\"image\":{\"@id\":\"https:\/\/jfrog.com\/de\/blog\/5-best-practices-for-golang-ci-cd\/#primaryimage\"},\"thumbnailUrl\":\"https:\/\/speedmedia2.jfrog.com\/08612fe1-9391-4cf3-ac1a-6dd49c36b276\/media.jfrog.com\/wp-content\/uploads\/2019\/07\/20130638\/GlangCICD_204x148.png\",\"datePublished\":\"2021-07-24T11:55:28+00:00\",\"dateModified\":\"2021-09-12T12:00:05+00:00\",\"description\":\"Lernen Sie Techniken wie: Verwendung von Go-Modulen f\u00fcr Go-Pakete, Registries mit GOPROXY, Artefakt-Repositories, Build-Bereitstellung und mehr mit JFrog Artifactory.\",\"breadcrumb\":{\"@id\":\"https:\/\/jfrog.com\/de\/blog\/5-best-practices-for-golang-ci-cd\/#breadcrumb\"},\"inLanguage\":\"de-DE\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\/\/jfrog.com\/de\/blog\/5-best-practices-for-golang-ci-cd\/\"]}]},{\"@type\":\"ImageObject\",\"inLanguage\":\"de-DE\",\"@id\":\"https:\/\/jfrog.com\/de\/blog\/5-best-practices-for-golang-ci-cd\/#primaryimage\",\"url\":\"https:\/\/speedmedia2.jfrog.com\/08612fe1-9391-4cf3-ac1a-6dd49c36b276\/media.jfrog.com\/wp-content\/uploads\/2019\/07\/20130638\/GlangCICD_204x148.png\",\"contentUrl\":\"https:\/\/speedmedia2.jfrog.com\/08612fe1-9391-4cf3-ac1a-6dd49c36b276\/media.jfrog.com\/wp-content\/uploads\/2019\/07\/20130638\/GlangCICD_204x148.png\",\"width\":204,\"height\":148,\"caption\":\"Blog\"},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\/\/jfrog.com\/de\/blog\/5-best-practices-for-golang-ci-cd\/#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"Home\",\"item\":\"https:\/\/jfrog.com\/de\/\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"5 Best Practices f\u00fcr GoLang-CI\/CD\"}]},{\"@type\":\"WebSite\",\"@id\":\"https:\/\/jfrog.com\/de\/#website\",\"url\":\"https:\/\/jfrog.com\/de\/\",\"name\":\"JFrog\",\"description\":\"Deliver Trusted Software Releases at Speed and Scale\",\"publisher\":{\"@id\":\"https:\/\/jfrog.com\/de\/#organization\"},\"potentialAction\":[{\"@type\":\"SearchAction\",\"target\":{\"@type\":\"EntryPoint\",\"urlTemplate\":\"https:\/\/jfrog.com\/de\/?s={search_term_string}\"},\"query-input\":\"required name=search_term_string\"}],\"inLanguage\":\"de-DE\"},{\"@type\":\"Organization\",\"@id\":\"https:\/\/jfrog.com\/de\/#organization\",\"name\":\"JFrog\",\"url\":\"https:\/\/jfrog.com\/de\/\",\"logo\":{\"@type\":\"ImageObject\",\"inLanguage\":\"de-DE\",\"@id\":\"https:\/\/jfrog.com\/de\/#\/schema\/logo\/image\/\",\"url\":\"https:\/\/speedmedia2.jfrog.com\/08612fe1-9391-4cf3-ac1a-6dd49c36b276\/media.jfrog.com\/wp-content\/uploads\/2025\/05\/27095207\/Logo.svg\",\"contentUrl\":\"https:\/\/speedmedia2.jfrog.com\/08612fe1-9391-4cf3-ac1a-6dd49c36b276\/media.jfrog.com\/wp-content\/uploads\/2025\/05\/27095207\/Logo.svg\",\"width\":74,\"height\":73,\"caption\":\"JFrog\"},\"image\":{\"@id\":\"https:\/\/jfrog.com\/de\/#\/schema\/logo\/image\/\"},\"sameAs\":[\"https:\/\/www.facebook.com\/artifrog\",\"https:\/\/x.com\/jfrog\",\"https:\/\/www.linkedin.com\/company\/455737\",\"https:\/\/www.youtube.com\/channel\/UCh2hNg76zo3d1qQqTWIQxDg\",\"https:\/\/www.wikidata.org\/wiki\/Q98608948\"],\"description\":\"We set out on our Liquid Software journey in 2008, with the mission to transform the way enterprises manage and release software updates. The world expects software to update continuously, securely, non-intrusively and without user intervention. This hyper-connected experience can only be enabled by automation with an end-to-end DevOps platform and a binary-centric focus. With this in mind, we\u2019ve developed the JFrog Platform, ushering in a new era of DevOps and DevSecOps standards that power continuous updates. More than a decade after our founding, with thousands of customers and millions of users globally, JFrog has become the \u201cDatabase of DevOps\u201d and the de-facto standard in release and update management.\",\"legalName\":\"Jfrog, Inc.\",\"numberOfEmployees\":{\"@type\":\"QuantitativeValue\",\"minValue\":\"1001\",\"maxValue\":\"5000\"}},{\"@type\":\"Person\",\"@id\":\"https:\/\/jfrog.com\/de\/#\/schema\/person\/b554ace14b37da5eed75bbfc7dd1c1af\",\"name\":\"giannit\",\"image\":{\"@type\":\"ImageObject\",\"inLanguage\":\"de-DE\",\"@id\":\"https:\/\/jfrog.com\/de\/#\/schema\/person\/image\/\",\"url\":\"https:\/\/secure.gravatar.com\/avatar\/fca3c188acf34ea94b72429eb16d496a8d0b50af476289bb5f51c8283e5c5b1c?s=96&d=mm&r=g\",\"contentUrl\":\"https:\/\/secure.gravatar.com\/avatar\/fca3c188acf34ea94b72429eb16d496a8d0b50af476289bb5f51c8283e5c5b1c?s=96&d=mm&r=g\",\"caption\":\"giannit\"}}]}<\/script>\n<!-- \/ Yoast SEO Premium plugin. -->","yoast_head_json":{"title":"5 Best Practices f\u00fcr den Aufbau von CI\/CD Pipelines f\u00fcr GoLang-Apps | JFrog","description":"Lernen Sie Techniken wie: Verwendung von Go-Modulen f\u00fcr Go-Pakete, Registries mit GOPROXY, Artefakt-Repositories, Build-Bereitstellung und mehr mit JFrog Artifactory.","robots":{"index":"index","follow":"follow","max-snippet":"max-snippet:-1","max-image-preview":"max-image-preview:large","max-video-preview":"max-video-preview:-1"},"canonical":"https:\/\/jfrog.com\/de\/wp-json\/wp\/v2\/posts\/81038","og_locale":"de_DE","og_type":"article","og_title":"5 Best Practices f\u00fcr GoLang CI\/CD-Pipelines","og_description":"Lernen Sie, wie Sie Go-Module, Artifactory-Registries und -Repositories und mehr verwenden, um schnelle, leistungsf\u00e4hige CI\/CD zu erstellen.","og_url":"https:\/\/jfrog.com\/de\/blog\/5-best-practices-for-golang-ci-cd\/","og_site_name":"JFrog","article_publisher":"https:\/\/www.facebook.com\/artifrog","article_published_time":"2021-07-24T11:55:28+00:00","article_modified_time":"2021-09-12T12:00:05+00:00","og_image":[{"url":"https:\/\/jfrog.com\/wp-content\/uploads\/2019\/07\/GlangCICDsocial.png"}],"author":"giannit","twitter_card":"summary_large_image","twitter_title":"5 Best Practices f\u00fcr GoLang CI\/CD-Pipelines","twitter_description":"Lernen Sie, wie Sie Go-Module, Artifactory-Registries und -Repositories und mehr verwenden, um schnelle, leistungsf\u00e4hige CI\/CD zu erstellen.","twitter_creator":"@jfrog","twitter_site":"@jfrog","twitter_misc":{"Written by":"giannit","Est. reading time":"9 minutes"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"Article","@id":"https:\/\/jfrog.com\/de\/blog\/5-best-practices-for-golang-ci-cd\/#article","isPartOf":{"@id":"https:\/\/jfrog.com\/de\/blog\/5-best-practices-for-golang-ci-cd\/"},"author":{"name":"giannit","@id":"https:\/\/jfrog.com\/de\/#\/schema\/person\/b554ace14b37da5eed75bbfc7dd1c1af"},"headline":"5 Best Practices f\u00fcr GoLang-CI\/CD","datePublished":"2021-07-24T11:55:28+00:00","dateModified":"2021-09-12T12:00:05+00:00","mainEntityOfPage":{"@id":"https:\/\/jfrog.com\/de\/blog\/5-best-practices-for-golang-ci-cd\/"},"wordCount":1652,"publisher":{"@id":"https:\/\/jfrog.com\/de\/#organization"},"image":{"@id":"https:\/\/jfrog.com\/de\/blog\/5-best-practices-for-golang-ci-cd\/#primaryimage"},"thumbnailUrl":"https:\/\/speedmedia2.jfrog.com\/08612fe1-9391-4cf3-ac1a-6dd49c36b276\/media.jfrog.com\/wp-content\/uploads\/2019\/07\/20130638\/GlangCICD_204x148.png","keywords":["CI\/CD","Continuous Delivery","CI","Go","Go-Module","Best Practices"],"articleSection":["Pakete","JFrog CLI","GoCenter","Artifactory"],"inLanguage":"de-DE"},{"@type":"WebPage","@id":"https:\/\/jfrog.com\/de\/blog\/5-best-practices-for-golang-ci-cd\/","url":"https:\/\/jfrog.com\/de\/blog\/5-best-practices-for-golang-ci-cd\/","name":"5 Best Practices f\u00fcr den Aufbau von CI\/CD Pipelines f\u00fcr GoLang-Apps | JFrog","isPartOf":{"@id":"https:\/\/jfrog.com\/de\/#website"},"primaryImageOfPage":{"@id":"https:\/\/jfrog.com\/de\/blog\/5-best-practices-for-golang-ci-cd\/#primaryimage"},"image":{"@id":"https:\/\/jfrog.com\/de\/blog\/5-best-practices-for-golang-ci-cd\/#primaryimage"},"thumbnailUrl":"https:\/\/speedmedia2.jfrog.com\/08612fe1-9391-4cf3-ac1a-6dd49c36b276\/media.jfrog.com\/wp-content\/uploads\/2019\/07\/20130638\/GlangCICD_204x148.png","datePublished":"2021-07-24T11:55:28+00:00","dateModified":"2021-09-12T12:00:05+00:00","description":"Lernen Sie Techniken wie: Verwendung von Go-Modulen f\u00fcr Go-Pakete, Registries mit GOPROXY, Artefakt-Repositories, Build-Bereitstellung und mehr mit JFrog Artifactory.","breadcrumb":{"@id":"https:\/\/jfrog.com\/de\/blog\/5-best-practices-for-golang-ci-cd\/#breadcrumb"},"inLanguage":"de-DE","potentialAction":[{"@type":"ReadAction","target":["https:\/\/jfrog.com\/de\/blog\/5-best-practices-for-golang-ci-cd\/"]}]},{"@type":"ImageObject","inLanguage":"de-DE","@id":"https:\/\/jfrog.com\/de\/blog\/5-best-practices-for-golang-ci-cd\/#primaryimage","url":"https:\/\/speedmedia2.jfrog.com\/08612fe1-9391-4cf3-ac1a-6dd49c36b276\/media.jfrog.com\/wp-content\/uploads\/2019\/07\/20130638\/GlangCICD_204x148.png","contentUrl":"https:\/\/speedmedia2.jfrog.com\/08612fe1-9391-4cf3-ac1a-6dd49c36b276\/media.jfrog.com\/wp-content\/uploads\/2019\/07\/20130638\/GlangCICD_204x148.png","width":204,"height":148,"caption":"Blog"},{"@type":"BreadcrumbList","@id":"https:\/\/jfrog.com\/de\/blog\/5-best-practices-for-golang-ci-cd\/#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Home","item":"https:\/\/jfrog.com\/de\/"},{"@type":"ListItem","position":2,"name":"5 Best Practices f\u00fcr GoLang-CI\/CD"}]},{"@type":"WebSite","@id":"https:\/\/jfrog.com\/de\/#website","url":"https:\/\/jfrog.com\/de\/","name":"JFrog","description":"Deliver Trusted Software Releases at Speed and Scale","publisher":{"@id":"https:\/\/jfrog.com\/de\/#organization"},"potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/jfrog.com\/de\/?s={search_term_string}"},"query-input":"required name=search_term_string"}],"inLanguage":"de-DE"},{"@type":"Organization","@id":"https:\/\/jfrog.com\/de\/#organization","name":"JFrog","url":"https:\/\/jfrog.com\/de\/","logo":{"@type":"ImageObject","inLanguage":"de-DE","@id":"https:\/\/jfrog.com\/de\/#\/schema\/logo\/image\/","url":"https:\/\/speedmedia2.jfrog.com\/08612fe1-9391-4cf3-ac1a-6dd49c36b276\/media.jfrog.com\/wp-content\/uploads\/2025\/05\/27095207\/Logo.svg","contentUrl":"https:\/\/speedmedia2.jfrog.com\/08612fe1-9391-4cf3-ac1a-6dd49c36b276\/media.jfrog.com\/wp-content\/uploads\/2025\/05\/27095207\/Logo.svg","width":74,"height":73,"caption":"JFrog"},"image":{"@id":"https:\/\/jfrog.com\/de\/#\/schema\/logo\/image\/"},"sameAs":["https:\/\/www.facebook.com\/artifrog","https:\/\/x.com\/jfrog","https:\/\/www.linkedin.com\/company\/455737","https:\/\/www.youtube.com\/channel\/UCh2hNg76zo3d1qQqTWIQxDg","https:\/\/www.wikidata.org\/wiki\/Q98608948"],"description":"We set out on our Liquid Software journey in 2008, with the mission to transform the way enterprises manage and release software updates. The world expects software to update continuously, securely, non-intrusively and without user intervention. This hyper-connected experience can only be enabled by automation with an end-to-end DevOps platform and a binary-centric focus. With this in mind, we\u2019ve developed the JFrog Platform, ushering in a new era of DevOps and DevSecOps standards that power continuous updates. More than a decade after our founding, with thousands of customers and millions of users globally, JFrog has become the \u201cDatabase of DevOps\u201d and the de-facto standard in release and update management.","legalName":"Jfrog, Inc.","numberOfEmployees":{"@type":"QuantitativeValue","minValue":"1001","maxValue":"5000"}},{"@type":"Person","@id":"https:\/\/jfrog.com\/de\/#\/schema\/person\/b554ace14b37da5eed75bbfc7dd1c1af","name":"giannit","image":{"@type":"ImageObject","inLanguage":"de-DE","@id":"https:\/\/jfrog.com\/de\/#\/schema\/person\/image\/","url":"https:\/\/secure.gravatar.com\/avatar\/fca3c188acf34ea94b72429eb16d496a8d0b50af476289bb5f51c8283e5c5b1c?s=96&d=mm&r=g","contentUrl":"https:\/\/secure.gravatar.com\/avatar\/fca3c188acf34ea94b72429eb16d496a8d0b50af476289bb5f51c8283e5c5b1c?s=96&d=mm&r=g","caption":"giannit"}}]}},"_links":{"self":[{"href":"https:\/\/jfrog.com\/de\/wp-json\/wp\/v2\/posts\/81038","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/jfrog.com\/de\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/jfrog.com\/de\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/jfrog.com\/de\/wp-json\/wp\/v2\/users\/140"}],"replies":[{"embeddable":true,"href":"https:\/\/jfrog.com\/de\/wp-json\/wp\/v2\/comments?post=81038"}],"version-history":[{"count":4,"href":"https:\/\/jfrog.com\/de\/wp-json\/wp\/v2\/posts\/81038\/revisions"}],"predecessor-version":[{"id":81050,"href":"https:\/\/jfrog.com\/de\/wp-json\/wp\/v2\/posts\/81038\/revisions\/81050"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/jfrog.com\/de\/wp-json\/wp\/v2\/media\/47309"}],"wp:attachment":[{"href":"https:\/\/jfrog.com\/de\/wp-json\/wp\/v2\/media?parent=81038"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/jfrog.com\/de\/wp-json\/wp\/v2\/categories?post=81038"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/jfrog.com\/de\/wp-json\/wp\/v2\/tags?post=81038"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}