Peppermint on a Raspberry Pi or Tiny VM

 

Learn Containers at Home with Peppermint on a Raspberry Pi or Tiny VM

YouTube: https://youtu.be/4yYphPc439M


Containers can feel intimidating at first.

Words like:

  • Docker
  • Compose
  • Volumes
  • Networking
  • Infrastructure-as-code

…sound like something reserved for giant cloud companies.

But the truth is much more exciting:

You can learn modern container technology right at home using a tiny virtual machine, a Raspberry Pi 5, and a beautifully simple application called  PeppermintAttachment.tiff.

And within minutes, you’ll have your own self-hosted ticketing and helpdesk platform running locally in Docker containers.

Why Peppermint Is a Great Learning Project

Peppermint is a modern open-source helpdesk and issue management platform.

Think of it as a lightweight internal support system where you can:

  • Create tickets
  • Track issues
  • Organise tasks
  • Manage requests
  • Explore databases and web applications

But the real magic is what happens underneath.

Peppermint runs as containers.

That means you learn:

  • Docker
  • Multi-container applications
  • Databases
  • Networking
  • Persistent storage
  • Infrastructure automation

Without needing expensive cloud infrastructure.

The Perfect Home Lab Project

This setup works beautifully on:

  • A Raspberry Pi
  • A mini PC
  • An old laptop
  • Or a small VM on your main computer

That makes it ideal for:

  • Students
  • Developers
  • Home lab enthusiasts
  • Parents teaching kids technology
  • Anyone curious about cloud-native computing

Instead of renting cloud servers, you build your own tiny platform locally.

Why Use Vagrant?

Vagrant lets you describe an entire server in code.

Instead of manually:

  • Installing Linux
  • Configuring networking
  • Installing Docker
  • Creating containers

…you automate everything.

One command builds the whole environment.

That’s how modern infrastructure works in real engineering teams.

The Vagrantfile

Here’s the complete setup:

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

      cat <<-'EOF' > /home/vagrant/compose.yaml
services:
  peppermint_postgres:
    container_name: peppermint_postgres
    image: postgres:latest
    restart: always
    volumes:
      - pgdata:/var/lib/postgresql/data

    environment:
      POSTGRES_USER: peppermint
      POSTGRES_PASSWORD: 1234
      POSTGRES_DB: peppermint

  peppermint:
    container_name: peppermint
    image: pepperlabs/peppermint:latest

    ports:
      - 3000:3000
      - 5003:5003

    restart: always

    depends_on:
      - peppermint_postgres

    environment:
      DB_USERNAME: "peppermint"
      DB_PASSWORD: "1234"
      DB_HOST: "peppermint_postgres"
      SECRET: 'peppermint4life'

volumes:
 pgdata:
EOF

      docker-compose -f /home/vagrant/compose.yaml up -d
  SHELL
end

What This Setup Actually Does

At first glance, it might look complicated.

But it’s really just automating a Linux server build.

Step 1: Create Ubuntu Automatically

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

This downloads a clean Ubuntu 24.04 server image.

Every deployment becomes:

  • Reproducible
  • Consistent
  • Easy to rebuild

Step 2: Allocate Resources

v.memory = 4096
v.cpus = 2

This gives the VM:

  • 4GB RAM
  • 2 CPU cores

More than enough for learning containers and running Peppermint comfortably.

Even older laptops can handle this.

Step 3: Put the VM on Your Home Network

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

Now your VM behaves like a real machine on your network.

You can access Peppermint from:

  • Your laptop
  • Desktop
  • Tablet
  • Phone

Simply open:

http://192.168.1.253:3000

Docker Does the Heavy Lifting

The setup installs:

  • Docker
  • Docker Compose

This is where containers become exciting.

Instead of manually installing software and dependencies:

  • Docker downloads prebuilt containers
  • Compose connects them together
  • Everything runs consistently

This is exactly how modern applications are deployed in production.

Understanding the Compose File

The Docker Compose file defines two services.

Peppermint Application

peppermint:

This is the main web application.

It provides:

  • The dashboard
  • Ticket management
  • User interface
  • API functionality

The container exposes:

  • Port 3000
  • Port 5003

So the application becomes reachable from your browser.

PostgreSQL Database

peppermint_postgres:

Peppermint needs a database to store:

  • Tickets
  • Users
  • Settings
  • Application data

This setup uses PostgreSQL, one of the most widely used databases in the world.

Persistent Storage Matters

This line is important:

volumes:
  - pgdata:/var/lib/postgresql/data

Without persistent storage, containers lose their data when recreated.

Volumes solve that problem.

Even if the container restarts:

  • Tickets remain
  • Settings stay intact
  • Your database survives

This is a critical real-world container concept.

Why This Is Such a Good Learning Platform

This project teaches:

  • Linux
  • Docker
  • Containers
  • Databases
  • Networking
  • Automation
  • Infrastructure-as-code

And because Peppermint is visual and interactive, the learning feels rewarding immediately.

You are not just reading documentation.

You are building real infrastructure.

Raspberry Pi + Containers = A Tiny Cloud Platform

One of the most exciting things about modern containers is how lightweight they are.

A small Raspberry Pi can now run:

  • Databases
  • Web applications
  • APIs
  • Multi-container stacks

That would have required expensive servers years ago.

Today, a tiny low-power device becomes a miniature cloud platform sitting on your desk.

Final Thoughts

Learning containers no longer requires:

  • Enterprise hardware
  • Massive cloud bills
  • Complicated Kubernetes clusters

A simple VM, Docker Compose, and Peppermint are enough to start exploring modern infrastructure properly.

And perhaps the best part is this:

Everything is disposable.

Break it.
Rebuild it.
Experiment freely.

That’s exactly how the best engineers learn.

Comments

Post a Comment

Popular posts from this blog

Don’t Be Afraid to Experiment

Image
  Don’t Be Afraid to Experiment: Building Your Own Home Lab with Linux, Containers, and Tiny Servers YouTube: https://youtu.be/ePHyb73RRLE One of the biggest misconceptions in technology is this: “I might break something.” Here’s the truth: Breaking things safely is one of the best ways to learn. And today, learning infrastructure, Linux, containers, and web servers is easier than ever because you can experiment from: A Raspberry Pi 5 A tiny VM on your laptop An old mini PC Or even a spare desktop machine You no longer need: Enterprise hardware Expensive cloud accounts Massive servers Complex corporate environments A small home lab is enough to learn real modern infrastructure skills. And honestly, that’s incredibly exciting. Why Home Labs Are So Powerful A home lab gives you freedom. You can: Install software Break systems Rebuild environments Try new ideas Learn networking Deploy containers Explore Linux Without worrying about damaging production systems. That freedom remove...
Read more

Learning Databases and Big Data

Image
  Learning Databases and Big Data at Home with a Raspberry Pi or Tiny VM YouTube: https://youtu.be/04g-2O7e6Qc Modern technology runs on data. Every: Website AI model Mobile app Online shop Cloud platform Banking system Streaming service Depends on databases underneath. And the exciting part is this: You can now learn many of these technologies from: A Raspberry Pi 5 A small virtual machine on your laptop Or a tiny home server That’s incredibly powerful. Because databases are one of the most important foundations of modern computing. What Is a Database? A database stores and organises information. Think of it as a highly advanced digital filing cabinet. Databases help systems: Save data Retrieve data quickly Search efficiently Handle many users simultaneously Protect information safely Without databases, modern applications simply would not function. A Short History of Databases Early computer systems stored information in flat files. That quickly became difficult to manage. A...
Read more

Build Your Own Agentic AI Platform

Image
  Build Your Own Agentic AI Platform at Home with Containers, Ollama, n8n, and Vector Databases YouTube on Pi:      https://youtu.be/__Led8X0bOk                                    https://youtu.be/huaCfx1My6M                                    https://youtu.be/JrhRwU2TkEA                                    https://youtu.be/NCXgHdqjxI0 YouTube on VM:  https://youtu.be/qar4KA47HIM Artificial Intelligence is changing rapidly. We are moving beyond simple chatbots into systems that can: Search documents Remember context Use tools Trigger workflows Query databases Make decisions Automate tasks These are often called  agentic AI systems . And the exciting...
Read more