Unleashing the Power of Terraform: A Step-by-Step Guide to Simple Custom Resource Creation

Welcome to the world of Infrastructure as Code (IaC) with Terraform! As a DevOps enthusiast, you’re probably eager to explore the limitless possibilities of custom resource creation. In this article, we’ll embark on a thrilling adventure to craft a simple custom Terraform resource from scratch. Buckle up, and let’s dive into the unknown!

What’s the Buzz About Custom Resources?

In Terraform, resources represent the infrastructure components you want to create, update, or destroy. While Terraform provides an extensive library of built-in resources, there might be cases where you need to create a custom resource tailored to your specific requirements. Perhaps you want to interact with a proprietary API, create a custom database schema, or integrate with a niche service. Whatever the reason, custom resources empower you to extend Terraform’s capabilities and make it an even more powerful tool in your DevOps arsenal.

Gathering the Essentials

Before we begin, make sure you have the following items in your toolbox:

• Go installed on your machine (yes, you read that right – we’ll be writing some Go code!)
• A basic understanding of Go programming language
• Terraform installed and configured on your system
• A code editor or IDE of your choice

Step 1: Define Your Custom Resource

In this step, we’ll outline the structure and functionality of our custom resource. Let’s say we want to create a custom resource that interacts with a fictional API to manage “Greeting Cards” (because who doesn’t love a good greeting card?!)

// greeting_card.go
package main

import (
	"context"
	"fmt"
)

type GreetingCard struct {
	ID   string `json:"id"`
	Text string `json:"text"`
}

In this example, we’ve defined a simple GreetingCard struct with two attributes: ID and Text. This will serve as the foundation for our custom resource.

Step 2: Create a Terraform Provider

A Terraform provider acts as a bridge between Terraform and your custom resource. It provides the necessary functionality to create, read, update, and delete (CRUD) your resource. Let’s create a new file called greeting_card_provider.go:

// greeting_card_provider.go
package main

import (
	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
)

func resourceGreetingCard() *schema.Resource {
	return &schema.Resource{
		Schema: map[string]*schema.Schema{
			"text": {
				Type:     schema.TypeString,
				Required: true,
			},
		},
		Create: resourceGreetingCardCreate,
		Read:   resourceGreetingCardRead,
		Update: resourceGreetingCardUpdate,
		Delete: resourceGreetingCardDelete,
	}
}

func resourceGreetingCardCreate(d *schema.ResourceData, meta interface{}) error {
	// Create logic goes here
	return nil
}

func resourceGreetingCardRead(d *schema.ResourceData, meta interface{}) error {
	// Read logic goes here
	return nil
}

func resourceGreetingCardUpdate(d *schema.ResourceData, meta interface{}) error {
	// Update logic goes here
	return nil
}

func resourceGreetingCardDelete(d *schema.ResourceData, meta interface{}) error {
	// Delete logic goes here
	return nil
}

In this example, we’ve defined a Terraform provider with CRUD functions for our GreetingCard resource. We’ll implement the logic for these functions in the next step.

Step 3: Implement the CRUD Functions

Now it’s time to add some meat to our CRUD functions! Let’s assume we have a fictional API endpoint https://api.example.com/greeting-cards that we’ll interact with using HTTP requests:

// greeting_card_provider.go
func resourceGreetingCardCreate(d *schema.ResourceData, meta interface{}) error {
	client := &http.Client{}
	req, err := http.NewRequest("POST", "https://api.example.com/greeting-cards", bytes.NewBufferString(`{"text": "`+d.Get("text").(string)+`"}`))
	if err != nil {
		return err
	}
	req.Header.Set("Content-Type", "application/json")
	resp, err := client.Do(req)
	if err != nil {
		return err
	}
	defer resp.Body.Close()
	var greetingCard GreetingCard
	err = json.NewDecoder(resp.Body).Decode(&greetingCard)
	if err != nil {
		return err
	}
	d.SetId(greetingCard.ID)
	return nil
}

func resourceGreetingCardRead(d *schema.ResourceData, meta interface{}) error {
	client := &http.Client{}
	req, err := http.NewRequest("GET", "https://api.example.com/greeting-cards/"+d.Id(), nil)
	if err != nil {
		return err
	}
	req.Header.Set("Content-Type", "application/json")
	resp, err := client.Do(req)
	if err != nil {
		return err
	}
	defer resp.Body.Close()
	var greetingCard GreetingCard
	err = json.NewDecoder(resp.Body).Decode(&greetingCard)
	if err != nil {
		return err
	}
	d.Set("text", greetingCard.Text)
	return nil
}

func resourceGreetingCardUpdate(d *schema.ResourceData, meta interface{}) error {
	client := &http.Client{}
	req, err := http.NewRequest("PATCH", "https://api.example.com/greeting-cards/"+d.Id(), bytes.NewBufferString(`{"text": "`+d.Get("text").(string)+`"}`))
	if err != nil {
		return err
	}
	req.Header.Set("Content-Type", "application/json")
	resp, err := client.Do(req)
	if err != nil {
		return err
	}
	defer resp.Body.Close()
	return nil
}

func resourceGreetingCardDelete(d *schema.ResourceData, meta interface{}) error {
	client := &http.Client{}
	req, err := http.NewRequest("DELETE", "https://api.example.com/greeting-cards/"+d.Id(), nil)
	if err != nil {
		return err
	}
	resp, err := client.Do(req)
	if err != nil {
		return err
	}
	defer resp.Body.Close()
	return nil
}

We’ve implemented the CRUD functions using HTTP requests to interact with our fictional API. Note that this is a simplified example and you should adapt it to your specific use case.

Step 4: Register the Terraform Provider

To register our Terraform provider, create a new file called main.go:

// main.go
package main

import (
	"github.com/hashicorp/terraform-plugin-sdk/v2/plugin"
)

func main() {
	plugin.Serve(&plugin.ServeOpts{
		ProviderFunc: func() *schema.Provider {
			return &schema.Provider{
				Schema: map[string]*schema.Schema{
					"greeting_card": resourceGreetingCard(),
				},
			}
		},
	})
}

This file registers our Terraform provider with the greeting_card resource.

Step 5: Build and Install the Terraform Provider

Compile the Go code and build the Terraform provider:

go build -o terraform-provider-greeting-card main.go

Move the compiled binary to a directory in your system’s PATH, such as /usr/local/bin on Linux/macOS or C:\Program Files\terraform.d\plugins on Windows:

mv terraform-provider-greeting-card /usr/local/bin/

Step 6: Use Your Custom Resource in Terraform

Create a new Terraform configuration file called main.tf:

// main.tf
provider "greeting_card" {
}

resource "greeting_card" "example" {
  text = "Hello, Terraform!"
}

Initialize Terraform and apply the configuration:

terraform init
terraform apply

Congratulations! You’ve successfully created a simple custom Terraform resource using Go. You can now use this resource in your Terraform configurations to manage your “Greeting Cards” API.