OpenEBS is a CNCF sandbox project providing container-native persistent storage for Kubernetes. This repository is the project's coordination hub: it contains the umbrella Helm chart for deploying OpenEBS (LocalPV hostpath/LVM/ZFS and Mayastor replicated engines), the kubectl-openebs plugin binary for inspecting and managing volumes and nodes, and the openebs-upgrade job for Helm-based upgrades and Mayastor data-plane rolling restarts. It also houses the OpenEBS Enhancement Proposals (OEPs), CI/CD workflows, and release automation. The repo is primarily an application repository rather than a data/research repository; its many markdown design documents are engineering proposals, not analysis artifacts. The main entry points are plugin/src/main.rs, openebs-upgrade/src/bin/upgrade-job/main.rs, and charts/Chart.yaml. The upgrade path uses trait-based Helm upgraders and Kubernetes pre-upgrade hooks, while the plugin dispatches engine-specific operations through a common Operations enum. Externally, it depends on the Kubernetes API, Helm, and several engine submodules/repositories (Mayastor, localpv-lvm, localpv-zfs). Maintenance is active: the last commit is recent, Dependabot is configured, and the CI pipeline includes linting, image building, Trivy scanning, and release workflows. Technical drift is low overall, though the project's reliance on git submodules and Nix-pinned dependencies creates coordination risk across the broader OpenEBS ecosystem.
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.
The Hyperledger Bevel Fabric Operator is a Kubernetes operator for managing the full lifecycle of Hyperledger Fabric networks. It provides custom resource definitions (CRDs) and controllers for Certificate Authorities (CAs), peers, ordering service nodes, chaincode (install, approve, commit), channels (main and follower), identities, network configurations, and an operator UI/API. The system also includes a kubectl plugin for CLI-based management. It supports multiple ingress controllers (Istio, Traefik, Gateway API), credential stores (Kubernetes Secrets, HashiCorp Vault), and database backends for the built-in Fabric CA. The operator vendors and patches upstream Hyperledger Fabric and Fabric CA libraries for cryptographic operations, MSP configuration, policy building, and channel configuration. The codebase is well-structured with generated client code, consistent controller patterns (finalizers, status conditions), and comprehensive integration tests. It is actively maintained under the Hyperledger Bevel project, with a large community and regular releases.
kubectl-foreach is a Go-based CLI tool designed to run kubectl commands against multiple Kubernetes contexts in parallel. It retrieves context lists from kubeconfig, applies user-defined filters (exact match, regex, exclusion) to select target contexts, executes the provided kubectl command concurrently for each context, and prefixes output lines with context names for clarity. The architecture is monolithic with clear separation of concerns: argument parsing, filtering, context matching, and parallel execution are isolated into distinct modules. Key dependencies include kubectl (for context retrieval and command execution) and third-party libraries for colored output (gchalk), testing (testify), and concurrency management (golang.org/x/sync).
RBAC Lookup is a CLI tool for Kubernetes that enables users to find all RoleBindings and ClusterRoleBindings associated with a specific user, service account, or group. The tool connects to a Kubernetes cluster via kubeconfig, queries the RBAC API, and presents the results in a tabular format. It includes optional GKE integration to show Google Cloud IAM roles alongside native Kubernetes RBAC roles. The architecture follows a standard Cobra-based CLI pattern with command definitions in cmd/, core lookup logic in lookup/, and data structures defined in lookup/rbac_subject.go. The tool requires access to a Kubernetes cluster and optionally Google Cloud credentials for GKE features.
kubectl-df-pv is a kubectl plugin that displays disk usage (like the Unix `df` command) for Kubernetes Persistent Volumes. It retrieves storage metrics from each node's kubelet stats/summary endpoint and presents them in a color-coded, human-readable table. The tool handles concurrent node queries using goroutines and channels, supports filtering by namespace, and allows users to select which columns to display (including inode information). It auto-converts byte sizes to IEC binary prefixes (Ki, Mi, Gi, Ti) and colorizes usage percentages (red > 75%, yellow < 25%, green otherwise). The codebase is a single Go binary using Cobra for CLI parsing, client-go for Kubernetes API interaction, and go-pretty for table rendering. It is a well-structured, focused utility that solves a specific operational need for Kubernetes administrators. While the core logic is solid, the project is relatively simple and does not exhibit exceptional architectural depth or highly reusable components beyond basic byte formatting.