DEV Community: Cyber

I Built a Dashboard to Monitor My Self-Hosted Docker Services

Cyber — Wed, 27 May 2026 14:16:18 +0000

I run a bunch of self-hosted services on my home server. Vaultwarden, Linkwarden, Nextcloud, Anynote, AFFiNE, Vikunja - the list keeps growing. At some point I had over 30 containers running and I realized I had a problem.

I couldn't remember what was running where.

Which port was Vikunja on again? Is Nextcloud on .local or the IP? Did Anynote go down after that update? Let me SSH in and check...

I wanted one place where I could:

See all my services at a glance
Know instantly if something is down
Access my DevOps tutorials and notes
Not need to bookmark 40 different URLs

So I built Cyberboard - a self-hosted homelab dashboard that runs in Docker alongside everything else.

The Problem

If you run a homelab, you probably know the feeling. You start with one or two containers. Then you add Vaultwarden because managing passwords yourself is the right thing to do. Then Nextcloud because Google Drive feels wrong now. Then a media stack. Then monitoring. Then a reverse proxy. Then DNS.

Before you know it, you're managing a small data center from your closet.

My pain points were:

Scattered bookmarks - services spread across browser profiles and devices
No health visibility - I'd only find out something crashed when I tried to use it
Wasted time - looking up IPs and ports in Docker Compose files
Lost notes - network configs and IPs scattered across random text files

Existing dashboards like Homer and Heimdall looked nice but felt static. I wanted something I could edit live, that checked if my services were actually responding, and where I could keep my learning resources next to my infrastructure.

What I Built

Cyberboard is a single-page dashboard with:

Service cards with live health status (green/red dots)
Tutorial cards for my DevOps notes (Terraform, K8s, Docker, CI/CD, etc.)
Quick links to GitHub, Docker Hub, K8s docs, and other references
A scratchpad for quick notes and network info
Built-in editor to add, edit, remove, and reorder everything
Search across all sections
Category filters (Productivity, Media, Infrastructure, Security, etc.)
Dark/light theme

Everything is stored in a single data.json file. No database, no accounts, no complexity.

The Health Check Problem

This was the most interesting part to build. My first attempt used browser-side fetch with mode: 'no-cors' to ping each service. It sort of worked - but had major issues:

HTTPS services with self-signed certs always showed as down (browser blocks them)
Auth-protected services (like ones behind Authentik) showed as down
no-cors responses are opaque - you can't tell if a service actually responded or not

The fix was to move health checks server-side. The Python server pings each service URL directly using HEAD requests, with:

Self-signed cert support (common in homelabs)
Any HTTP response = online (even 401/403 - the service is running, it just wants auth)
Parallel checks (20 threads, all services pinged simultaneously)
5-second timeout per service

Now a service behind HTTPS with a self-signed cert and basic auth shows as green. Because it is up - it just has security in front of it.

def check_url(url):
    try:
        req = urllib.request.Request(url, method="HEAD")
        urllib.request.urlopen(req, timeout=5, context=SSL_CTX)
        return True
    except urllib.error.HTTPError:
        # 401, 403, 500 — service is running
        return True
    except Exception:
        # Connection refused, timeout, DNS failure — actually down
        return False

The Tech Stack (No Build Step)

I wanted to keep it simple. No npm install, no webpack, no build pipeline. Just files that a browser can run directly.

Preact - 3KB React alternative, loaded from CDN
HTM - tagged template literals instead of JSX (no transpiler needed)
Lucide - SVG icons for the UI
Python stdlib - the entire server is one file with zero pip dependencies
Import Maps - browser-native module resolution, no bundler

The import map in the HTML tells the browser where to find each library:

<script type="importmap">
{
  "imports": {
    "preact": "https://esm.sh/preact@10",
    "preact/hooks": "https://esm.sh/preact@10/hooks",
    "htm": "https://esm.sh/htm@3",
    "lucide-preact": "https://esm.sh/lucide-preact@0.474.0?external=preact"
  }
}
</script>

Every component uses clean imports like import { useState } from 'preact/hooks' - same as any React project, just without the 200MB node_modules folder.

For Docker deployments, I have two Dockerfiles. The default one uses CDN imports (smaller image). The offline one (Dockerfile.offline) downloads and vendors all JS dependencies at build time - so the container runs on isolated networks with zero internet access. You pick which one fits your setup:

# Default - uses CDN
docker compose up -d

# Offline - fully self-contained
docker compose --profile offline up -d cyberboard-offline

How It's Structured

The whole project is ~20 files:

cyberboard/
├── index.html              # HTML shell + import map
├── style.css               # All styles
├── app.js                  # Root component
├── lib/                    # Shared modules
│   ├── preact.js           # Preact/HTM re-exports
│   ├── icons.js            # Lucide icons
│   ├── context.js          # App state context
│   ├── constants.js        # Emojis, colors, categories
│   └── data.js             # Load/save helpers
├── components/             # 14 Preact components
├── data.json               # Your data (gitignored)
├── data.json.default       # Factory defaults
├── server.py               # The entire backend
├── Dockerfile
└── docker-compose.yml

The server is 100 lines of Python. It serves static files, exposes GET /api/health for health checks, and POST /api/save to write changes back to data.json. That's it.

The Editor

One thing I didn't want was to edit a JSON file every time I added a new service. So I built an editor mode directly into the dashboard.

Press E (or click the pencil icon) and:

Delete buttons appear on every card
Edit buttons let you modify existing entries
"Add Service / Add Tutorial / Add Link" cards appear
Drag and drop to reorder cards
Export/import JSON backups

The add/edit modal has a searchable emoji picker with 250+ emojis organized by category (Tech, Security, Cloud, Media, etc.). Search "docker" and the whale emoji pops up. Search "lock" and you get all the security emojis.

All changes save to data.json on the server automatically (debounced 400ms). No save button needed.

Running It

Local:

git clone https://github.com/ppaczk0wsk1/cyberboard
cd cyberboard
python3 server.py

Open http://localhost:8900 and you're done.

Docker:

docker compose up -d

Mount data.json as a volume so your customizations persist:

services:
  cyberboard:
    build: .
    ports:
      - "8900:8900"
    volumes:
      - ./data.json:/app/data.json
    restart: unless-stopped

On first run, the server copies data.json.default into place so you start with a full set of example services and tutorials. Then you customize from there.

What I Learned

Building this was a good exercise in restraint. It would have been easy to add user accounts, uptime history graphs, Docker API integration, notification systems... but none of that is needed for a personal dashboard.

The things that actually mattered:

Health checks that work with real homelab setups (self-signed certs, auth, weird ports)
An editor that's fast enough to not be annoying
Search that finds things instantly
A single JSON file that's easy to back up and version control

If you run a homelab and you're tired of forgetting which port Sonarr is on, give it a try. The repo is at github.com/ppaczk0wsk1/cyberboard.

What's Next

Some things I'm considering:

Response time display on service cards (the health check already pings them - just need to time it)
Favorites pinned to top for the services I use most
Custom service groups beyond already existing categories

But honestly, it does everything I need right now. And that's kind of the point.

If you're interested in self-hosting, check out my other post: My Top 5 Self-Hosted Tools Running on My Home Server via Docker

Cyberboard is open source and MIT licensed. PRs welcome.

My Top 5 Self-Hosted Tools Running on My Home Server via Docker (Part 2)

Cyber — Sat, 21 Feb 2026 03:47:57 +0000

After sharing my first list of self-hosted tools, I realized something interesting:
my home server isn't just replacing SaaS apps anymore, it’s replacing habits.

Instead of doom-scrolling feeds, losing track of articles, or fighting with resume builders, I now rely on a second set of self-hosted tools that handle content consumption, learning, and utility tasks.

Here are five more services I run daily, all self-hosted using Docker.

The Stack

Why I Keep Expanding My Self-Hosted Stack

At this point, self-hosting is less about saving money and more about intentional software.

What I care about now:

No algorithms deciding what I read
Offline-friendly content
Tools that do one thing well
Full control over my data
Apps that don’t disappear behind a paywall

These five tools fit that philosophy perfectly.

1. FreshRSS – Taking Back Control of My Reading

What it replaces: Feedly, Inoreader, Twitter/X, Google News, etc
Best for: News, blogs, YouTube channels, Reddit, updates
Where: Browser, Android (via FeedMe)

FreshRSS is the backbone of how I consume information.

Instead of relying on social media or algorithm-driven feeds, I subscribe directly to blogs, YouTube channels, and news sources I actually care about.

Why FreshRSS Is a Game Changer

Chronological, distraction-free reading
Tags, filters, and categories
Supports thousands of feeds
Extremely lightweight
Works with almost any RSS client

I use it to follow:

Tech blogs
Open-source projects
DevOps updates
Personal blogs
And more

No rage-bait. No engagement tricks. Just content - on my terms.

2. Booklore - My Personal Digital Library

What it replaces: Goodreads, Kindle notes, random folders
Best for: Tracking and organizing books
Where: Browser

Booklore is one of those tools that feels small - until you start using it.

Why I Love It

Clean and simple UI
Self-hosted book tracking
No ads, no social pressure
Full control over metadata
Easy backups

I plan to use Booklore to:

Track reading progress (just 2 books for now haha)
Plan future reading
Keep notes on technical books
Maintain a long-term reading archive

It's calm, focused, and does exactly what I need.

3. Audiobookshelf - Your Own Audible, Minus the Lock-In

What it replaces: Audible, cloud-based audiobook apps
Best for: Audiobooks and podcasts
Where: Android, iOS, Browser

It turns your audiobook collection into a polished streaming platform, complete with progress syncing and mobile apps.

Why It’s Amazing

Supports audiobooks and podcasts
Beautiful UI
Remembers listening position
Mobile apps + web player
Metadata fetching and organization

I plan to use it for:

Tech and productivity audiobooks
Long-form learning
Podcasts I want to archive

No DRM. No subscriptions. Just my library, everywhere.

4. IT-Tools – The Swiss Army Knife for Developers

What it replaces: Random online tools, shady websites
Best for: Dev utilities and quick conversions
Where: Browser

IT-Tools is one of those things you don’t realize you need… until you have it.

It’s a collection of dozens of small utilities that developers constantly Google for.

Tools I Use the Most

JSON formatter
Base64 encoder/decoder
UUID generator
Hash generators
Date/time tools
Regex helpers

Why I Self-Host It

Works offline
No tracking
No ads
Instant access on my network

It’s bookmarked on every device I own.

5. Reactive Resume - My Resume, Always Ready

What it replaces: Online resume builders
Best for: Resume creation and versioning
Where: Browser

Reactive Resume solves a very specific problem:
I want a great resume, but I don’t want my career data locked behind a SaaS platform.

Why It's Worth Hosting

Clean, modern resume templates
JSON-based resume data
Multiple versions for different roles
Export to PDF
Fully self-hosted

I use it to:

Maintain different resumes
Quickly tailor applications
Keep my career history backed up

No watermarks. No subscriptions. No surprises.

Docker Setup (Same Philosophy, Same Simplicity)

Just like my first stack, everything here runs in Docker using Docker Compose.

Each service has:

Its own container
Persistent volumes
Reverse proxy routing
HTTPS via Let's Encrypt (if needed)

Once the base setup exists, adding services like these takes minutes - not hours.

Resource Usage (Still Very Reasonable)

Even with this expanded stack, resource usage stays low.

Typical requirements:

FreshRSS: extremely light
IT-Tools: negligible
Booklore: very light
Audiobookshelf: moderate (storage-heavy, CPU-light)
Reactive Resume: minimal

This entire setup runs comfortably on the same home server without breaking a sweat.

Final Thoughts

Self-hosting isn't about running everything yourself.

It's about choosing the right things to own.

With these five tools, I’ve taken control of:

What I read
What I listen to
How I manage my knowledge
How I apply for jobs
How I work day-to-day as a developer

Combined with my first list, my home server now replaces:

Notes / journaling → Anynote
Password managers → Vaultwarden
Knowledge bases / documentation → AFFiNE
Bookmarks / link management → Linkwarden
Task management / Kanban → Vikunja
RSS readers / feed aggregators → FreshRSS
Book tracking / library management → Booklore
Audiobooks / podcasts → Audiobookshelf
Dev utilities / quick tools → IT-Tools
Resume builders / CV tools → Reactive Resume

And honestly?
I wouldn't go back.

If you're building your own self-hosted stack, this is a fantastic second wave of services to try.

My Top 5 Self-Hosted Tools Running on My Home Server via Docker (Part 1)

Cyber — Wed, 28 Jan 2026 16:17:39 +0000

Running your own home server is one of the most rewarding things you can do if you care about privacy, control, and learning real-world infrastructure skills. Over the past year, I've been slowly replacing SaaS tools with self-hosted alternatives - all running neatly inside Docker containers.

Today I want to share my top 5 self-hosted apps that I use daily:

Anynote
Vaultwarden
AFFiNE
Linkwarden
Vikunja

These tools cover notes, passwords, project management, and knowledge organization - basically my entire productivity stack.

Let's dive in.

Why I Self-Host Everything

Before getting into the tools, here's why I host my own services:

Data ownership - My data stays on my hardware
No subscriptions - One-time setup beats monthly fees
Customization - I control updates, storage, and access
Learning experience - Docker, networking, reverse proxies, backups

Everything below runs using Docker and Docker Compose on my home server, which makes upgrades, backups, and migrations painless.

1. Anynote - Simple, Fast Personal Notes

What it replaces: Google Keep / Apple Notes
Best for: Lightweight note-taking and quick ideas
Where: Android, Desktop (Windows) app

Anynote is a minimal and fast note-taking app that I use for quick thoughts, daily logs, shopping lists, and scratch notes.

Why I Like It

Clean UI with no distractions
Lightweight and fast even on low-power servers
Markdown support
Easy backups via mounted volumes

It loads instantly and doesn't try to become a "second brain system." Sometimes simple is exactly what you want.

2. Vaultwarden (Bitwarden) - Password Manager That Just Works

What it replaces: Bitwarden Cloud (or any password manager)
Best for: Secure password management
Where: Android, Desktop (Windows) App + Browser

Vaultwarden is hands down one of the best self-hosted services you can run.

It's a lightweight Rust implementation of Bitwarden's server and works perfectly with official Bitwarden clients on desktop and mobile.

Why It's Essential

End-to-end encryption
Works with browser extensions and mobile apps
Extremely low resource usage
Easy to secure behind HTTPS and 2FA

This was the first service I ever self-hosted - and I've never looked back.
If you host only one thing at home, make it this.

3. AFFiNE - My Notion Replacement

What it replaces: Notion
Best for: Knowledge bases, documentation, personal wikis
Where: Android, Desktop (Windows) App + Browser

AFFiNE is an open-source workspace tool that combines documents, whiteboards, and databases.
Think Notion + Obsidian + Miro - but self-hosted.

What Makes AFFiNE Awesome

Block-based editing
Whiteboard mode
Local-first with sync
Clean modern UI

I use AFFiNE for:

Project documentation
Learning notes
Long-term knowledge storage

It's actively developed and improving rapidly, which makes it exciting to run.

4. Linkwarden - Bookmark Manager but better

What it replaces: Browser bookmarks, Pocket, Raindrop
Best for: Saving articles and resources
Where: Android, Browser

Linkwarden solved a problem I didn't realize I had: bookmark chaos.

Instead of losing links across browsers and devices, I now have a centralized searchable archive.

Why I Use It Daily

Tagging and collections
Full-page snapshots
Searchable content
Beautiful UI

It's perfect for:

Development resources
Tutorials
Articles I want to revisit
Reference material

It also integrates nicely with browser extensions for one-click saving.

5. Vikunja - Open-Source Task Management

What it replaces: Todoist / Trello
Best for: Tasks, projects, kanban boards
Where: Android, Browser

Vikunja is my go-to task manager. It's flexible enough to replace both simple to-do apps and full kanban boards.

Features I Love

Lists, projects, and namespaces
Kanban board view
Due dates and reminders
API and mobile app support

I use it to manage:

Personal tasks
Home server maintenance
Learning goals
Long-term projects

It's fast, reliable, and easy to self-host.

My Docker Setup (High Level)

All of these services run using Docker Compose.

Each service has:

Its own container
Mounted volumes for persistent data
Reverse proxy routing (Nginx/Traefik)
Automatic HTTPS via Let's Encrypt x

This setup gives me:

Easy backups
Simple upgrades
Isolation between services
Minimal downtime

Once you learn Docker basics, adding new services becomes trivial.

Resource Usage (Surprisingly Low)

One of the biggest myths is that self-hosting needs powerful hardware.

My stack runs comfortably on:

12GB RAM
Low-power CPU
SSD storage

Vaultwarden and Anynote barely consume resources, while AFFiNE and Linkwarden are the heavier ones - but still very manageable.

Final Thoughts

Self-hosting changed how I think about software.

Instead of asking:

"Which app should I subscribe to?"

I now ask:

"Which service should I host next?"

These five tools cover almost everything I need:

Notes
Passwords
Knowledge base
Bookmarks
Tasks

If you're just starting out, I recommend this order:

Vaultwarden
Vikunja
Linkwarden
AFFiNE
Anynote

Once you get comfortable, your home server quickly becomes your personal cloud.

🏠☠️ Home Alone: Exposing My Home Server to the Internet (and Judgment) with FRP + Jenkins + Bash

Cyber — Tue, 08 Jul 2025 11:42:11 +0000

TL;DR:

I turned my home server into a publicly available chaos machine by automating FRP tunnels from Jenkins… running on a remote VPS… like some kind of over-caffeinated Bond villain.

After all, who doesn't want to broadcast their cat cam to friends?

💡 The Setup (a.k.a. the Overkill Stack)

🧠 Home Server (Worker Jenkins Node) on private network - Raspberry Pi, old laptop, toaster with Linux - whatever you have.
🌍 VPS (Main Jenkins Node) - Runs Jenkins jobs to control FRP clients.
🚇 FRP (Fast Reverse Proxy) - An open-source alternative to Ngrok.
🤖 Jenkins - Because we like suffering, but reproducible.

🌟 Goal

From Jenkins (already connected to the home server via a build agent), we want to:

Spin up secure FRP tunnels that expose ports from the home server.
Use Jenkins jobs like a dashboard - "Expose internal port 3000 as port 1000 externally on VPS", "Shut it down", etc.
Avoid manual interaction unless something literally catches fire.

🛠️ Use Cases (Excuses to Build This)

💻 Show off local dev apps to clients/friends
📦 Share self-hosted dashboards (Grafana, Prometheus, whatever)
🎥 Let your dog cam stream to the world
⛔ Temporarily expose private tools during demos

How It Works

FRP server runs on your VPS
FRP client lives on your home server
Jenkins jobs (run on a connected build agent) generate config files + launch tunnels

📦 FRP Server Setup on Jenkins VPS

Steps to Create a Freestyle Job in Jenkins

Open Jenkins Dashboard
- Go to your Jenkins instance in the browser (e.g. http://localhost:8080).
Click on "New Item"
- (Top-left of the dashboard)
Enter a Job Name
Select "Freestyle Project"
- Then click OK.
Configure the Job
- Copy and paste the script provided below.
Click "Save"
Run the Job
- Click "Build Now" on the job page.

✅ Here's a minimal script:

#!/bin/bash

# --- SETTINGS ---
FRP_VERSION=0.63.0
FRP_PLATFORM=linux_amd64
FRP_DIR="frp_${FRP_VERSION}_${FRP_PLATFORM}"
FRP_DOWNLOAD_URL="https://github.com/fatedier/frp/releases/download/v${FRP_VERSION}/${FRP_DIR}.tar.gz"
FRP_INSTALL_DIR="/opt/frp"
FRPS_BINARY="${FRP_INSTALL_DIR}/frps"

# --- ENSURE INSTALL DIR EXISTS ---
mkdir -p "$FRP_INSTALL_DIR"

# --- DOWNLOAD + INSTALL IF NEEDED ---
if [[ ! -f "$FRPS_BINARY" ]]; then
  echo "📦 Downloading FRP server to $FRP_INSTALL_DIR..."
  wget "$FRP_DOWNLOAD_URL" -O frp.tar.gz || {
    echo "❌ Download failed. Check URL or network."
    exit 1
  }

  tar -xzf frp.tar.gz
  mv "${FRP_DIR}/frps" "$FRPS_BINARY"
  chmod +x "$FRPS_BINARY"
  rm -rf "$FRP_DIR" frp.tar.gz
fi

# --- CREATE CONFIG IF NEEDED ---
cat > "$FRP_INSTALL_DIR/frps.ini" <<EOF
[common]
bind_port = 1000
dashboard_port = 1500
dashboard_user = admin
dashboard_pwd = admin
EOF

# --- START FRP SERVER ---
cd "$FRP_INSTALL_DIR"
export BUILD_ID=dontKillMe
nohup "$FRPS_BINARY" -c frps.ini > frps.log 2>&1 &

echo "✅ FRP server started on port 1000, dashboard at :1500"

After that you have:

frps running on port 1000
A dashboard on http://vps-ip:1500
Config in /opt/frp/frps.ini

❌ How To Kill FTP Server

I set up a different freestyle job - just like in the thrilling saga above, that shuts down the server when I don't need it.

#!/bin/bash
FRP_PID=$(pgrep -f frps)

if [ -n "$FRP_PID" ]; then
  echo "Killing frps with PID $FRP_PID"
  kill "$FRP_PID"
else
  echo "No frps process found"
fi

📦 FRP Client Setup on Home Server via Jenkins

The next step is to create a third freestyle job in Jenkins, which will set up the FRP client on the worker node of Jenkins running on my home server.

Keep in mind, you'll need to use the "Build with Parameters" option, where the parameters are $LOCAL_PORT (the port on your private server) and $REMOTE_PORT (the port on your public VPS server).

✅ Here's another bash script:

#!/bin/bash

if [[ -z "$LOCAL_PORT" || -z "$REMOTE_PORT" ]]; then
  echo "❌ Missing required parameters."
  echo "Please provide: LOCAL_PORT, REMOTE_PORT"
  exit 1
fi

FRP_SERVER=<VPS IP>
FRP_SERVER_PORT=1000
FRP_VERSION=0.63.0
FRP_PLATFORM=linux_amd64
FRP_DIR="frp_${FRP_VERSION}_${FRP_PLATFORM}"

WORKDIR="$WORKSPACE/frpc_clients"
mkdir -p "$WORKDIR"

FRPC_BINARY="$WORKDIR/frpc"
FRPC_CONFIG="$WORKDIR/frpc_${LOCAL_PORT}_${REMOTE_PORT}.ini"
FRPC_LOG="$WORKDIR/frpc_${LOCAL_PORT}_${REMOTE_PORT}.log"
FRPC_PID="$WORKDIR/frpc_${LOCAL_PORT}_${REMOTE_PORT}.pid"

# Download frpc if missing
if [[ ! -f "$FRPC_BINARY" ]]; then
  echo "🔽 Downloading frpc v${FRP_VERSION}..."
  wget "https://github.com/fatedier/frp/releases/download/v${FRP_VERSION}/${FRP_DIR}.tar.gz" -O /tmp/frp.tar.gz || {
    echo "❌ Download failed. Please check FRP version or network."
    exit 1
  }

  tar -xzf /tmp/frp.tar.gz -C /tmp
  mv /tmp/${FRP_DIR}/frpc "$FRPC_BINARY"
  chmod +x "$FRPC_BINARY"
  rm -rf /tmp/${FRP_DIR} /tmp/frp.tar.gz
fi

echo "⚙️ Writing frpc config for local:$LOCAL_PORT → remote:$REMOTE_PORT"
cat > "$FRPC_CONFIG" <<EOL
[common]
server_addr = $FRP_SERVER
server_port = $FRP_SERVER_PORT

[tunnel_${LOCAL_PORT}]
type = tcp
local_port = $LOCAL_PORT
remote_port = $REMOTE_PORT
EOL

# Check if already running
if [[ -f "$FRPC_PID" ]]; then
  PID=$(cat "$FRPC_PID")
  if kill -0 "$PID" >/dev/null 2>&1; then
    echo "⚠️ Tunnel already running with PID $PID"
    exit 0
  else
    echo "⚠️ Stale PID file found, removing"
    rm -f "$FRPC_PID"
  fi
fi

echo "🚀 Starting FRP tunnel..."
export BUILD_ID=dontKillMe
nohup "$FRPC_BINARY" -c "$FRPC_CONFIG" > "$FRPC_LOG" 2>&1 &
echo $! > "$FRPC_PID"

echo "✅ Tunnel running at $FRP_SERVER:$REMOTE_PORT (PID $(cat $FRPC_PID))"

✅ Your janky React app is now live at http://vps-ip:30001

❌ How To Kill A Tunnel To FRP Client

Create another freestyle job using the Bash script below.

As mentioned earlier, make sure to use the "Build with Parameters" option, setting $LOCAL_PORT and $REMOTE_PORT appropriately.

#!/bin/bash

LOCAL_PORT="$LOCAL_PORT"
REMOTE_PORT="$REMOTE_PORT"
FRPC_DIR="$FRP_DIR/frpc_clients"
PID_FILE="$FRPC_DIR/frpc_${LOCAL_PORT}_${REMOTE_PORT}.pid"

if [ -f "$PID_FILE" ]; then
  PID=$(cat "$PID_FILE")
  echo "Stopping tunnel: local $LOCAL_PORT → remote $REMOTE_PORT (PID: $PID)"
  kill "$PID"
  rm -f "$PID_FILE"
  echo "Tunnel stopped successfully."
else
  echo "No PID file found at $PID_FILE"
  exit 1
fi

🧠 Final Thoughts

They said, "Don't expose your local ports to the internet". They didn't say, "Don't automate it with Jenkins like a Bond villain".

Because even in a zero-trust, cloud-native world…sometimes you just want to YOLO a port and livestream your cat feeder from Jenkins.

You can find the full code for this madness on GitHub.

💾 Go Sheet DB: I Built a REST API in Go Using Google Sheets as a Database, Then Dockerized It Like I Hate Myself

Cyber — Mon, 23 Jun 2025 11:06:48 +0000

Welcome to Go Sheet DB (API) ™ - the only REST API held together by sheer willpower, a Google Sheet, and my irrational desire to do something in Go.

What started as "I should do something in Go" became a full-blown REST API running on Google Sheets as the backend database. No Postgres. No SQLite. Just... Sheets. The kind with rows and columns and sadness.

👶 Why Google Sheets?

Because I didn't want to install a database. And I love bad ideas that technically work.

✅ Free
✅ Serverless (in the worst way possible)
✅ Editable by non-devs (like your boss)
✅ Feels illegal - but isn't

🧙 Step 1: Set Up Google Sheets API Like It's 2007

Go to the Google Cloud Console
Create a new project
Go to APIs & Services > Library, search for "Google Sheets API", and enable it
Then go to APIs & Services > Credentials > Create Credentials > Service Account
Once your Service account is created, click it email, later go to "Keys" > Add key > Create new key and download config.json
Download the JSON key (put this in config.json)
Share your Google Sheet with the service account email (something like my-api-thingy@your-project.iam.gserviceaccount.com)
Breathe deeply. You're now legally a spreadsheet engineer.

📄 Step 2: Create Your "Database"

Create a new Google Sheet. Call it something like users_db.

In the first sheet/tab, name the columns:

ID | Name | Email | CreatedAt

That's your schema. You're welcome.

💻 Step 3: Go Code That Shouldn't Exist But Does

Let's write some Go that connects to this spreadsheet and makes it behave like a proper database.

Install Dependencies

go mod init gosheetdb 
go get google.golang.org/api/sheets/v4 
go get golang.org/x/oauth2/google 
go get github.com/gin-gonic/gin
go install github.com/swaggo/swag/cmd/swag@latest
go get github.com/swaggo/gin-swagger
go get github.com/swaggo/files

main.go (All in One Like a Champion)

// @title           Go Sheet DB API (aka Go Sh**t DB API)
// @version         1.0
// @description     Local API that stores users in Google Sheets
// @host            localhost:8081
// @BasePath        /

package main

import (
    "context"
    "fmt"
    "log"
    "net/http"
    "os"
    "time"

    "github.com/gin-gonic/gin"
    _ "gosheetdb/docs" // Swagger docs generated by swag init
    "github.com/swaggo/files"
    "github.com/swaggo/gin-swagger"

    "golang.org/x/oauth2/google"
    "google.golang.org/api/option"
    "google.golang.org/api/sheets/v4"
)

var (
    srv     *sheets.Service
    sheetID = "1n3Vt0_zLdMspL5VEzbD7SVWgK9186k-GRLv5xcjrFDc"
)

// User represents a user stored in Google Sheets
type User struct {
    ID        string `json:"id" example:"1234567890"`
    Name      string `json:"name" example:"Cyber"`
    Email     string `json:"email" example:"cyber@spreadsheet.go"`
    CreatedAt string `json:"createdAt" example:"2025-06-22T15:04:05Z"`
}

type ErrorResponse struct {
    Error string `json:"error" example:"some error message"`
}

func initSheets() {
    ctx := context.Background()
    b, err := os.ReadFile("config.json")
    if err != nil {
        log.Fatalf("Failed to read config.json: %v", err)
    }

    config, err := google.JWTConfigFromJSON(b, sheets.SpreadsheetsScope)
    if err != nil {
        log.Fatalf("Failed to parse config: %v", err)
    }

    client := config.Client(ctx)
    srv, err = sheets.NewService(ctx, option.WithHTTPClient(client))
    if err != nil {
        log.Fatalf("Failed to create Sheets client: %v", err)
    }
}

// getUsers godoc
// @Summary      Get all users
// @Description  Retrieve all users from Google Sheets
// @Tags         users
// @Produce      json
// @Success      200  {array}   User
// @Failure      500  {object}  ErrorResponse
// @Router       /users [get]
func getUsers(c *gin.Context) {
    resp, err := srv.Spreadsheets.Values.Get(sheetID, "Users!A2:D").Do()
    if err != nil {
        c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
        return
    }

    var users []User
    for _, row := range resp.Values {
    if len(row) < 4 {
            continue
        }
        user := User{
            ID:        fmt.Sprintf("%v", row[0]),
            Name:      fmt.Sprintf("%v", row[1]),
            Email:     fmt.Sprintf("%v", row[2]),
            CreatedAt: fmt.Sprintf("%v", row[3]),
        }
        users = append(users, user)
    }

    c.JSON(http.StatusOK, users)
}

// addUser godoc
// @Summary      Add a new user
// @Description  Append a new user to Google Sheets
// @Tags         users
// @Accept       json
// @Produce      json
// @Param        user  body      User  true  "User to add"
// @Success      201   {object}  User
// @Failure      400   {object}  ErrorResponse
// @Failure      500   {object}  ErrorResponse
// @Router       /users [post]
func addUser(c *gin.Context) {
    var u User
    if err := c.BindJSON(&u); 
    err != nil {
        c.JSON(http.StatusBadRequest, gin.H{"error": "Bad JSON"})
        return
    }

    u.ID = fmt.Sprintf("%d", time.Now().UnixNano())
    u.CreatedAt = time.Now().Format(time.RFC3339)

    v := &sheets.ValueRange{
        Values: [][]interface{}{
            {u.ID, u.Name, u.Email, u.CreatedAt},
        },
    }

    _, err := srv.Spreadsheets.Values.Append(sheetID, "Users!A:D", v).ValueInputOption("RAW").Do()
    if err != nil {
        c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
        return
    }

    c.JSON(http.StatusCreated, u)
}

func main() {
    initSheets()

    r := gin.Default()

    // Swagger UI at /swagger/index.html
    r.GET("/swagger/*any", ginSwagger.WrapHandler(swaggerFiles.Handler))

    // API routes
    r.GET("/users", getUsers)
    r.POST("/users", addUser)

    port := os.Getenv("PORT")
    if port == "" {
        port = "8081"
    }

    r.Run(":" + port)
}

echo 'export PATH="$HOME/go/bin:$PATH"' >> ~/.bashrc
source ~/.bashrc
swag init

📦 How to Run It

Add your real Google Sheet ID where it says sheetID = "..."
Put your config.json in the root directory
Run it:

go run main.go

Test it:

curl -X POST http://localhost:8081/users -H "Content-Type: application/json" -d '{"name": "Cyber", "email": "cyber@spreadsheet.go"}'

curl http://localhost:8081/users

🎉 You just built an API powered by a spreadsheet.

📦 Step 4. Dockerfile From the Abyss

FROM golang:1.23 
WORKDIR /app 
COPY go.mod go.sum ./ 
RUN go mod download 
COPY . . 
RUN go build -o gosheetdb . 
CMD ["./gosheetdb"]

Fast. Irresponsible. Beautiful.

🧼 .dockerignore - Hide the Evidence

config.json .git *.log

Don't ship your secrets or your entire git history.
You're building a meme, not a monolith.

🧪 Run It Locally (For Science)

docker build -t gosheetdb .

docker run -p 8081:8081 -v $(pwd)/config.json:/app/config.json gosheetdb

And just like that, your spreadsheet is now a cloud-native database.
Somewhere, a DBA just felt a cold chill.

🛠️ Real-Life Uses for Go Sheet DB (Weirdly Viable)

Despite being built on pure tech blasphemy, this API can work for small, chaotic, and oddly practical use cases:

💬 Event RSVP Tracking (Without a Real Backend)
📋 Internal Tools for Non-Devs
🧪 Prototyping APIs Before You Commit to a Real DB
🎓 Teaching & Workshops
📈 Collecting Feedback, Bug Reports, or Feature Votes

🤔 Final Thoughts

Sure, it was a wacky little experiment, but hey, now you know what a REST API in Go might look like, how to sweet-talk the Google Sheets API, and how to shove the whole thing into a Docker container like a tech-savvy magician.

I regret everything
I also regret nothing
It works
And that’s the real problem

Want to witness the beautiful chaos for yourself? The full code lives here (handle with care): https://github.com/ppaczk0wsk1/go-sheet-api

Automating My Minecraft Bedrock Server with Bash, Jenkins, and Chicken Noises 🐔

Cyber — Sat, 14 Jun 2025 08:39:12 +0000

And yes, the Lava Chicken makes an appearance at the end.

Keeping your Minecraft Bedrock server up to date is important, unless you enjoy surprise crashes, player complaints, and corrupt worlds. Updating it manually? That’s a whole saga: stop the server, back everything up, grab the latest release, restore configs, restart it all. Miss a step? Say goodbye to your Nether castle.

Naturally, I decided to automate the whole thing with a Bash script and Jenkins, so now my server updates itself while I’m off building pixel art and eating a pickle pizza.

🛠️ Why Jenkins?

Jenkins is like that overachieving robot butler you wish you had in real life. It’s open-source, endlessly configurable, and perfect for automating server-side rituals like this one.

With Jenkins, I get:

Automatic updates on a schedule (e.g., 3 AM, when no one's online except Endermen).
Logs and job status in a web UI (goodbye, mystery bugs)
Failure notifications if something breaks
One-click manual runs, for when I’m feeling fancy

🔄 How Jenkins Runs the Update Script

I set up my Bash script as a Jenkins freestyle job (pipeline works too):

Stops the server (gently)
Backs up all important files (just in case Creepers learn how to hack)
Downloads the latest Bedrock release
Restores worlds and configs
Restarts the server
Logs everything like it’s testifying before a redstone tribunal

If something fails? Jenkins sends me a passive-aggressive email like, “Hey, your server faceplanted, bozo!”

🧰 Jenkins Setup TL;DR

Install Jenkins somewhere with access to your server files. I have it on my VPS which is connected to my home server.
Make sure the Jenkins user can stop/start the Bedrock server and write to the backup directory
Create a Jenkins job with a build step that runs the Bash script
Use cron syntax in Build Triggers to schedule it or trigger it manually.
Peek at “Console Output” in Jenkins if things get weird

📜 The Bash Script That Runs the Show
Pro tip: Put on headphones before running it. There’s a 1% chance the Lava Chicken song plays.

#!/bin/bash

# Variables
BEDROCK_DIR=<BEDROCK_DIR>
BEDROCK_LOG_FILE="$BEDROCK_DIR/bedrock_server.log"
BACKUP_DIR=<BACKUP_DIR>
TEMP_DIR=<TEMP_DIR>
WORLD_DIR="$BEDROCK_DIR/worlds"
CONFIG_FILES=("$BEDROCK_DIR/server.properties" "$BEDROCK_DIR/permissions.json" "$BEDROCK_DIR/whitelist.json")
LOG_FILE=<LOG_FILE>
BACKUP_FILE="$BACKUP_DIR/bedrock_backup_latest.tar.gz"

# Logging
exec > >(tee -i $LOG_FILE)
exec 2>&1

echo "Starting Bedrock Server update process..."

# Stop the server
echo "Stopping Bedrock server..."
pkill -f "bedrock_server" || echo "Bedrock server not running."

# Backup files
echo "Backing up world and configuration files..."
mkdir -p "$BACKUP_DIR"
TIMESTAMP=$(date +"%Y%m%d_%H%M%S")
tar -czf "$BACKUP_FILE" -C "$BEDROCK_DIR" .

# Save world/configs
echo "Saving world and configuration files..."
mkdir -p "$TEMP_DIR/config_backup"
cp -r "$WORLD_DIR" "$TEMP_DIR/config_backup"
for CONFIG_FILE in "${CONFIG_FILES[@]}"; do
  [ -f "$CONFIG_FILE" ] && cp "$CONFIG_FILE" "$TEMP_DIR/config_backup/"
done

# Download latest version
echo "Downloading the latest Bedrock server version..."
mkdir -p "$TEMP_DIR"
LATEST_URL=$(curl -Ls -A "Mozilla/5.0" "https://www.minecraft.net/en-us/download/server/bedrock/" | grep -o 'https://www.minecraft.net/bedrockdedicatedserver/bin-linux/[^"]*')
[ -z "$LATEST_URL" ] && echo "Error: Could not find latest Bedrock URL." && exit 1
wget --user-agent="Mozilla/5.0" "$LATEST_URL" -O "$TEMP_DIR/bedrock-server.zip" || { echo "Error: Download failed."; exit 1; }

# Update files
echo "Updating server files..."
unzip -o "$TEMP_DIR/bedrock-server.zip" -d "$BEDROCK_DIR"

# Restore world/configs
echo "Restoring world and configuration files..."
cp -r "$TEMP_DIR/config_backup/worlds" "$BEDROCK_DIR"
for CONFIG_FILE in "${CONFIG_FILES[@]}"; do
  RESTORED="$TEMP_DIR/config_backup/$(basename "$CONFIG_FILE")"
  [ -f "$RESTORED" ] && cp "$RESTORED" "$BEDROCK_DIR"
done

# Cleanup
rm -rf "$TEMP_DIR"
echo "Update complete. Cleaning up temporary files."

# Restart server
echo "Starting the Bedrock server..."
export BUILD_ID=dontKillMe
cd "$BEDROCK_DIR"
nohup bash -c "LD_LIBRARY_PATH=. ./bedrock_server" > "$BEDROCK_LOG_FILE" 2>&1 &
echo "Server restarted successfully. Log: $BEDROCK_LOG_FILE"
echo "https://youtu.be/41O_MydqxTU"

exit 0

🧠 Final Thoughts

Thanks to this setup, my Minecraft Bedrock server updates itself while I’m AFK. Safely, reliably, and without any “oops I overwrote my Nether base” moments.

If you're running a personal or community server, automating your updates with Jenkins + Bash is a power move. Add backups, clean logging, and a sprinkle of Lava Chicken magic, and you're golden.

Bonus: Yes, I actually listen to the Lava Chicken song every time this script runs. It’s tradition now.
La-la-la-Lava! Ch-ch-ch-chicken! 🐔🔥

A Minecraft GIF – A Minecraft Movie – odkrywaj i udostępniaj GIF-y

Click to view the GIF

tenor.com