Lights flicker in the server room at 3 AM—another drive fails, and you’re SSH-ing into three machines, praying Restic snapshots didn’t vanish into the ether.
That’s the nightmare that birthed Arkeep, a self-hosted centralized backup manager designed for folks like us who run real stacks: servers, Docker swarms, directories that can’t afford to lose a byte. The creator, fed up with fragmented tools, rolled his own. And damn, it’s got that future-proof vibe—think of it as the Kubernetes of backups, orchestrating chaos into symphony.
Here’s the thing. Backups? They’re everywhere. Restic crushes it on reliability. Backrest shines on single nodes. But scatter them across machines? You’re blind, scrambling, non-compliant. No single pane. No SSO magic. No metrics that scream ‘success’ or ‘fire drill.’
So, he built Arkeep. Agents phone home via persistent gRPC streams—no SSH roulette, no inbound ports begging for exploits. Server-side? REST API, slick web UI, scheduler humming on gocron, SQLite or Postgres for the data hoard. It’s Go-powered, lean, compliant-ready for ISO 27001 audits.
There’s no shortage of backup tools. But none of them gave me a simple way to manage backups across multiple machines from one place, so I built my own.
That quote nails it. Pull quotes like this from the trenches? Pure gold.
Why Ditch Scripts for Arkeep’s Agent Magic?
Sure, cron + Restic + bash could hack it. But that’s duct tape on a rocket ship—scheduling drifts, visibility? Zero. Audit trails? Laughable. And SSH from a central box? Firewalls laugh, NAT cries, VPNs like Netbird throw tantrums.
Arkeep flips the script. Agents outbound-connect, stream live. Job drops? Boom—resolve Docker volumes on-the-fly, hook pre/post scripts, fire Restic with JSON output, pipe metrics back real-time. Logs flow like a river. Disconnect? Server knows instantly. It’s resilient, secure, audit-gold.
Visualize the flow:
┌─────────────────────────────────┐ │ Arkeep Server │ │ REST API │ gRPC Server │ │ Scheduler │ WebSocket Hub │ │ SQLite/PG │ Notification Svc│ └─────────────────────────────────┘ ▲ ▲ │ gRPC │ gRPC │ (persistent stream) ┌───────┴────┐ ┌───┴────────┐ │ Agent A │ │ Agent B │ │ Server 1 │ │ Server 2 │ └────────────┘ └────────────┘
No polling waste. Just push perfection.
And Docker? Agent inspects containers, grabs volume mounts—Restic sees directories, oblivious to the wizardry. Code snippet tells the tale:
func resolveVolumeMounts(cli *client.Client, containerID string) ([]string, error) {
// Inspects, extracts volume sources. Boom, backed up.
}
It’s elegant. Effortless.
How Does Arkeep Fit Your Self-Hosted Empire?
You’re behind Zitadel SSO? OIDC slots right in. Netbird VPN? Agents tunnel clean. Compliance looming? Centralized logs, metrics (transferred data, snapshot sizes), traceability—check, check, check.
Server dispatch? Dead simple:
func (s *Server) DispatchJob(agentID string, job *pb.JobRequest) error {
stream, ok := s.agentStreams.Get(agentID)
if !ok {
return fmt.Errorf("agent %s offline", agentID)
}
return stream.Send(job)
}
Offline agent? Error fast. No ghosts in the machine.
Restic wrapper streams JSON events—bufio.Scanner chews stdout, unmarshals, sends. Pre/post hooks? Your scripts rule. It’s extensible without being a mess.
But wait—my bold take, absent from the original: Arkeep echoes Git’s revolution. Pre-Git, version control was per-repo hell. Git centralized it, birthed GitHub empires. Backups now? Same fragmented pain. Arkeep centralizes for the sovereign cloud era. Prediction: In five years, as we run local AI models gobbling personal data lakes, tools like this become mandatory. Backups aren’t recovery—they’re your AI’s memory bank, sovereign and snap-restorable. Self-hosters win the data wars.
Is Arkeep Battle-Ready or Just Clever Hype?
Tech stacks: Chi for HTTP, gRPC for agents, golang-migrate for DB schemas. SQLite defaults (lightweight genius), Postgres scales. Scheduler checks connectivity pre-job—smart.
Pain points solved: Multi-machine visibility. One UI. Metrics dashboard. Notifications. It’s not vaporware; architecture screams production.
Critique? Early days—community nascent. No fancy ML predictions (yet). But open-source? Fork it. That’s the futurist flex.
Deploy? Grab from GitHub (assuming it’s there), spin server, drop agents. Behind VPN/SSO? Native fit. Compliance? Audit logs seal it.
Picture fleets of homelabs, edge servers, Docker fleets—all pulsing backups to one nerve center. Wonder hits: This scales to thousands? Agents stream efficient. gRPC handles it. Postgres hums. Yeah.
Energy builds. Backups boring? Nah— they’re the unsung hero of uptime. Arkeep spotlights them.
Shorter para. Boom.
And the hooks—pre-backup sanity (disk space?), post-verify integrity. Restic’s rock-solid, agent adds ceremony without bloat.
Why Does Centralized Backup Matter Now More Than Ever?
Self-hosting surges—LLMs local, data sovereignty reigns. One outage? Model training data gone. Arkeep ensures snapshots cluster, queryable, restorable fleet-wide.
Corporate spin? None here—solo dev, no VC fluff. Honest build for real pain.
🧬 Related Insights
- Read more: Brett Cannon Spills: Python’s Steering Council Drama, Astral’s Quiet Takeover, and the Lock File Fight
- Read more: I Just Fired Up a Pirate Radio Station from My Dynamic IP – Here’s the No-BS Linux Hack
Frequently Asked Questions
What is Arkeep backup tool?
Arkeep’s a self-hosted manager centralizing Restic backups across machines via agents—no ports, full visibility, SSO-ready.
How does Arkeep work with Docker and Restic?
Agents resolve Docker volumes runtime, wrap Restic executions, stream JSON metrics/logs back live—Restic does the heavy lifting untouched.
Can Arkeep handle compliance like ISO 27001?
Yes—central logs, traceability, metrics, audit trails make it compliance catnip, especially with OIDC auth.
