Creating a Custom Terraform Provider with Go

Introduction
Prerequisites
Setting Up Terraform
Creating the Custom Provider
Implementing Resources
Building and Testing the Provider
Conclusion

Introduction

In this tutorial, we will learn how to create a custom Terraform provider using Go. Terraform is an open-source infrastructure as code tool that enables you to define and provision infrastructure resources using declarative configuration files. By creating a custom provider, you can extend Terraform’s capabilities and manage resources in your own infrastructure.

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

Understand the basics of creating a custom Terraform provider.
Implement resources and data sources in the provider.
Build and test the custom provider.

Let’s get started!

Prerequisites

Before diving into the tutorial, you should have:

Basic knowledge of Go programming language.
Familiarity with Terraform and its concepts.
Go development environment set up on your machine.

Setting Up Terraform

First, let’s ensure Terraform is installed on your system. Follow these steps to set up Terraform:

Visit the Terraform downloads page.
Download the appropriate package for your operating system.
Extract the downloaded package to a directory of your choice.
Add the Terraform binary location to your system’s PATH variable.

To verify the installation, open a terminal and run the following command:
```
 terraform version
```
If Terraform is installed correctly, you should see the version information.

Creating the Custom Provider

To create a custom Terraform provider, follow these steps:

Create a new directory for your custom provider project. For example, my-terraform-provider.

Initialize the project with Go modules by running the following command:

```shell
go mod init github.com/your-username/my-terraform-provider
```

Create the main provider file, typically named provider.go. This file will define the provider and its resources.

```go
package main
   
import (
    "github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
)
   
func Provider() *schema.Provider {
    return &schema.Provider{
        // Define provider configurations here
        // ...
    }
}
```

Add necessary imports and define the provider configuration in the Provider() function.

```go
import (
    "github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
)
   
func Provider() *schema.Provider {
    return &schema.Provider{
        ResourcesMap: map[string]*schema.Resource{
            // Define resources here
            // ...
        },
        DataSourcesMap: map[string]*schema.Resource{
            // Define data sources here
            // ...
        },
    }
}
```

Implement the provider configuration, including resource and data source definitions.
Continue implementing the necessary resources and data sources for your provider.

Implementing Resources

To implement resources in your custom provider, follow these steps:

Step 1: Define the Resource Schema

In the Provider() function, define the schema for the resource using schema.Resource:

func Provider() *schema.Provider {
    return &schema.Provider{
        ResourcesMap: map[string]*schema.Resource{
            "my_custom_resource": &schema.Resource{
                Schema: map[string]*schema.Schema{
                    // Define resource schema here
                    // ...
                },
                Create: createResourceFunc,
                Read:   readResourceFunc,
                Update: updateResourceFunc,
                Delete: deleteResourceFunc,
            },
        },
        // ...
    }
}

Replace "my_custom_resource" with the desired resource name and implement the functions createResourceFunc, readResourceFunc, updateResourceFunc, and deleteResourceFunc for resource management.

Step 2: Implement Resource Functions

Define the functions to handle resource management:

func createResourceFunc(d *schema.ResourceData, m interface{}) error {
    // Implement resource creation logic here
    // ...
}

func readResourceFunc(d *schema.ResourceData, m interface{}) error {
    // Implement resource read logic here
    // ...
}

func updateResourceFunc(d *schema.ResourceData, m interface{}) error {
    // Implement resource update logic here
    // ...
}

func deleteResourceFunc(d *schema.ResourceData, m interface{}) error {
    // Implement resource deletion logic here
    // ...
}

Replace the function bodies with your own resource management logic, which may involve communicating with external APIs or making system-level changes.

Building and Testing the Provider

After implementing the custom provider and resources, it’s time to build and test the provider. Follow these steps:

Build the provider by running the following command in the project directory:

```shell
go build -o terraform-provider-my-custom
```

This command generates the provider binary, named `terraform-provider-my-custom`.

Move the binary to a location on your system’s PATH.
Initialize a new Terraform project by creating a main.tf file with your desired resources and configurations.
Run the following command to download the provider’s dependencies:
```
```shell
terraform init
```
```

Use the custom provider in your Terraform configuration:

```hcl
terraform {
  required_providers {
    my-custom = {
      source = "github.com/your-username/my-terraform-provider"
    }
  }
}
   
resource "my_custom_resource" "example" {
  // Resource configurations here
}
```

Run the Terraform commands to apply the changes:

```shell
terraform plan
terraform apply
```

Terraform will use your custom provider to create, update, or delete resources according to your configuration.

Conclusion

In this tutorial, we learned how to create a custom Terraform provider using Go. We covered the basic steps of setting up Terraform, creating the provider, implementing resources, and testing the provider. With this knowledge, you can now extend Terraform’s capabilities by creating your own custom providers.

Remember to refer to official Terraform and Go documentation for detailed information on specific features and best practices.

Happy coding!

Published: 14 August 2019