Kubernetes controllers are control loops that track your resource clusters and alter them to match the desired state in a continuous cycle. For example, if you need to roast a chicken at 400 degrees Fahrenheit, the control loop in this case would monitor the oven temperature to keep it as close to your desired temperature as possible. If the temperature goes below or above 400, the control loop automatically adjusts the oven controls to fix it.

This is exactly how Kubernetes controllers work — they monitor the resources and conditions an admin has requested in a desired state and implement them automatically. Controllers ensure that the desired and actual states are in constant alignment. 

Kubernetes controllers perform various functions to observe, maintain, and enforce the desired state of resources within a Kubernetes cluster. The key functions of a controller include:

• - **Cluster observation** — Controllers continuously watch for state changes in the resource cluster, allowing for timely responses from admins or infrastructure teams.
• - **Desired state enforcement **— Controllers compare conditions of the admin’s desired state with the current state of the resource cluster and automatically make changes to enforce the desired state. 
• - **Resource limit enforcement** — Controllers enforce limits on resources used in a namespace to prevent overuse.
• - **Defined schedule** — Controllers run Jobs on a schedule defined by the user. 
• - **Event processing** — Controllers process lifecycle events and trigger responses, such as automatically restarting pods upon failure.
• - **Cluster health maintenance** — Node controllers detect and manage unhealthy nodes, while endpoint controllers maintain up-to-date endpoint objects for service discovery.
• - **Rollouts and rollbacks** — Deployment controllers provide rollout management of deployments and carry out rollbacks to previous versions.

Kubernetes controllers automate routine cluster operations, enforce policies, react to failures, and strive to continuously reconcile the actual state to match the user's desired configuration.

Kubernetes controllers have several key use cases for managing and operating applications and resources within a cluster:

• - **Scale a front-end web application **— Ensure you always have enough pod replicas running that can handle increasing user traffic to a web app. Controllers such as ReplicaSet will automatically create new pods as needed.
• - **Run a managed database** — Deploy and manage a stateful database and maintain a stable network ID as pods are restarted or moved with a controller like StatefulSet.
• - **Batch data processing **— Run pods to completion for batch jobs and ensure that failed pods are re-run. This use case works particularly well in a machine learning training or analytics pipeline setting.
• - **Maintain a set of pods** — ​​Ensure that sets of multiple identical pods are running at any given time. 
• - **Schedule tasks** — Run pods on a user-defined schedule with specific tasks using a controller like CronJob.
• - **Auto-scale deployments **— Scale deployments and replica sets based on different metrics and automatically adjust pod replicas with the HorizontalPodAutoscaler controller.
• - **Limit resource usage** — Limit resource usage and prevent overload with a controller like ResourceQuota.

Essentially, Kubernetes controllers automate operations to deploy, scale, heal, and enforce policies for applications while maximizing cluster utilization. This reduces manual effort for platform teams and adds self-managing capabilities to Kubernetes.

We’ve covered functions and use cases, but what core benefits do Kubernetes controllers provide? The main ones are: 

• - **Automation** — Controllers reduce manual operations with their auto-scaling and state enforcement capabilities.
• - **Reliability** — Controllers make applications more reliable with features like scheduling, pod creation, and replica management. 
• - **Availability** — By automatically addressing failure events, controllers ensure a high availability of applications.
• - **Efficiency** — Controllers provide efficient cluster resource management with quote management and auto-scaling.
• - **Agility** —  With features like rolling updates, controllers facilitate faster application deployments and lifecycle management.
• - **Flexibility** — Controllers are available for a variety of needs, like batch jobs, daemon services, deployments, etc.
• - **Observability** — Controllers provide clear visibility into cluster resource state changes, events, and health through the K8s API.

Kubernetes operators are a subcategory of controllers that use API extensions — or custom resources — to complete tasks. Operators are typically constructed as a set of independent controllers, each responsible for its own subset of tasks and resources pertaining to the managed application.

While an operator shares similar functions with a controller, it exclusively utilizes custom resources and focuses on one domain.

On the other hand, controllers work without custom resources or API extensions and don’t need to connect to a specific domain. Operators are well-suited to meet operational needs for a specific application or platform, but they do not accommodate generic resource cluster states as well as controllers.

Kubernetes operators are custom-built controllers that extend Kubernetes functionality to automate the deployment, management, and operations of specific applications or services. Some key functions that operators can provide include:

• - **Lifecycle management **— Operators manage the full lifecycle of complex stateful applications like databases through deployment, upgrades, and scaling. They can also apply application logic to automate operations like backup and restore.
• - **Declarative management **— By leveraging K8s abstractions like CRDs, operators provide simple declarative management of applications through custom resources.
• - **Security** — Operators integrate top-of-the-line security measures, such as encryption, secrets management, and access controls, to protect applications. These measures are customizable from app to app.
• - **Advanced scheduling** — Operators enable customized scheduling policies for app resources by integrating with K8s schedulers.
• - **Error detection and tuning** — Operators detect errors and resource abnormalities like deadlocks through app-specific health checks and take actions to correct them. They can also auto-tune apps by analyzing metrics and conditions using domain knowledge.
• - **Migration** - Operators can automatically migrate apps across resource clusters and Kubernetes versions with minimal disruption.
• - **Disaster recovery** — Using app-centric logic, operators create and execute backup and disaster recovery workflows for stateful apps. 

By encoding this operational knowledge into automated controllers, Kubernetes operators reduce manual work and human error while ensuring applications run reliably on Kubernetes clusters following best practices.

Kubernetes operators have several key use cases for managing and automating applications and services within a cluster:

• - **Manage databases **— Deploy, upgrade, backup, and restore databases using an operator like MySQL or Postgres.
• - **Provision storage** — Provision and manage storage operations for stateful applications based on their specific needs.
• - **Log and monitor** — Simplify your analysis and metrics collection by deploying logging and monitoring tools like Elasticsearch or Prometheus.
• - **Deploy CI/CD tools** — Automate the deployment, configuration, and scaling of CI/CD pipelines using tools like Jenkins in your operator.
• - **Integrate messaging systems** — Automatically perform cluster scaling, upgrades, and health checks with a messaging operator that can manage systems, like RabbitMQ.
• - **Use service mesh tools** — Install service mesh tools like Istio to manage application traffic, automate canary rollouts, and more.
• - **Backup and restore** — Automatically back up your application and utilize disaster recovery systems for specific applications. 

Overall, Kubernetes operators bring an applications-centric approach to managing services on Kubernetes. They enable fully automated operations while improving reliability, observability, and optimization — all following best practices.

Kubernetes operators provide several key benefits:

• - **Simplified application management **— Operators manage complex app operations and provide declarative management via custom resources. 
• - **Increased productivity** — Operators automate heavy workloads typically needed to run and maintain complex apps, allowing developers to focus more on code.
• - **Deployment consistency** — Operators allow complex stateful apps to run consistently across on-premises, hybrid, or public cloud environments.  
• - **Extensibility** — By extending K8s APIs with CRDs, operators allow admins to support a wide variety of applications without adding extra workload.
• - **Ecosystem management** — With a rich ecosystem of operators, infrastructure teams can more easily manage a diversity of complex apps on K8s.
• - **Modularity** — Operators are modular since they typically focus on automating tasks for a single application or platform.
• - **Easier legacy transitions** — Operators drastically simplify the transition to K8s for legacy organizations with complex apps.

The key benefit of using operators is encoding operational expertise and allowing Kubernetes to fully automate the deployment and operations of complex applications or services.

Want a quick summary of how they compare? Here's a chart to keep as a reference.

Now you know the functions, use cases, and benefits of K8s controllers and operators — but how do you decide which method is right for your organization? Let us provide some context to fuel your decision.

Kubernetes controllers are typically used for stateless apps with common use cases, like frontends. As mentioned before, controllers accommodate generic resource cluster states, so they work best for simpler apps with basic automation requirements for functions like scaling and backups. Controllers also use default Kubernetes abstractions, meaning they pair well with cloud-native apps in single environments that have minimal operational needs. If your main goal is to extend and control Kubernetes at the API resource level, then your best bet may be a controller that can fulfill generic purposes not tied to a specific domain. 

Kubernetes operators, on the other hand, are useful for deploying and managing stateful apps like databases. Operators automate complex tasks for specific applications and platforms using deep operational knowledge. They allow admins to create custom resources and achieve advanced automation of lifecycle management tasks like scaling, upgrades, and storage. Additionally, operators are the best option for organizations looking to transition from legacy apps or deploy apps consistently across environments. If you need to work at a granular level in a complex application and reduce operational overhead, a Kubernetes operator would be the right choice.

Overall, controllers extend Kubernetes at the resource level, while operators focus on automating specific, complex applications. You should evaluate your app characteristics, environments, operational knowledge, and automation needs to make the final decision between a Kubernetes controller or operator.

Kubernetes controllers and operators will undoubtedly take your cluster resource task management to the next level. We hope this guide can serve as a roadmap to help you evaluate your specific application knowledge and needs, so you can start your Kubernetes journey as soon as possible.

Luckily, Kong is the ultimate partner to help you take control of your Kubernetes clusters. With our support, you can natively manage your APIs in Kubernetes to implement policies for security, identity, and traffic management, completely hassle-free. The best part? You’ll reduce disruptions and strengthen security at the same time.

If you’re ready to learn more about a Kubernetes solution with Kong, [request a demo](https://konghq.com/contact-sales)request a demo today.

Continued Learning & Related Resources

• - [Kubernetes Operators vs HELM: Package Management Comparison](https://konghq.com/blog/learning-center/kubernetes-operators-vs-helm)Kubernetes Operators vs HELM: Package Management Comparison[](https://konghq.com/blog/learning-center/guide-to-understanding-kubernetes-deployments)
• - [Guide to Understanding Kubernetes Deployments](https://konghq.com/blog/learning-center/guide-to-understanding-kubernetes-deployments)Guide to Understanding Kubernetes Deployments
• - [What is a Kubernetes Operator?](https://konghq.com/blog/learning-center/what-is-a-kubernetes-operator)What is a Kubernetes Operator?
• - [What is Kubernetes Ingress?](https://konghq.com/blog/learning-center/what-is-kubernetes-ingress)What is Kubernetes Ingress?
• - [What is a Kubernetes Ingress Controller?](https://konghq.com/blog/learning-center/what-is-a-kubernetes-ingress-controller)What is a Kubernetes Ingress Controller?
• - [What is Kubernetes?](https://konghq.com/blog/learning-center/what-is-kubernetes)What is Kubernetes?
• - [Understanding The Basics of Kubernetes Architecture](https://konghq.com/blog/learning-center/kubernetes-architecture)Understanding The Basics of Kubernetes Architecture