Complete Microservices with Go

Explore how monoliths differ from microservices, how the strangler fig pattern enables gradual migration, and how redundancy, scalability, and team organization drive adoption.

Explore effective go error handling using a truck distribution center example, returning and wrapping errors with fmt.Errorf, performing explicit if err != nil checks, and adding context for debugging.

Explore using interfaces to write flexible, testable Go code by relying on abstractions rather than concrete implementations, including a truck interface, diesel and electric trucks.

Practice Go testing by creating test files, initializing modules, and running tests to verify truck loading. See how interfaces enable interchangeable components and how mocks support testing without a database.

Learn how pointers reference memory locations to mutate data in place in Go, using addresses, dereferencing, and pointer receivers, while handling nil pointers.

Explore goroutines, Go's lightweight threads, to write concurrent software by processing multiple trucks simultaneously. Learn to synchronize with wait groups to ensure all goroutines finish before continuing.

Study how Go context carries deadlines and cancellation signals across api boundaries to manage long-running operations in microservices. Use middleware to inject user metadata and implement timeouts.

Explore Go concurrency with goroutines and channels to safely pass errors and data, use buffered channels to prevent deadlocks, and implement a worker pool pattern for microservices.

Guides Windows users to set up the course environment with PowerShell or WSL, Docker for Windows, minikube, tilt, go, kubectl, git, and make. Run the project with tilt locally.

Explore the current microservice code base onboarding, folder structure, and multi-environment infrastructure, and learn practical principles from clean and hexagonal architectures to shape services.

Apply layered architecture to separate transport, service, and storage, and use the repository pattern to abstract data access with implementations like SQL and Mongo.

Apply clean layered architecture by bootstrapping a new trip service with gRPC, RabbitMQ, and HTTP transports, using the provided create service script and modular internal structure.

Define the trip and fare domain in Go, and implement a repository pattern with an in-memory repository and a service layer for a modular microservice.

Use the api gateway as a single entry point for all clients, shielding internal services and routing requests to the correct backend while supporting rest or GraphQL.

Implement the get routes method to fetch an optimal trip preview by calling the external OSRM API. Return distance, duration, and GeoJSON geometry for map rendering.

Prepare for external api failures by implementing three fallback strategies: use the public api, run your own hosted api, or return mock data, ensuring a resilient, responsive app.

Learn to use websockets to build real-time, two-way communication between front-end clients and a microservices backend, enabling live updates for riders and drivers via events, gRPC, and message brokers.

Explore why gRPC improves service-to-service communication over HTTP using protocol buffers, code generation, and strict contracts, and learn to set up and automate the workflow in a Go microservices project.

Define proto messages and RPC services in a dedicated proto folder, then automatically generate type-safe Go and gRPC code with the protoc compiler.

Define the trip proto, generate code from proto definitions, and implement a gRPC client and server (gateway and trip service) to handle routing, geometry, and ride options.

Implement a reusable trip service client for the API gateway using a gRPC client package. Provide a constructor that dials the trip service URL from env trip_service_url with defaults.

Explore how Kubernetes runs behind the scenes with minikube, kubectl, and tilt, observe pods, services, and replicas, and learn why stateless rest APIs scale easily.

Explore Kubernetes components, from the control plane to the data plane, and see how the API server, scheduler, etcd, kubelet, and control manager coordinate pods, workloads, and nodes.

Read and write Kubernetes deployment and service yaml to prepare production deployment, adjust replicas and labels. Explore config maps and secrets.

Deploy a production-ready microservices app on Google Cloud Kubernetes Engine by building and pushing Docker images to artifact registry, creating a cluster, and deploying the API gateway and trip service.

Bootstraps a new driver service over gRPC, scaffolding a flat structure, updating proto definitions, and wiring a gRPC handler to register and unregister drivers, with Kubernetes deployments for local development.

Fix a common Tiltfile compilation issue by setting the driver service as the entry point, removing main.go from the build, and ensuring the gRPC handler compiles in the flat structure.

Learn asynchronous communication and the reasons for decoupled microservices with RabbitMQ as a reliable broker. Build an event-driven trip scheduling flow using queues, producers, consumers, and fault-tolerant message delivery.

Set up rabbitmq on kubernetes with a deployment that includes the management plugin and ui, then secure credentials with kubernetes secrets and connect via port forwards.

Connect Go microservices to RabbitMQ using the official Go SDK, configure the URI via environment variables and secrets, and implement a reusable RabbitMQ wrapper with a constructor and close method.

Learn to synchronize microservice deployments with rabbitmq by adding readiness probes and service dependencies, ensuring driver, trip, and gateway wait for rabbitmq to be ready in development and production.

Publish the first message by creating a RabbitMQ channel and queue, introducing a trip event publisher, and testing the flow via the gRPC handler and RabbitMQ UI.

Learn how to achieve message and queue durability in RabbitMQ by enabling durable queues and persistent messages, then deploy with a statefulset and volumes to survive restarts.

Explore fair dispatch with rabbitmq, preventing busy services from delaying others by deferring message delivery until acknowledgment and applying a prefetch count for better load balance.

Discover how the publish/subscribe pattern uses exchanges and routing keys to decouple producers from queues and route messages to multiple services with bindings.