Fission is a Kubernetes-native serverless framework (FaaS) that deploys and manages functions triggered by HTTP requests, message queues (Kafka, NATS, etc.), cron schedules, and Kubernetes events. The system is composed of multiple microservices: a router that proxies HTTP requests to function pods, an executor that manages warm-pool and per-function deployment backends, a builder that compiles function packages, a fetcher sidecar that materializes code into pods, and a storage service for archive management. All resources (Function, Environment, HTTPTrigger, Workflow, etc.) are defined as Kubernetes Custom Resource Definitions (CRDs) and reconciled by controller-runtime controllers. The architecture supports multi-tenant namespaces, canary deployments via FunctionAlias and CanaryConfig CRDs, a workflow engine with event sourcing, and a pluggable state store (memory, SQLite, Postgres) for durable queues and key-value storage. Internal service-to-service communication is authenticated via HMAC signing. Observability is built on OpenTelemetry (traces, metrics, logs) and Prometheus. The CLI tool (`fission`) provides full lifecycle management and a GitOps-friendly spec system. The codebase is RFC-driven with formal verification (TLA+ specs) for critical subsystems like the workflow event log and queue lease protocol.
OpenFaaS is a serverless platform that provides an API gateway for deploying, managing, and invoking functions. The gateway handles HTTP routing to functions, collects and exposes Prometheus metrics, implements autoscaling based on invocation rates, includes a built-in AngularJS UI for function management, and supports alerting via integrations like Slack. It uses a plugin architecture for function providers (e.g., Kubernetes, Docker Swarm) via the faas-provider interface, allowing the core to remain decoupled from the underlying runtime. The system processes synchronous function invocations through a reverse proxy and asynchronous invocations via NATS queues.
The AWS Serverless Application Model (SAM) Transformer is a Python library that converts SAM templates into AWS CloudFormation templates. It serves as the core transformation engine for the AWS SAM CLI, enabling developers to define serverless applications using SAM syntax that gets expanded to standard CloudFormation resources. The system follows a modular architecture with distinct layers for parsing, validation, transformation, and resource generation, featuring an extensible plugin system for adding custom transformation logic. Key capabilities include intrinsic function resolution (!Ref, !GetAtt, !Sub), globals and conditions processing, policy template expansion, and resource-specific transformations for AWS services like Lambda, API Gateway, Step Functions, and more.
The Serverless Framework is a mature, open-source CLI tool for deploying and managing serverless applications on AWS. It compiles declarative YAML/JSON configuration (serverless.yml) into CloudFormation templates, orchestrates deployments via S3 artifact uploads and stack operations, and supports a wide range of AWS event sources (API Gateway, SQS, SNS, DynamoDB Streams, etc.). The repository is a monorepo with multiple packages: `sf-core` (new unified runner), `serverless` (legacy framework with AWS plugins), `engine` (AWS SDK client abstractions), `mcp` (Model Context Protocol server for AI agent integration), and `util` (shared logging, error handling, proxy support). Key entry points include `packages/sf-core/bin/sf-core.js` and `packages/serverless/lib/plugins/index.js`. The architecture is plugin-based, with lifecycle hooks for packaging, compiling events, and deploying. External dependencies include AWS SDK v2/v3, esbuild, and various npm packages. The codebase demonstrates high craftsmanship in areas like deterministic naming, proxy wrapping, and variable resolution, though some technical drift exists (dual SDK versions, deprecated providers).
Artillery is a cloud-scale load testing and functional testing framework for backend services and APIs. It supports multiple protocols (HTTP, WebSocket, Socket.IO, Playwright, PostHog) through a plugin-based engine architecture. The system is primarily a CLI tool (built on oclif) that executes YAML/JSON test scripts defining virtual user flows with configurable arrival phases, payloads, and assertions. It provides distributed execution across local worker threads, AWS Lambda, AWS ECS/Fargate, and Azure ACI, with a bill-of-materials (BOM) system that bundles test dependencies for cloud workers. Metrics are aggregated via a custom Simple Statistics Measurement System (SSMS) supporting counters, histograms (DDSketch), and rates, and can be published to Datadog, CloudWatch, Prometheus, OpenTelemetry, Splunk, New Relic, and other observability platforms. The codebase is a monorepo managed with Turborepo, containing the core runner, platform integrations, first-party plugins (expect, ensure, apdex, slack, fake-data, metrics-by-endpoint, publish-metrics, memory-inspector), and shared type definitions. Key entry points include the `artillery` binary (`packages/artillery/bin/run`), the core runner (`packages/artillery/lib/core/runner.ts`), and platform launchers (`packages/artillery/lib/launch-platform.ts`). External dependencies include AWS SDK, Azure SDK, Playwright, got (HTTP client), and various metric publishing SDKs. The architecture is event-driven, using EventEmitter for lifecycle events and plugin hooks, with a global `global.artillery` object for shared state.
This repository is the official AWS Toolkit extension for Visual Studio Code, providing deep integration with Amazon Web Services directly within the IDE. It enables developers to browse and manage AWS resources (S3, Lambda, CloudFormation, EC2, ECS, IoT, and dozens more), invoke Lambda functions, deploy serverless applications using AWS SAM, debug Lambda functions locally, and access Amazon Q (formerly CodeWhisperer) for AI-powered code suggestions, chat, security scanning, and code transformation. The codebase is a large monorepo organized into packages including the core extension logic, generated streaming API clients, a custom ESLint plugin, and webview-based UIs built with Vue.js. The architecture follows a modular activation pattern with centralized command registration, tree view providers for resource exploration, a wizard/prompter framework for multi-step user flows, and a telemetry system for operational metrics. It supports both Node.js and web (browser) extension targets. Despite its size, the codebase maintains consistent patterns, extensive test coverage, and clear separation of concerns, making it a well-crafted enterprise-grade IDE extension.
This repository is a collection of AWS EC2 Spot Instance best practices and workshop examples. It contains diverse implementations showing how to use Spot Instances across various AWS services including EC2 Auto Scaling, EC2 Fleet, ECS, EKS, Lambda, SageMaker, AWS Batch, and EMR. The examples demonstrate patterns for handling Spot Instance interruptions, cost optimization, fault tolerance, and workload-specific optimizations. While not a single cohesive application, it serves as a practical reference for deploying cost-effective, interruption-resilient workloads on AWS Spot Instances.