Go for Enterprise Services

Content

The course consists of the following topics and is tailored to the team’s architecture, libraries and platform for in-house sessions. We work throughout on a realistic service with an API contract, a messaging backend and deployment to Docker and Kubernetes.

– Go from a Java perspective:

• What Go deliberately leaves out: inheritance, exceptions, annotations, heavy frameworks
• Composition over inheritance, structs, methods and embedding
• Defining small interfaces at the consumer – implicit implementation
• Errors as values: wrapping, errors.Is and errors.As, sentinel and custom errors
• When Go, when Java: criteria for the team’s technology choice
• Hands-On: refactor typical Java-style code into idiomatic Go – Structuring projects and modules:
• Go modules, versioning and private modules in the enterprise
• Project layout: cmd/, internal/, packages by responsibility instead of by layer
• Monorepo or many repos, workspaces and dependencies
• Hands-On: set up a service project and split it into packages – REST services contract-first with OpenAPI:
• OpenAPI specification as the contract between teams
• Generating server and client code with oapi-codegen and go:generate
• net/http routing, handlers, request validation and JSON
• Swagger UI for documenting and trying out the API
• Hands-On: write the API contract, generate code and implement the service – Middleware and the request pipeline:
• Middleware chains for logging, authentication, tracing and recovery
• context.Context for timeouts, cancellation and request data
• Loading configuration: environment variables, files, defaults
• Hands-On: build your own middleware chain for the service – Messaging and asynchronous processing:
• Publishing and consuming events with a message queue (e.g. NATS, RabbitMQ or Kafka)
• Goroutines, channels and sync primitives in a service context
• Worker pools, backpressure, retries and idempotency
• Hands-On: the service publishes events, a consumer processes them – Internal libraries for many teams:
• Good library APIs: small surface, sensible defaults, functional options
• Typical candidates: configuration, LDAP access, logging, HTTP clients
• Versioning, compatibility and documentation with godoc
• Hands-On: extract an internal library and use it in the service – Testing and quality:
• Table-driven tests, subtests, httptest and test doubles without a mocking framework
• Integration tests with containers
• go vet, staticcheck, golangci-lint and the race detector in the pipeline
• Hands-On: cover the service and consumer with unit and integration tests – Operations and observability:
• Structured logging with log/slog, metrics and traces with OpenTelemetry
• Health checks, graceful shutdown and sensible timeouts
• Container images with multi-stage builds and deployment to Kubernetes
• Hands-On: run the service and message queue in the Labmachine’s Kubernetes cluster

The goal is not to get to know as many libraries as possible, but to write Go the way it is meant to be written: simple, explicit and readable – so that Go services in the enterprise become just as maintainable as the existing Java systems.

The actual course content may differ from the above depending on the trainer, delivery, duration and the composition of participants.