Skip to content

ObjectstorageCredentialsGroup Create hangs indefinitely on pulumi up (v0.0.5); TF equivalent succeeds #288

@qaiser42

Description

@qaiser42

Description

pulumi up hangs indefinitely on creation of stackit:index:ObjectstorageCredentialsGroup. The Create RPC never returns, so the stack stays stuck on that resource until the
process is killed. The equivalent Terraform resource (stackit_objectstorage_credentials_group) against the same project, region, and service account key succeeds in
seconds.

Steps to reproduce

  package main

  import (
        "encoding/base64"
        "fmt"                                                                                                                                                               
   
        "github.com/pulumi/pulumi/sdk/v3/go/pulumi"                                                                                                                         
        "github.com/pulumi/pulumi/sdk/v3/go/pulumi/config"                                                                                                    
        "github.com/stackitcloud/pulumi-stackit/sdk/go/stackit"                                                                                                             
  )                                                                                                                                                                         
                                                                                                                                                                            
  func main() {                                                                                                                                                             
        pulumi.Run(func(ctx *pulumi.Context) error {                                                                                                          
                cfg := config.New(ctx, "")
                projectID := cfg.Require("projectId")                                                                                                                       
                bucketName := cfg.Require("bucketName")                                                                                                                     
                region := cfg.Get("region")                                                                                                                                 
                if region == "" {                                                                                                                                           
                        region = "eu01"                                                                                                                       
                }                                                                                                                                                           
                                                                                                                                                              
                saKeyB64 := cfg.RequireSecret("serviceAccountKey")                                                                                                          
                saKey := saKeyB64.ApplyT(func(v string) (string, error) {
                        b, err := base64.StdEncoding.DecodeString(v)                                                                                                        
                        if err != nil {                                                                                                                       
                                return "", fmt.Errorf("decode SA key: %w", err)                                                                                             
                        }                                                                                                                                                   
                        return string(b), nil
                }).(pulumi.StringOutput).ToStringPtrOutput()                                                                                                                
                                                                                                                                                                            
                prov, err := stackit.NewProvider(ctx, "stackit", &stackit.ProviderArgs{                                                                                     
                        ServiceAccountKey: saKey,                                                                                                                           
                        DefaultRegion:     pulumi.String(region),                                                                                                           
                })                                                                                                                                                          
                if err != nil {
                        return err                                                                                                                                          
                }                                                                                                                                             

                bucket, err := stackit.NewObjectstorageBucket(ctx, "bucket", &stackit.ObjectstorageBucketArgs{                                                              
                        ProjectId: pulumi.String(projectID),
                        Name:      pulumi.String(bucketName),                                                                                                               
                        Region:    pulumi.String(region),                                                                                                     
                }, pulumi.Provider(prov))                                                                                                                                   
                if err != nil {                                                                                                                               
                        return err                                                                                                                                          
                }                                                                                                                                             

                credGroup, err := stackit.NewObjectstorageCredentialsGroup(ctx, "cred-group", &stackit.ObjectstorageCredentialsGroupArgs{                                   
                        ProjectId: pulumi.String(projectID),
                        Name:      pulumi.String(bucketName + "-cg"),                                                                                                       
                        Region:    pulumi.String(region),                                                                                                     
                }, pulumi.Provider(prov), pulumi.DependsOn([]pulumi.Resource{bucket}))                                                                                      
                if err != nil {                                                                                                                                             
                        return err                                                                                                                                          
                }                                                                                                                                                           
                                                                                                                                                              
                _, err = stackit.NewObjectstorageCredential(ctx, "creds", &stackit.ObjectstorageCredentialArgs{                                                             
                        ProjectId:          pulumi.String(projectID),
                        CredentialsGroupId: credGroup.CredentialsGroupId,                                                                                                   
                        Region:             pulumi.String(region),                                                                                                          
                }, pulumi.Provider(prov))
                return err                                                                                                                                                  
        })                                                                                                                                                    
  }

  1. pulumi stack init dev
  2. Set config: projectId, bucketName, serviceAccountKey (base64-encoded SA key JSON), optional region (default eu01).
  3. Run pulumi up.
  4. Bucket is created. Progress then stalls on + stackit:index:ObjectstorageCredentialsGroup cred-group create and never advances.

Equivalent Terraform against the same inputs (for reference — works in seconds):

  resource "stackit_objectstorage_bucket" "bucket" {                                                                                                                        
    project_id = var.project_id                                                                                                                               
    name       = var.bucket_name
    region     = var.region
  }                                                                                                                                                                         
   
  resource "stackit_objectstorage_credentials_group" "cred_group" {                                                                                                         
    project_id = var.project_id                                                                                                                               
    name       = "${var.bucket_name}-cred-group"
    region     = var.region                                                                                                                                                 
    depends_on = [stackit_objectstorage_bucket.bucket]
  }                                                                                                                                                                         
                                                                                                                                                                            
  resource "stackit_objectstorage_credential" "creds" {
    project_id           = var.project_id                                                                                                                                   
    credentials_group_id = stackit_objectstorage_credentials_group.cred_group.credentials_group_id                                                            
    region               = var.region                                                                                                                                       
  }

Actual behavior

pulumi up blocks indefinitely on ObjectstorageCredentialsGroup Create. The provider process does not exit on its own; the operation only ends when the user kills the CLI
or plugin. No error or timeout is surfaced. Bucket creation preceding it succeeds.

Expected behavior

ObjectstorageCredentialsGroup Create should complete (or fail with a clear error) in the same timeframe as the Terraform provider, which uses the same upstream API.

Environment

  • OS: macOS 15 (Darwin 25.3.0), arm64
  • pulumi version: v3.217.1
  • pulumictl version: n/a (not installed)
  • Version of the STACKIT Pulumi Provider: plugin v0.0.5, Go SDK github.com/stackitcloud/pulumi-stackit/sdk v0.0.0-20260417060440-49939a2858c2

Additional information

  • Go toolchain: go1.25.6 darwin/arm64
  • Region tested: eu01
  • Terraform comparison uses stackitcloud/stackit >= 0.50.0 with identical inputs against the same project — succeeds.
  • Pulumi preview (pulumi preview) returns immediately with unknowns because the terraform-bridge skips real API calls in preview, so the hang only surfaces on pulumi up.
  • Happy to attach a TF_LOG=DEBUG + pulumi up -v=11 --logtostderr --logflow trace on request.

Metadata

Metadata

Assignees

No one assigned

    Type

    No type

    Projects

    No projects

    Milestone

    No milestone

    Relationships

    None yet

    Development

    No branches or pull requests

    Issue actions