Die Kernbefehle von Go meistern: run, build, install und get

Go's Einfachheit und Effizienz liegen nicht nur im Design der Sprache, sondern auch in seinen leistungsstarken und intuitiven Kommandozeilenwerkzeugen. Für jeden Go-Entwickler ist ein solides Verständnis von go run, go build, go install und go get von grundlegender Bedeutung. Diese Befehle bilden das Rückgrat des Go-Entwicklungsworkflows, von der schnellen Prototypenerstellung bis zur Bereitstellung und Verwaltung von Abhängigkeiten. Lassen Sie uns jeden davon im Detail untersuchen, begleitet von praktischen Beispielen.

1. go run: Der schnelle Prototypenersteller

Der Befehl go run ist wohl der am häufigsten verwendete Befehl für Go-Entwickler, insbesondere in den frühen Phasen der Entwicklung und für schnelle Skripte. Er kompiliert und führt die angegebenen Go-Quelldateien aus, ohne eine ausführbare Datei auf der Festplatte im aktuellen Verzeichnis zu erstellen. Dies macht ihn unglaublich praktisch für schnelle Iterationen und Tests.

Wie es funktioniert: Wenn Sie go run ausführen, kompiliert Go intern den Quellcode in eine temporäre ausführbare Datei und führt diese dann aus. Nach Abschluss wird diese temporäre ausführbare Datei gelöscht.

Syntax:

go run [build flags] [packages]

Gängige Anwendungsfälle:

• Ausführen einfacher Skripte: Für schnelle einmalige Aufgaben oder zum Testen kleiner Codeausschnitte.
• Schnelle Prototypenerstellung: Wenn Sie die sofortige Ausgabe Ihrer Codeänderungen sehen möchten, ohne den Zwischenschritt der Erstellung einer Binärdatei.

Beispiel 1: Ausführen einer einzelnen Datei

Nehmen wir an, Sie haben eine Datei namens hello.go:

// hello.go
package main

import "fmt"

func main() {
    fmt.Println("Hello Go World!")
}

Um diese Datei auszuführen, führen Sie einfach aus:

go run hello.go

Ausgabe:

Hello Go World!

Beispiel 2: Ausführen mehrerer Dateien in einem Paket

Wenn Ihr main-Paket über mehrere Dateien aufgeteilt ist, kann go run auch dies handhaben. Angenommen, Sie haben main.go und util.go im selben Verzeichnis:

// main.go
package main

import "fmt"

func main() {
    fmt.Println("Ergebnis der Berechnung:", calculateCalculateSum(5, 3))
}

// util.go
package main

func calculateCalculateSum(a, b int) int {
    return a + b
}

Um dieses Programm auszuführen:

go run main.go util.go

Oder, idiomatischer, um das Hauptpaket im aktuellen Verzeichnis auszuführen:

go run .

Ausgabe:

Ergebnis der Berechnung: 8

Wichtiger Hinweis: Obwohl go run hervorragend für die Entwicklung geeignet ist, ist es für Bereitstellungsszenarien nicht geeignet, da es keine persistente ausführbare Datei erzeugt. Für die Bereitstellung sind go build oder go install die richtigen Wahlmöglichkeiten.

2. go build: Kompilieren für die Verteilung

Der Befehl go build wird verwendet, um Go-Pakete und Abhängigkeiten zu kompilieren. Im Gegensatz zu go run erstellt er eine ausführbare Binärdatei (oder ein Paketarchiv), die unabhängig verteilt und ausgeführt werden kann.

Wie es funktioniert: go build kompiliert den Go-Quellcode. Wenn es sich um ein main-Paket handelt, erstellt es eine ausführbare Datei. Wenn es sich um ein Bibliothekspaket handelt, speichert es typischerweise das kompilierte Paketarchiv (z. B. .a-Dateien) im Build-Cache (typischerweise GOCACHE), was nachfolgende Builds beschleunigt.

Syntax:

go build [build flags] [packages]

Gängige Anwendungsfälle:

• Erstellung ausführbarer Binärdateien: Für die Bereitstellung von Anwendungen.
• Kreuzkompilierung: Erzeugung von Binärdateien für verschiedene Betriebssysteme und Architekturen.
• Kompilierungsprüfung: Sicherstellen, dass Ihr Code kompiliert, ohne ihn tatsächlich auszuführen.

Beispiel 1: Erstellen einer einfachen ausführbaren Datei

Verwenden wir unser hello.go von zuvor:

// hello.go
package main

import "fmt"

func main() {
    fmt.Println("Hello Go World!")
}

Um eine ausführbare Datei zu erstellen:

go build hello.go

Dies erstellt eine ausführbare Datei namens hello (unter Linux/macOS) oder hello.exe (unter Windows) im aktuellen Verzeichnis. Sie können sie dann direkt ausführen:

./hello

Ausgabe:

Hello Go World!

Beispiel 2: Erstellen mit Ausgabenamen (-o)

Sie können den Namen der Ausführungsdatei mit dem Flag -o angeben:

go build -o myapp hello.go

Nun heißt die ausführbare Datei myapp.

./myapp

Ausgabe:

Hello Go World!

Beispiel 3: Kreuzkompilierung

Eine der leistungsstärksten Funktionen von Go ist die integrierte Unterstützung für die Kreuzkompilierung. Sie können leicht Binärdateien für verschiedene Zielplattformen (Betriebssystem und Architektur) erstellen, indem Sie die Umgebungsvariablen GOOS und GOARCH festlegen.

Um hello.go für Linux auf einer 64-Bit-ARM-Architektur (z. B. einem Raspberry Pi) von einem macOS-Rechner aus zu erstellen:

GOOS=linux GOARCH=arm64 go build -o hello_linux_arm64 hello.go

Dadurch wird eine ausführbare Datei hello_linux_arm64 erstellt, die auf einem Linux-ARM64-System ausgeführt werden kann.

Erstellen eines Moduls: Wenn Sie innerhalb eines Go-Moduls arbeiten, erstellt go build standardmäßig das Paket im aktuellen Verzeichnis, wenn keine Argumente angegeben werden.

# In Ihrem Modul-Stammverzeichnis, vorausgesetzt, main.go existiert
go build

Dies erstellt das Hauptpaket im aktuellen Verzeichnis und platziert die ausführbare Datei im aktuellen Verzeichnis.

3. go install: Installieren von Binärdateien und Paketen

Der Befehl go install ist go build ähnlich, mit einem entscheidenden Unterschied: Er platziert die kompilierte ausführbare Datei oder das Paketarchiv an einem Standardort in Ihrer Go-Umgebung, insbesondere in $GOPATH/bin (wenn $GOBIN nicht gesetzt ist) oder dem Pfad, der von der Umgebungsvariablen GOBIN angegeben wird. Dies macht ihn ideal für die Installation von Befehlszeilentools oder Bibliotheken, die Sie global im PATH Ihres Systems verfügbar haben möchten.

Wie es funktioniert: go install kompiliert zuerst das Paket. Wenn es sich um ein main-Paket handelt, verschiebt es die resultierende ausführbare Binärdatei dann in das GOBIN-Verzeichnis. Wenn es sich um ein Bibliothekspaket handelt, installiert es das kompilierte Paketarchiv in das Verzeichnis pkg innerhalb Ihres Go-Modul-Caches.

Syntax:

go install [build flags] [packages]

Gängige Anwendungsfälle:

• Installieren von Befehlszeilentools: Wenn Sie ein Go-Programm als Systembefehl verwenden möchten (z. B. golangci-lint, delve).
• Verwaltung globaler Dienstprogramme: Beibehaltung verschiedener Go-basierter Tools, die leicht zugänglich sind.
• Erstellen und Cachen von Abhängigkeiten: Für Bibliothekspakete erstellt und cacht go install diese für schnellere zukünftige Builds.

Beispiel 1: Installieren eines Befehlszeilentools

Erstellen wir ein einfaches Tool greeter.go:

// greeter.go
package main

import (
    "fmt"
    "os"
)

func main() {
    if len(os.Args) < 2 {
        fmt.Println("Nutzung: greeter <name>")
        return
    }
    name := os.Args[1]
    fmt.Printf("Grüße, %s!\n", name)
}

Um dieses Tool zu installieren:

go install greeter.go

Nach der Installation befindet sich die ausführbare Datei greeter in Ihrem $GOPATH/bin oder $GOBIN-Verzeichnis. Stellen Sie sicher, dass dieses Verzeichnis in der PATH-Umgebungsvariable Ihres Systems enthalten ist.

Jetzt können Sie es von überall in Ihrem Terminal ausführen:

greeter Alice

Ausgabe:

Grüße, Alice!

Beispiel 2: Installieren aus einem Remote-Repository (Go-Module)

Mit Go-Modulen ist go install der bevorzugte Weg, um eine ausführbare Datei aus einem externen Repository direkt in Ihr GOBIN zu installieren. Dies umgeht die Notwendigkeit, das Repository manuell zu klonen.

go install github.com/spf13/cobra@latest

Dieser Befehl ruft das cobra-Modul ab, kompiliert sein Hauptpaket und platziert die ausführbare Datei (wahrscheinlich cobra genannt) in Ihrem GOBIN-Verzeichnis. Das Suffix @latest weist Go an, die neueste stabile Version abzurufen. Sie können auch eine bestimmte Version (z. B. @v1.2.3) angeben.

Unterschied zwischen go build und go install:

• go build platziert die Executable im aktuellen Verzeichnis (oder wie von -o angegeben).
• go install platziert die Executable in $GOBIN (oder $GOPATH/bin).
• go install installiert auch kompilierte Pakete in den Build-Cache, wodurch nachfolgende go build-Befehle schneller werden, wenn sie von diesen Paketen abhängen.

4. go get: Verwaltung von Abhängigkeiten (Legacy und Modern)

Der Befehl go get hat sich mit der Einführung von Go-Modulen erheblich weiterentwickelt.

Vor Go-Modulen (GOPATH-Modus): Im alten GOPATH-Modus wurde go get hauptsächlich verwendet, um Pakete aus Remote-Repositories in Ihr $GOPATH/src-Verzeichnis herunterzuladen und zu installieren. Es verwaltete auch Abhängigkeiten, indem es sie rekursiv herunterlud.

Mit Go-Modulen (Moderner Ansatz): Mit Go-Modulen (eingeführt in Go 1.11, Standard seit Go 1.16) hat sich die Rolle von go get geändert. Seine Hauptfunktion besteht nun darin:

• Abhängigkeiten in Ihrer go.mod-Datei hinzuzufügen, zu aktualisieren oder herabzustufen.
• Ihre go.mod- und go.sum-Dateien zu synchronisieren.

Wie es funktioniert (Go-Module): Wenn Sie go get innerhalb eines Moduls ausführen, aktualisiert es Ihre go.mod- und go.sum-Dateien, um die gewünschten Abhängigkeitsversionen widerzuspiegeln. Anschließend ruft es die erforderlichen Module in Ihren Modul-Cache ab (normalerweise $GOPATH/pkg/mod). Nachfolgende go build, go run oder go test-Befehle verwenden diese gecachten Abhängigkeiten automatisch.

Syntax:

go get [build flags] [packages]

Gängige Anwendungsfälle (Go-Module):

• Hinzufügen einer neuen Abhängigkeit: Wenn Sie ein neues externes Paket verwenden möchten.
• Aktualisieren von Abhängigkeiten: Um die neuesten kompatiblen Versionen Ihrer vorhandenen Pakete zu erhalten.
• Herabstufen von Abhängigkeiten: Um zu einer älteren Version zurückzukehren.
• Bereinigen ungenutzter Abhängigkeiten: Dies wird jedoch typischerweise von go mod tidy gehandhabt.

Beispiel 1: Hinzufügen einer neuen Abhängigkeit

Nehmen wir an, Sie haben ein Go-Modul initialisiert:

mkdir mymodule
cd mymodule
go mod init mymodule

Erstellen wir nun eine main.go, die eine externe Bibliothek verwendet, z. B. rsc.io/quote:

// main.go
package main

import (
    "fmt"
    "rsc.io/quote" // Diese Abhängigkeit ist noch nicht in go.mod
)

func main() {
    fmt.Println(quote.Go())
}

Wenn Sie versuchen, go run main.go oder go build auszuführen, erkennt Go die fehlende Abhängigkeit und fordert Sie auf, go mod tidy auszuführen oder versucht automatisch, sie mit go get abzurufen.

Um sie explizit hinzuzufügen (und abzurufen):

go get rsc.io/quote

Nach diesem Befehl wird Ihre go.mod-Datei aktualisiert und sieht ungefähr so aus:

module mymodule

go 1.22

require rsc.io/quote v1.5.0 // oder eine ähnliche Version

Und eine go.sum-Datei wird mit kryptografischen Prüfsummen erstellt/aktualisiert.

Jetzt können Sie Ihr Programm ausführen:

go run main.go

Ausgabe:

Don't communicate by passing memory, share memory by communicating.

Beispiel 2: Aktualisieren einer Abhängigkeit

Um eine vorhandene Abhängigkeit auf ihre neueste kompatible Version zu aktualisieren:

go get rsc.io/quote@latest

Dadurch werden die go.mod- und go.sum-Dateien aktualisiert, um auf die neueste stabile Veröffentlichung zu verweisen.

Beispiel 3: Herabstufen oder Angeben einer Version

Wenn Sie eine bestimmte Version benötigen:

go get rsc.io/quote@v1.5.2

Hinweis zu go get und go install: Wie bereits erwähnt, ist go install jetzt der bevorzugte Weg, um ein Befehlszeilentool zu "holen und installieren". Während go get dies früher konnte (insbesondere im GOPATH-Modus), ist go install weniger mehrdeutig und besser in das Modulsystem für die Tool-Installation integriert.

Zum Beispiel, um delve (Go-Debugger) zu installieren:

go install github.com/go-delve/delve/cmd/dlv@latest

Dies wird im Allgemeinen gegenüber go get github.com/go-delve/delve/cmd/dlv bevorzugt.

Fazit

Die Befehle go run, go build, go install und go get sind die Säulen des Go-Entwicklungswerkzeugkastens.

• Verwenden Sie go run für schnelle Ausführung und Entwicklungsiterationen.
• Verwenden Sie go build, um verteilbare ausführbare Dateien für Ihre Anwendungen zu erstellen.
• Verwenden Sie go install, um Go-Programme als systemweite Tools zu installieren oder um Paketbibliotheken zu cachen.
• Verwenden Sie go get (innerhalb von Go-Modulen), um die Abhängigkeiten Ihres Projekts zu verwalten und korrekte Versionen sowie reproduzierbare Builds sicherzustellen.

Die Beherrschung dieser Befehle ermöglicht es Go-Entwicklern, ihre Projekte effizient zu verwalten, von der ersten Codezeile bis zur Bereitstellung robuster Anwendungen. Sie verkörpern Go's Philosophie der Einfachheit und Effizienz und bieten leistungsstarke Funktionalität durch klare und prägnante Befehle.