awesome-devops Documentation

File: README.md

Awesome DevOps

A curated list of platforms, tools, practices and resources to create, improve DevOps culture and SRE Team in the organization.

DevOps is the combination of cultural philosophies, practices, and tools that increases an organization’s ability to deliver applications and services at high velocity: evolving and improving products at a faster pace than organizations using traditional software development and infrastructure management processes. This speed enables organizations to better serve their customers and compete more effectively in the market.

Browse, search and filter the list at awesome-devops.xyz.

Each entry ends with tags: oss open source, free free plan or free to use, paid paid plans or support, self-hosted can run on your own infrastructure without being open source.

Cloud Platforms
Open Source Cloud Platforms
Operating Systems
Package Management & System Configuration
Distributed Filesystems
Applications Platforms
Internal Developer Platforms
Container Image Registry
Automation & Orchestration
Productivity Tools
Terminal
Continuous Integration & Delivery
Source Code Management
Web Servers
SSL
Databases
Observability and Monitoring
Service Discovery & Service Mesh
Chaos Engineering
API Gateway
Code review
Distributed messaging
Programming Languages
Chat and ChatOps
Secret Management
Security
Sharing
VPN
Resources
- Books
- Conferences
- Blogs
- DevOps Roadmap

Cloud Platforms

Public and Private Cloud Platforms.

Amazon Web Services (AWS) - Cloud Computing Services. free paid
Google Cloud Platform (GCP) - Cloud Computing Services. free paid
Azure - Cloud Computing Platform & Services. free paid
Alibaba Cloud - Integrated suite of cloud products and services. free paid
Oracle Cloud - Comprehensive and fully integrated stack of cloud applications and platform services. free paid
DigitalOcean - Helping developers easily build, test, manage, and scale applications of any size. paid
Scaleway - Single way to create, deploy and scale your infrastructure in the cloud. paid
Vultr - Easily deploy cloud servers, bare metal, and storage worldwide. paid
IBM Cloud - Tools, data & APIs to make AI real now. free paid
Interserver - Cloud VPS, Linux VPS, Windows VPS, dedicated servers and web hosting services. paid
Linode - Accelerate innovation in the cloud, virtual computing must be more accessible, affordable, and simple. paid
Kinsta - Create and deploy web applications and databases in minutes. free paid
Equinix - Global data center and colocation provider for enterprise network and cloud computing. paid
Clever Cloud - European Platform as a Service (PaaS) with managed databases and object storage. paid

Open Source Cloud Platforms

Private, Public and Hybrid open-source Cloud Platforms.

Openstack - Open source software for creating private and public clouds. oss
Apache CloudStack - Designed to deploy and manage large networks of virtual machines. oss
OpenNebula - Build Private Clouds and manage Data Center virtualization based on KVM, LXD and VMware. oss paid
Eucalyptus - Building AWS-compatible private and hybrid clouds. oss
DC/OS - Distributed operating system based on the Apache Mesos distributed systems kernel. oss
Apache Mesos - Program against your data center like it’s a single pool of resources. oss
Fakecloud - Local AWS cloud emulator for development and testing. oss
Localstack - Fully functional local AWS cloud stack. Develop and test your cloud & Serverless apps offline. oss paid
Spinifex - AWS-compatible infrastructure platform (EC2, VPC, S3, EKS, ECS, RDS and more) for bare-metal, edge and on-premises deployments. oss

Operating Systems

Operating Systems - Server Platform.

Ubuntu - Enterprise Open Source and Linux. oss paid
Rocky Linux - Open-source enterprise operating system designed to be 100% bug-for-bug compatible with Red Hat Enterprise Linux. oss
CoreOS - The pioneering lightweight container host. oss
OSv - Versatile modular unikernel designed to run unmodified Linux applications securely on micro-VMs in the cloud. oss
Atomic - Use immutable infrastructure to deploy and scale your containerized applications. oss
Talos Linux - Minimal, immutable Linux distribution for running Kubernetes, managed through an API. oss paid
Photon - Linux container host optimized for cloud-native applications, cloud platforms, and VMware infrastructure. oss

Package Management & System Configuration

Builds packages in isolation from each other.

Nix/NixOS - A tool that takes a unique approach to package management and system configuration. oss

Distributed Filesystems

Network distributed filesystems.

Ceph - Highly scalable object, block and file-based storage under one whole system. oss
Gluster - Free and open source software scalable network filesystem. oss
LINBIT - Create, remove, and replicate block storage devices for datacenter scale environments. oss paid
XtreemFS - Fault-tolerant distributed file system for all storage needs. oss
min.io - High-performance, distributed object storage system. oss paid
SeaweedFS - Distributed storage with S3-compatible object storage, POSIX file system access and Kubernetes CSI support. oss paid

Applications Platforms

Applications management platforms, Containers platform and Containers management.

Openshift - The Kubernetes platform for big ideas. paid self-hosted
Cycle.io - DevOps platform for building platforms. Handle container orchestration, load-balancing, monitoring, and more from a single control plane. paid
Dokku - Helps you build and manage the lifecycle of applications. oss paid
Cloud 66 - DevOps as a service that helps to build, deploy and manage any application on any cloud or server. paid
Docker - Create, deploy, and run applications by using containers. oss paid
Docker Compose - Define and run multi-container applications with Docker. oss
Docker Swarm - Docker-native clustering system. oss
Kubernetes - Automating deployment, scaling, and management of containerized applications. oss
LXC - Lets Linux users easily create and manage system or application containers. oss
Rancher - Lets you deliver Kubernetes-as-a-Service. oss paid
Singularity - Run the application from the local environment to the cloud. oss paid
AppScale - Easy-to-manage serverless platform for building and running scalable web and mobile applications. oss
Kata Containers - Building lightweight virtual machines that seamlessly plug into the containers ecosystem. oss
K3S - The certified Kubernetes distribution built for IoT and Edge computing. oss
Podman - A tool for managing OCI containers and pods. oss
Piku - The tiniest PaaS you've ever seen. Piku allows you to do git push deployments to your own servers. oss
OrbStack - fast, light, and easy way to run Docker containers and Linux on MacOS. free paid
Mocker - Docker-compatible container CLI for macOS, built on Apple's Containerization framework. oss
Canine - Deploy applications to Kubernetes as easily as deploying to Heroku. oss paid
AZIN - BYOC deployment platform. Deploy to your own GCP account with git-push, no Kubernetes config needed. GKE Autopilot under the hood. paid
vCluster - A open source project that helps you create virtual clusters. oss paid
devpod - Open-source, codebases-like tool that creates reproducible developer environments, supporting numerous providers (Kubernetes, AWS, GCP, etc.). oss
KubeStellar Console - Open source AI-powered multi-cluster Kubernetes dashboard with real-time observability, AI-guided operations, and 20+ CNCF integrations (Argo, Kyverno, Prometheus, Grafana, Istio, Flux, Falco, OPA/Gatekeeper). CNCF Sandbox project. oss
Kind - Run local Kubernetes clusters using Docker container nodes. oss
Kunobi - Desktop app for managing Kubernetes clusters, FluxCD, ArgoCD and Helm, with a built-in MCP server for AI assistants. free paid
JET Pilot - Desktop client for Kubernetes that brings the clusters from kubeconfig files and cloud accounts into one place, with multi-cluster views, logs and a built-in kubectl terminal. oss
Radar - Kubernetes UI with live topology, event timeline, service traffic and Helm release history. oss

Internal Developer Platforms

Tools, services and processes that support and accelerate software development.

Port - A platform for building no-code, holistic, Internal Developer Portals. free paid self-hosted
Backstage - An open platform for building developer portals. oss
Kratix - A framework used by platform teams to build the custom platforms tailored to their organisation. oss paid
Qovery - Enterprise Kubernetes management platform for deploying applications on AWS, GCP, Azure, and Scaleway. Includes Terraform provider, CLI, API, and an AI Agent Skill for deploying from AI coding tools like Claude Code, Cursor, and OpenCode. free paid
OpenChoreo - A complete, modular, open-source developer platform. oss
AgentsMesh - Self-hosted platform that gives AI coding agents isolated remote workspaces, with team management, SSO, RBAC and audit logs. paid self-hosted

Container Image Registry

Container Image registry.

Quay - Container image registry that enables you to build, organize, distribute, and deploy containers. oss paid
Dockyard - Container & Artifact Repository. oss
Harbor - An open source trusted cloud native registry project that stores, signs, and scans content. oss
GitHub Container Registry - Container registry free for public images. free paid
Zot - Lightweight, OCI-native container image registry. oss

Automation & Orchestration

Tools for automation, orchestration, deployment, provisioning and configuration management.

Ansible - Simple IT automation platform that makes your applications and systems easier to deploy. oss paid
Salt - Automate the management and configuration of any infrastructure or application at scale. oss
Puppet - Unparalleled infrastructure automation and delivery. oss paid
Chef - Automate infrastructure and applications. oss paid
Juju - Simplifies how you configure, scale and operate today's complex software. oss paid
Rundeck - Runbook Automation For Modernizing Your Operations. oss paid
StackStorm - Connects all your apps, services, and workflows. Automate DevOps your way. oss
Bosh - Release engineering, deployment, and lifecycle management of complex distributed systems. oss
Cloudify - Connect, Control, & Automate from core to edge: unlimited locations, clouds and devices. oss paid
Tsuru - An extensible and open source Platform as a Service software. oss
Fabric - High-level Python library designed to execute shell commands remotely over SSH. oss
Capistrano - A remote server automation and deployment tool. oss
Mina - Really fast deployer and server automation tool. oss
Terraform - use Infrastructure as Code to provision and manage any cloud, infrastructure, or service. free paid self-hosted
OpenTofu - Open source, community-driven fork of Terraform. oss
Pulumi - Modern infrastructure as code platform that allows you to use familiar programming languages and tools to build, deploy, and manage cloud infrastructure. oss paid
Packer - Build Automated Machine Images. free paid self-hosted
Vagrant - Development Environments Made Easy. free self-hosted
Foreman - Complete lifecycle management tool for physical and virtual servers. oss
Nomad - Deploy and Manage Any Containerized, Legacy, or Batch Application. free paid self-hosted
OctoDNS - Managing DNS across multiple providers. DNS as code. oss
ManageIQ - Manage containers, virtual machines, networks, and storage from a single platform. oss
Ignite - Open Source Virtual Machine (VM) manager with a container UX and built-in GitOps management. oss
Selefra - An open-source policy-as-code software that provides analytics for multi-cloud and SaaS. oss
Spacelift - Flexible orchestration solution for IaC development. free paid
Atlantis - Terraform Pull Request Automation. oss
KubeVela - Modern application delivery platform that makes deploying and operating applications across today's hybrid, multi-cloud environments easier, faster and more reliable. oss
Stacktape - Developer-friendly Infrastructure as a Code framework built on top of AWS. free paid
Score - Open Source developer-centric and platform-agnostic workload specification. oss
Stategraph - Terraform and OpenTofu without the state file bottleneck. paid
Meshery - An open-source, cloud native manager that enables the design and management of all Kubernetes-based infrastructure and applications. oss paid
Digger - Open Source Infrastructure as Code management tool that runs within your CI/CD system. oss paid
Deployment.io - DevOps co-pilot for developers to automate deployments to AWS. free paid
RapidForge.io - Create end points, forms and tasks using scripts. Automate your workflows. oss
Terrateam - Open-source alternative to Terraform Cloud/Enterprise, GitOps-first with native GitHub integration and designed for scale, security, and reliability. oss paid
Scalr - Drop-in Terraform Cloud alternative, usage-based pricing, unlimited concurrency. free paid
CloudRay - Centralised platform for managing servers, organizing Bash scripts, and automating infrastructure tasks across cloud and virtual machines. free paid
Helm - The package manager for Kubernetes. oss
Kustomize - Template-free customization of Kubernetes configuration. oss
Crossplane - Build control planes to manage infrastructure with Kubernetes APIs. oss
Servy - Runs any application as a native Windows service, with logging, health checks and restart policies. oss
SuperPlane - Control plane for event-based workflows across Git, CI/CD, observability, incident response and infrastructure tools. oss paid
Farmer - F# DSL that generates and deploys Azure Resource Manager templates for repeatable infrastructure. oss

Productivity Tools

Tools and services which increase productivity, developer velocity and developer experience.

tenv - streamline IaC version manager for OpenTofu, Terraform, Terragrunt and Atmos, written in Go. oss
pyenv - Simple Python version management. oss
tfenv - Terraform version manager. oss
Kanvas - a collaborative tool with visual interface for designing and operating infrastructure. free paid self-hosted
kubefwd - Bulk port forwarding Kubernetes services for local development. oss
mirrord - Run a local process as if it were a pod in a remote Kubernetes cluster. oss paid
YAML Validator - Online YAML validator, formatter and viewer with JSON Schema support for Kubernetes, Docker Compose, GitHub Actions, and more. free
Beekeeper Studio - Cross-platform database manager for PostgreSQL, MySQL, SQLite, SQL Server and other databases. free paid
Dorothy - Desktop app that runs and coordinates several AI coding agents (Claude Code, Codex, Gemini) with a kanban board and automations. oss
Super Productivity - Task manager and time tracker that pulls issues from Jira, GitHub, GitLab and Linear. oss
Laradock - Ready-made Docker environment for PHP development, with web servers, databases and queues. oss

Terminal

Terminals, SSH clients and terminal UIs for working with servers and cloud resources.

purple - SSH client with AWS/GCP/Azure sync, Docker/Podman and SCP transfers. oss
claws - A terminal UI for managing AWS resources across multiple profiles and regions with vim-style navigation. oss
Telert - Get alerts when terminal commands finish via Telegram, Slack, Audio, etc. oss
Chaterm - Open-source AI terminal and SSH client for servers, databases and Kubernetes. oss paid
k9s - Terminal UI to interact with your Kubernetes clusters. oss

Continuous Integration & Delivery

Continuous Integration, Continuous Delivery and Continuous Deployment. GitOps.

On-premises
- Buildbot - automate all aspects of the software development cycle. oss
- Gitlab CI - pipelines build, test, deploy, and monitor your code as part of a single, integrated workflow. oss paid
- Jenkins - automation server for building, deploying and automating any project. oss
- Drone - a Container-Native, Continuous Delivery Platform. oss paid
- Concourse - pipeline-based continuous thing-doer. oss
- Semaphore Community Edition - open-source (Apache-2) CI/CD for building, testing, and deploying any project. oss paid
- Spinnaker - fast, safe, repeatable deployments for every Enterprise. oss
- goCD - Delivery and Release Automation server. oss
- Teamcity - enterprise-level CI and CD. free paid self-hosted
- Bamboo - tie automated builds, tests, and releases together in a single workflow. paid self-hosted
- Integrity - Continuous Integration server. oss
- Hydra - Continuous integration server for Nix-based projects. oss
- Zuul - drives continuous integration, delivery, and deployment systems with a focus on project gating. oss
- Argo - Open Source Kubernetes native workflows, events, CI and CD. oss
- Argo CD - Declarative GitOps continuous delivery for Kubernetes. oss
- Strider - Continuous Deployment/Continuous Integration platform. oss
- Evergreen - A Distributed Continuous Integration System from MongoDB. oss
- werf - Open Source CI/CD tool for building Docker images & deploying them to Kubernetes using a GitOps approach. oss
- Flux - automatically ensures that the state of your Kubernetes cluster matches the configuration you’ve supplied in Git. oss
- Flagger - progressive delivery Kubernetes operator (Canary, A/B Testing and Blue/Green deployments). oss
- Tekton - powerful and flexible open-source framework for creating CI/CD systems. oss
- PipeCD - Continuous Delivery for Declarative Kubernetes, Serverless and Infrastructure Applications. oss
- Ctrlplane - Release governance control plane that sequences promotions across environments, regions and clusters, on top of existing CI/CD and GitOps tools. oss
- Dagger - CI/CD as Code that Runs Anywhere. oss paid
- Unleash - Open-source feature management platform (feature flags, gradual rollouts, A/B testing) to decouple deploy from release. oss paid
- Keploy - creates isolated production sandboxes for API, integration, and E2E testing from real traffic. oss
- Jumpstarter - Hardware-in-the-loop testing framework for real and virtual devices, with CI/CD integration and Kubernetes-native device management. oss
Public Services
- Travis CI - easily sync your projects, you’ll be testing your code in minutes. paid
- Circle CI - powerful CI/CD pipelines that keep code moving. free paid
- Bitrise - CI/CD for mobile applications. free paid
- Buildkite - run fast, secure, and scalable continuous integration pipelines on your own infrastructure. free paid
- Codefresh - GitOps automation platform for Kubernetes apps. free paid
- DeployHQ - Git-based deployment automation to servers via SSH/SFTP/S3. free paid
- Github actions - GitHub Actions makes it easy to automate all your software workflows, now with world-class CI/CD. free paid
- Kraken CI - Modern CI/CD, open-source, on-premise system that is highly scalable and focused on testing. oss
- Earthly - Develop CI/CD pipelines locally and run them anywhere. oss
- RunMyJob - Cloud runners for GitHub Actions and GitLab CI with KVM-isolated VMs and load-based billing. free paid
- Buildstash - Stores build binaries, distributes them to testers and publishes releases to app stores and distribution platforms. free paid

Source Code Management

Source Code management, Git-repository manager, Version Control.

GitHub - Helps developers store and manage their code, as well as track and control changes to their code. free paid
Gitlab - Entire DevOps lifecycle in one application. oss paid
Bitbucket - Gives teams one place to plan projects, collaborate on code, test, and deploy. free paid self-hosted
Phabricator - A collection of web applications which help software companies build better software. oss
Gogs - A painless self-hosted Git service. oss
Gitea - A painless self-hosted Git service. oss paid
Gitblit - Pure Java Git solution for managing, viewing, and serving Git repositories. oss
RhodeCode - Centralized control for distributed repositories. Mercurial, Git, and Subversion under a single roof. oss paid
Radicle - Radicle is a sovereign peer-to-peer network for code collaboration, built on top of Git. oss

Web Servers

Web servers and reverse proxy.

Nginx - High performance load balancer, web server and reverse proxy. oss paid
Apache - Web server and reverse proxy. oss
Caddy - Web server with automatic HTTPS. oss
Cherokee - Highly concurrent secured web applications. oss
Lighttpd - Optimized for speed-critical environments while remaining standards-compliant, secure and flexible. oss
Uwsgi - Application server container. oss

SSL

Tools for automating the management of SSL certificates.

Certbot - Automate using Let’s Encrypt certificates on manually-managed websites to enable HTTPS. oss
Let’s Encrypt - Free, automated, and open Certificate Authority. oss
Cert Manager - K8S add-on to automate the management and issuance of TLS certificates from various issuing sources. oss

Databases

Relational (SQL) and non-relational (NoSQL) databases.

Relational (SQL)
- PostgreSQL - Powerful, open-source object-relational database system. oss
- MySQL - Open-source relational database management system. oss paid
- MariaDB - Fast, scalable and robust, with a rich ecosystem of storage engines, plugins and many other tools. oss paid
- SQLite - Small, fast, self-contained, high-reliability, full-featured, SQL database engine. oss
Non-relational (NoSQL)
- Cassandra - Manage massive amounts of data, fast, without losing sleep. oss
- ScyllaDB - NoSQL data store using the seastar framework, compatible with Apache Cassandra. free paid self-hosted
- Apache HBase - Distributed, versioned, non-relational database. oss
- Couchdb - Database that completely embraces the web. oss
- Elasticsearch - Distributed, RESTful search and analytics engine capable of addressing a growing number of use cases. oss paid
- MongoDB - General purpose, document-based, distributed database built for modern applications. free paid self-hosted
- Rethinkdb - Open-source database for the real-time web. oss
- ClickHouse - Column-oriented database for real-time analytical reports. oss paid
- Key-Value
  - Couchbase - Distributed multi-model NoSQL document-oriented database that is optimized for interactive applications. free paid self-hosted
  - Leveldb - Fast key-value storage library. oss
  - Redis - In-memory data structure store, used as a database, cache and message broker. oss paid
  - RocksDB - A library that provides an embeddable, persistent key-value store for fast storage. oss
  - Etcd - Distributed reliable key-value store for the most critical data of a distributed system. oss
  - Valkey - High-performance key/value datastore forked from Redis. oss

Observability & Monitoring

Observability, Monitoring, Metrics/Metrics collection and Alerting tools.

Steampipe - The universal SQL interface for any cloud API, & cloud intelligence dashboards extensible w/ HCL+SQL. oss
stackql - Query and manage AWS, GCP, Azure and dozens of other cloud APIs with SQL. oss
Sensu - Simple. Scalable. Multi-cloud monitoring. oss paid
Alerta - Scalable, minimal configuration and visualization monitoring system. oss
Cabot - Self-hosted, easily-deployable monitoring and alerts service. oss
Amon - Modern server monitoring platform. oss
Icinga - Monitors availability and performance, gives you simple access to relevant data and raises alerts. oss paid
Monit - Managing and monitoring Unix systems. oss paid
Naemon - Fast, stable and innovative while giving you a clear view of the state of your network and applications. oss
Nagios - Computer-software application that monitors systems, networks and infrastructure. oss paid
Sentry - Error monitoring that helps all software teams discover, triage, and prioritize errors in real-time. oss paid
Shinken - Monitoring framework. oss
Zabbix - Mature and effortless monitoring solution for network monitoring and application monitoring. oss paid
Glances - Monitoring information through a curses or Web based interface. oss
Healthchecks - Cron monitoring tool. oss paid
Bolo - Building distributed, scalable monitoring systems. oss
cAdvisor - Analyzes resource usage and performance characteristics of running containers. oss
ElastiFlow - Network flow monitoring (Netflow, sFlow and IPFIX) with the Elastic Stack. free paid self-hosted
Co-Pilot - System performance analysis toolkit. oss
Keep - Open source alerting CLI for developers. oss paid
Globalping CLI - Run network commands like ping, traceroute and mtr from hundreds of global locations. oss
Grai - Open source observability integrating data impact analysis into CI. oss
Canary Checker - Open source health check platform. oss paid
HolmesGPT - Open Source AI assistant that can investigate alerts and find root cause automatically. oss
Middleware - A full-stack cloud observability platform. free paid
OpenTelemetry - Vendor-neutral framework for traces, metrics and logs. oss
Jaeger - Open source, end-to-end distributed tracing platform. oss
Regen - Self-hosted incident management with alert ingestion, on-call scheduling, escalation policies and Slack and Teams integration. oss
Sherlocks.ai - AI SRE that investigates alerts and incidents across observability data to find the root cause. paid
Hyperping - Uptime and API monitoring with on-call scheduling, escalation policies and status pages. paid
Metrics/Metrics collection
- Prometheus - Power your metrics and alerting with a leading open-source monitoring solution. oss
- Collectd - The system statistics collection daemon. oss
- Facette - Time series data visualization software. oss
- Grafana - Analytics & monitoring solution for every database. oss paid
- Graphite - Store numeric time-series data and render graphs of this data on demand. oss
- Influxdata - Time series database. oss paid
- Netdata - Instantly diagnose slowdowns and anomalies in your infrastructure. oss paid
- Freeboard - Real-time dashboard builder for IOT and other web mashups. oss
- Autometrics - An open-source micro framework for observability. oss
- Thanos - Highly available Prometheus setup with long-term storage. oss
- VictoriaMetrics - Fast, cost-effective time series database and monitoring. oss paid
Logs Management
- Anthracite - An event/change logging/management app. oss
- Graylog - Free and open source log management. oss paid
- Logstash - Collect, parse, transform logs. oss paid
- Fluentd - Data collector for unified logging layer. oss
- Flume - Distributed, reliable, and available service for efficiently collecting, aggregating, and moving logs. oss
- Heka - Stream processing software system. oss
- Kibana - Explore, visualize, discover data. oss paid
- Loki - Horizontally-scalable, highly available, multi-tenant log aggregation system inspired by Prometheus. oss paid
- LynxDB - Lightweight log analytics database with SPL-inspired queries. oss
Status
- Cachet - Beautiful and powerful open-source status page system. oss
- StatusPal - Communicate incidents and maintenance effectively with a beautiful hosted status page. paid
- Instatus - Quick and beautiful status page. free paid
- Oxmgr - Lightweight Rust process manager and PM2 alternative. 42x faster crash recovery, 19x lower memory usage. Manages Node.js, Python, Go, and any executable on Linux, macOS, and Windows. oss
- Rootly - Incident management platform with on-call, status pages, retrospectives and an AI SRE, running incidents in Slack and Microsoft Teams. paid

Service Discovery & Service Mesh

Service Discovery, Service Mesh and Failure detection tools.

Consul - Connect and secure any service. free paid self-hosted
Serf - Decentralized cluster membership, failure detection, and orchestration. oss
Doozerd - A consistent distributed data store. oss
Zookeeper - Centralized service for configuration, naming, providing distributed synchronization, and more. oss
Etcd - Distributed, reliable key-value store for the most critical data of a distributed system. oss
Istio - Connect, secure, control, and observe services. oss
Kong - Deliver performance needed for microservices, service mesh, and cloud native deployments. oss paid
Linkerd - Service mesh for Kubernetes and beyond. oss paid
Meshery - A cloud-native management plane that simplifies the design, deployment, and management of cloud native infrastructure. oss paid

Chaos Engineering

Experimenting on a distributed system to build confidence in its capability to withstand turbulent conditions.

Chaos Toolkit - The Open Source Platform for Chaos Engineering. oss
Chaos Monkey - A resiliency tool that helps applications tolerate random instance failures. oss
Toxiproxy - Simulate network and system conditions for chaos and resiliency testing. oss
Pumba - Chaos testing, network emulation and stress testing tool for containers. oss
Chaos Mesh - A Chaos Engineering Platform for Kubernetes. oss
Litmus - Litmus enables teams to identify weaknesses in infrastructures. oss

API Gateway

API Gateway, Service Proxy and Service Management tools.

API Umbrella - Proxy that sits in front of your APIs, API management platform. oss
Ambassador - Kubernetes-Native API Gateway built on the Envoy Proxy. oss paid
Kong - Connect all your microservices and APIs with the industry’s most performant, scalable and flexible API platform. oss paid
SBproxy - AI gateway and reverse proxy with LLM routing, rate limiting, and YAML config. oss
Tyk - API and service management platform. oss paid
Cilium - API aware networking and security using BPF and XDP. oss
Gloo - Feature-rich, Kubernetes-native ingress controller, and next-generation API gateway. oss paid
Envoy - Cloud-native high-performance edge/middle/service proxy. oss
Traefik - Reverse proxy and load balancer for HTTP and TCP-based applications. oss paid

Code review

Code review. A few of the Source Code Management tools have built-in code review features.

Gerrit - Web-based team code collaboration tool. oss
Review Board - Web-based collaborative code review tool. oss paid
MeshMap - World’s only visual designer for Kubernetes and cloud native applications. Design, deploy, and manage your Kubernetes-based, cloud native deployments allowing you to speed up infrastructure configuration. free paid
Potpie - AI agent that understands your code changes and computes the blast radius of your changes. oss paid
CodeRabbit - AI-powered code review tool that integrates with GitHub. It automates routine checks, provides intelligent feedback, and helps maintain consistent code quality. free paid
Kodus - Open-source AI agent that reviews pull requests and learns each team's conventions. oss paid

Distributed Messaging

Distributed messaging platforms and Queues software.

Rabbitmq - Message broker. oss paid
Kafka - Building real-time data pipelines and streaming apps. oss
Activemq - Multi-Protocol messaging. oss
Beanstalkd - Simple, fast work queue. oss
NSQ - Realtime distributed messaging platform. oss
Celery - Asynchronous task queue/job queue based on distributed message passing. oss
Faktory - Repository for background jobs within your application. oss paid
Nats - Simple, secure and high performance open source messaging system. oss paid
RestMQ - Message queue which uses HTTP as transport. oss
Dkron - Distributed, fault tolerant job scheduling system. oss paid
KubeMQ - Kubernetes-native messaging platform. free paid self-hosted

Programming Languages

Programming languages.

Python - Programming language that lets you work quickly and integrate systems more effectively. oss
Ruby - A dynamic, open-source programming language with a focus on simplicity and productivity. oss
Go - An open-source programming language that makes it easy to build simple, reliable, and efficient software. oss

Chat and ChatOps

Chat and ChatOps.

Rocket - Open source team communication. oss paid
Mattermost - Messaging platform that enables secure team collaboration. oss paid
Zulip - Real-time chat with an email threading model. oss paid
Riot - A universal secure chat app entirely under your control. oss paid
ChatOps:
- CloudBot - Simple, fast, expandable, open-source Python IRC Bot. oss
- Hubot - A customizable life embetterment robot. oss

Secret Management

Sensitive credentials and secrets managed, secured, maintained and rotated using automation.

SOPS - Simple and flexible tool for managing secrets. oss
Vault - Manage secrets and protect sensitive data. free paid self-hosted
Keybase - End-to-end encrypted chat and cloud storage system. oss
Vault Secrets Operator - Create Kubernetes secrets from Vault for a secure GitOps based workflow. oss
Git Secret - A bash-tool to store your private data inside a git repository. oss
Infisical - Open source end-to-end encrypted secrets sync for teams and infrastructure. oss paid
Lade - Automatically load secrets from your preferred vault as environment variables. oss
SigCLI - Signs in once through a browser or OAuth2, then supplies fresh credentials to CLI tools and AI agents without exposing them. oss
OpenBao - Community-driven, open-source fork of Vault for managing secrets, under the OpenSSF. oss
External Secrets Operator - Kubernetes operator that syncs secrets from external secret managers into Kubernetes. oss

Security

Validating, lint and best practice in term of Security on code or infrastructure.

checkov - Prevent cloud misconfigurations and find vulnerabilities during build-time in infrastructure as code, container images and open source packages. oss
Darkmoon - Open source autonomous AI penetration testing platform that orchestrates 80+ offensive tools via Markdown playbooks with a proof trail per finding. oss
IntoDNS.ai - Free DNS and email security scanner. Checks SPF, DKIM, DMARC, DNSSEC with API for CI/CD integration. free
Trivy - Scanner for vulnerabilities and misconfigurations in code and containers. oss
Falco - Cloud native runtime security and threat detection. oss
Open Policy Agent - General-purpose policy engine for cloud native environments. oss
Kyverno - Policy engine designed for Kubernetes. oss
Sigstore - Signing, verification and provenance for software artifacts. oss
Gitleaks - Detect and prevent hardcoded secrets in git repositories. oss
Cordum - Self-hosted control plane that applies policy checks, approval gates and audit trails to actions taken by AI agents. free self-hosted
BunkerWeb - Open-source web application firewall built on NGINX, for Docker, Kubernetes and Linux. oss paid
Greywall - Deny-by-default sandbox that isolates the filesystem and network access of commands, CLI tools and AI coding agents on Linux and macOS. oss

Tools to help with sharing knowledge and telling the story.

Gitbook - Modern documentation format and toolchain using Git and Markdown. free paid
Docusaurus - Easy to maintain open source documentation websites. oss
Docsify - A magical documentation site generator. oss
MkDocs - Project documentation with Markdown. oss
OneCompiler - Allow users to write, run, and share code online in over 70 programming languages and databases. free paid

VPN

VPN, routing and firewall.

OpenVPN - Flexible VPN solutions to secure your data communications, whether it's for Internet privacy. oss paid
Pritunl - Enterprise Distributed OpenVPN and IPsec Server. oss paid
VyOS - Open source network OS that runs on a wide range of hardware, virtual machines, and cloud providers. oss paid
Algo - Set up a personal VPN in the cloud. oss
Streisand - Sets up a new VPN service nearly automatically. oss
Freelan - A peer-to-peer, secure, easy-to-setup, multi-platform, open-source, highly-configurable VPN software. oss
Sshuttle - Transparent proxy server that works as a poor man's VPN. oss
SoftEther - An Open-Source Free Cross-platform Multi-protocol VPN Program, developed as an academic project at the University of Tsukuba under the Apache License 2.0. oss
Firezone - Self-hosted VPN server using WireGuard. Supports MFA, SSO, and has easy deployment options. oss paid
WireGuard - Fast, modern and secure VPN tunnel. oss
rustunnel - Self-hosted tunnel server for exposing local HTTP, HTTPS, TCP and UDP services, with TLS and Prometheus metrics. oss paid

Resources

Books

Books focused on DevOps, DevSecOps and Site Reliability Engineering.

Effective DevOps: Building a Culture of Collaboration, Affinity, and Tooling at Scale - Jennifer Davis, Ryn Daniels · O'Reilly · 2016. paid
Continuous Delivery: Reliable Software Releases through Build, Test, and Deployment Automation - Jez Humble, David Farley · Addison-Wesley · 2010. paid
Site Reliability Engineering - Betsy Beyer, Chris Jones, Jennifer Petoff, Niall Murphy · O'Reilly · 2016. free
The Site Reliability Workbook - Betsy Beyer, Niall Murphy, David Rensin, Kent Kawahara, Stephen Thorne · O'Reilly · 2018. free
Building Secure & Reliable Systems - Heather Adkins, Betsy Beyer, Paul Blankinship et al. · O'Reilly · 2020. free
Infrastructure as Code: Managing Servers in the Cloud - Kief Morris · O'Reilly · 2016. paid
The DevOps Handbook - Gene Kim, Jez Humble, Patrick Debois, John Willis · IT Revolution · 2016. paid
Fundamentals of DevOps and Software Delivery: A Hands-On Guide to Deploying and Managing Software in Production - Yevgeniy Brikman · O'Reilly · 2025. paid
Effective Platform Engineering - Ajay Chankramath, Nic Cheneweth, Bryan Oliver, Sean Alvarez · Manning · 2025. paid
Latency: Reduce delay in software systems - Pekka Enberg · Manning · 2025. paid

Conferences

DevOpsCon paid
AWS re:Invent - Las Vegas · December. paid
All Day DevOps - Online. free
DevOpsConnect paid
@Scale - Meta. free
devopsdays - Worldwide. paid
DevOps Enterprise Summit - IT Revolution. paid

Blogs

Medium free

DevOps Roadmap

Roadmap.sh DevOps - Basic understanding and what you should know to become a DevOps Engineer. free
Dynamic DevOps Roadmap - A Progressive, Non-Linear, and T-Shaped roadmap that works as a master plan to kickstart your DevOps Engineer career in the Cloud Native era following the Agile MVP style. free

Online Platforms

Cloud Native Playground - The Meshery CNCF Playground is an awesome and free resource featuring a live Kubernetes cluster where any CNCF project can be configured and deployed. It is a fantastic interactive learning platform for exploring cloud native technologies. free

Contributing

Your contributions are always welcome! Please take a look at the Contribution Guidelines.

File: CONTRIBUTING.md

Contribute

Contributions are always welcome. The whole list lives in one file, README.md. The website at awesome-devops.xyz is built from it, so a change to the README is all you need: you never edit the website.

Before you add a tool

Check that the tool:

helps teams build, ship, run or secure software, and fits one of the existing sections;
is not already on the list (search awesome-devops.xyz first);
is maintained: its repository is not archived and has had activity in the last two years;
is established: an open source tool needs a public repository with an open source license, at least 100 stars and 6 months of history; a tool without a repository needs a website on a domain at least 6 months old;
has an official link, without tracking parameters such as utm_source.

New projects are welcome once they meet these numbers. They keep out abandoned experiments, and projects with bought stars or a site set up only to be listed.

To suggest a new section, open an issue first so it can be discussed.

Add a tool

Open README.md on GitHub and select the pencil icon to edit it. GitHub forks the repository for you.

Add one line to the right section, in this format:

markdown

- [Name](https://example.com/) - What the tool does, in one sentence. `oss`

Select Commit changes, then Create pull request. Add one tool per pull request.

Within a few minutes an automated review comments on your pull request. It checks the entry format and tags, that the link works and has no tracking parameters, that the tool is not already listed, and how mature the project is (repository age, stars, forks, contributors, last activity, domain age, signs of inflated stars), and an AI reviewer checks that the description, section and tags match the project. The comment lists anything to fix, often with a corrected line you can copy, and updates every time you push.

Writing the entry

Name: the project's own spelling, for example Kubernetes, GitLab, etcd.
Link: the project's website, or its GitHub repository if it has no website.
Description: one sentence that says what the tool does, ending with a period. Leave out marketing words like "best", "blazing fast" or "revolutionary".

Pricing tags

End every entry with one or more tags:

Tag	Use it when
`oss`	The source code is public under an open source license.
`free`	There is a free plan or free usage, but the tool is not open source.
`paid`	There are paid plans, an enterprise edition or paid support.
`self-hosted`	You can run it on your own servers, but it is not open source.

Combine them when more than one applies:

Tool	Tags
Open source, nothing to buy	`oss`
Open source with a hosted or enterprise offering	`oss` `paid`
SaaS with a free tier	`free` `paid`
Commercial product you can install yourself	`paid` `self-hosted`
Paid only	`paid`

The website shows these as Open source, Freemium (has a free plan) or Paid.

GitHub stars and activity

The website shows stars, license, language and last activity from GitHub, refreshed every day. You don't need to do anything for this:

if the link is a GitHub repository, that repository is used;
if the link is a website, the build searches GitHub for a repository with the same name whose homepage is that website.

If the site shows the wrong repository or none at all, add the correct one to website/src/data/repos.json, keyed by the entry's link:

json

{
  "https://www.example.com/": "example-org/example"
}

Preview the website locally

cd website
npm install
npm run dev

Then open the address it prints. See website/README.md for details.

File: website/README.md

awesome-devops.xyz

The website for Awesome DevOps, built with Astro and a few Preact islands.

The repository README.md is the source of truth. The build parses it, so adding or editing a tool there is all that is needed. See CONTRIBUTING.md for the entry format and pricing tags.

The two guide pages are Markdown too:

What is DevOps? is src/content/what-is-devops.mdx: Markdown plus a few components for the visual blocks (cards, phases, metrics), listed at the top of the file. Each ## heading becomes an entry in the page menu.
Contribute is the repository's CONTRIBUTING.md, split into menu sections at each ## heading. Only the quick reference card at the top lives in src/pages/contribution.astro.

Develop

npm install
npm run dev        # http://localhost:4321
npm run build      # static site in dist/

Data

File	What it holds
`../README.md`	Tools, categories, descriptions, pricing tags, Learn resources
`src/data/repos-auto.json`	GitHub repositories found automatically for entries that link to a website (generated)
`src/data/repos.json`	Manual corrections when auto-detection picks the wrong repository or none (`null` means no repository)
`src/data/learn-topics.json`	Categories each Learn resource relates to ("Related reading" on tool pages)
`src/data/github.json`	Stars, forks, issues, license, language, last push, archived. Refreshed by the deploy

npm run fetch:github finds repositories for new website links (GitHub search, matching the repo homepage to the website's domain) and refreshes github.json. Set GITHUB_TOKEN to avoid the unauthenticated limits of 10 searches and 60 API calls per hour. npm run fetch:icons downloads favicons into public/icons/ (not committed).

The build fails if a README entry has no pricing tag or a section is not listed in CATEGORY_IDS in src/lib/readme.mjs.

Pull request review

.github/workflows/pr-review.yml reviews every pull request and posts one comment with a verdict label:

Label	Meaning
`ready-to-merge`	Checks passed and the AI review approves. Approve and merge.
`needs-changes`	Something must be fixed (the check fails). The comment says what.
`needs-human-review`	Nothing is blocking, but a maintainer should decide: files other than README.md changed, many entries added, the AI could not decide or raised a concern.

Repository checks (scripts/review/checks.mjs) block on: a missing pricing tag or unknown section, a missing description, a link that returns 404/410 or does not resolve, tracking parameters in the link, a link already on the list, and an archived repository. They warn on marketing language, long descriptions, http:// links, repositories inactive for 24 months, and oss without a detected license.

The AI review (scripts/review/ai.mjs, Claude claude-opus-5) reads the diff, the project's website and repository, and judges relevance, section, description and tags. It is advisory: it cannot merge, and repository checks alone decide whether the check fails.

Setup: add an ANTHROPIC_API_KEY repository secret (Settings → Secrets and variables → Actions). Without it, every pull request gets needs-human-review. To require the review before merging, add the PR review / review and Website check / build checks to a branch protection rule for main.

GitHub Copilot code review

Copilot reviews every pull request with the same rules, as inline comments with suggested fixes the contributor can apply in one click:

.github/copilot-instructions.md: what this repository is and what to flag in any pull request.
.github/instructions/readme.instructions.md: the rules for README entries. This file is the single rulebook: the Claude review reads it too, so both reviewers apply exactly the same rules. Edit the rules here only.
.github/instructions/website.instructions.md and workflows.instructions.md: rules for website code and CI changes.

Copilot reads these files from the pull request's own branch, so a pull request could change them to steer Copilot. The Claude review reads the rulebook from main instead, and any pull request that touches the review rules gets needs-human-review.

To turn on automatic Copilot reviews: Settings → Rules → Rulesets → New branch ruleset, target the default branch, enable Automatically request Copilot code review and Review new pushes.

Run it locally against two README versions:

node scripts/review/index.mjs --base-readme base.md --head-readme head.md --files files.txt --dry-run

Deploy

.github/workflows/deploy.yml runs on every push to main and daily at 06:00 UTC: it fetches GitHub data and favicons, builds, and publishes dist/ to the gh-pages branch for awesome-devops.xyz.

File: website/package.json

{
"name": "awesome-devops-website",
"private": true,
"type": "module",
"scripts": {
"dev": "astro dev",
"build": "astro build",
"preview": "astro preview",
"fetch:github": "node scripts/fetch-github.mjs",
"fetch:icons": "node scripts/fetch-icons.mjs"
},
"dependencies": {
"@astrojs/mdx": "^8.0.2",
"@astrojs/preact": "^6.0.5",
"@astrojs/sitemap": "^3.7.4",
"astro": "^7.3.5",
"marked": "^18.0.14",
"preact": "^10.29.8"
},
"devDependencies": {
"@anthropic-ai/sdk": "^0.131.0",
"zod": "^4.6.5"
}
}

File: website/tsconfig.json

{
"extends": "astro/tsconfigs/strict",
"include": [".astro/types.d.ts", "**/*"],
"exclude": ["dist"],
"compilerOptions": {
"jsx": "react-jsx",
"jsxImportSource": "preact",
"allowJs": true,
"checkJs": false
}
}

File: website/src/content/what-is-devops.mdx

import { Cards, Card, Rows, Row, Metrics, Metric, Phases, Phase, Steps, ReadNext } from '../components/guide';

{/*
The "What is DevOps?" guide. Write it as Markdown: every "## " heading becomes an
entry in the page menu. The components below are for the visual blocks:

+ grid of cards
+ list rows; category links to a tool category
+ metric tiles

plan with a list of actions

wraps a numbered list, shown as numbered cards
learning resources from README.md, by title
*/}

What DevOps is

For most of the history of software, developers were measured on how much they shipped and operations on how little broke. Those goals pull in opposite directions, so changes queued up, releases became large and risky, and every outage started with an argument about whose fault it was.

DevOps removes that wall. One team owns a service end to end and is measured on outcomes both sides care about: how quickly a change reaches users and how reliably the service runs. To make that possible, teams automate the path to production, release in small batches, watch production closely, and learn from every failure.

It is first a change in how people work together, then a set of practices, and only then a set of tools.

What DevOps is not

Renaming the ops team to "DevOps" or adding a DevOps team between developers and operations creates one more handoff. The goal is fewer handoffs. Tools make good habits cheap to repeat. They do not create the habits. A CI server nobody trusts, or a Kubernetes cluster only one person understands, changes nothing. Operations knowledge becomes more important, not less. It moves into code, platforms and shared on-call instead of tickets. Teams that deploy more often also tend to have fewer and shorter outages. Small, frequent, reversible changes are what make both possible.

Principles

A useful checklist is CALMS. If one of these is missing, the others stall.

Shared ownership of the service, from commit to production. Developers carry the pager for what they build, and incidents are reviewed without blame. Anything done twice by hand is a candidate: builds, tests, environments, deployments, rollbacks, access requests. Small batches, limited work in progress, and removing waiting time between steps. Most lead time is waiting, not working. Decisions are based on data from the delivery pipeline and from production, not on opinions. Runbooks, dashboards, postmortems and pipeline code are open to every team, so lessons travel.

The DevOps Handbook frames the same ideas as three ways: optimize the flow of work from development to production, create fast feedback from production back to development, and build a culture of continual experimentation and learning.

How to measure it

Research from the DORA program, published in the book Accelerate, found four measures that predict software delivery performance. Two measure speed and two measure stability, and the best teams improve both together.

How often you ship to production. Time from commit to running in production. Share of deployments that cause a failure in production. How long it takes to recover from a failed deployment or outage.

Measure per team and per service, and watch trends over months. Comparing teams against each other, or tying the numbers to bonuses, gets you gamed metrics instead of better software.

Core practices

Every change is merged at least daily and verified by an automated build and test run. Every change that passes the pipeline can be released at any time, or is released automatically. Servers, networks and cloud resources are described in versioned files, reviewed like code and applied by tools. Applications ship as immutable images and run on a scheduler that handles placement, scaling and restarts. Metrics, logs and traces explain what the system is doing, and alerts fire on user-facing symptoms. Credentials are stored, rotated and injected by automation instead of living in code or chat. Dependency, image and configuration scanning run on every change, not in a review before release. Controlled failure experiments prove the system survives the outages you expect. Self-service golden paths let teams create, deploy and operate services without filing tickets.

Bringing DevOps into your organization

DevOps is adopted one team and one bottleneck at a time. The phases below are a typical path. Timings vary with the size of the organization, but the order matters: skipping the foundations to build a platform nobody is ready to use is the most expensive mistake on this page.

text

- Map the value stream for one service: every step from an idea to running in production, with how long work waits at each step.
- Record a baseline of the four metrics above, even if you measure them roughly by hand.
- Choose one pilot team that owns a real, customer-facing service and wants to change. Avoid a greenfield toy project.
- Agree with leadership on the outcome you are after, in business terms: faster time to market, fewer outages, less overtime.




- Put everything in version control: application, infrastructure, configuration, pipeline definitions and runbooks.
- Run CI on every pull request. Keep branches short-lived and merge to the main branch at least daily.
- Automate deployment to at least one environment, triggered from the pipeline, never from a laptop.
- Add basic monitoring and alerting on what users feel: errors, latency, availability.
- Hold a blameless postmortem for every significant incident and track the follow-up actions to completion.




- Provision environments with infrastructure as code. Treat a manual change in production as an incident.
- Deploy to production through the pipeline with progressive delivery: canary or blue-green releases and automated rollback.
- Define service level objectives (SLOs) for key services and use error budgets to balance features against reliability.
- Share on-call between developers and operators for the services they build together.
- Move security left: scan dependencies, images and infrastructure code in the pipeline, and manage secrets centrally.
- Let the pilot team teach the next teams. Pairing beats training slides.




- Form a platform team that builds paved roads: a templated service, pipeline, observability and deployment that work out of the box.
- Offer the platform as a product with documentation, support and a roadmap driven by its users, the development teams.
- Keep the paved road optional but attractive, so teams choose it because it is easier.
- Measure developer experience alongside the four metrics: onboarding time, time to first deploy, how often people wait on others.

How to organize teams

Structure follows the work. The model described in the book Team Topologies fits DevOps well: a few team types with clear responsibilities, and as few handoffs between them as possible.

Own a product or service end to end: build it, ship it, run it. Most of your engineers should be here. Builds and runs the internal platform that stream-aligned teams use through self-service, not tickets. Experts in an area such as CI/CD, observability or security, who coach teams for a few weeks and then move on. Engineers who apply software engineering to reliability. They can work embedded in teams, as a central team for critical services, or as consultants.

The anti-pattern to avoid is a separate DevOps team that sits between development and operations and takes tickets from both. It recreates the wall DevOps is meant to remove.

DevOps and SRE

Site Reliability Engineering (SRE) is a concrete way to run DevOps, which started at Google, where operations work is treated as a software problem. Its core tools work in any organization:

A target for how reliable a service must be, measured from the user's side, for example 99.9% of requests succeed within 300 ms over 28 days. The unreliability the SLO allows. While budget remains, ship features. When it runs out, reliability work comes first. This turns the dev versus ops argument into a shared, numeric rule. Manual, repetitive operational work is capped (Google uses 50% of an engineer's time) so there is always time to automate it away. Every significant incident gets a written review focused on causes in the system, not on people, with tracked follow-up actions.

Common mistakes

The ops team becomes the "DevOps team", tickets stay tickets, and nothing about how work flows has changed. Buying a platform before agreeing on the problem it solves. Start with the value stream, then choose tools. Reorganizing every team at once. Start with one team, prove results, and spread what worked. When deployment frequency becomes a target, teams split deploys to hit the number. Use the metrics to find problems, never to rank teams or people. Automating five approval steps gives you five fast approval steps. Remove the waste first. If every sprint is 100% feature work, the toil never shrinks. Protect time for pipeline, reliability and tooling work. Security brought in at the end blocks releases. Bring them in early and encode their rules in the pipeline.

Start on Monday

You don't need a transformation program to begin. Five things one team can do this week:

Pick one service and write down every step from commit to production, with how long each one takes.
Measure how often that service deploys and how long a change takes to reach users.
Find the longest wait in that flow and fix only that.
Run your next incident review without blame, and ask "what made this possible?" instead of "who did this?".
Book a recurring slot for improvement work and protect it.

File: website/src/data/github.json

{
"fetchedAt": "2026-10-04T19:41:58Z",
"repos": {
"ASCIT31/Dark-Moon": {
"archived": false,
"forks": 166,
"issues": 2,
"lang": null,
"license": "GPL-3.0",
"pushed": "2026-10-01T08:22:43Z",
"stars": 993
},
"AppScale/appscale": {
"stars": 2421,
"forks": 277,
"issues": 52,
"license": "Apache-2.0",
"lang": "Python",
"pushed": "2024-05-22T02:14:44Z",
"archived": false
},
"CloudBotIRC/CloudBot": {
"archived": false,
"forks": 247,
"issues": 60,
"lang": "Python",
"license": "GPL-3.0",
"pushed": "2026-02-27T09:11:39Z",
"stars": 291
},
"Dieterbe/anthracite": {
"archived": false,
"forks": 32,
"issues": 9,
"lang": null,
"license": "Apache-2.0",
"pushed": "2015-03-10T19:16:26Z",
"stars": 295
},
"Freeboard/freeboard": {
"archived": false,
"forks": 1173,
"issues": 146,
"lang": null,
"license": "MIT",
"pushed": "2018-03-07T17:34:26Z",
"stars": 6507
},
"GitbookIO/gitbook": {
"archived": false,
"forks": 4044,
"issues": 51,
"lang": "TypeScript",
"license": "GPL-3.0",
"pushed": "2026-10-02T17:38:56Z",
"stars": 29061
},
"Graylog2/graylog2-server": {
"archived": false,
"forks": 1131,
"issues": 1862,
"lang": "Java",
"license": null,
"pushed": "2026-10-02T16:56:33Z",
"stars": 8150
},
"Huawei/dockyard": {
"stars": 278,
"forks": 66,
"issues": 12,
"license": "Apache-2.0",
"lang": "Go",
"pushed": "2023-04-12T08:04:56Z",
"archived": false
},
"Icinga/icinga2": {
"archived": false,
"forks": 618,
"issues": 365,
"lang": "C++",
"license": "GPL-3.0",
"pushed": "2026-10-01T09:54:36Z",
"stars": 2239
},
"Infisical/infisical": {
"archived": false,
"forks": 2307,
"issues": 267,
"lang": "TypeScript",
"license": null,
"pushed": "2026-10-04T00:21:31Z",
"stars": 29599
},
"Kong/kong": {
"archived": false,
"forks": 5224,
"issues": 89,
"lang": "Lua",
"license": "Apache-2.0",
"pushed": "2026-09-28T09:59:53Z",
"stars": 44239
},
"Kraken-CI/kraken": {
"archived": false,
"forks": 19,
"issues": 48,
"lang": "Python",
"license": "Apache-2.0",
"pushed": "2024-03-26T05:15:42Z",
"stars": 160
},
"LINBIT/drbd": {
"stars": 726,
"forks": 116,
"issues": 43,
"license": "GPL-2.0",
"lang": "C",
"pushed": "2026-10-02T13:54:54Z",
"archived": false
},
"ManageIQ/manageiq": {
"archived": false,
"forks": 940,
"issues": 295,
"lang": "Ruby",
"license": "Apache-2.0",
"pushed": "2026-10-02T22:26:37Z",
"stars": 1403
},
"MariaDB/server": {
"archived": false,
"forks": 2119,
"issues": null,
"lang": "C++",
"license": "GPL-2.0",
"pushed": "2026-10-02T11:59:22Z",
"stars": 8312
},
"NREL/api-umbrella": {
"archived": false,
"forks": 373,
"issues": 229,
"lang": "Lua",
"license": "MIT",
"pushed": "2026-07-26T13:32:56Z",
"stars": 2199
},
"NagiosEnterprises/nagioscore": {
"archived": false,
"forks": 482,
"issues": 204,
"lang": null,
"license": "GPL-2.0",
"pushed": "2026-08-07T15:48:28Z",
"stars": 2047
},
"Netflix/chaosmonkey": {
"archived": false,
"forks": 1307,
"issues": 15,
"lang": "Go",
"license": "Apache-2.0",
"pushed": "2024-10-03T23:46:19Z",
"stars": 17165
},
"NixOS/nixpkgs": {
"stars": 26349,
"forks": 20290,
"issues": 21819,
"license": "MIT",
"lang": "Nix",
"pushed": "2026-10-04T19:39:09Z",
"archived": false
},
"OpenNebula/one": {
"stars": 1749,
"forks": 534,
"issues": 749,
"license": "Apache-2.0",
"lang": "JavaScript",
"pushed": "2026-09-25T07:18:50Z",
"archived": false
},
"OpenVPN/openvpn": {
"archived": false,
"forks": 3404,
"issues": 179,
"lang": "C",
"license": "GPL-2.0",
"pushed": "2026-10-04T10:24:25Z",
"stars": 14638
},
"Qovery/engine": {
"stars": 2466,
"forks": 84,
"issues": 0,
"license": "GPL-3.0",
"lang": "Rust",
"pushed": "2026-10-02T14:54:13Z",
"archived": false
},
"RocketChat/Rocket.Chat": {
"archived": false,
"forks": 13942,
"issues": 2557,
"lang": "TypeScript",
"license": null,
"pushed": "2026-10-03T02:28:09Z",
"stars": 46212
},
"Shopify/toxiproxy": {
"archived": false,
"forks": 513,
"issues": 78,
"lang": "Go",
"license": "MIT",
"pushed": "2026-08-25T19:40:02Z",
"stars": 12378
},
"SoftEtherVPN/SoftEtherVPN": {
"archived": false,
"forks": 2780,
"issues": 275,
"lang": "C",
"license": "Apache-2.0",
"pushed": "2026-10-01T08:47:56Z",
"stars": 13611
},
"StackStorm/st2": {
"archived": false,
"forks": 790,
"issues": 555,
"lang": "Python",
"license": "Apache-2.0",
"pushed": "2026-09-02T12:30:43Z",
"stars": 6540
},
"StreisandEffect/streisand": {
"archived": true,
"forks": 1940,
"issues": 211,
"lang": "Shell",
"license": null,
"pushed": "2020-04-12T01:29:05Z",
"stars": 23440
},
"Strider-CD/strider": {
"archived": false,
"forks": 419,
"issues": 175,
"lang": "JavaScript",
"license": null,
"pushed": "2021-10-23T18:39:09Z",
"stars": 4565
},
"TykTechnologies/tyk": {
"archived": false,
"forks": 1166,
"issues": 188,
"lang": "Go",
"license": null,
"pushed": "2026-10-01T12:57:30Z",
"stars": 10846
},
"Unleash/unleash": {
"archived": false,
"forks": 904,
"issues": 16,
"lang": "TypeScript",
"license": "AGPL-3.0",
"pushed": "2026-10-02T20:43:29Z",
"stars": 13856
},
"Vladimir-Urik/OxMgr": {
"archived": false,
"forks": 23,
"issues": 11,
"lang": null,
"license": "MIT",
"pushed": "2026-09-28T11:48:25Z",
"stars": 267
},
"alerta/alerta": {
"archived": false,
"forks": 376,
"issues": 24,
"lang": "Python",
"license": "Apache-2.0",
"pushed": "2026-03-30T16:26:12Z",
"stars": 2530
},
"alexei-led/pumba": {
"archived": false,
"forks": 222,
"issues": 1,
"lang": "Go",
"license": "Apache-2.0",
"pushed": "2026-08-27T08:37:29Z",
"stars": 3177
},
"amonapp/amon": {
"archived": false,
"forks": 104,
"issues": 37,
"lang": null,
"license": "AGPL-3.0",
"pushed": "2019-02-20T19:11:16Z",
"stars": 1324
},
"ansible/ansible": {
"stars": 70852,
"forks": 24340,
"issues": 866,
"license": "GPL-3.0",
"lang": "Python",
"pushed": "2026-10-02T21:01:26Z",
"archived": false
},
"apache/activemq": {
"archived": false,
"forks": 1502,
"issues": 58,
"lang": "Java",
"license": "Apache-2.0",
"pushed": "2026-10-01T17:09:30Z",
"stars": 2464
},
"apache/cassandra": {
"archived": false,
"forks": 4120,
"issues": null,
"lang": "Java",
"license": "Apache-2.0",
"pushed": "2026-10-03T19:16:38Z",
"stars": 10114
},
"apache/cloudstack": {
"stars": 3089,
"forks": 1388,
"issues": 1118,
"license": "Apache-2.0",
"lang": "Java",
"pushed": "2026-10-03T08:07:33Z",
"archived": false
},
"apache/couchdb": {
"archived": false,
"forks": 1081,
"issues": 303,
"lang": "Erlang",
"license": "Apache-2.0",
"pushed": "2026-10-04T14:38:37Z",
"stars": 6968
},
"apache/flume": {
"archived": false,
"forks": 1538,
"issues": 3,
"lang": null,
"license": "Apache-2.0",
"pushed": "2026-09-17T17:37:12Z",
"stars": 2570
},
"apache/hbase": {
"archived": false,
"forks": 3400,
"issues": null,
"lang": "Java",
"license": "Apache-2.0",
"pushed": "2026-10-04T12:59:25Z",
"stars": 5560
},
"apache/httpd": {
"archived": false,
"forks": 1358,
"issues": null,
"lang": "C",
"license": "Apache-2.0",
"pushed": "2026-10-02T09:05:43Z",
"stars": 4035
},
"apache/kafka": {
"archived": false,
"forks": 15553,
"issues": null,
"lang": "Java",
"license": "Apache-2.0",
"pushed": "2026-10-04T18:12:24Z",
"stars": 33904
},
"apache/mesos": {
"stars": 5365,
"forks": 1653,
"issues": 11,
"license": "Apache-2.0",
"lang": "C++",
"pushed": "2026-05-15T22:22:50Z",
"archived": false
},
"apache/zookeeper": {
"archived": false,
"forks": 7321,
"issues": null,
"lang": "Java",
"license": "Apache-2.0",
"pushed": "2026-10-02T19:41:24Z",
"stars": 12817
},
"arachnys/cabot": {
"archived": false,
"forks": 582,
"issues": 149,
"lang": "JavaScript",
"license": "MIT",
"pushed": "2021-01-05T10:40:20Z",
"stars": 5679
},
"argoproj/argo-cd": {
"archived": false,
"forks": 7911,
"issues": 3552,
"lang": "Go",
"license": "Apache-2.0",
"pushed": "2026-10-03T13:38:36Z",
"stars": 24324
},
"autometrics-dev/autometrics-rs": {
"archived": false,
"forks": 32,
"issues": 14,
"lang": "Rust",
"license": "Apache-2.0",
"pushed": "2025-09-18T14:49:35Z",
"stars": 834
},
"backstage/backstage": {
"stars": 34559,
"forks": 7660,
"issues": 420,
"license": "Apache-2.0",
"lang": "TypeScript",
"pushed": "2026-10-03T18:53:42Z",
"archived": false
},
"beanstalkd/beanstalkd": {
"archived": false,
"forks": 866,
"issues": 42,
"lang": "C",
"license": null,
"pushed": "2025-03-18T15:40:18Z",
"stars": 6706
},
"bridgecrewio/checkov": {
"archived": false,
"forks": 1427,
"issues": 75,
"lang": "Python",
"license": "Apache-2.0",
"pushed": "2026-10-01T09:01:40Z",
"stars": 9053
},
"buildbot/buildbot": {
"archived": false,
"forks": 1679,
"issues": 699,
"lang": "Python",
"license": "GPL-2.0",
"pushed": "2026-09-28T13:58:35Z",
"stars": 5478
},
"cachethq/cachet": {
"archived": false,
"forks": 1629,
"issues": 6,
"lang": "PHP",
"license": null,
"pushed": "2026-09-28T13:12:41Z",
"stars": 15256
},
"caddyserver/caddy": {
"archived": false,
"forks": 5041,
"issues": 197,
"lang": "Go",
"license": "Apache-2.0",
"pushed": "2026-10-04T16:46:34Z",
"stars": 76455
},
"capistrano/capistrano": {
"archived": false,
"forks": 1739,
"issues": 59,
"lang": "Ruby",
"license": "MIT",
"pushed": "2026-07-19T03:53:28Z",
"stars": 13007
},
"celery/celery": {
"archived": false,
"forks": 5203,
"issues": 599,
"lang": "Python",
"license": null,
"pushed": "2026-10-04T15:01:03Z",
"stars": 28932
},
"ceph/ceph": {
"stars": 17092,
"forks": 6515,
"issues": 1643,
"license": null,
"lang": "C++",
"pushed": "2026-10-04T08:52:17Z",
"archived": false
},
"cert-manager/cert-manager": {
"archived": false,
"forks": 2460,
"issues": 160,
"lang": "Go",
"license": "Apache-2.0",
"pushed": "2026-10-04T11:32:48Z",
"stars": 14106
},
"certbot/certbot": {
"archived": false,
"forks": 3504,
"issues": 118,
"lang": "Python",
"license": null,
"pushed": "2026-09-30T18:52:09Z",
"stars": 33256
},
"chaos-mesh/chaos-mesh": {
"archived": false,
"forks": 1035,
"issues": 447,
"lang": "Go",
"license": "Apache-2.0",
"pushed": "2026-10-03T20:22:54Z",
"stars": 7929
},
"chaostoolkit/chaostoolkit": {
"archived": false,
"forks": 207,
"issues": 1,
"lang": "Python",
"license": "Apache-2.0",
"pushed": "2026-09-28T12:45:25Z",
"stars": 2031
},
"chef/chef": {
"stars": 8245,
"forks": 2517,
"issues": 418,
"license": "Apache-2.0",
"lang": "Ruby",
"pushed": "2026-10-01T22:28:10Z",
"archived": false
},
"cherokee/webserver": {
"archived": false,
"forks": 106,
"issues": 425,
"lang": "C",
"license": "GPL-2.0",
"pushed": "2023-01-11T20:34:30Z",
"stars": 569
},
"cilium/cilium": {
"archived": false,
"forks": 4124,
"issues": 841,
"lang": "Go",
"license": "Apache-2.0",
"pushed": "2026-10-04T18:07:04Z",
"stars": 25601
},
"cirruslabs/cirrus-ci-docs": {
"archived": false,
"forks": 118,
"issues": 99,
"lang": "Markdown",
"license": "MIT",
"pushed": "2026-04-07T10:39:21Z",
"stars": 384
},
"clawscli/claws": {
"archived": false,
"forks": 14,
"issues": 7,
"lang": "Go",
"license": "Apache-2.0",
"pushed": "2026-07-25T00:41:53Z",
"stars": 160
},
"cloudfoundry/bosh": {
"archived": false,
"forks": 663,
"issues": 25,
"lang": "Ruby",
"license": "Apache-2.0",
"pushed": "2026-10-03T12:17:26Z",
"stars": 2079
},
"cloudify-cosmo/cloudify-manager": {
"archived": false,
"forks": 79,
"issues": 5,
"lang": null,
"license": "Apache-2.0",
"pushed": "2024-08-12T13:16:13Z",
"stars": 154
},
"cloudius-systems/osv": {
"stars": 4263,
"forks": 609,
"issues": 387,
"license": null,
"lang": "C",
"pushed": "2026-08-17T16:19:20Z",
"archived": false
},
"collectd/collectd": {
"archived": false,
"forks": 1250,
"issues": 598,
"lang": "C",
"license": null,
"pushed": "2026-05-29T12:58:42Z",
"stars": 3368
},
"concourse/concourse": {
"archived": false,
"forks": 906,
"issues": 70,
"lang": "Go",
"license": "Apache-2.0",
"pushed": "2026-10-03T18:04:34Z",
"stars": 7913
},
"containers/podman": {
"stars": 32993,
"forks": 3396,
"issues": 1023,
"license": "Apache-2.0",
"lang": "Go",
"pushed": "2026-10-02T19:24:12Z",
"archived": false
},
"contribsys/faktory": {
"archived": false,
"forks": 241,
"issues": 22,
"lang": "Go",
"license": null,
"pushed": "2026-09-03T21:24:24Z",
"stars": 6150
},
"couchbase/couchbase-lite-core": {
"archived": false,
"forks": 74,
"issues": null,
"lang": null,
"license": null,
"pushed": "2026-09-25T05:42:47Z",
"stars": 264
},
"czhu12/canine": {
"stars": 2938,
"forks": 123,
"issues": 50,
"license": "Apache-2.0",
"lang": "Ruby",
"pushed": "2026-10-02T18:05:45Z",
"archived": false
},
"dagger/dagger": {
"archived": false,
"forks": 933,
"issues": 120,
"lang": "Go",
"license": "Apache-2.0",
"pushed": "2026-10-03T22:36:48Z",
"stars": 16315
},
"dcos/dcos": {
"stars": 2359,
"forks": 480,
"issues": 17,
"license": "Apache-2.0",
"lang": "Python",
"pushed": "2023-07-27T04:13:49Z",
"archived": false
},
"diggerhq/digger": {
"archived": false,
"forks": 612,
"issues": 421,
"lang": "Go",
"license": "MIT",
"pushed": "2026-09-30T16:56:09Z",
"stars": 5045
},
"distribworks/dkron": {
"archived": false,
"forks": 419,
"issues": 31,
"lang": "Go",
"license": "LGPL-3.0",
"pushed": "2026-09-28T15:03:24Z",
"stars": 4736
},
"docker/compose": {
"stars": 38284,
"forks": 5845,
"issues": 90,
"license": "Apache-2.0",
"lang": "Go",
"pushed": "2026-10-02T15:37:02Z",
"archived": false
},
"docker/swarm": {
"stars": 5726,
"forks": 1063,
"issues": 0,
"license": "Apache-2.0",
"lang": "Go",
"pushed": "2020-06-11T09:36:02Z",
"archived": true
},
"docsifyjs/docsify": {
"archived": false,
"forks": 5788,
"issues": 63,
"lang": "JavaScript",
"license": null,
"pushed": "2026-10-02T05:28:50Z",
"stars": 31544
},
"dokku/dokku": {
"stars": 32167,
"forks": 2082,
"issues": 31,
"license": "MIT",
"lang": "Go",
"pushed": "2026-10-01T19:05:54Z",
"archived": false
},
"earthly/earthly": {
"archived": false,
"forks": 461,
"issues": 694,
"lang": "Go",
"license": "MPL-2.0",
"pushed": "2025-07-16T19:42:23Z",
"stars": 12053
},
"elastic/elasticsearch": {
"archived": false,
"forks": 26111,
"issues": 4764,
"lang": "Java",
"license": "Trial",
"pushed": "2026-10-04T15:02:33Z",
"stars": 78191
},
"elastic/kibana": {
"archived": false,
"forks": 8631,
"issues": null,
"lang": "TypeScript",
"license": null,
"pushed": "2026-10-04T18:47:49Z",
"stars": 21305
},
"elastic/logstash": {
"archived": false,
"forks": 3496,
"issues": 1997,
"lang": "Java",
"license": null,
"pushed": "2026-10-02T18:51:09Z",
"stars": 14959
},
"element-hq/element-web": {
"archived": false,
"forks": 2784,
"issues": 3611,
"lang": "TypeScript",
"license": "AGPL-3.0",
"pushed": "2026-10-03T10:37:32Z",
"stars": 13540
},
"emissary-ingress/emissary": {
"archived": false,
"forks": 710,
"issues": 363,
"lang": "Go",
"license": "Apache-2.0",
"pushed": "2026-10-01T18:49:58Z",
"stars": 4525
},
"envoyproxy/envoy": {
"archived": false,
"forks": 5642,
"issues": 1604,
"lang": "C++",
"license": "Apache-2.0",
"pushed": "2026-10-04T18:58:16Z",
"stars": 29039
},
"erickochen/purple": {
"archived": false,
"forks": 36,
"issues": 4,
"lang": "Rust",
"license": "MIT",
"pushed": "2026-10-02T11:58:37Z",
"stars": 721
},
"etcd-io/etcd": {
"archived": false,
"forks": 10527,
"issues": 130,
"lang": "Go",
"license": "Apache-2.0",
"pushed": "2026-10-04T13:23:33Z",
"stars": 52323
},
"evergreen-ci/evergreen": {
"archived": false,
"forks": 161,
"issues": null,
"lang": "Go",
"license": null,
"pushed": "2026-10-02T22:09:30Z",
"stars": 449
},
"fabric/fabric": {
"archived": false,
"forks": 1953,
"issues": 444,
"lang": "Python",
"license": "BSD-2-Clause",
"pushed": "2026-04-10T01:51:57Z",
"stars": 15510
},
"facebook/docusaurus": {
"archived": false,
"forks": 10051,
"issues": 288,
"lang": "TypeScript",
"license": "MIT",
"pushed": "2026-10-02T11:46:32Z",
"stars": 66396
},
"facebook/rocksdb": {
"archived": false,
"forks": 6946,
"issues": 950,
"lang": "C++",
"license": "GPL-2.0",
"pushed": "2026-10-03T03:17:30Z",
"stars": 32163
},
"facette/facette": {
"archived": false,
"forks": 69,
"issues": 40,
"lang": null,
"license": "BSD-3-Clause",
"pushed": "2020-06-11T07:45:09Z",
"stars": 1158
},
"faiscadev/fakecloud": {
"stars": 740,
"forks": 48,
"issues": 11,
"license": "AGPL-3.0",
"lang": "Rust",
"pushed": "2026-10-04T17:31:17Z",
"archived": false
},
"firezone/firezone": {
"archived": false,
"forks": 463,
"issues": 295,
"lang": "Elixir",
"license": "Apache-2.0",
"pushed": "2026-10-04T14:57:19Z",
"stars": 9109
},
"flanksource/canary-checker": {
"archived": false,
"forks": 54,
"issues": 114,
"lang": null,
"license": "Apache-2.0",
"pushed": "2026-10-02T12:53:09Z",
"stars": 346
},
"fluent/fluentd": {
"archived": false,
"forks": 1402,
"issues": 126,
"lang": "Ruby",
"license": "Apache-2.0",
"pushed": "2026-10-02T02:46:10Z",
"stars": 13597
},
"fluxcd/flagger": {
"archived": false,
"forks": 807,
"issues": 319,
"lang": "Go",
"license": "Apache-2.0",
"pushed": "2026-09-01T14:22:26Z",
"stars": 5417
},
"fluxcd/flux2": {
"archived": false,
"forks": 792,
"issues": 203,
"lang": "Go",
"license": "Apache-2.0",
"pushed": "2026-10-02T16:15:24Z",
"stars": 8436
},
"freelan-developers/freelan": {
"archived": false,
"forks": 209,
"issues": 47,
"lang": "C++",
"license": null,
"pushed": "2020-03-23T19:44:37Z",
"stars": 1378
},
"getsentry/sentry": {
"archived": false,
"forks": 4901,
"issues": 1764,
"lang": "Python",
"license": null,
"pushed": "2026-10-03T20:50:50Z",
"stars": 45345
},
"getsops/sops": {
"archived": false,
"forks": 1089,
"issues": 377,
"lang": "Go",
"license": "MPL-2.0",
"pushed": "2026-09-21T20:03:16Z",
"stars": 23288
},
"gitblit-org/gitblit": {
"archived": false,
"forks": 670,
"issues": 237,
"lang": "Java",
"license": "Apache-2.0",
"pushed": "2025-06-14T17:21:24Z",
"stars": 2362
},
"gleicon/restmq": {
"archived": false,
"forks": 63,
"issues": 4,
"lang": null,
"license": null,
"pushed": "2015-05-25T15:48:03Z",
"stars": 558
},
"gluster/glusterfs": {
"stars": 5254,
"forks": 1106,
"issues": 326,
"license": "GPL-2.0",
"lang": "C",
"pushed": "2026-09-23T15:32:47Z",
"archived": false
},
"go-gitea/gitea": {
"archived": false,
"forks": 7218,
"issues": 2247,
"lang": "Go",
"license": "MIT",
"pushed": "2026-10-04T13:40:27Z",
"stars": 58295
},
"gocd/gocd": {
"archived": false,
"forks": 980,
"issues": 68,
"lang": "Java",
"license": "Apache-2.0",
"pushed": "2026-10-03T11:49:31Z",
"stars": 7432
},
"gogs/gogs": {
"archived": false,
"forks": 5074,
"issues": 945,
"lang": "Go",
"license": "MIT",
"pushed": "2026-09-12T20:27:31Z",
"stars": 47857
},
"goharbor/harbor": {
"stars": 29489,
"forks": 5371,
"issues": 933,
"license": "Apache-2.0",
"lang": "Go",
"pushed": "2026-10-04T19:08:09Z",
"archived": false
},
"golang/go": {
"archived": false,
"forks": 21295,
"issues": null,
"lang": "Go",
"license": "BSD-3-Clause",
"pushed": "2026-10-02T21:55:20Z",
"stars": 139237
},
"google/cadvisor": {
"archived": false,
"forks": 2493,
"issues": 41,
"lang": "Go",
"license": null,
"pushed": "2026-10-02T15:20:25Z",
"stars": 19465
},
"google/leveldb": {
"archived": false,
"forks": 8227,
"issues": 264,
"lang": "C++",
"license": "BSD-3-Clause",
"pushed": "2026-03-11T04:06:29Z",
"stars": 39470
},
"grafana/grafana": {
"archived": false,
"forks": 14817,
"issues": 2676,
"lang": "TypeScript",
"license": "AGPL-3.0",
"pushed": "2026-10-04T06:34:42Z",
"stars": 77071
},
"grafana/loki": {
"archived": false,
"forks": 4126,
"issues": 639,
"lang": "Go",
"license": "AGPL-3.0",
"pushed": "2026-10-04T18:40:31Z",
"stars": 28987
},
"grai-io/grai-core": {
"archived": false,
"forks": 20,
"issues": 5,
"lang": null,
"license": "MIT-0",
"pushed": "2025-04-01T19:47:54Z",
"stars": 317
},
"graphite-project/graphite-web": {
"archived": false,
"forks": 1254,
"issues": 14,
"lang": "JavaScript",
"license": "Apache-2.0",
"pushed": "2026-07-19T12:05:59Z",
"stars": 6124
},
"ha/doozerd": {
"archived": false,
"forks": 264,
"issues": 24,
"lang": null,
"license": "MIT",
"pushed": "2013-12-28T19:22:24Z",
"stars": 3249
},
"harness/drone": {
"archived": false,
"forks": 3410,
"issues": 99,
"lang": "Go",
"license": "Apache-2.0",
"pushed": "2026-10-02T22:26:50Z",
"stars": 38484
},
"hashicorp/consul": {
"archived": false,
"forks": 4622,
"issues": 1316,
"lang": "Go",
"license": null,
"pushed": "2026-10-01T14:29:43Z",
"stars": 30092
},
"hashicorp/nomad": {
"archived": false,
"forks": 2143,
"issues": 1507,
"lang": "Go",
"license": null,
"pushed": "2026-10-01T16:31:03Z",
"stars": 16986
},
"hashicorp/packer": {
"archived": false,
"forks": 3340,
"issues": 299,
"lang": "Go",
"license": null,
"pushed": "2026-09-18T10:01:37Z",
"stars": 15809
},
"hashicorp/serf": {
"archived": false,
"forks": 608,
"issues": 85,
"lang": "Go",
"license": "MPL-2.0",
"pushed": "2026-09-16T15:09:21Z",
"stars": 6077
},
"hashicorp/terraform": {
"archived": false,
"forks": 10640,
"issues": 1768,
"lang": "Go",
"license": null,
"pushed": "2026-10-02T15:38:37Z",
"stars": 49831
},
"hashicorp/vagrant": {
"archived": false,
"forks": 4394,
"issues": 673,
"lang": "Ruby",
"license": null,
"pushed": "2026-09-03T04:25:15Z",
"stars": 27212
},
"hashicorp/vault": {
"archived": false,
"forks": 4776,
"issues": 1170,
"lang": "Go",
"license": null,
"pushed": "2026-10-02T22:02:49Z",
"stars": 36340
},
"healthchecks/healthchecks": {
"archived": false,
"forks": 1017,
"issues": 54,
"lang": "Python",
"license": "BSD-3-Clause",
"pushed": "2026-10-02T14:13:35Z",
"stars": 10384
},
"hubotio/hubot": {
"archived": false,
"forks": 3707,
"issues": 4,
"lang": "JavaScript",
"license": "MIT",
"pushed": "2026-09-23T15:02:01Z",
"stars": 16794
},
"influxdata/influxdb": {
"archived": false,
"forks": 3717,
"issues": 2069,
"lang": "Rust",
"license": "Apache-2.0",
"pushed": "2026-09-18T13:43:20Z",
"stars": 31760
},
"integrity/integrity": {
"archived": true,
"forks": 167,
"issues": 8,
"lang": "Ruby",
"license": "MIT",
"pushed": "2015-11-24T03:49:48Z",
"stars": 666
},
"istio/istio": {
"archived": false,
"forks": 8383,
"issues": 389,
"lang": "Go",
"license": "Apache-2.0",
"pushed": "2026-10-04T02:52:15Z",
"stars": 38429
},
"jenkinsci/jenkins": {
"archived": false,
"forks": 9835,
"issues": 3426,
"lang": "Java",
"license": "MIT",
"pushed": "2026-10-04T15:55:17Z",
"stars": 26620
},
"jsdelivr/globalping-cli": {
"archived": false,
"forks": 26,
"issues": 2,
"lang": null,
"license": "MPL-2.0",
"pushed": "2026-09-17T14:35:05Z",
"stars": 288
},
"juju/juju": {
"stars": 2674,
"forks": 610,
"issues": 412,
"license": null,
"lang": "Go",
"pushed": "2026-10-02T13:55:53Z",
"archived": false
},
"k3s-io/k3s": {
"stars": 34120,
"forks": 2749,
"issues": 76,
"license": "Apache-2.0",
"lang": "Go",
"pushed": "2026-10-02T18:28:08Z",
"archived": false
},
"kamranahmedse/developer-roadmap": {
"archived": false,
"forks": 45026,
"issues": 2,
"lang": "TypeScript",
"license": null,
"pushed": "2026-10-02T09:00:46Z",
"stars": 368852
},
"kata-containers/kata-containers": {
"stars": 8876,
"forks": 1495,
"issues": 1184,
"license": "Apache-2.0",
"lang": "Rust",
"pushed": "2026-10-04T01:23:25Z",
"archived": false
},
"keephq/keep": {
"archived": false,
"forks": 1526,
"issues": 451,
"lang": "Python",
"license": null,
"pushed": "2026-09-28T07:11:17Z",
"stars": 12375
},
"keybase/client": {
"archived": false,
"forks": 1283,
"issues": 4044,
"lang": null,
"license": "BSD-3-Clause",
"pushed": "2026-10-02T19:11:06Z",
"stars": 9256
},
"kubernetes/kubernetes": {
"stars": 128282,
"forks": 46037,
"issues": 3168,
"license": "Apache-2.0",
"lang": "Go",
"pushed": "2026-10-04T11:42:22Z",
"archived": false
},
"kubestellar/kubestellar": {
"stars": 715,
"forks": 319,
"issues": 213,
"license": "Apache-2.0",
"lang": "Go",
"pushed": "2026-10-02T20:26:43Z",
"archived": false
},
"kubevela/kubevela": {
"archived": false,
"forks": 1070,
"issues": 164,
"lang": "Go",
"license": "Apache-2.0",
"pushed": "2026-09-29T16:21:42Z",
"stars": 7912
},
"linkerd/linkerd2": {
"archived": false,
"forks": 1380,
"issues": 186,
"lang": "Go",
"license": "Apache-2.0",
"pushed": "2026-10-02T16:24:26Z",
"stars": 11507
},
"litmuschaos/litmus": {
"archived": false,
"forks": 898,
"issues": 330,
"lang": "TypeScript",
"license": null,
"pushed": "2026-09-30T12:22:50Z",
"stars": 5728
},
"localstack/localstack": {
"stars": 65139,
"forks": 4806,
"issues": 0,
"license": null,
"lang": "Python",
"pushed": "2026-03-23T08:52:01Z",
"archived": true
},
"loft-sh/devpod": {
"stars": 15249,
"forks": 587,
"issues": 48,
"license": "MPL-2.0",
"lang": "Go",
"pushed": "2025-11-14T06:33:38Z",
"archived": false
},
"loft-sh/vcluster": {
"stars": 11330,
"forks": 611,
"issues": 170,
"license": "Apache-2.0",
"lang": "Go",
"pushed": "2026-10-04T02:45:22Z",
"archived": false
},
"lxc/lxc": {
"stars": 5266,
"forks": 1182,
"issues": 158,
"license": null,
"lang": "C",
"pushed": "2026-10-02T08:32:42Z",
"archived": false
},
"mattermost/mattermost": {
"archived": false,
"forks": 9035,
"issues": 614,
"lang": "TypeScript",
"license": null,
"pushed": "2026-10-04T09:01:13Z",
"stars": 39260
},
"meshery/meshery": {
"archived": false,
"forks": 3927,
"issues": 1219,
"lang": "JavaScript",
"license": "Apache-2.0",
"pushed": "2026-10-04T07:10:49Z",
"stars": 11898
},
"metalbear-co/mirrord": {
"archived": false,
"forks": 219,
"issues": 48,
"lang": null,
"license": "MIT",
"pushed": "2026-10-03T12:39:39Z",
"stars": 5355
},
"mina-deploy/mina": {
"archived": false,
"forks": 478,
"issues": 32,
"lang": "Ruby",
"license": null,
"pushed": "2023-10-03T13:37:01Z",
"stars": 4353
},
"minio/minio": {
"stars": 61341,
"forks": 8097,
"issues": 80,
"license": "AGPL-3.0",
"lang": "Go",
"pushed": "2026-04-24T17:54:39Z",
"archived": true
},
"mkdocs/mkdocs": {
"archived": false,
"forks": 2654,
"issues": 120,
"lang": "Python",
"license": "BSD-2-Clause",
"pushed": "2025-10-20T13:17:06Z",
"stars": 22490
},
"moby/moby": {
"stars": 72146,
"forks": 19235,
"issues": 3923,
"license": "Apache-2.0",
"lang": "Go",
"pushed": "2026-10-03T16:25:36Z",
"archived": false
},
"mongodb/mongo": {
"archived": false,
"forks": 5817,
"issues": null,
"lang": "C++",
"license": null,
"pushed": "2026-10-02T21:34:39Z",
"stars": 28614
},
"mozilla-services/heka": {
"archived": true,
"forks": 514,
"issues": 219,
"lang": null,
"license": null,
"pushed": "2024-01-23T00:09:27Z",
"stars": 3389
},
"mysql/mysql-server": {
"archived": false,
"forks": 4364,
"issues": 33,
"lang": "C++",
"license": null,
"pushed": "2026-09-28T09:55:17Z",
"stars": 12441
},
"naemon/naemon-core": {
"archived": false,
"forks": 68,
"issues": 46,
"lang": null,
"license": "GPL-2.0",
"pushed": "2026-10-01T15:22:23Z",
"stars": 173
},
"nats-io/nats-server": {
"archived": false,
"forks": 1987,
"issues": 449,
"lang": "Go",
"license": "Apache-2.0",
"pushed": "2026-10-02T14:50:16Z",
"stars": 20835
},
"navig-me/telert": {
"archived": false,
"forks": 19,
"issues": 2,
"lang": "Python",
"license": "MIT",
"pushed": "2026-09-29T01:42:14Z",
"stars": 287
},
"netdata/netdata": {
"archived": false,
"forks": 6648,
"issues": 201,
"lang": "C",
"license": "GPL-3.0",
"pushed": "2026-10-04T18:44:07Z",
"stars": 80790
},
"nginx/nginx": {
"archived": false,
"forks": 8312,
"issues": 193,
"lang": "C",
"license": "BSD-2-Clause",
"pushed": "2026-09-30T16:17:54Z",
"stars": 31788
},
"nicolargo/glances": {
"archived": false,
"forks": 1822,
"issues": 91,
"lang": "Python",
"license": null,
"pushed": "2026-10-03T19:38:53Z",
"stars": 33733
},
"nsqio/nsq": {
"archived": false,
"forks": 2885,
"issues": 54,
"lang": "Go",
"license": "MIT",
"pushed": "2026-08-11T18:19:49Z",
"stars": 25771
},
"octodns/octodns": {
"archived": false,
"forks": 444,
"issues": 3,
"lang": "Python",
"license": "MIT",
"pushed": "2026-09-26T17:14:26Z",
"stars": 3770
},
"openchoreo/openchoreo": {
"stars": 1624,
"forks": 259,
"issues": 246,
"license": "Apache-2.0",
"lang": "Go",
"pushed": "2026-10-03T06:07:53Z",
"archived": false
},
"openshift/origin": {
"stars": 8693,
"forks": 4804,
"issues": 329,
"license": "Apache-2.0",
"lang": "Go",
"pushed": "2026-10-02T03:13:41Z",
"archived": false
},
"openstack/openstack": {
"stars": 6050,
"forks": 1622,
"issues": 1,
"license": "Apache-2.0",
"lang": "Python",
"pushed": "2026-10-04T18:58:42Z",
"archived": false
},
"orbstack/orbstack": {
"stars": 9389,
"forks": 108,
"issues": 431,
"license": "MIT",
"lang": "Shell",
"pushed": "2025-08-15T13:03:07Z",
"archived": false
},
"performancecopilot/pcp": {
"archived": false,
"forks": 272,
"issues": 169,
"lang": null,
"license": null,
"pushed": "2026-10-04T02:15:48Z",
"stars": 1077
},
"phacility/phabricator": {
"archived": false,
"forks": 1630,
"issues": null,
"lang": "PHP",
"license": "Apache-2.0",
"pushed": "2023-11-13T19:04:04Z",
"stars": 12292
},
"piku/piku": {
"stars": 6604,
"forks": 158,
"issues": 6,
"license": "MIT",
"lang": "Python",
"pushed": "2026-09-04T06:40:06Z",
"archived": false
},
"pipe-cd/pipecd": {
"archived": false,
"forks": 368,
"issues": 155,
"lang": "Go",
"license": "Apache-2.0",
"pushed": "2026-10-04T08:11:59Z",
"stars": 1361
},
"postgres/postgres": {
"archived": false,
"forks": 5931,
"issues": null,
"lang": "C",
"license": null,
"pushed": "2026-10-04T14:46:08Z",
"stars": 22278
},
"potpie-ai/potpie": {
"archived": false,
"forks": 685,
"issues": 23,
"lang": "Python",
"license": "Apache-2.0",
"pushed": "2026-09-28T09:24:18Z",
"stars": 5735
},
"pritunl/pritunl": {
"archived": false,
"forks": 666,
"issues": null,
"lang": "Python",
"license": null,
"pushed": "2026-09-29T22:06:36Z",
"stars": 5030
},
"prometheus/prometheus": {
"archived": false,
"forks": 10886,
"issues": 496,
"lang": "Go",
"license": "Apache-2.0",
"pushed": "2026-10-03T13:33:50Z",
"stars": 66359
},
"pulumi/pulumi": {
"archived": false,
"forks": 1444,
"issues": 2185,
"lang": "Go",
"license": "Apache-2.0",
"pushed": "2026-10-03T09:29:47Z",
"stars": 25761
},
"puppetlabs/puppet": {
"stars": 7945,
"forks": 2204,
"issues": 90,
"license": "Apache-2.0",
"lang": "Ruby",
"pushed": "2026-08-06T13:05:18Z",
"archived": false
},
"pyenv/pyenv": {
"archived": false,
"forks": 3273,
"issues": 47,
"lang": "Shell",
"license": "MIT",
"pushed": "2026-10-03T15:51:15Z",
"stars": 45124
},
"python/cpython": {
"archived": false,
"forks": 37340,
"issues": null,
"lang": "Python",
"license": null,
"pushed": "2026-10-03T23:51:37Z",
"stars": 77487
},
"quay/quay": {
"stars": 2827,
"forks": 390,
"issues": 396,
"license": "Apache-2.0",
"lang": "Python",
"pushed": "2026-10-04T05:21:37Z",
"archived": false
},
"rabbitmq/rabbitmq-server": {
"archived": false,
"forks": 4026,
"issues": 205,
"lang": "Erlang",
"license": "Apache-2.0",
"pushed": "2026-10-03T03:50:22Z",
"stars": 13900
},
"rancher/rancher": {
"stars": 25955,
"forks": 3222,
"issues": 3389,
"license": "Apache-2.0",
"lang": "Go",
"pushed": "2026-10-03T07:10:30Z",
"archived": false
},
"rapidforge-io/rapidforge": {
"archived": false,
"forks": 1,
"issues": 13,
"lang": "Go",
"license": "Apache-2.0",
"pushed": "2026-09-14T20:00:28Z",
"stars": 44
},
"redis/redis": {
"archived": false,
"forks": 24833,
"issues": 2276,
"lang": "C",
"license": null,
"pushed": "2026-09-30T12:02:11Z",
"stars": 76582
},
"rethinkdb/rethinkdb": {
"archived": false,
"forks": 1851,
"issues": 1342,
"lang": "C++",
"license": null,
"pushed": "2026-03-28T06:10:59Z",
"stars": 27007
},
"reviewboard/reviewboard": {
"archived": false,
"forks": 436,
"issues": null,
"lang": "Python",
"license": "MIT",
"pushed": "2026-10-02T23:12:28Z",
"stars": 1726
},
"ricoberger/vault-secrets-operator": {
"archived": false,
"forks": 109,
"issues": 16,
"lang": "Go",
"license": "MIT",
"pushed": "2026-08-13T04:42:43Z",
"stars": 687
},
"robcowart/elastiflow": {
"archived": true,
"forks": 598,
"issues": 1,
"lang": null,
"license": null,
"pushed": "2024-03-22T22:03:12Z",
"stars": 2510
},
"robusta-dev/holmesgpt": {
"archived": false,
"forks": 513,
"issues": 133,
"lang": "Python",
"license": "Apache-2.0",
"pushed": "2026-10-04T15:52:55Z",
"stars": 3506
},
"ruby/ruby": {
"archived": false,
"forks": 5654,
"issues": null,
"lang": "Ruby",
"license": null,
"pushed": "2026-10-04T18:34:46Z",
"stars": 23771
},
"runatlantis/atlantis": {
"archived": false,
"forks": 1355,
"issues": 760,
"lang": "Go",
"license": "Apache-2.0",
"pushed": "2026-10-04T02:12:01Z",
"stars": 9308
},
"rundeck/rundeck": {
"stars": 6325,
"forks": 987,
"issues": 60,
"license": "Apache-2.0",
"lang": "Groovy",
"pushed": "2026-10-03T19:02:21Z",
"archived": false
},
"saltstack/salt": {
"stars": 15688,
"forks": 5607,
"issues": 1878,
"license": "Apache-2.0",
"lang": "Python",
"pushed": "2026-10-03T21:19:54Z",
"archived": false
},
"score-spec/spec": {
"archived": false,
"forks": 2141,
"issues": 11,
"lang": "Go",
"license": "Apache-2.0",
"pushed": "2026-07-20T01:53:53Z",
"stars": 8097
},
"scylladb/scylladb": {
"archived": false,
"forks": 1525,
"issues": 3068,
"lang": "C++",
"license": null,
"pushed": "2026-10-04T09:40:46Z",
"stars": 15782
},
"selefra/selefra": {
"archived": false,
"forks": 47,
"issues": 0,
"lang": "Go",
"license": "MPL-2.0",
"pushed": "2023-08-30T04:35:06Z",
"stars": 545
},
"semaphoreio/semaphore": {
"archived": false,
"forks": 94,
"issues": 114,
"lang": "Elixir",
"license": null,
"pushed": "2026-10-02T15:24:34Z",
"stars": 1612
},
"sensu/sensu-go": {
"archived": false,
"forks": 180,
"issues": 252,
"lang": "Go",
"license": "MIT",
"pushed": "2025-07-10T13:56:17Z",
"stars": 1113
},
"shinken-solutions/shinken": {
"archived": false,
"forks": 323,
"issues": 211,
"lang": null,
"license": "AGPL-3.0",
"pushed": "2024-04-26T08:16:18Z",
"stars": 1134
},
"soapbucket/sbproxy": {
"archived": false,
"forks": 1,
"issues": 1,
"lang": "Go",
"license": "Apache-2.0",
"pushed": "2026-09-11T16:55:09Z",
"stars": 53
},
"sobolevn/git-secret": {
"archived": false,
"forks": 213,
"issues": 137,
"lang": "Shell",
"license": "MIT",
"pushed": "2026-09-28T17:34:12Z",
"stars": 4048
},
"solo-io/gloo": {
"archived": false,
"forks": 12,
"issues": 1860,
"lang": "Go",
"license": null,
"pushed": "2026-09-19T04:26:03Z",
"stars": 170
},
"spinnaker/spinnaker": {
"archived": false,
"forks": 1273,
"issues": 73,
"lang": "Java",
"license": "Apache-2.0",
"pushed": "2026-10-02T21:34:58Z",
"stars": 9799
},
"sqlite/sqlite": {
"archived": false,
"forks": 1680,
"issues": null,
"lang": "C",
"license": null,
"pushed": "2026-10-04T16:23:01Z",
"stars": 10596
},
"sshuttle/sshuttle": {
"archived": false,
"forks": 795,
"issues": 210,
"lang": "Python",
"license": "LGPL-2.1",
"pushed": "2026-09-28T22:38:03Z",
"stars": 13594
},
"sylabs/singularity": {
"stars": 995,
"forks": 121,
"issues": 42,
"license": null,
"lang": "Go",
"pushed": "2026-10-02T19:06:17Z",
"archived": false
},
"syntasso/kratix": {
"stars": 779,
"forks": 63,
"issues": 72,
"license": "Apache-2.0",
"lang": "Go",
"pushed": "2026-10-02T16:25:57Z",
"archived": false
},
"tektoncd/pipeline": {
"archived": false,
"forks": 1965,
"issues": 451,
"lang": "Go",
"license": "Apache-2.0",
"pushed": "2026-10-02T09:25:17Z",
"stars": 9075
},
"terrateamio/terrateam": {
"archived": false,
"forks": 81,
"issues": 110,
"lang": "OCaml",
"license": "MPL-2.0",
"pushed": "2026-10-04T13:28:44Z",
"stars": 1289
},
"tfutils/tfenv": {
"archived": false,
"forks": 469,
"issues": 26,
"lang": "Shell",
"license": null,
"pushed": "2026-04-28T18:24:13Z",
"stars": 4977
},
"theforeman/foreman": {
"archived": false,
"forks": 1051,
"issues": null,
"lang": "Ruby",
"license": "GPL-3.0",
"pushed": "2026-10-02T00:56:33Z",
"stars": 2958
},
"tofuutils/tenv": {
"archived": false,
"forks": 80,
"issues": 30,
"lang": "Go",
"license": "Apache-2.0",
"pushed": "2026-09-01T07:37:25Z",
"stars": 1446
},
"traefik/traefik": {
"archived": false,
"forks": 6222,
"issues": 687,
"lang": "Go",
"license": "MIT",
"pushed": "2026-09-29T14:23:55Z",
"stars": 65065
},
"trailofbits/algo": {
"archived": false,
"forks": 2366,
"issues": 74,
"lang": "Jinja",
"license": "AGPL-3.0",
"pushed": "2026-08-26T21:44:50Z",
"stars": 30408
},
"tsuru/tsuru": {
"archived": false,
"forks": 552,
"issues": 1,
"lang": "Go",
"license": "BSD-3-Clause",
"pushed": "2026-09-30T11:35:41Z",
"stars": 5313
},
"turbot/steampipe": {
"archived": false,
"forks": 342,
"issues": 13,
"lang": "Go",
"license": "AGPL-3.0",
"pushed": "2026-09-29T08:30:06Z",
"stars": 7972
},
"txn2/kubefwd": {
"archived": false,
"forks": 238,
"issues": 0,
"lang": "Go",
"license": "Apache-2.0",
"pushed": "2026-10-03T16:58:37Z",
"stars": 4172
},
"unbit/uwsgi": {
"archived": false,
"forks": 695,
"issues": 796,
"lang": "C",
"license": null,
"pushed": "2025-10-11T19:11:09Z",
"stars": 3547
},
"vmware/photon": {
"stars": 3178,
"forks": 692,
"issues": 248,
"license": null,
"lang": "C",
"pushed": "2026-10-01T06:26:39Z",
"archived": false
},
"vyos/vyos-1x": {
"archived": false,
"forks": 466,
"issues": null,
"lang": "Python",
"license": "LGPL-2.1",
"pushed": "2026-10-03T16:01:28Z",
"stars": 496
},
"weaveworks/ignite": {
"archived": true,
"forks": 235,
"issues": 142,
"lang": "Go",
"license": "Apache-2.0",
"pushed": "2023-12-07T17:28:47Z",
"stars": 3530
},
"werf/werf": {
"archived": false,
"forks": 240,
"issues": 18,
"lang": "Go",
"license": "Apache-2.0",
"pushed": "2026-10-02T08:41:25Z",
"stars": 4728
},
"wmariuss/awesome-devops": {
"archived": false,
"forks": 1024,
"issues": 13,
"lang": null,
"license": "CC0-1.0",
"pushed": "2026-09-20T21:04:15Z",
"stars": 4407
},
"xtreemfs/xtreemfs": {
"stars": 348,
"forks": 65,
"issues": 69,
"license": null,
"lang": "Java",
"pushed": "2024-10-07T15:46:16Z",
"archived": false
},
"zabbix/zabbix": {
"archived": false,
"forks": 1265,
"issues": null,
"lang": "C",
"license": "AGPL-3.0",
"pushed": "2026-10-04T05:52:40Z",
"stars": 6435
},
"zifeo/lade": {
"archived": false,
"forks": 6,
"issues": 0,
"lang": "Rust",
"license": "MPL-2.0",
"pushed": "2026-10-03T12:40:33Z",
"stars": 133
},
"zulip/zulip": {
"archived": false,
"forks": 10349,
"issues": 1172,
"lang": "Python",
"license": null,
"pushed": "2026-10-03T00:17:28Z",
"stars": 25994
}
}
}

File: website/src/data/learn-topics.json

{
"https://sre.google/sre-book/table-of-contents/": [
"obs",
"automation",
"chaos"
],
"https://sre.google/workbook/table-of-contents/": [
"obs",
"cicd",
"automation"
],
"https://google.github.io/building-secure-and-reliable-systems/raw/toc.html": [
"security",
"secrets"
],
"https://www.oreilly.com/library/view/the-devops-handbook/9781457191381/": [
"cicd",
"automation"
],
"http://shop.oreilly.com/product/0636920039846.do": [
"chat",
"productivity"
],
"https://www.oreilly.com/library/view/continuous-delivery-reliable/9780321670250/": [
"cicd",
"scm"
],
"http://shop.oreilly.com/product/0636920039297.do": [
"automation",
"cloud"
],
"https://www.fundamentals-of-devops.com/": [
"automation",
"cicd",
"cloud",
"apps"
],
"https://roadmap.sh/devops": [
"cloud",
"apps",
"cicd",
"obs",
"automation"
],
"https://devopsroadmap.io": [
"apps",
"cicd",
"cloud"
],
"https://play.meshery.io": [
"apps",
"mesh",
"obs"
],
"https://devopscon.io/": [
"cicd",
"apps",
"cloud"
],
"https://reinvent.awsevents.com/": [
"cloud"
],
"https://www.alldaydevops.com/": [
"cicd",
"security",
"obs"
],
"https://www.devopsconnect.com/": [
"security",
"cicd"
],
"https://atscaleconference.com/": [
"db",
"msg",
"obs"
],
"https://devopsdays.org/": [
"chat",
"cicd",
"automation"
],
"https://events.itrevolution.com/": [
"cicd",
"automation"
],
"https://medium.com/?tag=devops": [
"cicd",
"automation",
"cloud",
"obs"
]
}

File: website/src/data/repos-auto.json

{
"http://bolo.niftylogic.com/": {
"repo": null,
"checked": "2026-10-04"
},
"http://coreos.com/": {
"repo": null,
"checked": "2026-10-04"
},
"http://www.lighttpd.net/": {
"repo": null,
"checked": "2026-10-04"
},
"http://www.projectatomic.io/": {
"repo": null,
"checked": "2026-10-04"
},
"https://gitlab.com/": {
"repo": null,
"checked": "2026-10-04"
},
"https://letsencrypt.org/": {
"repo": null,
"checked": "2026-10-04"
},
"https://mmonit.com/monit/#home": {
"repo": null,
"checked": "2026-10-04"
},
"https://openvz.org/": {
"repo": null,
"checked": "2026-10-04"
},
"https://radicle.xyz/": {
"repo": null,
"checked": "2026-10-04"
},
"https://rhodecode.com/": {
"repo": null,
"checked": "2026-10-04"
},
"https://ubuntu.com/": {
"repo": null,
"checked": "2026-10-04"
},
"https://www.eucalyptus.cloud/": {
"repo": null,
"checked": "2026-10-04"
},
"https://www.gerritcodereview.com/": {
"repo": null,
"checked": "2026-10-04"
},
"https://zuul-ci.org/": {
"repo": null,
"checked": "2026-10-04"
}
}

File: website/src/data/repos.json

{
"http://activemq.apache.org/": "apache/activemq",
"http://buildbot.net/": "buildbot/buildbot",
"http://cassandra.apache.org/": "apache/cassandra",
"http://cherokee-project.com/": "cherokee/webserver",
"http://hbase.apache.org/": "apache/hbase",
"http://httpd.apache.org/": "apache/httpd",
"http://integrity.github.io/": "integrity/integrity",
"http://jenkins-ci.org/": "jenkinsci/jenkins",
"http://kafka.apache.org/": "apache/kafka",
"http://mesos.apache.org/": "apache/mesos",
"http://nadarei.co/mina/": "mina-deploy/mina",
"http://nginx.org/": "nginx/nginx",
"http://osv.io/": "cloudius-systems/osv",
"http://restmq.com/": "gleicon/restmq",
"http://www.celeryproject.org/": "celery/celery",
"http://www.fabfile.org/": "fabric/fabric",
"http://www.naemon.org/": "naemon/naemon-core",
"http://www.xtreemfs.org/": "xtreemfs/xtreemfs",
"http://zookeeper.apache.org/": "apache/zookeeper",
"https://about.riot.im/": "element-hq/element-web",
"https://argoproj.github.io/": "argoproj/argo-cd",
"https://autometrics.dev/": "autometrics-dev/autometrics-rs",
"https://backstage.io/": "backstage/backstage",
"https://beanstalkd.github.io/": "beanstalkd/beanstalkd",
"https://caddyserver.com/": "caddyserver/caddy",
"https://canarychecker.io": "flanksource/canary-checker",
"https://canine.sh/": "czhu12/canine",
"https://capistranorb.com/": "capistrano/capistrano",
"https://ceph.io/en/": "ceph/ceph",
"https://cloudify.co/": "cloudify-cosmo/cloudify-manager",
"https://cloudstack.apache.org/": "apache/cloudstack",
"https://concourse-ci.org/": "concourse/concourse",
"https://console.kubestellar.io/": "kubestellar/kubestellar",
"https://couchdb.apache.org/": "apache/couchdb",
"https://dagger.io/": "dagger/dagger",
"https://dcos.io/": "dcos/dcos",
"https://devopsroadmap.io": "DevOpsHiveHQ/devops-hive",
"https://devpod.sh/": "loft-sh/devpod",
"https://digger.dev": "diggerhq/digger",
"https://dokku.com/": "dokku/dokku",
"https://earthly.dev/": "earthly/earthly",
"https://etcd.io/": "etcd-io/etcd",
"https://flume.apache.org/": "apache/flume",
"https://gitea.io/": "go-gitea/gitea",
"https://github.com/CachetHQ/Cachet": "cachethq/cachet",
"https://github.com/chaostoolkit": "chaostoolkit/chaostoolkit",
"https://github.com/drone/drone": "harness/drone",
"https://github.com/fluxcd/flux": "fluxcd/flux2",
"https://github.com/gitblit/gitblit": "gitblit-org/gitblit",
"https://github.com/github/octodns": "octodns/octodns",
"https://github.com/jetstack/cert-manager": "cert-manager/cert-manager",
"https://github.com/mozilla/sops": "getsops/sops",
"https://github.com/weaveworks/flagger": "fluxcd/flagger",
"https://gogs.io/": "gogs/gogs",
"https://goharbor.io/": "goharbor/harbor",
"https://golang.org/": "golang/go",
"https://grafana.com/": "grafana/grafana",
"https://graphite.readthedocs.io/en/latest/": "graphite-project/graphite-web",
"https://hekad.readthedocs.io/en/latest/#": "mozilla-services/heka",
"https://hubot.github.com/": "hubotio/hubot",
"https://icinga.com/": "Icinga/icinga2",
"https://istio.io/": "istio/istio",
"https://jaas.ai/": "juju/juju",
"https://k3s.io/": "k3s-io/k3s",
"https://katacontainers.io/": "kata-containers/kata-containers",
"https://keybase.io/": "keybase/client",
"https://konghq.com/": "Kong/kong",
"https://kraken.ci/": "Kraken-CI/kraken",
"https://kratix.io/": "syntasso/kratix",
"https://kubernetes.io/": "kubernetes/kubernetes",
"https://kubevela.io/": "kubevela/kubevela",
"https://learn.hashicorp.com/nomad": "hashicorp/nomad",
"https://linuxcontainers.org/": "lxc/lxc",
"https://mariadb.org/": "MariaDB/server",
"https://mattermost.com/": "mattermost/mattermost",
"https://meshery.io": "meshery/meshery",
"https://meshery.io/": "meshery/meshery",
"https://metalbear.com/mirrord/": "metalbear-co/mirrord",
"https://min.io/": "minio/minio",
"https://nats.io/": "nats-io/nats-server",
"https://nixos.org/": "NixOS/nixpkgs",
"https://nsq.io/": "nsqio/nsq",
"https://openchoreo.dev/": "openchoreo/openchoreo",
"https://opennebula.org/": "OpenNebula/one",
"https://openvpn.net/": "OpenVPN/openvpn",
"https://pcp.io/": "performancecopilot/pcp",
"https://pipecd.dev/": "pipe-cd/pipecd",
"https://potpie.ai": "potpie-ai/potpie",
"https://pritunl.com/": "pritunl/pritunl",
"https://prometheus.io/": "prometheus/prometheus",
"https://puppet.com/": "puppetlabs/puppet",
"https://rancher.com/": "rancher/rancher",
"https://rapidforge.io/": "rapidforge-io/rapidforge",
"https://redis.io/": "redis/redis",
"https://roadmap.sh/devops": "kamranahmedse/developer-roadmap",
"https://rocket.chat/": "RocketChat/Rocket.Chat",
"https://rocksdb.org/": "facebook/rocksdb",
"https://rockylinux.org/": null,
"https://saltproject.io/": "saltstack/salt",
"https://score.dev": "score-spec/spec",
"https://sensu.io/": "sensu/sensu-go",
"https://sentry.io/welcome/": "getsentry/sentry",
"https://sqlite.org/": "sqlite/sqlite",
"https://stackstorm.com/": "StackStorm/st2",
"https://steampipe.io/": "turbot/steampipe",
"https://strider-cd.github.io/": "Strider-CD/strider",
"https://sylabs.io/singularity/": "sylabs/singularity",
"https://tekton.dev/": "tektoncd/pipeline",
"https://terrateam.io": "terrateamio/terrateam",
"https://theforeman.org/": "theforeman/foreman",
"https://traefik.io/": "traefik/traefik",
"https://tsuru.io/": "tsuru/tsuru",
"https://tyk.io/": "TykTechnologies/tyk",
"https://vcluster.sh/": "loft-sh/vcluster",
"https://vyos.io/": "vyos/vyos-1x",
"https://werf.io/": "werf/werf",
"https://www.ansible.com/": "ansible/ansible",
"https://www.chef.io/": "chef/chef",
"https://www.cloudfoundry.org/bosh/": "cloudfoundry/bosh",
"https://www.couchbase.com/": "couchbase/couchbase-lite-core",
"https://www.docker.com/": "moby/moby",
"https://www.elastic.co/elasticsearch": "elastic/elasticsearch",
"https://www.elastic.co/kibana": "elastic/kibana",
"https://www.elastic.co/logstash": "elastic/logstash",
"https://www.envoyproxy.io/": "envoyproxy/envoy",
"https://www.firezone.dev/": "firezone/firezone",
"https://www.fluentd.org/": "fluent/fluentd",
"https://www.getambassador.io/": "emissary-ingress/emissary",
"https://www.getunleash.io": "Unleash/unleash",
"https://www.gluster.org/": "gluster/glusterfs",
"https://www.gocd.org/": "gocd/gocd",
"https://www.hashicorp.com/products/consul/": "hashicorp/consul",
"https://www.hashicorp.com/products/vault/": "hashicorp/vault",
"https://www.influxdata.com/": "influxdata/influxdb",
"https://www.linbit.com/en/": "LINBIT/drbd",
"https://www.manageiq.org/": "ManageIQ/manageiq",
"https://www.mongodb.com/": "mongodb/mongo",
"https://www.mysql.com/": "mysql/mysql-server",
"https://www.nagios.org/": "NagiosEnterprises/nagioscore",
"https://www.netdata.cloud/": "netdata/netdata",
"https://www.openshift.com/": "openshift/origin",
"https://www.openstack.org/": "openstack/openstack",
"https://www.packer.io/": "hashicorp/packer",
"https://www.postgresql.org/": "postgres/postgres",
"https://www.projectquay.io/": "quay/quay",
"https://www.pulumi.com/": "pulumi/pulumi",
"https://www.python.org/": "python/cpython",
"https://www.qovery.com/": "Qovery/engine",
"https://www.rabbitmq.com/": "rabbitmq/rabbitmq-server",
"https://www.reviewboard.org/": "reviewboard/reviewboard",
"https://www.ruby-lang.org/": "ruby/ruby",
"https://www.runatlantis.io/": "runatlantis/atlantis",
"https://www.rundeck.com/": "rundeck/rundeck",
"https://www.scylladb.com/": "scylladb/scylladb",
"https://www.serf.io/": "hashicorp/serf",
"https://www.siderolabs.com/talos-linux": "siderolabs/talos",
"https://www.softether.org/": "SoftEtherVPN/SoftEtherVPN",
"https://www.spinnaker.io/": "spinnaker/spinnaker",
"https://www.terraform.io/": "hashicorp/terraform",
"https://www.vagrantup.com/": "hashicorp/vagrant",
"https://www.zabbix.com/": "zabbix/zabbix",
"https://zulipchat.com/": "zulip/zulip"
}

File: README.md Copy Chapter

Awesome DevOps

Contents Copy Chapter

Cloud Platforms Copy Chapter

Open Source Cloud Platforms Copy Chapter

Operating Systems Copy Chapter

Package Management & System Configuration Copy Chapter

Distributed Filesystems Copy Chapter

Applications Platforms Copy Chapter

Internal Developer Platforms Copy Chapter

Container Image Registry Copy Chapter

Automation & Orchestration Copy Chapter

Productivity Tools Copy Chapter

Terminal Copy Chapter

Continuous Integration & Delivery Copy Chapter

Source Code Management Copy Chapter

Web Servers Copy Chapter

SSL Copy Chapter

Databases Copy Chapter

Observability & Monitoring Copy Chapter

Service Discovery & Service Mesh Copy Chapter

Chaos Engineering Copy Chapter

API Gateway Copy Chapter

Code review Copy Chapter

Distributed Messaging Copy Chapter

Programming Languages Copy Chapter

Chat and ChatOps Copy Chapter

Secret Management Copy Chapter

Security Copy Chapter

Sharing Copy Chapter

VPN Copy Chapter

Resources Copy Chapter

Books Copy Section

Conferences Copy Section

Blogs Copy Section

DevOps Roadmap Copy Section

Online Platforms Copy Section

Contributing Copy Chapter

File: CONTRIBUTING.md Copy Chapter

Contribute

Before you add a tool Copy Chapter

Add a tool Copy Chapter

Writing the entry Copy Chapter

Pricing tags Copy Chapter

GitHub stars and activity Copy Chapter

Preview the website locally Copy Chapter

File: website/README.md Copy Chapter