apache/openwhisk

Features

• Auto Scaling Groups - Automatically scales the number of active function containers based on real-time traffic and resource demand.
• Serverless Function Management - Provides a complete platform for running stateless code snippets in response to events or API calls with automatic scaling.
• Serverless Platforms - Provides a complete distributed computing platform for deploying and executing stateless functions in response to events.
• CouchDB Connectors - Uses CouchDB connectors to ensure permanent storage of user data and function definitions.
• Distributed State Persistence - Utilizes a distributed document database like CouchDB to persist user configurations, action definitions, and system metadata.
• Database Backend Integration - Supports integration with multiple database backends like CouchDB, Cloudant, and MongoDB to persist system state.
• Runtime Proxy Protocols - Enables the creation of new runtimes using a generic proxy and protocol to avoid implementing full web servers.
• Event-Driven Automation Engines - Connects external event sources and scheduled triggers to functions to automate processes via a rules engine.
• Declarative Event Routing - Provides a declarative configuration layer to map external event sources to specific serverless functions.
• Automated Workflow Orchestration - Chains multiple serverless functions together into complex sequences and workflows using a programming model.
• Event-Based Triggers - Implements a rules engine that initiates automated workflows and functions in response to system-level events.
• Function Sequences - Links multiple functions together into sequential pipelines where the output of one serves as the input for the next.
• Event-Driven Triggers - Maps external events to specific actions using a rules engine to automate execution workflows.
• Event-Driven Workflow Triggers - Links triggers and rules to actions so code executes automatically in response to system or external events.
• Event Triggers - Creates named event channels that activate serverless functions when specific key-value pairs are received.
• Kubernetes Deployments - Deploys the entire platform on Kubernetes clusters to enable containerized function execution and automatic scaling.
• Kubernetes Integrations - Integrates with Kubernetes to manage the container factory and execution environment for functions.
• Serverless Runtime Management - Manages application execution and worker pools across multiple language runtimes using Docker containers.
• HTTP Gateways - Maps external web requests to internal serverless functions through a high-performance API gateway.
• Namespace Organization - Groups related actions and triggers into namespaces to manage permissions and resource isolation across environments.
• Language Runtimes - Supports building and configuring custom execution environments using Docker containers for diverse programming languages.
• Language-Agnostic Runtimes - Uses a standardized protocol to execute code across multiple languages without requiring full web servers.
• Asynchronous Task Execution - Implements an asynchronous execution model for long-running tasks using durable handles and polling.
• Stateless Execution - Executes stateless code snippets and tasks within a distributed, isolated serverless environment.
• Sequence Pipelines - Enables the chaining of multiple serverless functions into sequential pipelines for complex logic orchestration.
• Remote Function Invocation - Supports remote function triggering with an asynchronous pattern that returns an activation ID for later result retrieval.
• Asynchronous Service Invocations - Implements an asynchronous invocation model that returns an activation ID for later result retrieval.
• Container-Based Isolation - Isolates function executions within Docker containers to ensure consistent environments and strict resource limits.
• API Gateways - Implements a stateless request-routing architecture that maps external endpoints to internal function invocations.
• External Event Integration - Connects external data sources to triggers using webhooks and polling to automate function execution based on remote events.
• RESTful API Development - Exposes functions as REST endpoints through an API gateway for external consumption as web services.
• HTTP Routing - Directs incoming HTTP traffic to specific functions based on request paths and methods via a gateway.
• Activation Log Routing - Routes execution logs and activation records to a dedicated search cluster to isolate them from primary storage.
• Object Storage Persistence - Persists data to external object storage systems to maintain state across stateless function executions.
• Action Bundles - Enables grouping related actions into single entities to organize code and share common configuration parameters.
• Local Development Servers - Launches a simplified server environment with an in-memory store for local development and testing.
• Webhook Triggers - Triggers serverless function execution in response to HTTP requests sent from external version control platforms.
• Deployment Automation - Uses automated playbooks to install and configure the system stack across various environments.
• Runtime Manifests - Uses runtime manifests to specify Docker images and language versions for executing custom functions.
• Execution Rate Limiters - Applies rate limits to the number of triggers per minute to control the volume of concurrent function executions.
• External Event Feeds - Connects external event sources to triggers to fire events based on schedules or remote changes.
• Namespace Isolation - Groups actions and triggers into logical namespaces to manage ownership and access permissions.
• Kubernetes-Native Deployments - Implements serverless deployment strategies specifically optimized for Kubernetes container orchestration environments.
• Throughput Controllers - Controls the volume of concurrent activations and requests per minute to prevent system overload.
• Cold Start Optimizations - Converts source files into compiled binaries offline before deployment to reduce function startup latency.
• Function Argument Passing - Passes JSON-formatted data as parameters during function invocation to customize behavior and output.
• Default Parameter Assignments - Allows the assignment of persistent input values to functions that remain constant unless overridden during invocation.
• Periodic Event Triggering - Enables the automatic execution of functions at regular, fixed time intervals.
• Runtime Artifact Preparation - Processes source files or binaries into a standardized work folder using custom compilation scripts.
• Identity and Access Management - Manages user registration and authentication keys via configuration files to control platform access permissions.
• External Service Integrations - Bundles feeds and actions into reusable packages to integrate third-party APIs and external event sources.
• User-to-Namespace Mapping - Isolates entities and controls permissions by associating users with specific namespaces.
• CLI System Management - Provides a command-line interface and REST endpoints for administrative control of platform settings and deployments.
• Function Monitoring - Aggregates metrics and logs from serverless functions to track real-time output and performance.
• Execution Resource Constraints - Enforces strict runtime limits on memory, execution time, and log size for every function instance.
• Concurrency Limiters - Defines maximum thresholds for concurrent invocations and sequence lengths to maintain system stability.
• Cloud Platforms - Serverless platform for event-driven function execution.
• Serverless Platforms - Open-source cloud platform for event-driven function execution.

Star history