DEV Community: Marin

Recyclarr + Docker: Easy TRaSH-Guides Sync for Your Media Server

Marin — Thu, 11 Sep 2025 17:49:23 +0000

If you’re running a homelab media server, you’ve probably used Radarr and Sonarr to automate your movie and TV libraries. But keeping them tuned with the latest recommended quality profiles and naming standards from TRaSH-Guides can be a chore. That’s where Recyclarr comes in, it automatically syncs your Radarr and Sonarr settings with TRaSH-Guides so your setup stays clean and consistent.

This guide assumes you already have a media server stack (e.g., Sonarr/Radarr + Docker) up and running.

📑 Table of Contents

🤔 What is Recyclarr?
🛠️ Docker Compose: config setup
📦 Configuration basics (recyclarr.yml)
💾 Optional: Customizing Recyclarr
✅ Final Thoughts

🤔 What is Recyclarr? (and why run it in Docker)

Recyclarr is an open-source tool that keeps your Sonarr and Radarr settings in sync with the latest recommendations from TRaSH-Guides. Instead of manually copying quality profiles, custom formats, and naming schemes, Recyclarr automatically pulls the newest configs from TRaSH-Guides and applies them to your apps. That means less time tweaking settings and more time enjoying a clean, consistent media library.

Updates happen on two levels:

The tool itself: updated by the Recyclarr project (easy to pull new versions via Docker).
The configs: fetched from TRaSH-Guides every time you run a sync, so you always get the latest community best practices.

Running Recyclarr in Docker makes it even easier:

Deploy with a single docker compose up -d
Update by pulling the latest image and restarting the container
Keep everything isolated and reproducible, just like the rest of your media stack

For anyone already using Docker for Plex/Jellyfin, Sonarr, Radarr, or other homelab apps, Recyclarr slots right in with minimal effort.

🛠️ Docker Compose: config setup

1. Create the config folder

First, create a folder for Recyclarr’s configuration. This is where your recyclarr.yml file will live:

mkdir recyclarr

2. Add docker-compose.yml

Create a docker-compose.yml in the same directory with the following content:

version: "3.9"

# Optional: only needed if Sonarr/Radarr are in a different compose file
networks:
  media-server:
    external: true

services:
  recyclarr:
    image: ghcr.io/recyclarr/recyclarr:latest
    container_name: recyclarr
    networks:
      - media-server   # Optional (see explanation below)
    environment:
      - TZ=Europe/Amsterdam
    volumes:
      - ./config:/config   # Holds your recyclarr.yml
    restart: unless-stopped

In this example I’ve chosen to use a custom network. This is the approach I recommend if Radarr and Sonarr run in a different docker-compose.yml, since each Compose file creates its own private network by default. Containers in separate files can’t see each other unless you attach them to a shared external network.

Now to create that network (if you haven't already):

docker network create media-server

Then attach Sonarr, Radarr, and Recyclarr to it (even across different Compose projects).

Start recyclarr

Bring it up with:

docker compose up -d

This will start Recyclarr and automatically create the ./config folder on your host (if it doesn’t already exist). Inside that folder, you’ll add your recyclarr.yml configuration file in the next step.

📦 Configuration basics (`recyclarr.yml`)

The easiest way to get started with Recyclarr is by using the prebuilt configuration files. These come directly from the Recyclarr project and are aligned with TRaSH-Guides. For most setups, these configs “just work” with minimal effort.

You can find them here:

Example config

Place this file in ./recyclarr/recyclarr.yml:

radarr: 
  remux-web-1080p:
    base_url: http://radarr:7878
    api_key: YOUR_RADARR_API_KEY
    include:
      - template: radarr-quality-definition-movie
      - template: radarr-quality-profile-remux-web-1080p
      - template: radarr-custom-formats-remux-web-1080p

sonarr:
  web-1080p-v4:
    base_url: http://sonarr:8989
    api_key: YOUR_SONARR_API_KEY
    include:
      - template: sonarr-quality-definition-series
      - template: sonarr-v4-quality-profile-web-1080p
      - template: sonarr-v4-custom-formats-web-1080p

How the templates work

Each include: line pulls in a prebuilt block of settings. For example:

radarr-quality-profile-remux-web-1080p → creates a quality profile for Remux + WEB 1080p.
radarr-custom-formats-remux-web-1080p → applies the correct TRaSH-Guides custom formats and scores.

You don’t have to define points or custom formats yourself, Recyclarr fetches the latest rules directly from TRaSH-Guides and applies them to your profiles.

API keys

Recyclarr needs API keys to talk to your apps:

Sonarr → Settings → General → Security → API Key
Radarr → Settings → General → Security → API Key

Copy the keys and paste them into your config.

Syncing Recyclarr

Once your recyclarr.yml is in place, run a sync:

docker compose exec recyclarr recyclarr sync

This will connect to Sonarr and Radarr, update the quality profiles, and apply the custom formats from TRaSH-Guides.
Once the container is running with docker compose up -d, it will sync automatically on a schedule (daily by default), so you don’t need to trigger it manually.
If you prefer one-off runs, add the --rm flag so the container is removed after the sync finishes.

After the sync, you should now see the new quality profiles and custom formats inside Radarr and Sonarr, automatically created and linked to TRaSH-Guides.

And that’s it, at this point, Recyclarr is up and running and your profiles are ready for use! 🎉

💾 Optional: Customizing Recyclarr

The prebuilt configurations are designed to be simple and opinionated. For example, the Radarr profiles often only include two qualities (e.g., Remux and WEB). That’s perfectly fine if you want to keep things minimal, but in reality many people like to include more options (Blu-ray, HDTV, etc.) or add their own rules.

You can do this by extending the prebuilt templates with your own settings.

Example: adding qualities and a custom format

radarr:
  remux-web-1080p:
    base_url: http://radarr:7878
    api_key: YOUR_RADARR_API_KEY
    include:
      - template: radarr-quality-definition-movie
      - template: radarr-quality-profile-remux-web-1080p
      - template: radarr-custom-formats-remux-web-1080p

    quality_profiles:
      - name: Remux + WEB 1080p
        qualities:
          - name: Remux-1080p
          - name: WEB 1080p
            qualities:
              - WEBDL-1080p
              - WEBRip-1080p
          - name: Bluray-1080p
          - name: HDTV-1080p

    custom_formats:
      - trash_ids:
          - 90a6f9a284dff5103f6346090e6280c8
        assign_scores_to:
          - name: Remux + WEB 1080p
            score: -100000

In this example:

We override the quality profile to add more qualities beyond the two defaults from the template (Blu-ray and HDTV in addition to Remux/WEB).
We add a custom format for “Low Quality releases” and apply it to the same profile, so Radarr avoids grabbing those.

Note: If you already have a custom format with the same name in Radarr/Sonarr, Recyclarr will skip updating it. To ensure the new settings are applied, delete the existing custom format first and then run a sync.

The full list of available TRaSH IDs (custom formats you can add) can be found here:

For most users, the defaults from the templates are plenty. But if you want extra control over which qualities are allowed, or you want to filter out certain release types, this kind of customization gives you the flexibility to tailor everything to your preferences.

Also make sure after every change to run docker-compose exec recyclarr recyclarr sync

✅ Final Thoughts

Setting up quality profiles and custom formats in Sonarr and Radarr can be tedious, especially if you want to follow all the recommendations from TRaSH-Guides. Recyclarr takes that whole process off your plate. With a single sync, it creates the profiles for you, applies the right custom formats, and keeps everything updated as TRaSH-Guides evolves.

Running it in Docker makes the setup even easier, no manual installs, simple updates, and it just runs quietly in the background. Instead of spending time tweaking settings, you get a media server that’s always in line with community best practices, without the extra work.

Thanks for reading!

Originally published on my site: ZeroToHomeLab I’ll post updates there if anything changes.

Set Up Cloudflare Tunnel on Linux for Secure Remote Access to Your Apps

Marin — Wed, 27 Aug 2025 14:43:38 +0000

You want to access your self-hosted apps or services from anywhere, but you don’t want to mess with port forwarding, deal with firewalls, or expose your home network to the internet.
You just want a simple, secure way to make your local app publicly available, without breaking things or worrying about security.
If that sounds like you, you’re in the right place.

📑 Table of Contents

📘 Introduction
🌩️ What Is Cloudflare, and Why Use a Tunnel?
🌐 Before We Touch the Server: Get a Domain & Set Up Cloudflare
💾 Set Up Cloudflared on Your Linux Server
🌍 Connect Your Tunnel to a Subdomain in Cloudflare
✅ Final Thoughts

📘 Introduction

Self-hosting is awesome, but getting remote access securely can be one of the most frustrating parts, especially if you’re new to it.

Maybe you’ve got something like a Ghost blog, a media-server, or a dashboard running on your home server, and now you're thinking:
“It works great locally, but how do I access this when I’m not at home?”

Sure, you could open ports on your router or try to set up a reverse proxy with SSL certificates, but for a lot of people, that’s just too complicated or risky.

That’s where Cloudflare Tunnel comes in.

It’s a free tool that lets you securely expose any service running on your home network to the internet without opening any ports. It handles the routing, encryption (SSL), and DNS for you, and it works even behind CGNAT or dynamic IPs.

In this guide, I’ll show you how to set up a Cloudflare Tunnel using a self-hosted Ghost blog as the example, but the same steps will work for just about any local app or web service.

🌩️ What Is Cloudflare, and Why Use a Tunnel?

Before we get into the setup, let’s take a moment to understand what Cloudflare is, and why their tunnel feature is so useful for home servers and self-hosted apps.

What is Cloudflare?

Cloudflare acts as an intelligent middle layer between your server and the public internet. It protects your site from malicious traffic, manages DNS, and improves speed and reliability by optimizing how data is delivered to your visitors.

What is a Cloudflare tunnel

Cloudflare Tunnel (previously known as Argo Tunnel or cloudflared) creates a secure, outbound connection from your server to Cloudflare’s network.

This tunnel allows you to make a service (like a blog, media-server, or app) available on the internet, without exposing your actual network or configuring your router.

Why use Cloudflare tunnel

Here’s why Cloudflare Tunnel is a great choice for self-hosted services:

No Port Forwarding or Public IP Needed - You don’t need to open any ports on your router, set up dynamic DNS, or deal with firewalls. Your server makes an outbound connection to Cloudflare, keeping your home network private and secure.
Built-In HTTPS - Cloudflare provides a free SSL certificate for your domain, automatically. Your site will be served over HTTPS without you needing to configure or renew certificates on your server.
Simple Setup - You don’t need to be a networking expert. Cloudflare Tunnel can be set up with a few commands.
Scalable - You can route multiple subdomains and apps through the same tunnel config, great for expanding your setup over time.

🌐 Before We Touch the Server: Get a Domain & Set Up Cloudflare

Before we dive into terminal commands and configuration files, let’s get everything ready in Cloudflare. This step is all about setting up your domain, DNS, and Cloudflare account, so your server can later connect securely through the tunnel.

Step 1: Get a Domain Name

To make your self-hosted app accessible from anywhere, you’ll need a domain like cloudboxhub.com. While you can use Cloudflare Tunnel without one, a custom domain makes things cleaner — especially when setting up HTTPS.

💡 I personally recommend Dynadot (This is an affiliate link). It’s beginner-friendly, affordable, and reliable. I use it for this blog, and all screenshots in this guide will be based on Dynadot, which might make things easier to follow.

Choose something short, relevant, and easy to remember.

Step 2: Create a Free Cloudflare Account

Go to cloudflare.com and create a free account.

Once you’re logged in, go to the Account Home tab and click "Add a Domain". Enter your domain name and follow the prompts to continue.

Step 3: Change Your Nameservers

On the next step, select "Quick Scan DNS Records." Cloudflare will scan your current DNS settings and display what it found. You can skip editing for now, just click Continue.

Next, Cloudflare will show you two nameservers to use.

Now head back to your domain registrar (in this case, Dynadot), check the box next to your domain, click the “Action” button, and choose “DNS Settings.” Then enter the Cloudflare-provided nameservers like in the screenshot below:

⏳ It may take a few minutes (up to 24 hours) for DNS changes to fully propagate. Cloudflare will notify you once your domain is connected and active.

Now that your Cloudflare account is set up and your domain is connected, we can move over to the server.

We’ll create the subdomain and DNS record after the tunnel is created, since we’ll need the unique tunnel address from Cloudflare at that point.

💾 Set Up Cloudflared on Your Linux Server

Now that your domain is connected to Cloudflare, it’s time to set up the tunnel from your linux server. We’ll use a small tool called cloudflared to create a secure, outbound connection to Cloudflare’s network.

This allows you to expose local apps without opening any ports or touching your router.

Step 1: Install Cloudflared

On Debian or Ubuntu, you can install Cloudflared with the official package:

curl -fsSL https://github.com/cloudflare/cloudflared/releases/latest/download/cloudflared-linux-amd64.deb -o cloudflared.deb

sudo dpkg -i cloudflared.deb

Step 2: Authenticate Cloudflared

Run this command to connect your server to your Cloudflare account:

cloudflared tunnel login

It will open a browser window. Log into your Cloudflare account and select the domain you added earlier (e.g. cloudboxhub.com).

If you're using something like PuTTY or a remote terminal, pressing Ctrl+C might cancel the login.
Instead, highlight the full URL to copy it, then use Ctrl+Shift+C to copy safely.

After approving, Cloudflared will store a credentials file in:

~/.cloudflared/

The dot (.) at the start makes this a hidden folder. You won’t see it with ls unless you run ls -a.

Step 3: Create a Tunnel

Now create a named tunnel:

cloudflared tunnel create myghostblog

This creates:

A new tunnel ID
A credentials file linked to this tunnel
An entry in your Cloudflare dashboard

You can name it anything you want — myghostblog, ghost-tunnel, media-tunnel etc.

Step 4: Create a Config File

Next, create a config file so Cloudflared knows what to connect:

sudo nano /etc/cloudflared/config.yml

Paste in the following (adjust as needed):

tunnel: myghostblog
credentials-file: /home/yourusername/.cloudflared/<your-tunnel-ID>.json

ingress:
  - hostname: blog.cloudboxhub.xyz
    service: http://localhost:2368
  - service: http_status:404

🔁 Replace:

yourusername with your Linux username
<your-tunnel-ID> with the actual filename inside ~/.cloudflared/
blog.cloudboxhub.xyz with your actual subdomain
2368 with the port used by your Docker container or app

Step 5: Run the Tunnel as a Service

To make the tunnel start automatically on boot:

sudo cloudflared service install

Then start the tunnel:

sudo systemctl enable cloudflared
sudo systemctl start cloudflared

Check the status:

sudo systemctl status cloudflared

This should show that the cloudflared service up and running:

If everything is set up properly, your tunnel is now running in the background!

Alternative: You can also run the tunnel manually using:
cloudflared tunnel run myghostblog
However, this only works while your terminal session is open. For long-term or production use, I strongly recommend using the systemd service instead.

🌍 Connect Your Tunnel to a Subdomain in Cloudflare

Now that your tunnel is up and running on your server, let’s make it accessible from the internet by pointing your domain (or subdomain) to it.

We’ll do this by creating a CNAME DNS record in your Cloudflare dashboard that maps your chosen subdomain (like blog.cloudboxhub.xyz) to the Cloudflare tunnel.

Step 1: Get Your Tunnel’s Public Address

Run this command to get your tunnel’s unique hostname:

cloudflared tunnel list

You'll see output like this:

The ID you see is your Tunnel ID (don’t confuse it with the Connector ID). To get your public tunnel address, just append .cfargotunnel.com to that ID:

For example:
80f75045-1c5f-42e0-a665-15711669e934.cfargotunnel.com

This is your tunnel’s public Cloudflare endpoint, it's how Cloudflare routes traffic to your linux server through the tunnel you created. This will be the target for your DNS record in the next step.

Step 2: Create a CNAME Record in Cloudflare

Go to your Cloudflare dashboard
Select your domain (e.g. cloudboxhub.xyz)
Navigate to the DNS tab → Records
Click “Add Record” and fill in:

Field	Value
Type	`CNAME`
Name	`blog` (or whatever subdomain you want)
Target	`your-tunnel-id.cfargotunnel.com` (from step 1)
Proxy status	☁️ Proxied (enabled)
TTL	Auto

Then click Save.

Enabling “Proxied” ensures Cloudflare handles traffic securely, including HTTPS.

Done!

Your subdomain (e.g. blog.cloudboxhub.xyz) now points to your tunnel, and Cloudflare is handling the traffic securely and without exposing your local network.

You can now visit your domain and access your self-hosted app from anywhere!

Verify It’s Working

Open your domain in any browser.

If everything is set up correctly, your self-hosted app should load right away, securely, and without any port forwarding.

If it doesn’t load:

Double-check that your subdomain in Cloudflare matches the one in your tunnel config file
Make sure the app you’re tunneling (like Ghost) is running and listening on the correct internal port

✅ Final Thoughts

Congrats! You just set up a secure, public-facing tunnel from your home server to the internet using Cloudflare Tunnel!

You did it without opening a single port, messing with firewalls, or worrying about dynamic IPs. That’s a huge win for privacy, security, and simplicity — especially for home lab users.

Whether you’re self-hosting Ghost, a dashboard, or any other app, this tunnel is your gateway to making it accessible from anywhere, the safe way.

Originally published on my site: ZeroToHomeLab I’ll post updates there if anything changes.

How to Self-Host a Ghost Blog with Docker Compose on Linux

Marin — Tue, 29 Jul 2025 16:03:53 +0000

So, you’ve got a Linux server running at home, and now you're thinking, "Why not use it to share my thoughts with the world?"
Maybe you want to write tutorials, document your projects, or just start a personal blog using something clean and modern like Ghost, which is exactly what I’m doing. If that sounds like you, then you’re in the right place!

📑 Table of Contents

📘 Introduction
🛠️ Prerequisites
📧 Why You Should Configure Email (SMTP)
📝 Writing the 'docker-compose.yml' File
▶️ Starting and Accessing the Blog
🧰 Managing Your Ghost Blog with Docker
🌍 Want to Use a Domain and HTTPS?
🐞 Troubleshooting
✅ Final Thoughts

📘 Introduction

In this guide, I’ll walk you through how to self-host a Ghost blog using Docker Compose. While it’s beginner-friendly in the sense that it’s step-by-step and avoids unnecessary complexity, I will assume you’re somewhat familiar with using the terminal and Docker. This helps keep the guide focused, efficient, and practical, so we won’t dive too deeply into explaining every tool or command.

By the end, you’ll have your own Ghost blog up and running, ready to publish posts and fully under your control.

🛠️ Prerequisites

Before we get started, make sure you have the following:

✅ A Linux server (can be a home server, Raspberry Pi, or old PC running Ubuntu/Debian)
✅ Basic familiarity with the Linux terminal
✅ Docker and Docker Compose already installed
✅ A working SMTP email account (e.g. Gmail) for sending login and system emails > Ghost requires working email even for local login, it sends a verification link to complete the sign-in process. If email isn’t set up, you may get stuck in a login loop. I’ll explain more below.
✅ (Optional but recommended) A domain name for public access

💡 Do I Need a Domain Name?

You don’t need a domain to get started. You can run Ghost locally on your home network using localhost or your local IP.

That said, using a custom domain with a service like Cloudflare Tunnel makes accessing your blog from anywhere much easier and more secure.

I cover how to set that up in this guide on setting up a Cloudflare Tunnel on Linux. You can also start without a domain and add one later.

📧 Why You Should Configure Email (SMTP)

When you first set up Ghost, it asks you to create an admin account. Normally, this triggers a confirmation email, but if email isn’t configured, it silently fails, and you might still get through the setup.

However, Ghost requires working email to log in later. If SMTP isn't properly set up, the login screen will try to send you a verification email, fail silently, and get stuck in a loop before eventually timing out.

💡 That’s why I recommend setting up SMTP (email) right from the beginning, even if you’re just running Ghost locally.

You can use Gmail’s SMTP service with an App Password, or any other email provider that supports SMTP. We'll include this in the Docker Compose file below.

📝 Writing the 'docker-compose.yml' File

Before we launch your Ghost blog, let’s create a dedicated directory to keep things organized, and write your Docker Compose configuration.

Step 1: Create Your Project Folder

First, create a folder where all your Ghost files and configuration will live:

mkdir -p ~/ghost-blog
cd ~/ghost-blog

Step 2: Create the Compose File

Now let’s create your docker-compose.yml file inside the folder.

I'll be using nano, but you can use vim or any other terminal-based text editor you prefer.

sudo nano docker-compose.yml

Inside this file, paste the following content:

version: '3.8'

services:
  ghost:
    image: ghost:5
    container_name: ghost_blog
    restart: unless-stopped
    ports:
      - "2368:2368"
    depends_on:
      - db
    environment:
      url: http://192.168.1.1:2368
      mail__transport: SMTP
      mail__options__host: smtp.gmail.com
      mail__options__port: 587
      mail__options__secure: "false"
      mail__options__auth__user: your-user@gmail.com
      mail__options__auth__pass: your-app-password
      database__client: mysql
      database__connection__host: db
      database__connection__user: ghostuser
      database__connection__password: password
      database__connection__database: ghostdb
    volumes:
      - ./content:/var/lib/ghost/content

  db:
    image: mysql:8
    container_name: ghost_mysql
    restart: unless-stopped
    environment:
      MYSQL_ROOT_PASSWORD: your-root-password
      MYSQL_DATABASE: ghostdb
      MYSQL_USER: ghostuser
      MYSQL_PASSWORD: password
    volumes:
      - db_data:/var/lib/mysql

volumes:
  db_data:

To get this working on your own server, you only need to update a few values in the docker-compose.yml file:

🔑 Key	📝 What It Does	✅ What You Should Do
`url:`	The public address of your blog	Replace `http://192.168.1.1:2368` with your server’s IP address (e.g. `http://192.168.0.101:2368`) or your custom domain later (e.g. `https://zerotohomelab.cloudboxhub.com`).
`mail__options__auth__user:`	The email Ghost will send from	Use your actual Gmail address (e.g. `you@gmail.com`).
`mail__options__auth__pass:`	The SMTP password for Gmail	Use a Gmail App Password, not your normal password. 👉 Generate one here
`MYSQL_ROOT_PASSWORD:`	The MySQL admin password	Set a strong password. It’s required but not used by Ghost directly.
`MYSQL_USER`, `MYSQL_PASSWORD`, `MYSQL_DATABASE`	MySQL credentials Ghost will use	You can change these if you like—just make sure the values match in both the `ghost` and `db` sections.

Once you've made those changes, you're ready to start your blog!

▶️ Starting and Accessing the Blog

Now that your docker-compose.yml file is ready and properly configured, it's time to bring your Ghost blog to life.

Start the Containers

In the same folder where your file is saved (~/ghost-blog), run:

docker compose up -d

Check That Everything is Running

To verify everything is running as expected, check the container status:

docker compose ps

You should see both the ghost_blog and ghost_mysql containers listed and marked as "Up".

Access the Blog in Your Browser

Now, go to your browser and visit:

http://<your-server-ip>:2368/ghost

Replace <your-server-ip> with the address you set in the url: field of your docker-compose.yml (e.g. 192.168.0.x).

If all is working, you’ll see the Ghost welcome screen with a prompt to set up your admin account, like this:

🧰 Managing Your Ghost Blog with Docker

If you’ve used Docker before, managing Ghost will feel familiar. Here are just a few Ghost-specific things to keep in mind.

Updating Ghost

To upgrade to the latest Ghost version:

docker compose pull
docker compose up -d

This downloads the latest Ghost image and restarts the blog using your current configuration. Your content and database are safe as long as your volumes remain intact.

Backing Up Your Blog

Ghost stores your data in two places:

./content/ — Contains file-based data such as images, themes, and logs.

MySQL volume — Stores the database, including posts, users, and settings.

To back the content folder up:

cp -r ./content ~/ghost-backup/content

To backup the MySQL database run the following:

docker exec ghost_mysql mysqldump -u root -p'ghostdbpass' ghostdb > ~/ghost-backup/ghostdb.sql

Replace ghostdb with your actual database name and replace ghostdbpass with your actual MySQL root password. If you're passing the password inline, make sure there is no space after - p, and enclose the password in quotes:
-p'yourpassword'   ✅
-p yourpassword  ❌ (won’t work)

This command connects to the MySQL container and creates a full SQL snapshot of your Ghost database. You can use this file to restore your blog’s data later if something goes wrong.

Restarting / Stopping

For reference:

docker compose restart      # Restart blog
docker compose down         # Stop containers
docker compose down -v      # Stop and remove all data (be careful!)

Restoring Your Ghost Backup

If something goes wrong or you want to migrate your blog to a new machine, you can restore it using the backup files we created.

Restore the content folder (images, themes, etc.):

cp -r ~/ghost-backup/content ./content

Restore the database from your .sql file:

docker cp ~/ghost-backup/ghostdb.sql ghost_mysql:/ghostdb.sql
docker exec -i ghost_mysql mysql -u root -p'ghostdbpass' ghostdb < /ghostdb.sql

Once restored, restart Ghost:

docker compose restart

Your blog should now be back exactly as it was.

🌍 Want to Use a Domain and HTTPS?

In this tutorial, we focused on getting Ghost running locally on your server.

If you'd like to make your blog publicly accessible using a domain name and secure HTTPS (via Cloudflare Tunnel), check out the next part:

👉 How to Secure Your Ghost Blog with a Domain and Cloudflare Tunnel

🐞 Troubleshooting

If you haven't ran into any issues, great, then you can skip this section! Ran into a problem? Here are a few common issues you might face and how to resolve them.

Can't Log In? SMTP Not Working

Ghost requires a working SMTP setup to send confirmation or login emails. If your SMTP settings are missing or incorrect, you'll get stuck on the login screen, it silently fails to send the verification email, then times out.

Fix:

Double-check the email and app password in your docker-compose.yml
Make sure your SMTP port is correct (587 for Gmail)
Restart Ghost after editing:

docker compose restart

Still stuck? Check the logs (see below) for SMTP-related errors.

Viewing Ghost Logs

To troubleshoot errors like email issues, startup failures, or database connection problems, use this command:

docker compose logs ghost_blog -f

This will stream the Ghost container logs in real time so you can see what's happening under the hood.

You can also check the MySQL container logs:

docker compose logs db -f

SQLite Is No Longer Supported

Ghost 5.x and later no longer support SQLite as a database engine. If you're coming from older guides or trying to set it up quickly without MySQL, you may see unexplained startup failures, like the following logs:

Solution:
This guide uses MySQL 8 via Docker, which is the officially supported setup. Make sure you don't try to switch to SQLite manually, it won’t work with recent versions of Ghost.

Tip: You can always restart from scratch with:
docker compose down -v
But be careful, -v also removes all volumes and stored data.

✅ Final Thoughts

If you've followed this guide, you now have a fully self-hosted Ghost blog running on your Linux server with Docker Compose.

You've taken full control of your content, your data, and your setup — with no need to rely on third-party platforms or expensive hosting services.

From here, you can:

Secure your blog with a cloudflare tunnel and a custom domain
Customize your theme and navigation
Start writing and publishing right away

Hopefully this has helped you get started with ghost.

Thanks for reading!

Originally published on my site: ZeroToHomeLab I’ll post updates there if anything changes.