DanubeData

import * as danubedata from "@danubedata/pulumi";

// Create a storage bucket
const bucket = new danubedata.StorageBucket("my-bucket", {
    region: "fsn1",
    versioningEnabled: true,
});

// Create a Redis cache instance
const cache = new danubedata.Cache("my-cache", {
    name: "app-cache",
    cacheProvider: "redis",
    resourceProfile: "small",
    datacenter: "fsn1",
});

// Create a PostgreSQL database
const database = new danubedata.Database("my-database", {
    name: "app-db",
    databaseProvider: "postgresql",
    providerVersion: "16",
    resourceProfile: "small",
    datacenter: "fsn1",
});

// Export endpoints
export const bucketEndpoint = bucket.endpointUrl;
export const cacheEndpoint = cache.endpoint;
export const databaseEndpoint = database.endpoint;

import pulumi_danubedata as danubedata

# Create a storage bucket
bucket = danubedata.StorageBucket("my-bucket",
    region="fsn1",
    versioning_enabled=True)

# Create a Redis cache instance
cache = danubedata.Cache("my-cache",
    name="app-cache",
    cache_provider="redis",
    resource_profile="small",
    datacenter="fsn1")

# Create a PostgreSQL database
database = danubedata.Database("my-database",
    name="app-db",
    database_provider="postgresql",
    provider_version="16",
    resource_profile="small",
    datacenter="fsn1")

# Export endpoints
pulumi.export("bucket_endpoint", bucket.endpoint_url)
pulumi.export("cache_endpoint", cache.endpoint)
pulumi.export("database_endpoint", database.endpoint)

package main

import (
	"github.com/AdrianSilaghi/pulumi-danubedata/sdk/go/danubedata"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		// Create a storage bucket
		bucket, err := danubedata.NewStorageBucket(ctx, "my-bucket", &danubedata.StorageBucketArgs{
			Region:            pulumi.String("fsn1"),
			VersioningEnabled: pulumi.Bool(true),
		})
		if err != nil {
			return err
		}

		// Create a Redis cache instance
		cache, err := danubedata.NewCache(ctx, "my-cache", &danubedata.CacheArgs{
			Name:            pulumi.String("app-cache"),
			CacheProvider:   pulumi.String("redis"),
			ResourceProfile: pulumi.String("small"),
			Datacenter:      pulumi.String("fsn1"),
		})
		if err != nil {
			return err
		}

		// Export endpoints
		ctx.Export("bucketEndpoint", bucket.EndpointUrl)
		ctx.Export("cacheEndpoint", cache.Endpoint)
		return nil
	})
}

using Pulumi;
using DanubeData = DanubeData.DanubeData;

return await Deployment.RunAsync(() =>
{
    // Create a storage bucket
    var bucket = new DanubeData.StorageBucket("my-bucket", new()
    {
        Region = "fsn1",
        VersioningEnabled = true,
    });

    // Create a Redis cache instance
    var cache = new DanubeData.Cache("my-cache", new()
    {
        Name = "app-cache",
        CacheProvider = "redis",
        ResourceProfile = "small",
        Datacenter = "fsn1",
    });

    // Export endpoints
    return new Dictionary<string, object?>
    {
        ["bucketEndpoint"] = bucket.EndpointUrl,
        ["cacheEndpoint"] = cache.Endpoint,
    };
});