Docs Home Pulumi IaC Pulumi ESC Pulumi Insights Pulumi Cloud Packages Tutorials
  1. Packages
  2. Glesys Provider
  3. API Docs
  4. Server
glesys 0.14.2 published on Tuesday, Apr 15, 2025 by glesys
glesys/terraform-provider-glesys

glesys.Server

Explore with Pulumi AI

glesys logo
glesys 0.14.2 published on Tuesday, Apr 15, 2025 by glesys
glesys/terraform-provider-glesys

    Create a new GleSYS virtual server.

    Example Usage

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

const myParams = {
    name: "Alice",
    numberOfBalloons: 99,
};
const kvmServer = new glesys.Server("kvmServer", {
    datacenter: "Stockholm",
    memory: 1024,
    storage: 20,
    cpu: 1,
    bandwidth: 100,
    hostname: "www1",
    platform: "KVM",
    template: "debian-11",
    cloudconfigparams: myParams,
    cloudconfig: `#cloud-config
bootcmd:
  - echo 'Hello {{params.name}}!'`,
    users: [
        {
            username: "alice",
            publickeys: [
                "ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAINOCh8br7CwZDMGmINyJgBip943QXgkf7XdXrDMJf5Dl alice@example.com",
                "ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIOfN4dBsS2p1UX+DP6RicdxAYCCeRK8mzCldCS0W9A+5 alice@ws.example.com",
            ],
            password: "hunter4!",
        },
        {
            username: "bob",
            publickeys: ["ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAINOCh8br7CwZDMGmINyJgBip943QXgkf7XdXrDMJf5Dl bob@example.com"],
            password: "hunter444!",
        },
    ],
});
// KVM with backups_schedule
const kvmIndex_serverServer = new glesys.Server("kvmIndex/serverServer", {
    datacenter: "Stockholm",
    memory: 1024,
    storage: 20,
    cpu: 1,
    bandwidth: 100,
    hostname: "www1",
    platform: "KVM",
    template: "debian-11",
    users: [{
        username: "alice",
        publickeys: [
            "ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAINOCh8br7CwZDMGmINyJgBip943QXgkf7XdXrDMJf5Dl alice@example.com",
            "ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIOfN4dBsS2p1UX+DP6RicdxAYCCeRK8mzCldCS0W9A+5 alice@ws.example.com",
        ],
        password: "hunter4!",
    }],
    backupsSchedules: [
        {
            frequency: "daily",
            retention: 7,
        },
        {
            frequency: "weekly",
            retention: 4,
        },
    ],
});
const config = new pulumi.Config();
const datacenter = config.get("datacenter") || "Falkenberg";
const description = config.get("description") || "tf-vmware-";
const bw = config.getNumber("bw") || 100;
const mem = config.getNumber("mem") || 1024;
const storage = config.getNumber("storage") || 20;
const platform = config.getObject<{Falkenberg?: string, Stockholm?: string}>("platform") || {
    Falkenberg: "KVM",
    Stockholm: "VMware",
};
const region = config.getObject<{0?: string, 1?: string}>("region") || {
    "0": "Falkenberg",
    "1": "Stockholm",
};
const regionShort = config.getObject<{0?: string, 1?: string}>("regionShort") || {
    "0": "fbg",
    "1": "sth",
};
const regionOs = config.getObject<{Falkenberg?: string, Stockholm?: string}>("regionOs") || {
    Falkenberg: "debian9",
    Stockholm: "debian9",
};
const template = config.getObject<{debian8?: string, debian9?: string}>("template") || {
    debian8: "Debian 8 64-bit",
    debian9: "Debian 9 64-bit",
};
const templatelist = config.getObject<{0?: string, 1?: string, 2?: string, 3?: string, 4?: string, 5?: string, 6?: string, 7?: string, 8?: string}>("templatelist") || {
    "0": "Centos 7 64-bit",
    "1": "Centos 8 64-bit",
    "2": "Debian 8 64-bit",
    "3": "Debian 9 64-bit",
    "4": "Debian 10 64-bit",
    "5": "Ubuntu 14.04 LTS 64-bit",
    "6": "Ubuntu 16.04 LTS 64-bit",
    "7": "Ubuntu 18.04 LTS 64-bit",
    "8": "Ubuntu 20.04 LTS 64-bit",
};
// Create the server resource
let vmware: glesys.Server | undefined;
if (1 == true) {
    vmware = new glesys.Server("vmware", {
        bandwidth: bw,
        cpu: 1,
        datacenter: "Falkenberg",
        description: `${description}-example-${range.value}`,
        hostname: `vmware-vm-${range.value}`,
        memory: mem,
        platform: "VMware",
        storage: storage,
        template: templatelist[range.value],
        password: "hunter2!",
    });
}

    import pulumi
import pulumi_glesys as glesys

my_params = {
    "name": "Alice",
    "numberOfBalloons": 99,
}
kvm_server = glesys.Server("kvmServer",
    datacenter="Stockholm",
    memory=1024,
    storage=20,
    cpu=1,
    bandwidth=100,
    hostname="www1",
    platform="KVM",
    template="debian-11",
    cloudconfigparams=my_params,
    cloudconfig="""#cloud-config
bootcmd:
  - echo 'Hello {{params.name}}!'""",
    users=[
        {
            "username": "alice",
            "publickeys": [
                "ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAINOCh8br7CwZDMGmINyJgBip943QXgkf7XdXrDMJf5Dl alice@example.com",
                "ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIOfN4dBsS2p1UX+DP6RicdxAYCCeRK8mzCldCS0W9A+5 alice@ws.example.com",
            ],
            "password": "hunter4!",
        },
        {
            "username": "bob",
            "publickeys": ["ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAINOCh8br7CwZDMGmINyJgBip943QXgkf7XdXrDMJf5Dl bob@example.com"],
            "password": "hunter444!",
        },
    ])
# KVM with backups_schedule
kvm_index_server_server = glesys.Server("kvmIndex/serverServer",
    datacenter="Stockholm",
    memory=1024,
    storage=20,
    cpu=1,
    bandwidth=100,
    hostname="www1",
    platform="KVM",
    template="debian-11",
    users=[{
        "username": "alice",
        "publickeys": [
            "ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAINOCh8br7CwZDMGmINyJgBip943QXgkf7XdXrDMJf5Dl alice@example.com",
            "ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIOfN4dBsS2p1UX+DP6RicdxAYCCeRK8mzCldCS0W9A+5 alice@ws.example.com",
        ],
        "password": "hunter4!",
    }],
    backups_schedules=[
        {
            "frequency": "daily",
            "retention": 7,
        },
        {
            "frequency": "weekly",
            "retention": 4,
        },
    ])
config = pulumi.Config()
datacenter = config.get("datacenter")
if datacenter is None:
    datacenter = "Falkenberg"
description = config.get("description")
if description is None:
    description = "tf-vmware-"
bw = config.get_float("bw")
if bw is None:
    bw = 100
mem = config.get_float("mem")
if mem is None:
    mem = 1024
storage = config.get_float("storage")
if storage is None:
    storage = 20
platform = config.get_object("platform")
if platform is None:
    platform = {
        "Falkenberg": "KVM",
        "Stockholm": "VMware",
    }
region = config.get_object("region")
if region is None:
    region = {
        "0": "Falkenberg",
        "1": "Stockholm",
    }
region_short = config.get_object("regionShort")
if region_short is None:
    region_short = {
        "0": "fbg",
        "1": "sth",
    }
region_os = config.get_object("regionOs")
if region_os is None:
    region_os = {
        "Falkenberg": "debian9",
        "Stockholm": "debian9",
    }
template = config.get_object("template")
if template is None:
    template = {
        "debian8": "Debian 8 64-bit",
        "debian9": "Debian 9 64-bit",
    }
templatelist = config.get_object("templatelist")
if templatelist is None:
    templatelist = {
        "0": "Centos 7 64-bit",
        "1": "Centos 8 64-bit",
        "2": "Debian 8 64-bit",
        "3": "Debian 9 64-bit",
        "4": "Debian 10 64-bit",
        "5": "Ubuntu 14.04 LTS 64-bit",
        "6": "Ubuntu 16.04 LTS 64-bit",
        "7": "Ubuntu 18.04 LTS 64-bit",
        "8": "Ubuntu 20.04 LTS 64-bit",
    }
# Create the server resource
vmware = None
if 1 == True:
    vmware = glesys.Server("vmware",
        bandwidth=bw,
        cpu=1,
        datacenter="Falkenberg",
        description=f"{description}-example-{range['value']}",
        hostname=f"vmware-vm-{range['value']}",
        memory=mem,
        platform="VMware",
        storage=storage,
        template=templatelist[range["value"]],
        password="hunter2!")

    package main

import (
	"fmt"

	"github.com/pulumi/pulumi-terraform-provider/sdks/go/glesys/glesys"
	"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 {
		myParams := map[string]interface{}{
			"name":             "Alice",
			"numberOfBalloons": 99,
		}
		_, err := glesys.NewServer(ctx, "kvmServer", &glesys.ServerArgs{
			Datacenter:        pulumi.String("Stockholm"),
			Memory:            pulumi.Float64(1024),
			Storage:           pulumi.Float64(20),
			Cpu:               pulumi.Float64(1),
			Bandwidth:         pulumi.Float64(100),
			Hostname:          pulumi.String("www1"),
			Platform:          pulumi.String("KVM"),
			Template:          pulumi.String("debian-11"),
			Cloudconfigparams: pulumi.Map(myParams),
			Cloudconfig:       pulumi.String("#cloud-config\nbootcmd:\n  - echo 'Hello {{params.name}}!'"),
			Users: glesys.ServerUserArray{
				&glesys.ServerUserArgs{
					Username: pulumi.String("alice"),
					Publickeys: pulumi.StringArray{
						pulumi.String("ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAINOCh8br7CwZDMGmINyJgBip943QXgkf7XdXrDMJf5Dl alice@example.com"),
						pulumi.String("ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIOfN4dBsS2p1UX+DP6RicdxAYCCeRK8mzCldCS0W9A+5 alice@ws.example.com"),
					},
					Password: pulumi.String("hunter4!"),
				},
				&glesys.ServerUserArgs{
					Username: pulumi.String("bob"),
					Publickeys: pulumi.StringArray{
						pulumi.String("ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAINOCh8br7CwZDMGmINyJgBip943QXgkf7XdXrDMJf5Dl bob@example.com"),
					},
					Password: pulumi.String("hunter444!"),
				},
			},
		})
		if err != nil {
			return err
		}
		_, err = glesys.NewServer(ctx, "kvmIndex/serverServer", &glesys.ServerArgs{
			Datacenter: pulumi.String("Stockholm"),
			Memory:     pulumi.Float64(1024),
			Storage:    pulumi.Float64(20),
			Cpu:        pulumi.Float64(1),
			Bandwidth:  pulumi.Float64(100),
			Hostname:   pulumi.String("www1"),
			Platform:   pulumi.String("KVM"),
			Template:   pulumi.String("debian-11"),
			Users: glesys.ServerUserArray{
				&glesys.ServerUserArgs{
					Username: pulumi.String("alice"),
					Publickeys: pulumi.StringArray{
						pulumi.String("ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAINOCh8br7CwZDMGmINyJgBip943QXgkf7XdXrDMJf5Dl alice@example.com"),
						pulumi.String("ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIOfN4dBsS2p1UX+DP6RicdxAYCCeRK8mzCldCS0W9A+5 alice@ws.example.com"),
					},
					Password: pulumi.String("hunter4!"),
				},
			},
			BackupsSchedules: glesys.ServerBackupsScheduleArray{
				&glesys.ServerBackupsScheduleArgs{
					Frequency: pulumi.String("daily"),
					Retention: pulumi.Float64(7),
				},
				&glesys.ServerBackupsScheduleArgs{
					Frequency: pulumi.String("weekly"),
					Retention: pulumi.Float64(4),
				},
			},
		})
		if err != nil {
			return err
		}
		cfg := config.New(ctx, "")
		datacenter := "Falkenberg"
		if param := cfg.Get("datacenter"); param != "" {
			datacenter = param
		}
		description := "tf-vmware-"
		if param := cfg.Get("description"); param != "" {
			description = param
		}
		bw := float64(100)
		if param := cfg.GetFloat64("bw"); param != 0 {
			bw = param
		}
		mem := float64(1024)
		if param := cfg.GetFloat64("mem"); param != 0 {
			mem = param
		}
		storage := float64(20)
		if param := cfg.GetFloat64("storage"); param != 0 {
			storage = param
		}
		platform := map[string]interface{}{
			"Falkenberg": "KVM",
			"Stockholm":  "VMware",
		}
		if param := cfg.GetObject("platform"); param != nil {
			platform = param
		}
		region := map[string]interface{}{
			"0": "Falkenberg",
			"1": "Stockholm",
		}
		if param := cfg.GetObject("region"); param != nil {
			region = param
		}
		regionShort := map[string]interface{}{
			"0": "fbg",
			"1": "sth",
		}
		if param := cfg.GetObject("regionShort"); param != nil {
			regionShort = param
		}
		regionOs := map[string]interface{}{
			"Falkenberg": "debian9",
			"Stockholm":  "debian9",
		}
		if param := cfg.GetObject("regionOs"); param != nil {
			regionOs = param
		}
		template := map[string]interface{}{
			"debian8": "Debian 8 64-bit",
			"debian9": "Debian 9 64-bit",
		}
		if param := cfg.GetObject("template"); param != nil {
			template = param
		}
		templatelist := map[string]interface{}{
			"0": "Centos 7 64-bit",
			"1": "Centos 8 64-bit",
			"2": "Debian 8 64-bit",
			"3": "Debian 9 64-bit",
			"4": "Debian 10 64-bit",
			"5": "Ubuntu 14.04 LTS 64-bit",
			"6": "Ubuntu 16.04 LTS 64-bit",
			"7": "Ubuntu 18.04 LTS 64-bit",
			"8": "Ubuntu 20.04 LTS 64-bit",
		}
		if param := cfg.GetObject("templatelist"); param != nil {
			templatelist = param
		}
		// Create the server resource
		var vmware []*glesys.Server
		for index := 0; index < 1 == true; index++ {
			key0 := index
			val0 := index
			__res, err := glesys.NewServer(ctx, fmt.Sprintf("vmware-%v", key0), &glesys.ServerArgs{
				Bandwidth:   pulumi.Float64(bw),
				Cpu:         pulumi.Float64(1),
				Datacenter:  pulumi.String("Falkenberg"),
				Description: pulumi.Sprintf("%v-example-%v", description, val0),
				Hostname:    pulumi.Sprintf("vmware-vm-%v", val0),
				Memory:      pulumi.Float64(mem),
				Platform:    pulumi.String("VMware"),
				Storage:     pulumi.Float64(storage),
				Template:    templatelist[val0],
				Password:    pulumi.String("hunter2!"),
			})
			if err != nil {
				return err
			}
			vmware = append(vmware, __res)
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var myParams = 
    {
        { "name", "Alice" },
        { "numberOfBalloons", 99 },
    };

    var kvmServer = new Glesys.Server("kvmServer", new()
    {
        Datacenter = "Stockholm",
        Memory = 1024,
        Storage = 20,
        Cpu = 1,
        Bandwidth = 100,
        Hostname = "www1",
        Platform = "KVM",
        Template = "debian-11",
        Cloudconfigparams = myParams,
        Cloudconfig = @"#cloud-config
bootcmd:
  - echo 'Hello {{params.name}}!'",
        Users = new[]
        {
            new Glesys.Inputs.ServerUserArgs
            {
                Username = "alice",
                Publickeys = new[]
                {
                    "ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAINOCh8br7CwZDMGmINyJgBip943QXgkf7XdXrDMJf5Dl alice@example.com",
                    "ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIOfN4dBsS2p1UX+DP6RicdxAYCCeRK8mzCldCS0W9A+5 alice@ws.example.com",
                },
                Password = "hunter4!",
            },
            new Glesys.Inputs.ServerUserArgs
            {
                Username = "bob",
                Publickeys = new[]
                {
                    "ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAINOCh8br7CwZDMGmINyJgBip943QXgkf7XdXrDMJf5Dl bob@example.com",
                },
                Password = "hunter444!",
            },
        },
    });

    // KVM with backups_schedule
    var kvmIndex_serverServer = new Glesys.Server("kvmIndex/serverServer", new()
    {
        Datacenter = "Stockholm",
        Memory = 1024,
        Storage = 20,
        Cpu = 1,
        Bandwidth = 100,
        Hostname = "www1",
        Platform = "KVM",
        Template = "debian-11",
        Users = new[]
        {
            new Glesys.Inputs.ServerUserArgs
            {
                Username = "alice",
                Publickeys = new[]
                {
                    "ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAINOCh8br7CwZDMGmINyJgBip943QXgkf7XdXrDMJf5Dl alice@example.com",
                    "ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIOfN4dBsS2p1UX+DP6RicdxAYCCeRK8mzCldCS0W9A+5 alice@ws.example.com",
                },
                Password = "hunter4!",
            },
        },
        BackupsSchedules = new[]
        {
            new Glesys.Inputs.ServerBackupsScheduleArgs
            {
                Frequency = "daily",
                Retention = 7,
            },
            new Glesys.Inputs.ServerBackupsScheduleArgs
            {
                Frequency = "weekly",
                Retention = 4,
            },
        },
    });

    var config = new Config();
    var datacenter = config.Get("datacenter") ?? "Falkenberg";
    var description = config.Get("description") ?? "tf-vmware-";
    var bw = config.GetDouble("bw") ?? 100;
    var mem = config.GetDouble("mem") ?? 1024;
    var storage = config.GetDouble("storage") ?? 20;
    var platform = config.GetObject<Platform>("platform") ?? 
    {
        { "Falkenberg", "KVM" },
        { "Stockholm", "VMware" },
    };
    var region = config.GetObject<Region>("region") ?? 
    {
        { "0", "Falkenberg" },
        { "1", "Stockholm" },
    };
    var regionShort = config.GetObject<RegionShort>("regionShort") ?? 
    {
        { "0", "fbg" },
        { "1", "sth" },
    };
    var regionOs = config.GetObject<RegionOs>("regionOs") ?? 
    {
        { "Falkenberg", "debian9" },
        { "Stockholm", "debian9" },
    };
    var template = config.GetObject<Template>("template") ?? 
    {
        { "debian8", "Debian 8 64-bit" },
        { "debian9", "Debian 9 64-bit" },
    };
    var templatelist = config.GetObject<Templatelist>("templatelist") ?? 
    {
        { "0", "Centos 7 64-bit" },
        { "1", "Centos 8 64-bit" },
        { "2", "Debian 8 64-bit" },
        { "3", "Debian 9 64-bit" },
        { "4", "Debian 10 64-bit" },
        { "5", "Ubuntu 14.04 LTS 64-bit" },
        { "6", "Ubuntu 16.04 LTS 64-bit" },
        { "7", "Ubuntu 18.04 LTS 64-bit" },
        { "8", "Ubuntu 20.04 LTS 64-bit" },
    };
    // Create the server resource
    var vmware = new List<Glesys.Server>();
    for (var rangeIndex = 0; rangeIndex < (1 == true); rangeIndex++)
    {
        var range = new { Value = rangeIndex };
        vmware.Add(new Glesys.Server($"vmware-{range.Value}", new()
        {
            Bandwidth = bw,
            Cpu = 1,
            Datacenter = "Falkenberg",
            Description = $"{description}-example-{range.Value}",
            Hostname = $"vmware-vm-{range.Value}",
            Memory = mem,
            Platform = "VMware",
            Storage = storage,
            Template = templatelist[range.Value],
            Password = "hunter2!",
        }));
    }
});

public class Platform
{
    public string Falkenberg { get; set; }
    public string Stockholm { get; set; }
}

public class Region
{
    public string 0 { get; set; }
    public string 1 { get; set; }
}

public class RegionOs
{
    public string Falkenberg { get; set; }
    public string Stockholm { get; set; }
}

public class RegionShort
{
    public string 0 { get; set; }
    public string 1 { get; set; }
}

public class Template
{
    public string debian8 { get; set; }
    public string debian9 { get; set; }
}

public class Templatelist
{
    public string 0 { get; set; }
    public string 1 { get; set; }
    public string 2 { get; set; }
    public string 3 { get; set; }
    public string 4 { get; set; }
    public string 5 { get; set; }
    public string 6 { get; set; }
    public string 7 { get; set; }
    public string 8 { get; set; }
}

    package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.glesys.Server;
import com.pulumi.glesys.ServerArgs;
import com.pulumi.glesys.inputs.ServerUserArgs;
import com.pulumi.glesys.inputs.ServerBackupsScheduleArgs;
import com.pulumi.codegen.internal.KeyedValue;
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 myParams = %!v(PANIC=Format method: runtime error: invalid memory address or nil pointer dereference);

        var kvmServer = new Server("kvmServer", ServerArgs.builder()
            .datacenter("Stockholm")
            .memory(1024)
            .storage(20)
            .cpu(1)
            .bandwidth(100)
            .hostname("www1")
            .platform("KVM")
            .template("debian-11")
            .cloudconfigparams(myParams)
            .cloudconfig("""
#cloud-config
bootcmd:
  - echo 'Hello {{params.name}}!'            """)
            .users(            
                ServerUserArgs.builder()
                    .username("alice")
                    .publickeys(                    
                        "ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAINOCh8br7CwZDMGmINyJgBip943QXgkf7XdXrDMJf5Dl alice@example.com",
                        "ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIOfN4dBsS2p1UX+DP6RicdxAYCCeRK8mzCldCS0W9A+5 alice@ws.example.com")
                    .password("hunter4!")
                    .build(),
                ServerUserArgs.builder()
                    .username("bob")
                    .publickeys("ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAINOCh8br7CwZDMGmINyJgBip943QXgkf7XdXrDMJf5Dl bob@example.com")
                    .password("hunter444!")
                    .build())
            .build());

        // KVM with backups_schedule
        var kvmIndex_serverServer = new Server("kvmIndex/serverServer", ServerArgs.builder()
            .datacenter("Stockholm")
            .memory(1024)
            .storage(20)
            .cpu(1)
            .bandwidth(100)
            .hostname("www1")
            .platform("KVM")
            .template("debian-11")
            .users(ServerUserArgs.builder()
                .username("alice")
                .publickeys(                
                    "ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAINOCh8br7CwZDMGmINyJgBip943QXgkf7XdXrDMJf5Dl alice@example.com",
                    "ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIOfN4dBsS2p1UX+DP6RicdxAYCCeRK8mzCldCS0W9A+5 alice@ws.example.com")
                .password("hunter4!")
                .build())
            .backupsSchedules(            
                ServerBackupsScheduleArgs.builder()
                    .frequency("daily")
                    .retention(7)
                    .build(),
                ServerBackupsScheduleArgs.builder()
                    .frequency("weekly")
                    .retention(4)
                    .build())
            .build());

        final var datacenter = config.get("datacenter").orElse("Falkenberg");
        final var description = config.get("description").orElse("tf-vmware-");
        final var bw = config.get("bw").orElse(100);
        final var mem = config.get("mem").orElse(1024);
        final var storage = config.get("storage").orElse(20);
        final var platform = config.get("platform").orElse(ServerBackupsScheduleArgs.builder()
            .falkenberg("KVM")
            .stockholm("VMware")
            .build());
        final var region = config.get("region").orElse(ServerBackupsScheduleArgs.builder()
%!v(PANIC=Format method: interface conversion: model.Expression is *model.TemplateExpression, not *model.LiteralValueExpression));
            final var regionShort = config.get("regionShort").orElse(ServerBackupsScheduleArgs.builder()
%!v(PANIC=Format method: interface conversion: model.Expression is *model.TemplateExpression, not *model.LiteralValueExpression));
                final var regionOs = config.get("regionOs").orElse(ServerBackupsScheduleArgs.builder()
                    .falkenberg("debian9")
                    .stockholm("debian9")
                    .build());
                final var template = config.get("template").orElse(ServerBackupsScheduleArgs.builder()
                    .debian8("Debian 8 64-bit")
                    .debian9("Debian 9 64-bit")
                    .build());
                final var templatelist = config.get("templatelist").orElse(ServerBackupsScheduleArgs.builder()
%!v(PANIC=Format method: interface conversion: model.Expression is *model.TemplateExpression, not *model.LiteralValueExpression));
                    // Create the server resource
                    for (var i = 0; i < (1 == true); i++) {
                        new Server("vmware-" + i, ServerArgs.builder()
                            .bandwidth(bw)
                            .cpu(1)
                            .datacenter("Falkenberg")
                            .description(String.format("%s-example-%s", description,range.value()))
                            .hostname(String.format("vmware-vm-%s", range.value()))
                            .memory(mem)
                            .platform("VMware")
                            .storage(storage)
                            .template(templatelist[range.value()])
                            .password("hunter2!")
                            .build());

                    
}
                }
}

    Coming soon!

    Cloud Config

    When using the KVM platform you can provide a custom cloud-config file to configure and provision your server automatically.

    Examples can be found in the GleSYS API - Cloud config documentation

    Create Server Resource

    Resources are created with functions called constructors. To learn more about declaring and configuring resources, see Resources.

    Constructor syntax

    new Server(name: string, args: ServerArgs, opts?: CustomResourceOptions);
    @overload
def Server(resource_name: str,
           args: ServerArgs,
           opts: Optional[ResourceOptions] = None)

@overload
def Server(resource_name: str,
           opts: Optional[ResourceOptions] = None,
           datacenter: Optional[str] = None,
           bandwidth: Optional[float] = None,
           storage: Optional[float] = None,
           memory: Optional[float] = None,
           hostname: Optional[str] = None,
           cpu: Optional[float] = None,
           ipv6_address: Optional[str] = None,
           platform: Optional[str] = None,
           cloudconfigparams: Optional[Mapping[str, str]] = None,
           ipv4_address: Optional[str] = None,
           backups_schedules: Optional[Sequence[ServerBackupsScheduleArgs]] = None,
           cloudconfig: Optional[str] = None,
           password: Optional[str] = None,
           description: Optional[str] = None,
           publickey: Optional[str] = None,
           server_id: Optional[str] = None,
           campaigncode: Optional[str] = None,
           template: Optional[str] = None,
           timeouts: Optional[ServerTimeoutsArgs] = None,
           users: Optional[Sequence[ServerUserArgs]] = None)
    func NewServer(ctx *Context, name string, args ServerArgs, opts ...ResourceOption) (*Server, error)
    public Server(string name, ServerArgs args, CustomResourceOptions? opts = null)
    public Server(String name, ServerArgs args)
public Server(String name, ServerArgs args, CustomResourceOptions options)

    type: glesys:Server
properties: # The arguments to resource properties.
options: # Bag of options to control resource's behavior.

    Parameters

    name string
    The unique name of the resource.
    args ServerArgs
    The arguments to resource properties.
    opts CustomResourceOptions
    Bag of options to control resource's behavior.
    resource_name str
    The unique name of the resource.
    args ServerArgs
    The arguments to resource properties.
    opts ResourceOptions
    Bag of options to control resource's behavior.
    ctx Context
    Context object for the current deployment.
    name string
    The unique name of the resource.
    args ServerArgs
    The arguments to resource properties.
    opts ResourceOption
    Bag of options to control resource's behavior.
    name string
    The unique name of the resource.
    args ServerArgs
    The arguments to resource properties.
    opts CustomResourceOptions
    Bag of options to control resource's behavior.
    name String
    The unique name of the resource.
    args ServerArgs
    The arguments to resource properties.
    options CustomResourceOptions
    Bag of options to control resource's behavior.

    Constructor example

    The following reference example uses placeholder values for all input properties.

    var serverResource = new Glesys.Server("serverResource", new()
{
    Datacenter = "string",
    Bandwidth = 0,
    Storage = 0,
    Memory = 0,
    Hostname = "string",
    Cpu = 0,
    Ipv6Address = "string",
    Platform = "string",
    Cloudconfigparams = 
    {
        { "string", "string" },
    },
    Ipv4Address = "string",
    BackupsSchedules = new[]
    {
        new Glesys.Inputs.ServerBackupsScheduleArgs
        {
            Frequency = "string",
            Retention = 0,
        },
    },
    Cloudconfig = "string",
    Password = "string",
    Description = "string",
    Publickey = "string",
    ServerId = "string",
    Campaigncode = "string",
    Template = "string",
    Timeouts = new Glesys.Inputs.ServerTimeoutsArgs
    {
        Create = "string",
        Delete = "string",
    },
    Users = new[]
    {
        new Glesys.Inputs.ServerUserArgs
        {
            Password = "string",
            Publickeys = new[]
            {
                "string",
            },
            Username = "string",
        },
    },
});

    example, err := glesys.NewServer(ctx, "serverResource", &glesys.ServerArgs{
	Datacenter:  pulumi.String("string"),
	Bandwidth:   pulumi.Float64(0),
	Storage:     pulumi.Float64(0),
	Memory:      pulumi.Float64(0),
	Hostname:    pulumi.String("string"),
	Cpu:         pulumi.Float64(0),
	Ipv6Address: pulumi.String("string"),
	Platform:    pulumi.String("string"),
	Cloudconfigparams: pulumi.StringMap{
		"string": pulumi.String("string"),
	},
	Ipv4Address: pulumi.String("string"),
	BackupsSchedules: glesys.ServerBackupsScheduleArray{
		&glesys.ServerBackupsScheduleArgs{
			Frequency: pulumi.String("string"),
			Retention: pulumi.Float64(0),
		},
	},
	Cloudconfig:  pulumi.String("string"),
	Password:     pulumi.String("string"),
	Description:  pulumi.String("string"),
	Publickey:    pulumi.String("string"),
	ServerId:     pulumi.String("string"),
	Campaigncode: pulumi.String("string"),
	Template:     pulumi.String("string"),
	Timeouts: &glesys.ServerTimeoutsArgs{
		Create: pulumi.String("string"),
		Delete: pulumi.String("string"),
	},
	Users: glesys.ServerUserArray{
		&glesys.ServerUserArgs{
			Password: pulumi.String("string"),
			Publickeys: pulumi.StringArray{
				pulumi.String("string"),
			},
			Username: pulumi.String("string"),
		},
	},
})

    var serverResource = new Server("serverResource", ServerArgs.builder()
    .datacenter("string")
    .bandwidth(0)
    .storage(0)
    .memory(0)
    .hostname("string")
    .cpu(0)
    .ipv6Address("string")
    .platform("string")
    .cloudconfigparams(Map.of("string", "string"))
    .ipv4Address("string")
    .backupsSchedules(ServerBackupsScheduleArgs.builder()
        .frequency("string")
        .retention(0)
        .build())
    .cloudconfig("string")
    .password("string")
    .description("string")
    .publickey("string")
    .serverId("string")
    .campaigncode("string")
    .template("string")
    .timeouts(ServerTimeoutsArgs.builder()
        .create("string")
        .delete("string")
        .build())
    .users(ServerUserArgs.builder()
        .password("string")
        .publickeys("string")
        .username("string")
        .build())
    .build());

    server_resource = glesys.Server("serverResource",
    datacenter="string",
    bandwidth=0,
    storage=0,
    memory=0,
    hostname="string",
    cpu=0,
    ipv6_address="string",
    platform="string",
    cloudconfigparams={
        "string": "string",
    },
    ipv4_address="string",
    backups_schedules=[{
        "frequency": "string",
        "retention": 0,
    }],
    cloudconfig="string",
    password="string",
    description="string",
    publickey="string",
    server_id="string",
    campaigncode="string",
    template="string",
    timeouts={
        "create": "string",
        "delete": "string",
    },
    users=[{
        "password": "string",
        "publickeys": ["string"],
        "username": "string",
    }])

    const serverResource = new glesys.Server("serverResource", {
    datacenter: "string",
    bandwidth: 0,
    storage: 0,
    memory: 0,
    hostname: "string",
    cpu: 0,
    ipv6Address: "string",
    platform: "string",
    cloudconfigparams: {
        string: "string",
    },
    ipv4Address: "string",
    backupsSchedules: [{
        frequency: "string",
        retention: 0,
    }],
    cloudconfig: "string",
    password: "string",
    description: "string",
    publickey: "string",
    serverId: "string",
    campaigncode: "string",
    template: "string",
    timeouts: {
        create: "string",
        "delete": "string",
    },
    users: [{
        password: "string",
        publickeys: ["string"],
        username: "string",
    }],
});

    type: glesys:Server
properties:
    backupsSchedules:
        - frequency: string
          retention: 0
    bandwidth: 0
    campaigncode: string
    cloudconfig: string
    cloudconfigparams:
        string: string
    cpu: 0
    datacenter: string
    description: string
    hostname: string
    ipv4Address: string
    ipv6Address: string
    memory: 0
    password: string
    platform: string
    publickey: string
    serverId: string
    storage: 0
    template: string
    timeouts:
        create: string
        delete: string
    users:
        - password: string
          publickeys:
            - string
          username: string

    Server Resource Properties

    To learn more about resource properties and how to use them, see Inputs and Outputs in the Architecture and Concepts docs.

    Inputs

    In Python, inputs that are objects can be passed either as argument classes or as dictionary literals.

    The Server resource accepts the following input properties:

    Bandwidth double
    Server network adapter bandwidth
    Cpu double
    Server CPU cores count
    Datacenter string
    Server datacenter placement
    Hostname string
    Server hostname
    Memory double
    Server RAM setting
    Storage double
    Server disk space
    BackupsSchedules List<ServerBackupsSchedule>
    KVM Server backup schedule definition.
    Campaigncode string
    Campaigncode used during creation for possible discount
    Cloudconfig string
    Cloudconfig used to provision server using a provided cloud-config mustache template.
    Cloudconfigparams Dictionary<string, string>
    Description string
    Server description
    Ipv4Address string
    Server IPv4 address, set none to disable IP allocation
    Ipv6Address string
    Server IPv6 address, set none to disable IP allocation
    Password string
    Server root password, VMware only
    Platform string
    Server virtualisation platform, KVM or VMware
    Publickey string
    ServerId string
    The ID of this resource.
    Template string
    Server OS template
    Timeouts ServerTimeouts
    Users List<ServerUser>
    Bandwidth float64
    Server network adapter bandwidth
    Cpu float64
    Server CPU cores count
    Datacenter string
    Server datacenter placement
    Hostname string
    Server hostname
    Memory float64
    Server RAM setting
    Storage float64
    Server disk space
    BackupsSchedules []ServerBackupsScheduleArgs
    KVM Server backup schedule definition.
    Campaigncode string
    Campaigncode used during creation for possible discount
    Cloudconfig string
    Cloudconfig used to provision server using a provided cloud-config mustache template.
    Cloudconfigparams map[string]string
    Description string
    Server description
    Ipv4Address string
    Server IPv4 address, set none to disable IP allocation
    Ipv6Address string
    Server IPv6 address, set none to disable IP allocation
    Password string
    Server root password, VMware only
    Platform string
    Server virtualisation platform, KVM or VMware
    Publickey string
    ServerId string
    The ID of this resource.
    Template string
    Server OS template
    Timeouts ServerTimeoutsArgs
    Users []ServerUserArgs
    bandwidth Double
    Server network adapter bandwidth
    cpu Double
    Server CPU cores count
    datacenter String
    Server datacenter placement
    hostname String
    Server hostname
    memory Double
    Server RAM setting
    storage Double
    Server disk space
    backupsSchedules List<ServerBackupsSchedule>
    KVM Server backup schedule definition.
    campaigncode String
    Campaigncode used during creation for possible discount
    cloudconfig String
    Cloudconfig used to provision server using a provided cloud-config mustache template.
    cloudconfigparams Map<String,String>
    description String
    Server description
    ipv4Address String
    Server IPv4 address, set none to disable IP allocation
    ipv6Address String
    Server IPv6 address, set none to disable IP allocation
    password String
    Server root password, VMware only
    platform String
    Server virtualisation platform, KVM or VMware
    publickey String
    serverId String
    The ID of this resource.
    template String
    Server OS template
    timeouts ServerTimeouts
    users List<ServerUser>
    bandwidth number
    Server network adapter bandwidth
    cpu number
    Server CPU cores count
    datacenter string
    Server datacenter placement
    hostname string
    Server hostname
    memory number
    Server RAM setting
    storage number
    Server disk space
    backupsSchedules ServerBackupsSchedule[]
    KVM Server backup schedule definition.
    campaigncode string
    Campaigncode used during creation for possible discount
    cloudconfig string
    Cloudconfig used to provision server using a provided cloud-config mustache template.
    cloudconfigparams {[key: string]: string}
    description string
    Server description
    ipv4Address string
    Server IPv4 address, set none to disable IP allocation
    ipv6Address string
    Server IPv6 address, set none to disable IP allocation
    password string
    Server root password, VMware only
    platform string
    Server virtualisation platform, KVM or VMware
    publickey string
    serverId string
    The ID of this resource.
    template string
    Server OS template
    timeouts ServerTimeouts
    users ServerUser[]
    bandwidth float
    Server network adapter bandwidth
    cpu float
    Server CPU cores count
    datacenter str
    Server datacenter placement
    hostname str
    Server hostname
    memory float
    Server RAM setting
    storage float
    Server disk space
    backups_schedules Sequence[ServerBackupsScheduleArgs]
    KVM Server backup schedule definition.
    campaigncode str
    Campaigncode used during creation for possible discount
    cloudconfig str
    Cloudconfig used to provision server using a provided cloud-config mustache template.
    cloudconfigparams Mapping[str, str]
    description str
    Server description
    ipv4_address str
    Server IPv4 address, set none to disable IP allocation
    ipv6_address str
    Server IPv6 address, set none to disable IP allocation
    password str
    Server root password, VMware only
    platform str
    Server virtualisation platform, KVM or VMware
    publickey str
    server_id str
    The ID of this resource.
    template str
    Server OS template
    timeouts ServerTimeoutsArgs
    users Sequence[ServerUserArgs]
    bandwidth Number
    Server network adapter bandwidth
    cpu Number
    Server CPU cores count
    datacenter String
    Server datacenter placement
    hostname String
    Server hostname
    memory Number
    Server RAM setting
    storage Number
    Server disk space
    backupsSchedules List<Property Map>
    KVM Server backup schedule definition.
    campaigncode String
    Campaigncode used during creation for possible discount
    cloudconfig String
    Cloudconfig used to provision server using a provided cloud-config mustache template.
    cloudconfigparams Map<String>
    description String
    Server description
    ipv4Address String
    Server IPv4 address, set none to disable IP allocation
    ipv6Address String
    Server IPv6 address, set none to disable IP allocation
    password String
    Server root password, VMware only
    platform String
    Server virtualisation platform, KVM or VMware
    publickey String
    serverId String
    The ID of this resource.
    template String
    Server OS template
    timeouts Property Map
    users List<Property Map>

    Outputs

    All input properties are implicitly available as output properties. Additionally, the Server resource produces the following output properties:

    ExtraDisks List<string>
    Disks associated with the server. Use glesys.ServerDisk resource to manage these.
    Id string
    The provider-assigned unique ID for this managed resource.
    Islocked bool
    Server locked state
    Isrunning bool
    Server running state
    NetworkAdapters List<ServerNetworkAdapter>
    Network adapters associated with the server. glesys.Networkadapter
    ExtraDisks []string
    Disks associated with the server. Use glesys.ServerDisk resource to manage these.
    Id string
    The provider-assigned unique ID for this managed resource.
    Islocked bool
    Server locked state
    Isrunning bool
    Server running state
    NetworkAdapters []ServerNetworkAdapter
    Network adapters associated with the server. glesys.Networkadapter
    extraDisks List<String>
    Disks associated with the server. Use glesys.ServerDisk resource to manage these.
    id String
    The provider-assigned unique ID for this managed resource.
    islocked Boolean
    Server locked state
    isrunning Boolean
    Server running state
    networkAdapters List<ServerNetworkAdapter>
    Network adapters associated with the server. glesys.Networkadapter
    extraDisks string[]
    Disks associated with the server. Use glesys.ServerDisk resource to manage these.
    id string
    The provider-assigned unique ID for this managed resource.
    islocked boolean
    Server locked state
    isrunning boolean
    Server running state
    networkAdapters ServerNetworkAdapter[]
    Network adapters associated with the server. glesys.Networkadapter
    extra_disks Sequence[str]
    Disks associated with the server. Use glesys.ServerDisk resource to manage these.
    id str
    The provider-assigned unique ID for this managed resource.
    islocked bool
    Server locked state
    isrunning bool
    Server running state
    network_adapters Sequence[ServerNetworkAdapter]
    Network adapters associated with the server. glesys.Networkadapter
    extraDisks List<String>
    Disks associated with the server. Use glesys.ServerDisk resource to manage these.
    id String
    The provider-assigned unique ID for this managed resource.
    islocked Boolean
    Server locked state
    isrunning Boolean
    Server running state
    networkAdapters List<Property Map>
    Network adapters associated with the server. glesys.Networkadapter

    Look up Existing Server Resource

    Get an existing Server resource’s state with the given name, ID, and optional extra properties used to qualify the lookup.

    public static get(name: string, id: Input<ID>, state?: ServerState, opts?: CustomResourceOptions): Server
    @staticmethod
def get(resource_name: str,
        id: str,
        opts: Optional[ResourceOptions] = None,
        backups_schedules: Optional[Sequence[ServerBackupsScheduleArgs]] = None,
        bandwidth: Optional[float] = None,
        campaigncode: Optional[str] = None,
        cloudconfig: Optional[str] = None,
        cloudconfigparams: Optional[Mapping[str, str]] = None,
        cpu: Optional[float] = None,
        datacenter: Optional[str] = None,
        description: Optional[str] = None,
        extra_disks: Optional[Sequence[str]] = None,
        hostname: Optional[str] = None,
        ipv4_address: Optional[str] = None,
        ipv6_address: Optional[str] = None,
        islocked: Optional[bool] = None,
        isrunning: Optional[bool] = None,
        memory: Optional[float] = None,
        network_adapters: Optional[Sequence[ServerNetworkAdapterArgs]] = None,
        password: Optional[str] = None,
        platform: Optional[str] = None,
        publickey: Optional[str] = None,
        server_id: Optional[str] = None,
        storage: Optional[float] = None,
        template: Optional[str] = None,
        timeouts: Optional[ServerTimeoutsArgs] = None,
        users: Optional[Sequence[ServerUserArgs]] = None) -> Server
    func GetServer(ctx *Context, name string, id IDInput, state *ServerState, opts ...ResourceOption) (*Server, error)
    public static Server Get(string name, Input<string> id, ServerState? state, CustomResourceOptions? opts = null)
    public static Server get(String name, Output<String> id, ServerState state, CustomResourceOptions options)
    resources:  _:    type: glesys:Server    get:      id: ${id}
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    resource_name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    The following state arguments are supported:
    BackupsSchedules List<ServerBackupsSchedule>
    KVM Server backup schedule definition.
    Bandwidth double
    Server network adapter bandwidth
    Campaigncode string
    Campaigncode used during creation for possible discount
    Cloudconfig string
    Cloudconfig used to provision server using a provided cloud-config mustache template.
    Cloudconfigparams Dictionary<string, string>
    Cpu double
    Server CPU cores count
    Datacenter string
    Server datacenter placement
    Description string
    Server description
    ExtraDisks List<string>
    Disks associated with the server. Use glesys.ServerDisk resource to manage these.
    Hostname string
    Server hostname
    Ipv4Address string
    Server IPv4 address, set none to disable IP allocation
    Ipv6Address string
    Server IPv6 address, set none to disable IP allocation
    Islocked bool
    Server locked state
    Isrunning bool
    Server running state
    Memory double
    Server RAM setting
    NetworkAdapters List<ServerNetworkAdapter>
    Network adapters associated with the server. glesys.Networkadapter
    Password string
    Server root password, VMware only
    Platform string
    Server virtualisation platform, KVM or VMware
    Publickey string
    ServerId string
    The ID of this resource.
    Storage double
    Server disk space
    Template string
    Server OS template
    Timeouts ServerTimeouts
    Users List<ServerUser>
    BackupsSchedules []ServerBackupsScheduleArgs
    KVM Server backup schedule definition.
    Bandwidth float64
    Server network adapter bandwidth
    Campaigncode string
    Campaigncode used during creation for possible discount
    Cloudconfig string
    Cloudconfig used to provision server using a provided cloud-config mustache template.
    Cloudconfigparams map[string]string
    Cpu float64
    Server CPU cores count
    Datacenter string
    Server datacenter placement
    Description string
    Server description
    ExtraDisks []string
    Disks associated with the server. Use glesys.ServerDisk resource to manage these.
    Hostname string
    Server hostname
    Ipv4Address string
    Server IPv4 address, set none to disable IP allocation
    Ipv6Address string
    Server IPv6 address, set none to disable IP allocation
    Islocked bool
    Server locked state
    Isrunning bool
    Server running state
    Memory float64
    Server RAM setting
    NetworkAdapters []ServerNetworkAdapterArgs
    Network adapters associated with the server. glesys.Networkadapter
    Password string
    Server root password, VMware only
    Platform string
    Server virtualisation platform, KVM or VMware
    Publickey string
    ServerId string
    The ID of this resource.
    Storage float64
    Server disk space
    Template string
    Server OS template
    Timeouts ServerTimeoutsArgs
    Users []ServerUserArgs
    backupsSchedules List<ServerBackupsSchedule>
    KVM Server backup schedule definition.
    bandwidth Double
    Server network adapter bandwidth
    campaigncode String
    Campaigncode used during creation for possible discount
    cloudconfig String
    Cloudconfig used to provision server using a provided cloud-config mustache template.
    cloudconfigparams Map<String,String>
    cpu Double
    Server CPU cores count
    datacenter String
    Server datacenter placement
    description String
    Server description
    extraDisks List<String>
    Disks associated with the server. Use glesys.ServerDisk resource to manage these.
    hostname String
    Server hostname
    ipv4Address String
    Server IPv4 address, set none to disable IP allocation
    ipv6Address String
    Server IPv6 address, set none to disable IP allocation
    islocked Boolean
    Server locked state
    isrunning Boolean
    Server running state
    memory Double
    Server RAM setting
    networkAdapters List<ServerNetworkAdapter>
    Network adapters associated with the server. glesys.Networkadapter
    password String
    Server root password, VMware only
    platform String
    Server virtualisation platform, KVM or VMware
    publickey String
    serverId String
    The ID of this resource.
    storage Double
    Server disk space
    template String
    Server OS template
    timeouts ServerTimeouts
    users List<ServerUser>
    backupsSchedules ServerBackupsSchedule[]
    KVM Server backup schedule definition.
    bandwidth number
    Server network adapter bandwidth
    campaigncode string
    Campaigncode used during creation for possible discount
    cloudconfig string
    Cloudconfig used to provision server using a provided cloud-config mustache template.
    cloudconfigparams {[key: string]: string}
    cpu number
    Server CPU cores count
    datacenter string
    Server datacenter placement
    description string
    Server description
    extraDisks string[]
    Disks associated with the server. Use glesys.ServerDisk resource to manage these.
    hostname string
    Server hostname
    ipv4Address string
    Server IPv4 address, set none to disable IP allocation
    ipv6Address string
    Server IPv6 address, set none to disable IP allocation
    islocked boolean
    Server locked state
    isrunning boolean
    Server running state
    memory number
    Server RAM setting
    networkAdapters ServerNetworkAdapter[]
    Network adapters associated with the server. glesys.Networkadapter
    password string
    Server root password, VMware only
    platform string
    Server virtualisation platform, KVM or VMware
    publickey string
    serverId string
    The ID of this resource.
    storage number
    Server disk space
    template string
    Server OS template
    timeouts ServerTimeouts
    users ServerUser[]
    backups_schedules Sequence[ServerBackupsScheduleArgs]
    KVM Server backup schedule definition.
    bandwidth float
    Server network adapter bandwidth
    campaigncode str
    Campaigncode used during creation for possible discount
    cloudconfig str
    Cloudconfig used to provision server using a provided cloud-config mustache template.
    cloudconfigparams Mapping[str, str]
    cpu float
    Server CPU cores count
    datacenter str
    Server datacenter placement
    description str
    Server description
    extra_disks Sequence[str]
    Disks associated with the server. Use glesys.ServerDisk resource to manage these.
    hostname str
    Server hostname
    ipv4_address str
    Server IPv4 address, set none to disable IP allocation
    ipv6_address str
    Server IPv6 address, set none to disable IP allocation
    islocked bool
    Server locked state
    isrunning bool
    Server running state
    memory float
    Server RAM setting
    network_adapters Sequence[ServerNetworkAdapterArgs]
    Network adapters associated with the server. glesys.Networkadapter
    password str
    Server root password, VMware only
    platform str
    Server virtualisation platform, KVM or VMware
    publickey str
    server_id str
    The ID of this resource.
    storage float
    Server disk space
    template str
    Server OS template
    timeouts ServerTimeoutsArgs
    users Sequence[ServerUserArgs]
    backupsSchedules List<Property Map>
    KVM Server backup schedule definition.
    bandwidth Number
    Server network adapter bandwidth
    campaigncode String
    Campaigncode used during creation for possible discount
    cloudconfig String
    Cloudconfig used to provision server using a provided cloud-config mustache template.
    cloudconfigparams Map<String>
    cpu Number
    Server CPU cores count
    datacenter String
    Server datacenter placement
    description String
    Server description
    extraDisks List<String>
    Disks associated with the server. Use glesys.ServerDisk resource to manage these.
    hostname String
    Server hostname
    ipv4Address String
    Server IPv4 address, set none to disable IP allocation
    ipv6Address String
    Server IPv6 address, set none to disable IP allocation
    islocked Boolean
    Server locked state
    isrunning Boolean
    Server running state
    memory Number
    Server RAM setting
    networkAdapters List<Property Map>
    Network adapters associated with the server. glesys.Networkadapter
    password String
    Server root password, VMware only
    platform String
    Server virtualisation platform, KVM or VMware
    publickey String
    serverId String
    The ID of this resource.
    storage Number
    Server disk space
    template String
    Server OS template
    timeouts Property Map
    users List<Property Map>

    Supporting Types

    ServerBackupsSchedule, ServerBackupsScheduleArgs

    Frequency string
    Retention double
    Frequency string
    Retention float64
    frequency String
    retention Double
    frequency string
    retention number
    frequency String
    retention Number

    ServerNetworkAdapter, ServerNetworkAdapterArgs

    Adaptertype string
    Bandwidth double
    Id string
    Name string
    Networkid string
    Adaptertype string
    Bandwidth float64
    Id string
    Name string
    Networkid string
    adaptertype String
    bandwidth Double
    id String
    name String
    networkid String
    adaptertype string
    bandwidth number
    id string
    name string
    networkid string
    adaptertype String
    bandwidth Number
    id String
    name String
    networkid String

    ServerTimeouts, ServerTimeoutsArgs

    Create string
    Delete string
    Create string
    Delete string
    create String
    delete String
    create string
    delete string
    create str
    delete str
    create String
    delete String

    ServerUser, ServerUserArgs

    Password string
    Publickeys List<string>
    User SSH key(s), as a list. '["ssh-rsa abc...", "ssh-rsa foo..."]'
    Username string
    Password string
    Publickeys []string
    User SSH key(s), as a list. '["ssh-rsa abc...", "ssh-rsa foo..."]'
    Username string
    password String
    publickeys List<String>
    User SSH key(s), as a list. '["ssh-rsa abc...", "ssh-rsa foo..."]'
    username String
    password string
    publickeys string[]
    User SSH key(s), as a list. '["ssh-rsa abc...", "ssh-rsa foo..."]'
    username string
    password str
    publickeys Sequence[str]
    User SSH key(s), as a list. '["ssh-rsa abc...", "ssh-rsa foo..."]'
    username str
    password String
    publickeys List<String>
    User SSH key(s), as a list. '["ssh-rsa abc...", "ssh-rsa foo..."]'
    username String

    Import

    glesys_server Import

    $ pulumi import glesys:index/server:Server example kvm123456

    To learn more about importing existing cloud resources, see Importing resources.

    Package Details

    Repository
    glesys glesys/terraform-provider-glesys
    License
    Notes
    This Pulumi package is based on the glesys Terraform Provider.
    glesys logo
    glesys 0.14.2 published on Tuesday, Apr 15, 2025 by glesys
    glesys/terraform-provider-glesys