Go to SlimFaas website

SlimFaas: The Slimmest, Simplest & Autoscaling-First Function-as-a-Service

Start exploring

Choose Kubernetes, native local processes, or Docker Compose. Open the built-in dashboard and follow the Guided Tour with cURL or the Bruno collection. Find all runtime routes in the API Reference.

The precompiled local demo packages the dashboard, functions and jobs without requiring a .NET or Node installation. It requires a release containing the new SlimFaas-Local-* bundles; source-based development remains available in Local Mode.

🌥️ Proud CNCF Landscape Project

SlimFaas is part of the Cloud Native Computing Foundation (CNCF) landscape.

Join us on CNCF Slack · Community Meeting Calendar · Code of Conduct

SlimFaas is a lightweight, plug-and-play Function-as-a-Service (FaaS) platform for Kubernetes, native local processes, Docker Compose and Podman Compose. It’s designed to be fast, simple, and extremely slim — with a very opinionated, autoscaling-first design:

• 0 → N wake-up from HTTP history & schedules,
• 0 → N wake-up from Kafka lag via the companion SlimFaas Kafka service,
• N → M scaling powered by PromQL, plus opt-in 0 → N wake-up from independent OpenMetrics exporters,
• internal metrics store, debug endpoints, and scale-to-zero out of the box.
• built-in User Interface at the SlimFaas root address to see functions, jobs, queues, and real-time messages.
• Scaling diagnostics and playground to explain live decisions and preview changes without modifying production.
• temporary Data Files endpoints to ingest and stage binaries (from tiny to very large) with TTL-friendly storage — perfect for caching & agentic workflows.
• temporary Data Sets endpoints (/data/sets) to store small, Redis-like KV payloads (cache, JSON state, flags) with optional TTL — replicated through the cluster via a robust consensus layer.

---

Why Use SlimFaas?

🚀 Autoscaling that actually understands your traffic

• Scale-to-zero & wake-up

  • Scale down to 0 after inactivity with configurable timeouts.
  • Wake up from 0 → N based on real HTTP traffic and/or cron-like schedules.
  • Wake up from 0 → N based on Kafka topic activity, using SlimFaas Kafka to monitor consumer lag and call the SlimFaas wake-up API.
  • Control initial capacity with ReplicasAtStart to reduce cold-start impact.

• Two-phase scaling model

  • 0 → N: driven by HTTP history, schedules, and Kafka lag (SlimFaas Kafka) to bring functions online only when they’re needed.
  • N → M: driven by a built-in PromQL mini-evaluator on top of an internal metrics store.
  • Existing local-metric configurations run while pods exist; independent external sources can opt into wake-up with ScaleFromZero: true.

• PromQL-driven autoscaler

  • Express scaling rules with PromQL-style queries, for example:
    • sum(rate(http_server_requests_seconds_count{namespace="...",job="..."}[1m]))
    • max_over_time(slimfaas_function_queue_ready_items{function="my-func"}[30s])
    • histogram_quantile(0.95, sum by (le) ( rate(http_server_requests_seconds_bucket{...}[1m]) ))
  • Choose whether thresholds are per pod (AverageValue) or global (Value).
  • Configure scale-up/scale-down policies and stabilization windows inspired by HPA/KEDA.

• Integrated metrics scraping

  • SlimFaas scrapes annotated pod endpoints and explicitly configured external HTTP/HTTPS OpenMetrics sources.
  • It stores only the metric keys that are requested in autoscaling triggers or debug queries.
  • A single designated node scrapes and persists metrics; all other nodes read from the same store.

• Debug-friendly

  • POST /debug/promql/eval – evaluate a PromQL expression against the internal store and see the scalar result.
  • GET /debug/store – inspect what metrics are being scraped, how many series exist, and retention size.
  • Designed so you can easily answer: “What does SlimFaas see when it decides to scale?”

• FinOps-minded

  • 30-minute metrics retention window for predictable memory usage.
  • Native scale-to-zero and schedules to keep non-critical workloads cold when they’re not needed.
  • Slim control-plane footprint to avoid burning resources in your autoscaling logic itself.

🧵 Synchronous and Asynchronous Functions

• Simple HTTP endpoints for both sync and async calls.
• Async mode:
  • Limit the number of concurrent requests per function.
  • Configure retry behaviors and backoff strategies.
  • Drive autoscaling decisions from queue metrics.

⏱ Jobs

• Run one-off, batch, and scheduled (cron) jobs via HTTP calls.
• Configure:
  • concurrency,
  • visibility (public/private),
  • retry behavior.

🔐 Private/Public Functions and Jobs

• Mark functions as public or private:
  • Private: only accessible from within the cluster or from trusted pods.
  • Public: fronted by Ingress / API Gateways as usual.

📣 Publish/Subscribe Internal Events

• Synchronously send events to every replica of selected functions.
• No additional event bus required — ideal for cluster-local fan-out, cache invalidation, configuration refresh, etc.

🧰 Data Files & Data Sets (real-time ingestion + ephemeral caching + robust KV)

SlimFaas includes two complementary “data” APIs:

📁 Data Files (temporary binary artifacts)

Data Files endpoints are designed to stream, store, and serve temporary files — from tiny payloads to very large binaries. Ideal for agentic workflows and real-time ingestion: upload once, get an id, then let tools/functions consume it when they’re ready.

• Stream-first uploads (without buffering in memory or disk)
• Agentic-ready attachments & multi-step flows
• Ephemeral caching for intermediate artifacts
• TTL-based lifecycle (auto-expiration)

🧠 Data Sets (Redis-like KV for small state)

Data Sets endpoints provide a small, Redis-like KV store (raw bytes) replicated across the SlimFaas cluster.

• Stream-first uploads
• Store anything small: JSON, strings, flags, lightweight cache entries
• Optional ttl in milliseconds (auto-expiration)
• Hard limit: 1 MiB per value

🧠 “Mind Changer” (Status & Wake-up API)

• Built-in REST APIs to:
  • monitor function and replica status,
  • wake functions up on demand,
  • integrate autoscaling state into your own tools/dashboards.

🔌 Plug and Play

• Deploy SlimFaas as a standard pod/StatefulSet with minimal configuration.
• Onboard existing workloads simply by adding annotations:
  • let SlimFaas manage their scaling without rewriting your applications.

⚡ Slim & Fast

• Written in .NET with:
  • focus on performance and low memory footprint,
  • AOT-friendly design,
  • minimal dependency surface.

---

Ready to Get Started?

Check out:

• Get Started – Choose Kubernetes, native local processes or Docker Compose.
• Local Mode – Run functions, Jobs, development processes, and a supervised SlimFaas cluster directly on your machine.
• Scaling
  • Autoscaling – Configure 0 → N / N → M autoscaling, PromQL triggers, metrics scraping, and debug endpoints.
  • Kafka Connector – Use Kafka topic lag to wake functions and keep workers alive while messages are flowing.
  • Planet Saver – Start and monitor replicas from a JavaScript frontend.
• Functions & Workloads
  • Functions – Call functions synchronously or asynchronously.
  • User Interface – Monitor functions, queues, jobs, and real-time messages.
  • Clients – Integrate SlimFaas with .NET and Python applications.
  • Events – Use internal publish/subscribe events.
  • Jobs – Define, schedule, and run one-off jobs.
  • OpenTelemetry – Enable distributed tracing, metrics, and logs.
  • Benchmarks – Measure sync overhead, async delivery latency, and native-local scaling speed.
• Data & Files
  • Data Files – Ingest, store, and serve temporary binary artifacts.
  • Data Sets – Store replicated, Redis-like key-value payloads with optional TTL.
• How It Works – Understand SlimFaas architecture and request flows.

Technical references

• Local three-node orchestrator
• Memory profiling
• Unified SlimData mutation batching
• SlimData batch modes
• Environment-variable breaking changes

We hope SlimFaas helps you simplify autoscaling, reduce costs, and keep your serverless workloads slim.

---

Community & Governance

• Community Meeting Join us through our Community Meeting Calendar

  • ICS file

• Slack Channel Join our channel on the CNCF Slack to connect with other SlimFaas users.

• Code of Conduct SlimFaas follows the CNCF Code of Conduct.

Enjoy SlimFaas!

---

Adopters

List of organizations using this project in production or at stages of testing.

---

Add your logo via a pull request:

• Logo must be in PNG format, 100 px wide and 100 px high.
• Add your logo to the docs/adopters_logo folder.

Live operational dashboard

The embedded SlimFaas dashboard pairs a compact infrastructure overview with a zoomable canvas traffic map for jobs, replicas and functions. Its Data tab streams keys, TTL and file sizes without reading stored contents. Traffic identifies the Raft leader and each visible replica destination; an opt-in log viewer follows managed functions, jobs and SlimFaas nodes with bounded, filterable output.

External metrics autoscaling

Scale running functions from independent Prometheus/OpenMetrics exporters and optionally wake them from zero with SlimFaas/Scale.ScaleFromZero: true. Existing annotations keep their behavior. See configuration and rollout and the native/Kubernetes exporter demo.