repository·master·Indexed 27 days ago
https://github.com/google/go-cloudA toolkit that allows Go developers to write cloud-agnostic applications by providing stable, idiomatic interfaces for common services. Supported generic APIs include unstructured binary (blob) storage, publish/subscribe (pubsub), runtime variables (runtimevar), databases (MySQL, PostgreSQL), and server diagnostics. It uses portable types implemented on top of service-specific drivers for providers like GCP, AWS, and Azure.
The Go Cloud Development Kit (Go CDK) provides vendor-neutral, idiomatic Go APIs for common cloud use cases such as storage, events, and databases.
By using these portable APIs, you can:
The Go Cloud Development Kit (Go CDK) provides stable, idiomatic interfaces for common cloud services, allowing you to write code that is portable across different cloud providers (like GCP, AWS, and Azure).
Supported generic APIs include:
The Go CDK avoids introducing global state to ensure applications can reason about different states in large codebases. Responsibility for state is pushed to the application via dependency injection.
Exception: A global registry is permitted specifically for URL scheme registration. This is allowed to reduce the boilerplate required for URL muxes when using multiple drivers without dependency injection tools like Wire.
In Go CDK, portable type constructors are top-level functions in driver packages used to obtain an instance of a portable type.
Key characteristics:
gcsblob.OpenBucket returns *blob.Bucket).OpenBucket(ctx, client, "mybucket").The Go CDK uses a pattern similar to database/sql to separate implementation-agnostic logic from service-specific implementations.
blob.Bucket or runtimevar.Variable) that you use in your application logic. They contain high-level, implementation-agnostic logic and provide a consistent API regardless of the underlying service.blob.Bucket.NewWriter) without requiring the driver to implement that complex logic itself.This structure allows you to write your core logic once and swap providers by simply changing the driver used at startup.
The Guestbook sample application demonstrates how to write cloud-agnostic business logic using the Go CDK. It records visitor messages, displays a cloud banner, and shows an administrative message.
Key Go CDK APIs used in this sample:
Platform-specific code and dependency injection are managed using Wire.
The Go CDK pubsub package is designed to provide a consistent interface across different messaging services (like GCP PubSub, Azure Service Bus, RabbitMQ, and Redis Streams) while avoiding the complexity of forcing developers to manage manual batching or callback-based subscription models.
go-micro, Go CDK does not use a callback function within the subscription to handle messages. This ensures compatibility with the inverted worker pool pattern.Ack a no-op).The Go CDK is designed to separate concerns between two roles:
Key Principle: The Go CDK avoids including platform-specific resource management (like creating a new blob.Bucket) to prevent leaky abstractions. Operators are expected to manage these non-portable resources externally and then provide the implementation to the application.
Since Go CDK does not currently support SQL on Azure for this sample, you must run a local MySQL database while using Azure Storage for the blob and runtimevar APIs.
az login.azure directory to create storage resources.guestbook binary locally, providing Azure credentials via environment variables (AZURE_STORAGE_ACCOUNT and AZURE_STORAGE_KEY) and the storage container name via the -bucket flag.terraform destroy in the azure directory.# Provisioning
az login
cd azure
terraform init
terraform apply -var location="West US"
# Running with Azure Storage
# (In a separate terminal, start local MySQL)
go run localdb/main.go
# In the azure directory
export AZURE_STORAGE_ACCOUNT=<your storage_account>
export AZURE_STORAGE_KEY=<your access_key>
./guestbook -env=azure -bucket=<your storage_container> -motd_var=motdThe mempubsub package provides an in-memory Pub/Sub provider for local testing.
Namespacing: Names in mem:// URLs are process-wide. Subscriptions to the same name will receive messages posted to that topic.
URL Format: mem://<topic-name>
While top-level functions like blob.OpenBucket use a DefaultURLMux to map schemes to providers, you can create a custom URLMux for more control. This is useful when you need to provide explicit configuration or credentials (e.g., via a ConfigProvider) rather than relying on default environment credentials.
To use a custom mux, follow these steps:
URLOpener with specific fields (e.g., s3blob.URLOpener{ConfigProvider: myAWSProvider}).URLMux (e.g., mymux := new(blob.URLMux)).URLOpener on the mux using the provider's scheme (e.g., mymux.RegisterBucket(s3blob.Scheme, myS3URLOpener)).mymux.OpenBucket("s3://my-bucket")).Tests in Go CDK can be run in -record mode to perform live integration tests against backend servers and record the requests/responses for later use in replay mode.
To use -record mode:
blob tests) or use the provided test-specific flags to pass resource information.-record flag. When adding or changing tests, use the -run flag with go test to record only the specific tests that were affected to minimize noise.