ionoscloud.compute.VCPUServer

import * as pulumi from "@pulumi/pulumi";
import * as ionoscloud from "@ionos-cloud/sdk-pulumi";
import * as ionoscloud from "@pulumi/ionoscloud";
import * as random from "@pulumi/random";

const example = ionoscloud.compute.getImage({
    type: "HDD",
    imageAlias: "ubuntu:latest",
    location: "us/las",
});
const exampleDatacenter = new ionoscloud.compute.Datacenter("example", {
    name: "Datacenter Example",
    location: "de/txl",
    description: "Datacenter Description",
    secAuthProtection: false,
});
const exampleLan = new ionoscloud.compute.Lan("example", {
    datacenterId: exampleDatacenter.id,
    "public": true,
    name: "Lan Example",
});
const exampleIPBlock = new ionoscloud.compute.IPBlock("example", {
    location: exampleDatacenter.location,
    size: 4,
    name: "IP Block Example",
});
const serverImagePassword = new random.index.Password("server_image_password", {
    length: 16,
    special: false,
});
const exampleVCPUServer = new ionoscloud.compute.VCPUServer("example", {
    name: "VCPU Server Example",
    datacenterId: exampleDatacenter.id,
    cores: 1,
    ram: 1024,
    availabilityZone: "ZONE_1",
    imageName: example.then(example => example.id),
    imagePassword: serverImagePassword.result,
    volume: {
        name: "system",
        size: 5,
        diskType: "SSD Standard",
        userData: "foo",
        bus: "VIRTIO",
        availabilityZone: "ZONE_1",
    },
    nic: {
        lan: exampleLan.id,
        name: "system",
        dhcp: true,
        firewallActive: true,
        firewallType: "BIDIRECTIONAL",
        ips: [
            exampleIPBlock.ips[0],
            exampleIPBlock.ips[1],
        ],
        firewalls: [{
            protocol: "TCP",
            name: "SSH",
            portRangeStart: 22,
            portRangeEnd: 22,
            sourceMac: "00:0a:95:9d:68:17",
            sourceIp: exampleIPBlock.ips[2],
            targetIp: exampleIPBlock.ips[3],
            type: "EGRESS",
        }],
    },
    labels: [
        {
            key: "labelkey1",
            value: "labelvalue1",
        },
        {
            key: "labelkey2",
            value: "labelvalue2",
        },
    ],
});

import pulumi
import pulumi_ionoscloud as ionoscloud
import pulumi_random as random

example = ionoscloud.compute.get_image(type="HDD",
    image_alias="ubuntu:latest",
    location="us/las")
example_datacenter = ionoscloud.compute.Datacenter("example",
    name="Datacenter Example",
    location="de/txl",
    description="Datacenter Description",
    sec_auth_protection=False)
example_lan = ionoscloud.compute.Lan("example",
    datacenter_id=example_datacenter.id,
    public=True,
    name="Lan Example")
example_ip_block = ionoscloud.compute.IPBlock("example",
    location=example_datacenter.location,
    size=4,
    name="IP Block Example")
server_image_password = random.index.Password("server_image_password",
    length=16,
    special=False)
example_vcpu_server = ionoscloud.compute.VCPUServer("example",
    name="VCPU Server Example",
    datacenter_id=example_datacenter.id,
    cores=1,
    ram=1024,
    availability_zone="ZONE_1",
    image_name=example.id,
    image_password=server_image_password["result"],
    volume={
        "name": "system",
        "size": 5,
        "disk_type": "SSD Standard",
        "user_data": "foo",
        "bus": "VIRTIO",
        "availability_zone": "ZONE_1",
    },
    nic={
        "lan": example_lan.id,
        "name": "system",
        "dhcp": True,
        "firewall_active": True,
        "firewall_type": "BIDIRECTIONAL",
        "ips": [
            example_ip_block.ips[0],
            example_ip_block.ips[1],
        ],
        "firewalls": [{
            "protocol": "TCP",
            "name": "SSH",
            "port_range_start": 22,
            "port_range_end": 22,
            "source_mac": "00:0a:95:9d:68:17",
            "source_ip": example_ip_block.ips[2],
            "target_ip": example_ip_block.ips[3],
            "type": "EGRESS",
        }],
    },
    labels=[
        {
            "key": "labelkey1",
            "value": "labelvalue1",
        },
        {
            "key": "labelkey2",
            "value": "labelvalue2",
        },
    ])

package main

import (
	"github.com/ionos-cloud/pulumi-ionoscloud/sdk/go/ionoscloud/compute"
	"github.com/pulumi/pulumi-random/sdk/go/random"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		example, err := compute.GetImage(ctx, &compute.GetImageArgs{
			Type:       pulumi.StringRef("HDD"),
			ImageAlias: pulumi.StringRef("ubuntu:latest"),
			Location:   pulumi.StringRef("us/las"),
		}, nil)
		if err != nil {
			return err
		}
		exampleDatacenter, err := compute.NewDatacenter(ctx, "example", &compute.DatacenterArgs{
			Name:              pulumi.String("Datacenter Example"),
			Location:          pulumi.String("de/txl"),
			Description:       pulumi.String("Datacenter Description"),
			SecAuthProtection: pulumi.Bool(false),
		})
		if err != nil {
			return err
		}
		exampleLan, err := compute.NewLan(ctx, "example", &compute.LanArgs{
			DatacenterId: exampleDatacenter.ID(),
			Public:       pulumi.Bool(true),
			Name:         pulumi.String("Lan Example"),
		})
		if err != nil {
			return err
		}
		exampleIPBlock, err := compute.NewIPBlock(ctx, "example", &compute.IPBlockArgs{
			Location: exampleDatacenter.Location,
			Size:     pulumi.Int(4),
			Name:     pulumi.String("IP Block Example"),
		})
		if err != nil {
			return err
		}
		serverImagePassword, err := random.NewPassword(ctx, "server_image_password", &random.PasswordArgs{
			Length:  16,
			Special: false,
		})
		if err != nil {
			return err
		}
		_, err = compute.NewVCPUServer(ctx, "example", &compute.VCPUServerArgs{
			Name:             pulumi.String("VCPU Server Example"),
			DatacenterId:     exampleDatacenter.ID(),
			Cores:            pulumi.Int(1),
			Ram:              pulumi.Int(1024),
			AvailabilityZone: pulumi.String("ZONE_1"),
			ImageName:        pulumi.String(example.Id),
			ImagePassword:    serverImagePassword.Result,
			Volume: &compute.VCPUServerVolumeArgs{
				Name:             pulumi.String("system"),
				Size:             pulumi.Int(5),
				DiskType:         pulumi.String("SSD Standard"),
				UserData:         pulumi.String("foo"),
				Bus:              pulumi.String("VIRTIO"),
				AvailabilityZone: pulumi.String("ZONE_1"),
			},
			Nic: &compute.VCPUServerNicArgs{
				Lan:            exampleLan.ID(),
				Name:           pulumi.String("system"),
				Dhcp:           pulumi.Bool(true),
				FirewallActive: pulumi.Bool(true),
				FirewallType:   pulumi.String("BIDIRECTIONAL"),
				Ips: pulumi.StringArray{
					exampleIPBlock.Ips.ApplyT(func(ips []string) (string, error) {
						return ips[0], nil
					}).(pulumi.StringOutput),
					exampleIPBlock.Ips.ApplyT(func(ips []string) (string, error) {
						return ips[1], nil
					}).(pulumi.StringOutput),
				},
				Firewalls: compute.VCPUServerNicFirewallArray{
					&compute.VCPUServerNicFirewallArgs{
						Protocol:       pulumi.String("TCP"),
						Name:           pulumi.String("SSH"),
						PortRangeStart: pulumi.Int(22),
						PortRangeEnd:   pulumi.Int(22),
						SourceMac:      pulumi.String("00:0a:95:9d:68:17"),
						SourceIp: exampleIPBlock.Ips.ApplyT(func(ips []string) (string, error) {
							return ips[2], nil
						}).(pulumi.StringOutput),
						TargetIp: exampleIPBlock.Ips.ApplyT(func(ips []string) (string, error) {
							return ips[3], nil
						}).(pulumi.StringOutput),
						Type: pulumi.String("EGRESS"),
					},
				},
			},
			Labels: compute.VCPUServerLabelArray{
				&compute.VCPUServerLabelArgs{
					Key:   pulumi.String("labelkey1"),
					Value: pulumi.String("labelvalue1"),
				},
				&compute.VCPUServerLabelArgs{
					Key:   pulumi.String("labelkey2"),
					Value: pulumi.String("labelvalue2"),
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Ionoscloud = Ionoscloud.Pulumi.Ionoscloud;
using Ionoscloud = Pulumi.Ionoscloud;
using Random = Pulumi.Random;

return await Deployment.RunAsync(() => 
{
    var example = Ionoscloud.Compute.GetImage.Invoke(new()
    {
        Type = "HDD",
        ImageAlias = "ubuntu:latest",
        Location = "us/las",
    });

    var exampleDatacenter = new Ionoscloud.Compute.Datacenter("example", new()
    {
        Name = "Datacenter Example",
        Location = "de/txl",
        Description = "Datacenter Description",
        SecAuthProtection = false,
    });

    var exampleLan = new Ionoscloud.Compute.Lan("example", new()
    {
        DatacenterId = exampleDatacenter.Id,
        Public = true,
        Name = "Lan Example",
    });

    var exampleIPBlock = new Ionoscloud.Compute.IPBlock("example", new()
    {
        Location = exampleDatacenter.Location,
        Size = 4,
        Name = "IP Block Example",
    });

    var serverImagePassword = new Random.Index.Password("server_image_password", new()
    {
        Length = 16,
        Special = false,
    });

    var exampleVCPUServer = new Ionoscloud.Compute.VCPUServer("example", new()
    {
        Name = "VCPU Server Example",
        DatacenterId = exampleDatacenter.Id,
        Cores = 1,
        Ram = 1024,
        AvailabilityZone = "ZONE_1",
        ImageName = example.Apply(getImageResult => getImageResult.Id),
        ImagePassword = serverImagePassword.Result,
        Volume = new Ionoscloud.Compute.Inputs.VCPUServerVolumeArgs
        {
            Name = "system",
            Size = 5,
            DiskType = "SSD Standard",
            UserData = "foo",
            Bus = "VIRTIO",
            AvailabilityZone = "ZONE_1",
        },
        Nic = new Ionoscloud.Compute.Inputs.VCPUServerNicArgs
        {
            Lan = exampleLan.Id,
            Name = "system",
            Dhcp = true,
            FirewallActive = true,
            FirewallType = "BIDIRECTIONAL",
            Ips = new[]
            {
                exampleIPBlock.Ips.Apply(ips => ips[0]),
                exampleIPBlock.Ips.Apply(ips => ips[1]),
            },
            Firewalls = new[]
            {
                new Ionoscloud.Compute.Inputs.VCPUServerNicFirewallArgs
                {
                    Protocol = "TCP",
                    Name = "SSH",
                    PortRangeStart = 22,
                    PortRangeEnd = 22,
                    SourceMac = "00:0a:95:9d:68:17",
                    SourceIp = exampleIPBlock.Ips.Apply(ips => ips[2]),
                    TargetIp = exampleIPBlock.Ips.Apply(ips => ips[3]),
                    Type = "EGRESS",
                },
            },
        },
        Labels = new[]
        {
            new Ionoscloud.Compute.Inputs.VCPUServerLabelArgs
            {
                Key = "labelkey1",
                Value = "labelvalue1",
            },
            new Ionoscloud.Compute.Inputs.VCPUServerLabelArgs
            {
                Key = "labelkey2",
                Value = "labelvalue2",
            },
        },
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.ionoscloud.compute.ComputeFunctions;
import com.pulumi.ionoscloud.compute.inputs.GetImageArgs;
import com.pulumi.ionoscloud.compute.Datacenter;
import com.pulumi.ionoscloud.compute.DatacenterArgs;
import com.pulumi.ionoscloud.compute.Lan;
import com.pulumi.ionoscloud.compute.LanArgs;
import com.pulumi.ionoscloud.compute.IPBlock;
import com.pulumi.ionoscloud.compute.IPBlockArgs;
import com.pulumi.random.password;
import com.pulumi.random.PasswordArgs;
import com.pulumi.ionoscloud.compute.VCPUServer;
import com.pulumi.ionoscloud.compute.VCPUServerArgs;
import com.pulumi.ionoscloud.compute.inputs.VCPUServerVolumeArgs;
import com.pulumi.ionoscloud.compute.inputs.VCPUServerNicArgs;
import com.pulumi.ionoscloud.compute.inputs.VCPUServerLabelArgs;
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 example = ComputeFunctions.getImage(GetImageArgs.builder()
            .type("HDD")
            .imageAlias("ubuntu:latest")
            .location("us/las")
            .build());

        var exampleDatacenter = new Datacenter("exampleDatacenter", DatacenterArgs.builder()
            .name("Datacenter Example")
            .location("de/txl")
            .description("Datacenter Description")
            .secAuthProtection(false)
            .build());

        var exampleLan = new Lan("exampleLan", LanArgs.builder()
            .datacenterId(exampleDatacenter.id())
            .public_(true)
            .name("Lan Example")
            .build());

        var exampleIPBlock = new IPBlock("exampleIPBlock", IPBlockArgs.builder()
            .location(exampleDatacenter.location())
            .size(4)
            .name("IP Block Example")
            .build());

        var serverImagePassword = new Password("serverImagePassword", PasswordArgs.builder()
            .length(16)
            .special(false)
            .build());

        var exampleVCPUServer = new VCPUServer("exampleVCPUServer", VCPUServerArgs.builder()
            .name("VCPU Server Example")
            .datacenterId(exampleDatacenter.id())
            .cores(1)
            .ram(1024)
            .availabilityZone("ZONE_1")
            .imageName(example.applyValue(getImageResult -> getImageResult.id()))
            .imagePassword(serverImagePassword.result())
            .volume(VCPUServerVolumeArgs.builder()
                .name("system")
                .size(5)
                .diskType("SSD Standard")
                .userData("foo")
                .bus("VIRTIO")
                .availabilityZone("ZONE_1")
                .build())
            .nic(VCPUServerNicArgs.builder()
                .lan(exampleLan.id())
                .name("system")
                .dhcp(true)
                .firewallActive(true)
                .firewallType("BIDIRECTIONAL")
                .ips(                
                    exampleIPBlock.ips().applyValue(ips -> ips[0]),
                    exampleIPBlock.ips().applyValue(ips -> ips[1]))
                .firewalls(VCPUServerNicFirewallArgs.builder()
                    .protocol("TCP")
                    .name("SSH")
                    .portRangeStart(22)
                    .portRangeEnd(22)
                    .sourceMac("00:0a:95:9d:68:17")
                    .sourceIp(exampleIPBlock.ips().applyValue(ips -> ips[2]))
                    .targetIp(exampleIPBlock.ips().applyValue(ips -> ips[3]))
                    .type("EGRESS")
                    .build())
                .build())
            .labels(            
                VCPUServerLabelArgs.builder()
                    .key("labelkey1")
                    .value("labelvalue1")
                    .build(),
                VCPUServerLabelArgs.builder()
                    .key("labelkey2")
                    .value("labelvalue2")
                    .build())
            .build());

    }
}

resources:
  exampleDatacenter:
    type: ionoscloud:compute:Datacenter
    name: example
    properties:
      name: Datacenter Example
      location: de/txl
      description: Datacenter Description
      secAuthProtection: false
  exampleLan:
    type: ionoscloud:compute:Lan
    name: example
    properties:
      datacenterId: ${exampleDatacenter.id}
      public: true
      name: Lan Example
  exampleIPBlock:
    type: ionoscloud:compute:IPBlock
    name: example
    properties:
      location: ${exampleDatacenter.location}
      size: 4
      name: IP Block Example
  exampleVCPUServer:
    type: ionoscloud:compute:VCPUServer
    name: example
    properties:
      name: VCPU Server Example
      datacenterId: ${exampleDatacenter.id}
      cores: 1
      ram: 1024
      availabilityZone: ZONE_1
      imageName: ${example.id}
      imagePassword: ${serverImagePassword.result}
      volume:
        name: system
        size: 5
        diskType: SSD Standard
        userData: foo
        bus: VIRTIO
        availabilityZone: ZONE_1
      nic:
        lan: ${exampleLan.id}
        name: system
        dhcp: true
        firewallActive: true
        firewallType: BIDIRECTIONAL
        ips:
          - ${exampleIPBlock.ips[0]}
          - ${exampleIPBlock.ips[1]}
        firewalls:
          - protocol: TCP
            name: SSH
            portRangeStart: 22
            portRangeEnd: 22
            sourceMac: 00:0a:95:9d:68:17
            sourceIp: ${exampleIPBlock.ips[2]}
            targetIp: ${exampleIPBlock.ips[3]}
            type: EGRESS
      labels:
        - key: labelkey1
          value: labelvalue1
        - key: labelkey2
          value: labelvalue2
  serverImagePassword:
    type: random:password
    name: server_image_password
    properties:
      length: 16
      special: false
variables:
  example:
    fn::invoke:
      function: ionoscloud:compute:getImage
      arguments:
        type: HDD
        imageAlias: ubuntu:latest
        location: us/las

var vcpuserverResource = new Ionoscloud.Compute.VCPUServer("vcpuserverResource", new()
{
    Ram = 0,
    DatacenterId = "string",
    Volume = new Ionoscloud.Compute.Inputs.VCPUServerVolumeArgs
    {
        DiskType = "string",
        CpuHotPlug = false,
        Name = "string",
        Bus = "string",
        AvailabilityZone = "string",
        DeviceNumber = 0,
        DiscVirtioHotPlug = false,
        BootServer = "string",
        DiscVirtioHotUnplug = false,
        LicenceType = "string",
        BackupUnitId = "string",
        NicHotPlug = false,
        NicHotUnplug = false,
        PciSlot = 0,
        RamHotPlug = false,
        Size = 0,
        UserData = "string",
    },
    Cores = 0,
    Labels = new[]
    {
        new Ionoscloud.Compute.Inputs.VCPUServerLabelArgs
        {
            Key = "string",
            Value = "string",
        },
    },
    FirewallruleIds = new[]
    {
        "string",
    },
    Hostname = "string",
    ImageName = "string",
    Name = "string",
    ImagePassword = "string",
    Nic = new Ionoscloud.Compute.Inputs.VCPUServerNicArgs
    {
        Lan = 0,
        Id = "string",
        Ipv6CidrBlock = "string",
        FirewallActive = false,
        FirewallType = "string",
        Firewalls = new[]
        {
            new Ionoscloud.Compute.Inputs.VCPUServerNicFirewallArgs
            {
                Protocol = "string",
                IcmpCode = "string",
                IcmpType = "string",
                Id = "string",
                Name = "string",
                PortRangeEnd = 0,
                PortRangeStart = 0,
                SourceIp = "string",
                SourceMac = "string",
                TargetIp = "string",
                Type = "string",
            },
        },
        DeviceNumber = 0,
        Ips = new[]
        {
            "string",
        },
        Dhcpv6 = false,
        Ipv6Ips = new[]
        {
            "string",
        },
        Dhcp = false,
        Mac = "string",
        Name = "string",
        PciSlot = 0,
        SecurityGroupsIds = new[]
        {
            "string",
        },
    },
    AvailabilityZone = "string",
    SecurityGroupsIds = new[]
    {
        "string",
    },
    SshKeys = new[]
    {
        "string",
    },
    VmState = "string",
    BootImage = "string",
});

example, err := compute.NewVCPUServer(ctx, "vcpuserverResource", &compute.VCPUServerArgs{
	Ram:          pulumi.Int(0),
	DatacenterId: pulumi.String("string"),
	Volume: &compute.VCPUServerVolumeArgs{
		DiskType:            pulumi.String("string"),
		CpuHotPlug:          pulumi.Bool(false),
		Name:                pulumi.String("string"),
		Bus:                 pulumi.String("string"),
		AvailabilityZone:    pulumi.String("string"),
		DeviceNumber:        pulumi.Int(0),
		DiscVirtioHotPlug:   pulumi.Bool(false),
		BootServer:          pulumi.String("string"),
		DiscVirtioHotUnplug: pulumi.Bool(false),
		LicenceType:         pulumi.String("string"),
		BackupUnitId:        pulumi.String("string"),
		NicHotPlug:          pulumi.Bool(false),
		NicHotUnplug:        pulumi.Bool(false),
		PciSlot:             pulumi.Int(0),
		RamHotPlug:          pulumi.Bool(false),
		Size:                pulumi.Int(0),
		UserData:            pulumi.String("string"),
	},
	Cores: pulumi.Int(0),
	Labels: compute.VCPUServerLabelArray{
		&compute.VCPUServerLabelArgs{
			Key:   pulumi.String("string"),
			Value: pulumi.String("string"),
		},
	},
	FirewallruleIds: pulumi.StringArray{
		pulumi.String("string"),
	},
	Hostname:      pulumi.String("string"),
	ImageName:     pulumi.String("string"),
	Name:          pulumi.String("string"),
	ImagePassword: pulumi.String("string"),
	Nic: &compute.VCPUServerNicArgs{
		Lan:            pulumi.Int(0),
		Id:             pulumi.String("string"),
		Ipv6CidrBlock:  pulumi.String("string"),
		FirewallActive: pulumi.Bool(false),
		FirewallType:   pulumi.String("string"),
		Firewalls: compute.VCPUServerNicFirewallArray{
			&compute.VCPUServerNicFirewallArgs{
				Protocol:       pulumi.String("string"),
				IcmpCode:       pulumi.String("string"),
				IcmpType:       pulumi.String("string"),
				Id:             pulumi.String("string"),
				Name:           pulumi.String("string"),
				PortRangeEnd:   pulumi.Int(0),
				PortRangeStart: pulumi.Int(0),
				SourceIp:       pulumi.String("string"),
				SourceMac:      pulumi.String("string"),
				TargetIp:       pulumi.String("string"),
				Type:           pulumi.String("string"),
			},
		},
		DeviceNumber: pulumi.Int(0),
		Ips: pulumi.StringArray{
			pulumi.String("string"),
		},
		Dhcpv6: pulumi.Bool(false),
		Ipv6Ips: pulumi.StringArray{
			pulumi.String("string"),
		},
		Dhcp:    pulumi.Bool(false),
		Mac:     pulumi.String("string"),
		Name:    pulumi.String("string"),
		PciSlot: pulumi.Int(0),
		SecurityGroupsIds: pulumi.StringArray{
			pulumi.String("string"),
		},
	},
	AvailabilityZone: pulumi.String("string"),
	SecurityGroupsIds: pulumi.StringArray{
		pulumi.String("string"),
	},
	SshKeys: pulumi.StringArray{
		pulumi.String("string"),
	},
	VmState:   pulumi.String("string"),
	BootImage: pulumi.String("string"),
})

var vcpuserverResource = new VCPUServer("vcpuserverResource", VCPUServerArgs.builder()
    .ram(0)
    .datacenterId("string")
    .volume(VCPUServerVolumeArgs.builder()
        .diskType("string")
        .cpuHotPlug(false)
        .name("string")
        .bus("string")
        .availabilityZone("string")
        .deviceNumber(0)
        .discVirtioHotPlug(false)
        .bootServer("string")
        .discVirtioHotUnplug(false)
        .licenceType("string")
        .backupUnitId("string")
        .nicHotPlug(false)
        .nicHotUnplug(false)
        .pciSlot(0)
        .ramHotPlug(false)
        .size(0)
        .userData("string")
        .build())
    .cores(0)
    .labels(VCPUServerLabelArgs.builder()
        .key("string")
        .value("string")
        .build())
    .firewallruleIds("string")
    .hostname("string")
    .imageName("string")
    .name("string")
    .imagePassword("string")
    .nic(VCPUServerNicArgs.builder()
        .lan(0)
        .id("string")
        .ipv6CidrBlock("string")
        .firewallActive(false)
        .firewallType("string")
        .firewalls(VCPUServerNicFirewallArgs.builder()
            .protocol("string")
            .icmpCode("string")
            .icmpType("string")
            .id("string")
            .name("string")
            .portRangeEnd(0)
            .portRangeStart(0)
            .sourceIp("string")
            .sourceMac("string")
            .targetIp("string")
            .type("string")
            .build())
        .deviceNumber(0)
        .ips("string")
        .dhcpv6(false)
        .ipv6Ips("string")
        .dhcp(false)
        .mac("string")
        .name("string")
        .pciSlot(0)
        .securityGroupsIds("string")
        .build())
    .availabilityZone("string")
    .securityGroupsIds("string")
    .sshKeys("string")
    .vmState("string")
    .bootImage("string")
    .build());

vcpuserver_resource = ionoscloud.compute.VCPUServer("vcpuserverResource",
    ram=0,
    datacenter_id="string",
    volume={
        "disk_type": "string",
        "cpu_hot_plug": False,
        "name": "string",
        "bus": "string",
        "availability_zone": "string",
        "device_number": 0,
        "disc_virtio_hot_plug": False,
        "boot_server": "string",
        "disc_virtio_hot_unplug": False,
        "licence_type": "string",
        "backup_unit_id": "string",
        "nic_hot_plug": False,
        "nic_hot_unplug": False,
        "pci_slot": 0,
        "ram_hot_plug": False,
        "size": 0,
        "user_data": "string",
    },
    cores=0,
    labels=[{
        "key": "string",
        "value": "string",
    }],
    firewallrule_ids=["string"],
    hostname="string",
    image_name="string",
    name="string",
    image_password="string",
    nic={
        "lan": 0,
        "id": "string",
        "ipv6_cidr_block": "string",
        "firewall_active": False,
        "firewall_type": "string",
        "firewalls": [{
            "protocol": "string",
            "icmp_code": "string",
            "icmp_type": "string",
            "id": "string",
            "name": "string",
            "port_range_end": 0,
            "port_range_start": 0,
            "source_ip": "string",
            "source_mac": "string",
            "target_ip": "string",
            "type": "string",
        }],
        "device_number": 0,
        "ips": ["string"],
        "dhcpv6": False,
        "ipv6_ips": ["string"],
        "dhcp": False,
        "mac": "string",
        "name": "string",
        "pci_slot": 0,
        "security_groups_ids": ["string"],
    },
    availability_zone="string",
    security_groups_ids=["string"],
    ssh_keys=["string"],
    vm_state="string",
    boot_image="string")

const vcpuserverResource = new ionoscloud.compute.VCPUServer("vcpuserverResource", {
    ram: 0,
    datacenterId: "string",
    volume: {
        diskType: "string",
        cpuHotPlug: false,
        name: "string",
        bus: "string",
        availabilityZone: "string",
        deviceNumber: 0,
        discVirtioHotPlug: false,
        bootServer: "string",
        discVirtioHotUnplug: false,
        licenceType: "string",
        backupUnitId: "string",
        nicHotPlug: false,
        nicHotUnplug: false,
        pciSlot: 0,
        ramHotPlug: false,
        size: 0,
        userData: "string",
    },
    cores: 0,
    labels: [{
        key: "string",
        value: "string",
    }],
    firewallruleIds: ["string"],
    hostname: "string",
    imageName: "string",
    name: "string",
    imagePassword: "string",
    nic: {
        lan: 0,
        id: "string",
        ipv6CidrBlock: "string",
        firewallActive: false,
        firewallType: "string",
        firewalls: [{
            protocol: "string",
            icmpCode: "string",
            icmpType: "string",
            id: "string",
            name: "string",
            portRangeEnd: 0,
            portRangeStart: 0,
            sourceIp: "string",
            sourceMac: "string",
            targetIp: "string",
            type: "string",
        }],
        deviceNumber: 0,
        ips: ["string"],
        dhcpv6: false,
        ipv6Ips: ["string"],
        dhcp: false,
        mac: "string",
        name: "string",
        pciSlot: 0,
        securityGroupsIds: ["string"],
    },
    availabilityZone: "string",
    securityGroupsIds: ["string"],
    sshKeys: ["string"],
    vmState: "string",
    bootImage: "string",
});

type: ionoscloud:compute:VCPUServer
properties:
    availabilityZone: string
    bootImage: string
    cores: 0
    datacenterId: string
    firewallruleIds:
        - string
    hostname: string
    imageName: string
    imagePassword: string
    labels:
        - key: string
          value: string
    name: string
    nic:
        deviceNumber: 0
        dhcp: false
        dhcpv6: false
        firewallActive: false
        firewallType: string
        firewalls:
            - icmpCode: string
              icmpType: string
              id: string
              name: string
              portRangeEnd: 0
              portRangeStart: 0
              protocol: string
              sourceIp: string
              sourceMac: string
              targetIp: string
              type: string
        id: string
        ips:
            - string
        ipv6CidrBlock: string
        ipv6Ips:
            - string
        lan: 0
        mac: string
        name: string
        pciSlot: 0
        securityGroupsIds:
            - string
    ram: 0
    securityGroupsIds:
        - string
    sshKeys:
        - string
    vmState: string
    volume:
        availabilityZone: string
        backupUnitId: string
        bootServer: string
        bus: string
        cpuHotPlug: false
        deviceNumber: 0
        discVirtioHotPlug: false
        discVirtioHotUnplug: false
        diskType: string
        licenceType: string
        name: string
        nicHotPlug: false
        nicHotUnplug: false
        pciSlot: 0
        ramHotPlug: false
        size: 0
        userData: string