Using random resource in plans with Go?

[sheldonhull]

There are very few examples to go on with applying a resource like random to use as input for random logical names in further steps in Pulumi.

My use case:

• I am deploying the same stack via pulumi cli to multiple Kubernetes clusters, without the operator.
• I want to ensure a unique URN.

My thought was to do:

• for each cluster in range clusters
• Provider logical name = "k8-clustername-${randompet}"
• Each resource logical name is set to "mydeploymentname-${randompet}" which would result in " "mydeploymentname-${randompet}-${randomsuffix}" that pulumi would do automatically when i'm not overriding the metadata name (which I'm trying to remove).

This would require:

• Random resource which has a keeper value of the cluster.
• Random resource is applied explicitly at beginning to be available for subsequent steps.
• Random resource id is able to be provided as a string value, since the logical naming of resources requires a string, not a StringOutput/Ptr.

I'm having no luck so far. The syntax is pretty foreign and reminds me sort of delegate expressions in C#. Attempting to work my way through it hasn't succeeded so far.

Example

import (
	kubernetes "github.com/pulumi/pulumi-kubernetes/sdk/v3/go/kubernetes"
	random "github.com/pulumi/pulumi-random/sdk/v4/go/random"
	pulumi "github.com/pulumi/pulumi/sdk/v3/go/pulumi"
	config "github.com/pulumi/pulumi/sdk/v3/go/pulumi/config"

)
for _, cluster := range clusterList {
	pargs := &kubernetes.ProviderArgs{}
	pargs.Namespace = pulumi.String(sharedConfig.Namespace)
	pet, err := random.NewRandomPet(ctx, "random-pet"+cluster.Name, &random.RandomPetArgs{
		Keepers:   pulumi.Map{"cluster": pulumi.String(cluster.Name)},
		Length:    pulumi.Int(2),
		Prefix:    pulumi.String("-"),
		Separator: pulumi.String("-"),
	}, nil)
	if err != nil {
		return err
	}
	// I've tried combinations of this, no string conversion and others, and can't seem to get this to work reasonably.
	randompet := pet.ID().ApplyT(func(result string) (string, error) {
		return fmt.Sprintf("%v", result), nil
	}).(pulumi.StringOutput).ToStringOutput()
	ctx.Export("randompet-"+cluster.Name, randompet)
	_ = ctx.Log.Info(fmt.Sprintf("petname: %+v", pet.ID()), &pulumi.LogArgs{})

	// ... now pass this into functions as a string to consume to help build the logical names uniquely for each resource created in the cluster/namespace.

}

I can't seem to get this to work like I need it and would really appreciate some examples of using the random petname/strings in practice for things like this multi-cluster type of deployment.

Even with the operator, I'm not sure if it would solve the issue of unique URNs that is required when using state based tracking so regardless I think having more random resources in my plan will help ensure uniqueness.

My Current Workaround

Until I get this figured out, I added a random petname to the yaml config, load into the struct and then provide it in code explicitly like:

clustersuffix := "-" + cluster.Petname  // petname: itchy-elephant, etc

err = ingress.NetworkingIngress(ctx, clustersuffix, renderProvider, &configData, &sharedConfig)
if err != nil {
return err
}
// ingress.go func

	_, err = networkingv1.NewIngress(
		  ctx,
		  configData.ServiceDeployName(sharedConfig, "ingress")+pet,  // can't join stringoutput here, must be string.
          &networkingv1.IngressArgs{
          }, 
          ), pulumi.Provider(prov),
        )
//...
}

Links

• Random Provider

[Frassle]

Resource's logical names currently have to be string, not Output<string> (see #5234). So that limits the use of the random provider for names a lot.

There are three things you could do:

1. Just do the randomness outside pulumi and pass it in as config
2. Call into the random provider at the start of your program and then do the rest of your program inside an apply. This causes some confusion at preview time because preview won't initially run the code inside apply but up will.
3. Just copy the logic from the random provider into your code, and give it a deterministic seed (for example the hash of your stack name). The random pet code is just calling into https://github.com/dustinkirkland/golang-petname/blob/master/petname.go

[sheldonhull]

Thank you. Related question also came up with this: #9216 (comment)

I was able to use the random provider pretty straightforward and terraform so I figured this would be possible in Pulumi. It didn't seem to function this clearly as I thought it would.