Creating a Go CLI for Azure Resource Management

Introduction
Prerequisites
Setting Up Azure
Installing Go
Creating a Go CLI
Connecting to Azure
Listing Resources
Creating a Resource
Deleting a Resource
Conclusion

Introduction

This tutorial will guide you through the process of creating a Command-Line Interface (CLI) tool using Go for managing Azure resources. By the end of this tutorial, you will have a fully functional CLI program that can connect to Azure, list resources, create resources, and delete resources.

Prerequisites

Before you begin, make sure you have the following:

Basic knowledge of Go programming language
An Azure account
Azure CLI installed on your machine

Setting Up Azure

To use the Azure CLI and connect to Azure, you need to set up an Azure account and obtain the necessary credentials. Follow these steps:

Sign up for an Azure account at https://azure.microsoft.com.
Install the Azure CLI by following the instructions provided here.
Open the command prompt or terminal and sign in to your Azure account by running the following command:
```
 az login
```
Follow the instructions to authenticate and log in to your Azure account.

Installing Go

To create our Go CLI, we need to install Go on our machine. Follow these steps to install Go:

Download the latest stable version of Go from https://golang.org/dl/.
Run the installer and follow the instructions to complete the installation.
Verify that Go has been installed correctly by opening a command prompt or terminal and running the following command:
```
 go version
```
You should see the installed Go version displayed in the output.

Creating a Go CLI

Now that we have set up Azure and installed Go, let’s create our Go CLI. Here are the steps:

Open your favorite text editor or Integrated Development Environment (IDE) to create a new Go source file.
Create a new Go module by running the following command in the terminal:
```
 go mod init <module-name>
```
Replace <module-name> with the name of your module, for example, go-cli-azure.
Set up the necessary dependencies by running the following command:
```
 go get github.com/Azure/azure-sdk-for-go
```
This command will fetch and install the Azure SDK for Go.

Write the code for your CLI tool by importing the required packages and defining the necessary functions to connect to Azure, list resources, create resources, and delete resources. Here is a basic example:

 package main
    
 import (
 	"context"
 	"fmt"
 	"os"
    
 	"github.com/Azure/azure-sdk-for-go/services/resources/mgmt/2021-04-01/resources"
 	"github.com/Azure/azure-sdk-for-go/auth"
 )
    
 func main() {
 	resourceGroupName := "my-resource-group"
    
 	err := listResources(resourceGroupName)
 	if err != nil {
 		fmt.Printf("Failed to list resources: %s", err)
 		os.Exit(1)
 	}
    
 	err = createResource(resourceGroupName)
 	if err != nil {
 		fmt.Printf("Failed to create resource: %s", err)
 		os.Exit(1)
 	}
    
 	err = deleteResource(resourceGroupName)
 	if err != nil {
 		fmt.Printf("Failed to delete resource: %s", err)
 		os.Exit(1)
 	}
 }
    
 func listResources(resourceGroupName string) error {
     // Connect to Azure
 	authorizer, err := auth.NewAuthorizerFromEnvironment()
 	if err != nil {
 		return err
 	}
    
     // Create a resources client
 	client := resources.NewGroupsClient("<subscription-id>")
 	client.Authorizer = authorizer
    
     // List resources in the specified resource group
 	result, err := client.List(context.Background(), "<location>")
 	if err != nil {
 		return err
 	}
    
     // Display the resource names
 	for _, resource := range result.Values() {
 		fmt.Println(*resource.Name)
 	}
    
 	return nil
 }
    
 func createResource(resourceGroupName string) error {
     // Connect to Azure (same as listResources)
    
     // Create a resource group
     _, err := client.CreateOrUpdate(context.Background(), "<location>", resources.Group{
         Location: &location,
         GroupProperties: &resources.GroupProperties{},
     })
     if err != nil {
         return err
     }
    
     fmt.Println("Resource created successfully")
     return nil
 }
    
 func deleteResource(resourceGroupName string) error {
     // Connect to Azure (same as listResources)
    
     // Delete the resource group
     _, err := client.Delete(context.Background(), "<location>")
     if err != nil {
         return err
     }
    
     fmt.Println("Resource deleted successfully")
     return nil
 }

Make sure to replace <subscription-id> and <location> with your subscription ID and desired location.

Connecting to Azure

In the code above, we used the auth.NewAuthorizerFromEnvironment() function to authenticate and connect to Azure using the Azure CLI credentials. This allows us to perform actions on Azure resources on behalf of the authenticated user.

Listing Resources

To list resources in a specific resource group, we created a resources.GroupsClient and called the List method, passing the desired resource group and context as parameters. The result is then iterated, and the resource names are printed.

Creating a Resource

To create a resource group, we used the CreateOrUpdate method of the resources.GroupsClient and provided the desired location and an empty resources.GroupProperties struct. The result is discarded, and a success message is printed.

Deleting a Resource

To delete a resource group, we used the Delete method of the resources.GroupsClient and provided the desired location. Again, the result is discarded, and a success message is printed.

Conclusion

Congratulations! You have successfully created a Go CLI for Azure Resource Management. You have learned how to connect to Azure, list resources, create resources, and delete resources using the Azure SDK for Go. Feel free to expand upon this basic CLI tool and add more functionality or integrate it into your own projects.

Remember to handle errors properly, incorporate proper input validation, and follow best practices for error handling and code organization.

Published: 12 July 2022