volcengine.escloud_v2.getEscloudInstancesV2

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

const fooZones = volcengine.ecs.getZones({});
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",
    description: "tfdesc",
    cidrBlock: "172.16.0.0/24",
    zoneId: fooZones.then(fooZones => fooZones.zones?.[0]?.id),
    vpcId: fooVpc.id,
});
const fooEscloudInstanceV2 = new volcengine.escloud_v2.EscloudInstanceV2("fooEscloudInstanceV2", {
    instanceName: "acc-test-escloud-instance",
    version: "V7_10",
    zoneIds: [
        fooZones.then(fooZones => fooZones.zones?.[0]?.id),
        fooZones.then(fooZones => fooZones.zones?.[1]?.id),
        fooZones.then(fooZones => fooZones.zones?.[2]?.id),
    ],
    subnetId: fooSubnet.id,
    enableHttps: false,
    adminPassword: "Password@@123",
    chargeType: "PostPaid",
    autoRenew: false,
    period: 1,
    configurationCode: "es.standard",
    enablePureMaster: true,
    deletionProtection: false,
    projectName: "default",
    nodeSpecsAssigns: [
        {
            type: "Master",
            number: 3,
            resourceSpecName: "es.x2.medium",
            storageSpecName: "es.volume.essd.pl0",
            storageSize: 20,
        },
        {
            type: "Hot",
            number: 6,
            resourceSpecName: "es.x2.medium",
            storageSpecName: "es.volume.essd.flexpl-standard",
            storageSize: 500,
            extraPerformance: {
                throughput: 65,
            },
        },
        {
            type: "Kibana",
            number: 1,
            resourceSpecName: "kibana.x2.small",
            storageSpecName: "",
            storageSize: 0,
        },
    ],
    networkSpecs: [
        {
            type: "Elasticsearch",
            bandwidth: 1,
            isOpen: true,
            specName: "es.eip.bgp_fixed_bandwidth",
        },
        {
            type: "Kibana",
            bandwidth: 1,
            isOpen: true,
            specName: "es.eip.bgp_fixed_bandwidth",
        },
    ],
    tags: [{
        key: "k1",
        value: "v1",
    }],
});
const fooEscloudInstancesV2 = volcengine.escloud_v2.getEscloudInstancesV2Output({
    ids: [fooEscloudInstanceV2.id],
});

import pulumi
import pulumi_volcengine as volcengine

foo_zones = volcengine.ecs.get_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",
    description="tfdesc",
    cidr_block="172.16.0.0/24",
    zone_id=foo_zones.zones[0].id,
    vpc_id=foo_vpc.id)
foo_escloud_instance_v2 = volcengine.escloud_v2.EscloudInstanceV2("fooEscloudInstanceV2",
    instance_name="acc-test-escloud-instance",
    version="V7_10",
    zone_ids=[
        foo_zones.zones[0].id,
        foo_zones.zones[1].id,
        foo_zones.zones[2].id,
    ],
    subnet_id=foo_subnet.id,
    enable_https=False,
    admin_password="Password@@123",
    charge_type="PostPaid",
    auto_renew=False,
    period=1,
    configuration_code="es.standard",
    enable_pure_master=True,
    deletion_protection=False,
    project_name="default",
    node_specs_assigns=[
        volcengine.escloud_v2.EscloudInstanceV2NodeSpecsAssignArgs(
            type="Master",
            number=3,
            resource_spec_name="es.x2.medium",
            storage_spec_name="es.volume.essd.pl0",
            storage_size=20,
        ),
        volcengine.escloud_v2.EscloudInstanceV2NodeSpecsAssignArgs(
            type="Hot",
            number=6,
            resource_spec_name="es.x2.medium",
            storage_spec_name="es.volume.essd.flexpl-standard",
            storage_size=500,
            extra_performance=volcengine.escloud_v2.EscloudInstanceV2NodeSpecsAssignExtraPerformanceArgs(
                throughput=65,
            ),
        ),
        volcengine.escloud_v2.EscloudInstanceV2NodeSpecsAssignArgs(
            type="Kibana",
            number=1,
            resource_spec_name="kibana.x2.small",
            storage_spec_name="",
            storage_size=0,
        ),
    ],
    network_specs=[
        volcengine.escloud_v2.EscloudInstanceV2NetworkSpecArgs(
            type="Elasticsearch",
            bandwidth=1,
            is_open=True,
            spec_name="es.eip.bgp_fixed_bandwidth",
        ),
        volcengine.escloud_v2.EscloudInstanceV2NetworkSpecArgs(
            type="Kibana",
            bandwidth=1,
            is_open=True,
            spec_name="es.eip.bgp_fixed_bandwidth",
        ),
    ],
    tags=[volcengine.escloud_v2.EscloudInstanceV2TagArgs(
        key="k1",
        value="v1",
    )])
foo_escloud_instances_v2 = volcengine.escloud_v2.get_escloud_instances_v2_output(ids=[foo_escloud_instance_v2.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/escloud_v2"
	"github.com/volcengine/pulumi-volcengine/sdk/go/volcengine/vpc"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		fooZones, err := ecs.GetZones(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"),
			Description: pulumi.String("tfdesc"),
			CidrBlock:   pulumi.String("172.16.0.0/24"),
			ZoneId:      pulumi.String(fooZones.Zones[0].Id),
			VpcId:       fooVpc.ID(),
		})
		if err != nil {
			return err
		}
		fooEscloudInstanceV2, err := escloud_v2.NewEscloudInstanceV2(ctx, "fooEscloudInstanceV2", &escloud_v2.EscloudInstanceV2Args{
			InstanceName: pulumi.String("acc-test-escloud-instance"),
			Version:      pulumi.String("V7_10"),
			ZoneIds: pulumi.StringArray{
				pulumi.String(fooZones.Zones[0].Id),
				pulumi.String(fooZones.Zones[1].Id),
				pulumi.String(fooZones.Zones[2].Id),
			},
			SubnetId:           fooSubnet.ID(),
			EnableHttps:        pulumi.Bool(false),
			AdminPassword:      pulumi.String("Password@@123"),
			ChargeType:         pulumi.String("PostPaid"),
			AutoRenew:          pulumi.Bool(false),
			Period:             pulumi.Int(1),
			ConfigurationCode:  pulumi.String("es.standard"),
			EnablePureMaster:   pulumi.Bool(true),
			DeletionProtection: pulumi.Bool(false),
			ProjectName:        pulumi.String("default"),
			NodeSpecsAssigns: escloud_v2.EscloudInstanceV2NodeSpecsAssignArray{
				&escloud_v2.EscloudInstanceV2NodeSpecsAssignArgs{
					Type:             pulumi.String("Master"),
					Number:           pulumi.Int(3),
					ResourceSpecName: pulumi.String("es.x2.medium"),
					StorageSpecName:  pulumi.String("es.volume.essd.pl0"),
					StorageSize:      pulumi.Int(20),
				},
				&escloud_v2.EscloudInstanceV2NodeSpecsAssignArgs{
					Type:             pulumi.String("Hot"),
					Number:           pulumi.Int(6),
					ResourceSpecName: pulumi.String("es.x2.medium"),
					StorageSpecName:  pulumi.String("es.volume.essd.flexpl-standard"),
					StorageSize:      pulumi.Int(500),
					ExtraPerformance: &escloud_v2.EscloudInstanceV2NodeSpecsAssignExtraPerformanceArgs{
						Throughput: pulumi.Int(65),
					},
				},
				&escloud_v2.EscloudInstanceV2NodeSpecsAssignArgs{
					Type:             pulumi.String("Kibana"),
					Number:           pulumi.Int(1),
					ResourceSpecName: pulumi.String("kibana.x2.small"),
					StorageSpecName:  pulumi.String(""),
					StorageSize:      pulumi.Int(0),
				},
			},
			NetworkSpecs: escloud_v2.EscloudInstanceV2NetworkSpecArray{
				&escloud_v2.EscloudInstanceV2NetworkSpecArgs{
					Type:      pulumi.String("Elasticsearch"),
					Bandwidth: pulumi.Int(1),
					IsOpen:    pulumi.Bool(true),
					SpecName:  pulumi.String("es.eip.bgp_fixed_bandwidth"),
				},
				&escloud_v2.EscloudInstanceV2NetworkSpecArgs{
					Type:      pulumi.String("Kibana"),
					Bandwidth: pulumi.Int(1),
					IsOpen:    pulumi.Bool(true),
					SpecName:  pulumi.String("es.eip.bgp_fixed_bandwidth"),
				},
			},
			Tags: escloud_v2.EscloudInstanceV2TagArray{
				&escloud_v2.EscloudInstanceV2TagArgs{
					Key:   pulumi.String("k1"),
					Value: pulumi.String("v1"),
				},
			},
		})
		if err != nil {
			return err
		}
		_ = escloud_v2.GetEscloudInstancesV2Output(ctx, escloud_v2.GetEscloudInstancesV2OutputArgs{
			Ids: pulumi.StringArray{
				fooEscloudInstanceV2.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.GetZones.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",
        Description = "tfdesc",
        CidrBlock = "172.16.0.0/24",
        ZoneId = fooZones.Apply(getZonesResult => getZonesResult.Zones[0]?.Id),
        VpcId = fooVpc.Id,
    });

    var fooEscloudInstanceV2 = new Volcengine.Escloud_v2.EscloudInstanceV2("fooEscloudInstanceV2", new()
    {
        InstanceName = "acc-test-escloud-instance",
        Version = "V7_10",
        ZoneIds = new[]
        {
            fooZones.Apply(getZonesResult => getZonesResult.Zones[0]?.Id),
            fooZones.Apply(getZonesResult => getZonesResult.Zones[1]?.Id),
            fooZones.Apply(getZonesResult => getZonesResult.Zones[2]?.Id),
        },
        SubnetId = fooSubnet.Id,
        EnableHttps = false,
        AdminPassword = "Password@@123",
        ChargeType = "PostPaid",
        AutoRenew = false,
        Period = 1,
        ConfigurationCode = "es.standard",
        EnablePureMaster = true,
        DeletionProtection = false,
        ProjectName = "default",
        NodeSpecsAssigns = new[]
        {
            new Volcengine.Escloud_v2.Inputs.EscloudInstanceV2NodeSpecsAssignArgs
            {
                Type = "Master",
                Number = 3,
                ResourceSpecName = "es.x2.medium",
                StorageSpecName = "es.volume.essd.pl0",
                StorageSize = 20,
            },
            new Volcengine.Escloud_v2.Inputs.EscloudInstanceV2NodeSpecsAssignArgs
            {
                Type = "Hot",
                Number = 6,
                ResourceSpecName = "es.x2.medium",
                StorageSpecName = "es.volume.essd.flexpl-standard",
                StorageSize = 500,
                ExtraPerformance = new Volcengine.Escloud_v2.Inputs.EscloudInstanceV2NodeSpecsAssignExtraPerformanceArgs
                {
                    Throughput = 65,
                },
            },
            new Volcengine.Escloud_v2.Inputs.EscloudInstanceV2NodeSpecsAssignArgs
            {
                Type = "Kibana",
                Number = 1,
                ResourceSpecName = "kibana.x2.small",
                StorageSpecName = "",
                StorageSize = 0,
            },
        },
        NetworkSpecs = new[]
        {
            new Volcengine.Escloud_v2.Inputs.EscloudInstanceV2NetworkSpecArgs
            {
                Type = "Elasticsearch",
                Bandwidth = 1,
                IsOpen = true,
                SpecName = "es.eip.bgp_fixed_bandwidth",
            },
            new Volcengine.Escloud_v2.Inputs.EscloudInstanceV2NetworkSpecArgs
            {
                Type = "Kibana",
                Bandwidth = 1,
                IsOpen = true,
                SpecName = "es.eip.bgp_fixed_bandwidth",
            },
        },
        Tags = new[]
        {
            new Volcengine.Escloud_v2.Inputs.EscloudInstanceV2TagArgs
            {
                Key = "k1",
                Value = "v1",
            },
        },
    });

    var fooEscloudInstancesV2 = Volcengine.Escloud_v2.GetEscloudInstancesV2.Invoke(new()
    {
        Ids = new[]
        {
            fooEscloudInstanceV2.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.GetZonesArgs;
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.escloud_v2.EscloudInstanceV2;
import com.pulumi.volcengine.escloud_v2.EscloudInstanceV2Args;
import com.pulumi.volcengine.escloud_v2.inputs.EscloudInstanceV2NodeSpecsAssignArgs;
import com.pulumi.volcengine.escloud_v2.inputs.EscloudInstanceV2NodeSpecsAssignExtraPerformanceArgs;
import com.pulumi.volcengine.escloud_v2.inputs.EscloudInstanceV2NetworkSpecArgs;
import com.pulumi.volcengine.escloud_v2.inputs.EscloudInstanceV2TagArgs;
import com.pulumi.volcengine.escloud_v2.Escloud_v2Functions;
import com.pulumi.volcengine.escloud_v2.inputs.GetEscloudInstancesV2Args;
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.getZones();

        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")
            .description("tfdesc")
            .cidrBlock("172.16.0.0/24")
            .zoneId(fooZones.applyValue(getZonesResult -> getZonesResult.zones()[0].id()))
            .vpcId(fooVpc.id())
            .build());

        var fooEscloudInstanceV2 = new EscloudInstanceV2("fooEscloudInstanceV2", EscloudInstanceV2Args.builder()        
            .instanceName("acc-test-escloud-instance")
            .version("V7_10")
            .zoneIds(            
                fooZones.applyValue(getZonesResult -> getZonesResult.zones()[0].id()),
                fooZones.applyValue(getZonesResult -> getZonesResult.zones()[1].id()),
                fooZones.applyValue(getZonesResult -> getZonesResult.zones()[2].id()))
            .subnetId(fooSubnet.id())
            .enableHttps(false)
            .adminPassword("Password@@123")
            .chargeType("PostPaid")
            .autoRenew(false)
            .period(1)
            .configurationCode("es.standard")
            .enablePureMaster(true)
            .deletionProtection(false)
            .projectName("default")
            .nodeSpecsAssigns(            
                EscloudInstanceV2NodeSpecsAssignArgs.builder()
                    .type("Master")
                    .number(3)
                    .resourceSpecName("es.x2.medium")
                    .storageSpecName("es.volume.essd.pl0")
                    .storageSize(20)
                    .build(),
                EscloudInstanceV2NodeSpecsAssignArgs.builder()
                    .type("Hot")
                    .number(6)
                    .resourceSpecName("es.x2.medium")
                    .storageSpecName("es.volume.essd.flexpl-standard")
                    .storageSize(500)
                    .extraPerformance(EscloudInstanceV2NodeSpecsAssignExtraPerformanceArgs.builder()
                        .throughput(65)
                        .build())
                    .build(),
                EscloudInstanceV2NodeSpecsAssignArgs.builder()
                    .type("Kibana")
                    .number(1)
                    .resourceSpecName("kibana.x2.small")
                    .storageSpecName("")
                    .storageSize(0)
                    .build())
            .networkSpecs(            
                EscloudInstanceV2NetworkSpecArgs.builder()
                    .type("Elasticsearch")
                    .bandwidth(1)
                    .isOpen(true)
                    .specName("es.eip.bgp_fixed_bandwidth")
                    .build(),
                EscloudInstanceV2NetworkSpecArgs.builder()
                    .type("Kibana")
                    .bandwidth(1)
                    .isOpen(true)
                    .specName("es.eip.bgp_fixed_bandwidth")
                    .build())
            .tags(EscloudInstanceV2TagArgs.builder()
                .key("k1")
                .value("v1")
                .build())
            .build());

        final var fooEscloudInstancesV2 = Escloud_v2Functions.getEscloudInstancesV2(GetEscloudInstancesV2Args.builder()
            .ids(fooEscloudInstanceV2.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
      description: tfdesc
      cidrBlock: 172.16.0.0/24
      zoneId: ${fooZones.zones[0].id}
      vpcId: ${fooVpc.id}
  fooEscloudInstanceV2:
    type: volcengine:escloud_v2:EscloudInstanceV2
    properties:
      instanceName: acc-test-escloud-instance
      version: V7_10
      zoneIds:
        - ${fooZones.zones[0].id}
        - ${fooZones.zones[1].id}
        - ${fooZones.zones[2].id}
      subnetId: ${fooSubnet.id}
      enableHttps: false
      adminPassword: Password@@123
      chargeType: PostPaid
      autoRenew: false
      period: 1
      configurationCode: es.standard
      enablePureMaster: true
      deletionProtection: false
      projectName: default
      nodeSpecsAssigns:
        - type: Master
          number: 3
          resourceSpecName: es.x2.medium
          storageSpecName: es.volume.essd.pl0
          storageSize: 20
        - type: Hot
          number: 6
          resourceSpecName: es.x2.medium
          storageSpecName: es.volume.essd.flexpl-standard
          storageSize: 500
          extraPerformance:
            throughput: 65
        - type: Kibana
          number: 1
          resourceSpecName: kibana.x2.small
          storageSpecName:
          storageSize: 0
      networkSpecs:
        - type: Elasticsearch
          bandwidth: 1
          isOpen: true
          specName: es.eip.bgp_fixed_bandwidth
        - type: Kibana
          bandwidth: 1
          isOpen: true
          specName: es.eip.bgp_fixed_bandwidth
      tags:
        - key: k1
          value: v1
variables:
  fooZones:
    fn::invoke:
      Function: volcengine:ecs:getZones
      Arguments: {}
  fooEscloudInstancesV2:
    fn::invoke:
      Function: volcengine:escloud_v2:getEscloudInstancesV2
      Arguments:
        ids:
          - ${fooEscloudInstanceV2.id}

function getEscloudInstancesV2(args: GetEscloudInstancesV2Args, opts?: InvokeOptions): Promise<GetEscloudInstancesV2Result>
function getEscloudInstancesV2Output(args: GetEscloudInstancesV2OutputArgs, opts?: InvokeOptions): Output<GetEscloudInstancesV2Result>

def get_escloud_instances_v2(charge_types: Optional[Sequence[str]] = None,
                             ids: Optional[Sequence[str]] = None,
                             instance_names: Optional[Sequence[str]] = None,
                             output_file: Optional[str] = None,
                             project_name: Optional[str] = None,
                             statuses: Optional[Sequence[str]] = None,
                             tags: Optional[Sequence[GetEscloudInstancesV2Tag]] = None,
                             versions: Optional[Sequence[str]] = None,
                             zone_ids: Optional[Sequence[str]] = None,
                             opts: Optional[InvokeOptions] = None) -> GetEscloudInstancesV2Result
def get_escloud_instances_v2_output(charge_types: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                             ids: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                             instance_names: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                             output_file: Optional[pulumi.Input[str]] = None,
                             project_name: Optional[pulumi.Input[str]] = None,
                             statuses: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                             tags: Optional[pulumi.Input[Sequence[pulumi.Input[GetEscloudInstancesV2TagArgs]]]] = None,
                             versions: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                             zone_ids: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                             opts: Optional[InvokeOptions] = None) -> Output[GetEscloudInstancesV2Result]

func GetEscloudInstancesV2(ctx *Context, args *GetEscloudInstancesV2Args, opts ...InvokeOption) (*GetEscloudInstancesV2Result, error)
func GetEscloudInstancesV2Output(ctx *Context, args *GetEscloudInstancesV2OutputArgs, opts ...InvokeOption) GetEscloudInstancesV2ResultOutput

public static class GetEscloudInstancesV2 
{
    public static Task<GetEscloudInstancesV2Result> InvokeAsync(GetEscloudInstancesV2Args args, InvokeOptions? opts = null)
    public static Output<GetEscloudInstancesV2Result> Invoke(GetEscloudInstancesV2InvokeArgs args, InvokeOptions? opts = null)
}

public static CompletableFuture<GetEscloudInstancesV2Result> getEscloudInstancesV2(GetEscloudInstancesV2Args args, InvokeOptions options)
public static Output<GetEscloudInstancesV2Result> getEscloudInstancesV2(GetEscloudInstancesV2Args args, InvokeOptions options)

fn::invoke:
  function: volcengine:escloud_v2/getEscloudInstancesV2:getEscloudInstancesV2
  arguments:
    # arguments dictionary