Build Google’s Microservices Demo Shop on a Raspberry Pi or Tiny VM

Matching YouTube: https://youtu.be/cMGQCKA8qwU

Original source: https://github.com/GoogleCloudPlatform/microservices-demo

Modern applications rarely live inside a single monolithic server anymore.

Instead, they are built from dozens — sometimes hundreds — of tiny services working together. One service handles payments. Another manages products. Another deals with recommendations, shipping, email, or advertisements.

This architecture is called microservices, and one of the best ways to learn it is through Google’s fantastic demo application:

Google Cloud Microservices Demo Attachment.tiff

Google designed this project for Google cloud platforms like Kubernetes and GKE, but the exciting part is this:

You can run the entire thing at home on:

A Raspberry Pi 5
A small Linux VM on your laptop
Or an old mini PC sitting under your desk

And suddenly, you have your own miniature cloud-native application stack running locally.

Why This Demo Is So Cool

The application itself is an online shop called “Online Boutique”.

At first glance, it looks like a simple ecommerce website.

But behind the scenes, dozens of containers are communicating together:

Product catalog
Shopping cart
Checkout
Currency conversion
Recommendations
Email notifications
Advertising
Shipping
Redis caching

Even better, the services are intentionally written in different languages to demonstrate real-world integration.

This is exactly what happens inside modern companies.

One team might use:

Go
Python
Java
Node.js
C#
Rust

Containers make all of them work together cleanly.

That’s the magic of microservices.

Why Run It Locally?

Google’s documentation focuses heavily on Kubernetes and cloud infrastructure:

Google Cloud Service Mesh Docs
Microservices Demo Repository

That’s brilliant for enterprise deployments, but it can feel overwhelming for beginners.

Running the stack locally changes everything.

Instead of needing:

Managed Kubernetes
Cloud networking
Service meshes
Complex ingress controllers

You can simply:

Launch a lightweight Ubuntu VM
Install Docker
Start the containers
Open a browser

Now you can learn microservices from your kitchen table.

The Tiny Home Lab Approach

This setup is intentionally simple.

You only need:

A Raspberry Pi or laptop
Vagrant
VMware Fusion or VirtualBox
Docker
Docker Compose

That’s it.

Instead of building a giant enterprise cluster, you create a tiny self-contained development environment.

Perfect for:

Learning containers
Exploring networking
Teaching cloud-native concepts
Practicing DevOps
Demonstrating service integration

Building the VM Automatically with Vagrant

Here’s the reference Vagrant configuration:

Vagrant.configure("2") do |config|
 config.vm.box = "bento/ubuntu-24.04"

 config.vm.provider "vmware_fusion" do |v|
   v.memory = 4096
   v.cpus = 2
 end

 config.vm.synced_folder ".", "/vagrant", disabled: true

 config.vm.network "public_network",
   ip: "192.168.1.253",
   use_dhcp_assigned_default_route: true

 config.vm.provision "shell", inline: <<-SHELL
      sudo apt update -y

      sudo ufw disable

      sudo systemctl stop apparmor
      sudo systemctl disable apparmor

      sudo sed -i '/swap/d' /etc/fstab
      sudo swapoff -a

      echo "192.168.1.253 aionpi" >> /etc/hosts

      groupadd docker
      usermod -aG docker vagrant

      apt-get -y install docker.io
      apt-get -y install slirp4netns

      curl -L \
      "https://github.com/docker/compose/releases/latest/download/docker-compose-$(uname -s)-$(uname -m)" \
      -o /usr/bin/docker-compose

      chmod 755 /usr/bin/docker-compose
  SHELL
end

What This Actually Does

This entire file is infrastructure automation.

Instead of manually building a Linux server every time, Vagrant creates it for you automatically.

Step 1: Create Ubuntu

config.vm.box = "bento/ubuntu-24.04"

This downloads a clean Ubuntu 24.04 image.

Every deployment starts identical.

Step 2: Give the VM Resources

v.memory = 4096
v.cpus = 2

The demo shop is surprisingly lightweight.

4GB RAM and 2 CPUs are enough to run the whole environment for learning purposes.

That means:

Older laptops work fine
Small mini PCs work great
Raspberry Pi systems become viable

Step 3: Put the VM on Your Home Network

config.vm.network "public_network",
  ip: "192.168.1.253"

Now the VM behaves like a real machine on your LAN.

You can open the storefront from:

Your laptop
Tablet
Phone
Another PC

Simply browse to:

http://192.168.1.253:8080

Docker Is the Real Star

Once Ubuntu is ready, the setup installs Docker and Docker Compose.

This is where containers shine.

Every microservice becomes its own isolated component.

Instead of manually configuring software dependencies:

Docker downloads ready-made containers
Compose wires them together
Environment variables define communication paths

The entire application becomes portable and repeatable.

Understanding the Docker Compose File

The compose file is a simplified version of Google’s Kubernetes deployment.

Instead of dozens of Kubernetes YAML files, everything lives in one readable configuration.

That makes it fantastic for learning.

Each Service Has a Job

Frontend

frontend:

This is the web shop users actually visit.

It talks to nearly every backend service.

Product Catalog

productcatalogservice:

Stores product information for the shop.

When you browse items, this service responds.

Cart Service

cartservice:

Handles shopping baskets and stores temporary cart data inside Redis.

Redis

redis-cart:

A lightweight in-memory database.

Fast, tiny, and perfect for caching sessions and shopping carts.

Recommendation Service

recommendationservice:

Suggests related products.

This mimics the “You may also like…” features seen on real ecommerce sites.

Checkout Service

checkoutservice:

Coordinates the final order process.

It communicates with:

Payment
Shipping
Email
Cart
Currency services

This is a great example of service orchestration.

Payment Service

paymentservice:

Processes fake payment transactions safely for demo purposes.

Shipping Service

shippingservice:

Calculates delivery costs and shipping details.

Currency Service

currencyservice:

Converts product prices between currencies dynamically.

Email Service

emailservice:

Sends simulated order confirmations.

Why This Is Such a Great Learning Platform

This project teaches:

Containers
Docker networking
Service discovery
Distributed applications
APIs
Infrastructure automation
Cloud-native architecture

And it does it visually.

You can literally watch modern software architecture working in real time.

Raspberry Pi + Cloud Native = Surprisingly Powerful

People often assume microservices require huge cloud infrastructure.

But modern containers are incredibly efficient.

A Raspberry Pi or tiny VM can comfortably demonstrate:

Multi-container deployments
Internal networking
Stateful services
Frontend/backend separation
Infrastructure-as-code

That’s a remarkable amount of learning from a tiny device.

Final Thoughts

Google’s microservices demo is one of the best hands-on learning projects available today.

By simplifying the deployment with:

Vagrant
Docker Compose
A small Ubuntu VM

…you make cloud-native technology approachable, affordable, and fun.

You don’t need:

A Kubernetes cluster
Expensive cloud bills
Enterprise hardware

Just curiosity, a lightweight VM, and a few containers.

And suddenly you’re running the same architectural concepts used by some of the largest platforms in the world — right from your desk.

Search This Blog

Simple concise steps to an AI career

Build Google’s GKE Microservices Demo Shop on a Raspberry Pi or Tiny VM