MTVLab: Pioneering DevOps Cloud Training

Step-by-Step: Managing Multiple Kubernetes Clusters with ~/.kube/config

By Rajesh Gheware

Managing multiple Kubernetes clusters is a common scenario for many organizations, especially in industries like e-commerce, healthcare, and finance. As businesses scale, they often deploy applications across various clusters for reasons such as redundancy, geographical distribution, and workload separation. The ~/.kube/config file is a powerful tool that allows you to efficiently manage these clusters from a single command-line interface. In this article, I will walk you through the step-by-step process of configuring and using the ~/.kube/config file to manage multiple Kubernetes clusters.

Why Use Multiple Kubernetes Clusters?

Before diving into the technical details, let’s explore why managing multiple Kubernetes clusters is beneficial across different industries:

E-commerce

An e-commerce company might deploy different clusters for handling front-end, back-end, and data analytics workloads. This separation ensures that a spike in front-end traffic during a sale doesn’t impact back-end operations.

Healthcare

In healthcare, managing sensitive patient data requires stringent compliance. Separate clusters can be used for development, testing, and production to ensure that patient data is handled securely and meets compliance standards.

Finance

Financial institutions often use multiple clusters to manage microservices-based applications. For example, separate clusters for trading systems, risk management, and customer services ensure that critical services remain available and secure.

Setting Up the ~/.kube/config File

Step 1: Gather Cluster Information

To manage multiple clusters, you need the API server endpoints, certificates, and user credentials for each cluster. Here’s an example setup for three clusters in different industries:

E-commerce Cluster
Healthcare Cluster
Finance Cluster

Step 2: Structure of the ~/.kube/config File

The ~/.kube/config file is structured into three main sections: clusters, contexts, and users. Let’s look at how you can configure these sections for our example clusters.

Example ~/.kube/config

apiVersion: v1
clusters:
- cluster:
    certificate-authority: /path/to/ecommerce-ca.crt
    server: https://ecommerce.example.com
  name: ecommerce-cluster
- cluster:
    certificate-authority: /path/to/healthcare-ca.crt
    server: https://healthcare.example.com
  name: healthcare-cluster
- cluster:
    certificate-authority: /path/to/finance-ca.crt
    server: https://finance.example.com
  name: finance-cluster
contexts:
- context:
    cluster: ecommerce-cluster
    user: ecommerce-user
    namespace: default
  name: ecommerce-context
- context:
    cluster: healthcare-cluster
    user: healthcare-user
    namespace: default
  name: healthcare-context
- context:
    cluster: finance-cluster
    user: finance-user
    namespace: default
  name: finance-context
current-context: ecommerce-context
kind: Config
preferences: {}
users:
- name: ecommerce-user
  user:
    client-certificate: /path/to/ecommerce-client.crt
    client-key: /path/to/ecommerce-client.key
- name: healthcare-user
  user:
    client-certificate: /path/to/healthcare-client.crt
    client-key: /path/to/healthcare-client.key
- name: finance-user
  user:
    client-certificate: /path/to/finance-client.crt
    client-key: /path/to/finance-client.key

Step 3: Switching Between Contexts

Once your ~/.kube/config file is set up, you can easily switch between different clusters using the kubectl command.

Viewing All Contexts

kubectl config get-contexts

This command will list all the contexts defined in your config file.

Switching to a Specific Context

kubectl config use-context healthcare-context

This command switches the current context to the healthcare cluster. You can verify the switch by running:

kubectl config current-context

Step 4: Performing Cluster Operations

With the contexts properly configured, you can now perform operations on the respective clusters.

Deploying an Application

Let’s deploy a sample application to the e-commerce cluster. First, switch to the e-commerce context:

kubectl config use-context ecommerce-context

Next, deploy the application:

kubectl apply -f ecommerce-deployment.yaml

Checking the Status of Pods

Switch to the finance context and check the status of pods:

kubectl config use-context finance-context
kubectl get pods

Real-World Example: Deploying a Payment Microservice

Let’s consider a detailed example where a financial institution needs to deploy a new payment microservice across multiple clusters for redundancy and load balancing.

Define the Deployment YAML

Create a payment-deployment.yaml file with the following content:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: payment-service
spec:
  replicas: 3
  selector:
    matchLabels:
      app: payment
  template:
    metadata:
      labels:
        app: payment
    spec:
      containers:
      - name: payment
        image: brainupgrade/payment-service:latest
        ports:
        - containerPort: 8080

Deploy to the Finance Cluster

Switch to the finance context and deploy:

kubectl config use-context finance-context
kubectl apply -f payment-deployment.yaml

Deploy to the E-commerce Cluster

Switch to the e-commerce context and deploy:

kubectl config use-context ecommerce-context
kubectl apply -f payment-deployment.yaml

Deploy to the Healthcare Cluster

Switch to the healthcare context and deploy:

kubectl config use-context healthcare-context
kubectl apply -f payment-deployment.yaml

Conclusion

Managing multiple Kubernetes clusters with the ~/.kube/config file simplifies administration and enhances operational efficiency. By organizing your clusters, contexts, and users in a single configuration file, you can seamlessly switch between different environments and perform necessary operations with ease. Whether you’re in e-commerce, healthcare, or finance, leveraging this powerful tool will help you maintain robust, scalable, and secure applications across your Kubernetes infrastructure.

Implementing these practices ensures you are well-prepared to handle the complexities of multi-cluster management in Kubernetes, providing a scalable solution for your organization’s needs. Happy clustering!

Rajesh Gheware