How to Use Vultr Object Storage as State Storage

I tried using the following code to get a VKE up and running. This worked with local state. I want to store the state in Vultr object storage

Here is the main.go

package main

import (
    "fmt"
    "os"

    "github.com/spf13/cobra"
)

var backendURL string

func main() {
    var rootCmd = &cobra.Command{
        Use:   "pulumi-cli",
        Short: "Pulumi CLI tool",
        Long:  `A CLI tool to manage Pulumi stacks.`,
    }

    rootCmd.PersistentFlags().StringVar(&backendURL, "backend-url", "", "Pulumi backend URL")
    rootCmd.AddCommand(upCmd)
    if err := rootCmd.Execute(); err != nil {
        fmt.Println(err)
        os.Exit(1)
    }
}

Here is the up.go

package main

import (
    "context"
    "fmt"
    "os"
    "strings"

    "github.com/dirien/pulumi-vultr/sdk/v2/go/vultr"
    "github.com/pulumi/pulumi/sdk/v3/go/auto"
    "github.com/pulumi/pulumi/sdk/v3/go/auto/optup"
    "github.com/pulumi/pulumi/sdk/v3/go/pulumi"
    "github.com/spf13/cobra"
)

var upCmd = &cobra.Command{
    Use:   "up",
    Short: "Update the Pulumi stack",
    Run: func(cmd *cobra.Command, args []string) {
        // Set the Pulumi config passphrase
        os.Setenv("PULUMI_CONFIG_PASSPHRASE", "your_passphrase")

        // Set the Pulumi backend URL if provided
        if backendURL != "" {
            os.Setenv("PULUMI_BACKEND_URL", backendURL)
        }

        // Define project and stack names
        projectName := "my-project"
        stackName := "stack"

        // Set up a Pulumi program in-line as a function
        pulumiProgram := func(ctx *pulumi.Context) error {
            // Define a Vultr Kubernetes cluster
            vke, err := vultr.NewKubernetes(ctx, "vke", &vultr.KubernetesArgs{
                Region:  pulumi.String("fra"),
                Version: pulumi.String("v1.28.12+1"),
                Label:   pulumi.String("pulumi-vultr"),
                NodePools: vultr.KubernetesNodePoolsTypeArgs{
                    NodeQuantity: pulumi.Int(1),
                    Plan:         pulumi.String("vc2-2c-4gb"),
                    Label:        pulumi.String("pulumi-vultr-nodepool"),
                },
            })
            if err != nil {
                return err
            }

            // Export the kubeconfig
            ctx.Export("kubeconfig", vke.KubeConfig)
            return nil
        }

        // Create a context
        ctx := context.Background()

        // Try to create or select the Pulumi stack using an inline program
        stack, err := auto.NewStackInlineSource(ctx, stackName, projectName, pulumiProgram)
        if err != nil {
            if strings.Contains(err.Error(), "already exists") {
                stack, err = auto.SelectStackInlineSource(ctx, stackName, projectName, pulumiProgram)
                if err != nil {
                    fmt.Printf("Failed to select existing stack: %v\n", err)
                    os.Exit(1)
                }
            } else {
                fmt.Printf("Failed to create or select stack: %v\n", err)
                os.Exit(1)
            }
        }

//      // Set up the stack configuration as needed
//      stackConfig := auto.ConfigMap{
//          "vultr:apiKey": auto.ConfigValue{Value: os.Getenv("VULTR_API_KEY")},
//      }
//      err = stack.SetAllConfig(ctx, stackConfig)
//      if err != nil {
//          fmt.Printf("Failed to set config: %v\n", err)
//          os.Exit(1)
//      }

//      // Optionally refresh the stack's state before running an update
//      _, err = stack.Refresh(ctx)
//      if err != nil {
//          fmt.Printf("Failed to refresh stack: %v\n", err)
//          os.Exit(1)
//      }

        // Run the update (equivalent to `pulumi up`)
        upRes, err := stack.Up(ctx, optup.Message("Updating stack via CLI"))
        if err != nil {
            fmt.Printf("Failed to update stack: %v\n", err)
            os.Exit(1)
        }

        fmt.Printf("Update succeeded! Stack outputs: %v\n", upRes.Outputs)
    },
}

I tried exporting the following environment variables but it didn't work

export VULTR_API_KEY='your vultr api key'
export AWS_ACCESS_KEY='access key of the object storage'
export AWS_SECRET_ACCESS_KEY='secret key of the object storage'
export PULUMI_BACKEND_URL=s3://<bucket name>.ewr1.vultrobjects.com

dirien / pulumi-vultr

How to Use Vultr Object Storage as State Storage #388