Apollo Router is a production-grade GraphQL gateway written in Rust. It accepts incoming GraphQL HTTP requests, composes a supergraph schema from subgraph schemas, plans queries across subgraphs, and executes them through a tower-style service pipeline. It supports federation, subscriptions, persisted queries, demand control, entity caching, progressive overrides, connectors, and defer. Configuration is YAML-based and can be managed via Apollo GraphOS Uplink for schema/config propagation.
Emissary-ingress (formerly Ambassador) is a Kubernetes-native API gateway and ingress controller built on Envoy Proxy. It sits at the edge of a Kubernetes cluster, managing ingress traffic with self-service configuration via Custom Resource Definitions (CRDs) like Mapping, Host, Module, AuthService, RateLimitService, and TLSContext. The system is architected as a dual-language control plane: a Go-based main entrypoint (`cmd/entrypoint/`) handles Kubernetes resource watching, snapshot assembly, secret reconciliation, and Envoy lifecycle management, while a Python-based configuration engine (`python/ambassador/`) compiles the desired state into an Intermediate Representation (IR) and generates Envoy xDS configuration (v3). A separate Go API extension server (`cmd/apiext/`) provides conversion webhooks and certificate management for CRD versions (v1, v2, v3alpha1). The compiled Envoy configuration is served via gRPC and pushed to Envoy through the ambex package using go-control-plane. Key data flows: Kubernetes resources (CRDs, Ingresses, Services) are watched by Go watchers and accumulated into snapshots via the `pkg/kates/accumulator`. Snapshots are passed to the Python diagd process, which builds an IR (Intermediate Representation) and generates Envoy v3 configuration for listeners, clusters, routes, filters (auth, rate limiting, gzip, CORS, tracing), and TLS settings. The resulting config is written as JSON files, read by the ambex ADS server, and pushed to Envoy. The system supports dynamic updates without restart, canary deployments, circuit breaking, health checks, Istio and Consul integration, and extensive observability (Prometheus, StatsD, Datadog). The codebase demonstrates strong engineering practices with a comprehensive test suite including Go unit tests, Python unit tests, Kubernetes integration tests (KAT framework), and e2e tests using chainsaw and k3d. It has a mature build system with multi-architecture Docker images, Helm charts, and automated release pipelines. While the dual-language architecture introduces some complexity and duplication (e.g., service name normalization in both Python and Go), the project is actively maintained with regular releases and a large community (4.5k stars, 700+ forks).
Apache Dubbo for Kubernetes is a service mesh control plane that extends Apache Dubbo's capabilities to Kubernetes-native environments. It provides an xDS-based control plane (dubbod) for dynamic configuration of gRPC proxies, sidecar injection via a mutating webhook and CNI plugin, mTLS with a built-in certificate authority, and integration with the Kubernetes Gateway API for traffic management. The system also includes a KEDA-based activation mechanism for scale-to-zero workloads, multi-cluster support, and an operator for lifecycle management. The codebase is heavily inspired by Istio, with many packages adapted from that project, and includes a reactive collections framework (krt) for building incremental state from Kubernetes resources. It is in an active development phase with some incomplete features and generated code dependencies.