Writing a Go-Based AWS ECR Image Management Tool

Table of Contents

1. Introduction
2. Prerequisites
3. Setup
4. Creating an AWS ECR Repository
5. Pushing Docker Images to ECR
6. Listing Docker Images in ECR
7. Deleting Docker Images in ECR
8. Conclusion

Introduction

In this tutorial, we will learn how to write a Go-based tool for managing Docker images in Amazon Elastic Container Registry (ECR). The tool will allow us to create an ECR repository, push Docker images to the repository, list the images, and delete images from the repository.

By the end of this tutorial, you will be able to:

• Set up the necessary tools and AWS credentials for working with ECR.
• Create an ECR repository using Go.
• Push Docker images to the ECR repository using Go.
• List Docker images in the ECR repository using Go.
• Delete Docker images from the ECR repository using Go.

Prerequisites

Before getting started with this tutorial, you should have the following:

• Basic knowledge of Go programming language.
• Docker installed on your machine.
• An AWS account with appropriate permissions to create and manage ECR repositories.

Setup

To begin, let’s set up our development environment by installing the necessary packages and tools.

1. Install Go on your machine by following the official Go installation guide for your operating system.

2. Set up Go workspace by creating a directory for your Go projects. For example, you can create a directory named go in your home directory:

   ```bash
   mkdir ~/go
   ```
   

3. Set the GOPATH environment variable to your Go workspace directory. Add the following line to your shell configuration file (e.g., ~/.bashrc, ~/.zshrc):

   ```bash
   export GOPATH=~/go
   ```
   

4. Reload the shell configuration or open a new terminal window to apply the changes.

5. Install the AWS SDK for Go by running the following command:

   ```bash
   go get github.com/aws/aws-sdk-go/...
   ```
   
   This will download and install the AWS SDK for Go and its dependencies.
   

6. Configure your AWS credentials by creating a credentials file in the .aws directory in your home directory (~/.aws/credentials). Add your AWS access key ID and secret access key in the following format:

   ```plaintext
   [default]
   aws_access_key_id = YOUR_ACCESS_KEY_ID
   aws_secret_access_key = YOUR_SECRET_ACCESS_KEY
   ```
   
   Replace `YOUR_ACCESS_KEY_ID` and `YOUR_SECRET_ACCESS_KEY` with your actual credentials.
   

   Now that our development environment is set up, let’s move on to writing our Go-based AWS ECR image management tool.

Creating an AWS ECR Repository

To create an AWS ECR repository using Go, we will utilize the AWS SDK for Go and its ECR client.

Let’s create a new Go file named create_ecr_repository.go inside your Go workspace directory (~/go/src/github.com/your-username/ecr-tool).

package main

import (
	"fmt"

	"github.com/aws/aws-sdk-go/aws"
	"github.com/aws/aws-sdk-go/aws/session"
	"github.com/aws/aws-sdk-go/service/ecr"
)

func main() {
	// Create a new AWS session using the default region and credentials from the shared configuration file
	sess := session.Must(session.NewSessionWithOptions(session.Options{
		SharedConfigState: session.SharedConfigEnable,
	}))

	// Create a new ECR client
	svc := ecr.New(sess)

	// Specify the repository name
	repoName := "my-ecr-repo"

	// Create the ECR repository
	result, err := svc.CreateRepository(&ecr.CreateRepositoryInput{
		RepositoryName: aws.String(repoName),
	})
	if err != nil {
		fmt.Println("Error creating ECR repository:", err)
		return
	}

	// Print the ARN of the created repository
	fmt.Println("ECR repository ARN:", *result.Repository.RepositoryArn)
}

In the above code, we import necessary packages from the AWS SDK for Go. We create a new AWS session and an ECR client using the session.

Next, we specify the name of the ECR repository we want to create (repoName). We use the CreateRepository method of the ECR client to create the repository, passing the repository name as an input.

If the repository creation is successful, we print the ARN (Amazon Resource Name) of the created repository.

To run this Go script, navigate to the directory where the script is located (~/go/src/github.com/your-username/ecr-tool) and execute the following command:

go run create_ecr_repository.go

You should see the ARN of the created ECR repository printed to the console.

Pushing Docker Images to ECR

Next, let’s see how we can push Docker images to the ECR repository using our Go-based tool.

To push Docker images to the ECR repository, we will utilize the docker command-line tool and the AWS SDK for Go.

First, make sure you have Docker installed on your machine and that you are logged in to the Docker Registry associated with your ECR repository.

To push a Docker image to the ECR repository, follow these steps:

1. Build a Docker image from your application using the docker build command. For example:

   ```bash
   docker build -t my-app:latest .
   ```
   
   This will build a Docker image with the tag `my-app:latest` using the Dockerfile in the current directory.
   

2. Tag the Docker image with the ECR repository URI. Replace YOUR_ECR_REPOSITORY_URI with the URI of your ECR repository, which can be obtained from the console or using the AWS CLI.

   ```bash
   docker tag my-app:latest YOUR_ECR_REPOSITORY_URI
   ```
   
   For example:
   
   ```bash
   docker tag my-app:latest 123456789012.dkr.ecr.us-west-2.amazonaws.com/my-ecr-repo
   ```
   

3. Push the Docker image to the ECR repository using the docker push command:

   ```bash
   docker push YOUR_ECR_REPOSITORY_URI
   ```
   
   For example:
   
   ```bash
   docker push 123456789012.dkr.ecr.us-west-2.amazonaws.com/my-ecr-repo
   ```
   

   The above steps demonstrate how to manually push a Docker image to an ECR repository. To automate this process using Go, we can utilize the Docker SDK for Go to build and push Docker images programmatically.

Listing Docker Images in ECR

To list Docker images in an ECR repository using Go, we will use the AWS SDK for Go and its ECR client.

Let’s create a new Go file named list_ecr_images.go inside your Go workspace directory (~/go/src/github.com/your-username/ecr-tool).

package main

import (
	"fmt"

	"github.com/aws/aws-sdk-go/aws"
	"github.com/aws/aws-sdk-go/aws/session"
	"github.com/aws/aws-sdk-go/service/ecr"
)

func main() {
	// Create a new AWS session using the default region and credentials from the shared configuration file
	sess := session.Must(session.NewSessionWithOptions(session.Options{
		SharedConfigState: session.SharedConfigEnable,
	}))

	// Create a new ECR client
	svc := ecr.New(sess)

	// Specify the repository name
	repoName := "my-ecr-repo"

	// List the images in the ECR repository
	result, err := svc.DescribeImages(&ecr.DescribeImagesInput{
		RepositoryName: aws.String(repoName),
	})
	if err != nil {
		fmt.Println("Error listing ECR images:", err)
		return
	}

	// Print the image tags
	for _, image := range result.ImageDetails {
		fmt.Println("Image Tag:", *image.ImageTags[0])
	}
}

In the above code, we import necessary packages from the AWS SDK for Go. We create a new AWS session and an ECR client using the session.

Next, we specify the name of the ECR repository we want to list images from (repoName). We use the DescribeImages method of the ECR client to get the details of the images in the repository.

If the image listing is successful, we iterate through the image details and print the image tags.

To run this Go script, navigate to the directory where the script is located (~/go/src/github.com/your-username/ecr-tool) and execute the following command:

go run list_ecr_images.go

You should see the tags of the Docker images in the ECR repository printed to the console.

Deleting Docker Images in ECR

To delete Docker images from an ECR repository using Go, we will use the AWS SDK for Go and its ECR client.

Let’s create a new Go file named delete_ecr_images.go inside your Go workspace directory (~/go/src/github.com/your-username/ecr-tool).

package main

import (
	"fmt"

	"github.com/aws/aws-sdk-go/aws"
	"github.com/aws/aws-sdk-go/aws/session"
	"github.com/aws/aws-sdk-go/service/ecr"
)

func main() {
	// Create a new AWS session using the default region and credentials from the shared configuration file
	sess := session.Must(session.NewSessionWithOptions(session.Options{
		SharedConfigState: session.SharedConfigEnable,
	}))

	// Create a new ECR client
	svc := ecr.New(sess)

	// Specify the repository name
	repoName := "my-ecr-repo"

	// Specify the image tag to delete
	imageTag := "latest"

	// Get the image digest based on the image tag
	result, err := svc.DescribeImages(&ecr.DescribeImagesInput{
		RepositoryName: aws.String(repoName),
		Filter: &ecr.DescribeImagesFilter{
			TagStatus: aws.String("TAGGED"),
			TagStatus: aws.String("UNTAGGED"),
		},
	})
	if err != nil {
		fmt.Println("Error describing ECR images:", err)
		return
	}

	var imageDigest string

	// Find the image digest based on the specified image tag
	for _, image := range result.ImageDetails {
		if aws.StringValue(image.ImageTags[0]) == imageTag {
			imageDigest = aws.StringValue(image.ImageDigest)
			break
		}
	}

	// Delete the image based on the image digest
	_, err = svc.BatchDeleteImage(&ecr.BatchDeleteImageInput{
		RepositoryName: aws.String(repoName),
		ImageIds: []*ecr.ImageIdentifier{
			{
				ImageDigest: aws.String(imageDigest),
			},
		},
	})
	if err != nil {
		fmt.Println("Error deleting ECR image:", err)
		return
	}

	fmt.Println("ECR image deleted successfully.")
}

In the above code, we import necessary packages from the AWS SDK for Go. We create a new AWS session and an ECR client using the session.

Next, we specify the name of the ECR repository we want to delete images from (repoName). We also specify the image tag of the image we want to delete (imageTag).

We use the DescribeImages method of the ECR client to get the details of the images in the repository. Then, we find the image digest based on the specified image tag.

Finally, we use the BatchDeleteImage method of the ECR client to delete the image from the repository.

To run this Go script, navigate to the directory where the script is located (~/go/src/github.com/your-username/ecr-tool) and execute the following command:

go run delete_ecr_images.go

You should see a success message indicating that the ECR image has been deleted.

Conclusion

In this tutorial, we learned how to write a Go-based AWS ECR image management tool. We covered the following topics:

• Setting up the development environment with Go and the AWS SDK for Go.
• Creating an AWS ECR repository using Go.
• Pushing Docker images to an ECR repository using Go.
• Listing Docker images in an ECR repository using Go.
• Deleting Docker images from an ECR repository using Go.

With this knowledge, you can now create your own Go-based tools for managing Docker images in AWS ECR.

Published: 20 August 2020

Related Articles

• Implementing a Multi-Threaded Web Spider in Go
• Building a CLI for Docker Container Management in Go
• Writing a Kubernetes Custom Scheduler in Go
• Creating a Multi-Page Web Application in Go
• Handling I/O Errors in Go
• Creating a Go Application for Automated Kubernetes Rollbacks
• Writing a Go-Based CLI Tool for IP Address Lookup
• Building a Rate-Limited HTTP Server in Go
• Working with File Metadata in Go
• How to Use the os.FileInfo Interface in Go
• Reading and Writing to a Text File in Go
• Writing a CLI for Log Parsing in Go
• Developing a Real-Time Recommendation Engine with Go
• Understanding Standard Input and Standard Output in Go
• Developing a Command-Line File Sharing Tool in Go
• Building a Real-Time Trading App with Go and WebSockets
• Go Project Structure: A Guide to Scalable Applications
• Building a CLI for File System Operations in Go
• Interacting with the OS in Go: A Comprehensive Guide
• Creating a Go-Based Data Pipeline for Real Estate Data Analysis