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.

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.

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.

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.

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.

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.

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.

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.

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.