Operators vs Helm: What Platform Teams Should Use When

In this article, we'll explore the differences between Operators and Helm, two popular tools for deploying and managing applications on Kubernetes.

### TL;DR

• Operators are best for dynamic runtime behavior and lifecycle controllers
• Helm is suitable for repeatable installs, especially when teams cannot enforce chart quality
• Consider a combination of both, depending on your needs and environment
• Use caution when managing Helm Charts across teams

### What are Operators? Operators are a way to manage Kubernetes resources and applications through custom-built controllers. They are designed to automate complex tasks, ensure application compliance, and provide a high level of flexibility. Operators are useful when dynamic runtime behavior is required, making them ideal for applications with unique or changing requirements. However, their complexity and customization needs can make them difficult to maintain.

Here's an example of a simple Operator:

```yaml apiVersion: rbac.authorization.k8s.io/v1 kind: ClusterRole metadata: name: tempo-distributed-operator rules:

• apiGroups:
• apps

resources:

• deployments

verbs:

• get
• list

``` ### What is Helm? Helm is a package manager for Kubernetes that simplifies the process of deploying, managing, and rolling back applications. Helm charts provide a consistent and repeatable way to install and configure applications on Kubernetes. They are ideal for applications that require a high degree of consistency and stability, making them a popular choice for production environments.

Here's an example of a Helm chart:

```yaml # Source: https://github.com/grafana-community/helm-charts/blob/main/charts/tempo-distributed/README.md --- apiVersion: v2 name: tempo-distributed version: 1.0.0 description: A Helm chart for deploying Tempo Distributed. values: metaMonitoring: grafanaAgent: metrics: scrapeK8s: enabled: true kubeStateMetrics: namespace: "monitoring" labelSelectors: app.kubernetes.io/name: "kube-state-metrics" ``` ### Choosing Between Operators and Helm When deciding between Operators and Helm, consider the following factors:

• **Dynamic runtime behavior**: If your application requires dynamic or changing behavior, an Operator might be a better fit. However, keep in mind the complexity and maintenance needs associated with Operators.
• **Repeatable installs**: If you need to deploy and manage multiple instances of the same application, Helm charts can provide a consistent and repeatable way to do so.
• **Team environment**: If you have multiple teams managing different applications, Helm charts can make it easier to share knowledge and best practices across teams.
• **Complexity level**: If your application requires advanced features and customization, an Operator might be more suitable.

### Common Pitfalls

• **Don't use Helm for complex applications**: If your application requires advanced features or customization, consider using an Operator.
• **Don't underestimate the maintenance needs of Operators**: Be prepared to invest time and effort in maintaining and updating Operators.
• **Use Helm charts consistently**: Establish a consistent naming convention and versioning scheme for Helm charts to make them easier to manage across teams.
• **Monitor and review Helm chart versions**: Regularly review and update Helm chart versions to ensure they remain relevant and compatible with your environment.

### What to Do Next

• **Assess your application's needs**: Evaluate your application's requirements and determine whether an Operator or Helm chart is more suitable.
• **Research and experiment**: Experiment with different tools and approaches to find the best fit for your environment.
• **Establish best practices**: Develop and enforce consistent practices for deploying and managing applications, regardless of the tool or approach chosen.
• **Continuously review and improve**: Regularly review and refine your approach to ensure it remains effective and efficient.

### Key Takeaways

• Operators are best for dynamic runtime behavior and lifecycle controllers
• Helm is suitable for repeatable installs, especially when teams cannot enforce chart quality
• Consider a combination of both, depending on your needs and environment
• Use caution when managing Helm Charts across teams

By carefully considering your application's needs and environment, you can make an informed decision about whether to use Operators or Helm for your Kubernetes deployments. Remember to establish best practices and continuously review and improve your approach to ensure the success of your platform teams.