How Policy Engines Make Day 2 Easier

How Policy Engines Make Day 2 Easier

When we think about policy enforcement, it’s often in the context of ensuring compliance with governance frameworks and compliance laws. When working in Kubernetes, however, it’s slightly more nuanced. In Kubernetes, everything is controlled through configuration, and everything is designed to be tunable. This is what makes Kubernetes so flexible, but it is also what can make it extremely difficult to manage. It also means that policy enforcement has ramifications beyond security and compliance, including things like resilience and ability to recover from incidents. 

Policy enforcement in Kubernetes is an essential part of configuration management. Effective policy management is essential for companies to scale Kubernetes throughout the enterprise and deploy quickly while avoiding Day 2 operations challenges from configuration mistakes. 

What are Kubernetes policy engines? 

Policy engines are a part of the configuration management story in Kubernetes. They allow organizations to set policies or guardrails around what configurations are allowed, both in general in all deployments as well as in specific types of applications. In addition to establishing guardrails, policy engines can dynamically create configurations or change configurations based on pre-set policies. 

Kubernetes-native policy engines work specifically with Kubernetes, working with Kubernetes’ declarative syntax and following configuration management best practices. 

Why do intelligent policy engines matter?

Policy engines can operate on a simple pass/fail basis, scanning a deployment to see what fails the policies — that’s what a typical traditional policy management tool would do. Intelligent policy engines are dynamic, however. They allow users to create if-then-else policies that will dynamically change configurations, or even generate new configuration objects. 

As a result, configuration can be largely automated. For example, when a new namespace is created, there are dozens of configurations that have to be tuned. With an intelligent policy engine, all of those configurations can be generated automatically every time a namespace is created. 

In another example, if the policy engine finds configurations that violate the set policy, instead of just alerting the Kubernetes admin the engine will also automatically fix the configuration to bring it into compliance. As a result, policy violations are fixed faster and are less likely to cause problems. 

How does this relate to Day 2?

The key to a smooth Day 2 is strict adherence to predetermined best practices during design and development. Given the amount of complexity in Kubernetes, this absolutely requires automation — even the most experienced Kubernetes admins make mistakes when manually managing hundreds of configurations. 

Here are some specific ways that automating configurations with an intelligent policy engine lead to smoother Day 2 operations. 

Security

By default, Kubernetes is insecure. Improving Kubernetes’ security posture involves tightly controlling configurations. At the same time, the Kubernetes environment is dynamic, with users constantly making requests or deploying new applications. A policy engine can constantly scan both the development and the production environment to ensure that no pods are running as root users and to check Helm charts for vulnerabilities, among many other things. With automated policy engines, when a problem is detected it is both reported as well as fixed automatically. 

Resource usage

Organizations can get into trouble with escalating costs if they don’t put limits on resource usage, but leaving it up to each individual developer guarantees that mistakes will happen. Intelligent policy engines allow organizations to decide ahead of time what appropriate resource limits are and ensure those limits are applied uniformly. 

Monitoring and logging

Monitoring application health is key to ensuring quick recoveries in case of failure, high availability and a positive customer experience. Getting all the information you need from the application in production often requires configuring the monitoring capabilities correctly; a policy engine can ensure that happens. 

In general, Day 2 operations depend on workloads being configured correctly during the development stage. Especially as Kubernetes expands throughout an organization and the footprint becomes more complex, involving engineers who are non-experts in Kubernetes configuration, handling as much as possible through automation is the only way to get both a quick development velocity as well as uniform configurations that adhere to organizational policies. 

How Kyverno fits in

Kyverno is a Kubernetes-native intelligent policy engine that can generate configurations, change them according to policies and/or be used to simply validate configurations. Kyverno creates and enforces policies by creating custom resources and interacting with Kubernetes through the Kubernetes API. This approach ultimately makes the Kyverno policy engine simpler to use, reducing the learning curve and simplifying the experience for users. This in turn both increases adoption in the organization while also reducing the risk of errors. 

In our experience, the only way for organizations to successfully manage Kubernetes configurations is through policy engines, especially as the Kubernetes footprint expands. Organizations ultimately want to deploy applications as quickly as possible without risking problems on Day 2, and a policy engine is an important tool to make sure configuration errors don’t get in the way of operational success. 

At the same time, the more automation the policy engine is able to provide, the better. Using a tool like Kyverno to not only validate but also generate and mutate configurations to meet the set policies saves developers time while ensuring that applications are secure, cost-effective, resilient and able to recover from incidents. Kyverno is open source — try it out here to see how it can simplify configuration management. 

Deny Rules! Fine-Grained Kubernetes Access Controls with Kyverno
Managing Day 2 in a Hybrid Cloud Environment
No Comments

Post a Comment