Securing Kubernetes: The Risks Of Unmanaged Machine Identities

Microservices and containers are changing the way businesses build, deploy, and manage their applications. Within a short span, these technologies have become the de facto standard for software development and distribution. Kubernetes, the open-source container orchestration platform, has also become synonymous with developing, scaling, and managing cloud-native applications and services in hybrid and multi-cloud environments.

The widespread adoption of containers and Kubernetes has transformed the application landscape, powering modern use cases like Infrastructure as Code (IaC) and DevOps. However, the shift to Kubernetes has brought significant change in infrastructure and increased complexity, opening up a whole new attack surface.

Kubernetes Necessitates A Fresh Perspective on Security

The Kubernetes environment is highly dynamic and ephemeral in nature, with container workloads constantly spinning up and down in response to demand. This constant flux means that each pod and container within a Kubernetes cluster is a potential gateway for attackers. A single container or pod compromise can grant attackers deep access to organizational data. Therefore, it is imperative that we protect them with the highest level of security.

Trying to repurpose existing security tools for protecting containerized and microservice-based applications hasn’t proven effective as these tools are not equipped to adapt to the scale and short-lived nature of containers.

Securing Kubernetes environments requires a defense-in-depth approach that addresses the “4 Cs” – Cloud, Cluster, Container, and Code. Security controls must be implemented at all these layers of the Kubernetes stack to ensure the underlying infrastructure, the orchestration platform, and applications are always secure.

The various approaches to securing Kubernetes environments can be classified mainly into four categories:

  • Infrastructure Security
  • Network Security
  • Code and Container Security
  • Identity and Access Control

While there is a lot of focus on offering competing solutions addressing the needs of the first three categories, the fourth category—Identity and Access Control—remains largely overlooked and not discussed enough in Kubernetes security.

Identity and Access is Fundamental to Kubernetes Security

Identity and Access Management (IAM) is a framework of policies and technologies designed to ensure that the right individuals have the appropriate access to resources within an organization’s IT environment. In the context of Kubernetes, IAM involves managing human and non-human (machine) identities, their roles, and access permissions to regulate what each user or machine can access and do within the cluster.

The role of IAM is pivotal in Kubernetes security as it enables fine-grained access control and least privilege access that are essential for preventing unauthorized access and malicious lateral movement between clusters and pods. Identities provide a secure and flexible way of authenticating and authorizing users and machines (workloads, services, code, etc.), controlling their access to Kubernetes resources, and minimizing security risks.

An effective IAM strategy must provide the framework for managing both human and non-human identities. However, most organizations tend to focus only on human identities. Non-human identities are disregarded and managed with basic manual processes, which leaves a big gap in the Kubernetes security posture.

Simplify certificate lifecycle management across Kubernetes environments with AppViewX KUBE+

Non-human identities are supported by SSL/TLS certificates that help identify and authenticate machines and encrypt machine-to-machine communications. In Kubernetes, SSL/TLS certificates are used to secure the ingress web traffic, pod-to-pod and service mesh communications, and Kubernetes infrastructure components and their communications.

As the Kubernetes environment is home to a large number of container workloads at any given point, the volume of SSL/TLS certificates is also exceptionally high. As these certificates are often short-lived due to the ephemeral nature of Kubernetes resources, they must be continuously monitored and managed to mitigate the risk of outages, unauthorized access, and vulnerabilities caused by expired, unknown, rogue, or non-compliant certificates. However, most organizations manage these certificates using spreadsheets and other ad hoc processes, exposing themselves to cluster compromises and large-scale data breaches.

Here are some of the challenges and risks of manual certificate lifecycle management in Kubernetes:

  • Lack of Visibility

Cloud-native applications today use a large number of (dozens to hundreds)
containers that are constantly spun up or down, created, deleted, or rescheduled to
meet fluctuating demand. Given the large number of clusters and the short lifespan of containers, it’s critical for InfoSec teams to maintain complete visibility of all the certificates to ensure that all the components in the Kubernetes cluster are using valid, trusted, and compliant certificates.

However, spreadsheets and CA-specific solutions fail to provide centralized visibility of all public and private trust certificates, leading to missed renewals, outages and security blind spots. Further, with DevOps teams often using self-signed certificates or getting certificates independently from a CA of their choice to avoid delays, InfoSec teams quickly lose oversight and control. This creates vulnerabilities in the form of unmanaged, rogue, and non-compliant certificates.

  • No Centralized Root of Trust

Extending the root of trust to all clusters in Kubernetes environments is a complex challenge. Without a common trust anchor, it becomes difficult to ensure consistent certificate issuance, renewal, and revocation across the entire cluster. This can lead to fragmented security policies, increased risk of certificate compromise, and administrative overhead. Moreover, the absence of a centralized root of trust complicates the enforcement of compliance standards and auditability, potentially exposing the system to vulnerabilities and misconfigurations that can be exploited by malicious actors.

  • Disconnected Processes and Team Silos

Organizations today run a large number of Kubernetes clusters, primarily managed by DevOps and CloudOps teams. While DevOps focuses on getting work done quickly, CloudOps focuses on platform availability. Between these priorities, security often takes a backseat. The problem is further compounded by the use of disparate tools, resulting in delays, complexity, and inconsistency issues. On the other hand, Security teams have little visibility or control over DevOps practices, leading to blind spots, vulnerabilities, and compliance violations.

  • Operational Bottlenecks

Developers need high-speed certificate issuance at scale. However, the traditional process for requesting and issuing a certificate involves raising a ticket, seeking multiple approvals, and waiting for days. Even after a certificate is issued, developers will still need to install and bind certificates manually, which impacts productivity and increases the possibility of certificate misconfigurations and outages. Because manual processes are painfully slow, developers often dodge certificate management best practices in favor of speed, amplifying cyber risks.

  • Lack of Control

Manual or Ad hoc processes provide no means to enforce a uniform PKI policy. Lack of well-defined policies and certificate sprawl often lead to weak crypto standards, use of vulnerable self-signed certificates and certificates procured from unapproved CAs, and misconfigurations—all of which introduce security risks and non-compliance issues. Compounding the problem is the lack of clear certificate ownership and approval workflows that lead to expired certificates, unauthorized access, and rogue certificate issuance.

As containerization and Kubernetes adoption mature, the security and integrity of the environment and applications within, become more important than ever. Safeguarding against potential vulnerabilities, unauthorized access, lateral movement, and data breaches requires a solid IAM strategy, managing both human and non-human identities. Automation can be a game-changer in managing machine identities effectively and turning them into powerful guardrails for Kubernetes environments.

Simplify and Streamline Certificate Lifecycle Management in Kubernetes with AppViewX

AppViewX offers comprehensive certificate lifecycle management for Kubernetes environments as part of its AVX ONE platform. It provides a central solution to discover, manage, automate, and govern certificates (or machine identities) across containerized workloads and Kubernetes infrastructure. AVX ONE brings together visibility, automation, and policy-driven control to bake security into the core of DevOps pipelines and Kubernetes management.

Simplify Certificate Management Across Ingress, Service Mesh, and Kubernetes Infrastructure Components


  • CloudOps
  • Cluster
  • Container
  • DevOps
  • Identity and Access Management
  • Infrastructure as Code (IaC)
  • Infrastructure Security
  • Kubernetes
  • Network Security
  • SSL/TLS certificates

About the Author

Krupa Patil

Product Marketing Manager

A content creator focused on providing readers and prospective buyers with accurate, useful, and latest product information to help them make better informed decisions.

More From the Author →

Related Articles

The Impending Identity Crisis Of Machines: Why We Need To Secure All Non-Human Identities, From Genai To Microservices And IOT

| 4 Min Read

How To Streamline Certificate Lifecycle Management In Azure Kubernetes Service (AKS) with AppViewX KUBE+

| 5 Min Read

Simplify Certificate Lifecycle Management And Build Security Into OpenShift Kubernetes Engine With AppViewX KUBE+

| 4 Min Read