volcengine.veenedge.CloudServer

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

return await Deployment.RunAsync(() => 
{
    var foo = new Volcengine.Veenedge.CloudServer("foo", new()
    {
        BillingConfig = new Volcengine.Veenedge.Inputs.CloudServerBillingConfigArgs
        {
            BandwidthBillingMethod = "MonthlyP95",
            ComputingBillingMethod = "MonthlyPeak",
        },
        CloudserverName = "tf-test",
        DefaultAreaName = "C******na",
        DefaultIsp = "CMCC",
        ImageId = "image*****viqm",
        NetworkConfig = new Volcengine.Veenedge.Inputs.CloudServerNetworkConfigArgs
        {
            BandwidthPeak = "5",
        },
        ScheduleStrategy = new Volcengine.Veenedge.Inputs.CloudServerScheduleStrategyArgs
        {
            NetworkStrategy = "region",
            PriceStrategy = "high_priority",
            ScheduleStrategy = "dispersion",
        },
        SecretData = "sshkey-47*****wgc",
        SecretType = "KeyPair",
        ServerAreaLevel = "region",
        SpecName = "veEN****rge",
        StorageConfig = new Volcengine.Veenedge.Inputs.CloudServerStorageConfigArgs
        {
            DataDiskLists = new[]
            {
                new Volcengine.Veenedge.Inputs.CloudServerStorageConfigDataDiskListArgs
                {
                    Capacity = "20",
                    StorageType = "CloudBlockSSD",
                },
            },
            SystemDisk = new Volcengine.Veenedge.Inputs.CloudServerStorageConfigSystemDiskArgs
            {
                Capacity = "40",
                StorageType = "CloudBlockSSD",
            },
        },
    });

});

package main

import (
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
	"github.com/volcengine/pulumi-volcengine/sdk/go/volcengine/veenedge"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := veenedge.NewCloudServer(ctx, "foo", &veenedge.CloudServerArgs{
			BillingConfig: &veenedge.CloudServerBillingConfigArgs{
				BandwidthBillingMethod: pulumi.String("MonthlyP95"),
				ComputingBillingMethod: pulumi.String("MonthlyPeak"),
			},
			CloudserverName: pulumi.String("tf-test"),
			DefaultAreaName: pulumi.String("C******na"),
			DefaultIsp:      pulumi.String("CMCC"),
			ImageId:         pulumi.String("image*****viqm"),
			NetworkConfig: &veenedge.CloudServerNetworkConfigArgs{
				BandwidthPeak: pulumi.String("5"),
			},
			ScheduleStrategy: &veenedge.CloudServerScheduleStrategyArgs{
				NetworkStrategy:  pulumi.String("region"),
				PriceStrategy:    pulumi.String("high_priority"),
				ScheduleStrategy: pulumi.String("dispersion"),
			},
			SecretData:      pulumi.String("sshkey-47*****wgc"),
			SecretType:      pulumi.String("KeyPair"),
			ServerAreaLevel: pulumi.String("region"),
			SpecName:        pulumi.String("veEN****rge"),
			StorageConfig: &veenedge.CloudServerStorageConfigArgs{
				DataDiskLists: veenedge.CloudServerStorageConfigDataDiskListArray{
					&veenedge.CloudServerStorageConfigDataDiskListArgs{
						Capacity:    pulumi.String("20"),
						StorageType: pulumi.String("CloudBlockSSD"),
					},
				},
				SystemDisk: &veenedge.CloudServerStorageConfigSystemDiskArgs{
					Capacity:    pulumi.String("40"),
					StorageType: pulumi.String("CloudBlockSSD"),
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.volcengine.veenedge.CloudServer;
import com.pulumi.volcengine.veenedge.CloudServerArgs;
import com.pulumi.volcengine.veenedge.inputs.CloudServerBillingConfigArgs;
import com.pulumi.volcengine.veenedge.inputs.CloudServerNetworkConfigArgs;
import com.pulumi.volcengine.veenedge.inputs.CloudServerScheduleStrategyArgs;
import com.pulumi.volcengine.veenedge.inputs.CloudServerStorageConfigArgs;
import com.pulumi.volcengine.veenedge.inputs.CloudServerStorageConfigSystemDiskArgs;
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) {
        var foo = new CloudServer("foo", CloudServerArgs.builder()        
            .billingConfig(CloudServerBillingConfigArgs.builder()
                .bandwidthBillingMethod("MonthlyP95")
                .computingBillingMethod("MonthlyPeak")
                .build())
            .cloudserverName("tf-test")
            .defaultAreaName("C******na")
            .defaultIsp("CMCC")
            .imageId("image*****viqm")
            .networkConfig(CloudServerNetworkConfigArgs.builder()
                .bandwidthPeak(5)
                .build())
            .scheduleStrategy(CloudServerScheduleStrategyArgs.builder()
                .networkStrategy("region")
                .priceStrategy("high_priority")
                .scheduleStrategy("dispersion")
                .build())
            .secretData("sshkey-47*****wgc")
            .secretType("KeyPair")
            .serverAreaLevel("region")
            .specName("veEN****rge")
            .storageConfig(CloudServerStorageConfigArgs.builder()
                .dataDiskLists(CloudServerStorageConfigDataDiskListArgs.builder()
                    .capacity(20)
                    .storageType("CloudBlockSSD")
                    .build())
                .systemDisk(CloudServerStorageConfigSystemDiskArgs.builder()
                    .capacity(40)
                    .storageType("CloudBlockSSD")
                    .build())
                .build())
            .build());

    }
}

import pulumi
import pulumi_volcengine as volcengine

foo = volcengine.veenedge.CloudServer("foo",
    billing_config=volcengine.veenedge.CloudServerBillingConfigArgs(
        bandwidth_billing_method="MonthlyP95",
        computing_billing_method="MonthlyPeak",
    ),
    cloudserver_name="tf-test",
    default_area_name="C******na",
    default_isp="CMCC",
    image_id="image*****viqm",
    network_config=volcengine.veenedge.CloudServerNetworkConfigArgs(
        bandwidth_peak="5",
    ),
    schedule_strategy=volcengine.veenedge.CloudServerScheduleStrategyArgs(
        network_strategy="region",
        price_strategy="high_priority",
        schedule_strategy="dispersion",
    ),
    secret_data="sshkey-47*****wgc",
    secret_type="KeyPair",
    server_area_level="region",
    spec_name="veEN****rge",
    storage_config=volcengine.veenedge.CloudServerStorageConfigArgs(
        data_disk_lists=[volcengine.veenedge.CloudServerStorageConfigDataDiskListArgs(
            capacity="20",
            storage_type="CloudBlockSSD",
        )],
        system_disk=volcengine.veenedge.CloudServerStorageConfigSystemDiskArgs(
            capacity="40",
            storage_type="CloudBlockSSD",
        ),
    ))

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

const foo = new volcengine.veenedge.CloudServer("foo", {
    billingConfig: {
        bandwidthBillingMethod: "MonthlyP95",
        computingBillingMethod: "MonthlyPeak",
    },
    cloudserverName: "tf-test",
    defaultAreaName: "C******na",
    defaultIsp: "CMCC",
    imageId: "image*****viqm",
    networkConfig: {
        bandwidthPeak: "5",
    },
    scheduleStrategy: {
        networkStrategy: "region",
        priceStrategy: "high_priority",
        scheduleStrategy: "dispersion",
    },
    secretData: "sshkey-47*****wgc",
    secretType: "KeyPair",
    serverAreaLevel: "region",
    specName: "veEN****rge",
    storageConfig: {
        dataDiskLists: [{
            capacity: "20",
            storageType: "CloudBlockSSD",
        }],
        systemDisk: {
            capacity: "40",
            storageType: "CloudBlockSSD",
        },
    },
});

resources:
  foo:
    type: volcengine:veenedge:CloudServer
    properties:
      billingConfig:
        bandwidthBillingMethod: MonthlyP95
        computingBillingMethod: MonthlyPeak
      cloudserverName: tf-test
      defaultAreaName: C******na
      defaultIsp: CMCC
      imageId: image*****viqm
      networkConfig:
        bandwidthPeak: 5
      scheduleStrategy:
        networkStrategy: region
        priceStrategy: high_priority
        scheduleStrategy: dispersion
      secretData: sshkey-47*****wgc
      secretType: KeyPair
      serverAreaLevel: region
      specName: veEN****rge
      storageConfig:
        dataDiskLists:
          - capacity: 20
            storageType: CloudBlockSSD
        systemDisk:
          capacity: 40
          storageType: CloudBlockSSD