go-tutorial

CASOON Tutorial

Go lernen, indem du einen echten Dienst baust.

Kein Syntax-Kurs, sondern Go für echte Projekte: In 16 Teilen entsteht upwatch, ein URL-Monitor mit HTTP-API, parallelen Checks, SQLite, Tests, Logging, Graceful Shutdown und einem einzelnen Binary zum Deployen. Für Entwickler, die aus C#, Java oder TypeScript kommen.

Go 1.26+nur Standardbibliothek + SQLiteMIT
upwatch
$ curl -sd '{"url":"https://example.com"}' \
    :8080/targets | jq -c '{id, url}'
{"id":1,"url":"https://example.com"}
$ curl -sd '{"url":"https://nope.invalid"}' \
    :8080/targets | jq -c '{id, url}'
{"id":2,"url":"https://nope.invalid"}
$ curl -s :8080/targets/1/results \
    | jq -c '.[0] | {status_code, duration_ms}'
{"status_code":200,"duration_ms":198}
$ curl -s :8080/targets/2/results | jq '.[0].up'
false
Teile, ein durchgehendes Projekt
16
direkte Abhängigkeit: der SQLite-Treiber, ohne cgo
1
statisches Linux-Binary inklusive Datenbank
12 MB
Zielplattformen aus einem Befehl: make build-all
4

Der Weg durch das Tutorial

Grundlagen

Die Sprache und ihre Denkweise – an Beispielen aus upwatch.

  1. Warum gibt es Go?upwatch starten und mit curl ausprobieren
  2. Toolchain und Modulego build, test, vet, Module und govulncheck
  3. Die Sprache, kompaktStructs, Slices, Maps, Interfaces, Generics
  4. Go-Denkweise statt OOP-DenkweiseKleine Interfaces, Composition, DI ohne Container
  5. FehlerbehandlungErrors wrappen, prüfen, an der Grenze übersetzen
  6. ConcurrencyDer Worker-Pool des Schedulers
  7. Context richtig verstehenAbbruch und Timeouts vom Request bis zur Datenbank

Die Anwendung

upwatch entsteht: API, Struktur, Datenbank, Tests, Betrieb.

  1. Eine HTTP-API mit net/httpDie JSON-API mit net/http und Middleware
  2. Projektstruktur und Architekturcmd/, internal/ und Packages, die tragen
  3. Datenbanken mit database/sqlSQLite, Transaktionen, Migrationen
  4. TestingTabellen-Tests, httptest, Fakes, synctest, Fuzzing
  5. Logging, Konfiguration, Observabilityslog, Konfiguration, Metriken, Graceful Shutdown

Produktion

Absichern, messen, ausliefern – und was Umsteiger falsch machen.

  1. SecurityTimeouts, Limits, SSRF-Schutz, govulncheck
  2. Performance und SpeicherBenchmarks, Escape Analysis, pprof
  3. DeploymentEin Binary, systemd, ein distroless Container
  4. Go Best Practices für UmsteigerMuster aus C#, Java, TS – und ihre Go-Form

Worum es geht

  1. Ein Projekt statt 16 Inseln

    Jedes Kapitel erklärt ein Stück von upwatch: Context am echten Request, Concurrency am echten Worker-Pool, Testing an den echten Tests. Kein Todo-Service.

  2. Go-Denkweise statt OOP-Import

    Kleine Interfaces beim Konsumenten, konkrete Structs, explizite Fehler, Dependency Injection ohne Container – und warum IUserService und BaseRepository hier nicht hingehören.

  3. Standardbibliothek zuerst

    net/http mit Routing-Patterns, log/slog, database/sql, expvar, pprof, testing/synctest. Frameworks werden eingeordnet, nicht vorausgesetzt.

  4. Bis in die Produktion

    Timeouts, SSRF-Schutz, govulncheck, Cross-Compilation, distroless Container und eine gehärtete systemd-Unit. Der Code im Repo ist getestet, auch mit dem Race Detector.

Loslegen

Du brauchst Go ab 1.26 und curl. Der Code ist fertig und getestet: Du startest upwatch in Teil 1 und lernst es danach Baustein für Baustein kennen – mit einem „Jetzt du“ in jedem Kapitel und Übungen in drei Stufen.

  1. Repository klonen und upwatch mit make run starten.
  2. Eine URL anlegen – der Scheduler prüft sie sofort und danach im Intervall.
  3. Mit Teil 1: Warum gibt es Go? beginnen.
Zur Dokumentation
TerminalShell
git clone https://github.com/casoon/go-tutorial
cd go-tutorial
make run            # go run ./cmd/upwatch on :8080

curl -s -d '{"url":"https://example.com"}' :8080/targets
curl -s :8080/targets/1/results