DOCSEARCHbyAlgolia
Submit Docs

Celerity Framework

website·Indexed 30 days ago

https://celerityframework.io

A framework for building and shipping applications with a focus on backend architectures, including support for HTTP APIs, scalable WebSockets, and workflow runtimes. It provides a CLI for development and deployment, along with SDKs for Go, Python, and Node.js to interact with NoSQL datastores, SQL databases, and caches. The framework includes resource specifications for VPCs, buckets, and consumer events, and supports authentication via JWTs, API keys, and Bluelink Signature v1.

Tokens
94.2K
Snippets
313
Records
623
Agent score
49%

What's inside Celerity

  1. Overview of Celerity SQL Schema Management

    Celerity uses a declarative approach to SQL database schema management. Developers define the desired state of the database in YAML files. When these files are modified, the celerity schema diff command generates a versioned SQL migration file. This file is reviewed and committed to version control, ensuring that all database changes are ordered and transparent. The underlying diffing and migration execution are powered by the Atlas migration engine.

  2. Overview of the Celerity Framework

    Celerity provides portable building blocks for creating backends, including APIs, WebSockets, workflows, and queues. It is designed to allow developers to build at 'serverless speed' while maintaining the flexibility to run the application anywhere (serverless or containerized) to avoid provider lock-in. The framework includes built-in support for authentication, CORS, observability, telemetry, and resilient WebSocket connections with a dedicated client SDK.

  3. Overview of Celerity Channel resource

    The celerity/channel resource defines a real-time channel for pub/sub messaging, presence tracking, and targeted broadcasting over a WebSocket API. It is an opt-in layer; if no celerity/channel resources are linked to a celerity/api (with protocol: websocket), the channel protocol routes are not registered and there is zero runtime overhead.

    Key capabilities include:

    • Real-time pub/sub: Deliver messages to all subscribers without manual connection tracking.
    • Presence tracking: Broadcast join/leave events for channel members.
    • Per-channel auth: Define specific auth guards or subscribe handlers for fine-grained access control.
    • Rate limiting: Protect against message amplification via per-channel limits.
    • Secure by default: Only declared channels accept subscriptions.
    • Reconnection recovery: Automatic restoration of client subscriptions after reconnection.

  5. Overview of Celerity NoSQL Schema Management

    Celerity provides a declarative schema definition for NoSQL databases (such as DynamoDB, Cosmos DB, and Firestore) to solve the lack of database-level introspection. Instead of DDL migrations, Celerity focuses on visibility, conformance, and contracts. It uses a Schema Manager to compute differences between the current state (from the previous deployment) and the desired state defined in YAML files. This process does not execute operations against the database; it is used for validation, type generation, and drift detection.

  6. Overview of Celerity Datastore SDK Portability

    The Celerity SDK provides a language-agnostic contract for reading and writing data across various NoSQL stores. This ensures that handler code behaves identically regardless of the target store. Portability is categorized into two tiers:

    • Tier A: Operations that require only one request on every supported store.
    • Tier B: Operations that are correct on every store but may require extra reads or a narrower data shape on some stores.

    Supported and planned target stores include:

    • Amazon DynamoDB (Available in v0)
    • Google Cloud Firestore (Planned for v1)
    • Azure Cosmos DB (Planned for v1)
    • PostgreSQL JSONB-backed (Planned for v1+)
    • ScyllaDB Alternator (Planned for v1+)

  7. Overview of the Celerity Framework

    Celerity is a framework for building portable backend applications using a set of simple building blocks (primitives). It provides a unified approach to building, testing, and deploying systems that can run across multiple cloud providers or on-premise environments. It offers a serverless-like development experience but allows applications to be deployed as either serverless or traditional containerized applications.

  8. Overview of the Celerity Go SDK Datastore package

    The datastore package in the Celerity Go SDK provides a cloud-agnostic interface for interacting with NoSQL data stores, specifically supporting Amazon DynamoDB, Google Cloud Firestore, and Azure Cosmos DB.

  9. Overview of the Celerity Runtime

    The Celerity runtime allows applications to run in containerized environments (such as Kubernetes, Docker, Amazon ECS, Google Kubernetes Engine, and Azure Kubernetes Service) without requiring changes to the application source code. It supports various application types, including HTTP APIs, WebSocket APIs, workflows, scheduled handlers, cloud event handlers, and message queue/broker/stream pollers.

  10. Overview of Celerity Scalable WebSocket Architecture

    The Celerity runtime allows WebSocket APIs to be deployed as a horizontally scalable cluster. Because clients can connect to any server in the cluster, the runtime uses a shared message broker (Redis OSS pub/sub) to route messages to the specific node holding a client's connection. Redis is also used to store mappings of connection IDs to node groups to ensure efficient message publishing.

  11. Overview of the Celerity Go SDK

    The Celerity Go SDK provides a cloud-agnostic interface for building Celerity applications in Go. Go projects operate on an OS-only runtime, where the runtime launches the compiled handlers executable and dispatches events to it, rather than hosting the language runtime itself.

  12. Overview of Celerity authentication mechanisms

    Celerity tools and applications with public HTTP APIs (such as the Workflow Runtime) support several authentication mechanisms to secure requests. These include standard industry methods and a specialized signature process to avoid transmitting private keys over the network.

    Supported mechanisms include:

    • API Keys: Standard key-based authentication.
    • JWTs: JSON Web Tokens issued by OAuth2 or OIDC (OpenID Connect) providers.
    • Celerity Signature (Bluelink Signature v1): A custom mechanism that uses a private API key in combination with a public key, timestamp, and specific request headers to create a signature, ensuring private keys are not transported over the wire.