volcengine.ebs.Volume

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 fooImages = volcengine.ecs.Images({
    osType: "Linux",
    visibility: "public",
    instanceTypeId: "ecs.g1.large",
});
const fooInstance = new volcengine.ecs.Instance("fooInstance", {
    instanceName: "acc-test-ecs",
    description: "acc-test",
    hostName: "tf-acc-test",
    imageId: fooImages.then(fooImages => fooImages.images?.[0]?.imageId),
    instanceType: "ecs.g1.large",
    password: "93f0cb0614Aab12",
    instanceChargeType: "PrePaid",
    period: 1,
    systemVolumeType: "ESSD_PL0",
    systemVolumeSize: 40,
    subnetId: fooSubnet.id,
    securityGroupIds: [fooSecurityGroup.id],
    projectName: "default",
    tags: [{
        key: "k1",
        value: "v1",
    }],
});
const preVolume = new volcengine.ebs.Volume("preVolume", {
    volumeName: "acc-test-volume",
    volumeType: "ESSD_PL0",
    description: "acc-test",
    kind: "data",
    size: 40,
    zoneId: fooZones.then(fooZones => fooZones.zones?.[0]?.id),
    volumeChargeType: "PrePaid",
    instanceId: fooInstance.id,
    projectName: "default",
    deleteWithInstance: true,
    tags: [{
        key: "k1",
        value: "v1",
    }],
});
const postVolume = new volcengine.ebs.Volume("postVolume", {
    volumeName: "acc-test-volume",
    volumeType: "ESSD_PL0",
    description: "acc-test",
    kind: "data",
    size: 40,
    zoneId: fooZones.then(fooZones => fooZones.zones?.[0]?.id),
    volumeChargeType: "PostPaid",
    projectName: "default",
    tags: [{
        key: "k1",
        value: "v1",
    }],
});

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_images = volcengine.ecs.images(os_type="Linux",
    visibility="public",
    instance_type_id="ecs.g1.large")
foo_instance = volcengine.ecs.Instance("fooInstance",
    instance_name="acc-test-ecs",
    description="acc-test",
    host_name="tf-acc-test",
    image_id=foo_images.images[0].image_id,
    instance_type="ecs.g1.large",
    password="93f0cb0614Aab12",
    instance_charge_type="PrePaid",
    period=1,
    system_volume_type="ESSD_PL0",
    system_volume_size=40,
    subnet_id=foo_subnet.id,
    security_group_ids=[foo_security_group.id],
    project_name="default",
    tags=[volcengine.ecs.InstanceTagArgs(
        key="k1",
        value="v1",
    )])
pre_volume = volcengine.ebs.Volume("preVolume",
    volume_name="acc-test-volume",
    volume_type="ESSD_PL0",
    description="acc-test",
    kind="data",
    size=40,
    zone_id=foo_zones.zones[0].id,
    volume_charge_type="PrePaid",
    instance_id=foo_instance.id,
    project_name="default",
    delete_with_instance=True,
    tags=[volcengine.ebs.VolumeTagArgs(
        key="k1",
        value="v1",
    )])
post_volume = volcengine.ebs.Volume("postVolume",
    volume_name="acc-test-volume",
    volume_type="ESSD_PL0",
    description="acc-test",
    kind="data",
    size=40,
    zone_id=foo_zones.zones[0].id,
    volume_charge_type="PostPaid",
    project_name="default",
    tags=[volcengine.ebs.VolumeTagArgs(
        key="k1",
        value="v1",
    )])

package main

import (
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
	"github.com/volcengine/pulumi-volcengine/sdk/go/volcengine/ebs"
	"github.com/volcengine/pulumi-volcengine/sdk/go/volcengine/ecs"
	"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
		}
		fooSecurityGroup, err := vpc.NewSecurityGroup(ctx, "fooSecurityGroup", &vpc.SecurityGroupArgs{
			SecurityGroupName: pulumi.String("acc-test-security-group"),
			VpcId:             fooVpc.ID(),
		})
		if err != nil {
			return err
		}
		fooImages, err := ecs.Images(ctx, &ecs.ImagesArgs{
			OsType:         pulumi.StringRef("Linux"),
			Visibility:     pulumi.StringRef("public"),
			InstanceTypeId: pulumi.StringRef("ecs.g1.large"),
		}, nil)
		if err != nil {
			return err
		}
		fooInstance, err := ecs.NewInstance(ctx, "fooInstance", &ecs.InstanceArgs{
			InstanceName:       pulumi.String("acc-test-ecs"),
			Description:        pulumi.String("acc-test"),
			HostName:           pulumi.String("tf-acc-test"),
			ImageId:            pulumi.String(fooImages.Images[0].ImageId),
			InstanceType:       pulumi.String("ecs.g1.large"),
			Password:           pulumi.String("93f0cb0614Aab12"),
			InstanceChargeType: pulumi.String("PrePaid"),
			Period:             pulumi.Int(1),
			SystemVolumeType:   pulumi.String("ESSD_PL0"),
			SystemVolumeSize:   pulumi.Int(40),
			SubnetId:           fooSubnet.ID(),
			SecurityGroupIds: pulumi.StringArray{
				fooSecurityGroup.ID(),
			},
			ProjectName: pulumi.String("default"),
			Tags: ecs.InstanceTagArray{
				&ecs.InstanceTagArgs{
					Key:   pulumi.String("k1"),
					Value: pulumi.String("v1"),
				},
			},
		})
		if err != nil {
			return err
		}
		_, err = ebs.NewVolume(ctx, "preVolume", &ebs.VolumeArgs{
			VolumeName:         pulumi.String("acc-test-volume"),
			VolumeType:         pulumi.String("ESSD_PL0"),
			Description:        pulumi.String("acc-test"),
			Kind:               pulumi.String("data"),
			Size:               pulumi.Int(40),
			ZoneId:             pulumi.String(fooZones.Zones[0].Id),
			VolumeChargeType:   pulumi.String("PrePaid"),
			InstanceId:         fooInstance.ID(),
			ProjectName:        pulumi.String("default"),
			DeleteWithInstance: pulumi.Bool(true),
			Tags: ebs.VolumeTagArray{
				&ebs.VolumeTagArgs{
					Key:   pulumi.String("k1"),
					Value: pulumi.String("v1"),
				},
			},
		})
		if err != nil {
			return err
		}
		_, err = ebs.NewVolume(ctx, "postVolume", &ebs.VolumeArgs{
			VolumeName:       pulumi.String("acc-test-volume"),
			VolumeType:       pulumi.String("ESSD_PL0"),
			Description:      pulumi.String("acc-test"),
			Kind:             pulumi.String("data"),
			Size:             pulumi.Int(40),
			ZoneId:           pulumi.String(fooZones.Zones[0].Id),
			VolumeChargeType: pulumi.String("PostPaid"),
			ProjectName:      pulumi.String("default"),
			Tags: ebs.VolumeTagArray{
				&ebs.VolumeTagArgs{
					Key:   pulumi.String("k1"),
					Value: pulumi.String("v1"),
				},
			},
		})
		if err != nil {
			return err
		}
		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 fooImages = Volcengine.Ecs.Images.Invoke(new()
    {
        OsType = "Linux",
        Visibility = "public",
        InstanceTypeId = "ecs.g1.large",
    });

    var fooInstance = new Volcengine.Ecs.Instance("fooInstance", new()
    {
        InstanceName = "acc-test-ecs",
        Description = "acc-test",
        HostName = "tf-acc-test",
        ImageId = fooImages.Apply(imagesResult => imagesResult.Images[0]?.ImageId),
        InstanceType = "ecs.g1.large",
        Password = "93f0cb0614Aab12",
        InstanceChargeType = "PrePaid",
        Period = 1,
        SystemVolumeType = "ESSD_PL0",
        SystemVolumeSize = 40,
        SubnetId = fooSubnet.Id,
        SecurityGroupIds = new[]
        {
            fooSecurityGroup.Id,
        },
        ProjectName = "default",
        Tags = new[]
        {
            new Volcengine.Ecs.Inputs.InstanceTagArgs
            {
                Key = "k1",
                Value = "v1",
            },
        },
    });

    var preVolume = new Volcengine.Ebs.Volume("preVolume", new()
    {
        VolumeName = "acc-test-volume",
        VolumeType = "ESSD_PL0",
        Description = "acc-test",
        Kind = "data",
        Size = 40,
        ZoneId = fooZones.Apply(zonesResult => zonesResult.Zones[0]?.Id),
        VolumeChargeType = "PrePaid",
        InstanceId = fooInstance.Id,
        ProjectName = "default",
        DeleteWithInstance = true,
        Tags = new[]
        {
            new Volcengine.Ebs.Inputs.VolumeTagArgs
            {
                Key = "k1",
                Value = "v1",
            },
        },
    });

    var postVolume = new Volcengine.Ebs.Volume("postVolume", new()
    {
        VolumeName = "acc-test-volume",
        VolumeType = "ESSD_PL0",
        Description = "acc-test",
        Kind = "data",
        Size = 40,
        ZoneId = fooZones.Apply(zonesResult => zonesResult.Zones[0]?.Id),
        VolumeChargeType = "PostPaid",
        ProjectName = "default",
        Tags = new[]
        {
            new Volcengine.Ebs.Inputs.VolumeTagArgs
            {
                Key = "k1",
                Value = "v1",
            },
        },
    });

});

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.ecs.inputs.ImagesArgs;
import com.pulumi.volcengine.ecs.Instance;
import com.pulumi.volcengine.ecs.InstanceArgs;
import com.pulumi.volcengine.ecs.inputs.InstanceTagArgs;
import com.pulumi.volcengine.ebs.Volume;
import com.pulumi.volcengine.ebs.VolumeArgs;
import com.pulumi.volcengine.ebs.inputs.VolumeTagArgs;
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());

        final var fooImages = EcsFunctions.Images(ImagesArgs.builder()
            .osType("Linux")
            .visibility("public")
            .instanceTypeId("ecs.g1.large")
            .build());

        var fooInstance = new Instance("fooInstance", InstanceArgs.builder()        
            .instanceName("acc-test-ecs")
            .description("acc-test")
            .hostName("tf-acc-test")
            .imageId(fooImages.applyValue(imagesResult -> imagesResult.images()[0].imageId()))
            .instanceType("ecs.g1.large")
            .password("93f0cb0614Aab12")
            .instanceChargeType("PrePaid")
            .period(1)
            .systemVolumeType("ESSD_PL0")
            .systemVolumeSize(40)
            .subnetId(fooSubnet.id())
            .securityGroupIds(fooSecurityGroup.id())
            .projectName("default")
            .tags(InstanceTagArgs.builder()
                .key("k1")
                .value("v1")
                .build())
            .build());

        var preVolume = new Volume("preVolume", VolumeArgs.builder()        
            .volumeName("acc-test-volume")
            .volumeType("ESSD_PL0")
            .description("acc-test")
            .kind("data")
            .size(40)
            .zoneId(fooZones.applyValue(zonesResult -> zonesResult.zones()[0].id()))
            .volumeChargeType("PrePaid")
            .instanceId(fooInstance.id())
            .projectName("default")
            .deleteWithInstance(true)
            .tags(VolumeTagArgs.builder()
                .key("k1")
                .value("v1")
                .build())
            .build());

        var postVolume = new Volume("postVolume", VolumeArgs.builder()        
            .volumeName("acc-test-volume")
            .volumeType("ESSD_PL0")
            .description("acc-test")
            .kind("data")
            .size(40)
            .zoneId(fooZones.applyValue(zonesResult -> zonesResult.zones()[0].id()))
            .volumeChargeType("PostPaid")
            .projectName("default")
            .tags(VolumeTagArgs.builder()
                .key("k1")
                .value("v1")
                .build())
            .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}
  fooInstance:
    type: volcengine:ecs:Instance
    properties:
      instanceName: acc-test-ecs
      description: acc-test
      hostName: tf-acc-test
      imageId: ${fooImages.images[0].imageId}
      instanceType: ecs.g1.large
      password: 93f0cb0614Aab12
      instanceChargeType: PrePaid
      period: 1
      systemVolumeType: ESSD_PL0
      systemVolumeSize: 40
      subnetId: ${fooSubnet.id}
      securityGroupIds:
        - ${fooSecurityGroup.id}
      projectName: default
      tags:
        - key: k1
          value: v1
  preVolume:
    type: volcengine:ebs:Volume
    properties:
      volumeName: acc-test-volume
      volumeType: ESSD_PL0
      description: acc-test
      kind: data
      size: 40
      zoneId: ${fooZones.zones[0].id}
      volumeChargeType: PrePaid
      instanceId: ${fooInstance.id}
      projectName: default
      deleteWithInstance: true
      tags:
        - key: k1
          value: v1
  postVolume:
    type: volcengine:ebs:Volume
    properties:
      volumeName: acc-test-volume
      volumeType: ESSD_PL0
      description: acc-test
      kind: data
      size: 40
      zoneId: ${fooZones.zones[0].id}
      volumeChargeType: PostPaid
      projectName: default
      tags:
        - key: k1
          value: v1
variables:
  fooZones:
    fn::invoke:
      Function: volcengine:ecs:Zones
      Arguments: {}
  fooImages:
    fn::invoke:
      Function: volcengine:ecs:Images
      Arguments:
        osType: Linux
        visibility: public
        instanceTypeId: ecs.g1.large

var volumeResource = new Volcengine.Ebs.Volume("volumeResource", new()
{
    Kind = "string",
    ZoneId = "string",
    VolumeType = "string",
    VolumeName = "string",
    Size = 0,
    ExtraPerformanceThroughputMb = 0,
    InstanceId = "string",
    ProjectName = "string",
    ExtraPerformanceTypeId = "string",
    Tags = new[]
    {
        new Volcengine.Ebs.Inputs.VolumeTagArgs
        {
            Key = "string",
            Value = "string",
        },
    },
    VolumeChargeType = "string",
    DeleteWithInstance = false,
    ExtraPerformanceIops = 0,
    Description = "string",
});

example, err := ebs.NewVolume(ctx, "volumeResource", &ebs.VolumeArgs{
	Kind:                         pulumi.String("string"),
	ZoneId:                       pulumi.String("string"),
	VolumeType:                   pulumi.String("string"),
	VolumeName:                   pulumi.String("string"),
	Size:                         pulumi.Int(0),
	ExtraPerformanceThroughputMb: pulumi.Int(0),
	InstanceId:                   pulumi.String("string"),
	ProjectName:                  pulumi.String("string"),
	ExtraPerformanceTypeId:       pulumi.String("string"),
	Tags: ebs.VolumeTagArray{
		&ebs.VolumeTagArgs{
			Key:   pulumi.String("string"),
			Value: pulumi.String("string"),
		},
	},
	VolumeChargeType:     pulumi.String("string"),
	DeleteWithInstance:   pulumi.Bool(false),
	ExtraPerformanceIops: pulumi.Int(0),
	Description:          pulumi.String("string"),
})

var volumeResource = new Volume("volumeResource", VolumeArgs.builder()
    .kind("string")
    .zoneId("string")
    .volumeType("string")
    .volumeName("string")
    .size(0)
    .extraPerformanceThroughputMb(0)
    .instanceId("string")
    .projectName("string")
    .extraPerformanceTypeId("string")
    .tags(VolumeTagArgs.builder()
        .key("string")
        .value("string")
        .build())
    .volumeChargeType("string")
    .deleteWithInstance(false)
    .extraPerformanceIops(0)
    .description("string")
    .build());

volume_resource = volcengine.ebs.Volume("volumeResource",
    kind="string",
    zone_id="string",
    volume_type="string",
    volume_name="string",
    size=0,
    extra_performance_throughput_mb=0,
    instance_id="string",
    project_name="string",
    extra_performance_type_id="string",
    tags=[{
        "key": "string",
        "value": "string",
    }],
    volume_charge_type="string",
    delete_with_instance=False,
    extra_performance_iops=0,
    description="string")

const volumeResource = new volcengine.ebs.Volume("volumeResource", {
    kind: "string",
    zoneId: "string",
    volumeType: "string",
    volumeName: "string",
    size: 0,
    extraPerformanceThroughputMb: 0,
    instanceId: "string",
    projectName: "string",
    extraPerformanceTypeId: "string",
    tags: [{
        key: "string",
        value: "string",
    }],
    volumeChargeType: "string",
    deleteWithInstance: false,
    extraPerformanceIops: 0,
    description: "string",
});

type: volcengine:ebs:Volume
properties:
    deleteWithInstance: false
    description: string
    extraPerformanceIops: 0
    extraPerformanceThroughputMb: 0
    extraPerformanceTypeId: string
    instanceId: string
    kind: string
    projectName: string
    size: 0
    tags:
        - key: string
          value: string
    volumeChargeType: string
    volumeName: string
    volumeType: string
    zoneId: string