Best 100+ Docker Containers for Home Server

Dragos
July 12, 2024
- Vps

Docker is an open-source platform that allows you to develop, ship, and run applications in containers. Containers are lightweight, standalone, and executable packages that include everything needed to run a piece of software, including the code, runtime, system tools, libraries, and settings.

Key benefits of Docker:

Consistency across different environments
Isolation of applications
Efficient resource utilization
Easy deployment and scaling

Using Docker containers for your home server offers several advantages:

Simplified management: Easily install, update, and remove applications without affecting the host system or other containers.
Resource efficiency: Containers share the host OS kernel, making them more lightweight than traditional virtual machines.
Improved security: Containers provide isolation, reducing the risk of one compromised application affecting others.
Portability: Easily move your applications between different systems or hardware.
Version control: Quickly roll back to previous versions if issues arise.

Setting Up Your Home Server

Hardware requirements

To run a Docker-based home server, you’ll need:

Component	Minimum Recommendation
CPU	Dual-core processor
RAM	4GB
Storage	32GB (SSD preferred)
Network	Gigabit Ethernet

Note: Actual requirements may vary depending on the number and type of containers you plan to run.

you can check Best Mini PC For Home Servers to choose one.

Operating system considerations

Docker can run on various operating systems, including:

Linux distributions (Ubuntu, Debian, CentOS, etc.)
Windows 10/11 Pro or Enterprise (using Hyper-V)
macOS

For home servers, a lightweight Linux distribution is often the best choice due to its lower resource overhead and better Docker support.

Popular options include:

Ubuntu Server
Debian
Proxmox VE (for advanced users who want to combine Docker with virtual machines)

Installing Docker

To install Docker on your chosen operating system, follow these general steps:

Update your system’s package manager
Install required dependencies
Add Docker’s official GPG key and repository
Install Docker Engine and Docker Compose

For detailed, up-to-date installation instructions, refer to the official Docker documentation.

After installation, it’s recommended to:

Add your user to the Docker group to avoid using sudo for Docker commands
Enable and start the Docker service
Test the installation by running a simple container, such as:
```
docker run hello-world
```

With Docker installed and running on your home server, you’re now ready to explore the wide world of Docker containers and start building your personalized home server environment.

Media Management Containers

Docker containers offer excellent solutions for managing and organizing your media library. Let’s explore some of the most popular options:

Plex

Plex is a comprehensive media server that organizes and streams your personal media collection.

Key features:

Automatic metadata fetching
Transcoding for various devices
User management and sharing

Docker image: linuxserver/plex

Jellyfin

Jellyfin is a free, open-source alternative to Plex with similar functionality.

Key features:

Completely free and open-source
No central servers or tracking
Supports live TV and DVR

Docker image: jellyfin/jellyfin

Emby

Emby is another media server option that offers a balance between features and pricing.

Key features:

Live TV and DVR support
Parental controls
Mobile sync (premium feature)

Docker image: emby/embyserver

Comparison Table

Feature	Plex	Jellyfin	Emby
Cost	Free (with premium option)	Free	Free (with premium option)
Open-source	No	Yes	Partially
Live TV	Yes (with Plex Pass)	Yes	Yes
Mobile sync	Yes (with Plex Pass)	No	Yes (with premium)

Sonarr

Sonarr is an automated TV show downloader and manager.

Key features:

Automated TV show searching and downloading
Calendar view of upcoming episodes
Integration with media servers and download clients

Docker image: linuxserver/sonarr

Radarr

Radarr is similar to Sonarr but focuses on movies instead of TV shows.

Key features:

Automated movie searching and downloading
Integration with media servers and download clients
Customizable quality profiles

Docker image: linuxserver/radarr

Lidarr

Lidarr completes the *arr trio by providing similar functionality for music.

Key features:

Automated music searching and downloading
Artist and album management
Integration with various music sources and download clients

Docker image: linuxserver/lidarr

Jackett

Jackett works as a proxy server between your media management apps and torrent trackers.

Key features:

Supports a wide range of torrent trackers
Provides a unified search interface
Integrates with Sonarr, Radarr, and Lidarr

Docker image: linuxserver/jackett

Transmission

Transmission is a lightweight and user-friendly BitTorrent client.

Key features:

Web interface for remote management
Scheduling and bandwidth controls
Support for magnet links

Docker image: linuxserver/transmission

qBittorrent

qBittorrent is another popular BitTorrent client with a feature-rich web interface.

Key features:

Built-in search engine
RSS feed support
IP filtering and encryption

Docker image: linuxserver/qbittorrent

These Docker containers can work together to create a powerful, automated media management system for your home server. By combining media servers like Plex or Jellyfin with automated downloaders like Sonarr, Radarr, and Lidarr, and using Jackett as a search proxy, you can create a seamless entertainment experience tailored to your preferences. The addition of torrent clients like Transmission or qBittorrent completes the setup, allowing for efficient downloading of your desired content.

Docker containers offer excellent solutions for file sharing and synchronization across devices. Let’s explore some of the most popular options:

Nextcloud

Nextcloud is a powerful, self-hosted file sync and share solution that provides a platform for collaboration and productivity.

Key features:

File synchronization across devices
Collaborative document editing
Calendar and contact management
Built-in chat and video calling

Docker image: nextcloud

Syncthing

Syncthing is a continuous file synchronization program that securely synchronizes files between two or more computers in real-time.

Key features:

Decentralized and peer-to-peer
End-to-end encryption
Cross-platform support
No central server required

Docker image: syncthing/syncthing

Seafile

Seafile is an open-source file sync and share solution with high reliability and performance.

Key features:

File versioning and snapshots
Selective sync
Two-factor authentication
Built-in wiki

Docker image: seafileltd/seafile-mc

ownCloud

ownCloud is another popular open-source file sync and share platform that offers a range of features for personal and business use.

Key features:

File sharing and synchronization
Collaborative editing
Mobile and desktop clients
Extensible through apps

Docker image: owncloud/server

Filebrowser

Filebrowser is a lightweight, web-based file manager that allows you to manage files and directories on your server through a clean, easy-to-use interface.

Key features:

Simple and intuitive web interface
File upload and download
User management with configurable permissions
Customizable look and feel

Docker image: filebrowser/filebrowser

For a detailed guide on how to deploy Filebrowser using Docker, check out this tutorial: How to Deploy Filebrowser with Docker

Comparison Table

Feature	Nextcloud	Syncthing	Seafile	ownCloud	Filebrowser
File sync	Yes	Yes	Yes	Yes	No
Collaboration tools	Yes	No	Limited	Yes	No
Self-hosted	Yes	Yes	Yes	Yes	Yes
Mobile apps	Yes	Yes	Yes	Yes	No
End-to-end encryption	Yes	Yes	Yes	Yes	No
Open-source	Yes	Yes	Yes	Yes	Yes
Web-based file manager	Yes	No	Yes	Yes	Yes

These file sharing and sync containers offer a range of options to suit different needs and preferences. Whether you’re looking for a comprehensive collaboration platform like Nextcloud or ownCloud, a simple yet powerful sync solution like Syncthing, a high-performance option like Seafile, or a lightweight file manager like Filebrowser, there’s a Docker container that can meet your requirements.

By setting up one of these containers on your home server, you can create your own personal cloud storage system, ensuring that your files are always accessible and synchronized across all your devices while maintaining control over your data.

Remember to consider factors such as ease of use, scalability, and specific features that matter to you when choosing the right file sharing and sync solution for your home server setup.

AI Applications Containers

Docker containers offer powerful solutions for running various AI applications on your home server. Let’s explore some of the most popular options:

Ollama with OpenWebUI

Ollama is an open-source project that allows you to run large language models locally. OpenWebUI provides a user-friendly interface for interacting with Ollama.

Key features:

Run various large language models locally
User-friendly web interface
Customizable prompts and settings
No need for API keys or internet connection for inference

Docker images:

ollama/ollama
ghcr.io/open-webui/open-webui:main

For a detailed guide on how to install Ollama with OpenWebUI using Docker, check out this tutorial: How to Install Ollama with Docker

Flowise

Flowise is an open-source UI visual tool for building LLM apps, chatbots, and agents with a drag-and-drop interface.

Key features:

Visual workflow builder
Integration with various AI models and tools
Customizable components
API generation for created flows

Docker image: flowiseai/flowise

For a step-by-step installation guide, see: How to Install Flowise AI

Langflow

Langflow is an GUI for LangChain, designed to provide an easy way to experiment and prototype flows.

Key features:

Drag-and-drop interface for LangChain components
Code export functionality
Easy integration with various LLMs and tools
Customizable nodes and edges

Docker image: logspace/langflow

Learn how to set up Langflow with this guide: How to Install Langflow with Docker

Langfuse

Langfuse is an open-source observability and analytics solution for LLM applications.

Key features:

Tracing and logging for LLM interactions
Performance monitoring and analytics
Integration with popular LLM frameworks
Customizable dashboards

Docker image: langfuse/langfuse

For installation instructions, check out: How to Install Langfuse with Docker

LiteLLM

LiteLLM is a lightweight package to standardize inputs and outputs across LLM providers.

Key features:

Unified interface for multiple LLM providers
Caching and rate limiting
Logging and monitoring
Easy integration with various AI applications

Docker image: ghcr.io/berriai/litellm

For a guide on setting up LiteLLM, see: How to Install LiteLLM with Docker

Comparison Table

Feature	Ollama + OpenWebUI	Flowise	Langflow	Langfuse	LiteLLM
Primary Function	Local LLM Inference	LLM App Builder	LangChain GUI	LLM Observability	LLM Standardization
User Interface	Web-based	Web-based	Web-based	Web-based	API
Local Models	Yes	No	No	N/A	Depends on setup
Visualization	Basic chat	Flow diagram	Flow diagram	Analytics dashboards	N/A
Extensibility	Limited	High	High	High	High

These AI application containers can work together to create a powerful ecosystem for developing, running, and monitoring AI applications:

Use Ollama with OpenWebUI for running and interacting with local language models.
Implement Flowise or Langflow for building complex LLM applications with a visual interface.
Set up Langfuse to monitor and analyze the performance of your LLM applications.
Utilize LiteLLM to standardize interactions with various LLM providers and simplify your codebase.

By combining these containers, you can create a robust AI development and deployment environment that:

Allows for local LLM inference without relying on external APIs
Provides tools for rapid prototyping and development of LLM applications
Offers monitoring and analytics capabilities for optimizing your AI systems
Simplifies integration with multiple LLM providers

Remember to consider the following when setting up your AI application environment:

Ensure you have sufficient computational resources, especially for running local LLM models
Implement proper security measures, especially if exposing services to the internet
Regularly update your containers to benefit from the latest features and security patches
Be mindful of licensing and usage terms, especially when using commercial LLM models

With these Docker containers, you can build a powerful, flexible, and efficient AI application environment on your home server, enabling you to explore and leverage the latest advancements in language models and AI technologies.

Home Automation Containers

Docker containers offer powerful solutions for home automation, allowing you to control and monitor various aspects of your smart home. Let’s explore some of the most popular options:

Home Assistant

Home Assistant is an open-source home automation platform that puts local control and privacy first.

Key features:

Supports over 1,000 integrations
Powerful automation engine
Local processing for faster response times
Customizable dashboard

Docker image: homeassistant/home-assistant

Node-RED

Node-RED is a flow-based programming tool for connecting hardware devices, APIs, and online services.

Key features:

Visual programming interface
Extensive library of nodes
Easy integration with IoT devices
Customizable dashboard

Docker image: nodered/node-red

Mosquitto MQTT Broker

Eclipse Mosquitto is an open-source message broker that implements the MQTT protocol, widely used in IoT and home automation.

Key features:

Lightweight and efficient
Supports MQTT v3.1 and v3.1.1
SSL/TLS encryption
Authentication and access control

Docker image: eclipse-mosquitto

OpenHAB

openHAB (Open Home Automation Bus) is a vendor and technology-agnostic open-source automation software for your home.

Key features:

Supports over 200 technologies and systems
Rule-based automation engine
Mobile apps for iOS and Android
Customizable user interfaces

Docker image: openhab/openhab

Comparison Table

Feature	Home Assistant	Node-RED	Mosquitto	openHAB
Primary Function	Home Automation Platform	Flow-based Programming	MQTT Broker	Home Automation Platform
User Interface	Web-based	Web-based	Command-line	Web-based
Automation	Yes	Yes	No (facilitates communication)	Yes
Device Support	Extensive	Extensive	N/A (protocol-based)	Extensive
Customization	High	High	Limited	High

These home automation containers can work together to create a powerful and flexible smart home system:

Use Home Assistant or openHAB as your central home automation platform.
Implement Node-RED for complex automations and integrations.
Set up Mosquitto MQTT Broker to facilitate communication between various smart devices and your automation platform.

By combining these containers, you can create a robust home automation system that:

Controls your smart lights, thermostats, and other IoT devices
Automates routines based on time, presence, or other triggers
Monitors energy usage and environmental conditions
Provides a unified interface for managing your entire smart home

Remember to secure your home automation setup by:

Using strong passwords
Enabling two-factor authentication where possible
Keeping your containers and host system updated
Implementing network segmentation for IoT devices

With these Docker containers, you can build a powerful, customizable, and secure home automation system that puts you in control of your smart home.

Network Management Containers

Docker containers offer powerful solutions for managing and optimizing your home network. Let’s explore some of the most popular options:

Pi-hole

Pi-hole is a network-wide ad blocker that acts as a DNS sinkhole to block unwanted content.

Key features:

Network-wide ad blocking
Customizable blocklists
Detailed statistics and reporting
DHCP server functionality

Docker image: pihole/pihole

Unbound

Unbound is a validating, recursive, and caching DNS resolver.

Key features:

DNSSEC validation
Improved privacy and security
Caching for faster DNS resolution
Can work alongside Pi-hole for enhanced functionality

Docker image: mvance/unbound

Traefik

Traefik is a modern HTTP reverse proxy and load balancer that makes deploying microservices easy.

Key features:

Automatic SSL certificate generation with Let’s Encrypt
Dynamic configuration
Docker integration
Metrics and monitoring

Docker image: traefik

Nginx Proxy Manager

Nginx Proxy Manager provides a user-friendly interface to manage Nginx proxy hosts with SSL termination.

Key features:

Easy-to-use web interface
Automatic SSL certificate management
Access lists and basic authentication
Docker container support

Docker image: jc21/nginx-proxy-manager

Portainer

Portainer is a lightweight management UI for Docker environments.

Key features:

Web-based Docker management
Container and image management
User authentication and role-based access control
Monitoring and logging

Docker image: portainer/portainer-ce

Dockge

Dockge is a simple, lightweight, and powerful Docker compose stack manager and UI.

Key features:

User-friendly web interface for managing Docker compose stacks
Easy deployment and management of Docker containers
Built-in code editor for compose files
Support for environment variables and secrets

Docker image: louislam/dockge

For a detailed guide on how to install and set up Dockge, check out this tutorial: How to Install Dockge

Comparison Table

Feature	Pi-hole	Unbound	Traefik	Nginx Proxy Manager	Portainer	Dockge
Primary Function	Ad Blocking	DNS Resolver	Reverse Proxy	Reverse Proxy	Docker Management	Docker Compose Management
User Interface	Web-based	Command-line	Web-based	Web-based	Web-based	Web-based
SSL Management	No	No	Yes	Yes	No	No
Docker Integration	N/A	N/A	Yes	Yes	Yes	Yes
Ease of Use	High	Medium	Medium	High	High	High

These network management containers can work together to create a powerful and secure home network setup:

Use Pi-hole for network-wide ad blocking and DNS management.
Implement Unbound as a recursive DNS resolver for improved privacy and security.
Set up Traefik or Nginx Proxy Manager to handle reverse proxy and SSL termination for your services.
Use Portainer to manage your Docker containers and images easily.
Implement Dockge for simplified management of Docker compose stacks.

By combining these containers, you can create a robust network management system that:

Blocks ads and unwanted content across all devices on your network
Improves DNS resolution speed and security
Provides easy access to your self-hosted services with automatic SSL management
Simplifies Docker container and stack management

Remember to secure your network management setup by:

Using strong passwords for all interfaces
Keeping your containers and host system updated
Implementing proper firewall rules
Regularly reviewing and updating your configurations

With these Docker containers, you can build a powerful, customizable, and secure network management system that gives you full control over your home network infrastructure.

Monitoring and Analytics Containers

Monitoring and analytics are crucial for maintaining a healthy and efficient home server setup. Docker containers offer powerful solutions for tracking system performance, resource usage, and network activity. Let’s explore some of the most popular options:

Grafana

Grafana is an open-source platform for monitoring and observability, allowing you to query, visualize, and alert on metrics from various data sources.

Key features:

Beautiful and customizable dashboards
Support for multiple data sources (Prometheus, InfluxDB, etc.)
Alerting and notification system
User authentication and team-based access control

Docker image: grafana/grafana

Prometheus

Prometheus is an open-source systems monitoring and alerting toolkit, designed for reliability and scalability.

Key features:

Multi-dimensional data model with time series data
Flexible query language (PromQL)
Pull model for collecting metrics
Service discovery and dynamic configuration

Docker image: prom/prometheus

InfluxDB

InfluxDB is an open-source time series database designed to handle high write and query loads.

Key features:

Purpose-built for time series data
High performance and data compression
SQL-like query language
Retention policies and continuous queries

Docker image: influxdb

Telegraf

Telegraf is an agent for collecting, processing, aggregating, and writing metrics.

Key features:

Plugin-driven for both inputs and outputs
Supports a wide variety of services and systems
Low memory footprint
Can be used with InfluxDB and other time series databases

Docker image: telegraf

Netdata

Netdata is a distributed, real-time performance and health monitoring system for systems, hardware, containers, and applications.

Key features:

Real-time, per-second metrics
Highly optimized data collection and visualization
Automatic configuration and zero maintenance
Extensible through plugins

Docker image: netdata/netdata

Comparison Table

Feature	Grafana	Prometheus	InfluxDB	Telegraf	Netdata
Primary Function	Visualization	Monitoring & Alerting	Time Series Database	Data Collection	Real-time Monitoring
Data Sources	Multiple	Self & Exporters	Self	Multiple	Self
Visualization	Yes	Basic	No	No	Yes
Alerting	Yes	Yes	No	No	Yes
Ease of Setup	Medium	Medium	Easy	Easy	Very Easy

These monitoring and analytics containers can work together to create a comprehensive monitoring solution for your home server:

Use Prometheus as your primary metrics collection and storage system.
Implement Grafana for creating beautiful dashboards and visualizations.
Set up InfluxDB for storing high-resolution metrics data.
Use Telegraf to collect metrics from various sources and send them to InfluxDB or Prometheus.
Implement Netdata for real-time, per-second monitoring of your systems.

By combining these containers, you can create a robust monitoring and analytics system that:

Provides real-time insights into your server’s performance
Allows you to create custom dashboards for different aspects of your setup
Sends alerts when issues arise or thresholds are exceeded
Helps you identify trends and optimize your server’s resources

Remember to consider the following when setting up your monitoring solution:

Properly configure retention policies to manage data storage
Set up appropriate alerting thresholds to avoid alert fatigue
Regularly review and update your dashboards and metrics collection
Ensure your monitoring setup doesn’t overly tax your system resources

With these Docker containers, you can build a powerful, customizable, and insightful monitoring and analytics system that gives you full visibility into your home server’s performance and health.

Security and Privacy Containers

Ensuring the security and privacy of your home server is crucial. Docker containers offer several solutions to help protect your data and network. Let’s explore some of the most popular options:

Bitwarden

Bitwarden is an open-source password management solution that allows you to store, manage, and share sensitive information securely.

Key features:

End-to-end encryption
Self-hosting option for complete control
Cross-platform support (desktop, mobile, browser extensions)
Secure password sharing and organization

Docker image: bitwardenrs/server

OpenVPN

OpenVPN is a popular open-source VPN solution that allows you to create secure connections to your home network from remote locations.

Key features:

Strong encryption and authentication
Supports various authentication methods
Cross-platform compatibility
Extensible through plugins

Docker image: kylemanna/openvpn

WireGuard

WireGuard is a modern, fast, and secure VPN protocol that aims to be simpler and more efficient than traditional VPN solutions.

Key features:

Lightweight and high-performance
Strong, modern cryptography
Simple configuration
Cross-platform support

Docker image: linuxserver/wireguard

Fail2Ban

Fail2Ban is an intrusion prevention software framework that protects computer servers from brute-force attacks.

Key features:

Monitors log files for suspicious activity
Automatically blocks IP addresses of potential attackers
Customizable rules and actions
Supports various services (SSH, Apache, etc.)

Docker image: crazymax/fail2ban

Comparison Table

Feature	Bitwarden	OpenVPN	WireGuard	Fail2Ban
Primary Function	Password Management	VPN	VPN	Intrusion Prevention
Encryption	Yes	Yes	Yes	N/A
Self-hosting	Yes	Yes	Yes	Yes
Ease of Setup	Medium	Medium	Easy	Medium
Cross-platform	Yes	Yes	Yes	Linux-focused

These security and privacy containers can work together to create a comprehensive protection system for your home server:

Use Bitwarden to securely store and manage passwords for all your services.
Implement OpenVPN or WireGuard to create secure remote access to your home network.
Set up Fail2Ban to protect your server from brute-force attacks and other malicious activities.

By combining these containers, you can create a robust security and privacy system that:

Keeps your sensitive information encrypted and easily accessible
Provides secure remote access to your home network
Protects your server from common attack vectors

Remember to consider the following when setting up your security and privacy solution:

Regularly update your containers and host system to patch security vulnerabilities
Use strong, unique passwords for all services and accounts
Enable two-factor authentication where possible
Regularly review logs and security reports

With these Docker containers, you can build a powerful, customizable, and secure system that helps protect your home server and personal data from various threats.

Productivity Containers

Docker containers offer a range of solutions to boost your productivity and organization. Let’s explore some of the most popular options:

Bookstack

Bookstack is a free and open-source wiki system that provides a simple, self-hosted platform for organizing and storing information.

Key features:

User-friendly interface
Markdown support
File attachments
Full-text search

Docker image: linuxserver/bookstack

Joplin

Joplin is an open-source note-taking and to-do application with synchronization capabilities.

Key features:

End-to-end encryption
Markdown support
Web clipper for saving web pages
Cross-platform (desktop, mobile, terminal)

Docker image: joplin/server

Kanboard

Kanboard is a free and open-source Kanban project management software.

Key features:

Visual task board
Drag and drop tasks
Multiple projects and users
Automatic actions and subtasks

Docker image: kanboard/kanboard

Wekan

Wekan is an open-source kanban board that allows real-time collaboration.

Key features:

Customizable boards and lists
Card attachments and comments
User management and permissions
REST API for integrations

Docker image: wekanteam/wekan

Docmost

Docmost is a self-hosted, open-source knowledge base and documentation platform that helps teams organize and share information efficiently.

Key features:

Markdown and WYSIWYG editor support
Version history and document comparison
Full-text search
User and group management
Custom branding options

Docker image: docmost/docmost

For a detailed guide on how to install Docmost using Docker, check out this tutorial: How to Install Docmost with Docker

Comparison Table

Feature	Bookstack	Joplin	Kanboard	Wekan	Docmost
Primary Function	Wiki	Note-taking	Project Management	Kanban Board	Knowledge Base
Collaboration	Yes	Limited	Yes	Yes	Yes
Encryption	No	Yes	No	No	No
Mobile App	No	Yes	No	Yes (third-party)	No
Markdown Support	Yes	Yes	Limited	Yes	Yes
Version History	No	Yes	No	No	Yes

These productivity containers can work together to create a comprehensive system for managing information, tasks, and projects:

Use Bookstack or Docmost as your central knowledge base and documentation system.
Implement Joplin for personal note-taking and information gathering.
Set up Kanboard or Wekan (or both) for project management and task tracking.

By combining these containers, you can create a robust productivity system that:

Centralizes your team’s knowledge and documentation
Provides a secure platform for personal note-taking and information management
Offers visual project management tools for better task organization and collaboration
Enables efficient information sharing and collaboration within your team

Remember to consider the following when setting up your productivity solution:

Integrate these tools into your daily workflow to maximize their benefits
Regularly backup your data to prevent loss of important information
Set up proper user permissions to ensure data security and privacy
Consider using a reverse proxy (like Traefik or Nginx Proxy Manager) to access these services securely from outside your network

With these Docker containers, you can build a powerful, customizable, and efficient productivity system that helps you stay organized and focused on your tasks and projects.

Development Containers

Docker containers offer excellent solutions for setting up development environments and continuous integration/continuous deployment (CI/CD) pipelines. Let’s explore some of the most popular options:

GitLab

GitLab is a complete DevOps platform that combines Git repository management, issue tracking, CI/CD, and more.

Key features:

Git repository management
Built-in CI/CD pipelines
Issue tracking and project management
Container registry

Docker image: gitlab/gitlab-ce

Jenkins

Jenkins is a popular open-source automation server that enables developers to build, test, and deploy their software.

Key features:

Extensible through plugins
Distributed builds
Pipeline support
Easy configuration via web interface

Docker image: jenkins/jenkins

Gitea

Gitea is a lightweight, self-hosted Git service written in Go, designed to be easy to install and use.

Key features:

Git repository hosting
Issue tracking and pull requests
Webhooks and API
Low resource requirements

Docker image: gitea/gitea

Drone CI

Drone is a modern CI/CD platform that uses simple YAML configuration files to define and execute pipelines.

Key features:

Docker-native pipeline execution
Parallel and distributed builds
Extensible plugin system
Built-in secret management

Docker image: drone/drone

Comparison Table

Feature	GitLab	Jenkins	Gitea	Drone CI
Primary Function	All-in-one DevOps	CI/CD	Git Hosting	CI/CD
Repository Hosting	Yes	No	Yes	No
Built-in CI/CD	Yes	Yes	No	Yes
Resource Usage	High	Medium	Low	Low
Extensibility	High	High	Medium	High

These development containers can work together to create a comprehensive development environment:

Use GitLab or Gitea for source code management and repository hosting.
Implement Jenkins or Drone CI for continuous integration and deployment pipelines.

By combining these containers, you can create a robust development system that:

Provides version control and collaboration tools for your projects
Automates your build, test, and deployment processes
Offers flexibility in choosing the right tools for your specific needs

Remember to consider the following when setting up your development environment:

Ensure proper backup and disaster recovery plans for your repositories and build artifacts
Implement security best practices, such as access controls and secrets management
Regularly update your containers and plugins to benefit from the latest features and security patches
Consider resource requirements when choosing between lightweight options like Gitea and more comprehensive solutions like GitLab

With these Docker containers, you can build a powerful, customizable, and efficient development environment that streamlines your software development lifecycle and improves collaboration among team members.

Database Containers

Docker containers offer excellent solutions for running various database systems. Let’s explore some of the most popular options:

MariaDB

MariaDB is a community-developed fork of MySQL that aims to remain free and open-source software.

Key features:

Drop-in replacement for MySQL
Enhanced performance and features
Strong data consistency and integrity
Galera Cluster for multi-master replication

Docker image: mariadb

PostgreSQL

PostgreSQL is a powerful, open-source object-relational database system with a strong reputation for reliability and data integrity.

Key features:

Advanced SQL support
ACID compliance
Extensible through custom functions and data types
Full-text search capabilities

Docker image: postgres

MongoDB

MongoDB is a popular NoSQL database that provides high performance, high availability, and easy scalability.

Key features:

Document-oriented storage
Flexible schema design
Powerful query language
Built-in sharding and replication

Docker image: mongo

Redis

Redis is an open-source, in-memory data structure store, used as a database, cache, and message broker.

Key features:

High performance and low latency
Supports various data structures
Built-in replication and clustering
Pub/sub messaging paradigm

Docker image: redis

Comparison Table

Feature	MariaDB	PostgreSQL	MongoDB	Redis
Type	Relational	Relational	Document-oriented	Key-value
SQL Support	Yes	Yes	No (but has query language)	Limited
ACID Compliance	Yes	Yes	Optional	No
Scalability	Good	Good	Excellent	Excellent
Use Cases	General-purpose	Complex queries, OLTP	Flexible schema, large-scale apps	Caching, real-time analytics

These database containers can be used individually or in combination to support various applications and services:

Use MariaDB or PostgreSQL for traditional relational database needs
Implement MongoDB for applications requiring flexible schema and horizontal scalability
Utilize Redis for caching, session management, and real-time data processing

When setting up database containers, consider the following best practices:

Use volumes to persist data outside the container
Implement regular backups and test restoration procedures
Configure appropriate resource limits (CPU, memory) for each container
Use Docker networks to isolate database containers from public access
Regularly update your database containers to benefit from security patches and new features

Example docker-compose snippet for setting up a MariaDB container:

version: "3"
services:
  mariadb:
    image: mariadb:latest
    container_name: mariadb
    environment:
      MYSQL_ROOT_PASSWORD: your_root_password
      MYSQL_DATABASE: your_database_name
      MYSQL_USER: your_username
      MYSQL_PASSWORD: your_password
    volumes:
      - ./mariadb_data:/var/lib/mysql
    ports:
      - "3306:3306"
    restart: unless-stopped

By using these Docker containers, you can easily set up and manage various database systems for your home server, providing robust data storage and management capabilities for your applications and services.

Backup and Recovery Containers

Ensuring the safety and recoverability of your data is crucial for any home server setup. Docker containers offer several excellent solutions for backup and recovery. Let’s explore some of the most popular options:

Duplicati

Duplicati is a free, open-source backup software that securely stores encrypted, incremental, compressed backups on cloud storage services and remote file servers.

Key features:

Strong encryption (AES-256)
Incremental backups
Supports various cloud storage providers
Web-based user interface

Docker image: linuxserver/duplicati

Restic

Restic is a fast, secure, and efficient backup program that supports multiple storage backends.

Key features:

Deduplication and compression
Encryption by default
Fast incremental backups
Support for various storage backends (local, SFTP, S3, etc.)

Docker image: restic/restic

Borgmatic

Borgmatic is a simple, configuration-driven backup software that uses BorgBackup as its backend.

Key features:

Deduplication and compression
Encryption
Flexible retention policies
Hooks for pre and post-backup actions

Docker image: b3vis/borgmatic

Veeam

Veeam offers various backup solutions, including Veeam Backup & Replication Community Edition, which is free for up to 10 instances.

Key features:

Full, incremental, and synthetic full backups
Instant VM recovery
Built-in WAN acceleration
Comprehensive reporting

Note: Veeam doesn’t have an official Docker image, but you can run it in a VM alongside your Docker host.

Comparison Table

Feature	Duplicati	Restic	Borgmatic	Veeam
Encryption	Yes	Yes	Yes	Yes
Deduplication	Yes	Yes	Yes	Yes
Incremental Backups	Yes	Yes	Yes	Yes
Web UI	Yes	No	No	Yes
Cloud Storage Support	Extensive	Good	Limited	Good
Ease of Use	High	Medium	Medium	Medium

These backup and recovery containers can be used to create a comprehensive backup strategy for your home server:

Use Duplicati for user-friendly, web-based backups to various cloud storage providers.
Implement Restic for fast, efficient backups to local or remote storage.
Set up Borgmatic for flexible, configuration-driven backups using BorgBackup.
Consider Veeam for more advanced backup and recovery needs, especially if you’re running VMs.

When setting up your backup solution, consider the following best practices:

Follow the 3-2-1 backup rule: Keep at least three copies of your data, on two different storage types, with one copy off-site.
Regularly test your backups by performing test restores.
Encrypt your backups, especially when storing them off-site or in the cloud.
Set up automated backup schedules to ensure consistent backups.
Monitor your backup jobs and set up notifications for successful completions and failures.

Example docker-compose snippet for setting up a Duplicati container:

version: "3"
services:
  duplicati:
    image: linuxserver/duplicati
    container_name: duplicati
    environment:
      - PUID=1000
      - PGID=1000
      - TZ=Your/Timezone
    volumes:
      - ./duplicati_config:/config
      - /path/to/source/files:/source
      - /path/to/backups:/backups
    ports:
      - 8200:8200
    restart: unless-stopped

By using these Docker containers, you can easily set up and manage robust backup and recovery solutions for your home server, ensuring that your important data is protected and recoverable in case of any issues.

Personal Finance Containers

Docker containers offer several solutions for managing personal finances. Let’s explore some of the most popular options:

Firefly III

Firefly III is a free and open-source personal finance manager.

Key features:

Double-entry bookkeeping system
Budgeting and financial goal tracking
Bill management and recurring transactions
Detailed reports and charts

Docker image: fireflyiii/core

GnuCash

GnuCash is a free, open-source accounting software designed for personal and small business use.

Key features:

Double-entry bookkeeping
Scheduled transactions
Financial reports and graphs
Multi-currency support

Docker image: jrwrigh/gnucash

HomeBank

HomeBank is a free, easy-to-use personal accounting software.

Key features:

Multiple account management
Transaction categorization
Budgeting tools
Graphical reports

Docker image: linuxserver/homebank

Comparison Table

Feature	Firefly III	GnuCash	HomeBank
Web-based	Yes	No	No
Double-entry	Yes	Yes	No
Mobile App	No (but API available)	No	No
Multi-currency	Yes	Yes	Yes
Ease of Use	Medium	Medium	High

These personal finance containers can help you manage your finances more effectively:

Use Firefly III for a comprehensive, web-based personal finance management solution.
Implement GnuCash for more advanced accounting features and small business use.
Set up HomeBank for a simple, user-friendly approach to personal finance tracking.

When setting up your personal finance solution, consider the following:

Ensure proper security measures are in place to protect your sensitive financial data.
Regularly backup your financial data to prevent loss.
Consider using a reverse proxy (like Traefik or Nginx Proxy Manager) for secure access to web-based solutions.
Keep your containers updated to benefit from the latest features and security patches.

Example docker-compose snippet for setting up a Firefly III container:

version: "3"
services:
  firefly_iii:
    image: fireflyiii/core:latest
    container_name: firefly_iii
    environment:
      - APP_KEY=your_app_key_here
      - DB_HOST=firefly_db
      - DB_PORT=3306
      - DB_CONNECTION=mysql
      - DB_DATABASE=firefly
      - DB_USERNAME=firefly
      - DB_PASSWORD=your_password_here
    volumes:
      - ./firefly_iii_upload:/var/www/html/storage/upload
    ports:
      - "8080:8080"
    depends_on:
      - firefly_db
    restart: unless-stopped

  firefly_db:
    image: mariadb:latest
    container_name: firefly_db
    environment:
      - MYSQL_ROOT_PASSWORD=your_root_password_here
      - MYSQL_DATABASE=firefly
      - MYSQL_USER=firefly
      - MYSQL_PASSWORD=your_password_here
    volumes:
      - ./firefly_db_data:/var/lib/mysql
    restart: unless-stopped

By using these Docker containers, you can easily set up and manage personal finance tools on your home server, helping you track expenses, manage budgets, and achieve your financial goals.

Photography and Image Management Containers

Docker containers offer excellent solutions for managing and organizing your photo collections. Let’s explore some of the most popular options:

PhotoPrism

PhotoPrism is a feature-rich, AI-powered photo management solution that automatically organizes and tags your photo collection.

Key features:

AI-powered image classification and face recognition
Automatic tagging and geocoding
Full-text search
Web-based user interface with mobile support

Docker image: photoprism/photoprism

Lychee

Lychee is a free, open-source photo-management tool that allows you to create a self-hosted photo server.

Key features:

Clean, minimalist interface
Album creation and management
Password protection for albums
Import from various sources (local, URL, Dropbox)

Docker image: lycheeorg/lychee

Piwigo

Piwigo is a free and open-source photo gallery software that offers a wide range of features for managing your photo collection.

Key features:

Customizable themes and plugins
User management and access control
Batch import and upload
Tagging and search functionality

Docker image: linuxserver/piwigo

Comparison Table

Feature	PhotoPrism	Lychee	Piwigo
AI-powered organization	Yes	No	No
Face recognition	Yes	No	Via plugin
Mobile support	Yes	Yes	Yes
User management	Basic	No	Advanced
Customization	Limited	Limited	Extensive

These photography and image management containers can help you organize and showcase your photo collection:

Use PhotoPrism for advanced, AI-powered photo organization and management.
Implement Lychee for a simple, clean photo gallery solution.
Set up Piwigo for a highly customizable photo gallery with advanced user management.

When setting up your photography and image management solution, consider the following:

Ensure you have sufficient storage space for your photo collection.
Set up regular backups of your photo library and database.
Consider using a reverse proxy (like Traefik or Nginx Proxy Manager) for secure access to your photo gallery.
Keep your containers updated to benefit from the latest features and security patches.

Example docker-compose snippet for setting up a PhotoPrism container:

version: "3"
services:
  photoprism:
    image: photoprism/photoprism:latest
    container_name: photoprism
    depends_on:
      - mariadb
    environment:
      PHOTOPRISM_ADMIN_PASSWORD: "your_admin_password"
      PHOTOPRISM_SITE_URL: "http://your-site-url.com/"
      PHOTOPRISM_DATABASE_DRIVER: "mysql"
      PHOTOPRISM_DATABASE_SERVER: "mariadb:3306"
      PHOTOPRISM_DATABASE_NAME: "photoprism"
      PHOTOPRISM_DATABASE_USER: "photoprism"
      PHOTOPRISM_DATABASE_PASSWORD: "your_database_password"
    volumes:
      - ./photos:/photoprism/originals
      - ./storage:/photoprism/storage
    ports:
      - "2342:2342"
    restart: unless-stopped

  mariadb:
    image: mariadb:10.5
    container_name: photoprism-mariadb
    environment:
      MYSQL_ROOT_PASSWORD: "your_root_password"
      MYSQL_DATABASE: "photoprism"
      MYSQL_USER: "photoprism"
      MYSQL_PASSWORD: "your_database_password"
    volumes:
      - ./database:/var/lib/mysql
    restart: unless-stopped

By using these Docker containers, you can easily set up and manage powerful photography and image management solutions on your home server, helping you organize, showcase, and enjoy your photo collection.

E-book Management Containers

Docker containers offer excellent solutions for managing and organizing your e-book collection. Let’s explore some of the most popular options:

Calibre-web

Calibre-web is a web app providing a clean interface for browsing, reading and downloading e-books using an existing Calibre database.

Key features:

Clean, responsive web interface
OPDS feed for remote e-book reading
User management with fine-grained permissions
Integrates with existing Calibre libraries

Docker image: linuxserver/calibre-web

COPS (Calibre OPDS PHP Server)

COPS is a lightweight e-book server that serves your Calibre library through a web interface and an OPDS feed.

Key features:

Lightweight and fast
OPDS feed support
Multiple output formats (HTML, EPUB, MOBI)
Integrates with existing Calibre libraries

Docker image: lscr.io/linuxserver/cops:latest

Ubooquity

Ubooquity is a free, lightweight, and easy-to-use home server for your comics and ebooks.

Key features:

Supports both e-books and comics
Web-based reader
OPDS feed support
User management and access control

Docker image: linuxserver/ubooquity

Comparison Table

Feature	Calibre-web	COPS	Ubooquity
Web interface	Yes	Yes	Yes
OPDS support	Yes	Yes	Yes
Comic support	No	No	Yes
User management	Yes	No	Yes
Calibre integration	Yes	Yes	No

These e-book management containers can help you organize and access your digital library:

Use Calibre-web for a feature-rich, web-based interface to your Calibre library.
Implement COPS for a lightweight, fast solution focused on OPDS support.
Set up Ubooquity if you need support for both e-books and comics in a single application.

When setting up your e-book management solution, consider the following:

Ensure you have sufficient storage space for your e-book collection.
Set up regular backups of your e-book library and database.
Use a reverse proxy (like Traefik or Nginx Proxy Manager) for secure access to your e-book server.
Keep your containers updated to benefit from the latest features and security patches.

Example docker-compose snippet for setting up a Calibre-web container:

version: "3"
services:
  calibre-web:
    image: linuxserver/calibre-web
    container_name: calibre-web
    environment:
      - PUID=1000
      - PGID=1000
      - TZ=Your/Timezone
    volumes:
      - ./config:/config
      - /path/to/your/calibre/library:/books
    ports:
      - 8083:8083
    restart: unless-stopped

By using these Docker containers, you can easily set up and manage powerful e-book management solutions on your home server, helping you organize, access, and enjoy your digital library from any device.

Game Server Containers

Docker containers offer an excellent way to set up and manage game servers for various popular games. Let’s explore some of the most popular options:

Minecraft Server

Minecraft is a popular sandbox game that allows players to build, explore, and survive in a blocky, procedurally-generated world.

Key features:

Customizable server settings
Support for various game modes (Survival, Creative, Adventure)
Plugin support for extended functionality
Cross-platform play between Java and Bedrock editions (with additional setup)

Docker image: itzg/minecraft-server

Terraria Server

Terraria is a 2D action-adventure sandbox game that offers a vast world to explore, craft, and fight in.

Key features:

Customizable world generation
Support for various game modes
Multiplayer support for up to 255 players
Mod support (tModLoader)

Docker image: ryshe/terraria

Factorio Server

Factorio is a game about building and maintaining factories while defending against alien threats.

Key features:

Highly optimized for multiplayer
Mod support
Customizable map settings
Automatic saving and server management

Docker image: factoriotools/factorio

Valheim Server

Valheim is a survival and exploration game set in a procedurally-generated world inspired by Norse mythology.

Key features:

Cooperative gameplay for up to 10 players
Customizable server settings
World persistence
Cross-platform play between Windows and Linux

Docker image: lloesche/valheim-server

Comparison Table

Feature	Minecraft	Terraria	Factorio	Valheim
Player Limit	Configurable	Up to 255	Unlimited	Up to 10
Mod Support	Yes	Yes	Yes	Limited
Cross-platform	Yes*	Yes	No	Yes
Resource Usage	Moderate	Low	High	Moderate

*Requires additional setup for Java-Bedrock cross-play

When setting up game server containers, consider the following best practices:

Allocate sufficient resources (CPU, RAM) based on the game’s requirements and expected player count
Use volumes to persist game data and world saves outside the container
Configure automatic backups to prevent data loss
Use a reverse proxy or VPN for secure remote access to your game servers
Keep your game server containers updated to benefit from the latest features and security patches

Example docker-compose snippet for setting up a Minecraft server container:

version: "3"
services:
  minecraft:
    image: itzg/minecraft-server
    container_name: minecraft
    environment:
      EULA: "TRUE"
      MEMORY: "2G"
      TYPE: "PAPER"
      DIFFICULTY: "normal"
      ALLOW_NETHER: "true"
      ENABLE_COMMAND_BLOCK: "true"
    volumes:
      - ./minecraft_data:/data
    ports:
      - "25565:25565"
    restart: unless-stopped

By using these Docker containers, you can easily set up and manage game servers on your home server, providing a fun and customizable gaming experience for you and your friends. Remember to check the specific documentation for each game server container, as they may have additional configuration options and requirements.

Communication Containers

Docker containers offer excellent solutions for setting up your own communication platforms. Let’s explore some of the most popular options:

Mattermost

Mattermost is an open-source, self-hostable alternative to Slack, providing team messaging and collaboration features.

Key features:

Team messaging and file sharing
Integrations with various tools and services
Customizable themes and branding
End-to-end encryption (in Enterprise edition)

Docker image: mattermost/mattermost-team-edition

Rocket.Chat

Rocket.Chat is a free and open-source team communication platform that offers chat, video conferencing, and file sharing capabilities.

Key features:

Real-time chat with channels and direct messages
Video and audio calls
File sharing and screen sharing
Customizable with a marketplace of apps and integrations

Docker image: rocket.chat

Jitsi Meet

Jitsi Meet is a fully encrypted, 100% open-source video conferencing solution that you can use all day, every day, for free.

Key features:

High-quality video and audio conferencing
Screen sharing and collaborative document editing
No account required for participants
Mobile apps for iOS and Android

Docker image: jitsi/web

Matrix Synapse

Matrix Synapse is the reference homeserver implementation of the Matrix protocol, an open standard for secure, decentralized real-time communication.

Key features:

End-to-end encryption
Federated architecture for decentralized communication
Supports various clients (e.g., Element)
Bridges to other communication platforms

Docker image: matrixdotorg/synapse

Comparison Table

Feature	Mattermost	Rocket.Chat	Jitsi Meet	Matrix Synapse
Primary Focus	Team Chat	Team Chat	Video Conferencing	Decentralized Communication
Video Calls	Via plugins	Built-in	Built-in	Via clients
E2E Encryption	Enterprise only	Optional	Yes	Yes
Federation	No	No	No	Yes
Mobile Apps	Yes	Yes	Yes	Via clients

When setting up communication containers, consider the following best practices:

Use HTTPS with valid SSL certificates for secure communication
Implement proper user authentication and access control
Regularly backup your data and configuration
Keep your containers updated to benefit from the latest features and security patches
Consider using a reverse proxy (like Traefik or Nginx Proxy Manager) for secure access to your communication platforms

Example docker-compose snippet for setting up a Mattermost container:

version: "3"
services:
  mattermost:
    image: mattermost/mattermost-team-edition:latest
    container_name: mattermost
    depends_on:
      - db
    environment:
      - MM_SQLSETTINGS_DRIVERNAME=postgres
      - MM_SQLSETTINGS_DATASOURCE=postgres://mmuser:mmuser_password@db:5432/mattermost?sslmode=disable&connect_timeout=10
    volumes:
      - ./mattermost-data:/mattermost/data
      - ./mattermost-logs:/mattermost/logs
      - ./mattermost-config:/mattermost/config
    ports:
      - "8065:8065"
    restart: unless-stopped

  db:
    image: postgres:13
    container_name: mattermost-db
    environment:
      - POSTGRES_USER=mmuser
      - POSTGRES_PASSWORD=mmuser_password
      - POSTGRES_DB=mattermost
    volumes:
      - ./postgres-data:/var/lib/postgresql/data
    restart: unless-stopped

By using these Docker containers, you can easily set up and manage various communication platforms on your home server, providing secure and customizable communication solutions for your team or personal use.

Document Management Containers

Docker containers offer excellent solutions for managing and organizing your documents. Let’s explore some of the most popular options:

Paperless-ng

Paperless-ng is a document management system that transforms your physical documents into a searchable online archive.

Key features:

OCR (Optical Character Recognition) for scanned documents
Automatic tagging and classification
Full-text search
Mobile-friendly web interface

Docker image: jonaswinkler/paperless-ng

Mayan EDMS

Mayan EDMS is a free and open-source electronic document management system.

Key features:

Document versioning
Fine-grained access control
Workflow automation
OCR and full-text search

Docker image: mayanedms/mayanedms

OpenKM

OpenKM is a document management system that helps you manage, track, and store documents.

Key features:

Document versioning and workflow
Metadata and taxonomy management
Full-text indexing and search
Integration with external applications

Docker image: openkm/openkm-ce

Comparison Table

Feature	Paperless-ng	Mayan EDMS	OpenKM
OCR	Yes	Yes	Yes
Full-text search	Yes	Yes	Yes
Workflow automation	Limited	Yes	Yes
Mobile-friendly	Yes	Yes	Limited
Document versioning	No	Yes	Yes

These document management containers can help you organize and access your digital documents:

Use Paperless-ng for a lightweight, user-friendly solution focused on personal document management.
Implement Mayan EDMS for a more comprehensive document management system with advanced features.
Set up OpenKM if you need extensive integration capabilities and advanced workflow management.

When setting up your document management solution, consider the following:

Ensure you have sufficient storage space for your document collection.
Set up regular backups of your document library and database.
Use a reverse proxy (like Traefik or Nginx Proxy Manager) for secure access to your document management system.
Keep your containers updated to benefit from the latest features and security patches.

Example docker-compose snippet for setting up a Paperless-ng container:

version: "3"
services:
  paperless:
    image: jonaswinkler/paperless-ng:latest
    container_name: paperless
    depends_on:
      - redis
      - db
    environment:
      - PAPERLESS_TIME_ZONE=Your/Timezone
      - PAPERLESS_OCR_LANGUAGE=eng
      - PAPERLESS_SECRET_KEY=your_secret_key_here
    volumes:
      - ./data:/usr/src/paperless/data
      - ./media:/usr/src/paperless/media
      - ./export:/usr/src/paperless/export
      - ./consume:/usr/src/paperless/consume
    ports:
      - "8000:8000"
    restart: unless-stopped

  redis:
    image: redis:6
    container_name: paperless-redis
    restart: unless-stopped

  db:
    image: postgres:13
    container_name: paperless-db
    environment:
      - POSTGRES_DB=paperless
      - POSTGRES_USER=paperless
      - POSTGRES_PASSWORD=paperless
    volumes:
      - ./pgdata:/var/lib/postgresql/data
    restart: unless-stopped

By using these Docker containers, you can easily set up and manage powerful document management solutions on your home server, helping you organize, search, and access your digital documents efficiently.

Web Hosting Containers

Docker containers offer excellent solutions for hosting websites and content management systems. Let’s explore some of the most popular options:

WordPress

WordPress is the world’s most popular content management system, powering over 40% of all websites on the internet.

Key features:

User-friendly content management
Extensive plugin and theme ecosystem
SEO-friendly
Suitable for blogs, e-commerce, and complex websites

Docker image: wordpress

Ghost

Ghost is a modern, open-source publishing platform designed for creating professional publications and newsletters.

Key features:

Clean, minimalist interface
Built-in SEO tools
Membership and subscription features
Native email newsletter functionality

Docker image: ghost

Drupal

Drupal is a flexible and powerful content management system known for its robustness and scalability.

Key features:

Highly customizable
Strong security features
Excellent for complex, content-heavy websites
Large community and extensive module ecosystem

Docker image: drupal

Joomla

Joomla is a popular content management system that offers a balance between ease of use and powerful features.

Key features:

User-friendly administration
Multilingual support out of the box
Extensive extension directory
Suitable for various types of websites

Docker image: joomla

Comparison Table

Feature	WordPress	Ghost	Drupal	Joomla
Ease of Use	High	High	Medium	Medium
Customizability	High	Medium	Very High	High
Performance	Good	Excellent	Good	Good
Plugin Ecosystem	Extensive	Limited	Extensive	Extensive
Best For	General-purpose	Blogging, Publications	Complex sites	Medium to large sites

When setting up web hosting containers, consider the following best practices:

Use separate containers for your web server, database, and application
Implement proper security measures, including SSL certificates and regular updates
Set up automated backups for your website data and database
Use a reverse proxy (like Traefik or Nginx Proxy Manager) for secure access and easy SSL management
Monitor resource usage and scale your containers as needed

Example docker-compose snippet for setting up a WordPress container:

version: "3"
services:
  wordpress:
    image: wordpress:latest
    container_name: wordpress
    depends_on:
      - db
    environment:
      - WORDPRESS_DB_HOST=db
      - WORDPRESS_DB_USER=wordpress
      - WORDPRESS_DB_PASSWORD=wordpress_password
      - WORDPRESS_DB_NAME=wordpress
    volumes:
      - ./wordpress:/var/www/html
    ports:
      - "8080:80"
    restart: unless-stopped

  db:
    image: mysql:5.7
    container_name: wordpress-db
    environment:
      - MYSQL_DATABASE=wordpress
      - MYSQL_USER=wordpress
      - MYSQL_PASSWORD=wordpress_password
      - MYSQL_RANDOM_ROOT_PASSWORD=1
    volumes:
      - ./mysql:/var/lib/mysql
    restart: unless-stopped

By using these Docker containers, you can easily set up and manage various content management systems and web hosting solutions on your home server. This allows you to create and maintain websites, blogs, or online publications with ease, while maintaining full control over your hosting environment.

Personal Dashboard Containers

Docker containers offer excellent solutions for creating personal dashboards that help you organize and access your self-hosted services. Let’s explore some of the most popular options:

Heimdall

Heimdall is a sleek, customizable application dashboard that allows you to organize all your web applications and services in one place.

Key features:

Clean, modern interface
Customizable icons and colors
Support for enhanced apps with additional functionality
Multiple user support with fine-grained access control

Docker image: linuxserver/heimdall

Organizr

Organizr is a PHP-based dashboard that brings all your services together in one place, with a focus on media server management.

Key features:

Tabbed interface for easy navigation
Integration with popular media server applications
Customizable themes and layouts
User management and authentication

Docker image: organizr/organizr

Homer

Homer is a simple, lightweight, and highly customizable static dashboard for your server.

Key features:

Minimalist design
Easy configuration using YAML files
Support for custom CSS and icons
Lightweight and fast-loading

Docker image: b4bz/homer

Comparison Table

Feature	Heimdall	Organizr	Homer
Interface	Modern, tile-based	Tabbed	Static, customizable
Customization	High	High	Very High
User Management	Yes	Yes	No
Enhanced App Support	Yes	Yes	No
Ease of Setup	Easy	Medium	Easy

These personal dashboard containers can help you organize and access your self-hosted services:

Use Heimdall for a polished, feature-rich dashboard with enhanced app support.
Implement Organizr if you’re primarily focused on media server management and want deep integration.
Set up Homer for a lightweight, highly customizable static dashboard that’s easy to configure.

When setting up your personal dashboard solution, consider the following:

Choose a dashboard that fits your specific needs and aesthetic preferences.
Ensure proper security measures, such as using HTTPS and implementing authentication.
Regularly update your dashboard container to benefit from the latest features and security patches.
Consider using a reverse proxy (like Traefik or Nginx Proxy Manager) for secure access to your dashboard.

Example docker-compose snippet for setting up a Heimdall container:

version: "3"
services:
  heimdall:
    image: linuxserver/heimdall
    container_name: heimdall
    environment:
      - PUID=1000
      - PGID=1000
      - TZ=Your/Timezone
    volumes:
      - ./config:/config
    ports:
      - "80:80"
      - "443:443"
    restart: unless-stopped

By using these Docker containers, you can easily set up and manage a personal dashboard on your home server, providing a centralized point of access for all your self-hosted services and applications. This not only improves organization but also enhances the overall user experience of your home server setup.

RSS Feed Containers

Docker containers offer excellent solutions for managing and reading RSS feeds. Let’s explore some of the most popular options:

FreshRSS

FreshRSS is a free, self-hostable RSS feed aggregator that’s lightweight and customizable.

Key features:

Clean, responsive web interface
Supports keyboard shortcuts for efficient navigation
Customizable themes and extensions
API support for mobile apps (compatible with Google Reader API)

Docker image: linuxserver/freshrss

Tiny Tiny RSS

Tiny Tiny RSS is a free and open-source web-based news feed (RSS/Atom) reader and aggregator.

Key features:

Customizable interface with themes
Plugins for extended functionality
Mobile-friendly web interface
API for third-party clients and mobile apps

Docker image: linuxserver/tt-rss

Miniflux

Miniflux is a minimalist and opinionated feed reader, focusing on simplicity and performance.

Key features:

Clean, distraction-free interface
Built-in support for various content scraping methods
Fever API support for third-party clients
Keyboard shortcuts for efficient navigation

Docker image: miniflux/miniflux

Comparison Table

Feature	FreshRSS	Tiny Tiny RSS	Miniflux
Interface	Clean, customizable	Customizable	Minimalist
Extensions/Plugins	Yes	Yes	No
API Support	Yes (Google Reader)	Yes (Custom)	Yes (Fever)
Performance	Good	Good	Excellent
Ease of Setup	Easy	Medium	Easy

These RSS feed containers can help you manage and read your favorite news and content sources:

Use FreshRSS for a feature-rich, customizable RSS reader with good mobile app support.
Implement Tiny Tiny RSS if you need extensive plugin support and don’t mind a slightly more complex setup.
Set up Miniflux for a minimalist, high-performance RSS reader that focuses on the essentials.

When setting up your RSS feed solution, consider the following:

Choose a reader that fits your reading habits and preferences.
Ensure proper security measures, such as using HTTPS and implementing authentication.
Regularly update your RSS reader container to benefit from the latest features and security patches.
Consider using a reverse proxy (like Traefik or Nginx Proxy Manager) for secure access to your RSS reader.

Example docker-compose snippet for setting up a FreshRSS container:

version: "3"
services:
  freshrss:
    image: linuxserver/freshrss
    container_name: freshrss
    environment:
      - PUID=1000
      - PGID=1000
      - TZ=Your/Timezone
    volumes:
      - ./config:/config
    ports:
      - "8080:80"
    restart: unless-stopped

By using these Docker containers, you can easily set up and manage an RSS feed reader on your home server, allowing you to stay up-to-date with your favorite news sources, blogs, and websites in a centralized, self-hosted solution. This gives you full control over your news consumption while ensuring your reading habits remain private.

Weather Monitoring Containers

Docker containers offer excellent solutions for monitoring and analyzing weather data. Let’s explore some of the most popular options:

Weewx

Weewx is a free, open-source weather station software that collects data from various weather sensors and generates reports, graphs, and web pages.

Key features:

Supports a wide range of weather stations and sensors
Customizable reports and graphs
Extensible through plugins
Can upload data to popular weather services

Docker image: felddy/weewx

Meteobridge

Meteobridge is a commercial weather station data logger and uploader that can be run in a Docker container.

Key features:

Supports various weather stations and sensors
Real-time data processing and uploading
Customizable web interface
Integration with multiple weather services

Docker image: acperez/meteobridge-docker (unofficial)

Comparison Table

Feature	Weewx	Meteobridge
Open-source	Yes	No
Supported Stations	Wide range	Wide range
Customization	High	Medium
Ease of Setup	Medium	Easy
Cost	Free	Paid license required

These weather monitoring containers can help you collect, analyze, and display weather data from your personal weather station:

Use Weewx for a free, highly customizable solution with extensive support for various weather stations.
Implement Meteobridge if you prefer a commercial solution with easier setup and real-time data processing.

When setting up your weather monitoring solution, consider the following:

Ensure your weather station or sensors are compatible with the chosen software.
Set up proper networking to allow the container to communicate with your weather station.
Configure regular backups of your weather data.
Consider using a reverse proxy (like Traefik or Nginx Proxy Manager) for secure access to your weather dashboard.

Example docker-compose snippet for setting up a Weewx container:

version: "3"
services:
  weewx:
    image: felddy/weewx
    container_name: weewx
    environment:
      - TZ=Your/Timezone
      - WEEWX_UID=1000
      - WEEWX_GID=1000
    volumes:
      - ./config:/config
      - ./data:/home/weewx/archive
    devices:
      - /dev/ttyUSB0:/dev/ttyUSB0
    ports:
      - "8080:80"
    restart: unless-stopped

By using these Docker containers, you can easily set up and manage a weather monitoring system on your home server. This allows you to collect and analyze data from your personal weather station, create custom reports and graphs, and even contribute to larger weather monitoring networks.

Remember to check the specific documentation for each weather monitoring container, as they may have additional configuration options and requirements based on your specific weather station and sensors.

Time Tracking Containers

Docker containers offer excellent solutions for tracking and managing your time. Let’s explore some of the most popular options:

Kimai

Kimai is a free, open-source time-tracking application that can be used for project management, freelance billing, or personal time management.

Key features:

User-friendly interface with responsive design
Detailed reporting and export options
Project and customer management
Customizable through plugins
Multi-user support with role-based permissions

Docker image: kimai/kimai2

TimeTagger

TimeTagger is a simple, open-source time tracking application with a focus on ease of use and flexibility.

Key features:

Intuitive timeline-based interface
Keyboard shortcuts for quick entry
Customizable tags and projects
Data export in various formats
Self-hosted option for privacy

Docker image: almarklein/timetagger

Comparison Table

Feature	Kimai	TimeTagger
Interface	Feature-rich, customizable	Simple, timeline-based
Reporting	Extensive	Basic
Multi-user support	Yes	Limited
Project management	Yes	Basic
Ease of use	Good	Excellent

These time tracking containers can help you manage your time more effectively:

Use Kimai for a comprehensive time tracking solution with extensive project management and reporting features.
Implement TimeTagger for a simpler, more intuitive approach to personal time tracking.

When setting up your time tracking solution, consider the following:

Choose a solution that fits your specific needs (personal use, team management, or client billing).
Ensure proper security measures, such as using HTTPS and implementing authentication.
Regularly backup your time tracking data.
Keep your containers updated to benefit from the latest features and security patches.

Example docker-compose snippet for setting up a Kimai container:

version: "3"
services:
  kimai:
    image: kimai/kimai2:latest
    container_name: kimai
    environment:
      - TRUSTED_HOSTS=localhost,127.0.0.1
      - DATABASE_URL=mysql://kimaiuser:kimaipassword@db:3306/kimai
      - APP_ENV=prod
    volumes:
      - ./kimai_data:/opt/kimai/var
    ports:
      - "8001:8001"
    depends_on:
      - db
    restart: unless-stopped

  db:
    image: mysql:5.7
    container_name: kimai-db
    environment:
      - MYSQL_DATABASE=kimai
      - MYSQL_USER=kimaiuser
      - MYSQL_PASSWORD=kimaipassword
      - MYSQL_ROOT_PASSWORD=rootpassword
    volumes:
      - ./mysql_data:/var/lib/mysql
    restart: unless-stopped

By using these Docker containers, you can easily set up and manage a time tracking system on your home server. This allows you to monitor your work hours, manage projects, and generate reports, all while maintaining control over your data and ensuring your privacy.

Remember to check the specific documentation for each time tracking container, as they may have additional configuration options and requirements based on your specific needs and use case.

Password Management Containers

Docker containers offer secure and convenient solutions for managing your passwords and sensitive information. Let’s explore some of the most popular options:

Passbolt

Passbolt is an open-source password manager designed for team collaboration, with a focus on security and ease of use.

Key features:

End-to-end encryption
User-friendly web interface
Browser extensions for easy access
Granular access control and user management
API for integration with other tools

Docker image: passbolt/passbolt

Vaultwarden (Bitwarden RS)

Vaultwarden (formerly known as Bitwarden RS) is an unofficial Bitwarden server implementation written in Rust, designed to be lighter and more efficient than the official server.

Key features:

Compatible with official Bitwarden clients
End-to-end encryption
Self-hosted for complete control over your data
Supports all core Bitwarden features
Low resource requirements

Docker image: vaultwarden/server

Comparison Table

Feature	Passbolt	Vaultwarden
Focus	Team collaboration	Personal and small team use
Client compatibility	Custom web interface and browser extensions	Official Bitwarden clients
Resource usage	Moderate	Low
Setup complexity	Moderate	Easy
API availability	Yes	Limited

These password management containers can help you securely store and manage your passwords:

Use Passbolt for team-oriented password management with granular access control.
Implement Vaultwarden for a lightweight, Bitwarden-compatible solution suitable for personal or small team use.

When setting up your password management solution, consider the following best practices:

Always use HTTPS with valid SSL certificates to encrypt communications.
Implement strong authentication methods, such as two-factor authentication.
Regularly backup your password database and encryption keys.
Keep your containers and host system updated with the latest security patches.
Use a reverse proxy (like Traefik or Nginx Proxy Manager) for secure access to your password manager.

Example docker-compose snippet for setting up a Vaultwarden container:

version: "3"
services:
  vaultwarden:
    image: vaultwarden/server:latest
    container_name: vaultwarden
    environment:
      - WEBSOCKET_ENABLED=true
      - SIGNUPS_ALLOWED=false
    volumes:
      - ./vw-data:/data
    ports:
      - "80:80"
    restart: unless-stopped

By using these Docker containers, you can easily set up and manage a secure password management system on your home server. This allows you to maintain control over your sensitive information while providing convenient access across your devices.

Remember to choose a solution that best fits your needs, whether you’re looking for personal password management or a team-oriented solution with advanced access controls. Always prioritize security when dealing with password managers, as they are a critical component of your overall digital security strategy.

VoIP Containers

Docker containers offer excellent solutions for setting up your own Voice over IP (VoIP) system. Let’s explore some of the most popular options:

Asterisk

Asterisk is a powerful, open-source framework for building communications applications, including VoIP systems.

Key features:

Supports various VoIP protocols (SIP, IAX, etc.)
Highly customizable and extensible
Can function as a PBX, VoIP gateway, or conference bridge
Supports interactive voice response (IVR) systems

Docker image: andrius/asterisk

FreePBX

FreePBX is a web-based open-source GUI that controls and manages Asterisk, making it easier to set up and manage a VoIP system.

Key features:

User-friendly web interface for managing Asterisk
Extensive module system for adding functionality
Built-in reporting and call logging
Supports various VoIP phones and softphones

Docker image: tiredofit/freepbx

Comparison Table

Feature	Asterisk	FreePBX
User Interface	Command-line	Web-based GUI
Customization	High (requires technical knowledge)	High (through modules)
Ease of Use	Complex	User-friendly
Resource Usage	Low	Moderate
Best For	Advanced users, custom solutions	Small to medium businesses, less technical users

These VoIP containers can help you set up your own phone system:

Use Asterisk for a highly customizable, lightweight VoIP solution if you have technical expertise.
Implement FreePBX for a more user-friendly approach to managing an Asterisk-based system.

When setting up your VoIP solution, consider the following best practices:

Ensure your network is properly configured for VoIP traffic (QoS, port forwarding, etc.).
Implement strong security measures, including firewalls and encryption for SIP traffic.
Regularly backup your VoIP system configuration and data.
Keep your containers and host system updated with the latest security patches.
Consider using a reverse proxy (like Traefik or Nginx Proxy Manager) for secure access to the management interface.

Example docker-compose snippet for setting up a FreePBX container:

version: "3"
services:
  freepbx:
    image: tiredofit/freepbx:latest
    container_name: freepbx
    environment:
      - TIMEZONE=America/New_York
      - ENABLE_CRON=TRUE
      - ENABLE_SMTP=FALSE
    volumes:
      - ./freepbx-data:/data
      - ./freepbx-logs:/var/log
    ports:
      - "80:80"
      - "5060:5060/udp"
      - "5160:5160/udp"
      - "16384-16484:16384-16484/udp"
    restart: unless-stopped

By using these Docker containers, you can easily set up and manage a VoIP system on your home server. This allows you to create your own phone system, potentially saving on communication costs and gaining more control over your telecommunications infrastructure.

Remember to carefully consider your specific needs and technical expertise when choosing between Asterisk and FreePBX. While Asterisk offers more flexibility and customization options, it requires more technical knowledge to set up and maintain. FreePBX, on the other hand, provides a more user-friendly interface for managing Asterisk, making it a good choice for those who prefer a graphical interface and easier management.

Best Practices for Managing Docker Containers

When running multiple Docker containers on your home server, it’s important to follow best practices to ensure optimal performance, security, and maintainability. Let’s explore some key areas to focus on:

Container organization

Properly organizing your Docker containers can make management and troubleshooting much easier:

Use meaningful container names and labels for easy identification
Group related containers using Docker Compose
Implement a consistent naming convention for volumes and networks
Use Docker networks to isolate container groups

Example of organizing containers with Docker Compose:

version: "3"
services:
  web:
    image: nginx:latest
    container_name: myapp-web
    labels:
      - "com.example.description=Web server for MyApp"
    networks:
      - myapp-network

  db:
    image: mysql:5.7
    container_name: myapp-db
    labels:
      - "com.example.description=Database for MyApp"
    networks:
      - myapp-network

networks:
  myapp-network:
    name: myapp-network

Resource allocation

Properly allocating resources to your containers ensures stable performance and prevents one container from impacting others:

Set memory limits for each container to prevent memory exhaustion
Use CPU quotas to prevent a single container from monopolizing CPU resources
Monitor resource usage and adjust limits as needed
Consider using Docker Swarm or Kubernetes for more advanced resource management in larger setups

Example of setting resource limits in Docker Compose:

version: "3"
services:
  myapp:
    image: myapp:latest
    deploy:
      resources:
        limits:
          cpus: "0.50"
          memory: 512M
        reservations:
          cpus: "0.25"
          memory: 256M

Security considerations

Securing your Docker containers is crucial to protect your home server and data:

Keep Docker and container images up to date
Use official images from trusted sources
Implement the principle of least privilege (run containers as non-root users when possible)
Use secrets management for sensitive data (e.g., Docker secrets or environment variables)
Regularly scan your containers for vulnerabilities (e.g., using tools like Trivy or Clair)
Implement network segmentation using Docker networks

Example of running a container as a non-root user:

version: "3"
services:
  myapp:
    image: myapp:latest
    user: 1000:1000

Updating and maintenance

Regular updates and maintenance are essential for keeping your Docker environment healthy and secure:

Set up automated updates for your containers (e.g., using Watchtower)
Implement a backup strategy for your container data and configurations
Regularly prune unused images, containers, and volumes to free up disk space
Monitor container logs for errors and issues
Use Docker Compose for easier updates and rollbacks

Example of using Watchtower for automated updates:

version: "3"
services:
  watchtower:
    image: containrrr/watchtower
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock
    command: --interval 86400 --cleanup
    restart: unless-stopped

By following these best practices, you can ensure that your Docker-based home server remains organized, efficient, secure, and easy to maintain. Remember to regularly review and update your Docker setup to take advantage of new features and security improvements.

Troubleshooting Common Issues

When running Docker containers on your home server, you may encounter various issues. Here are some common problems and their solutions:

Network connectivity problems

Network issues can prevent containers from communicating with each other or the outside world. Here are some troubleshooting steps:

Check container network settings:
- Ensure containers are on the correct network
- Verify port mappings are correct

Inspect Docker networks:

docker network ls
docker network inspect <network_name>

Use tools like ping or curl from within containers to test connectivity:
```
docker exec -it <container_name> ping <destination>
```
Check host firewall settings to ensure necessary ports are open
Verify that the Docker daemon is running and responsive:
```
systemctl status docker
```

Container conflicts

Conflicts between containers can cause various issues. Here’s how to address them:

Check for port conflicts:
- Use docker ps to view running containers and their port mappings
- Modify port mappings in your Docker Compose file or run command if conflicts exist
Resolve name conflicts:
- Ensure container names are unique
- Use docker rename to change conflicting names
Address volume mount conflicts:
- Check volume definitions in your Docker Compose file
- Use docker volume ls and docker volume inspect to investigate volume issues
Resolve network conflicts:
- Ensure containers are on the correct networks
- Use docker network prune to remove unused networks

Resource constraints

Resource limitations can cause containers to perform poorly or crash. Here’s how to identify and resolve these issues:

Monitor resource usage:
- Use docker stats to view container resource usage in real-time
- Implement monitoring solutions like Prometheus and Grafana for more detailed insights

Adjust resource limits:

Modify memory and CPU limits in your Docker Compose file or run command

Example:

services:
  myapp:
    image: myapp:latest
    deploy:
      resources:
        limits:
          cpus: "0.5"
          memory: 512M

Check for memory leaks:
- Monitor container memory usage over time
- Update or replace containers with memory leak issues
Optimize container performance:
- Use multi-stage builds to create smaller images
- Implement proper caching strategies in Dockerfiles
Consider upgrading hardware if resource constraints persist

By following these troubleshooting steps, you can resolve many common issues that arise when running Docker containers on your home server. Remember to keep your Docker installation and container images up to date, as newer versions often include bug fixes and performance improvements.

Conclusions

Recap of the best Docker containers for home servers

Throughout this article, we’ve explored a wide range of Docker containers that can enhance your home server setup. Here’s a quick recap of some of the best options across various categories:

Media Management: Plex, Jellyfin, Sonarr, Radarr
File Sharing: Nextcloud, Syncthing
Home Automation: Home Assistant, Node-RED
Network Management: Pi-hole, Traefik
Monitoring: Grafana, Prometheus
Security: Bitwarden, OpenVPN
Productivity: Bookstack, Kanboard
Development: GitLab, Jenkins

These containers offer powerful, customizable solutions for various home server needs, from media streaming and file sharing to home automation and network management.

Future trends in home server containerization

As Docker and container technology continue to evolve, we can expect several trends to shape the future of home server containerization:

Increased focus on security: With growing concerns about data privacy and security, future container solutions will likely place even greater emphasis on built-in security features and best practices.
Improved resource management: As home servers become more powerful, we can expect more sophisticated resource allocation and management tools to optimize container performance.
Integration with edge computing: The rise of edge computing may lead to new container solutions that better leverage distributed computing resources in home environments.
AI and machine learning integration: More containers may incorporate AI and machine learning capabilities to enhance automation, data analysis, and user experience.
Simplified management interfaces: As containerization becomes more mainstream, we can expect more user-friendly interfaces and management tools to emerge, making it easier for non-technical users to leverage container technology.

Final thoughts and recommendations

Docker containers offer an excellent way to enhance your home server’s capabilities while maintaining flexibility and ease of management. Here are some final recommendations:

Start small: Begin with a few essential containers and gradually expand your setup as you become more comfortable with Docker.
Prioritize security: Always follow security best practices, including keeping your containers updated, using secure networks, and implementing proper authentication.
Monitor and maintain: Regularly monitor your containers’ performance and resource usage, and perform maintenance tasks like updates and backups.
Join the community: Engage with the Docker and home server communities to stay informed about new developments, share experiences, and get help when needed.
Experiment and customize: Don’t be afraid to experiment with different containers and configurations to find the perfect setup for your needs.

By leveraging Docker containers, you can create a powerful, flexible, and customized home server environment that caters to your specific needs while providing valuable learning opportunities in containerization and server management.

Remember that the world of Docker containers is constantly evolving, with new and improved solutions emerging regularly. Stay curious, keep learning, and enjoy the process of building and maintaining your ideal home server setup!

#Docker

Best 100+ Docker Containers for Home Server

Setting Up Your Home Server

Hardware requirements

Operating system considerations

Installing Docker

Media Management Containers

Plex

Jellyfin

Emby

Comparison Table

Sonarr

Radarr

Lidarr

Jackett

Transmission

qBittorrent

File Sharing and Sync Containers

Nextcloud

Syncthing

Seafile

ownCloud

Filebrowser

Comparison Table

AI Applications Containers

Ollama with OpenWebUI

Flowise

Langflow

Langfuse

LiteLLM

Comparison Table

Home Automation Containers

Home Assistant

Node-RED

Mosquitto MQTT Broker

OpenHAB

Comparison Table

Network Management Containers

Pi-hole

Unbound

Traefik

Nginx Proxy Manager

Portainer

Dockge

Comparison Table

Monitoring and Analytics Containers

Grafana

Prometheus

InfluxDB

Telegraf

Netdata

Comparison Table

Security and Privacy Containers

Bitwarden

OpenVPN

WireGuard

Fail2Ban

Comparison Table

Productivity Containers

Bookstack

Joplin

Kanboard

Wekan

Docmost

Comparison Table

Development Containers

GitLab

Jenkins

Gitea

Drone CI

Comparison Table

Database Containers

MariaDB

PostgreSQL

MongoDB

Redis

Comparison Table

Backup and Recovery Containers

Duplicati

Restic

Borgmatic