Unlocking the Power of Kubernetes: A Step-by-Step Guide to Creating a Kubernetes Client with Go SDK for AWS EKS with Automatic Token Refresh

In the world of cloud computing, Kubernetes has become the de facto standard for container orchestration. Amazon Web Services (AWS) offers a managed Kubernetes service called Amazon Elastic Container Service for Kubernetes (EKS), making it easier to deploy and manage containerized applications. However, to interact with EKS, you need a Kubernetes client. In this article, we’ll explore how to create a Kubernetes client using the Go SDK, complete with automatic token refresh, to seamlessly interact with your EKS cluster.

Prerequisites

Before we dive into the implementation, make sure you have the following prerequisites in place:

• AWS account with EKS cluster setup
• Go programming language installed on your machine (version 1.17 or later)
• AWS CLI configured with your EKS cluster credentials
• Kubernetes Go SDK installed (we’ll cover this in the next section)

Installing the Kubernetes Go SDK

To create a Kubernetes client using Go, you need to install the Kubernetes Go SDK. You can do this using the following command:

go get -u k8s.io/client-go/...

This command will fetch the latest version of the Kubernetes Go SDK and its dependencies.

Creating a Kubernetes Client with Go SDK

Now that you have the Kubernetes Go SDK installed, let’s create a simple Kubernetes client using Go.

package main

import (
	"context"
	"fmt"

	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
	"k8s.io/client-go/kubernetes"
	"k8s.io/client-go/rest"
)

In this code snippet, we’re importing the necessary packages, including the Kubernetes Go SDK. The main function will create a new Kubernetes client:

func main() {
	// Create a new Kubernetes client
	config, err := rest.InClusterConfig()
	if err != nil {
		fmt.Println(err)
		return
	}

	clientset, err := kubernetes.NewForConfig(config)
	if err != nil {
		fmt.Println(err)
		return
	}

	// Get a list of nodes
	nodes, err := clientset.CoreV1().Nodes().List(context.TODO(), metav1.ListOptions{})
	if err != nil {
		fmt.Println(err)
		return
	}

	// Print the node names
	for _, node := range nodes.Items {
		fmt.Println(node.Name)
	}
}

This code creates a new Kubernetes client using the `kubernetes.NewForConfig()` function, which takes a `rest.Config` object as an argument. We’re using the `rest.InClusterConfig()` function to create a `rest.Config` object that points to the EKS cluster.

Configuring the Kubernetes Client for AWS EKS

To use the Kubernetes client with your EKS cluster, you need to configure it with your AWS credentials and EKS cluster endpoint. Create a new file called `aws.go` with the following content:

package main

import (
	"context"
	"fmt"
	"log"

	"github.com/aws/aws-sdk-go/aws"
	"github.com/aws/aws-sdk-go/aws/session"
	"k8s.io/client-go/rest"
	"k8s.io/client-go/tools/clientcmd"
)

In this file, we’re importing the necessary packages, including the AWS SDK for Go and the Kubernetes Go SDK. The `getCredentials()` function will retrieve your AWS credentials:

func getCredentials() (*aws.Credentials, error) {
	sess, err := session.NewSession(&aws.Config{Region: aws.String("your-region")}, nil)
	if err != nil {
		return nil, err
	}

	creds, err := sess.Credentials.Get()
	if err != nil {
		return nil, err
	}

	return creds, nil
}

The `getEKSConfig()` function will create a `rest.Config` object with your EKS cluster endpoint and credentials:

func getEKSConfig(creds *aws.Credentials) (*rest.Config, error) {
	clusterName := "your-eks-cluster-name"
	region := "your-region"

	config, err := rest.InClusterConfig()
	if err != nil {
		return nil, err
	}

	// Set the EKS cluster endpoint
	endpoint, err := getEKSAPIEndpoint(clusterName, region)
	if err != nil {
		return nil, err
	}

	config.Host = endpoint

	// Set the AWS credentials
	config.TLSClientConfig.CertData = creds.GetCredential().Certificate
	config.TLSClientConfig.KeyData = creds.GetCredential().PrivateKey

	return config, nil
}

The `getEKSAPIEndpoint()` function will retrieve the EKS cluster endpoint using the AWS SDK for Go:

func getEKSAPIEndpoint(clusterName string, region string) (string, error) {
	svc := eks.New(session.New())
	input := &eks.DescribeClusterInput{
		Name: aws.String(clusterName),
	}

	result, err := svc.DescribeCluster(context.TODO(), input)
	if err != nil {
		return "", err
	}

	return *result.Cluster.Endpoint, nil
}

Now, let’s update the `main()` function in the previous code snippet to use the `getEKSConfig()` function:

func main() {
	// Get AWS credentials
	creds, err := getCredentials()
	if err != nil {
		log.Fatal(err)
	}

	// Get EKS config
	eksConfig, err := getEKSConfig(creds)
	if err != nil {
		log.Fatal(err)
	}

	// Create a new Kubernetes client
	clientset, err := kubernetes.NewForConfig(eksConfig)
	if err != nil {
		log.Fatal(err)
	}

	// Get a list of nodes
	nodes, err := clientset.CoreV1().Nodes().List(context.TODO(), metav1.ListOptions{})
	if err != nil {
		log.Fatal(err)
	}

	// Print the node names
	for _, node := range nodes.Items {
		fmt.Println(node.Name)
	}
}

In this updated code, we’re using the `getEKSConfig()` function to create a `rest.Config` object with your EKS cluster endpoint and credentials. We then pass this `rest.Config` object to the `kubernetes.NewForConfig()` function to create a new Kubernetes client.

Implementing Automatic Token Refresh

To implement automatic token refresh, we’ll use the `token` package from the Kubernetes Go SDK. Create a new file called `token.go` with the following content:

package main

import (
	"context"
	"fmt"
	"time"

	"k8s.io/client-go/token"
)

In this file, we’ll create a `tokenManager` struct to manage the token refresh:

type tokenManager struct {
	tokenGetter *token.GetToken
	client      *http.Client
}

The `tokenManager` struct has two fields: `tokenGetter`, which is used to get the token from the EKS cluster, and `client`, which is an HTTP client used to send requests to the EKS cluster.

func (t *tokenManager) GetToken(ctx context.Context) (*token.Token, error) {
	token, err := t.tokenGetter.GetToken(ctx)
	if err != nil {
		return nil, err
	}

	// Refresh the token if it's near expiration
 если token.Expiration.Before(time.Now().Add(30 * time.Second)) {
		token, err = t.tokenGetter.GetToken(ctx)
		if err != nil {
			return nil, err
		}
	}

	return token, nil
}

In the `GetToken()` function, we’re using the `tokenGetter` to get the token from the EKS cluster. We’re also checking if the token is near expiration and refreshing it if necessary.

Now, let’s update the `main()` function to use the `tokenManager` struct:

func main() {
	// Get AWS credentials
	creds, err := getCredentials()
	if err != nil {
		log.Fatal(err)
	}

	// Get EKS config
	eksConfig, err := getEKSConfig(creds)
	if err != nil {
		log.Fatal(err)
	}

	// Create a token manager
	tokenManager := &tokenManager{
		tokenGetter: &token.GetToken{
			Config: eksConfig,
		},
		client: &http.Client{},
	}

	// Create a new Kubernetes client with token manager
	clientset, err := kubernetes.NewForConfig(tokenManager)
	if err != nil {
		log.Fatal(err)
	}

	// Get a list of nodes
	nodes, err := clientset.CoreV1().Nodes().List(context.TODO(), metav1.ListOptions{})
	if err != nil {
		log.Fatal(err)
	}

	// Print the node names
	for _, node := range nodes.Items {
		fmt.Println(node.Name)
	}
}

In this updated code, we’re creating a `tokenManager` struct and passing it to the

Frequently Asked Questions

Get ready to dive into the world of Kubernetes and AWS EKS with automatic token refresh using Go SDK!