redpanda.ResourceGroup

import * as pulumi from "@pulumi/pulumi";
import * as redpanda from "@pulumi/redpanda";

const testResourceGroup = new redpanda.ResourceGroup("testResourceGroup", {});
const config = new pulumi.Config();
const region = config.get("region") || "us-east-2";
const cloudProvider = config.get("cloudProvider") || "aws";
const testNetwork = new redpanda.Network("testNetwork", {
    resourceGroupId: testResourceGroup.id,
    cloudProvider: cloudProvider,
    region: region,
    clusterType: "dedicated",
    cidrBlock: "10.0.0.0/20",
});
const zones = config.getObject("zones") || [
    "use2-az1",
    "use2-az2",
    "use2-az3",
];
const throughputTier = config.get("throughputTier") || "tier-1-aws-v2-arm";
const testCluster = new redpanda.Cluster("testCluster", {
    resourceGroupId: testResourceGroup.id,
    networkId: testNetwork.id,
    cloudProvider: cloudProvider,
    region: region,
    clusterType: "dedicated",
    connectionType: "public",
    throughputTier: throughputTier,
    zones: zones,
    allowDeletion: true,
    tags: {
        key: "value",
    },
});
// aws_private_link = {
//   enabled         = true
//   connect_console = true
//   allowed_principals = ["arn:aws:iam::123456789024:root"]
// }
const resourceGroupName = config.get("resourceGroupName") || "testname";
const networkName = config.get("networkName") || "testname";
const clusterName = config.get("clusterName") || "testname";
const userPw = config.get("userPw") || "password";
const mechanism = config.get("mechanism") || "scram-sha-256";
const testUser = new redpanda.User("testUser", {
    password: userPw,
    mechanism: mechanism,
    clusterApiUrl: testCluster.clusterApiUrl,
});
const partitionCount = config.getNumber("partitionCount") || 3;
const replicationFactor = config.getNumber("replicationFactor") || 3;
const testTopic = new redpanda.Topic("testTopic", {
    partitionCount: partitionCount,
    replicationFactor: replicationFactor,
    clusterApiUrl: testCluster.clusterApiUrl,
    allowDeletion: true,
});
const testAcl = new redpanda.Acl("testAcl", {
    resourceType: "TOPIC",
    resourceName: testTopic.name,
    resourcePatternType: "LITERAL",
    principal: pulumi.interpolate`User:${testUser.name}`,
    host: "*",
    operation: "READ",
    permissionType: "ALLOW",
    clusterApiUrl: testCluster.clusterApiUrl,
});
const userName = config.get("userName") || "test-username";
const topicName = config.get("topicName") || "test-topic";

import pulumi
import pulumi_redpanda as redpanda

test_resource_group = redpanda.ResourceGroup("testResourceGroup")
config = pulumi.Config()
region = config.get("region")
if region is None:
    region = "us-east-2"
cloud_provider = config.get("cloudProvider")
if cloud_provider is None:
    cloud_provider = "aws"
test_network = redpanda.Network("testNetwork",
    resource_group_id=test_resource_group.id,
    cloud_provider=cloud_provider,
    region=region,
    cluster_type="dedicated",
    cidr_block="10.0.0.0/20")
zones = config.get_object("zones")
if zones is None:
    zones = [
        "use2-az1",
        "use2-az2",
        "use2-az3",
    ]
throughput_tier = config.get("throughputTier")
if throughput_tier is None:
    throughput_tier = "tier-1-aws-v2-arm"
test_cluster = redpanda.Cluster("testCluster",
    resource_group_id=test_resource_group.id,
    network_id=test_network.id,
    cloud_provider=cloud_provider,
    region=region,
    cluster_type="dedicated",
    connection_type="public",
    throughput_tier=throughput_tier,
    zones=zones,
    allow_deletion=True,
    tags={
        "key": "value",
    })
# aws_private_link = {
#   enabled         = true
#   connect_console = true
#   allowed_principals = ["arn:aws:iam::123456789024:root"]
# }
resource_group_name = config.get("resourceGroupName")
if resource_group_name is None:
    resource_group_name = "testname"
network_name = config.get("networkName")
if network_name is None:
    network_name = "testname"
cluster_name = config.get("clusterName")
if cluster_name is None:
    cluster_name = "testname"
user_pw = config.get("userPw")
if user_pw is None:
    user_pw = "password"
mechanism = config.get("mechanism")
if mechanism is None:
    mechanism = "scram-sha-256"
test_user = redpanda.User("testUser",
    password=user_pw,
    mechanism=mechanism,
    cluster_api_url=test_cluster.cluster_api_url)
partition_count = config.get_float("partitionCount")
if partition_count is None:
    partition_count = 3
replication_factor = config.get_float("replicationFactor")
if replication_factor is None:
    replication_factor = 3
test_topic = redpanda.Topic("testTopic",
    partition_count=partition_count,
    replication_factor=replication_factor,
    cluster_api_url=test_cluster.cluster_api_url,
    allow_deletion=True)
test_acl = redpanda.Acl("testAcl",
    resource_type="TOPIC",
    resource_name_=test_topic.name,
    resource_pattern_type="LITERAL",
    principal=test_user.name.apply(lambda name: f"User:{name}"),
    host="*",
    operation="READ",
    permission_type="ALLOW",
    cluster_api_url=test_cluster.cluster_api_url)
user_name = config.get("userName")
if user_name is None:
    user_name = "test-username"
topic_name = config.get("topicName")
if topic_name is None:
    topic_name = "test-topic"

package main

import (
	"fmt"

	"github.com/pulumi/pulumi-terraform-provider/sdks/go/redpanda/redpanda"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi/config"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		testResourceGroup, err := redpanda.NewResourceGroup(ctx, "testResourceGroup", nil)
		if err != nil {
			return err
		}
		cfg := config.New(ctx, "")
		region := "us-east-2"
		if param := cfg.Get("region"); param != "" {
			region = param
		}
		cloudProvider := "aws"
		if param := cfg.Get("cloudProvider"); param != "" {
			cloudProvider = param
		}
		testNetwork, err := redpanda.NewNetwork(ctx, "testNetwork", &redpanda.NetworkArgs{
			ResourceGroupId: testResourceGroup.ID(),
			CloudProvider:   pulumi.String(cloudProvider),
			Region:          pulumi.String(region),
			ClusterType:     pulumi.String("dedicated"),
			CidrBlock:       pulumi.String("10.0.0.0/20"),
		})
		if err != nil {
			return err
		}
		zones := []string{
			"use2-az1",
			"use2-az2",
			"use2-az3",
		}
		if param := cfg.GetObject("zones"); param != nil {
			zones = param
		}
		throughputTier := "tier-1-aws-v2-arm"
		if param := cfg.Get("throughputTier"); param != "" {
			throughputTier = param
		}
		testCluster, err := redpanda.NewCluster(ctx, "testCluster", &redpanda.ClusterArgs{
			ResourceGroupId: testResourceGroup.ID(),
			NetworkId:       testNetwork.ID(),
			CloudProvider:   pulumi.String(cloudProvider),
			Region:          pulumi.String(region),
			ClusterType:     pulumi.String("dedicated"),
			ConnectionType:  pulumi.String("public"),
			ThroughputTier:  pulumi.String(throughputTier),
			Zones:           pulumi.Any(zones),
			AllowDeletion:   pulumi.Bool(true),
			Tags: pulumi.StringMap{
				"key": pulumi.String("value"),
			},
		})
		if err != nil {
			return err
		}
		resourceGroupName := "testname"
		if param := cfg.Get("resourceGroupName"); param != "" {
			resourceGroupName = param
		}
		networkName := "testname"
		if param := cfg.Get("networkName"); param != "" {
			networkName = param
		}
		clusterName := "testname"
		if param := cfg.Get("clusterName"); param != "" {
			clusterName = param
		}
		userPw := "password"
		if param := cfg.Get("userPw"); param != "" {
			userPw = param
		}
		mechanism := "scram-sha-256"
		if param := cfg.Get("mechanism"); param != "" {
			mechanism = param
		}
		testUser, err := redpanda.NewUser(ctx, "testUser", &redpanda.UserArgs{
			Password:      pulumi.String(userPw),
			Mechanism:     pulumi.String(mechanism),
			ClusterApiUrl: testCluster.ClusterApiUrl,
		})
		if err != nil {
			return err
		}
		partitionCount := float64(3)
		if param := cfg.GetFloat64("partitionCount"); param != 0 {
			partitionCount = param
		}
		replicationFactor := float64(3)
		if param := cfg.GetFloat64("replicationFactor"); param != 0 {
			replicationFactor = param
		}
		testTopic, err := redpanda.NewTopic(ctx, "testTopic", &redpanda.TopicArgs{
			PartitionCount:    pulumi.Float64(partitionCount),
			ReplicationFactor: pulumi.Float64(replicationFactor),
			ClusterApiUrl:     testCluster.ClusterApiUrl,
			AllowDeletion:     pulumi.Bool(true),
		})
		if err != nil {
			return err
		}
		_, err = redpanda.NewAcl(ctx, "testAcl", &redpanda.AclArgs{
			ResourceType:        pulumi.String("TOPIC"),
			ResourceName:        testTopic.Name,
			ResourcePatternType: pulumi.String("LITERAL"),
			Principal: testUser.Name.ApplyT(func(name string) (string, error) {
				return fmt.Sprintf("User:%v", name), nil
			}).(pulumi.StringOutput),
			Host:           pulumi.String("*"),
			Operation:      pulumi.String("READ"),
			PermissionType: pulumi.String("ALLOW"),
			ClusterApiUrl:  testCluster.ClusterApiUrl,
		})
		if err != nil {
			return err
		}
		userName := "test-username"
		if param := cfg.Get("userName"); param != "" {
			userName = param
		}
		topicName := "test-topic"
		if param := cfg.Get("topicName"); param != "" {
			topicName = param
		}
		return nil
	})
}

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Redpanda = Pulumi.Redpanda;

return await Deployment.RunAsync(() => 
{
    var testResourceGroup = new Redpanda.ResourceGroup("testResourceGroup");

    var config = new Config();
    var region = config.Get("region") ?? "us-east-2";
    var cloudProvider = config.Get("cloudProvider") ?? "aws";
    var testNetwork = new Redpanda.Network("testNetwork", new()
    {
        ResourceGroupId = testResourceGroup.Id,
        CloudProvider = cloudProvider,
        Region = region,
        ClusterType = "dedicated",
        CidrBlock = "10.0.0.0/20",
    });

    var zones = config.GetObject<dynamic>("zones") ?? new[]
    {
        "use2-az1",
        "use2-az2",
        "use2-az3",
    };
    var throughputTier = config.Get("throughputTier") ?? "tier-1-aws-v2-arm";
    var testCluster = new Redpanda.Cluster("testCluster", new()
    {
        ResourceGroupId = testResourceGroup.Id,
        NetworkId = testNetwork.Id,
        CloudProvider = cloudProvider,
        Region = region,
        ClusterType = "dedicated",
        ConnectionType = "public",
        ThroughputTier = throughputTier,
        Zones = zones,
        AllowDeletion = true,
        Tags = 
        {
            { "key", "value" },
        },
    });

    // aws_private_link = {
    //   enabled         = true
    //   connect_console = true
    //   allowed_principals = ["arn:aws:iam::123456789024:root"]
    // }
    var resourceGroupName = config.Get("resourceGroupName") ?? "testname";
    var networkName = config.Get("networkName") ?? "testname";
    var clusterName = config.Get("clusterName") ?? "testname";
    var userPw = config.Get("userPw") ?? "password";
    var mechanism = config.Get("mechanism") ?? "scram-sha-256";
    var testUser = new Redpanda.User("testUser", new()
    {
        Password = userPw,
        Mechanism = mechanism,
        ClusterApiUrl = testCluster.ClusterApiUrl,
    });

    var partitionCount = config.GetDouble("partitionCount") ?? 3;
    var replicationFactor = config.GetDouble("replicationFactor") ?? 3;
    var testTopic = new Redpanda.Topic("testTopic", new()
    {
        PartitionCount = partitionCount,
        ReplicationFactor = replicationFactor,
        ClusterApiUrl = testCluster.ClusterApiUrl,
        AllowDeletion = true,
    });

    var testAcl = new Redpanda.Acl("testAcl", new()
    {
        ResourceType = "TOPIC",
        ResourceName = testTopic.Name,
        ResourcePatternType = "LITERAL",
        Principal = testUser.Name.Apply(name => $"User:{name}"),
        Host = "*",
        Operation = "READ",
        PermissionType = "ALLOW",
        ClusterApiUrl = testCluster.ClusterApiUrl,
    });

    var userName = config.Get("userName") ?? "test-username";
    var topicName = config.Get("topicName") ?? "test-topic";
});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.redpanda.ResourceGroup;
import com.pulumi.redpanda.Network;
import com.pulumi.redpanda.NetworkArgs;
import com.pulumi.redpanda.Cluster;
import com.pulumi.redpanda.ClusterArgs;
import com.pulumi.redpanda.User;
import com.pulumi.redpanda.UserArgs;
import com.pulumi.redpanda.Topic;
import com.pulumi.redpanda.TopicArgs;
import com.pulumi.redpanda.Acl;
import com.pulumi.redpanda.AclArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }

    public static void stack(Context ctx) {
        final var config = ctx.config();
        var testResourceGroup = new ResourceGroup("testResourceGroup");

        final var region = config.get("region").orElse("us-east-2");
        final var cloudProvider = config.get("cloudProvider").orElse("aws");
        var testNetwork = new Network("testNetwork", NetworkArgs.builder()
            .resourceGroupId(testResourceGroup.id())
            .cloudProvider(cloudProvider)
            .region(region)
            .clusterType("dedicated")
            .cidrBlock("10.0.0.0/20")
            .build());

        final var zones = config.get("zones").orElse(        
            "use2-az1",
            "use2-az2",
            "use2-az3");
        final var throughputTier = config.get("throughputTier").orElse("tier-1-aws-v2-arm");
        var testCluster = new Cluster("testCluster", ClusterArgs.builder()
            .resourceGroupId(testResourceGroup.id())
            .networkId(testNetwork.id())
            .cloudProvider(cloudProvider)
            .region(region)
            .clusterType("dedicated")
            .connectionType("public")
            .throughputTier(throughputTier)
            .zones(zones)
            .allowDeletion(true)
            .tags(Map.of("key", "value"))
            .build());

        // aws_private_link = {
        //   enabled         = true
        //   connect_console = true
        //   allowed_principals = ["arn:aws:iam::123456789024:root"]
        // }
        final var resourceGroupName = config.get("resourceGroupName").orElse("testname");
        final var networkName = config.get("networkName").orElse("testname");
        final var clusterName = config.get("clusterName").orElse("testname");
        final var userPw = config.get("userPw").orElse("password");
        final var mechanism = config.get("mechanism").orElse("scram-sha-256");
        var testUser = new User("testUser", UserArgs.builder()
            .password(userPw)
            .mechanism(mechanism)
            .clusterApiUrl(testCluster.clusterApiUrl())
            .build());

        final var partitionCount = config.get("partitionCount").orElse(3);
        final var replicationFactor = config.get("replicationFactor").orElse(3);
        var testTopic = new Topic("testTopic", TopicArgs.builder()
            .partitionCount(partitionCount)
            .replicationFactor(replicationFactor)
            .clusterApiUrl(testCluster.clusterApiUrl())
            .allowDeletion(true)
            .build());

        var testAcl = new Acl("testAcl", AclArgs.builder()
            .resourceType("TOPIC")
            .resourceName(testTopic.name())
            .resourcePatternType("LITERAL")
            .principal(testUser.name().applyValue(name -> String.format("User:%s", name)))
            .host("*")
            .operation("READ")
            .permissionType("ALLOW")
            .clusterApiUrl(testCluster.clusterApiUrl())
            .build());

        final var userName = config.get("userName").orElse("test-username");
        final var topicName = config.get("topicName").orElse("test-topic");
    }
}

configuration:
  resourceGroupName:
    type: string
    default: testname
  networkName:
    type: string
    default: testname
  clusterName:
    type: string
    default: testname
  region:
    type: string
    default: us-east-2
  zones:
    type: dynamic
    default:
      - use2-az1
      - use2-az2
      - use2-az3
  cloudProvider:
    type: string
    default: aws
  throughputTier:
    type: string
    default: tier-1-aws-v2-arm
  userName:
    type: string
    default: test-username
  userPw:
    type: string
    default: password
  mechanism:
    type: string
    default: scram-sha-256
  topicName:
    type: string
    default: test-topic
  partitionCount:
    type: number
    default: 3
  replicationFactor:
    type: number
    default: 3
resources:
  testResourceGroup:
    type: redpanda:ResourceGroup
  testNetwork:
    type: redpanda:Network
    properties:
      resourceGroupId: ${testResourceGroup.id}
      cloudProvider: ${cloudProvider}
      region: ${region}
      clusterType: dedicated
      cidrBlock: 10.0.0.0/20
  testCluster:
    type: redpanda:Cluster
    properties:
      resourceGroupId: ${testResourceGroup.id}
      networkId: ${testNetwork.id}
      cloudProvider: ${cloudProvider}
      region: ${region}
      clusterType: dedicated
      connectionType: public
      throughputTier: ${throughputTier}
      zones: ${zones}
      allowDeletion: true
      tags:
        key: value
  testUser:
    type: redpanda:User
    properties:
      password: ${userPw}
      mechanism: ${mechanism}
      clusterApiUrl: ${testCluster.clusterApiUrl}
  testTopic:
    type: redpanda:Topic
    properties:
      partitionCount: ${partitionCount}
      replicationFactor: ${replicationFactor}
      clusterApiUrl: ${testCluster.clusterApiUrl}
      allowDeletion: true
  testAcl:
    type: redpanda:Acl
    properties:
      resourceType: TOPIC
      resourceName: ${testTopic.name}
      resourcePatternType: LITERAL
      principal: User:${testUser.name}
      host: '*'
      operation: READ
      permissionType: ALLOW
      clusterApiUrl: ${testCluster.clusterApiUrl}

var resourceGroupResource = new Redpanda.ResourceGroup("resourceGroupResource", new()
{
    Name = "string",
});

example, err := redpanda.NewResourceGroup(ctx, "resourceGroupResource", &redpanda.ResourceGroupArgs{
Name: pulumi.String("string"),
})

var resourceGroupResource = new ResourceGroup("resourceGroupResource", ResourceGroupArgs.builder()
    .name("string")
    .build());

resource_group_resource = redpanda.ResourceGroup("resourceGroupResource", name="string")

const resourceGroupResource = new redpanda.ResourceGroup("resourceGroupResource", {name: "string"});

type: redpanda:ResourceGroup
properties:
    name: string