I have a resource A that outputs a base64 encoded kubeconfig as A.kubeconfig. I need to pass the decoded value as an input to another Pulumi resource B. How do I do that?

To achieve this, you can use the Pulumi's Apply method to decode the base64 encoded kubeconfig and pass it to the second resource. Here is an example using Go:

package main

import (
	"encoding/base64"

	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		// Define resource A that outputs a base64 encoded kubeconfig
		resourceA, err := NewResourceA(ctx, "resourceA", &ResourceAArgs{})
		if err != nil {
			return err
		}

		// Decode kubeconfig from resource A
		decodedKubeconfig := resourceA.Kubeconfig.ApplyT(func(kubeconfig string) (string, error) {
			decoded, err := base64.StdEncoding.DecodeString(kubeconfig)
			if err != nil {
				return "", err
			}
			return string(decoded), nil
		}).(pulumi.StringOutput)

		// Pass decoded kubeconfig as input to resource B
		_, err = NewResourceB(ctx, "resourceB", &ResourceBArgs{
			Kubeconfig: decodedKubeconfig,
		})
		if err != nil {
			return err
		}

		return nil
	})
}

type ResourceA struct {
	pulumi.CustomResourceState

	Kubeconfig pulumi.StringOutput `pulumi:"kubeconfig"`
}

type ResourceAArgs struct {
	// Add necessary input properties for ResourceA
}

func NewResourceA(ctx *pulumi.Context, name string, args *ResourceAArgs, opts ...pulumi.ResourceOption) (*ResourceA, error) {
	var resource ResourceA
	err := ctx.RegisterResource("package:module:ResourceA", name, args, &resource, opts...)
	if err != nil {
		return nil, err
	}
	return &resource, nil
}

type ResourceB struct {
	pulumi.CustomResourceState
}

type ResourceBArgs struct {
	Kubeconfig pulumi.StringInput `pulumi:"kubeconfig"`
}

func NewResourceB(ctx *pulumi.Context, name string, args *ResourceBArgs, opts ...pulumi.ResourceOption) (*ResourceB, error) {
	var resource ResourceB
	err := ctx.RegisterResource("package:module:ResourceB", name, args, &resource, opts...)
	if err != nil {
		return nil, err
	}
	return &resource, nil
}

In this example:

ResourceA is assumed to output a base64 encoded kubeconfig (resourceA.Kubeconfig).
Apply is used to decode the kubeconfig from base64.
The decoded kubeconfig is passed as input to ResourceB.

Here is the provided program rewritten in Python:

import base64
import pulumi
from pulumi import Output

class ResourceA(pulumi.CustomResource):
    kubeconfig: Output[str]

    def __init__(self, name, args=None, opts=None):
        super().__init__('package:module:ResourceA', name, None, opts)

class ResourceB(pulumi.CustomResource):
    def __init__(self, name, kubeconfig, opts=None):
        args = {'kubeconfig': kubeconfig}
        super().__init__('package:module:ResourceB', name, args, opts)

def decode_base64(encoded_str: str) -> str:
    return base64.b64decode(encoded_str).decode('utf-8')

def main():
    # Define resource A that outputs a base64 encoded kubeconfig
    resource_a = ResourceA('resourceA')

    # Decode kubeconfig from resource A
    decoded_kubeconfig = resource_a.kubeconfig.apply(decode_base64)

    # Pass decoded kubeconfig as input to resource B
    resource_b = ResourceB('resourceB', decoded_kubeconfig)

pulumi.run(main)

I have a resource A that outputs a base64 encoded kubeconfig as A.kubeconfig. I need to pass the decoded value as an input to another Pulumi resource B. How do I do that?

Rewrite this program in Python