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.

Design microservices as small, autonomous, and loosely coupled units, focusing on high cohesion, low coupling, and practical boundaries to manage domain coupling and service communication.

Explore how microservices communicate through synchronous and asynchronous styles, contrasting blocking HTTP/GRPC calls with non-blocking, message-driven flows via brokers like RabbitMQ and Kafka, and a hybrid gateway approach.

Define the architecture for a ride-hailing microservices system by identifying core services, boundaries, and interactions among the driver, trip, rider, and payment services, including matchmaking and asynchronous messaging.

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.

Explore maps as key-value stores with unique keys, fast O(1) lookups in go, and note concurrency caveats like race conditions with multiple goroutines.

learn how to prevent data races in go maps when multiple goroutines access them by applying read-write mutexes, embedding mutexes in structs, and using lock and unlock patterns.

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.

Set up your Mac or Linux environment for the course by installing Go, Docker for desktop, minikube, and tilt, then run tilt up to start the project.

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.

Learn how Tilt and Kubernetes streamline local microservices development with live code reload, centralized logs, and automated deployments via Minikube, while comparing Tilt to Skaffold.

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.

Build and improve an http server in Go by swapping the default mux for a dedicated router, adding a /trip/preview post endpoint, and handling json payloads with proper error handling.

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.

master graceful shutdown for Go-based microservices, using a goroutine, context with timeout, and signal handling to finish in-flight requests before termination.

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.

Implement WebSocket connections in the gateway by creating drivers and riders handlers with gorilla websocket, upgrading HTTP requests, and sending the initial driver profile.

Apply CORS middleware in Go to enable cross-origin requests, handle preflight options, and set Access-Control-Allow-Origin, methods, and headers for robust front-end to back-end communication.

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.

Deprecate the http server and implement a gRPC server for the trip service, configure port 9000, create a TCP listener, and enable graceful shutdown with the gRPC server.

Implement a gRPC preview trip handler that bridges the gRPC server with business logic in a clean architecture, wiring dependencies and converting protobuf requests to internal domain types.

Implement dot two proto conversions to map internal trip types to protobuf for the preview trip handler's coordinates, and migrate transport to gRPC in a Go microservices setup.

Learn how ride fares are estimated and secured in a microservices architecture using gRPC, with base packages, distance-based pricing, and fare IDs to prevent price manipulation.

Learn to implement ride pricing estimation in a Go microservice, calculating route-based fares from base packages, distance and time, with configurable pricing and in-memory storage.

Implement the create trip flow in the trip service by synchronously fetching and validating the fare, then publish a trip.event.created via RabbitMQ to trigger the driver service.

Master Kubernetes basics through a hands-on crash course, learning the building blocks and how it autoscales, handles load balancing, and self-heals a microservices app running in containers.

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.

Apply final adjustments by adding the root property to the right fare model, enabling driver route visualization and preparing create trip events for the next module.

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.

Consume messages from RabbitMQ in the driver service using a reusable trip consumer, a background listener, and a pluggable message handler to enable durable, asynchronous processing.

Explore how RabbitMQ distributes messages across multiple service instances with round-robin delivery. Learn to implement manual acknowledgment to prevent lost work and to handle dead-letter queues.

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.

Implement the exchange and topics flow in a Go microservices setup by defining shared AMQP contracts, creating a topic exchange, and binding queues to routing keys.

Publish and consume json messages in a Go microservices setup by marshaling and unmarshalling trip data, using an AMQP message contract and protobuf payloads for structured, interoperable data.

Finds a suitable driver by matching the trip package to registered drivers, then publishes either no drivers found or a driver command trip request via RabbitMQ and notifies the driver.