Byron Cabrera

In modern web development, creating cloud-native applications is key to building scalable, accessible, and resilient services. Choosing the right cloud provider is an essential part of this process, as each platform offers unique features and capabilities tailored to specific needs. However, as applications evolve, so do their requirements, and the initial choice of a cloud provider may no longer be the ideal fit. This leads to the challenge developers face today: building applications that are not only cloud-native but also portable, capable of adapting to different cloud environments as needs change over time.

The Go Cloud Development Kit (Go CDK) aims to make this possible for Go developers. Built by Google, the Go CDK offers a set of portable APIs for common cloud services, letting developers write applications that can run across providers like AWS, GCP, Azure, and more without changing code.

In this post, we’ll explore what the Go CDK is, why it’s useful, and what makes it a unique and interesting tool for cloud-agnostic application development!

The Go CDK is an open-source library designed to help Go developers create applications that are provider-agnostic. With it, you can interact with cloud services—such as object storage, pub/sub messaging, configuration management, and SQL databases—in a uniform way across multiple cloud providers.

The Go CDK achieves this by providing an abstraction layer over cloud services, allowing developers to write code once and deploy it to different cloud platforms without having to refactor code for each provider.

Why is the Go CDK Useful?

When you use the Go CDK, you gain several benefits:

1. Cloud Portability: You can build applications that work across multiple cloud providers, making it easier to switch providers or run multi-cloud strategies.
2. Reduced Complexity: The Go CDK abstracts away the complexities of working with different cloud providers, allowing you to focus on business logic rather than infrastructure differences.
3. Consistent API: With the Go CDK, you interact with cloud services using the same API, whether you’re using AWS, GCP, Azure, or even on-prem solutions. This consistency simplifies code maintenance and testing.

What Makes the Go CDK Interesting?

The Go CDK is especially interesting because it brings true cloud portability to Go developers without sacrificing the quality of cloud services. This is achieved through a set of portable APIs—APIs that work similarly across cloud providers but can still access provider-specific features when needed.

Another intriguing feature is provider-specific openers, which allow developers to configure and extend the CDK to take advantage of provider-specific functionality. For example, while the blob package lets you work with object storage across clouds, you can still access AWS S3-specific features if needed.

Key Features of the Go CDK

Here are some of the Go CDK’s key modules that make cloud development seamless:

1. blob (Object Storage)

The blob package provides a unified API for object storage services, such as Amazon S3, Google Cloud Storage, and Azure Blob Storage. This package allows you to write code for uploading, downloading, and managing large binary files across different providers.

package main

import (
	"context"
	"log"
	"gocloud.dev/blob"
	_ "gocloud.dev/blob/s3blob" // import the S3 driver
)

func main() {
	ctx := context.Background()

	// Open a bucket using the portable API.
	bucket, err := blob.OpenBucket(ctx, "s3://my-bucket")
	if err != nil {
		log.Fatal(err)
	}
	defer bucket.Close()

	// Write to a file in the bucket.
	err = bucket.WriteAll(ctx, "myfile.txt", []byte("Hello, World!"), nil)
	if err != nil {
		log.Fatal(err)
	}
	log.Println("File written successfully")

    // Read from a file in the bucket
    data, err := bucket.ReadAll(ctx, "myfile.txt")
    if err != nil {
 	    return err
    }
    fmt.Println(string(data))
}

2. pubsub (Message Passing)

The pubsub package lets you work with cloud messaging services in a unified way. Whether you’re using Google Cloud Pub/Sub, Amazon SNS/SQS, or NATS, the pubsub package lets you set up subscriptions and publish messages consistently.

package main

import (
	"context"
	"log"
	"gocloud.dev/pubsub"
	_ "gocloud.dev/pubsub/gcppubsub"
)

func main() {
	ctx := context.Background()

	topic, err := pubsub.OpenTopic(ctx, "gcppubsub://my-topic")
	if err != nil {
		log.Fatal(err)
	}
	defer topic.Shutdown(ctx)

	err = topic.Send(ctx, &pubsub.Message{
		Body: []byte("Hello, World!"),
	})
	if err != nil {
		log.Fatal(err)
	}
	log.Println("Message published")
}

3. docstore (Document Storage)

The docstore package provides a NoSQL-style document API that is portable across providers. You can perform CRUD operations on documents stored in collections in services like MongoDB, DynamoDB, or Google Firestore.

4. Testing Utils

Go CDK offers in memory swap ins for its various packages that make it easy to test application business logic without a strict dependency on external systems

Things to Consider

While the Go CDK is a powerful tool, there are some factors to consider:

• Limited Advanced Features: The Go CDK covers the essentials but may not support every provider-specific feature. For applications that rely heavily on a specific provider’s advanced services, you may need to work directly with the cloud provider’s SDK.
• Openers: Setting up provider-specific openers requires additional configuration, especially for authentication. Make sure your environment is configured to handle the specific setup needed for each provider.
• Best for Simpler Use Cases: The Go CDK is best for applications where simplicity and portability are more valuable than taking advantage of every cloud-specific feature.

Furthermore, as of writing this post (v0.40.0). The Go CDK is still in development phase and has not officially released a production ready version though they are seeking early adopters and are actively developing and addressing bugs.

Conclusion

The Go Cloud Development Kit provides Go developers with a straightforward way to write cloud-agnostic applications. By leveraging portable APIs, the Go CDK enables applications to operate across multiple cloud providers seamlessly, reducing complexity and increasing flexibility.

Whether you’re building a simple file storage service, a message-passing system, or an application that loads dynamic configuration, the Go CDK makes it easier to maintain and scale your application across cloud environments. It’s an exciting tool for developers looking to embrace multi-cloud strategies while keeping their codebase clean and consistent.

For more information on Go CDK please visit their docs: tutorials.

Cheers!