Creating a Go-Based CLI for Google Kubernetes Engine

Table of Contents

  1. Introduction
  2. Prerequisites
  3. Setup

  4. Creating the CLI - Step 1: Setting up the CLI structure - Step 2: Authenticating with GKE - Step 3: Listing GKE clusters - Step 4: Creating a GKE cluster - Step 5: Deleting a GKE cluster

  5. Conclusion

Introduction

In this tutorial, we will create a command-line interface (CLI) tool using the Go programming language to interact with Google Kubernetes Engine (GKE). The CLI will provide functionality to authenticate with GKE, list existing GKE clusters, create a new GKE cluster, and delete an existing GKE cluster. By the end of this tutorial, you will have a working CLI that can manage GKE clusters.

Prerequisites

Before starting this tutorial, you should have the following:

  1. Basic knowledge of the Go programming language.

  2. A Google Cloud Platform (GCP) account with access to GKE.

  3. Go installed on your local machine.

Setup

To get started, you need to set up the following:

  1. Install the necessary Go packages: bash go get -u github.com/spf13/cobra go get -u cloud.google.com/go/container/apiv1

  2. Make sure you have the necessary GCP credentials (a service account key) to authenticate with GKE. Refer to the official documentation to set up the credentials.

Creating the CLI

Step 1: Setting up the CLI structure

Create a new Go module and initialize the project structure:

mkdir gke-cli
cd gke-cli
go mod init github.com/your-username/gke-cli

Next, create a new Go file with the following initial code:

package main

import "github.com/spf13/cobra"

var rootCmd = &cobra.Command{
  Use:   "gke-cli",
  Short: "A CLI tool to interact with Google Kubernetes Engine",
}

func main() {
  if err := rootCmd.Execute(); err != nil {
    fmt.Println(err)
    os.Exit(1)
  }
}

Step 2: Authenticating with GKE

First, import the necessary packages:

import (
    "context"
    "fmt"
    container "cloud.google.com/go/container/apiv1"
    "google.golang.org/api/option"
    "github.com/spf13/cobra"
)

Add a new subcommand for authentication:

var authCmd = &cobra.Command{
  Use:   "auth",
  Short: "Authenticate with Google Cloud Platform",
  Run: func(cmd *cobra.Command, args []string) {
    ctx := context.Background()
    client, err := container.NewClusterManagerClient(ctx, option.WithCredentialsFile("path/to/credentials.json"))
    if err != nil {
      fmt.Println(err)
      return
    }
    defer client.Close()

    // Perform authentication logic
    fmt.Println("Authenticated with GKE")
  },
}

Add the authCmd as a subcommand to the root command:

rootCmd.AddCommand(authCmd)

Step 3: Listing GKE clusters

Create a new command to list existing GKE clusters:

var listCmd = &cobra.Command{
  Use:   "list",
  Short: "List GKE clusters",
  Run: func(cmd *cobra.Command, args []string) {
    ctx := context.Background()
    client, err := container.NewClusterManagerClient(ctx, option.WithCredentialsFile("path/to/credentials.json"))
    if err != nil {
      fmt.Println(err)
      return
    }
    defer client.Close()

    // Perform list operation
    fmt.Println("Listing GKE clusters")
  },
}

rootCmd.AddCommand(listCmd)

Step 4: Creating a GKE cluster

Add a new command to create a GKE cluster:

var createCmd = &cobra.Command{
  Use:   "create",
  Short: "Create a new GKE cluster",
  Run: func(cmd *cobra.Command, args []string) {
    ctx := context.Background()
    client, err := container.NewClusterManagerClient(ctx, option.WithCredentialsFile("path/to/credentials.json"))
    if err != nil {
      fmt.Println(err)
      return
    }
    defer client.Close()

    // Perform create operation
    fmt.Println("Creating a new GKE cluster")
  },
}

rootCmd.AddCommand(createCmd)

Step 5: Deleting a GKE cluster

Finally, add a command to delete an existing GKE cluster:

var deleteCmd = &cobra.Command{
  Use:   "delete",
  Short: "Delete a GKE cluster",
  Run: func(cmd *cobra.Command, args []string) {
    ctx := context.Background()
    client, err := container.NewClusterManagerClient(ctx, option.WithCredentialsFile("path/to/credentials.json"))
    if err != nil {
      fmt.Println(err)
      return
    }
    defer client.Close()

    // Perform delete operation
    fmt.Println("Deleting an existing GKE cluster")
  },
}

rootCmd.AddCommand(deleteCmd)

Conclusion

In this tutorial, you have learned how to create a Go-based CLI tool for managing Google Kubernetes Engine (GKE) clusters. You have implemented commands for authenticating with GKE, listing existing clusters, creating a new cluster, and deleting an existing cluster. You can now extend this CLI tool further to include more commands and functionalities to suit your needs.

Remember to always handle errors properly and make necessary checks when interacting with GKE or any other external services. This ensures your CLI tool is robust and provides accurate feedback to the users.

Happy coding!

Published:

Related Articles