edgecenter.InstanceV2

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

const config = new pulumi.Config();
const regionId = config.getNumber("regionId") || 1;
const projectId = config.getNumber("projectId") || 1;
const imageId = config.get("imageId") || "f4ce3d30-e29c-4cfd-811f-46f383b6081f";
const network = new edgecenter.Network("network", {
    type: "vxlan",
    regionId: regionId,
    projectId: projectId,
});
const subnet = new edgecenter.Subnet("subnet", {
    cidr: "192.168.10.0/24",
    networkId: network.networkId,
    dnsNameservers: [
        "8.8.4.4",
        "1.1.1.1",
    ],
    hostRoutes: [{
        destination: "10.0.3.0/24",
        nexthop: "10.0.0.13",
    }],
    gatewayIp: "192.168.10.1",
    regionId: regionId,
    projectId: projectId,
});
const firstVolume = new edgecenter.Volume("firstVolume", {
    typeName: "ssd_hiiops",
    size: 5,
    regionId: regionId,
    projectId: projectId,
    imageId: imageId,
});
const secondVolume = new edgecenter.Volume("secondVolume", {
    typeName: "ssd_hiiops",
    size: 5,
    regionId: regionId,
    projectId: projectId,
});
const sg = new edgecenter.Securitygroup("sg", {
    regionId: regionId,
    projectId: projectId,
    securityGroupRules: [{
        direction: "egress",
        ethertype: "IPv4",
        protocol: "tcp",
        portRangeMin: 19990,
        portRangeMax: 19990,
    }],
});
const instance = new edgecenter.InstanceV2("instance", {
    flavorId: "g1-standard-2-4",
    bootVolumes: [{
        volumeId: firstVolume.volumeId,
        bootIndex: 0,
    }],
    dataVolumes: [{
        volumeId: secondVolume.volumeId,
    }],
    interfaces: [{
        isDefault: true,
        type: "subnet",
        networkId: network.networkId,
        subnetId: subnet.subnetId,
    }],
    metadata: {
        some_key: "some_value",
        stage: "dev",
    },
    configurations: [{
        key: "some_key",
        value: "some_data",
    }],
    regionId: regionId,
    projectId: projectId,
});
const portSecurity = new edgecenter.InstancePortSecurity("portSecurity", {
    portId: pulumi.all([instance.interfaces, subnet.subnetId]).apply(([interfaces, subnetId]) => interfaces.filter(iface => iface.subnetId == subnetId).map(iface => (iface.portId))[0]),
    instanceId: instance.instanceV2Id,
    regionId: regionId,
    projectId: projectId,
    portSecurityDisabled: false,
    securityGroups: {
        overwriteExisting: true,
        securityGroupIds: [sg.securitygroupId],
    },
});

import pulumi
import pulumi_edgecenter as edgecenter

config = pulumi.Config()
region_id = config.get_float("regionId")
if region_id is None:
    region_id = 1
project_id = config.get_float("projectId")
if project_id is None:
    project_id = 1
image_id = config.get("imageId")
if image_id is None:
    image_id = "f4ce3d30-e29c-4cfd-811f-46f383b6081f"
network = edgecenter.Network("network",
    type="vxlan",
    region_id=region_id,
    project_id=project_id)
subnet = edgecenter.Subnet("subnet",
    cidr="192.168.10.0/24",
    network_id=network.network_id,
    dns_nameservers=[
        "8.8.4.4",
        "1.1.1.1",
    ],
    host_routes=[{
        "destination": "10.0.3.0/24",
        "nexthop": "10.0.0.13",
    }],
    gateway_ip="192.168.10.1",
    region_id=region_id,
    project_id=project_id)
first_volume = edgecenter.Volume("firstVolume",
    type_name="ssd_hiiops",
    size=5,
    region_id=region_id,
    project_id=project_id,
    image_id=image_id)
second_volume = edgecenter.Volume("secondVolume",
    type_name="ssd_hiiops",
    size=5,
    region_id=region_id,
    project_id=project_id)
sg = edgecenter.Securitygroup("sg",
    region_id=region_id,
    project_id=project_id,
    security_group_rules=[{
        "direction": "egress",
        "ethertype": "IPv4",
        "protocol": "tcp",
        "port_range_min": 19990,
        "port_range_max": 19990,
    }])
instance = edgecenter.InstanceV2("instance",
    flavor_id="g1-standard-2-4",
    boot_volumes=[{
        "volume_id": first_volume.volume_id,
        "boot_index": 0,
    }],
    data_volumes=[{
        "volume_id": second_volume.volume_id,
    }],
    interfaces=[{
        "is_default": True,
        "type": "subnet",
        "network_id": network.network_id,
        "subnet_id": subnet.subnet_id,
    }],
    metadata={
        "some_key": "some_value",
        "stage": "dev",
    },
    configurations=[{
        "key": "some_key",
        "value": "some_data",
    }],
    region_id=region_id,
    project_id=project_id)
port_security = edgecenter.InstancePortSecurity("portSecurity",
    port_id=pulumi.Output.all(
        interfaces=instance.interfaces,
        subnet_id=subnet.subnet_id
).apply(lambda resolved_outputs: [iface.port_id for iface in resolved_outputs['interfaces'] if iface.subnet_id == resolved_outputs['subnet_id']][0])
,
    instance_id=instance.instance_v2_id,
    region_id=region_id,
    project_id=project_id,
    port_security_disabled=False,
    security_groups={
        "overwrite_existing": True,
        "security_group_ids": [sg.securitygroup_id],
    })

package main

import (
	"github.com/pulumi/pulumi-terraform-provider/sdks/go/edgecenter/edgecenter"
	"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 {
		cfg := config.New(ctx, "")
		regionId := float64(1)
		if param := cfg.GetFloat64("regionId"); param != 0 {
			regionId = param
		}
		projectId := float64(1)
		if param := cfg.GetFloat64("projectId"); param != 0 {
			projectId = param
		}
		imageId := "f4ce3d30-e29c-4cfd-811f-46f383b6081f"
		if param := cfg.Get("imageId"); param != "" {
			imageId = param
		}
		network, err := edgecenter.NewNetwork(ctx, "network", &edgecenter.NetworkArgs{
			Type:      pulumi.String("vxlan"),
			RegionId:  pulumi.Float64(regionId),
			ProjectId: pulumi.Float64(projectId),
		})
		if err != nil {
			return err
		}
		subnet, err := edgecenter.NewSubnet(ctx, "subnet", &edgecenter.SubnetArgs{
			Cidr:      pulumi.String("192.168.10.0/24"),
			NetworkId: network.NetworkId,
			DnsNameservers: pulumi.StringArray{
				pulumi.String("8.8.4.4"),
				pulumi.String("1.1.1.1"),
			},
			HostRoutes: edgecenter.SubnetHostRouteArray{
				&edgecenter.SubnetHostRouteArgs{
					Destination: pulumi.String("10.0.3.0/24"),
					Nexthop:     pulumi.String("10.0.0.13"),
				},
			},
			GatewayIp: pulumi.String("192.168.10.1"),
			RegionId:  pulumi.Float64(regionId),
			ProjectId: pulumi.Float64(projectId),
		})
		if err != nil {
			return err
		}
		firstVolume, err := edgecenter.NewVolume(ctx, "firstVolume", &edgecenter.VolumeArgs{
			TypeName:  pulumi.String("ssd_hiiops"),
			Size:      pulumi.Float64(5),
			RegionId:  pulumi.Float64(regionId),
			ProjectId: pulumi.Float64(projectId),
			ImageId:   pulumi.String(imageId),
		})
		if err != nil {
			return err
		}
		secondVolume, err := edgecenter.NewVolume(ctx, "secondVolume", &edgecenter.VolumeArgs{
			TypeName:  pulumi.String("ssd_hiiops"),
			Size:      pulumi.Float64(5),
			RegionId:  pulumi.Float64(regionId),
			ProjectId: pulumi.Float64(projectId),
		})
		if err != nil {
			return err
		}
		sg, err := edgecenter.NewSecuritygroup(ctx, "sg", &edgecenter.SecuritygroupArgs{
			RegionId:  pulumi.Float64(regionId),
			ProjectId: pulumi.Float64(projectId),
			SecurityGroupRules: edgecenter.SecuritygroupSecurityGroupRuleArray{
				&edgecenter.SecuritygroupSecurityGroupRuleArgs{
					Direction:    pulumi.String("egress"),
					Ethertype:    pulumi.String("IPv4"),
					Protocol:     pulumi.String("tcp"),
					PortRangeMin: pulumi.Float64(19990),
					PortRangeMax: pulumi.Float64(19990),
				},
			},
		})
		if err != nil {
			return err
		}
		instance, err := edgecenter.NewInstanceV2(ctx, "instance", &edgecenter.InstanceV2Args{
			FlavorId: pulumi.String("g1-standard-2-4"),
			BootVolumes: edgecenter.InstanceV2BootVolumeArray{
				&edgecenter.InstanceV2BootVolumeArgs{
					VolumeId:  firstVolume.VolumeId,
					BootIndex: pulumi.Float64(0),
				},
			},
			DataVolumes: edgecenter.InstanceV2DataVolumeArray{
				&edgecenter.InstanceV2DataVolumeArgs{
					VolumeId: secondVolume.VolumeId,
				},
			},
			Interfaces: edgecenter.InstanceV2InterfaceArray{
				&edgecenter.InstanceV2InterfaceArgs{
					IsDefault: pulumi.Bool(true),
					Type:      pulumi.String("subnet"),
					NetworkId: network.NetworkId,
					SubnetId:  subnet.SubnetId,
				},
			},
			Metadata: pulumi.StringMap{
				"some_key": pulumi.String("some_value"),
				"stage":    pulumi.String("dev"),
			},
			Configurations: edgecenter.InstanceV2ConfigurationArray{
				&edgecenter.InstanceV2ConfigurationArgs{
					Key:   pulumi.String("some_key"),
					Value: pulumi.String("some_data"),
				},
			},
			RegionId:  pulumi.Float64(regionId),
			ProjectId: pulumi.Float64(projectId),
		})
		if err != nil {
			return err
		}
		_, err = edgecenter.NewInstancePortSecurity(ctx, "portSecurity", &edgecenter.InstancePortSecurityArgs{
			PortId: pulumi.String(pulumi.All(instance.Interfaces, subnet.SubnetId).ApplyT(func(_args []interface{}) (*string, error) {
				interfaces := _args[0].([]edgecenter.InstanceV2Interface)
				subnetId := _args[1].(string)
				return "TODO: For expression"[0], nil
			}).(pulumi.StringPtrOutput)),
			InstanceId:           instance.InstanceV2Id,
			RegionId:             pulumi.Float64(regionId),
			ProjectId:            pulumi.Float64(projectId),
			PortSecurityDisabled: pulumi.Bool(false),
			SecurityGroups: &edgecenter.InstancePortSecuritySecurityGroupsArgs{
				OverwriteExisting: pulumi.Bool(true),
				SecurityGroupIds: pulumi.StringArray{
					sg.SecuritygroupId,
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var config = new Config();
    var regionId = config.GetDouble("regionId") ?? 1;
    var projectId = config.GetDouble("projectId") ?? 1;
    var imageId = config.Get("imageId") ?? "f4ce3d30-e29c-4cfd-811f-46f383b6081f";
    var network = new Edgecenter.Network("network", new()
    {
        Type = "vxlan",
        RegionId = regionId,
        ProjectId = projectId,
    });

    var subnet = new Edgecenter.Subnet("subnet", new()
    {
        Cidr = "192.168.10.0/24",
        NetworkId = network.NetworkId,
        DnsNameservers = new[]
        {
            "8.8.4.4",
            "1.1.1.1",
        },
        HostRoutes = new[]
        {
            new Edgecenter.Inputs.SubnetHostRouteArgs
            {
                Destination = "10.0.3.0/24",
                Nexthop = "10.0.0.13",
            },
        },
        GatewayIp = "192.168.10.1",
        RegionId = regionId,
        ProjectId = projectId,
    });

    var firstVolume = new Edgecenter.Volume("firstVolume", new()
    {
        TypeName = "ssd_hiiops",
        Size = 5,
        RegionId = regionId,
        ProjectId = projectId,
        ImageId = imageId,
    });

    var secondVolume = new Edgecenter.Volume("secondVolume", new()
    {
        TypeName = "ssd_hiiops",
        Size = 5,
        RegionId = regionId,
        ProjectId = projectId,
    });

    var sg = new Edgecenter.Securitygroup("sg", new()
    {
        RegionId = regionId,
        ProjectId = projectId,
        SecurityGroupRules = new[]
        {
            new Edgecenter.Inputs.SecuritygroupSecurityGroupRuleArgs
            {
                Direction = "egress",
                Ethertype = "IPv4",
                Protocol = "tcp",
                PortRangeMin = 19990,
                PortRangeMax = 19990,
            },
        },
    });

    var instance = new Edgecenter.InstanceV2("instance", new()
    {
        FlavorId = "g1-standard-2-4",
        BootVolumes = new[]
        {
            new Edgecenter.Inputs.InstanceV2BootVolumeArgs
            {
                VolumeId = firstVolume.VolumeId,
                BootIndex = 0,
            },
        },
        DataVolumes = new[]
        {
            new Edgecenter.Inputs.InstanceV2DataVolumeArgs
            {
                VolumeId = secondVolume.VolumeId,
            },
        },
        Interfaces = new[]
        {
            new Edgecenter.Inputs.InstanceV2InterfaceArgs
            {
                IsDefault = true,
                Type = "subnet",
                NetworkId = network.NetworkId,
                SubnetId = subnet.SubnetId,
            },
        },
        Metadata = 
        {
            { "some_key", "some_value" },
            { "stage", "dev" },
        },
        Configurations = new[]
        {
            new Edgecenter.Inputs.InstanceV2ConfigurationArgs
            {
                Key = "some_key",
                Value = "some_data",
            },
        },
        RegionId = regionId,
        ProjectId = projectId,
    });

    var portSecurity = new Edgecenter.InstancePortSecurity("portSecurity", new()
    {
        PortId = Output.Tuple(instance.Interfaces, subnet.SubnetId).Apply(values =>
        {
            var interfaces = values.Item1;
            var subnetId = values.Item2;
            return interfaces.Where(iface => iface.SubnetId == subnetId).Select(iface => 
            {
                return iface.PortId;
            }).ToList()[0];
        }),
        InstanceId = instance.InstanceV2Id,
        RegionId = regionId,
        ProjectId = projectId,
        PortSecurityDisabled = false,
        SecurityGroups = new Edgecenter.Inputs.InstancePortSecuritySecurityGroupsArgs
        {
            OverwriteExisting = true,
            SecurityGroupIds = new[]
            {
                sg.SecuritygroupId,
            },
        },
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.edgecenter.Network;
import com.pulumi.edgecenter.NetworkArgs;
import com.pulumi.edgecenter.Subnet;
import com.pulumi.edgecenter.SubnetArgs;
import com.pulumi.edgecenter.inputs.SubnetHostRouteArgs;
import com.pulumi.edgecenter.Volume;
import com.pulumi.edgecenter.VolumeArgs;
import com.pulumi.edgecenter.Securitygroup;
import com.pulumi.edgecenter.SecuritygroupArgs;
import com.pulumi.edgecenter.inputs.SecuritygroupSecurityGroupRuleArgs;
import com.pulumi.edgecenter.InstanceV2;
import com.pulumi.edgecenter.InstanceV2Args;
import com.pulumi.edgecenter.inputs.InstanceV2BootVolumeArgs;
import com.pulumi.edgecenter.inputs.InstanceV2DataVolumeArgs;
import com.pulumi.edgecenter.inputs.InstanceV2InterfaceArgs;
import com.pulumi.edgecenter.inputs.InstanceV2ConfigurationArgs;
import com.pulumi.edgecenter.InstancePortSecurity;
import com.pulumi.edgecenter.InstancePortSecurityArgs;
import com.pulumi.edgecenter.inputs.InstancePortSecuritySecurityGroupsArgs;
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();
        final var regionId = config.get("regionId").orElse(1);
        final var projectId = config.get("projectId").orElse(1);
        final var imageId = config.get("imageId").orElse("f4ce3d30-e29c-4cfd-811f-46f383b6081f");
        var network = new Network("network", NetworkArgs.builder()
            .type("vxlan")
            .regionId(regionId)
            .projectId(projectId)
            .build());

        var subnet = new Subnet("subnet", SubnetArgs.builder()
            .cidr("192.168.10.0/24")
            .networkId(network.networkId())
            .dnsNameservers(            
                "8.8.4.4",
                "1.1.1.1")
            .hostRoutes(SubnetHostRouteArgs.builder()
                .destination("10.0.3.0/24")
                .nexthop("10.0.0.13")
                .build())
            .gatewayIp("192.168.10.1")
            .regionId(regionId)
            .projectId(projectId)
            .build());

        var firstVolume = new Volume("firstVolume", VolumeArgs.builder()
            .typeName("ssd_hiiops")
            .size(5)
            .regionId(regionId)
            .projectId(projectId)
            .imageId(imageId)
            .build());

        var secondVolume = new Volume("secondVolume", VolumeArgs.builder()
            .typeName("ssd_hiiops")
            .size(5)
            .regionId(regionId)
            .projectId(projectId)
            .build());

        var sg = new Securitygroup("sg", SecuritygroupArgs.builder()
            .regionId(regionId)
            .projectId(projectId)
            .securityGroupRules(SecuritygroupSecurityGroupRuleArgs.builder()
                .direction("egress")
                .ethertype("IPv4")
                .protocol("tcp")
                .portRangeMin(19990)
                .portRangeMax(19990)
                .build())
            .build());

        var instance = new InstanceV2("instance", InstanceV2Args.builder()
            .flavorId("g1-standard-2-4")
            .bootVolumes(InstanceV2BootVolumeArgs.builder()
                .volumeId(firstVolume.volumeId())
                .bootIndex(0)
                .build())
            .dataVolumes(InstanceV2DataVolumeArgs.builder()
                .volumeId(secondVolume.volumeId())
                .build())
            .interfaces(InstanceV2InterfaceArgs.builder()
                .isDefault(true)
                .type("subnet")
                .networkId(network.networkId())
                .subnetId(subnet.subnetId())
                .build())
            .metadata(Map.ofEntries(
                Map.entry("some_key", "some_value"),
                Map.entry("stage", "dev")
            ))
            .configurations(InstanceV2ConfigurationArgs.builder()
                .key("some_key")
                .value("some_data")
                .build())
            .regionId(regionId)
            .projectId(projectId)
            .build());

        var portSecurity = new InstancePortSecurity("portSecurity", InstancePortSecurityArgs.builder()
            .portId(Output.tuple(instance.interfaces(), subnet.subnetId()).applyValue(values -> {
                var interfaces = values.t1;
                var subnetId = values.t2;
                return "TODO: ForExpression"[0];
            }))
            .instanceId(instance.instanceV2Id())
            .regionId(regionId)
            .projectId(projectId)
            .portSecurityDisabled(false)
            .securityGroups(InstancePortSecuritySecurityGroupsArgs.builder()
                .overwriteExisting(true)
                .securityGroupIds(sg.securitygroupId())
                .build())
            .build());

    }
}

var instanceV2Resource = new Edgecenter.InstanceV2("instanceV2Resource", new()
{
    FlavorId = "string",
    BootVolumes = new[]
    {
        new Edgecenter.Inputs.InstanceV2BootVolumeArgs
        {
            BootIndex = 0,
            VolumeId = "string",
            AttachmentTag = "string",
            Name = "string",
            Size = 0,
            TypeName = "string",
        },
    },
    Interfaces = new[]
    {
        new Edgecenter.Inputs.InstanceV2InterfaceArgs
        {
            Type = "string",
            IpAddress = "string",
            IsDefault = false,
            NetworkId = "string",
            NetworkName = "string",
            PortId = "string",
            ReservedFixedIpPortId = "string",
            SubnetId = "string",
        },
    },
    NameTemplate = "string",
    ProjectId = 0,
    InstanceV2Id = "string",
    Configurations = new[]
    {
        new Edgecenter.Inputs.InstanceV2ConfigurationArgs
        {
            Key = "string",
            Value = "string",
        },
    },
    KeypairName = "string",
    Metadata = 
    {
        { "string", "string" },
    },
    Name = "string",
    AllowAppPorts = false,
    Password = "string",
    DataVolumes = new[]
    {
        new Edgecenter.Inputs.InstanceV2DataVolumeArgs
        {
            VolumeId = "string",
            AttachmentTag = "string",
            Name = "string",
            Size = 0,
            TypeName = "string",
        },
    },
    ProjectName = "string",
    RegionId = 0,
    RegionName = "string",
    ServerGroup = "string",
    Status = "string",
    UserData = "string",
    Username = "string",
    VmState = "string",
});

example, err := edgecenter.NewInstanceV2(ctx, "instanceV2Resource", &edgecenter.InstanceV2Args{
	FlavorId: pulumi.String("string"),
	BootVolumes: edgecenter.InstanceV2BootVolumeArray{
		&edgecenter.InstanceV2BootVolumeArgs{
			BootIndex:     pulumi.Float64(0),
			VolumeId:      pulumi.String("string"),
			AttachmentTag: pulumi.String("string"),
			Name:          pulumi.String("string"),
			Size:          pulumi.Float64(0),
			TypeName:      pulumi.String("string"),
		},
	},
	Interfaces: edgecenter.InstanceV2InterfaceArray{
		&edgecenter.InstanceV2InterfaceArgs{
			Type:                  pulumi.String("string"),
			IpAddress:             pulumi.String("string"),
			IsDefault:             pulumi.Bool(false),
			NetworkId:             pulumi.String("string"),
			NetworkName:           pulumi.String("string"),
			PortId:                pulumi.String("string"),
			ReservedFixedIpPortId: pulumi.String("string"),
			SubnetId:              pulumi.String("string"),
		},
	},
	NameTemplate: pulumi.String("string"),
	ProjectId:    pulumi.Float64(0),
	InstanceV2Id: pulumi.String("string"),
	Configurations: edgecenter.InstanceV2ConfigurationArray{
		&edgecenter.InstanceV2ConfigurationArgs{
			Key:   pulumi.String("string"),
			Value: pulumi.String("string"),
		},
	},
	KeypairName: pulumi.String("string"),
	Metadata: pulumi.StringMap{
		"string": pulumi.String("string"),
	},
	Name:          pulumi.String("string"),
	AllowAppPorts: pulumi.Bool(false),
	Password:      pulumi.String("string"),
	DataVolumes: edgecenter.InstanceV2DataVolumeArray{
		&edgecenter.InstanceV2DataVolumeArgs{
			VolumeId:      pulumi.String("string"),
			AttachmentTag: pulumi.String("string"),
			Name:          pulumi.String("string"),
			Size:          pulumi.Float64(0),
			TypeName:      pulumi.String("string"),
		},
	},
	ProjectName: pulumi.String("string"),
	RegionId:    pulumi.Float64(0),
	RegionName:  pulumi.String("string"),
	ServerGroup: pulumi.String("string"),
	Status:      pulumi.String("string"),
	UserData:    pulumi.String("string"),
	Username:    pulumi.String("string"),
	VmState:     pulumi.String("string"),
})

var instanceV2Resource = new InstanceV2("instanceV2Resource", InstanceV2Args.builder()
    .flavorId("string")
    .bootVolumes(InstanceV2BootVolumeArgs.builder()
        .bootIndex(0)
        .volumeId("string")
        .attachmentTag("string")
        .name("string")
        .size(0)
        .typeName("string")
        .build())
    .interfaces(InstanceV2InterfaceArgs.builder()
        .type("string")
        .ipAddress("string")
        .isDefault(false)
        .networkId("string")
        .networkName("string")
        .portId("string")
        .reservedFixedIpPortId("string")
        .subnetId("string")
        .build())
    .nameTemplate("string")
    .projectId(0)
    .instanceV2Id("string")
    .configurations(InstanceV2ConfigurationArgs.builder()
        .key("string")
        .value("string")
        .build())
    .keypairName("string")
    .metadata(Map.of("string", "string"))
    .name("string")
    .allowAppPorts(false)
    .password("string")
    .dataVolumes(InstanceV2DataVolumeArgs.builder()
        .volumeId("string")
        .attachmentTag("string")
        .name("string")
        .size(0)
        .typeName("string")
        .build())
    .projectName("string")
    .regionId(0)
    .regionName("string")
    .serverGroup("string")
    .status("string")
    .userData("string")
    .username("string")
    .vmState("string")
    .build());

instance_v2_resource = edgecenter.InstanceV2("instanceV2Resource",
    flavor_id="string",
    boot_volumes=[{
        "boot_index": 0,
        "volume_id": "string",
        "attachment_tag": "string",
        "name": "string",
        "size": 0,
        "type_name": "string",
    }],
    interfaces=[{
        "type": "string",
        "ip_address": "string",
        "is_default": False,
        "network_id": "string",
        "network_name": "string",
        "port_id": "string",
        "reserved_fixed_ip_port_id": "string",
        "subnet_id": "string",
    }],
    name_template="string",
    project_id=0,
    instance_v2_id="string",
    configurations=[{
        "key": "string",
        "value": "string",
    }],
    keypair_name="string",
    metadata={
        "string": "string",
    },
    name="string",
    allow_app_ports=False,
    password="string",
    data_volumes=[{
        "volume_id": "string",
        "attachment_tag": "string",
        "name": "string",
        "size": 0,
        "type_name": "string",
    }],
    project_name="string",
    region_id=0,
    region_name="string",
    server_group="string",
    status="string",
    user_data="string",
    username="string",
    vm_state="string")

const instanceV2Resource = new edgecenter.InstanceV2("instanceV2Resource", {
    flavorId: "string",
    bootVolumes: [{
        bootIndex: 0,
        volumeId: "string",
        attachmentTag: "string",
        name: "string",
        size: 0,
        typeName: "string",
    }],
    interfaces: [{
        type: "string",
        ipAddress: "string",
        isDefault: false,
        networkId: "string",
        networkName: "string",
        portId: "string",
        reservedFixedIpPortId: "string",
        subnetId: "string",
    }],
    nameTemplate: "string",
    projectId: 0,
    instanceV2Id: "string",
    configurations: [{
        key: "string",
        value: "string",
    }],
    keypairName: "string",
    metadata: {
        string: "string",
    },
    name: "string",
    allowAppPorts: false,
    password: "string",
    dataVolumes: [{
        volumeId: "string",
        attachmentTag: "string",
        name: "string",
        size: 0,
        typeName: "string",
    }],
    projectName: "string",
    regionId: 0,
    regionName: "string",
    serverGroup: "string",
    status: "string",
    userData: "string",
    username: "string",
    vmState: "string",
});

type: edgecenter:InstanceV2
properties:
    allowAppPorts: false
    bootVolumes:
        - attachmentTag: string
          bootIndex: 0
          name: string
          size: 0
          typeName: string
          volumeId: string
    configurations:
        - key: string
          value: string
    dataVolumes:
        - attachmentTag: string
          name: string
          size: 0
          typeName: string
          volumeId: string
    flavorId: string
    instanceV2Id: string
    interfaces:
        - ipAddress: string
          isDefault: false
          networkId: string
          networkName: string
          portId: string
          reservedFixedIpPortId: string
          subnetId: string
          type: string
    keypairName: string
    metadata:
        string: string
    name: string
    nameTemplate: string
    password: string
    projectId: 0
    projectName: string
    regionId: 0
    regionName: string
    serverGroup: string
    status: string
    userData: string
    username: string
    vmState: string