Nirvati

Nirvati is a self‑hosted platform that abstracts the complexity of deploying, managing, and scaling individual applications on a single machine or cluster. At its core, it functions as an application hub: users install a lightweight runtime that pulls curated Docker images from the Nirvati App Store, orchestrates networking, and enforces a strict isolation model. For developers, this means you can expose your own services to the world without wrestling with reverse proxies or SSL termination—Nirvati supplies automated HTTPS via Let's Encrypt and a permissive yet auditable permission system that restricts each container to its own namespace.

Architecture

• Runtime Engine: The heart of Nirvati is a Go‑based orchestrator that interfaces directly with the Docker API. It watches a configuration file (YAML/JSON) for desired app manifests, pulls images from the Nirvati registry, and manages container lifecycles.
• API Layer: A RESTful API exposes CRUD operations on apps, logs, and metrics. Endpoints are authenticated via JWT tokens issued by the central auth service, allowing programmatic control from CI/CD pipelines or custom dashboards.
• Database: Application metadata and user settings are stored in a lightweight SQLite database shipped with the runtime, making initial deployment trivial while still supporting migration to PostgreSQL for larger deployments.
• Networking: Nirvati sets up an internal Docker network and exposes each app on a unique subdomain (e.g., app.example.com). It uses Traefik as an edge router to handle HTTPS termination, HTTP/2, and WebSocket upgrades automatically.

The stack deliberately favors containerization over virtual machines to reduce overhead and simplify scaling: a single host can run dozens of isolated services, each with its own resource limits.

Core Capabilities

• App Store Integration: The platform ships with a curated catalog of Docker images. Developers can add custom entries by providing a simple nirvati.yaml that specifies image name, port mapping, and environment variables.
• Permission System: Every app runs in its own namespace with a dedicated Docker user, and the runtime enforces read/write permissions to host directories via userns-remap.
• Webhooks & Events: The API emits events on install, update, and uninstall actions. Developers can hook into these to trigger downstream automation (e.g., provisioning a database or updating DNS records).
• Metrics & Logging: Integrated Prometheus exporters expose per‑app CPU/memory usage, while logs are forwarded to a central Loki instance for aggregation.

Deployment & Infrastructure

Nirvati is designed for easy self‑hosting: a single binary, an optional Docker image, or a Helm chart for Kubernetes. It runs on Linux distributions that support systemd; optional system‑wide installation exposes it as a service (systemctl enable nirvati). For larger environments, the runtime can be deployed behind an HAProxy load balancer or as a Kubernetes deployment that manages its own sidecar containers. Resource requirements are modest—typically 512 MiB RAM and a single CPU core suffice for a handful of apps, scaling linearly with the number of containers.

Integration & Extensibility

• Plugin SDK: Developers can write Go plugins that hook into the runtime’s lifecycle events. The plugin API exposes callbacks for OnStart, OnStop, and OnUpdate, allowing custom logic (e.g., dynamic DNS updates or custom security checks).
• Custom App Store: The registry can be mirrored locally, enabling private app distribution. By hosting your own Docker registry and pointing the Nirvati runtime to it, you maintain full control over image provenance.
• Webhooks: Each app can expose internal REST endpoints; Nirvati forwards external webhook calls to these endpoints, enabling integrations with GitHub Actions or Slack.

Developer Experience

The platform’s configuration is intentionally human‑readable: a single YAML file defines all apps, their ports, and environment variables. The API documentation is auto‑generated with Swagger UI, providing interactive exploration of endpoints. Community support is active on GitHub Discussions and a dedicated Discord server where developers share custom app manifests and troubleshoot deployment issues. Licensing is permissive (GPL‑3.0), allowing commercial use without royalties.

Use Cases

• Personal Cloud: Run a self‑hosted Nextcloud, GitLab, or Home Assistant instance with minimal manual setup.
• Team Collaboration: Deploy a suite of internal tools (Jira, Confluence, Mattermost) on a single server with automated TLS and isolated containers.
• Edge Computing: Host lightweight services (e.g., MQTT brokers, REST APIs) on IoT gateways while keeping traffic encrypted and isolated.
• Educational Labs: Provide students with a sandboxed environment where each lab assignment runs in its own container, ensuring no cross‑contamination of data.

Advantages

Developers choose Nirvati for its balance of simplicity and control: a single binary orchestrates complex container workloads, eliminating the need for separate reverse proxy or SSL tooling. The built‑in permission system and automated HTTPS give strong security out of the box, while the extensible plugin SDK allows deep customization. Compared to generic Docker Compose setups, Nirvati reduces operational overhead by handling app discovery, updates, and health checks automatically. Its lightweight footprint and permissive license make it ideal for both hobbyists and enterprise teams seeking a privacy‑first, self‑hosted solution.