proxmoxve.Sdn.Subnet

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

const finalizer = new proxmoxve.sdn.Applier("finalizer", {});
// SDN Zone (Simple) - Basic zone for simple vnets
const exampleZone1 = new proxmoxve.sdnzone.Simple("example_zone_1", {
    zoneId: "zone1",
    nodes: ["pve"],
    mtu: 1500,
    dns: "1.1.1.1",
    dnsZone: "example.com",
    ipam: "pve",
    reverseDns: "1.1.1.1",
}, {
    dependsOn: [finalizer],
});
// SDN Zone (Simple) - Second zone for demonstration
const exampleZone2 = new proxmoxve.sdnzone.Simple("example_zone_2", {
    zoneId: "zone2",
    nodes: ["pve"],
    mtu: 1500,
}, {
    dependsOn: [finalizer],
});
// SDN VNet - Basic vnet
const exampleVnet1 = new proxmoxve.sdn.Vnet("example_vnet_1", {
    vnetId: "vnet1",
    zone: exampleZone1.zoneId,
}, {
    dependsOn: [finalizer],
});
// SDN VNet - VNet with alias and port isolation
const exampleVnet2 = new proxmoxve.sdn.Vnet("example_vnet_2", {
    vnetId: "vnet2",
    zone: exampleZone2.zoneId,
    alias: "Example VNet 2",
    isolatePorts: true,
    vlanAware: false,
}, {
    dependsOn: [finalizer],
});
// Basic Subnet
const basicSubnet = new proxmoxve.sdn.Subnet("basic_subnet", {
    cidr: "192.168.1.0/24",
    vnet: exampleVnet1.vnetId,
    gateway: "192.168.1.1",
}, {
    dependsOn: [finalizer],
});
// Subnet with DHCP Configuration
const dhcpSubnet = new proxmoxve.sdn.Subnet("dhcp_subnet", {
    cidr: "192.168.2.0/24",
    vnet: exampleVnet2.vnetId,
    gateway: "192.168.2.1",
    dhcpDnsServer: "192.168.2.53",
    dnsZonePrefix: "internal.example.com",
    snat: true,
    dhcpRange: {
        startAddress: "192.168.2.10",
        endAddress: "192.168.2.100",
    },
}, {
    dependsOn: [finalizer],
});
// SDN Applier for all resources
const subnetApplier = new proxmoxve.sdn.Applier("subnet_applier", {}, {
    dependsOn: [
        exampleZone1,
        exampleZone2,
        exampleVnet1,
        exampleVnet2,
        basicSubnet,
        dhcpSubnet,
    ],
});

import pulumi
import pulumi_proxmoxve as proxmoxve

finalizer = proxmoxve.sdn.Applier("finalizer")
# SDN Zone (Simple) - Basic zone for simple vnets
example_zone1 = proxmoxve.sdnzone.Simple("example_zone_1",
    zone_id="zone1",
    nodes=["pve"],
    mtu=1500,
    dns="1.1.1.1",
    dns_zone="example.com",
    ipam="pve",
    reverse_dns="1.1.1.1",
    opts = pulumi.ResourceOptions(depends_on=[finalizer]))
# SDN Zone (Simple) - Second zone for demonstration
example_zone2 = proxmoxve.sdnzone.Simple("example_zone_2",
    zone_id="zone2",
    nodes=["pve"],
    mtu=1500,
    opts = pulumi.ResourceOptions(depends_on=[finalizer]))
# SDN VNet - Basic vnet
example_vnet1 = proxmoxve.sdn.Vnet("example_vnet_1",
    vnet_id="vnet1",
    zone=example_zone1.zone_id,
    opts = pulumi.ResourceOptions(depends_on=[finalizer]))
# SDN VNet - VNet with alias and port isolation
example_vnet2 = proxmoxve.sdn.Vnet("example_vnet_2",
    vnet_id="vnet2",
    zone=example_zone2.zone_id,
    alias="Example VNet 2",
    isolate_ports=True,
    vlan_aware=False,
    opts = pulumi.ResourceOptions(depends_on=[finalizer]))
# Basic Subnet
basic_subnet = proxmoxve.sdn.Subnet("basic_subnet",
    cidr="192.168.1.0/24",
    vnet=example_vnet1.vnet_id,
    gateway="192.168.1.1",
    opts = pulumi.ResourceOptions(depends_on=[finalizer]))
# Subnet with DHCP Configuration
dhcp_subnet = proxmoxve.sdn.Subnet("dhcp_subnet",
    cidr="192.168.2.0/24",
    vnet=example_vnet2.vnet_id,
    gateway="192.168.2.1",
    dhcp_dns_server="192.168.2.53",
    dns_zone_prefix="internal.example.com",
    snat=True,
    dhcp_range={
        "start_address": "192.168.2.10",
        "end_address": "192.168.2.100",
    },
    opts = pulumi.ResourceOptions(depends_on=[finalizer]))
# SDN Applier for all resources
subnet_applier = proxmoxve.sdn.Applier("subnet_applier", opts = pulumi.ResourceOptions(depends_on=[
        example_zone1,
        example_zone2,
        example_vnet1,
        example_vnet2,
        basic_subnet,
        dhcp_subnet,
    ]))

package main

import (
	"github.com/muhlba91/pulumi-proxmoxve/sdk/v7/go/proxmoxve/sdn"
	"github.com/muhlba91/pulumi-proxmoxve/sdk/v7/go/proxmoxve/sdnzone"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		finalizer, err := sdn.NewApplier(ctx, "finalizer", nil)
		if err != nil {
			return err
		}
		// SDN Zone (Simple) - Basic zone for simple vnets
		exampleZone1, err := sdnzone.NewSimple(ctx, "example_zone_1", &sdnzone.SimpleArgs{
			ZoneId: pulumi.String("zone1"),
			Nodes: pulumi.StringArray{
				pulumi.String("pve"),
			},
			Mtu:        pulumi.Int(1500),
			Dns:        pulumi.String("1.1.1.1"),
			DnsZone:    pulumi.String("example.com"),
			Ipam:       pulumi.String("pve"),
			ReverseDns: pulumi.String("1.1.1.1"),
		}, pulumi.DependsOn([]pulumi.Resource{
			finalizer,
		}))
		if err != nil {
			return err
		}
		// SDN Zone (Simple) - Second zone for demonstration
		exampleZone2, err := sdnzone.NewSimple(ctx, "example_zone_2", &sdnzone.SimpleArgs{
			ZoneId: pulumi.String("zone2"),
			Nodes: pulumi.StringArray{
				pulumi.String("pve"),
			},
			Mtu: pulumi.Int(1500),
		}, pulumi.DependsOn([]pulumi.Resource{
			finalizer,
		}))
		if err != nil {
			return err
		}
		// SDN VNet - Basic vnet
		exampleVnet1, err := sdn.NewVnet(ctx, "example_vnet_1", &sdn.VnetArgs{
			VnetId: pulumi.String("vnet1"),
			Zone:   exampleZone1.ZoneId,
		}, pulumi.DependsOn([]pulumi.Resource{
			finalizer,
		}))
		if err != nil {
			return err
		}
		// SDN VNet - VNet with alias and port isolation
		exampleVnet2, err := sdn.NewVnet(ctx, "example_vnet_2", &sdn.VnetArgs{
			VnetId:       pulumi.String("vnet2"),
			Zone:         exampleZone2.ZoneId,
			Alias:        pulumi.String("Example VNet 2"),
			IsolatePorts: pulumi.Bool(true),
			VlanAware:    pulumi.Bool(false),
		}, pulumi.DependsOn([]pulumi.Resource{
			finalizer,
		}))
		if err != nil {
			return err
		}
		// Basic Subnet
		basicSubnet, err := sdn.NewSubnet(ctx, "basic_subnet", &sdn.SubnetArgs{
			Cidr:    pulumi.String("192.168.1.0/24"),
			Vnet:    exampleVnet1.VnetId,
			Gateway: pulumi.String("192.168.1.1"),
		}, pulumi.DependsOn([]pulumi.Resource{
			finalizer,
		}))
		if err != nil {
			return err
		}
		// Subnet with DHCP Configuration
		dhcpSubnet, err := sdn.NewSubnet(ctx, "dhcp_subnet", &sdn.SubnetArgs{
			Cidr:          pulumi.String("192.168.2.0/24"),
			Vnet:          exampleVnet2.VnetId,
			Gateway:       pulumi.String("192.168.2.1"),
			DhcpDnsServer: pulumi.String("192.168.2.53"),
			DnsZonePrefix: pulumi.String("internal.example.com"),
			Snat:          pulumi.Bool(true),
			DhcpRange: &sdn.SubnetDhcpRangeArgs{
				StartAddress: pulumi.String("192.168.2.10"),
				EndAddress:   pulumi.String("192.168.2.100"),
			},
		}, pulumi.DependsOn([]pulumi.Resource{
			finalizer,
		}))
		if err != nil {
			return err
		}
		// SDN Applier for all resources
		_, err = sdn.NewApplier(ctx, "subnet_applier", nil, pulumi.DependsOn([]pulumi.Resource{
			exampleZone1,
			exampleZone2,
			exampleVnet1,
			exampleVnet2,
			basicSubnet,
			dhcpSubnet,
		}))
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var finalizer = new ProxmoxVE.Sdn.Applier("finalizer");

    // SDN Zone (Simple) - Basic zone for simple vnets
    var exampleZone1 = new ProxmoxVE.SDNZone.Simple("example_zone_1", new()
    {
        ZoneId = "zone1",
        Nodes = new[]
        {
            "pve",
        },
        Mtu = 1500,
        Dns = "1.1.1.1",
        DnsZone = "example.com",
        Ipam = "pve",
        ReverseDns = "1.1.1.1",
    }, new CustomResourceOptions
    {
        DependsOn =
        {
            finalizer,
        },
    });

    // SDN Zone (Simple) - Second zone for demonstration
    var exampleZone2 = new ProxmoxVE.SDNZone.Simple("example_zone_2", new()
    {
        ZoneId = "zone2",
        Nodes = new[]
        {
            "pve",
        },
        Mtu = 1500,
    }, new CustomResourceOptions
    {
        DependsOn =
        {
            finalizer,
        },
    });

    // SDN VNet - Basic vnet
    var exampleVnet1 = new ProxmoxVE.Sdn.Vnet("example_vnet_1", new()
    {
        VnetId = "vnet1",
        Zone = exampleZone1.ZoneId,
    }, new CustomResourceOptions
    {
        DependsOn =
        {
            finalizer,
        },
    });

    // SDN VNet - VNet with alias and port isolation
    var exampleVnet2 = new ProxmoxVE.Sdn.Vnet("example_vnet_2", new()
    {
        VnetId = "vnet2",
        Zone = exampleZone2.ZoneId,
        Alias = "Example VNet 2",
        IsolatePorts = true,
        VlanAware = false,
    }, new CustomResourceOptions
    {
        DependsOn =
        {
            finalizer,
        },
    });

    // Basic Subnet
    var basicSubnet = new ProxmoxVE.Sdn.Subnet("basic_subnet", new()
    {
        Cidr = "192.168.1.0/24",
        Vnet = exampleVnet1.VnetId,
        Gateway = "192.168.1.1",
    }, new CustomResourceOptions
    {
        DependsOn =
        {
            finalizer,
        },
    });

    // Subnet with DHCP Configuration
    var dhcpSubnet = new ProxmoxVE.Sdn.Subnet("dhcp_subnet", new()
    {
        Cidr = "192.168.2.0/24",
        Vnet = exampleVnet2.VnetId,
        Gateway = "192.168.2.1",
        DhcpDnsServer = "192.168.2.53",
        DnsZonePrefix = "internal.example.com",
        Snat = true,
        DhcpRange = new ProxmoxVE.Sdn.Inputs.SubnetDhcpRangeArgs
        {
            StartAddress = "192.168.2.10",
            EndAddress = "192.168.2.100",
        },
    }, new CustomResourceOptions
    {
        DependsOn =
        {
            finalizer,
        },
    });

    // SDN Applier for all resources
    var subnetApplier = new ProxmoxVE.Sdn.Applier("subnet_applier", new()
    {
    }, new CustomResourceOptions
    {
        DependsOn =
        {
            exampleZone1,
            exampleZone2,
            exampleVnet1,
            exampleVnet2,
            basicSubnet,
            dhcpSubnet,
        },
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import io.muehlbachler.pulumi.proxmoxve.Sdn.Applier;
import io.muehlbachler.pulumi.proxmoxve.SDNZone.Simple;
import io.muehlbachler.pulumi.proxmoxve.SDNZone.SimpleArgs;
import io.muehlbachler.pulumi.proxmoxve.Sdn.Vnet;
import io.muehlbachler.pulumi.proxmoxve.Sdn.VnetArgs;
import io.muehlbachler.pulumi.proxmoxve.Sdn.Subnet;
import io.muehlbachler.pulumi.proxmoxve.Sdn.SubnetArgs;
import com.pulumi.proxmoxve.Sdn.inputs.SubnetDhcpRangeArgs;
import io.muehlbachler.pulumi.proxmoxve.Sdn.ApplierArgs;
import com.pulumi.resources.CustomResourceOptions;
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 finalizer = new Applier("finalizer");

        // SDN Zone (Simple) - Basic zone for simple vnets
        var exampleZone1 = new Simple("exampleZone1", SimpleArgs.builder()
            .zoneId("zone1")
            .nodes("pve")
            .mtu(1500)
            .dns("1.1.1.1")
            .dnsZone("example.com")
            .ipam("pve")
            .reverseDns("1.1.1.1")
            .build(), CustomResourceOptions.builder()
                .dependsOn(finalizer)
                .build());

        // SDN Zone (Simple) - Second zone for demonstration
        var exampleZone2 = new Simple("exampleZone2", SimpleArgs.builder()
            .zoneId("zone2")
            .nodes("pve")
            .mtu(1500)
            .build(), CustomResourceOptions.builder()
                .dependsOn(finalizer)
                .build());

        // SDN VNet - Basic vnet
        var exampleVnet1 = new Vnet("exampleVnet1", VnetArgs.builder()
            .vnetId("vnet1")
            .zone(exampleZone1.zoneId())
            .build(), CustomResourceOptions.builder()
                .dependsOn(finalizer)
                .build());

        // SDN VNet - VNet with alias and port isolation
        var exampleVnet2 = new Vnet("exampleVnet2", VnetArgs.builder()
            .vnetId("vnet2")
            .zone(exampleZone2.zoneId())
            .alias("Example VNet 2")
            .isolatePorts(true)
            .vlanAware(false)
            .build(), CustomResourceOptions.builder()
                .dependsOn(finalizer)
                .build());

        // Basic Subnet
        var basicSubnet = new Subnet("basicSubnet", SubnetArgs.builder()
            .cidr("192.168.1.0/24")
            .vnet(exampleVnet1.vnetId())
            .gateway("192.168.1.1")
            .build(), CustomResourceOptions.builder()
                .dependsOn(finalizer)
                .build());

        // Subnet with DHCP Configuration
        var dhcpSubnet = new Subnet("dhcpSubnet", SubnetArgs.builder()
            .cidr("192.168.2.0/24")
            .vnet(exampleVnet2.vnetId())
            .gateway("192.168.2.1")
            .dhcpDnsServer("192.168.2.53")
            .dnsZonePrefix("internal.example.com")
            .snat(true)
            .dhcpRange(SubnetDhcpRangeArgs.builder()
                .startAddress("192.168.2.10")
                .endAddress("192.168.2.100")
                .build())
            .build(), CustomResourceOptions.builder()
                .dependsOn(finalizer)
                .build());

        // SDN Applier for all resources
        var subnetApplier = new Applier("subnetApplier", ApplierArgs.Empty, CustomResourceOptions.builder()
            .dependsOn(            
                exampleZone1,
                exampleZone2,
                exampleVnet1,
                exampleVnet2,
                basicSubnet,
                dhcpSubnet)
            .build());

    }
}

resources:
  # SDN Zone (Simple) - Basic zone for simple vnets
  exampleZone1:
    type: proxmoxve:SDNZone:Simple
    name: example_zone_1
    properties:
      zoneId: zone1
      nodes:
        - pve
      mtu: 1500 # Optional attributes
      dns: 1.1.1.1
      dnsZone: example.com
      ipam: pve
      reverseDns: 1.1.1.1
    options:
      dependsOn:
        - ${finalizer}
  # SDN Zone (Simple) - Second zone for demonstration
  exampleZone2:
    type: proxmoxve:SDNZone:Simple
    name: example_zone_2
    properties:
      zoneId: zone2
      nodes:
        - pve
      mtu: 1500
    options:
      dependsOn:
        - ${finalizer}
  # SDN VNet - Basic vnet
  exampleVnet1:
    type: proxmoxve:Sdn:Vnet
    name: example_vnet_1
    properties:
      vnetId: vnet1
      zone: ${exampleZone1.zoneId}
    options:
      dependsOn:
        - ${finalizer}
  # SDN VNet - VNet with alias and port isolation
  exampleVnet2:
    type: proxmoxve:Sdn:Vnet
    name: example_vnet_2
    properties:
      vnetId: vnet2
      zone: ${exampleZone2.zoneId}
      alias: Example VNet 2
      isolatePorts: true
      vlanAware: false
    options:
      dependsOn:
        - ${finalizer}
  # Basic Subnet
  basicSubnet:
    type: proxmoxve:Sdn:Subnet
    name: basic_subnet
    properties:
      cidr: 192.168.1.0/24
      vnet: ${exampleVnet1.vnetId}
      gateway: 192.168.1.1
    options:
      dependsOn:
        - ${finalizer}
  # Subnet with DHCP Configuration
  dhcpSubnet:
    type: proxmoxve:Sdn:Subnet
    name: dhcp_subnet
    properties:
      cidr: 192.168.2.0/24
      vnet: ${exampleVnet2.vnetId}
      gateway: 192.168.2.1
      dhcpDnsServer: 192.168.2.53
      dnsZonePrefix: internal.example.com
      snat: true
      dhcpRange:
        startAddress: 192.168.2.10
        endAddress: 192.168.2.100
    options:
      dependsOn:
        - ${finalizer}
  # SDN Applier for all resources
  subnetApplier:
    type: proxmoxve:Sdn:Applier
    name: subnet_applier
    options:
      dependsOn:
        - ${exampleZone1}
        - ${exampleZone2}
        - ${exampleVnet1}
        - ${exampleVnet2}
        - ${basicSubnet}
        - ${dhcpSubnet}
  finalizer:
    type: proxmoxve:Sdn:Applier

var subnetResource = new ProxmoxVE.Sdn.Subnet("subnetResource", new()
{
    Cidr = "string",
    Vnet = "string",
    DhcpDnsServer = "string",
    DhcpRange = new ProxmoxVE.Sdn.Inputs.SubnetDhcpRangeArgs
    {
        EndAddress = "string",
        StartAddress = "string",
    },
    DnsZonePrefix = "string",
    Gateway = "string",
    Snat = false,
});

example, err := sdn.NewSubnet(ctx, "subnetResource", &sdn.SubnetArgs{
	Cidr:          pulumi.String("string"),
	Vnet:          pulumi.String("string"),
	DhcpDnsServer: pulumi.String("string"),
	DhcpRange: &sdn.SubnetDhcpRangeArgs{
		EndAddress:   pulumi.String("string"),
		StartAddress: pulumi.String("string"),
	},
	DnsZonePrefix: pulumi.String("string"),
	Gateway:       pulumi.String("string"),
	Snat:          pulumi.Bool(false),
})

var subnetResource = new Subnet("subnetResource", SubnetArgs.builder()
    .cidr("string")
    .vnet("string")
    .dhcpDnsServer("string")
    .dhcpRange(SubnetDhcpRangeArgs.builder()
        .endAddress("string")
        .startAddress("string")
        .build())
    .dnsZonePrefix("string")
    .gateway("string")
    .snat(false)
    .build());

subnet_resource = proxmoxve.sdn.Subnet("subnetResource",
    cidr="string",
    vnet="string",
    dhcp_dns_server="string",
    dhcp_range={
        "end_address": "string",
        "start_address": "string",
    },
    dns_zone_prefix="string",
    gateway="string",
    snat=False)

const subnetResource = new proxmoxve.sdn.Subnet("subnetResource", {
    cidr: "string",
    vnet: "string",
    dhcpDnsServer: "string",
    dhcpRange: {
        endAddress: "string",
        startAddress: "string",
    },
    dnsZonePrefix: "string",
    gateway: "string",
    snat: false,
});

type: proxmoxve:Sdn:Subnet
properties:
    cidr: string
    dhcpDnsServer: string
    dhcpRange:
        endAddress: string
        startAddress: string
    dnsZonePrefix: string
    gateway: string
    snat: false
    vnet: string