Manage DevZero resources using Pulumi

package main

import (
    devzerocluster "github.com/pulumi/pulumi-terraform-module/sdks/go/devzero-cluster/devzero-cluster"
    "github.com/pulumi/pulumi-terraform-provider/sdks/go/devzero/devzero"
    "github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
    pulumi.Run(func(ctx *pulumi.Context) error {
        devzeroProvider, err := devzero.NewProvider(ctx, "devzero", &devzero.ProviderArgs{})
        if err != nil {
            return err
        }

        // Create the devzero-cluster provider with devzero and helm configurations
        clusterProvider, err := devzerocluster.NewProvider(ctx, "devzero-cluster", &devzerocluster.ProviderArgs{
            Helm: pulumi.Map{
                "kubernetes": pulumi.Map{
                    "config_path": pulumi.String("~/.kube/config"),
                },
            },
        })
        if err != nil {
            return err
        }

        cluster, err := devzerocluster.NewModule(ctx, "cluster", &devzerocluster.ModuleArgs{
            Cluster_name: pulumi.String("pulumi-cluster"),
        }, pulumi.Provider(clusterProvider))
        if err != nil {
            return err
        }

        workloadPolicy, err := devzero.NewWorkloadPolicy(ctx, "workload-policy", &devzero.WorkloadPolicyArgs{
            Name: pulumi.String("pulumi-workload-policy"),
        }, pulumi.Provider(devzeroProvider))
        if err != nil {
            return err
        }

        _, err = devzero.NewWorkloadPolicyTarget(ctx, "workload-policy-target", &devzero.WorkloadPolicyTargetArgs{
            Name:       pulumi.String("pulumi-workload-policy-target"),
            PolicyId:   workloadPolicy.ID(),
            ClusterIds: pulumi.StringArray{cluster.Cluster_id.AsStringOutput()},
        }, pulumi.Provider(devzeroProvider))
        if err != nil {
            return err
        }

        return nil
    })
}

import pulumi
from pulumi_devzero import Provider as DevzeroProvider, WorkloadPolicy, WorkloadPolicyArgs, WorkloadPolicyTarget, WorkloadPolicyTargetArgs
from pulumi_devzero_cluster import Provider as ClusterProvider, Module, ModuleArgs

# Configure the Devzero provider
dz_provider = DevzeroProvider(
    "devzero",
)

# Configure the devzero-cluster module provider
cluster_provider = ClusterProvider(
    "devzero-cluster",
    helm={
        "kubernetes": {
            "config_path": "~/.kube/config",
        }
    },
)

# Create the cluster module
cluster = Module(
    "cluster",
    ModuleArgs(
        cluster_name="pulumi-cluster",
    ),
    pulumi.ResourceOptions(provider=cluster_provider),
)

# Create a workload policy using the devzero provider
workload_policy = WorkloadPolicy(
    "workload-policy",
    WorkloadPolicyArgs(
        name="pulumi-workload-policy",
    ),
    pulumi.ResourceOptions(provider=dz_provider),
)

# Attach the policy to the cluster
WorkloadPolicyTarget(
    "workload-policy-target",
    WorkloadPolicyTargetArgs(
        name="pulumi-workload-policy-target",
        policy_id=workload_policy.id,
        cluster_ids=cluster.cluster_id.apply(lambda v: [str(v)]),
    ),
    pulumi.ResourceOptions(provider=dz_provider),
)

"use strict";
const pulumi = require("@pulumi/pulumi");
const devzero = require("@pulumi/devzero");
const devzeroCluster = require("@pulumi/devzero-cluster");

// Configure the Devzero provider
const dzProvider = new devzero.Provider("devzero", {});

// Configure the devzero-cluster module provider
const clusterProvider = new devzeroCluster.Provider("devzero-cluster", {
    helm: {
        kubernetes: {
            config_path: "~/.kube/config",
        },
    },
});

// Create the cluster module
const cluster = new devzeroCluster.Module("cluster", {
    cluster_name: "pulumi-cluster",
}, { provider: clusterProvider });

// Create a workload policy using the devzero provider
const workloadPolicy = new devzero.WorkloadPolicy("workload-policy", {
    name: "pulumi-workload-policy",
}, { provider: dzProvider });

// Attach the policy to the cluster
new devzero.WorkloadPolicyTarget("workload-policy-target", {
    name: "pulumi-workload-policy-target",
    policyId: workloadPolicy.id,
    clusterIds: [cluster.cluster_id.apply(v => String(v))],
}, { provider: dzProvider });