proxmoxve.ContainerLegacy

import * as pulumi from "@pulumi/pulumi";
import * as proxmoxve from "@muhlba91/pulumi-proxmoxve";
import * as random from "@pulumi/random";
import * as std from "@pulumi/std";
import * as tls from "@pulumi/tls";

export = async () => {
    const ubuntu2504LxcImg = new proxmoxve.download.FileLegacy("ubuntu_2504_lxc_img", {
        contentType: "vztmpl",
        datastoreId: "local",
        nodeName: "first-node",
        url: "https://mirrors.servercentral.com/ubuntu-cloud-images/releases/25.04/release/ubuntu-25.04-server-cloudimg-amd64-root.tar.xz",
    });
    const ubuntuContainerPassword = new random.RandomPassword("ubuntu_container_password", {
        length: 16,
        overrideSpecial: "_%@",
        special: true,
    });
    const ubuntuContainerKey = new tls.PrivateKey("ubuntu_container_key", {
        algorithm: "RSA",
        rsaBits: 2048,
    });
    const ubuntuContainer = new proxmoxve.ContainerLegacy("ubuntu_container", {
        description: "Managed by Pulumi",
        nodeName: "first-node",
        vmId: 1234,
        unprivileged: true,
        features: {
            nesting: true,
        },
        initialization: {
            hostname: "terraform-provider-proxmox-ubuntu-container",
            ipConfigs: [{
                ipv4: {
                    address: "dhcp",
                },
            }],
            userAccount: {
                keys: [std.trimspaceOutput({
                    input: ubuntuContainerKey.publicKeyOpenssh,
                }).apply(invoke => invoke.result)],
                password: ubuntuContainerPassword.result,
            },
        },
        networkInterfaces: [{
            name: "veth0",
        }],
        disk: {
            datastoreId: "local-lvm",
            size: 4,
        },
        operatingSystem: {
            templateFileId: ubuntu2504LxcImg.id,
            type: "ubuntu",
        },
        mountPoints: [
            {
                volume: "/mnt/bindmounts/shared",
                path: "/mnt/shared",
            },
            {
                volume: "local-lvm",
                size: "10G",
                path: "/mnt/volume",
            },
            {
                volume: "local-lvm:subvol-108-disk-101",
                size: "10G",
                path: "/mnt/data",
            },
        ],
        startup: {
            order: 3,
            upDelay: 60,
            downDelay: 60,
        },
    });
    return {
        ubuntuContainerPassword: ubuntuContainerPassword.result,
        ubuntuContainerPrivateKey: ubuntuContainerKey.privateKeyPem,
        ubuntuContainerPublicKey: ubuntuContainerKey.publicKeyOpenssh,
    };
}

import pulumi
import pulumi_proxmoxve as proxmoxve
import pulumi_random as random
import pulumi_std as std
import pulumi_tls as tls

ubuntu2504_lxc_img = proxmoxve.download.FileLegacy("ubuntu_2504_lxc_img",
    content_type="vztmpl",
    datastore_id="local",
    node_name="first-node",
    url="https://mirrors.servercentral.com/ubuntu-cloud-images/releases/25.04/release/ubuntu-25.04-server-cloudimg-amd64-root.tar.xz")
ubuntu_container_password = random.RandomPassword("ubuntu_container_password",
    length=16,
    override_special="_%@",
    special=True)
ubuntu_container_key = tls.PrivateKey("ubuntu_container_key",
    algorithm="RSA",
    rsa_bits=2048)
ubuntu_container = proxmoxve.ContainerLegacy("ubuntu_container",
    description="Managed by Pulumi",
    node_name="first-node",
    vm_id=1234,
    unprivileged=True,
    features={
        "nesting": True,
    },
    initialization={
        "hostname": "terraform-provider-proxmox-ubuntu-container",
        "ip_configs": [{
            "ipv4": {
                "address": "dhcp",
            },
        }],
        "user_account": {
            "keys": [std.trimspace_output(input=ubuntu_container_key.public_key_openssh).apply(lambda invoke: invoke.result)],
            "password": ubuntu_container_password.result,
        },
    },
    network_interfaces=[{
        "name": "veth0",
    }],
    disk={
        "datastore_id": "local-lvm",
        "size": 4,
    },
    operating_system={
        "template_file_id": ubuntu2504_lxc_img.id,
        "type": "ubuntu",
    },
    mount_points=[
        {
            "volume": "/mnt/bindmounts/shared",
            "path": "/mnt/shared",
        },
        {
            "volume": "local-lvm",
            "size": "10G",
            "path": "/mnt/volume",
        },
        {
            "volume": "local-lvm:subvol-108-disk-101",
            "size": "10G",
            "path": "/mnt/data",
        },
    ],
    startup={
        "order": 3,
        "up_delay": 60,
        "down_delay": 60,
    })
pulumi.export("ubuntuContainerPassword", ubuntu_container_password.result)
pulumi.export("ubuntuContainerPrivateKey", ubuntu_container_key.private_key_pem)
pulumi.export("ubuntuContainerPublicKey", ubuntu_container_key.public_key_openssh)

package main

import (
	"github.com/muhlba91/pulumi-proxmoxve/sdk/v8/go/proxmoxve"
	"github.com/muhlba91/pulumi-proxmoxve/sdk/v8/go/proxmoxve/download"
	"github.com/pulumi/pulumi-random/sdk/v4/go/random"
	"github.com/pulumi/pulumi-std/sdk/v2/go/std"
	"github.com/pulumi/pulumi-tls/sdk/v5/go/tls"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		ubuntu2504LxcImg, err := download.NewFileLegacy(ctx, "ubuntu_2504_lxc_img", &download.FileLegacyArgs{
			ContentType: pulumi.String("vztmpl"),
			DatastoreId: pulumi.String("local"),
			NodeName:    pulumi.String("first-node"),
			Url:         pulumi.String("https://mirrors.servercentral.com/ubuntu-cloud-images/releases/25.04/release/ubuntu-25.04-server-cloudimg-amd64-root.tar.xz"),
		})
		if err != nil {
			return err
		}
		ubuntuContainerPassword, err := random.NewRandomPassword(ctx, "ubuntu_container_password", &random.RandomPasswordArgs{
			Length:          pulumi.Int(16),
			OverrideSpecial: pulumi.String("_%@"),
			Special:         pulumi.Bool(true),
		})
		if err != nil {
			return err
		}
		ubuntuContainerKey, err := tls.NewPrivateKey(ctx, "ubuntu_container_key", &tls.PrivateKeyArgs{
			Algorithm: pulumi.String("RSA"),
			RsaBits:   pulumi.Int(2048),
		})
		if err != nil {
			return err
		}
		_, err = proxmoxve.NewContainerLegacy(ctx, "ubuntu_container", &proxmoxve.ContainerLegacyArgs{
			Description:  pulumi.String("Managed by Pulumi"),
			NodeName:     pulumi.String("first-node"),
			VmId:         pulumi.Int(1234),
			Unprivileged: pulumi.Bool(true),
			Features: &proxmoxve.ContainerLegacyFeaturesArgs{
				Nesting: pulumi.Bool(true),
			},
			Initialization: &proxmoxve.ContainerLegacyInitializationArgs{
				Hostname: pulumi.String("terraform-provider-proxmox-ubuntu-container"),
				IpConfigs: proxmoxve.ContainerLegacyInitializationIpConfigArray{
					&proxmoxve.ContainerLegacyInitializationIpConfigArgs{
						Ipv4: &proxmoxve.ContainerLegacyInitializationIpConfigIpv4Args{
							Address: pulumi.String("dhcp"),
						},
					},
				},
				UserAccount: &proxmoxve.ContainerLegacyInitializationUserAccountArgs{
					Keys: pulumi.StringArray{
						std.TrimspaceOutput(ctx, std.TrimspaceOutputArgs{
							Input: ubuntuContainerKey.PublicKeyOpenssh,
						}, nil).ApplyT(func(invoke std.TrimspaceResult) (*string, error) {
							val := invoke.Result
							return &val, nil
						}).(pulumi.StringPtrOutput),
					},
					Password: ubuntuContainerPassword.Result,
				},
			},
			NetworkInterfaces: proxmoxve.ContainerLegacyNetworkInterfaceArray{
				&proxmoxve.ContainerLegacyNetworkInterfaceArgs{
					Name: pulumi.String("veth0"),
				},
			},
			Disk: &proxmoxve.ContainerLegacyDiskArgs{
				DatastoreId: pulumi.String("local-lvm"),
				Size:        pulumi.Int(4),
			},
			OperatingSystem: &proxmoxve.ContainerLegacyOperatingSystemArgs{
				TemplateFileId: ubuntu2504LxcImg.ID(),
				Type:           pulumi.String("ubuntu"),
			},
			MountPoints: proxmoxve.ContainerLegacyMountPointArray{
				&proxmoxve.ContainerLegacyMountPointArgs{
					Volume: pulumi.String("/mnt/bindmounts/shared"),
					Path:   pulumi.String("/mnt/shared"),
				},
				&proxmoxve.ContainerLegacyMountPointArgs{
					Volume: pulumi.String("local-lvm"),
					Size:   pulumi.String("10G"),
					Path:   pulumi.String("/mnt/volume"),
				},
				&proxmoxve.ContainerLegacyMountPointArgs{
					Volume: pulumi.String("local-lvm:subvol-108-disk-101"),
					Size:   pulumi.String("10G"),
					Path:   pulumi.String("/mnt/data"),
				},
			},
			Startup: &proxmoxve.ContainerLegacyStartupArgs{
				Order:     pulumi.Int(3),
				UpDelay:   pulumi.Int(60),
				DownDelay: pulumi.Int(60),
			},
		})
		if err != nil {
			return err
		}
		ctx.Export("ubuntuContainerPassword", ubuntuContainerPassword.Result)
		ctx.Export("ubuntuContainerPrivateKey", ubuntuContainerKey.PrivateKeyPem)
		ctx.Export("ubuntuContainerPublicKey", ubuntuContainerKey.PublicKeyOpenssh)
		return nil
	})
}

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using ProxmoxVE = Pulumi.ProxmoxVE;
using Random = Pulumi.Random;
using Std = Pulumi.Std;
using Tls = Pulumi.Tls;

return await Deployment.RunAsync(() => 
{
    var ubuntu2504LxcImg = new ProxmoxVE.Download.FileLegacy("ubuntu_2504_lxc_img", new()
    {
        ContentType = "vztmpl",
        DatastoreId = "local",
        NodeName = "first-node",
        Url = "https://mirrors.servercentral.com/ubuntu-cloud-images/releases/25.04/release/ubuntu-25.04-server-cloudimg-amd64-root.tar.xz",
    });

    var ubuntuContainerPassword = new Random.Index.RandomPassword("ubuntu_container_password", new()
    {
        Length = %!v(PANIC=Format method: fatal: A failure has occurred: unexpected literal type in GenLiteralValueExpression: cty.NumberIntVal(16) (example.pp:74,21-23)),
        OverrideSpecial = "_%@",
        Special = true,
    });

    var ubuntuContainerKey = new Tls.Index.PrivateKey("ubuntu_container_key", new()
    {
        Algorithm = "RSA",
        RsaBits = %!v(PANIC=Format method: fatal: A failure has occurred: unexpected literal type in GenLiteralValueExpression: cty.NumberIntVal(2048) (example.pp:82,19-23)),
    });

    var ubuntuContainer = new ProxmoxVE.Index.ContainerLegacy("ubuntu_container", new()
    {
        Description = "Managed by Pulumi",
        NodeName = "first-node",
        VmId = %!v(PANIC=Format method: fatal: A failure has occurred: unexpected literal type in GenLiteralValueExpression: cty.NumberIntVal(1234) (example.pp:4,19-23)),
        Unprivileged = true,
        Features = new ProxmoxVE.Inputs.ContainerLegacyFeaturesArgs
        {
            Nesting = true,
        },
        Initialization = new ProxmoxVE.Inputs.ContainerLegacyInitializationArgs
        {
            Hostname = "terraform-provider-proxmox-ubuntu-container",
            IpConfigs = new[]
            {
                new ProxmoxVE.Inputs.ContainerLegacyInitializationIpConfigArgs
                {
                    Ipv4 = new ProxmoxVE.Inputs.ContainerLegacyInitializationIpConfigIpv4Args
                    {
                        Address = "dhcp",
                    },
                },
            },
            UserAccount = new ProxmoxVE.Inputs.ContainerLegacyInitializationUserAccountArgs
            {
                Keys = new[]
                {
                    Std.Index.Trimspace.Invoke(new()
                    {
                        Input = ubuntuContainerKey.PublicKeyOpenssh,
                    }).Apply(invoke => invoke.Result),
                },
                Password = ubuntuContainerPassword.Result,
            },
        },
        NetworkInterfaces = new[]
        {
            new ProxmoxVE.Inputs.ContainerLegacyNetworkInterfaceArgs
            {
                Name = "veth0",
            },
        },
        Disk = new ProxmoxVE.Inputs.ContainerLegacyDiskArgs
        {
            DatastoreId = "local-lvm",
            Size = %!v(PANIC=Format method: fatal: A failure has occurred: unexpected literal type in GenLiteralValueExpression: cty.NumberIntVal(4) (example.pp:31,19-20)),
        },
        OperatingSystem = new ProxmoxVE.Inputs.ContainerLegacyOperatingSystemArgs
        {
            TemplateFileId = ubuntu2504LxcImg.Id,
            Type = "ubuntu",
        },
        MountPoints = new[]
        {
            new ProxmoxVE.Inputs.ContainerLegacyMountPointArgs
            {
                Volume = "/mnt/bindmounts/shared",
                Path = "/mnt/shared",
            },
            new ProxmoxVE.Inputs.ContainerLegacyMountPointArgs
            {
                Volume = "local-lvm",
                Size = "10G",
                Path = "/mnt/volume",
            },
            new ProxmoxVE.Inputs.ContainerLegacyMountPointArgs
            {
                Volume = "local-lvm:subvol-108-disk-101",
                Size = "10G",
                Path = "/mnt/data",
            },
        },
        Startup = new ProxmoxVE.Inputs.ContainerLegacyStartupArgs
        {
            Order = %!v(PANIC=Format method: fatal: A failure has occurred: unexpected literal type in GenLiteralValueExpression: cty.NumberIntVal(3) (:0,0-0)),
            UpDelay = %!v(PANIC=Format method: fatal: A failure has occurred: unexpected literal type in GenLiteralValueExpression: cty.NumberIntVal(60) (:0,0-0)),
            DownDelay = %!v(PANIC=Format method: fatal: A failure has occurred: unexpected literal type in GenLiteralValueExpression: cty.NumberIntVal(60) (:0,0-0)),
        },
    });

    return new Dictionary<string, object?>
    {
        ["ubuntuContainerPassword"] = ubuntuContainerPassword.Result,
        ["ubuntuContainerPrivateKey"] = ubuntuContainerKey.PrivateKeyPem,
        ["ubuntuContainerPublicKey"] = ubuntuContainerKey.PublicKeyOpenssh,
    };
});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import io.muehlbachler.pulumi.proxmoxve.download.FileLegacy;
import io.muehlbachler.pulumi.proxmoxve.download.FileLegacyArgs;
import com.pulumi.random.RandomPassword;
import com.pulumi.random.RandomPasswordArgs;
import com.pulumi.tls.PrivateKey;
import com.pulumi.tls.PrivateKeyArgs;
import io.muehlbachler.pulumi.proxmoxve.ContainerLegacy;
import io.muehlbachler.pulumi.proxmoxve.ContainerLegacyArgs;
import com.pulumi.proxmoxve.inputs.ContainerLegacyFeaturesArgs;
import com.pulumi.proxmoxve.inputs.ContainerLegacyInitializationArgs;
import com.pulumi.proxmoxve.inputs.ContainerLegacyInitializationUserAccountArgs;
import com.pulumi.proxmoxve.inputs.ContainerLegacyNetworkInterfaceArgs;
import com.pulumi.proxmoxve.inputs.ContainerLegacyDiskArgs;
import com.pulumi.proxmoxve.inputs.ContainerLegacyOperatingSystemArgs;
import com.pulumi.proxmoxve.inputs.ContainerLegacyMountPointArgs;
import com.pulumi.proxmoxve.inputs.ContainerLegacyStartupArgs;
import com.pulumi.std.StdFunctions;
import com.pulumi.std.inputs.TrimspaceArgs;
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 ubuntu2504LxcImg = new FileLegacy("ubuntu2504LxcImg", FileLegacyArgs.builder()
            .contentType("vztmpl")
            .datastoreId("local")
            .nodeName("first-node")
            .url("https://mirrors.servercentral.com/ubuntu-cloud-images/releases/25.04/release/ubuntu-25.04-server-cloudimg-amd64-root.tar.xz")
            .build());

        var ubuntuContainerPassword = new RandomPassword("ubuntuContainerPassword", RandomPasswordArgs.builder()
            .length(%!v(PANIC=Format method: fatal: A failure has occurred: unexpected literal type in GenLiteralValueExpression: cty.NumberIntVal(16) (example.pp:74,21-23)))
            .overrideSpecial("_%@")
            .special(true)
            .build());

        var ubuntuContainerKey = new PrivateKey("ubuntuContainerKey", PrivateKeyArgs.builder()
            .algorithm("RSA")
            .rsaBits(%!v(PANIC=Format method: fatal: A failure has occurred: unexpected literal type in GenLiteralValueExpression: cty.NumberIntVal(2048) (example.pp:82,19-23)))
            .build());

        var ubuntuContainer = new ContainerLegacy("ubuntuContainer", ContainerLegacyArgs.builder()
            .description("Managed by Pulumi")
            .nodeName("first-node")
            .vmId(%!v(PANIC=Format method: fatal: A failure has occurred: unexpected literal type in GenLiteralValueExpression: cty.NumberIntVal(1234) (example.pp:4,19-23)))
            .unprivileged(true)
            .features(ContainerLegacyFeaturesArgs.builder()
                .nesting(true)
                .build())
            .initialization(ContainerLegacyInitializationArgs.builder()
                .hostname("terraform-provider-proxmox-ubuntu-container")
                .ipConfigs(ContainerLegacyInitializationIpConfigArgs.builder()
                    .ipv4(ContainerLegacyInitializationIpConfigIpv4Args.builder()
                        .address("dhcp")
                        .build())
                    .build())
                .userAccount(ContainerLegacyInitializationUserAccountArgs.builder()
                    .keys(StdFunctions.trimspace(TrimspaceArgs.builder()
                        .input(ubuntuContainerKey.publicKeyOpenssh())
                        .build()).applyValue(_invoke -> _invoke.result()))
                    .password(ubuntuContainerPassword.result())
                    .build())
                .build())
            .networkInterfaces(ContainerLegacyNetworkInterfaceArgs.builder()
                .name("veth0")
                .build())
            .disk(ContainerLegacyDiskArgs.builder()
                .datastoreId("local-lvm")
                .size(%!v(PANIC=Format method: fatal: A failure has occurred: unexpected literal type in GenLiteralValueExpression: cty.NumberIntVal(4) (example.pp:31,19-20)))
                .build())
            .operatingSystem(ContainerLegacyOperatingSystemArgs.builder()
                .templateFileId(ubuntu2504LxcImg.id())
                .type("ubuntu")
                .build())
            .mountPoints(            
                ContainerLegacyMountPointArgs.builder()
                    .volume("/mnt/bindmounts/shared")
                    .path("/mnt/shared")
                    .build(),
                ContainerLegacyMountPointArgs.builder()
                    .volume("local-lvm")
                    .size("10G")
                    .path("/mnt/volume")
                    .build(),
                ContainerLegacyMountPointArgs.builder()
                    .volume("local-lvm:subvol-108-disk-101")
                    .size("10G")
                    .path("/mnt/data")
                    .build())
            .startup(ContainerLegacyStartupArgs.builder()
                .order(%!v(PANIC=Format method: fatal: A failure has occurred: unexpected literal type in GenLiteralValueExpression: cty.NumberIntVal(3) (:0,0-0)))
                .upDelay(%!v(PANIC=Format method: fatal: A failure has occurred: unexpected literal type in GenLiteralValueExpression: cty.NumberIntVal(60) (:0,0-0)))
                .downDelay(%!v(PANIC=Format method: fatal: A failure has occurred: unexpected literal type in GenLiteralValueExpression: cty.NumberIntVal(60) (:0,0-0)))
                .build())
            .build());

        ctx.export("ubuntuContainerPassword", ubuntuContainerPassword.result());
        ctx.export("ubuntuContainerPrivateKey", ubuntuContainerKey.privateKeyPem());
        ctx.export("ubuntuContainerPublicKey", ubuntuContainerKey.publicKeyOpenssh());
    }
}

resources:
  ubuntuContainer:
    type: proxmoxve:ContainerLegacy
    name: ubuntu_container
    properties:
      description: Managed by Pulumi
      nodeName: first-node
      vmId: 1234 # newer linux distributions require unprivileged user namespaces
      unprivileged: true
      features:
        nesting: true
      initialization:
        hostname: terraform-provider-proxmox-ubuntu-container
        ipConfigs:
          - ipv4:
              address: dhcp
        userAccount:
          keys:
            - fn::invoke:
                function: std:trimspace
                arguments:
                  input: ${ubuntuContainerKey.publicKeyOpenssh}
                return: result
          password: ${ubuntuContainerPassword.result}
      networkInterfaces:
        - name: veth0
      disk:
        datastoreId: local-lvm
        size: 4
      operatingSystem:
        templateFileId: ${ubuntu2504LxcImg.id}
        type: ubuntu
      mountPoints:
        - volume: /mnt/bindmounts/shared
          path: /mnt/shared
        - volume: local-lvm
          size: 10G
          path: /mnt/volume
        - volume: local-lvm:subvol-108-disk-101
          size: 10G
          path: /mnt/data
      startup:
        order: '3'
        upDelay: '60'
        downDelay: '60'
  ubuntu2504LxcImg:
    type: proxmoxve:download:FileLegacy
    name: ubuntu_2504_lxc_img
    properties:
      contentType: vztmpl
      datastoreId: local
      nodeName: first-node
      url: https://mirrors.servercentral.com/ubuntu-cloud-images/releases/25.04/release/ubuntu-25.04-server-cloudimg-amd64-root.tar.xz
  ubuntuContainerPassword:
    type: random:RandomPassword
    name: ubuntu_container_password
    properties:
      length: 16
      overrideSpecial: _%@
      special: true
  ubuntuContainerKey:
    type: tls:PrivateKey
    name: ubuntu_container_key
    properties:
      algorithm: RSA
      rsaBits: 2048
outputs:
  ubuntuContainerPassword: ${ubuntuContainerPassword.result}
  ubuntuContainerPrivateKey: ${ubuntuContainerKey.privateKeyPem}
  ubuntuContainerPublicKey: ${ubuntuContainerKey.publicKeyOpenssh}