volcengine.vke.Kubeconfigs

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

const fooZones = volcengine.ecs.Zones({});
const fooVpc = new volcengine.vpc.Vpc("fooVpc", {
    vpcName: "acc-test-vpc",
    cidrBlock: "172.16.0.0/16",
});
const fooSubnet = new volcengine.vpc.Subnet("fooSubnet", {
    subnetName: "acc-test-subnet",
    cidrBlock: "172.16.0.0/24",
    zoneId: fooZones.then(fooZones => fooZones.zones?.[0]?.id),
    vpcId: fooVpc.id,
});
const fooSecurityGroup = new volcengine.vpc.SecurityGroup("fooSecurityGroup", {
    securityGroupName: "acc-test-security-group",
    vpcId: fooVpc.id,
});
const fooCluster = new volcengine.vke.Cluster("fooCluster", {
    description: "created by terraform",
    deleteProtectionEnabled: false,
    clusterConfig: {
        subnetIds: [fooSubnet.id],
        apiServerPublicAccessEnabled: true,
        apiServerPublicAccessConfig: {
            publicAccessNetworkConfig: {
                billingType: "PostPaidByBandwidth",
                bandwidth: 1,
            },
        },
        resourcePublicAccessDefaultEnabled: true,
    },
    podsConfig: {
        podNetworkMode: "VpcCniShared",
        vpcCniConfig: {
            subnetIds: [fooSubnet.id],
        },
    },
    servicesConfig: {
        serviceCidrsv4s: ["172.30.0.0/18"],
    },
    tags: [{
        key: "tf-k1",
        value: "tf-v1",
    }],
});
const foo1 = new volcengine.vke.Kubeconfig("foo1", {
    clusterId: fooCluster.id,
    type: "Private",
    validDuration: 2,
});
const foo2 = new volcengine.vke.Kubeconfig("foo2", {
    clusterId: fooCluster.id,
    type: "Public",
    validDuration: 2,
});
const fooKubeconfigs = volcengine.vke.KubeconfigsOutput({
    ids: [
        foo1.id,
        foo2.id,
    ],
});

import pulumi
import pulumi_volcengine as volcengine

foo_zones = volcengine.ecs.zones()
foo_vpc = volcengine.vpc.Vpc("fooVpc",
    vpc_name="acc-test-vpc",
    cidr_block="172.16.0.0/16")
foo_subnet = volcengine.vpc.Subnet("fooSubnet",
    subnet_name="acc-test-subnet",
    cidr_block="172.16.0.0/24",
    zone_id=foo_zones.zones[0].id,
    vpc_id=foo_vpc.id)
foo_security_group = volcengine.vpc.SecurityGroup("fooSecurityGroup",
    security_group_name="acc-test-security-group",
    vpc_id=foo_vpc.id)
foo_cluster = volcengine.vke.Cluster("fooCluster",
    description="created by terraform",
    delete_protection_enabled=False,
    cluster_config=volcengine.vke.ClusterClusterConfigArgs(
        subnet_ids=[foo_subnet.id],
        api_server_public_access_enabled=True,
        api_server_public_access_config=volcengine.vke.ClusterClusterConfigApiServerPublicAccessConfigArgs(
            public_access_network_config=volcengine.vke.ClusterClusterConfigApiServerPublicAccessConfigPublicAccessNetworkConfigArgs(
                billing_type="PostPaidByBandwidth",
                bandwidth=1,
            ),
        ),
        resource_public_access_default_enabled=True,
    ),
    pods_config=volcengine.vke.ClusterPodsConfigArgs(
        pod_network_mode="VpcCniShared",
        vpc_cni_config=volcengine.vke.ClusterPodsConfigVpcCniConfigArgs(
            subnet_ids=[foo_subnet.id],
        ),
    ),
    services_config=volcengine.vke.ClusterServicesConfigArgs(
        service_cidrsv4s=["172.30.0.0/18"],
    ),
    tags=[volcengine.vke.ClusterTagArgs(
        key="tf-k1",
        value="tf-v1",
    )])
foo1 = volcengine.vke.Kubeconfig("foo1",
    cluster_id=foo_cluster.id,
    type="Private",
    valid_duration=2)
foo2 = volcengine.vke.Kubeconfig("foo2",
    cluster_id=foo_cluster.id,
    type="Public",
    valid_duration=2)
foo_kubeconfigs = volcengine.vke.kubeconfigs_output(ids=[
    foo1.id,
    foo2.id,
])

package main

import (
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
	"github.com/volcengine/pulumi-volcengine/sdk/go/volcengine/ecs"
	"github.com/volcengine/pulumi-volcengine/sdk/go/volcengine/vke"
	"github.com/volcengine/pulumi-volcengine/sdk/go/volcengine/vpc"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		fooZones, err := ecs.Zones(ctx, nil, nil)
		if err != nil {
			return err
		}
		fooVpc, err := vpc.NewVpc(ctx, "fooVpc", &vpc.VpcArgs{
			VpcName:   pulumi.String("acc-test-vpc"),
			CidrBlock: pulumi.String("172.16.0.0/16"),
		})
		if err != nil {
			return err
		}
		fooSubnet, err := vpc.NewSubnet(ctx, "fooSubnet", &vpc.SubnetArgs{
			SubnetName: pulumi.String("acc-test-subnet"),
			CidrBlock:  pulumi.String("172.16.0.0/24"),
			ZoneId:     pulumi.String(fooZones.Zones[0].Id),
			VpcId:      fooVpc.ID(),
		})
		if err != nil {
			return err
		}
		_, err = vpc.NewSecurityGroup(ctx, "fooSecurityGroup", &vpc.SecurityGroupArgs{
			SecurityGroupName: pulumi.String("acc-test-security-group"),
			VpcId:             fooVpc.ID(),
		})
		if err != nil {
			return err
		}
		fooCluster, err := vke.NewCluster(ctx, "fooCluster", &vke.ClusterArgs{
			Description:             pulumi.String("created by terraform"),
			DeleteProtectionEnabled: pulumi.Bool(false),
			ClusterConfig: &vke.ClusterClusterConfigArgs{
				SubnetIds: pulumi.StringArray{
					fooSubnet.ID(),
				},
				ApiServerPublicAccessEnabled: pulumi.Bool(true),
				ApiServerPublicAccessConfig: &vke.ClusterClusterConfigApiServerPublicAccessConfigArgs{
					PublicAccessNetworkConfig: &vke.ClusterClusterConfigApiServerPublicAccessConfigPublicAccessNetworkConfigArgs{
						BillingType: pulumi.String("PostPaidByBandwidth"),
						Bandwidth:   pulumi.Int(1),
					},
				},
				ResourcePublicAccessDefaultEnabled: pulumi.Bool(true),
			},
			PodsConfig: &vke.ClusterPodsConfigArgs{
				PodNetworkMode: pulumi.String("VpcCniShared"),
				VpcCniConfig: &vke.ClusterPodsConfigVpcCniConfigArgs{
					SubnetIds: pulumi.StringArray{
						fooSubnet.ID(),
					},
				},
			},
			ServicesConfig: &vke.ClusterServicesConfigArgs{
				ServiceCidrsv4s: pulumi.StringArray{
					pulumi.String("172.30.0.0/18"),
				},
			},
			Tags: vke.ClusterTagArray{
				&vke.ClusterTagArgs{
					Key:   pulumi.String("tf-k1"),
					Value: pulumi.String("tf-v1"),
				},
			},
		})
		if err != nil {
			return err
		}
		foo1, err := vke.NewKubeconfig(ctx, "foo1", &vke.KubeconfigArgs{
			ClusterId:     fooCluster.ID(),
			Type:          pulumi.String("Private"),
			ValidDuration: pulumi.Int(2),
		})
		if err != nil {
			return err
		}
		foo2, err := vke.NewKubeconfig(ctx, "foo2", &vke.KubeconfigArgs{
			ClusterId:     fooCluster.ID(),
			Type:          pulumi.String("Public"),
			ValidDuration: pulumi.Int(2),
		})
		if err != nil {
			return err
		}
		_ = vke.KubeconfigsOutput(ctx, vke.KubeconfigsOutputArgs{
			Ids: pulumi.StringArray{
				foo1.ID(),
				foo2.ID(),
			},
		}, nil)
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var fooZones = Volcengine.Ecs.Zones.Invoke();

    var fooVpc = new Volcengine.Vpc.Vpc("fooVpc", new()
    {
        VpcName = "acc-test-vpc",
        CidrBlock = "172.16.0.0/16",
    });

    var fooSubnet = new Volcengine.Vpc.Subnet("fooSubnet", new()
    {
        SubnetName = "acc-test-subnet",
        CidrBlock = "172.16.0.0/24",
        ZoneId = fooZones.Apply(zonesResult => zonesResult.Zones[0]?.Id),
        VpcId = fooVpc.Id,
    });

    var fooSecurityGroup = new Volcengine.Vpc.SecurityGroup("fooSecurityGroup", new()
    {
        SecurityGroupName = "acc-test-security-group",
        VpcId = fooVpc.Id,
    });

    var fooCluster = new Volcengine.Vke.Cluster("fooCluster", new()
    {
        Description = "created by terraform",
        DeleteProtectionEnabled = false,
        ClusterConfig = new Volcengine.Vke.Inputs.ClusterClusterConfigArgs
        {
            SubnetIds = new[]
            {
                fooSubnet.Id,
            },
            ApiServerPublicAccessEnabled = true,
            ApiServerPublicAccessConfig = new Volcengine.Vke.Inputs.ClusterClusterConfigApiServerPublicAccessConfigArgs
            {
                PublicAccessNetworkConfig = new Volcengine.Vke.Inputs.ClusterClusterConfigApiServerPublicAccessConfigPublicAccessNetworkConfigArgs
                {
                    BillingType = "PostPaidByBandwidth",
                    Bandwidth = 1,
                },
            },
            ResourcePublicAccessDefaultEnabled = true,
        },
        PodsConfig = new Volcengine.Vke.Inputs.ClusterPodsConfigArgs
        {
            PodNetworkMode = "VpcCniShared",
            VpcCniConfig = new Volcengine.Vke.Inputs.ClusterPodsConfigVpcCniConfigArgs
            {
                SubnetIds = new[]
                {
                    fooSubnet.Id,
                },
            },
        },
        ServicesConfig = new Volcengine.Vke.Inputs.ClusterServicesConfigArgs
        {
            ServiceCidrsv4s = new[]
            {
                "172.30.0.0/18",
            },
        },
        Tags = new[]
        {
            new Volcengine.Vke.Inputs.ClusterTagArgs
            {
                Key = "tf-k1",
                Value = "tf-v1",
            },
        },
    });

    var foo1 = new Volcengine.Vke.Kubeconfig("foo1", new()
    {
        ClusterId = fooCluster.Id,
        Type = "Private",
        ValidDuration = 2,
    });

    var foo2 = new Volcengine.Vke.Kubeconfig("foo2", new()
    {
        ClusterId = fooCluster.Id,
        Type = "Public",
        ValidDuration = 2,
    });

    var fooKubeconfigs = Volcengine.Vke.Kubeconfigs.Invoke(new()
    {
        Ids = new[]
        {
            foo1.Id,
            foo2.Id,
        },
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.volcengine.ecs.EcsFunctions;
import com.pulumi.volcengine.ecs.inputs.ZonesArgs;
import com.pulumi.volcengine.vpc.Vpc;
import com.pulumi.volcengine.vpc.VpcArgs;
import com.pulumi.volcengine.vpc.Subnet;
import com.pulumi.volcengine.vpc.SubnetArgs;
import com.pulumi.volcengine.vpc.SecurityGroup;
import com.pulumi.volcengine.vpc.SecurityGroupArgs;
import com.pulumi.volcengine.vke.Cluster;
import com.pulumi.volcengine.vke.ClusterArgs;
import com.pulumi.volcengine.vke.inputs.ClusterClusterConfigArgs;
import com.pulumi.volcengine.vke.inputs.ClusterClusterConfigApiServerPublicAccessConfigArgs;
import com.pulumi.volcengine.vke.inputs.ClusterClusterConfigApiServerPublicAccessConfigPublicAccessNetworkConfigArgs;
import com.pulumi.volcengine.vke.inputs.ClusterPodsConfigArgs;
import com.pulumi.volcengine.vke.inputs.ClusterPodsConfigVpcCniConfigArgs;
import com.pulumi.volcengine.vke.inputs.ClusterServicesConfigArgs;
import com.pulumi.volcengine.vke.inputs.ClusterTagArgs;
import com.pulumi.volcengine.vke.Kubeconfig;
import com.pulumi.volcengine.vke.KubeconfigArgs;
import com.pulumi.volcengine.vke.VkeFunctions;
import com.pulumi.volcengine.vke.inputs.KubeconfigsArgs;
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 fooZones = EcsFunctions.Zones();

        var fooVpc = new Vpc("fooVpc", VpcArgs.builder()        
            .vpcName("acc-test-vpc")
            .cidrBlock("172.16.0.0/16")
            .build());

        var fooSubnet = new Subnet("fooSubnet", SubnetArgs.builder()        
            .subnetName("acc-test-subnet")
            .cidrBlock("172.16.0.0/24")
            .zoneId(fooZones.applyValue(zonesResult -> zonesResult.zones()[0].id()))
            .vpcId(fooVpc.id())
            .build());

        var fooSecurityGroup = new SecurityGroup("fooSecurityGroup", SecurityGroupArgs.builder()        
            .securityGroupName("acc-test-security-group")
            .vpcId(fooVpc.id())
            .build());

        var fooCluster = new Cluster("fooCluster", ClusterArgs.builder()        
            .description("created by terraform")
            .deleteProtectionEnabled(false)
            .clusterConfig(ClusterClusterConfigArgs.builder()
                .subnetIds(fooSubnet.id())
                .apiServerPublicAccessEnabled(true)
                .apiServerPublicAccessConfig(ClusterClusterConfigApiServerPublicAccessConfigArgs.builder()
                    .publicAccessNetworkConfig(ClusterClusterConfigApiServerPublicAccessConfigPublicAccessNetworkConfigArgs.builder()
                        .billingType("PostPaidByBandwidth")
                        .bandwidth(1)
                        .build())
                    .build())
                .resourcePublicAccessDefaultEnabled(true)
                .build())
            .podsConfig(ClusterPodsConfigArgs.builder()
                .podNetworkMode("VpcCniShared")
                .vpcCniConfig(ClusterPodsConfigVpcCniConfigArgs.builder()
                    .subnetIds(fooSubnet.id())
                    .build())
                .build())
            .servicesConfig(ClusterServicesConfigArgs.builder()
                .serviceCidrsv4s("172.30.0.0/18")
                .build())
            .tags(ClusterTagArgs.builder()
                .key("tf-k1")
                .value("tf-v1")
                .build())
            .build());

        var foo1 = new Kubeconfig("foo1", KubeconfigArgs.builder()        
            .clusterId(fooCluster.id())
            .type("Private")
            .validDuration(2)
            .build());

        var foo2 = new Kubeconfig("foo2", KubeconfigArgs.builder()        
            .clusterId(fooCluster.id())
            .type("Public")
            .validDuration(2)
            .build());

        final var fooKubeconfigs = VkeFunctions.Kubeconfigs(KubeconfigsArgs.builder()
            .ids(            
                foo1.id(),
                foo2.id())
            .build());

    }
}

resources:
  fooVpc:
    type: volcengine:vpc:Vpc
    properties:
      vpcName: acc-test-vpc
      cidrBlock: 172.16.0.0/16
  fooSubnet:
    type: volcengine:vpc:Subnet
    properties:
      subnetName: acc-test-subnet
      cidrBlock: 172.16.0.0/24
      zoneId: ${fooZones.zones[0].id}
      vpcId: ${fooVpc.id}
  fooSecurityGroup:
    type: volcengine:vpc:SecurityGroup
    properties:
      securityGroupName: acc-test-security-group
      vpcId: ${fooVpc.id}
  fooCluster:
    type: volcengine:vke:Cluster
    properties:
      description: created by terraform
      deleteProtectionEnabled: false
      clusterConfig:
        subnetIds:
          - ${fooSubnet.id}
        apiServerPublicAccessEnabled: true
        apiServerPublicAccessConfig:
          publicAccessNetworkConfig:
            billingType: PostPaidByBandwidth
            bandwidth: 1
        resourcePublicAccessDefaultEnabled: true
      podsConfig:
        podNetworkMode: VpcCniShared
        vpcCniConfig:
          subnetIds:
            - ${fooSubnet.id}
      servicesConfig:
        serviceCidrsv4s:
          - 172.30.0.0/18
      tags:
        - key: tf-k1
          value: tf-v1
  foo1:
    type: volcengine:vke:Kubeconfig
    properties:
      clusterId: ${fooCluster.id}
      type: Private
      validDuration: 2
  foo2:
    type: volcengine:vke:Kubeconfig
    properties:
      clusterId: ${fooCluster.id}
      type: Public
      validDuration: 2
variables:
  fooZones:
    fn::invoke:
      Function: volcengine:ecs:Zones
      Arguments: {}
  fooKubeconfigs:
    fn::invoke:
      Function: volcengine:vke:Kubeconfigs
      Arguments:
        ids:
          - ${foo1.id}
          - ${foo2.id}

function kubeconfigs(args: KubeconfigsArgs, opts?: InvokeOptions): Promise<KubeconfigsResult>
function kubeconfigsOutput(args: KubeconfigsOutputArgs, opts?: InvokeOptions): Output<KubeconfigsResult>

def kubeconfigs(cluster_ids: Optional[Sequence[str]] = None,
                ids: Optional[Sequence[str]] = None,
                name_regex: Optional[str] = None,
                output_file: Optional[str] = None,
                page_number: Optional[int] = None,
                page_size: Optional[int] = None,
                role_ids: Optional[Sequence[int]] = None,
                types: Optional[Sequence[str]] = None,
                opts: Optional[InvokeOptions] = None) -> KubeconfigsResult
def kubeconfigs_output(cluster_ids: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                ids: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                name_regex: Optional[pulumi.Input[str]] = None,
                output_file: Optional[pulumi.Input[str]] = None,
                page_number: Optional[pulumi.Input[int]] = None,
                page_size: Optional[pulumi.Input[int]] = None,
                role_ids: Optional[pulumi.Input[Sequence[pulumi.Input[int]]]] = None,
                types: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                opts: Optional[InvokeOptions] = None) -> Output[KubeconfigsResult]

func Kubeconfigs(ctx *Context, args *KubeconfigsArgs, opts ...InvokeOption) (*KubeconfigsResult, error)
func KubeconfigsOutput(ctx *Context, args *KubeconfigsOutputArgs, opts ...InvokeOption) KubeconfigsResultOutput

public static class Kubeconfigs 
{
    public static Task<KubeconfigsResult> InvokeAsync(KubeconfigsArgs args, InvokeOptions? opts = null)
    public static Output<KubeconfigsResult> Invoke(KubeconfigsInvokeArgs args, InvokeOptions? opts = null)
}

public static CompletableFuture<KubeconfigsResult> kubeconfigs(KubeconfigsArgs args, InvokeOptions options)
public static Output<KubeconfigsResult> kubeconfigs(KubeconfigsArgs args, InvokeOptions options)

fn::invoke:
  function: volcengine:vke:Kubeconfigs
  arguments:
    # arguments dictionary