Apache-2.0 Open Source · Cloudflare Workers + Static Go Agent

Enterprise Fleet Orchestration Without the SaaS Tax

Reconcile zero-downtime Blue/Green services and stateful singletons with immutable revisions, enforce hard Docker cgroup limits, connect servers over a direct P2P WireGuard mesh with TTL 5s MagicDNS, and query an R2 Parquet lakehouse—all from a $0/month serverless control plane.

$0/mo
Workers + D1 + R2 Free Tier
<25 MiB
Static Go Host Daemon
<1 ms
Atomic Traefik Route Flip
5s TTL
Split-Horizon Mesh DNS
Enroll any Linux host in 10 seconds
curl -fsSL https://flarelens.dev/install.sh | sudo bash -s -- \
  --control "https://your-plane.workers.dev" \
  --token "$FLARELENS_INGEST_SECRET"
Live Host Verification ● Healthy · Piggybacked 15s Sync
[flarelensd] SHA-256 checksum verified (linux/amd64)
[flarelensd] WireGuard overlay active: 100.64.0.1/10 (UDP P2P)
[flarelensd] MagicDNS listening on 100.64.0.1:53 (UDP+TCP, TTL=5s)
[flarelensd] RAM secret store mounted: /dev/shm/flarelens-secrets (0700)
[flarelensd] Enrolled as Healthy — 0 inbound firewall ports required
Two-Plane Sovereign Design

The Edge Coordinates. Your Servers Own the Data Plane.

FlareLens never routes private database or container traffic through a central proxy. If control-plane connectivity ever drops, running containers, Traefik routes, and WireGuard tunnels continue serving live traffic autonomously.

Control Plane · Cloudflare Edge

Global Coordinator (antwig2/flarelens)

  • D1 State & Revisions: Immutable numbered fleet revisions (rev-1, rev-2, …), placement leases, and 1-click UAT → Prod promotion & rollback.
  • Piggybacked 15s Heartbeat: Commands, mesh peers, cluster endpoints, and feature flag hashes ride the /api/v1/ingest response (0 R2 list() calls).
  • AES-256-GCM Vault: Zero-plaintext secrets stored encrypted in Workers KV and delivered strictly into process RAM or ephemeral /dev/shm tmpfs.
  • Parquet Lakehouse: Compacts container logs into Hive-partitioned Apache Parquet in R2, queried in-browser via DuckDB-WASM with $0 egress.
Data Plane · Cloud, Bare-Metal & Hybrid

Static Go Host Agent (antwig2/flarelensd)

  • Blue/Green & Singletons: Boots candidate slots, runs pre-deploy R2 pg_dump snapshots & migrations, verifies health probes, and flips Traefik in <1ms.
  • Hard Kernel Cgroups: Enforces HostConfig.Memory & NanoCPUs, updates running stateful singletons in place with zero restarts, and auto-prunes 72h+ images.
  • Direct P2P WireGuard: Kernel-space ChaCha20-Poly1305 mesh across regions and providers without central VPN relays or bandwidth bottlenecks.
  • Split-Horizon MagicDNS: Embedded UDP+TCP DNS server on <overlay_ip>:53 serving round-robin <service>.<env>.mesh records at TTL = 5s.
Platform Capabilities

Everything Docker Compose Was Missing Across Multiple Servers

No Kubernetes control-plane VMs, no etcd quorum babysitting, and no six separate SaaS subscriptions.

Zero-Git Fleet & Immutable Revisions

Create, edit, suspend, promote (uat → prod), and roll back workloads directly in the UI—or sync YAML manifests from GitHub Actions via keyless OIDC. Every mutation writes an immutable rev-N snapshot to D1 + R2.

Multi-Server Scheduler & Auto-Failover

Schedule stateless replicas across a server pool with spread anti-affinity, binpack consolidation, or pinned affinity. Drain nodes cleanly, reschedule off dead hosts automatically, and fence stateful DB volumes so data is never wiped.

Dynamic Mesh DNS (TTL 5s)

Containers receive HostConfig.Dns pointing to <overlay_ip>:53 over UDP and TCP. Cross-server calls to http://billing-api:8080 resolve across healthy WireGuard peers with lock-free round-robin and 5-second failover.

Zero-Plaintext Vault & RAM tmpfs

Secrets stay AES-256-GCM encrypted in KV until deployment, then inject into container memory or materialize into /dev/shm/flarelens-secrets (0700 host isolation, 0600 private keys) via __FLARELENS_FILE__—never touching persistent disks.

Hard Cgroup Limits & Auto Image Prune

Declare memory_mb and cpu_cores on apps, workers, and stateful singletons so a memory leak can never starve PostgreSQL. Retired Docker images older than 72 hours are garbage-collected automatically while preserving instant rollback layers.

Zero-Disk R2 Backups & DuckDB Logs

Pre-deploy guardrails stream gzipped pg_dump snapshots through an io.Pipe directly to Cloudflare R2 before running schema migrations, with automated rollback on failure and browser-native SQL analytics over Parquet logs.

Canonical Schema · flarelens.dev/schemas/fleet.schema.json

Clean Declarative Manifests With Full IDE Autocomplete

Author workloads in the Dashboard UI or validate YAML/JSON files in VS Code and CI against https://flarelens.dev/schemas/fleet.schema.json.

Zero-downtime Blue/Green API + background worker + pre-deploy migration guardrail YAML
# yaml-language-server: $schema=https://flarelens.dev/schemas/fleet.schema.json
service: billing-api
env: prod
mode: blue_green
domains:
  - api.example.com
  - auth.example.com
image: ghcr.io/acme/billing-api:1.8.0
memory_mb: 768
cpu_cores: 1.5
container_port: 8080
host_port_blue: 9080
host_port_green: 9081
health_path: /health
pre_deploy_snapshot: true
run_migrations: true
migration_cmd: /app/billing-api migrate up

networks:
  - app-prod
  - flarelens-edge

aliases:
  - billing-api

workers:
  - name: outbox-drainer
    command: ["worker", "start"]
    memory_mb: 384
    cpu_cores: 0.75
    networks:
      - app-prod
Operational Economics

How FlareLens Compares

Keep raw Linux/Docker predictability and $0 egress telemetry while gaining multi-host orchestration, encrypted secrets, and mesh networking.

Platform architecture and cost comparison across multi-server deployments
Capability FlareLens Managed Kubernetes Fragmented SaaS + Compose
Control Plane Cost $0/mo (Workers + D1 + R2 free tier) $75–$300+/mo control plane + node overhead $150–$500+/mo across 4–6 SaaS bills
Host Agent Overhead <25 MiB static Go binary 600–1,200+ MiB (kubelet, CNI, CSI, agents) Multiple log, APM, and VPN daemons
Cross-Server Service DNS Built-in WireGuard MagicDNS (TTL 5s) CoreDNS + CNI overlay Manual /etc/hosts or external VPN DNS
Secret Materialization AES-256-GCM Vault → RAM /dev/shm tmpfs etcd Secrets + external-secrets operator Plaintext .env files on disk or SaaS CLI
Log Storage & Egress R2 Parquet + DuckDB-WASM ($0 egress) Self-hosted Loki/ELK or paid SaaS ingest Per-GB ingestion & retention markups
Stateful DB Safety Volume fencing + streaming R2 pg_dump StatefulSet PVCs + CSI snapshot controller Custom cron scripts
Frequently Asked Questions

Common Architectural Questions

Do I need a GitOps repository to use FlareLens?

No. You can define, deploy, suspend, promote (uat → prod), and roll back services directly in the FlareLens Dashboard UI backed by immutable D1 + R2 revisions (rev-1, rev-2, …). If you also use CI/CD, GitHub Actions webhooks and fleet/*.yml OIDC syncs plug directly into the same revision history.

Does my private server-to-server traffic pass through Cloudflare?

Never. Cloudflare Workers only coordinates Curve25519 public keys and endpoint discovery. All private container, database, and operator mesh traffic flows directly peer-to-peer between your hosts over encrypted UDP WireGuard tunnels.

What happens if a host loses internet access to the Control Plane?

Running containers, local Traefik routing rules, hard kernel cgroups, and active peer-to-peer WireGuard sessions continue operating autonomously with zero disruption. Once connectivity returns, flarelensd resumes its 15-second heartbeat sync automatically.

Do I have to use Cloudflare Tunnel (cloudflared) for public web traffic?

No. FlareLens supports both direct public ingress (pointing standard A/AAAA DNS records at your server with Traefik/Caddy TLS) and zero-inbound-port tunnels (running cloudflared as a managed singleton with ports 22, 80, and 443 closed on your firewall).