Developing a Go Application for AWS EKS Management

Introduction
Prerequisites
Setting Up AWS EKS
Creating a Go Application
Deploying the Go Application to AWS EKS
Conclusion

Introduction

In this tutorial, we will learn how to develop a Go application for managing AWS Elastic Kubernetes Service (EKS). AWS EKS is a fully managed Kubernetes service provided by Amazon Web Services. By the end of this tutorial, you will be able to create a Go application that interacts with AWS EKS to manage your Kubernetes clusters.

Prerequisites

Before starting this tutorial, you should have the following prerequisites:

Basic knowledge of Go programming language.
An AWS account. If you don’t have one, you can create a free account at AWS Free Tier.
Set up the AWS Command Line Interface (CLI) by following the AWS CLI User Guide.
Install the AWS SDK for Go by running the following command:
```
 go get github.com/aws/aws-sdk-go/aws
```

Setting Up AWS EKS

First, let’s set up AWS EKS by following these steps:

Login to the AWS Management Console.
Navigate to the Amazon EKS console.
Click on “Create cluster” to create a new EKS cluster.
Enter a name for your cluster and choose the desired region.
Select the Kubernetes version and choose the desired VPC configuration.
Configure the cluster’s permissions and role.
Review your settings and click on “Create” to create the EKS cluster.

Make sure to take note of the cluster’s endpoint and the associated security group, as we will need them later.

Creating a Go Application

Now, let’s create a Go application that interacts with AWS EKS:

Create a new Go project by running the following command:
```
 mkdir my-eks-app
 cd my-eks-app
 go mod init github.com/username/my-eks-app
```
Replace “username” with your GitHub username or any other desired name.

Install the required AWS SDK packages by running the following commands:

 go get github.com/aws/aws-sdk-go/aws
 go get github.com/aws/aws-sdk-go/aws/session
 go get github.com/aws/aws-sdk-go/service/eks

Create a new file called main.go and open it in a text editor.

Import the required packages in main.go:

 package main
    
 import (
 	"fmt"
 	"os"
    
 	"github.com/aws/aws-sdk-go/aws/session"
 	"github.com/aws/aws-sdk-go/service/eks"
 )

Set up a new AWS session in the main function:

 func main() {
 	sess, err := session.NewSessionWithOptions(session.Options{
 		SharedConfigState: session.SharedConfigEnable,
 	})
 	if err != nil {
 		fmt.Println("Failed to create AWS session:", err)
 		os.Exit(1)
 	}
    
 	// Create an EKS client using the session
 	svc := eks.New(sess)
 }

Add code to list the existing EKS clusters:

 func main() {
 	// ...
    
 	// List EKS clusters
 	input := &eks.ListClustersInput{}
 	result, err := svc.ListClusters(input)
 	if err != nil {
 		fmt.Println("Failed to list EKS clusters:", err)
 		os.Exit(1)
 	}
    
 	fmt.Println("Existing EKS clusters:")
 	for _, cluster := range result.Clusters {
 		fmt.Println(*cluster)
 	}
 }

Build and run the application:
```
 go build
 ./my-eks-app
```
You should see a list of existing EKS clusters printed to the console.

Deploying the Go Application to AWS EKS

To deploy the Go application to AWS EKS, we will use the AWS Elastic Container Service for Kubernetes (EKS) and AWS CloudFormation.

Create a new folder called eks-manifests in the root of your project.

Create a file called deployment.yaml inside the eks-manifests folder, and define the deployment manifest for your Go application:

 apiVersion: apps/v1
 kind: Deployment
 metadata:
   name: my-eks-app-deployment
   labels:
     app: my-eks-app
 spec:
   replicas: 2
   selector:
     matchLabels:
       app: my-eks-app
   template:
     metadata:
       labels:
         app: my-eks-app
     spec:
       containers:
       - name: my-eks-app
         image: <your-docker-image>
         ports:
         - containerPort: 8080

Replace <your-docker-image> with the Docker image URL of your Go application.

Create a file called service.yaml inside the eks-manifests folder, and define the service manifest for your Go application:

 apiVersion: v1
 kind: Service
 metadata:
   name: my-eks-app-service
 spec:
   selector:
     app: my-eks-app
   ports:
     - protocol: TCP
       port: 80
       targetPort: 8080
   type: LoadBalancer

Deploy the manifests to AWS EKS by running the following command:
```
 aws eks update-kubeconfig --region <desired-region> --name <your-eks-cluster-name>
 kubectl apply -f eks-manifests
```
Replace <desired-region> with the desired AWS region and <your-eks-cluster-name> with the name of your EKS cluster.
Verify that the application is running by checking the load balancer’s URL:
```
 kubectl get service my-eks-app-service
```
You should see the load balancer’s URL in the output. Accessing this URL in a web browser should display your running Go application.

Conclusion

In this tutorial, you have learned how to develop a Go application for managing AWS EKS. You have set up AWS EKS, created a Go application that interacts with AWS EKS, and deployed the application to AWS EKS using AWS CloudFormation and Kubernetes manifests.

With this knowledge, you can now further explore and enhance your Go application to perform various tasks and automate the management of your AWS EKS clusters. Happy coding!

Published: 12 November 2020