Photo by FLY:D / Unsplash

Securing Your Kubernetes Environment: A Comprehensive Guide to Server and Client Certificates in Kubernetes

Ehis Iribhogbe
Ehis Iribhogbe

Table of Contents

Kubernetes has emerged as the de facto container orchestration platform in recent years. With its rapid adoption, the need for robust security measures within Kubernetes environments has become paramount. Kubernetes provides several security features, but one of the most important is using server and client certificates.

This article will teach you about the different server and client certificates used by Kubernetes components. You will also learn how these certificates are generated, signed, and distributed.

Finally, you will learn some best practices for securing Kubernetes using certificates, including tips for generating and managing certificates and monitoring certificate usage and expiration.


A basic understanding of:

  • Kubernetes
  • Kubeadm
  • Authentication and authorization in software

Understanding Authentication and Authorization in Kubernetes

Authentication and authorization are essential concepts for securing Kubernetes. Authentication verifies the identity of users or components accessing the cluster, while authorization ensures that authenticated entities have the necessary permissions to perform actions within the cluster. Server and client certificates are crucial in enabling strong authentication and enforcing access control in Kubernetes.

As Kubernetes clusters comprise numerous components, including nodes, controllers, and the Kubernetes API server, maintaining the integrity and confidentiality of data exchanged between these components is of utmost importance.

Server certificates are used to secure communication between Kubernetes components, such as the Kubernetes API server and the kubelet. In contrast, Client certificates are used to authenticate users and applications that interact with Kubernetes.

In the context of Kubernetes, certificates validate the authenticity of entities interacting with the cluster, including Kubernetes components and applications running within it. These certificates are issued by a trusted Certificate Authority (CA) and enable secure communication by establishing encrypted connections and verifying the integrity of transmitted data.

For instance, an admin user interacting with the cluster via kubectl or via accessing the Kubernetes API must establish secure TLS connections, and communications between all components within the Kubernetes cluster must be secure. So, the main requirement is to have all the services within the cluster use server certificates, and all clients interacting with the cluster use client certificates to verify who they are.

Server Certificates Kubernetes

In Kubernetes, server certificates are a type of cryptographic credential used to establish secure communication between various components within a cluster. Server certificates play a crucial role in ensuring communication channels' authenticity, confidentiality, and integrity.

Server certificates are primarily used to secure the communication between the Kubernetes API server and other components, such as kubelets, etcd, and controllers. These certificates are commonly issued by a trusted Certificate Authority (CA).

A server certificate must be generated for the Kubernetes API server when setting up a Kubernetes cluster. This certificate should be signed by a trusted certificate authority (CA) to establish trust. The Certificate Authority acts as a trusted third party that verifies the identity of the server and issues the certificate. Once the server certificate is in place, it can be used to secure communication with the Kubernetes API server.

Client Certificates in Kubernetes

In Kubernetes, client certificates are a type of authentication mechanism used to verify the identity of clients (users or processes) that interact with the Kubernetes cluster. A CA issues Client certificates, which consist of a public key, a private key, and additional information about the client, such as its name or organization.

When a client wants to access the Kubernetes cluster, it presents its client certificate to the Kubernetes API server for authentication. The Kubernetes API server then verifies the certificate's authenticity by checking its validity, signature, and the CA that issued it. The client is granted access to the cluster if the certificate is valid and trusted.

The general steps for generating client or server certificates in Kubernetes

The following steps provide a general overview of the process, but the specific commands and procedures may vary depending on the tools or utilities you are using to generate and manage certificates in your Kubernetes environment.

Step 1: Create a Certificate Authority (CA): Start by setting up a Certificate Authority (CA) that will be used to sign and validate certificates within your Kubernetes cluster.

Step 2: Generate a Private Key: Create a private key that will be used for the certificate.

Step 3: Create a Certificate Signing Request (CSR): Generate a Certificate Signing Request (CSR) that includes the necessary details for the certificate, such as the Common Name (CN) and other relevant attributes.

Step 4: Sign the Certificate Signing Request: Submit the CSR to the CA for signing. The C.A. will verify the request and generate a signed certificate.

Step 5: Distribute the Certificates: Once the certificate is signed, distribute the appropriate certificates and keys to the respective components or users within the Kubernetes cluster. This may involve deploying the certificates to the Kubernetes API Server, kubelet, etcd, or any other relevant components.

Step 6: Configure Component or User to Use Certificates: Update the configuration of the relevant Kubernetes components or users to use the newly generated certificates. This typically involves specifying the paths to the certificate and key files in the component's or user's configuration.

Step 7: Restart or Reload Components: Restart or reload the Kubernetes components that rely on the certificates to ensure they pick up the new certificate configurations.

How to generate Server Certificates in Kubernetes

Depends on how you install Kubernetes; if you install Kubernetes with Kubeadm, Kubeadm will create self-signed server certificates for you. These certificate files will be stored in /etc/kubernetes/pki directory and will be distributed to each node and also any new node to the cluster.

Below is an image of the server and client certificates that were generated when bootstrapping the Kubernetes cluster with Kubeadm :

Please note that the server certificate has a file extension of .crt whereas the private key has a file extension of .key

Different types of Server certificates in Kubernetes and How They Work

The following are different types of Server certificates in Kubernetes and how they work:

Kubernetes API Server Certificate: The Kubernetes API Server is responsible for providing an HTTPS service that allows various components and external users to manage the Kubernetes cluster. To ensure secure communication with its clients, the Kubernetes API Server requires certificates and a key pair. In the example of using Kubeadm to set up a cluster, it generates a certificate called apiserver.crt and a private key called apiserver.key for the Kubernetes API Server. This certificate and key pair is used to encrypt and authenticate communication between the API Server and its clients

Etcd server Certificate: The etcd, which serves as the storage backend for all the information in the Kubernetes cluster, also needs to have its own key pair and certificate for secure operations. When setting up a cluster using Kubeadm, for instance, it generates a certificate named server.crt and a private key named server.key specifically for the etcd component and saved in the directory /etc/kubernetes/pki/etcd. This certificate and key pair are crucial for encrypting and authenticating communication within the etcd storage, ensuring the confidentiality and integrity of the cluster's data.

  1. Kubelet server Certificate: On the worker node, the kubelet service plays a vital role by exposing HTTPS endpoints that allow communication between the Kubernetes API Server and the worker node itself. In order for the Kubernetes API Server to interact securely with the worker node, it requires specific certificates. When setting up a cluster using Kubeadm, for example, a certificate called kubelet.crt and a private key named kubelet.key are generated for this purpose. This certificate and key pair enable encrypted and authenticated communication, ensuring secure interactions between the kube-apiserver and the worker node.

Kubernetes components and the client certificate they use with the API server

The following are Kubernetes components and the certificate they use to communicate with the API server:

Admin user

Admin users interact with the Kubernetes API server either through the kubectl utility or the Kubernetes REST API. To authenticate themselves with the Kubernetes API Server, admin users need to have a certificate and key pair. These credentials are typically named admin.crt and admin.key, allow the admin user to prove their identity when accessing the Kubernetes API server. The certificate and key pair provide the necessary authentication mechanism for admin users, ensuring secure and authorized access to the Kubernetes cluster


The kube-scheduler communicates with the Kubernetes API server to identify pods that need to be scheduled and then requests the Kubernetes API server to allocate the appropriate node for each pod. As the scheduler acts as a client to the Kubernetes API server, it needs to validate its identity using its own client TLS certificate. Therefore, the kube-scheduler requires its own pair of certificates and keys, commonly known as scheduler.crt and scheduler.key. These credentials are used by the scheduler to authenticate itself with the API server, ensuring secure and authorized communication between the scheduler and the API server during the pod scheduling process


The kube-controller-manager also acts as a client to the Kubernetes API server. Similar to other components, it requires its own certificate and key pair to authenticate and establish a secure connection with the API server. This certificate is known as controller-manager.crt, and the corresponding private key is controller-manager.key. The scheduler uses these credentials to authenticate itself with the API server, ensuring secure and authorized communication between the scheduler and the API server during the pod scheduling process


The kube-proxy serves as a network proxy that plays a crucial role in enabling network communication within the cluster and requires a client certificate and key pair to access the Kubernetes API server. This certificate is known as kube-proxy.crt, and the corresponding private key is kube-proxy.key. By possessing these credentials, the kube-proxy is able to authenticate itself when communicating with the Kubernetes API server. The client certificate and key pair ensure secure and authorized interactions between the kube-proxy and the API server, enabling the proxy to fulfill its role in network routing and service discovery within the Kubernetes cluster.

Kubernetes API server

5. The Kubernetes API server acts as the intermediary between other components and the etcd server, making it the only server authorized to communicate with etcd. As a result, the Kubernetes API server requires its own client certificate and key pair to authenticate itself when connecting to the etcd server. There are two options for certificate usage:

  1. Sharing Certificates: The API server can use the same certificate and key pair that it uses for authenticating its clients (e.g. apiserver.crt ****and apiserver.key). In this case, the API server utilizes the existing certificate to establish a secure connection with the etcd server.
  2. Separate Certificate: Alternatively, the API server can generate a distinct client certificate specifically for authenticating its communication with the etcd server (apiserver-etcd-client.crt and apiserver-etcd-client.key). This approach involves creating a new certificate and key pair dedicated to the kube-apiserver, ensuring its unique identity when accessing the etcd server.

Both approaches ensure secure authentication and communication between the API server and     the etcd server, allowing the API server to access and manage cluster-wide state stored in etcd effectively.

The Kubernetes API server is responsible for communicating with the kubelet servers on each worker node. To establish a secure connection and authenticate itself to the kubelet, the kube-apiserver requires a client certificate and key pair. There are two approaches for certificate usage in this scenario:

  1. Shared Certificates: The kube-apiserver can utilize the same certificate and key pair that it uses for authenticating its clients. This means that the existing certificates, such as apiserver.crt and apiserver.key, can be used for communicating with the kubelet servers.
  2. Separate Certificates: Alternatively, the kube-apiserver can generate a new client certificate and key pair specifically for authenticating its communication with the kubelet servers. In this case, a distinct certificate named kubelet-client.crt and its corresponding private key, kubelet-client.key are created.

Both approaches ensure secure and authenticated communication between the kube-apiserver and the kubelet servers on the worker nodes. The choice between using shared or separate certificates depends on specific security requirements and configurations within the Kubernetes cluster.

It is important to note that when installing Kubernetes, you will need to generate your own Kubernetes certificates to ensure secure communication within the cluster. This involves creating the necessary certificates and key pairs that will be used to encrypt and authenticate the communication channels between the various components of the Kubernetes cluster. By generating your own Kubernetes certificates, you can customize the security measures according to your specific requirements and configurations.

Best practices for securing and managing Server and Client certificates in Kubernetes

Managing and securing server certificates and client certificates in Kubernetes involves following best practices and leveraging Kubernetes native features. Here are some best practices to effectively manage and secure these certificates:

  1. Generate server certificates and client certificates using a trusted certificate authority (C.A) or a self-signed CA within your Kubernetes cluster. Ensure that the certificates have appropriate expiration dates and key lengths.
  2. Store the server certificates and client certificates securely, avoiding any exposure or unauthorized access. Kubernetes Secrets or external secrets management solutions like HashiCorp Vault can be utilized for secure storage.
  3. Implement a certificate rotation policy to regularly update and replace expiring or compromised certificates. This helps maintain the security and validity of the certificates. Use Kubernetes controllers or custom automation scripts to automate the certificate rotation process.
  4. Distribute the server certificates and client certificates to the appropriate components and services within the Kubernetes cluster. This includes the Kubernetes API server, kubelets, ingress controllers, and any other components that require TLS authentication.
  5. Enable and enforce TLS authentication for all communication channels within the Kubernetes cluster. Ensure that client certificates are validated by the server during authentication to establish secure and trusted connections.

By following these practices, you can effectively manage and secure server certificates and client certificates in a Kubernetes environment, enhancing the overall security posture of your cluster.


Server certificates in Kubernetes are typically managed using a combination of tools and processes, including certificate generation, renewal, rotation, and distribution. Organizations often use tools like cert-manager, an open-source Kubernetes-native certificate management controller, to automate the lifecycle management of certificates within the cluster.

By securing communication with server certificates, Kubernetes ensures that sensitive information remains confidential, unauthorized access is prevented, and the overall cluster's security is enhanced.

To learn more, check out the official Kubernetes documentation on certificates


Ehis Iribhogbe Twitter

An experienced software engineer and technical writer. My expertise includes developing, maintaining, and deploying software applications that effectively address real-world problems.