Shaving Cloud Expenses: How to Automate GKE Cluster Node Scaling

Are you tired of burning a hole in your pocket with unnecessary cloud expenses? Do you wish there was a way to scale down your Google Kubernetes Engine (GKE) cluster nodes to zero after work hours and spin them back up when the workday begins? Well, you’re in luck! In this article, we’ll guide you through the process of automating GKE cluster node scaling to minimize your cloud expenses.

Why Scale Down GKE Cluster Nodes?

Before we dive into the how-to section, let’s quickly discuss why scaling down GKE cluster nodes is a brilliant idea. Here are a few compelling reasons:

• Cost Savings: By scaling down your cluster nodes during off-peak hours, you can significantly reduce your cloud expenses. This is especially crucial for businesses with fluctuating workloads or those that only require cluster resources during specific hours.
• Resource Optimization: Scaling down idle nodes helps optimize resource utilization, ensuring that your cluster is running lean and mean during non-peak periods.
• Enhanced Security: With fewer nodes running, you reduce the attack surface of your cluster, making it more secure and less vulnerable to potential threats.

Prerequisites and Assumptions

Before we proceed, make sure you have the following:

• A GKE cluster set up and running.
• A basic understanding of GKE and Kubernetes concepts.
• A Google Cloud Platform (GCP) project with the necessary permissions and access.
• A Cloud Scheduler and Cloud Functions setup (we’ll cover this later).

Step 1: Create a Cloud Scheduler Job

To automate the scaling process, we’ll create a Cloud Scheduler job that will trigger a Cloud Function to scale down and up our GKE cluster nodes at the desired times.

Navigate to the GCP Console and follow these steps:

1. Click on the Navigation menu (three horizontal lines in the top left corner) and select CLOUD SCHEDULER.
2. Click on the CREATE JOB button.
3. Enter a name and description for your job (e.g., “GKE Node Scaler”).
4. Select the region and zone where your GKE cluster is located.
5. Set the frequency and start time for your job. For example, you can set it to run daily at 5 PM (scale down) and 8 AM (scale up).
6. Specify the Cloud Function that will be triggered by the Cloud Scheduler job (we’ll create this later).
7. Save the job.

Step 2: Create a Cloud Function

Next, we’ll create a Cloud Function that will receive the trigger from the Cloud Scheduler job and scale down or up our GKE cluster nodes accordingly.

Navigate to the GCP Console and follow these steps:

1. Click on the Navigation menu and select CLOUD FUNCTIONS.
2. Click on the CREATE FUNCTION button.
3. Choose the Node.js 14 runtime and set the function name (e.g., “gke-node-scaler”).
4. Set the region and zone where your GKE cluster is located.
5. Paste the following code into the function body:

   exports.gkeNodeScaler = async (event) => {
     const { pubsubMessage } = event;
   
     // Get the GKE cluster name and zone from environment variables
     const clusterName = process.env.CLUSTER_NAME;
     const zone = process.env.ZONE;
   
     // Set the desired node count based on the trigger
     let nodeCount;
     if (pubsubMessage.data === 'scale_down') {
       nodeCount = 0;
     } else if (pubsubMessage.data === 'scale_up') {
       nodeCount = 3; // Replace with your desired node count
     } else {
       console.error('Invalid trigger data:', pubsubMessage.data);
       return;
     }
   
     // Use the Google Cloud Client Library to update the node pool
     const { google } = require('googleapis');
     const compute = google.compute('v1');
     const params = {
       project: process.env.PROJECT_ID,
       zone,
       clusterName,
     };
   
     try {
       const response = await compute.nodePools.patch({
         project: params.project,
         zone: params.zone,
         cluster: params.clusterName,
         nodePool: 'default-pool', // Replace with your node pool name
         requestBody: {
           nodeCount,
         },
       });
   
       console.log(`Scaled ${params.clusterName} to ${nodeCount} nodes`);
     } catch (err) {
       console.error('Error scaling GKE cluster:', err);
     }
   };
   

6. Set the following environment variables:
   

   Environment Variable	Value
   CLUSTER_NAME	Your GKE cluster name
   ZONE	Your GKE cluster zone
   PROJECT_ID	Your GCP project ID

7. Save the function.

Step 3: Trigger the Cloud Function

Finally, we need to trigger the Cloud Function from the Cloud Scheduler job. We’ll do this by publishing a message to the Cloud Pub/Sub topic that the function is subscribed to.

Navigate to the GCP Console and follow these steps:

1. Click on the Navigation menu and select CLOUD PUB/SUB.
2. Click on the CREATE TOPIC button.
3. Enter a name for your topic (e.g., “gke-node-scaler-topic”).
4. Click on the CREATE button.
5. Subscribe your Cloud Function to the topic by clicking on the SUBSCRIBE button.

Update your Cloud Scheduler job to publish a message to the topic when it runs. You can do this by adding a pubsubMessage property to the job with the desired data (e.g., “scale_down” or “scale_up”).

Conclusion

And that’s it! You’ve successfully set up an automated GKE cluster node scaling system that reduces your cloud expenses during off-peak hours. By following these steps, you can enjoy significant cost savings while ensuring your cluster is always ready to meet your business needs.

Remember to monitor your cluster’s performance and adjust the scaling parameters as needed. Happy scaling!

Frequently Asked Question

Want to know the secret to slashing your cloud expenses? We’ve got you covered!