10 Docker Projects You Can Build in a Weekend and Actually Use!

Do yourself a favor and get accustomed to project-based learning. This is my philosophy to the most effective learning you can do. A home lab is a great way to do this. AND, getting into using containers will totally change your mindset on how you run your applications. Using Docker, you can totally spin up your containerized environment using simple Docker Compose code and even form these into stacks of apps that you can bring up and down as you want. Let’s look at 10 Docker Projects you can build in a weekend and that actually give you something you can use.

1. Gitea for Self-Hosted Git Repositories

Having your own self-hosted code repo is the way to go to start learning DevOps and infrastructure as code. It will help you get up to speed very quickly with git commands and learn the workflows of DevOps. Of course, the next decision is which solution should you host? Well, that is where Gitea is quickly becoming a favorite, due to the fact it is lightweight and it is almost a clone it looks like of GitHub which many are familiar with. I still prefer GitLab over all other solutions, but to begin with if you are looking for a Docker solution for code repo, Gitea is a great place to start.

You can use the example Docker Compose code below to get started with Gitea.

version: '3'

services:
  gitea:
    image: gitea/gitea:latest
    container_name: gitea
    environment:
      - USER_UID=1000
      - USER_GID=1000
    volumes:
      - ./gitea:/data
    ports:
      - "3000:3000"
      - "222:22"
    restart: always

2. Netdata to start monitoring

Netdata is one of the easiest monitoring solutions you will find for monitoring your home lab environment. It is easily installed with a lightweight agent that you install on your Linux and Windows hosts, and it picks up Docker containers you are running as well as Kubernetes metrics. And, I like that it is a simple container that you provision for getting it spun up.

Check out the following example Docker run code. Just enter your claim token and room ID:

docker run -d --name=netdata \
--pid=host \
--network=host \
-v netdataconfig:/etc/netdata \
-v netdatalib:/var/lib/netdata \
-v netdatacache:/var/cache/netdata \
-v /:/host/root:ro,rslave \
-v /etc/passwd:/host/etc/passwd:ro \
-v /etc/group:/host/etc/group:ro \
-v /etc/localtime:/etc/localtime:ro \
-v /proc:/host/proc:ro \
-v /sys:/host/sys:ro \
-v /etc/os-release:/host/etc/os-release:ro \
-v /var/log:/host/var/log:ro \
-v /var/run/docker.sock:/var/run/docker.sock:ro \
-v /run/dbus:/run/dbus:ro \
--restart unless-stopped \
--cap-add SYS_PTRACE \
--cap-add SYS_ADMIN \
--security-opt apparmor=unconfined \
-e NETDATA_CLAIM_TOKEN=<your claim token \
-e NETDATA_CLAIM_URL=https://app.netdata.cloud \
-e NETDATA_CLAIM_ROOMS=<your claim room> \
netdata/netdata:stable

3. Nginx Proxy Manager to put SSL on everything

One of the best projects you can spin up is Nginx Proxy Manager. My recommendation for those that are getting into home labs is to start with Nginx Proxy Manager as it provides a simple GUI to manage your Docker container SSL certificates for your containers and easily lets you provision Lets Encrypt certs. Having SSL certs on your containers with web interfaces just makes everything more secure and work better with other solutions that may not deal well with self-signed certificates.

Check out the example Docker Compose code you can use to spin it up below:

version: '3'

services:
  npm:
    image: jc21/nginx-proxy-manager:latest
    container_name: npm
    ports:
      - "80:80"
      - "81:81"
      - "443:443"
    volumes:
      - ./data:/data
      - ./letsencrypt:/etc/letsencrypt
    restart: always

4. Vaultwarden for a self-hosted password manager

If you are looking for a password manager where you control all of your data and no one else has access to your secrets, then self-hosting this is a great way to make sure of that. Vaultwarden is one of the best known self-hosted password managers out there and has gained a reputation as one that is secure and does the job.

Check out the Docker compose code for an example Vaultwarden instance below:

version: '3'

services:
  vaultwarden:
    image: vaultwarden/server:latest
    container_name: vaultwarden
    volumes:
      - ./vw-data:/data
    ports:
      - "8080:80"
    restart: always

5. Watchtower to keep your containers updated

If there is a solution that helps you with lifecycle management with Docker, it is Watchtower. Watchtower is a solution that, on a schedule, checks yours containers to see if there is a new container image available. If it finds one it stops the container, pulls the new image, and restarts the container with the same configuration using the new image. Pretty cool. In case you are running Docker Swarm, there is a counterpart to Watchtower called Shepherd. It does basically the same thing with your Docker services.

Here is sample Docker Compose code that will get a basic instance of Watchtower up and running for you. The cleanup parameter tells Watchtower to clean up the old images which helps with housekeeping for your disk space.

version: '3'

services:
  watchtower:
    image: containrrr/watchtower
    container_name: watchtower
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock
    environment:
      - WATCHTOWER_CLEANUP=true
      - WATCHTOWER_POLL_INTERVAL=300
    restart: always

6. Dozzle for container insights

Dozzle was a solution I just discovered not too long ago and realized what a great little tool it is. It lets you have a quick and easy view of your container logs across many different container hosts. With this, you can quickly view the logs for your containers no matter which host they are running on, without having to SSH into your Docker container hosts and run a docker logs <container name> command.

version: '3'

services:
  dozzle:
    image: amir20/dozzle:latest
    container_name: dozzle
    ports:
      - "8888:8080"
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock
    restart: always

7. Portainer is the best GUI for Docker

If you are looking for the best all around management tool for your Docker containers, Portainer is it. There are other free and open source tools out there, but I have tried them all and there are just none as polished and feature-rich as Portainer. If you don’t currently have a tool to manage your containers across hosts, do yourself a favor and implement Portainer over a weekend project and you will quickly reap the rewards of better management.

Portainer is also one of the best tools you can use if you are delving into Docker Swarm. It absolutely makes the Docker Swarm solution viable in my opinion with the great management features.

version: '3'

services:
  portainer:
    image: portainer/portainer-ce:latest
    container_name: portainer
    ports:
      - "9443:9443"
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock
      - ./portainer-data:/data
    restart: always

8. OpenWebUI + Ollama for self-hosted AI at home

This is a pair of solutions I have been playing around with the past few months and I have to say that self-hosting your own AI server is totally awesome. You don’t have to worry about API costs to the major cloud AI providers, and you keep control of your own data.

Also, it is not as hard as you might imagine to self-host your own AI either. With OpenWebUI and Ollama, you have a very ChatGPT like experience from the comforts of your own home lab.

Below is example Docker Compose code to get you started with self-hosting private AI:

version: '3.8'

services:
  ollama:
    image: ollama/ollama
    container_name: ollama
    volumes:
      - ollama:/root/.ollama
    ports:
      - "11434:11434"
    restart: unless-stopped

  openwebui:
    image: ghcr.io/open-webui/open-webui:main
    container_name: openwebui
    depends_on:
      - ollama
    environment:
      - OLLAMA_BASE_URL=http://ollama:11434
    ports:
      - "3000:3000"
    volumes:
      - openwebui:/app/backend/data
    restart: unless-stopped

volumes:
  ollama:
  openwebui:

9. Home Assistant to get into smart home tech

The Home Assistant solution is absolutely the defacto standard in smart home self-hosting technologies. It is a complete management system for all of your smart home devices and allows you to control them from a single pane of glass interface.

Below is the same Docker Compose code I am running in my environment for Home Assistant and provides side car containers for use in forwarding messages if you need to your HomeAssistant environment.

version: '3.8'
services:
  homeassistant:
    image: ghcr.io/home-assistant/home-assistant:stable
    container_name: homeassistant
    user: "1001:1001"
    restart: unless-stopped
    network_mode: "service:proxy" # attach to Traefik sidecar for SSL
    depends_on:
      - mosquitto
    volumes:
      - /srv/homeassistant/config:/config:rw
      - homeassistant_db:/config/home-assistant_v2.db
    environment:
      - TZ=America/Chicago
    secrets:
      - api_key
    healthcheck:
      test: ["CMD-SHELL", "curl -f http://localhost:8123/api/health || exit 1"]
      interval: 1m
      timeout: 10s
      retries: 3
    cap_drop:
      - ALL
    cap_add:
      - CHOWN
      - SETUID
      - SETGID

  mosquitto:
    image: eclipse-mosquitto:latest
    container_name: mosquitto
    restart: unless-stopped
    networks:
      homenet:
    volumes:
      - /srv/mosquitto/config:/mosquitto/config:ro
      - /srv/mosquitto/data:/mosquitto/data
      - /srv/mosquitto/log:/mosquitto/log
    ports:
      - "1883:1883"

  influxdb:
    image: influxdb:2.6
    container_name: influxdb
    restart: unless-stopped
    networks:
      homenet:
    volumes:
      - influxdb_data:/var/lib/influxdb2
    environment:
      - INFLUXDB_ADMIN_USER=admin
      - INFLUXDB_ADMIN_PASSWORD_FILE=/run/secrets/influxdb_admin_password
    secrets:
      - influxdb_admin_password
    ports:
      - "8086:8086"

  grafana:
    image: grafana/grafana:9.5
    container_name: grafana
    restart: unless-stopped
    networks:
      homenet:
    volumes:
      - grafana_data:/var/lib/grafana
    environment:
      - GF_SECURITY_ADMIN_PASSWORD_FILE=/run/secrets/grafana_admin_password
    secrets:
      - grafana_admin_password
    ports:
      - "3000:3000"


networks:
  homenet:
    driver: macvlan
    driver_opts:
      parent: eth0
    ipam:
      config:
        - subnet: 192.168.1.0/24
          gateway: 192.168.1.1

volumes:
  homeassistant_db:
  influxdb_data:
  grafana_data:

10. N8N to automate your workflows

The n8n solution is one of the coolest automation tools I have seen. It provides an easy way to automate entire workflows so that it takes the heavy lifting out of the process. You can think of it like your own self-hosted Zapier that provides hooks into just about any API solution out there. You can use it for automating Git updates, email alerts, file movements, or even things like Home Assistant triggers.

Below is the very basic Docker Compose code you will need. However, check out my recent blog post covering all the details of setup here: Automate Your Home Lab with n8n Workflow Automation and AI.

version: '3'

services:
  n8n:
    image: n8nio/n8n:latest
    container_name: n8n
    ports:
      - "5678:5678"
    environment:
      - N8N_BASIC_AUTH_ACTIVE=true
      - N8N_BASIC_AUTH_USER=admin
      - N8N_BASIC_AUTH_PASSWORD=changeme
      - TZ=America/New_York
    volumes:
      - ./n8n-data:/home/node/.n8n
    restart: always

Wrapping it

I get excited thinking about how far Docker projects have brought me in my own personal learning journey and I want to share this with others who are on the same learning path. By spinning up these Docker projects and others, you will set yourself up to learn a TON of new things around containerization, self-hosting, and how to manage modern app infrastructure. Let me know in the comments if you are running some of the projects covered here or if there are others you would recommend.