nuclio/nuclio
Nuclio
Nuclio is a high-performance serverless framework designed for Kubernetes that automatically executes user functions when events arrive from HTTP endpoints, message queues, or streaming data platforms. It processes hundreds of thousands of events per second per function instance through efficient parallel workers, and can allocate functions to run on either CPU or GPU hardware to match workload requirements for data processing or machine learning tasks.
The platform scales function instances down to zero when idle and wakes them on demand based on incoming event load, while providing an event-source abstraction layer that maps diverse triggers like Kafka, Kinesis, RabbitMQ, and NATS to a unified interface without requiring code changes. Nuclio builds Docker images from raw function code at runtime using Kaniko, avoiding the need for a Docker daemon or privileged access, and offers a web-based code editor for editing and testing functions directly in the browser.
The framework integrates with Jupyter Notebooks through a dedicated Python SDK, enabling programmatic function creation and deployment from data science workflows. Functions can be deployed as standalone Docker containers or on top of an existing Kubernetes cluster, with support for auto-scaling, GPU scheduling, and event-driven lifecycle management.
Features
- Serverless Function Executions - Executes user functions automatically when events arrive from HTTP, message queues, or streaming data sources.
- Serverless Platforms - Provides an event-driven platform that runs user functions triggered by HTTP, message queues, and streaming data sources with automatic scaling.
- High-Throughput Event Processing - Processes hundreds of thousands of events per second from HTTP, message queues, and streaming sources with automatic scaling.
- High-Throughput Processing - Processes large volumes of streaming data and events in real time with sub-second latency using serverless functions.
- Streaming Data Sources - Connects functions to streaming data sources so they run automatically when new events arrive.
- Docker Image Builds - Builds Docker images from raw function code at runtime for automated deployment pipelines.
- Kaniko-Based Builders - Uses Kaniko to securely build Docker images from raw function code without privileged access.
- Daemonless Image Builds - Builds Docker images at runtime using Kaniko for secure, daemonless container image generation.
- Kubernetes Deployments - Deploys serverless functions as standalone Docker containers or on top of an existing Kubernetes cluster.
- Daemonless Container Image Building - Builds Docker images from raw function code using Kaniko for secure, daemonless artifact generation.
- Kaniko-Based Builds - Builds Docker images from function code at runtime using Kaniko for secure artifact generation.
- Event Ingestion - Ingests events from HTTP, message queues, and timers to trigger serverless function execution.
- Event Triggers - Triggers user functions automatically when events arrive from HTTP, message queues, or streaming platforms.
- Scale-to-Zero Pods - Scales function instances down to zero when idle and wakes them on demand based on event load.
- Serverless Deployment - Deploys user code as serverless functions that automatically trigger from HTTP, message queues, streams, and timers.
- Custom Resource Serverless Frameworks - Deploys functions as Kubernetes custom resources with automatic scaling and event-driven invocation.
- Stateless Function Deployments - Deploys user functions as containerized services triggered by HTTP, message queues, streams, or schedules.
- Kubernetes Custom Resource Functions - Deploys functions as containers on Kubernetes with auto-scaling, GPU scheduling, and event-driven lifecycle management.
- Event Source Integrations - Connects serverless functions to Kafka, Kinesis, RabbitMQ, and NATS without code changes.
- Unified Trigger Interfaces - Maps HTTP, Kafka, and message queues to a unified trigger interface without requiring code changes.
- High-Throughput Task Processing - Processes hundreds of thousands of events per second per function instance through efficient I/O and compute handling.
- High-Throughput Processors - Processes hundreds of thousands of events per second per function instance through efficient parallel workers.
- Serverless Platforms - Runs user functions triggered by HTTP, message queues, and streaming data sources with automatic scaling and GPU support.
- Hardware-Aware Function Schedulers - Allocates serverless functions to CPU or GPU hardware to match data processing or ML workload requirements.
- Serverless GPU Inference Platforms - Runs serverless functions on GPU hardware to accelerate machine learning inference and data processing workloads.
- Jupyter Notebook Integrations - Integrates with Jupyter Notebooks through a dedicated Python SDK for programmatic function creation and deployment.
- Notebook-Based Function Management - Creates and deploys serverless functions programmatically from Jupyter Notebooks using a dedicated Python SDK.
- Notebook Function Deployments - Creates and deploys serverless functions programmatically from a Jupyter Notebook using a dedicated SDK.
- Auto Scaling - Scales function instances up or down to zero based on usage, waking idle functions on demand.
- Feature-Flagged Docker Builds - Builds Docker images from function code at runtime using Kaniko without requiring a Docker daemon.
- Web-Based Function Editors - Edits, deploys, and tests serverless functions through a web-based code editor and dashboard.
- GPU-Aware Function Scheduling - Executes serverless functions on either CPU or GPU hardware to accelerate data processing and machine learning tasks.
- GPU Resource Allocators - Allocates serverless functions to run on either CPU or GPU hardware to match workload requirements.
- Notebook-Based Function Deployments - Builds, deploys, and manages serverless functions from data science notebooks using Jupyter, Kubeflow, and MLRun.
- Notebook SDKs - Enables programmatic function creation and deployment from Jupyter Notebooks using a dedicated Python SDK.
- Browser-Based Editors - Provides a graphical interface for editing and testing functions directly in the browser without command-line tools.
- Model Serving & Deployment - Executes compute-intensive workloads in a serverless fashion.
- Serverless Platforms - High-performance serverless event processing.
