nsxt.getPolicyEdgeTransportNodeRealization

Explore with Pulumi AI

nsxt 3.10.0 published on Wednesday, Sep 10, 2025 by vmware

This data source provides information about the realization of a Policy Edge transport node resource on NSX manager. This data source will wait until realization is determined as either success or error. It is recommended to use this data source if further configuration depends on Policy Edge transport node realization. The data source will fail the plan when the Edge transport node deployment fails.

Example Usage

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

const test = new nsxt.PolicyEdgeTransportNode("test", {
    displayName: "test-edge-appliance",
    description: "Terraform deployed Edge appliance",
    applianceConfig: {
        allowSshRootLogin: true,
        enableSsh: true,
    },
    credentials: {
        cliPassword: _var.CLI_PASSWORD,
        rootPassword: _var.ROOT_PASSWORD,
    },
    formFactor: "SMALL",
    hostname: "test-edge",
    managementInterface: {
        ipAssignments: [
            {
                dhcpV4: true,
            },
            {
                staticIpv6: {
                    defaultGateway: "2001:0000:130F:0000:0000:09C0:876A:1",
                    managementPortSubnet: {
                        ipAddresses: ["2001:0000:130F:0000:0000:09C0:876A:130B"],
                        prefixLength: 64,
                    },
                },
            },
        ],
        networkId: data.vsphere_network.mgt_network.id,
    },
    switches: [{
        overlayTransportZonePath: data.nsxt_policy_transport_zone.overlay_tz.path,
        pnics: [{
            deviceName: "fp-eth0",
            uplinkName: "uplink1",
        }],
        uplinkHostSwitchProfilePath: data.nsxt_policy_uplink_host_switch_profile.uplink_host_switch_profile.path,
        tunnelEndpoint: {
            ipAssignment: {
                dhcpV4: true,
            },
        },
        vlanTransportZonePaths: [data.nsxt_policy_transport_zone.vlan_tz.path],
    }],
    vmDeploymentConfig: {
        computeId: data.vsphere_compute_cluster.edge_cluster.id,
        storageId: data.vsphere_datastore.datastore.id,
        computeManagerId: data.nsxt_compute_manager.vc.id,
        hostId: data.vsphere_host.host.id,
    },
});
const info = nsxt.getPolicyEdgeTransportNodeRealizationOutput({
    path: test.path,
    timeout: 1200,
});

import pulumi
import pulumi_nsxt as nsxt

test = nsxt.PolicyEdgeTransportNode("test",
    display_name="test-edge-appliance",
    description="Terraform deployed Edge appliance",
    appliance_config={
        "allow_ssh_root_login": True,
        "enable_ssh": True,
    },
    credentials={
        "cli_password": var["CLI_PASSWORD"],
        "root_password": var["ROOT_PASSWORD"],
    },
    form_factor="SMALL",
    hostname="test-edge",
    management_interface={
        "ip_assignments": [
            {
                "dhcp_v4": True,
            },
            {
                "static_ipv6": {
                    "default_gateway": "2001:0000:130F:0000:0000:09C0:876A:1",
                    "management_port_subnet": {
                        "ip_addresses": ["2001:0000:130F:0000:0000:09C0:876A:130B"],
                        "prefix_length": 64,
                    },
                },
            },
        ],
        "network_id": data["vsphere_network"]["mgt_network"]["id"],
    },
    switches=[{
        "overlay_transport_zone_path": data["nsxt_policy_transport_zone"]["overlay_tz"]["path"],
        "pnics": [{
            "device_name": "fp-eth0",
            "uplink_name": "uplink1",
        }],
        "uplink_host_switch_profile_path": data["nsxt_policy_uplink_host_switch_profile"]["uplink_host_switch_profile"]["path"],
        "tunnel_endpoint": {
            "ip_assignment": {
                "dhcp_v4": True,
            },
        },
        "vlan_transport_zone_paths": [data["nsxt_policy_transport_zone"]["vlan_tz"]["path"]],
    }],
    vm_deployment_config={
        "compute_id": data["vsphere_compute_cluster"]["edge_cluster"]["id"],
        "storage_id": data["vsphere_datastore"]["datastore"]["id"],
        "compute_manager_id": data["nsxt_compute_manager"]["vc"]["id"],
        "host_id": data["vsphere_host"]["host"]["id"],
    })
info = nsxt.get_policy_edge_transport_node_realization_output(path=test.path,
    timeout=1200)

package main

import (
	"github.com/pulumi/pulumi-terraform-provider/sdks/go/nsxt/v3/nsxt"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		test, err := nsxt.NewPolicyEdgeTransportNode(ctx, "test", &nsxt.PolicyEdgeTransportNodeArgs{
			DisplayName: pulumi.String("test-edge-appliance"),
			Description: pulumi.String("Terraform deployed Edge appliance"),
			ApplianceConfig: &nsxt.PolicyEdgeTransportNodeApplianceConfigArgs{
				AllowSshRootLogin: pulumi.Bool(true),
				EnableSsh:         pulumi.Bool(true),
			},
			Credentials: &nsxt.PolicyEdgeTransportNodeCredentialsArgs{
				CliPassword:  pulumi.Any(_var.CLI_PASSWORD),
				RootPassword: pulumi.Any(_var.ROOT_PASSWORD),
			},
			FormFactor: pulumi.String("SMALL"),
			Hostname:   pulumi.String("test-edge"),
			ManagementInterface: &nsxt.PolicyEdgeTransportNodeManagementInterfaceArgs{
				IpAssignments: nsxt.PolicyEdgeTransportNodeManagementInterfaceIpAssignmentArray{
					&nsxt.PolicyEdgeTransportNodeManagementInterfaceIpAssignmentArgs{
						DhcpV4: pulumi.Bool(true),
					},
					&nsxt.PolicyEdgeTransportNodeManagementInterfaceIpAssignmentArgs{
						StaticIpv6: &nsxt.PolicyEdgeTransportNodeManagementInterfaceIpAssignmentStaticIpv6Args{
							DefaultGateway: pulumi.String("2001:0000:130F:0000:0000:09C0:876A:1"),
							ManagementPortSubnet: &nsxt.PolicyEdgeTransportNodeManagementInterfaceIpAssignmentStaticIpv6ManagementPortSubnetArgs{
								IpAddresses: pulumi.StringArray{
									pulumi.String("2001:0000:130F:0000:0000:09C0:876A:130B"),
								},
								PrefixLength: pulumi.Float64(64),
							},
						},
					},
				},
				NetworkId: pulumi.Any(data.Vsphere_network.Mgt_network.Id),
			},
			Switches: nsxt.PolicyEdgeTransportNodeSwitchArray{
				&nsxt.PolicyEdgeTransportNodeSwitchArgs{
					OverlayTransportZonePath: pulumi.Any(data.Nsxt_policy_transport_zone.Overlay_tz.Path),
					Pnics: nsxt.PolicyEdgeTransportNodeSwitchPnicArray{
						&nsxt.PolicyEdgeTransportNodeSwitchPnicArgs{
							DeviceName: pulumi.String("fp-eth0"),
							UplinkName: pulumi.String("uplink1"),
						},
					},
					UplinkHostSwitchProfilePath: pulumi.Any(data.Nsxt_policy_uplink_host_switch_profile.Uplink_host_switch_profile.Path),
					TunnelEndpoint: &nsxt.PolicyEdgeTransportNodeSwitchTunnelEndpointArgs{
						IpAssignment: &nsxt.PolicyEdgeTransportNodeSwitchTunnelEndpointIpAssignmentArgs{
							DhcpV4: pulumi.Bool(true),
						},
					},
					VlanTransportZonePaths: pulumi.StringArray{
						data.Nsxt_policy_transport_zone.Vlan_tz.Path,
					},
				},
			},
			VmDeploymentConfig: &nsxt.PolicyEdgeTransportNodeVmDeploymentConfigArgs{
				ComputeId:        pulumi.Any(data.Vsphere_compute_cluster.Edge_cluster.Id),
				StorageId:        pulumi.Any(data.Vsphere_datastore.Datastore.Id),
				ComputeManagerId: pulumi.Any(data.Nsxt_compute_manager.Vc.Id),
				HostId:           pulumi.Any(data.Vsphere_host.Host.Id),
			},
		})
		if err != nil {
			return err
		}
		_ = nsxt.GetPolicyEdgeTransportNodeRealizationOutput(ctx, nsxt.GetPolicyEdgeTransportNodeRealizationOutputArgs{
			Path:    test.Path,
			Timeout: pulumi.Float64(1200),
		}, nil)
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var test = new Nsxt.PolicyEdgeTransportNode("test", new()
    {
        DisplayName = "test-edge-appliance",
        Description = "Terraform deployed Edge appliance",
        ApplianceConfig = new Nsxt.Inputs.PolicyEdgeTransportNodeApplianceConfigArgs
        {
            AllowSshRootLogin = true,
            EnableSsh = true,
        },
        Credentials = new Nsxt.Inputs.PolicyEdgeTransportNodeCredentialsArgs
        {
            CliPassword = @var.CLI_PASSWORD,
            RootPassword = @var.ROOT_PASSWORD,
        },
        FormFactor = "SMALL",
        Hostname = "test-edge",
        ManagementInterface = new Nsxt.Inputs.PolicyEdgeTransportNodeManagementInterfaceArgs
        {
            IpAssignments = new[]
            {
                new Nsxt.Inputs.PolicyEdgeTransportNodeManagementInterfaceIpAssignmentArgs
                {
                    DhcpV4 = true,
                },
                new Nsxt.Inputs.PolicyEdgeTransportNodeManagementInterfaceIpAssignmentArgs
                {
                    StaticIpv6 = new Nsxt.Inputs.PolicyEdgeTransportNodeManagementInterfaceIpAssignmentStaticIpv6Args
                    {
                        DefaultGateway = "2001:0000:130F:0000:0000:09C0:876A:1",
                        ManagementPortSubnet = new Nsxt.Inputs.PolicyEdgeTransportNodeManagementInterfaceIpAssignmentStaticIpv6ManagementPortSubnetArgs
                        {
                            IpAddresses = new[]
                            {
                                "2001:0000:130F:0000:0000:09C0:876A:130B",
                            },
                            PrefixLength = 64,
                        },
                    },
                },
            },
            NetworkId = data.Vsphere_network.Mgt_network.Id,
        },
        Switches = new[]
        {
            new Nsxt.Inputs.PolicyEdgeTransportNodeSwitchArgs
            {
                OverlayTransportZonePath = data.Nsxt_policy_transport_zone.Overlay_tz.Path,
                Pnics = new[]
                {
                    new Nsxt.Inputs.PolicyEdgeTransportNodeSwitchPnicArgs
                    {
                        DeviceName = "fp-eth0",
                        UplinkName = "uplink1",
                    },
                },
                UplinkHostSwitchProfilePath = data.Nsxt_policy_uplink_host_switch_profile.Uplink_host_switch_profile.Path,
                TunnelEndpoint = new Nsxt.Inputs.PolicyEdgeTransportNodeSwitchTunnelEndpointArgs
                {
                    IpAssignment = new Nsxt.Inputs.PolicyEdgeTransportNodeSwitchTunnelEndpointIpAssignmentArgs
                    {
                        DhcpV4 = true,
                    },
                },
                VlanTransportZonePaths = new[]
                {
                    data.Nsxt_policy_transport_zone.Vlan_tz.Path,
                },
            },
        },
        VmDeploymentConfig = new Nsxt.Inputs.PolicyEdgeTransportNodeVmDeploymentConfigArgs
        {
            ComputeId = data.Vsphere_compute_cluster.Edge_cluster.Id,
            StorageId = data.Vsphere_datastore.Datastore.Id,
            ComputeManagerId = data.Nsxt_compute_manager.Vc.Id,
            HostId = data.Vsphere_host.Host.Id,
        },
    });

    var info = Nsxt.GetPolicyEdgeTransportNodeRealization.Invoke(new()
    {
        Path = test.Path,
        Timeout = 1200,
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.nsxt.PolicyEdgeTransportNode;
import com.pulumi.nsxt.PolicyEdgeTransportNodeArgs;
import com.pulumi.nsxt.inputs.PolicyEdgeTransportNodeApplianceConfigArgs;
import com.pulumi.nsxt.inputs.PolicyEdgeTransportNodeCredentialsArgs;
import com.pulumi.nsxt.inputs.PolicyEdgeTransportNodeManagementInterfaceArgs;
import com.pulumi.nsxt.inputs.PolicyEdgeTransportNodeSwitchArgs;
import com.pulumi.nsxt.inputs.PolicyEdgeTransportNodeSwitchTunnelEndpointArgs;
import com.pulumi.nsxt.inputs.PolicyEdgeTransportNodeSwitchTunnelEndpointIpAssignmentArgs;
import com.pulumi.nsxt.inputs.PolicyEdgeTransportNodeVmDeploymentConfigArgs;
import com.pulumi.nsxt.NsxtFunctions;
import com.pulumi.nsxt.inputs.GetPolicyEdgeTransportNodeRealizationArgs;
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 test = new PolicyEdgeTransportNode("test", PolicyEdgeTransportNodeArgs.builder()
            .displayName("test-edge-appliance")
            .description("Terraform deployed Edge appliance")
            .applianceConfig(PolicyEdgeTransportNodeApplianceConfigArgs.builder()
                .allowSshRootLogin(true)
                .enableSsh(true)
                .build())
            .credentials(PolicyEdgeTransportNodeCredentialsArgs.builder()
                .cliPassword(var_.CLI_PASSWORD())
                .rootPassword(var_.ROOT_PASSWORD())
                .build())
            .formFactor("SMALL")
            .hostname("test-edge")
            .managementInterface(PolicyEdgeTransportNodeManagementInterfaceArgs.builder()
                .ipAssignments(                
                    PolicyEdgeTransportNodeManagementInterfaceIpAssignmentArgs.builder()
                        .dhcpV4(true)
                        .build(),
                    PolicyEdgeTransportNodeManagementInterfaceIpAssignmentArgs.builder()
                        .staticIpv6(PolicyEdgeTransportNodeManagementInterfaceIpAssignmentStaticIpv6Args.builder()
                            .defaultGateway("2001:0000:130F:0000:0000:09C0:876A:1")
                            .managementPortSubnet(PolicyEdgeTransportNodeManagementInterfaceIpAssignmentStaticIpv6ManagementPortSubnetArgs.builder()
                                .ipAddresses("2001:0000:130F:0000:0000:09C0:876A:130B")
                                .prefixLength(64)
                                .build())
                            .build())
                        .build())
                .networkId(data.vsphere_network().mgt_network().id())
                .build())
            .switches(PolicyEdgeTransportNodeSwitchArgs.builder()
                .overlayTransportZonePath(data.nsxt_policy_transport_zone().overlay_tz().path())
                .pnics(PolicyEdgeTransportNodeSwitchPnicArgs.builder()
                    .deviceName("fp-eth0")
                    .uplinkName("uplink1")
                    .build())
                .uplinkHostSwitchProfilePath(data.nsxt_policy_uplink_host_switch_profile().uplink_host_switch_profile().path())
                .tunnelEndpoint(PolicyEdgeTransportNodeSwitchTunnelEndpointArgs.builder()
                    .ipAssignment(PolicyEdgeTransportNodeSwitchTunnelEndpointIpAssignmentArgs.builder()
                        .dhcpV4(true)
                        .build())
                    .build())
                .vlanTransportZonePaths(data.nsxt_policy_transport_zone().vlan_tz().path())
                .build())
            .vmDeploymentConfig(PolicyEdgeTransportNodeVmDeploymentConfigArgs.builder()
                .computeId(data.vsphere_compute_cluster().edge_cluster().id())
                .storageId(data.vsphere_datastore().datastore().id())
                .computeManagerId(data.nsxt_compute_manager().vc().id())
                .hostId(data.vsphere_host().host().id())
                .build())
            .build());

        final var info = NsxtFunctions.getPolicyEdgeTransportNodeRealization(GetPolicyEdgeTransportNodeRealizationArgs.builder()
            .path(test.path())
            .timeout(1200)
            .build());

    }
}

resources:
  test:
    type: nsxt:PolicyEdgeTransportNode
    properties:
      displayName: test-edge-appliance
      description: Terraform deployed Edge appliance
      applianceConfig:
        allowSshRootLogin: true
        enableSsh: true
      credentials:
        cliPassword: ${var.CLI_PASSWORD}
        rootPassword: ${var.ROOT_PASSWORD}
      formFactor: SMALL
      hostname: test-edge
      managementInterface:
        ipAssignments:
          - dhcpV4: true
          - staticIpv6:
              defaultGateway: 2001:0000:130F:0000:0000:09C0:876A:1
              managementPortSubnet:
                ipAddresses:
                  - 2001:0000:130F:0000:0000:09C0:876A:130B
                prefixLength: 64
        networkId: ${data.vsphere_network.mgt_network.id}
      switches:
        - overlayTransportZonePath: ${data.nsxt_policy_transport_zone.overlay_tz.path}
          pnics:
            - deviceName: fp-eth0
              uplinkName: uplink1
          uplinkHostSwitchProfilePath: ${data.nsxt_policy_uplink_host_switch_profile.uplink_host_switch_profile.path}
          tunnelEndpoint:
            ipAssignment:
              dhcpV4: true
          vlanTransportZonePaths:
            - ${data.nsxt_policy_transport_zone.vlan_tz.path}
      vmDeploymentConfig:
        computeId: ${data.vsphere_compute_cluster.edge_cluster.id}
        storageId: ${data.vsphere_datastore.datastore.id}
        computeManagerId: ${data.nsxt_compute_manager.vc.id}
        hostId: ${data.vsphere_host.host.id}
variables:
  info:
    fn::invoke:
      function: nsxt:getPolicyEdgeTransportNodeRealization
      arguments:
        path: ${test.path}
        timeout: 1200

Using getPolicyEdgeTransportNodeRealization

Two invocation forms are available. The direct form accepts plain arguments and either blocks until the result value is available, or returns a Promise-wrapped result. The output form accepts Input-wrapped arguments and returns an Output-wrapped result.

function getPolicyEdgeTransportNodeRealization(args: GetPolicyEdgeTransportNodeRealizationArgs, opts?: InvokeOptions): Promise<GetPolicyEdgeTransportNodeRealizationResult>
function getPolicyEdgeTransportNodeRealizationOutput(args: GetPolicyEdgeTransportNodeRealizationOutputArgs, opts?: InvokeOptions): Output<GetPolicyEdgeTransportNodeRealizationResult>

def get_policy_edge_transport_node_realization(delay: Optional[float] = None,
                                               id: Optional[str] = None,
                                               path: Optional[str] = None,
                                               timeout: Optional[float] = None,
                                               opts: Optional[InvokeOptions] = None) -> GetPolicyEdgeTransportNodeRealizationResult
def get_policy_edge_transport_node_realization_output(delay: Optional[pulumi.Input[float]] = None,
                                               id: Optional[pulumi.Input[str]] = None,
                                               path: Optional[pulumi.Input[str]] = None,
                                               timeout: Optional[pulumi.Input[float]] = None,
                                               opts: Optional[InvokeOptions] = None) -> Output[GetPolicyEdgeTransportNodeRealizationResult]

func GetPolicyEdgeTransportNodeRealization(ctx *Context, args *GetPolicyEdgeTransportNodeRealizationArgs, opts ...InvokeOption) (*GetPolicyEdgeTransportNodeRealizationResult, error)
func GetPolicyEdgeTransportNodeRealizationOutput(ctx *Context, args *GetPolicyEdgeTransportNodeRealizationOutputArgs, opts ...InvokeOption) GetPolicyEdgeTransportNodeRealizationResultOutput

> Note: This function is named GetPolicyEdgeTransportNodeRealization in the Go SDK.

public static class GetPolicyEdgeTransportNodeRealization 
{
    public static Task<GetPolicyEdgeTransportNodeRealizationResult> InvokeAsync(GetPolicyEdgeTransportNodeRealizationArgs args, InvokeOptions? opts = null)
    public static Output<GetPolicyEdgeTransportNodeRealizationResult> Invoke(GetPolicyEdgeTransportNodeRealizationInvokeArgs args, InvokeOptions? opts = null)
}

public static CompletableFuture<GetPolicyEdgeTransportNodeRealizationResult> getPolicyEdgeTransportNodeRealization(GetPolicyEdgeTransportNodeRealizationArgs args, InvokeOptions options)
public static Output<GetPolicyEdgeTransportNodeRealizationResult> getPolicyEdgeTransportNodeRealization(GetPolicyEdgeTransportNodeRealizationArgs args, InvokeOptions options)

fn::invoke:
  function: nsxt:index/getPolicyEdgeTransportNodeRealization:getPolicyEdgeTransportNodeRealization
  arguments:
    # arguments dictionary

The following arguments are supported:

Path string: The path for the Policy Edge transport node.
Delay double: Delay (in seconds) before realization polling is started. Default is set to 1.
Id string
Timeout double: Timeout (in seconds) for realization polling. Default is set to 1200.

Path string: The path for the Policy Edge transport node.
Delay float64: Delay (in seconds) before realization polling is started. Default is set to 1.
Id string
Timeout float64: Timeout (in seconds) for realization polling. Default is set to 1200.

path String: The path for the Policy Edge transport node.
delay Double: Delay (in seconds) before realization polling is started. Default is set to 1.
id String
timeout Double: Timeout (in seconds) for realization polling. Default is set to 1200.

path string: The path for the Policy Edge transport node.
delay number: Delay (in seconds) before realization polling is started. Default is set to 1.
id string
timeout number: Timeout (in seconds) for realization polling. Default is set to 1200.

path str: The path for the Policy Edge transport node.
delay float: Delay (in seconds) before realization polling is started. Default is set to 1.
id str
timeout float: Timeout (in seconds) for realization polling. Default is set to 1200.

path String: The path for the Policy Edge transport node.
delay Number: Delay (in seconds) before realization polling is started. Default is set to 1.
id String
timeout Number: Timeout (in seconds) for realization polling. Default is set to 1200.

getPolicyEdgeTransportNodeRealization Result

The following output properties are available:

Id string
Path string
Delay double
Timeout double

Id string
Path string
Delay float64
Timeout float64

id String
path String
delay Double
timeout Double

id string
path string
delay number
timeout number

id str
path str
delay float
timeout float

id String
path String
delay Number
timeout Number

Package Details

Repository: nsxt vmware/terraform-provider-nsxt
License
Notes: This Pulumi package is based on the nsxt Terraform Provider.

nsxt 3.10.0 published on Wednesday, Sep 10, 2025 by vmware

vmware/terraform-provider-nsxt

nsxt.getPolicyEdgeTransportNodeRealization

On this page

On this page

Example Usage

Using getPolicyEdgeTransportNodeRealization

getPolicyEdgeTransportNodeRealization Result

Package Details

On this page

On this page