Step by Step Guide to Building a Duda API Integration in Go

Aug 15, 2024 • 6 minute read

Introduction

Hey there, fellow developer! Ready to dive into the world of Duda API integration with Go? You're in for a treat. Duda's API is a powerhouse for website creation and management, and Go's simplicity and efficiency make it the perfect dance partner. Let's get this integration party started!

Prerequisites

Before we jump in, make sure you've got:

Go installed (you're a pro, so I'm sure you do)
Duda API credentials (if you don't have 'em, grab 'em quick!)
Your favorite code editor at the ready

Setting up the project

Alright, let's lay the groundwork:

mkdir duda-api-integration
cd duda-api-integration
go mod init github.com/yourusername/duda-api-integration

Now, let's grab the essentials:

go get github.com/go-resty/resty/v2

Authentication

Time to get cozy with Duda's API. Create a config.go file:

package main

import "os"

func getAPICredentials() (string, string) {
    return os.Getenv("DUDA_API_KEY"), os.Getenv("DUDA_API_SECRET")
}

Pro tip: Keep those credentials safe in environment variables!

Making API requests

Let's create a client.go file to handle our HTTP shenanigans:

package main

import (
    "github.com/go-resty/resty/v2"
)

const baseURL = "https://api.duda.co/api"

func newClient() *resty.Client {
    client := resty.New()
    apiKey, apiSecret := getAPICredentials()
    client.SetBasicAuth(apiKey, apiSecret)
    client.SetBaseURL(baseURL)
    return client
}

Implementing key Duda API endpoints

Now for the fun part! Let's create some functions to interact with Duda's API. In main.go:

package main

import (
    "fmt"
    "log"
)

func listWebsites() ([]map[string]interface{}, error) {
    client := newClient()
    resp, err := client.R().
        SetResult([]map[string]interface{}{}).
        Get("/sites/multiscreen")
    if err != nil {
        return nil, err
    }
    return *resp.Result().(*[]map[string]interface{}), nil
}

func createWebsite(name string) (map[string]interface{}, error) {
    client := newClient()
    resp, err := client.R().
        SetBody(map[string]string{"template_id": "1067972"}).
        SetResult(map[string]interface{}{}).
        Post("/sites/multiscreen/create")
    if err != nil {
        return nil, err
    }
    return *resp.Result().(*map[string]interface{}), nil
}

func main() {
    websites, err := listWebsites()
    if err != nil {
        log.Fatal(err)
    }
    fmt.Printf("Found %d websites\n", len(websites))

    newSite, err := createWebsite("My Awesome Site")
    if err != nil {
        log.Fatal(err)
    }
    fmt.Printf("Created new site: %v\n", newSite)
}

Error handling and logging

You've probably noticed we're already doing some basic error handling. For more robust logging, consider using a package like logrus.

Testing the integration

Time to put our code through its paces:

package main

import (
    "testing"
)

func TestListWebsites(t *testing.T) {
    websites, err := listWebsites()
    if err != nil {
        t.Fatalf("Error listing websites: %v", err)
    }
    if len(websites) == 0 {
        t.Log("No websites found, but request was successful")
    }
}

Run it with go test -v.

Best practices and optimization

Remember to implement rate limiting to play nice with Duda's API. You might want to check out the golang.org/x/time/rate package for this.

For caching, consider using an in-memory store like go-cache for frequently accessed data.

Conclusion

And there you have it! You've just built a solid foundation for a Duda API integration in Go. From here, sky's the limit. Why not try implementing more endpoints or building a CLI tool?

Resources

Now go forth and create amazing things with Duda and Go! Happy coding!