Cassandra Medusa is a production-grade backup and restore tool for Apache Cassandra and DSE, designed to operate at cluster scale. It supports full and differential backups, with storage backends for local filesystems, S3-compatible object stores, Google Cloud Storage, Azure Blob Storage, and IBM Cloud. The tool operates in two modes: a CLI that orchestrates backups across nodes via parallel SSH (pssh), and a gRPC service for Kubernetes sidecar deployments. Backups are stored as indexed blobs (token maps, manifests, schemas) in the chosen storage, with configurable retention and purge policies. It also provides integrity verification (MD5 checksums), monitoring integration (DogStatsD), and snapshot management via nodetool, Jolokia, or the DSE Management API. The architecture is modular: storage backends inherit from an abstract async base class, snapshot creation is abstracted via a service factory, and monitoring is pluggable. Configuration is loaded from INI files, environment variables, and Kubernetes secrets. The codebase uses asyncio for concurrent uploads/downloads with configurable concurrency, tenacity for retry logic, and protocol buffers for the gRPC interface. While primarily an operational tool, its design patterns (abstract storage, factory-based snapshot services, monitoring abstractions) are cleanly separated and could serve as a reference for similar infrastructure tools. Medusa is actively maintained with frequent releases, a comprehensive test suite (unit + integration behave tests), and support for Python 3.10–3.12. The codebase demonstrates solid engineering practices: strong typing (namedtuples), separation of concerns, and minimal framework boilerplate. The integration tests cover multiple storage providers, encryption modes, and cluster topologies, providing high confidence in production readiness.
PGO (Crunchy Data Postgres Operator) is a production-grade Kubernetes operator that manages the full lifecycle of PostgreSQL clusters, including deployment, high availability via Patroni, backup/restore via pgBackRest, connection pooling via PgBouncer, monitoring via OpenTelemetry and pgMonitor, and a web UI via pgAdmin. The operator uses custom resource definitions (CRDs) for PostgresCluster, PGAdmin, and PGUpgrade, and reconciles desired state using controller-runtime with server-side apply. It manages StatefulSets, PVCs, Services, ConfigMaps, Secrets, Jobs, and RBAC across multiple namespaces. Architecturally, the operator is a single binary with multiple controllers (postgrescluster, standalone_pgadmin, pgupgrade) and sidecar containers for pgBackRest, PgBouncer, pgAdmin, and the OpenTelemetry collector. It uses feature gates to enable optional capabilities like volume snapshots, auto-grow volumes, and OpenTelemetry logging/metrics. The codebase is well-structured with distinct packages for naming conventions, PKI certificate management, PostgreSQL parameter management, and shell command construction. Extensive unit and e2e tests (using kuttl and chainsaw) cover most scenarios, including backup/restore, scaling, upgrades, and security contexts. Key external dependencies include controller-runtime, client-go, Patroni, pgBackRest, PgBouncer, pgAdmin, OpenTelemetry SDK, and pg_query_go for SQL parsing. The operator is deployed via Kustomize and supports multiple PostgreSQL versions (11-18) with PostGIS extensions.
CloudNativePG is a Kubernetes operator for managing PostgreSQL databases in production. It automates deployment, failover, scaling, backups, upgrades, and connection pooling (PgBouncer) through custom Kubernetes resources (CRDs) and reconciliation loops. The operator consists of two binaries: a manager that runs inside pods to manage PostgreSQL instances, and a kubectl plugin for administrative commands. The architecture is modular with separate reconcilers for clusters, instances, backups, roles, tablespaces, and replication slots. It includes a plugin system (CNPG-I) for extensibility via gRPC, a web server for health probes and metrics, and a Prometheus exporter for monitoring. The codebase is written in a non-standard Go dialect (using URL-like import paths, func keyword, and var type declarations), which may indicate a custom transpiler or DSL. Despite this, the project is production-grade with extensive unit and end-to-end tests, active maintenance, and support for multiple Kubernetes distributions (kind, k3d, OpenShift).
VolSync is a Kubernetes operator for asynchronous replication of persistent volume data between clusters or to object storage. It implements a pluggable data mover architecture with backends for rsync, rclone, restic, syncthing, and rsync-tls. The operator watches ReplicationSource and ReplicationDestination custom resources, orchestrates mover jobs (typically as Kubernetes Jobs or StatefulSets), and manages the lifecycle of replication: trigger scheduling, synchronization, cleanup, and optional snapshot handling. A kubectl plugin provides CLI commands for managing replication relationships and migrations. The codebase is built with controller-runtime, includes a Helm chart, Prometheus metrics, and extensive test coverage (unit, integration, e2e). Major dependencies include vendored copies of restic and minio-go for the restic-based mover, which introduce maintenance risk but enable FIPS-compliant encrypted backups to S3-compatible storage.