Zum Inhalt springen
Trainingslager IT-Trainingslager

Tag 0: Das Trainingsgelände

Ziel: Toolchain, Editor und Linter einrichten und das erste Tool hallo mit eingebauter Version bauen · Dauer: ca. 60 min · Voraussetzung: keine

Briefing

  • Go ist eine einzige Toolchain: go build, go run, go test, go vet, go fmt, go doc – alles im Kommando go.
  • Ein Modul (go.mod) ist dein Projekt; jedes Tool in diesem Buch ist ein eigenes Modul example.com/<tool>.
  • Ein Programm ist package main mit func main(). Das Ergebnis ist ein statisches Binary – kein Interpreter, kein venv.
  • Die Version setzt der Build per -ldflags "-X main.version=…", nicht der Code.
  • Qualität kommt von Werkzeugen: gofmt, go vet, golangci-lint.
 main.go ──go build──► bin/hallo (ein Binary, ~2 MB)
    ▲                       │
 -ldflags "-X main.version=0.1.0"   ./bin/hallo -version ─► hallo 0.1.0

Drill 1: Toolchain prüfen

go version
go env GOVERSION GOOS GOARCH

Erwartet:

go version go1.26.9 darwin/arm64
go1.26.9
darwin
arm64

Warum? GOOS/GOARCH bestimmen, wofür gebaut wird – das nutzt du an Tag 14 für Cross-Compiles. Deine Projekte liegen, wo du willst; go env GOPATH (meist ~/go) ist nur noch Cache und Ablage für go install.

Tipp: Zeigt go version etwas Älteres als 1.26: brew upgrade go. Steht in einem go.mod eine neuere Version, lädt Go die passende Toolchain selbst nach (GOTOOLCHAIN=auto, der Default).

Fortschritt speichern? Kostenlos registrieren

Drill 2: Editor mit gopls

Jeder ernsthafte Go-Editor spricht mit gopls, dem offiziellen Language Server: Autovervollständigung, Springen zur Definition, Umbenennen, Fehler beim Tippen.

go install golang.org/x/tools/[email protected]
gopls version

Erwartet:

golang.org/x/tools/gopls v0.23.0

In VS Code installierst du die Erweiterung „Go” (vom Go-Team); sie findet gopls selbst. GoLand bringt eine eigene Engine mit und braucht gopls nicht.

Tipp: Liegt ~/go/bin nicht im PATH, findet die Shell gopls nicht. Der Editor schon – er fragt go env GOPATH.

Fortschritt speichern? Kostenlos registrieren

Drill 3: Modul anlegen

mkdir -p ~/go-lab/tag00-hallo && cd ~/go-lab/tag00-hallo
go mod init example.com/hallo
cat go.mod

Erwartet:

go: creating new go.mod: module example.com/hallo
module example.com/hallo

go 1.26.9

Warum? Der Modulpfad ist der Import-Präfix für alle Pakete im Projekt. example.com/… ist reserviert und kollidiert nie mit echten Repos; für echte Projekte nimmst du den Repo-Pfad, z. B. github.com/<user>/hallo.

Fortschritt speichern? Kostenlos registrieren

Drill 4: Das erste Programm

mkdir -p cmd/hallo
cat > cmd/hallo/main.go <<'EOF'
// hallo begrüßt dich und verrät seine Version.
// Tag 0 aus "Go zum Anfassen".
package main

import (
    "flag"
    "fmt"
    "os"
    "runtime"
)

// version setzt der Build per -ldflags "-X main.version=...".
var version = "dev"

func main() {
    name := flag.String("name", "Welt", "wen hallo begrüßt")
    showVersion := flag.Bool("version", false, "Version ausgeben und beenden")
    flag.Parse()

    if *showVersion {
        fmt.Printf("hallo %s (%s %s/%s)\n",
            version, runtime.Version(), runtime.GOOS, runtime.GOARCH)
        return
    }
    if *name == "" {
        fmt.Fprintln(os.Stderr, "hallo: -name darf nicht leer sein")
        os.Exit(2)
    }
    fmt.Printf("Hallo, %s!\n", *name)
}
EOF
go run ./cmd/hallo
go run ./cmd/hallo -name Thomas

Erwartet:

Hallo, Welt!
Hallo, Thomas!

Warum? flag.String liefert einen Pointer (*string); erst flag.Parse() füllt ihn, *name liest den Wert. Großgeschriebene Namen wie fmt.Printf sind exportiert, kleingeschriebene wie version nur im eigenen Paket sichtbar.

Fortschritt speichern? Kostenlos registrieren

Drill 5: Flags, Hilfe und Exit-Codes

Gebaute Binaries verhalten sich wie jedes Unix-Tool. Bau eins und prüf die Exit-Codes:

go build -o bin/hallo ./cmd/hallo
./bin/hallo -h; echo "exit=$?"
./bin/hallo -name ""; echo "exit=$?"
go run ./cmd/hallo -name ""; echo "exit=$?"

Erwartet:

Usage of ./bin/hallo:
  -name string
        wen hallo begrüßt (default "Welt")
  -version
        Version ausgeben und beenden
exit=0
hallo: -name darf nicht leer sein
exit=2
hallo: -name darf nicht leer sein
exit status 2
exit=1

Warum? Die Hilfe erzeugt das Paket flag aus deinen Definitionen. go run meldet den Exit-Code nur als Text und endet selbst mit 1 – für Skripte und CI immer das gebaute Binary prüfen. Konvention in diesem Buch: 0 = ok, 1 = Fehler bei der Arbeit, 2 = falscher Aufruf.

Fortschritt speichern? Kostenlos registrieren

Drill 6: Version per -ldflags

./bin/hallo -version
go build -ldflags "-X main.version=0.1.0" -o bin/hallo ./cmd/hallo
./bin/hallo -version
ls -lh bin/hallo | awk '{print $5}'
go build -ldflags "-s -w -X main.version=0.1.0" -o bin/hallo ./cmd/hallo
ls -lh bin/hallo | awk '{print $5}'
go version -m bin/hallo | head -6

Erwartet:

hallo dev (go1.26.9 darwin/arm64)
hallo 0.1.0 (go1.26.9 darwin/arm64)
2,5M
1,7M
bin/hallo: go1.26.9
    path    example.com/hallo/cmd/hallo
    mod example.com/hallo   (devel)
    build   -buildmode=exe
    build   -compiler=gc
    build   -ldflags="-s -w -X main.version=0.1.0"

Warum? -X paket.variable=wert überschreibt eine String-Variable beim Linken – der Code bleibt unverändert. -s -w entfernt Symbol- und Debug-Tabellen (kleiner, aber schlechter zu debuggen). go version -m liest die eingebetteten Build-Infos aus jedem Go-Binary – praktisch, wenn ein Kunde fragt „womit wurde das gebaut?“.

Fortschritt speichern? Kostenlos registrieren

Drill 7: Qualitätskontrolle

Erst die eingebauten Werkzeuge, dann der Linter. Bau einen Fehler ein, den der Compiler nicht findet:

perl -pi -e 's/"Hallo, %s!\\n"/"Hallo, %d!\\n"/' cmd/hallo/main.go
go build ./... && echo "kompiliert trotzdem"
go vet ./...
perl -pi -e 's/"Hallo, %d!\\n"/"Hallo, %s!\\n"/' cmd/hallo/main.go
go vet ./... && gofmt -l . && echo "sauber"

Erwartet:

kompiliert trotzdem
cmd/hallo/main.go:29:21: fmt.Printf format %d has arg *name of wrong type string
sauber

Für golangci-lint legst du ein kleines Wrapper-Skript an. go run …@version baut den Linter in fester Version in den Go-Cache – keine globale Installation, und alle Tage nutzen dieselbe Version:

mkdir -p ~/go-lab/bin
cat > ~/go-lab/bin/lint <<'EOF'
#!/usr/bin/env bash
# golangci-lint in fester Version – ohne globale Installation
exec go run github.com/golangci/golangci-lint/v2/cmd/[email protected] "$@"
EOF
chmod +x ~/go-lab/bin/lint
~/go-lab/bin/lint version
~/go-lab/bin/lint run ./...
go fix -diff ./... && echo "nichts zu modernisieren"

Erwartet (der erste Aufruf baut ca. 1–2 Minuten, gekürzt):

golangci-lint has version 2.14.0 built with go1.26.9 from (unknown, ...)
0 issues.
nichts zu modernisieren

Warum? gofmt -l listet unformatierte Dateien – leer heißt gut; dein Editor formatiert beim Speichern. golangci-lint bündelt govet, errcheck, staticcheck, unused und ineffassign (Standard-Set). go fix bringt seit Go 1.26 „Modernizer” mit, die alten Code auf aktuelle Sprachmittel heben.

Fortschritt speichern? Kostenlos registrieren

Drill 8: Doku ohne Browser

Die Standardbibliothek ist groß und gut dokumentiert – direkt im Terminal:

go doc flag.String
go doc -short os | grep -E 'func (Exit|Getenv)\('
go list -f '{{.ImportPath}} {{.Imports}}' ./cmd/hallo
go list std | wc -l

Erwartet:

package flag // import "flag"

func String(name string, value string, usage string) *string
    String defines a string flag with specified name, default value, and usage
    string. The return value is the address of a string variable that stores the
    value of the flag.

func Exit(code int)
func Getenv(key string) string
example.com/hallo/cmd/hallo [flag fmt os runtime]
     360

Warum? Rund 360 Pakete Standardbibliothek decken HTTP, JSON, Krypto, Tests und Logging ab – deshalb kommen die Tools in diesem Buch mit wenigen Abhängigkeiten aus. go doc funktioniert genauso für deine eigenen Pakete (Tag 2).

Zum Einordnen, was du aus Bash und Python kennst:

Aufgabe Bash Python Go
Argumente getopts argparse flag (Tag 5: cobra)
Exit-Code exit 2 sys.exit(2) os.Exit(2)
Umgebung $HOME os.environ os.Getenv("HOME")
Ausliefern Skript + Tools venv/pipx ein Binary

Fortschritt speichern? Kostenlos registrieren

Drill 9: Das Tool ist fertig

cd ~/go-lab/tag00-hallo
go build -ldflags "-s -w -X main.version=0.1.0" -o bin/hallo ./cmd/hallo
./bin/hallo -name "Platform-Team"
./bin/hallo -version

Erwartet:

Hallo, Platform-Team!
hallo 0.1.0 (go1.26.9 darwin/arm64)

Dein Modul sieht jetzt so aus:

tag00-hallo/
├── bin/hallo
├── cmd/hallo/main.go
└── go.mod

Den fertigen Code jedes Tages gibt es zum Vergleichen im Begleitcode auf GitHub. Hol ihn jetzt; erst tippst du selbst, dann siehst du nach:

git clone https://github.com/thomaszachmann/go-zum-anfassen.git ~/go-zum-anfassen
ls -1 ~/go-zum-anfassen/tag00-hallo

Erwartet:

Cloning into '…/go-zum-anfassen'...
cmd
go.mod

Die Ordner heißen wie deine in ~/go-lab. Nach Tag 1 zeigt etwa diff -r ~/go-lab/tag01-wc ~/go-zum-anfassen/tag01-wc, wo du abweichst.

Fortschritt speichern? Kostenlos registrieren

Kontrollpunkt

#!/usr/bin/env bash
check() { if eval "$2" >/dev/null 2>&1; then echo "✔ $1"; else echo "✘ $1"; fi; }
cd ~/go-lab/tag00-hallo
check "Go 1.26 aktiv" "go version | grep -q 'go1\.26'"
check "gofmt sauber" "test -z \"\$(gofmt -l .)\""
check "go vet" "go vet ./..."
check "golangci-lint" "~/go-lab/bin/lint run ./..."
check "Version per ldflags" "./bin/hallo -version | grep -q '^hallo 0.1.0'"
check "Exit-Code 2 bei leerem Namen" "./bin/hallo -name ''; test \$? -eq 2"

Erwartet:

✔ Go 1.26 aktiv
✔ gofmt sauber
✔ go vet
✔ golangci-lint
✔ Version per ldflags
✔ Exit-Code 2 bei leerem Namen

Challenge

Ohne -ldflags soll hallo -version nicht „dev” zeigen, sondern die Version aus Git: den Tag, falls vorhanden, sonst eine Pseudo-Version mit Commit. main.go bleibt dabei unverändert.

Hinweis: Go bettet seit Go 1.18 VCS-Infos ins Binary ein, und seit Go 1.24 steht in debug.ReadBuildInfo().Main.Version eine Version aus Git; eine init()-Funktion läuft vor main.

Lösung

cat > cmd/hallo/buildinfo.go <<'EOF'
package main

import "runtime/debug"

// init läuft vor main: ohne -ldflags nehmen wir die Version aus Git.
func init() {
    if version != "dev" {
        return
    }
    if bi, ok := debug.ReadBuildInfo(); ok && bi.Main.Version != "(devel)" {
        version = bi.Main.Version
    }
}
EOF
git init -q && printf 'bin/\n' > .gitignore
git add . && git commit -qm "hallo"
go build -o bin/hallo ./cmd/hallo && ./bin/hallo -version
git tag v0.2.0
go build -o bin/hallo ./cmd/hallo && ./bin/hallo -version
echo "// geändert" >> cmd/hallo/main.go
go build -o bin/hallo ./cmd/hallo && ./bin/hallo -version
git checkout -q cmd/hallo/main.go

Erwartet (Zeitstempel und Hash weichen ab):

hallo v0.0.0-20261010064452-1ace3d653a29 (go1.26.9 darwin/arm64)
hallo v0.2.0 (go1.26.9 darwin/arm64)
hallo v0.2.0+dirty (go1.26.9 darwin/arm64)

Ein uncommitteter Stand bekommt +dirty – genau das willst du in Produktion nie sehen. -ldflags hat weiterhin Vorrang, weil init dann früh aussteigt. Mit go run gibt es keine VCS-Infos, dort bleibt es bei „dev”.

Fortschritt speichern? Kostenlos registrieren

Enterprise-Notiz

  • Go-Version im Team festnageln: go- und toolchain-Zeile in go.mod, dieselbe Version in CI (Tag 14) – sonst baut jeder mit etwas anderem.
  • Proxy und Prüfsummen: Unternehmen setzen oft GOPROXY auf einen internen Proxy (Artifactory, Athens) und GOPRIVATE für interne Repos; GOSUMDB bleibt für öffentliche Module an.
  • Linter-Version und .golangci.yml gehören ins Repo; CI bricht bei Findings ab, lokal läuft derselbe Aufruf.
  • Version immer aus dem Build (Git-Tag → -ldflags oder Build-Info), nie von Hand im Code pflegen.
  • Kein go install …@latest auf Build-Servern: Versionen pinnen, damit Builds reproduzierbar bleiben.