Building a Cloud Native E-Commerce Demo: 11 Polyglot Microservices on GKE

If you've ever wanted to see how a real world microservices architecture works on Kubernetes, but didn't want to build one yourself from scratch, Google Cloud Platform has you covered. Their microservices-demo repository gives you a complete, cloud native e-commerce application with 11 different services, each written in a different language.

This isn't just a toy hello world app. It's a production style demo that shows how a modern retail system handles cart, checkout, payments, recommendations, and more. And because all the services are containerized, you can run it on any Kubernetes cluster, not just GKE.

What It Does

The demo is an online boutique that sells (fake) merchandise. A user can browse products, view recommendations, add items to a cart, and check out. Under the hood, it's a mesh of services that communicate over gRPC and HTTP:

• frontend (Go) — the web UI
• cartservice (C#) — shopping cart persistence
• productcatalogservice (Go) — product info
• currencyservice (Node.js) — currency conversion
• paymentservice (Node.js) — credit card processing
• shippingservice (Go) — shipping cost calculation
• emailservice (Python) — sending order confirmation emails
• checkoutservice (Go) — coordinating the checkout flow
• recommendationservice (Python) — related product suggestions
• adservice (Java) — text ads based on context
• loadgenerator (Python) — simulates real user traffic

Each service is independent. They all have their own Dockerfiles, tests, and deployment configs. The repo also includes OpenTelemetry tracing, health checks, and sample metrics.

Why It's Cool

What makes this stand out isn't just that it's a working e-commerce app. It's the way it's built for real world patterns.

Polyglot by design. Each team could own a service in whatever language they prefer, and it still works. That's exactly how many organizations end up operating. Seeing Go, C#, Node.js, Python, and Java coexist in one project is a great example of why microservices are useful when you need different strengths from different tech stacks.

Production ready structure. Every service has its own deployment manifest, health probes, resource limits, and readiness checks. The frontend uses feature flags. The load generator simulates realistic traffic patterns. This isn't a demo that just prints "hello world". It's designed to show you how to run a real service mesh with Istio or service mesh interface (SMI) controllers.

Observability built in. Traces, logs, and metrics are wired up out of the box. You can see exactly how a request flows from the frontend through the checkout service to the payment service. That's incredibly useful for debugging or for learning distributed tracing.

Easily extendable. Want to add custom logic? You can swap any service with your own implementation. The gRPC protos are all there. The interfaces are clean. It's a great starting point for building your own microservices architecture or teaching new team members the ropes.

How to Try It

The quickest way to get started is to deploy it on a Kubernetes cluster. The repo has clear instructions, but here's the tl;dr:

1. Make sure you have kubectl and skaffold installed.
2. Clone the repo: git clone https://github.com/GoogleCloudPlatform/microservices-demo
3. Run skaffold run in the root directory. Skaffold will build the images (or pull them from the repo) and deploy everything to your current Kubernetes context.

If you want to see it in action on GKE, Google Cloud has a one click deployment option that sets up a cluster and installs the entire app for you. The README links to that as well.

To explore the code, open the service folders. Each one has its own README explaining how it works. The protos/ directory holds the shared gRPC definitions.

Final Thoughts

This project is a gem for anyone learning Kubernetes, microservices, or cloud native development. It's realistic enough to be useful, but simple enough to wrap your head around in a weekend. Whether you're building a new service mesh at work, experimenting with different languages, or just want to see what a properly structured demo looks like, give it a spin.

And if you ever need to show someone what "cloud native" actually means in practice, this repo does a better job than any slide deck ever could.

Brought to you by @githubprojects