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

Introduction

Hey there, fellow Go enthusiast! Ready to dive into the world of Heroku API integration? You're in for a treat. We'll be using the awesome heroku-go package to make our lives easier. Buckle up, and let's get coding!

Prerequisites

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

• Go installed (I know you probably do, but just checking!)
• A Heroku account with an API key
• Some basic Go skills and RESTful API knowledge

Got all that? Great! Let's roll.

Setting up the project

First things first, let's create a new Go project:

mkdir heroku-api-integration
cd heroku-api-integration
go mod init heroku-api-integration

Now, let's grab the heroku-go package:

go get github.com/heroku/heroku-go/v5

Authenticating with Heroku API

Time to get cozy with the Heroku API. We'll need to set up our API key and create a client:

import (
    "os"
    heroku "github.com/heroku/heroku-go/v5"
)

func main() {
    herokuAPIKey := os.Getenv("HEROKU_API_KEY")
    herokuClient := heroku.NewService(&http.Client{
        Transport: &heroku.Transport{
            BearerToken: herokuAPIKey,
        },
    })
}

Pro tip: Keep that API key safe! Using environment variables is a smart move.

Basic API operations

Now that we're all set up, let's flex those API muscles with some basic operations.

Listing apps

apps, err := herokuClient.AppList(context.Background(), &heroku.ListRange{})
if err != nil {
    log.Fatal(err)
}
for _, app := range apps {
    fmt.Printf("App: %s\n", app.Name)
}

Creating a new app

newApp, err := herokuClient.AppCreate(context.Background(), heroku.AppCreateOpts{
    Name: heroku.String("my-awesome-app"),
})
if err != nil {
    log.Fatal(err)
}
fmt.Printf("Created app: %s\n", newApp.Name)

Retrieving app information

app, err := herokuClient.AppInfo(context.Background(), "my-awesome-app")
if err != nil {
    log.Fatal(err)
}
fmt.Printf("App Name: %s, Region: %s\n", app.Name, app.Region.Name)

Advanced operations

Ready to level up? Let's tackle some more complex operations.

Managing dynos

formation, err := herokuClient.FormationUpdate(context.Background(), "my-awesome-app", "web", heroku.FormationUpdateOpts{
    Quantity: heroku.Int(2),
    Size:     heroku.String("standard-1x"),
})
if err != nil {
    log.Fatal(err)
}
fmt.Printf("Updated formation: %d %s dynos\n", *formation.Quantity, *formation.Size)

Deploying code

source := heroku.Source{
    Version: heroku.String("v1.0"),
}
build, err := herokuClient.BuildCreate(context.Background(), "my-awesome-app", source)
if err != nil {
    log.Fatal(err)
}
fmt.Printf("Build status: %s\n", build.Status)

Configuring add-ons

addon, err := herokuClient.AddonCreate(context.Background(), "my-awesome-app", heroku.AddonCreateOpts{
    Plan: heroku.String("heroku-postgresql:hobby-dev"),
})
if err != nil {
    log.Fatal(err)
}
fmt.Printf("Added add-on: %s\n", addon.Plan.Name)

Error handling and best practices

Let's talk about keeping our code robust and reliable.

Dealing with rate limits

The Heroku API has rate limits, so be a good citizen:

if err != nil {
    if herokuErr, ok := err.(*heroku.Error); ok && herokuErr.ID == "rate_limit" {
        time.Sleep(10 * time.Second)
        // Retry the request
    }
}

Handling API errors

Always check for errors and handle them gracefully:

if err != nil {
    if herokuErr, ok := err.(*heroku.Error); ok {
        fmt.Printf("Heroku API error: %s (ID: %s)\n", herokuErr.Message, herokuErr.ID)
    } else {
        fmt.Printf("Unexpected error: %v\n", err)
    }
    return
}

Implementing retries

For those pesky network hiccups:

func retryOperation(operation func() error) error {
    maxRetries := 3
    for i := 0; i < maxRetries; i++ {
        err := operation()
        if err == nil {
            return nil
        }
        time.Sleep(time.Duration(i+1) * time.Second)
    }
    return fmt.Errorf("operation failed after %d retries", maxRetries)
}

Testing the integration

Don't forget to test your code! Here's a quick example:

func TestAppCreate(t *testing.T) {
    client := mockHerokuClient()
    app, err := client.AppCreate(context.Background(), heroku.AppCreateOpts{
        Name: heroku.String("test-app"),
    })
    assert.NoError(t, err)
    assert.Equal(t, "test-app", app.Name)
}

Conclusion

And there you have it! You're now equipped to build some seriously cool Heroku API integrations with Go. Remember, the heroku-go package has tons more features, so don't be afraid to explore and experiment.

For more in-depth info, check out the Heroku Platform API documentation and the heroku-go GitHub repository.

Now go forth and build something awesome! Happy coding!