TunnelInterface

Strata Cloud Manager v1.0.3, Jan 22 26

Strata Cloud Manager v1.0.3 published on Thursday, Jan 22, 2026 by Pulumi

Schema (JSON)

pulumi/pulumi-scm

Strata Cloud Manager v1.0.3 published on Thursday, Jan 22, 2026 by Pulumi

Schema (JSON)

pulumi/pulumi-scm

Example Usage

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

//
// Creates a tunnel interface with static ipv4 address
//
const scmTunnelIntf = new scm.TunnelInterface("scm_tunnel_intf", {
    name: "$scm_tunnel_intf",
    comment: "Managed by Pulumi",
    folder: "ngfw-shared",
    ips: [{
        name: "198.18.1.1/32",
    }],
});
//
// Creates a tunnel interface with static ipv4 address, with default value tunnel.123
//
const scmTunnelIntf2 = new scm.TunnelInterface("scm_tunnel_intf_2", {
    name: "$scm_tunnel_intf_2",
    comment: "Managed by Pulumi",
    folder: "ngfw-shared",
    ips: [{
        name: "198.18.1.2/32",
    }],
});
//
// Creates an ip subnet variable used in the subsequent example
//
const scmIpv6Prefix = new scm.Variable("scm_ipv6_prefix", {
    folder: "ngfw-shared",
    name: "$scm_ipv6_prefix",
    description: "Managed by Pulumi",
    type: "ip-netmask",
    value: "2001:0db8:abcd:0001::/64",
});
//
// Creates a tunnel interface with ipv6 address, with default value tunnel.321
//
const scmTunnelIntf3 = new scm.TunnelInterface("scm_tunnel_intf_3", {
    name: "$scm_tunnel_intf_3",
    comment: "Managed by Pulumi",
    folder: "ngfw-shared",
    defaultValue: "tunnel.321",
    ipv6: {
        enabled: true,
        interfaceId: "EUI-64",
        addresses: [{
            name: "$scm_ipv6_prefix",
            prefix: {},
        }],
    },
}, {
    dependsOn: [scmIpv6Prefix],
});

import pulumi
import pulumi_scm as scm

#
# Creates a tunnel interface with static ipv4 address
#
scm_tunnel_intf = scm.TunnelInterface("scm_tunnel_intf",
    name="$scm_tunnel_intf",
    comment="Managed by Pulumi",
    folder="ngfw-shared",
    ips=[{
        "name": "198.18.1.1/32",
    }])
#
# Creates a tunnel interface with static ipv4 address, with default value tunnel.123
#
scm_tunnel_intf2 = scm.TunnelInterface("scm_tunnel_intf_2",
    name="$scm_tunnel_intf_2",
    comment="Managed by Pulumi",
    folder="ngfw-shared",
    ips=[{
        "name": "198.18.1.2/32",
    }])
#
# Creates an ip subnet variable used in the subsequent example
#
scm_ipv6_prefix = scm.Variable("scm_ipv6_prefix",
    folder="ngfw-shared",
    name="$scm_ipv6_prefix",
    description="Managed by Pulumi",
    type="ip-netmask",
    value="2001:0db8:abcd:0001::/64")
#
# Creates a tunnel interface with ipv6 address, with default value tunnel.321
#
scm_tunnel_intf3 = scm.TunnelInterface("scm_tunnel_intf_3",
    name="$scm_tunnel_intf_3",
    comment="Managed by Pulumi",
    folder="ngfw-shared",
    default_value="tunnel.321",
    ipv6={
        "enabled": True,
        "interface_id": "EUI-64",
        "addresses": [{
            "name": "$scm_ipv6_prefix",
            "prefix": {},
        }],
    },
    opts = pulumi.ResourceOptions(depends_on=[scm_ipv6_prefix]))

package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		// Creates a tunnel interface with static ipv4 address
		_, err := scm.NewTunnelInterface(ctx, "scm_tunnel_intf", &scm.TunnelInterfaceArgs{
			Name:    pulumi.String("$scm_tunnel_intf"),
			Comment: pulumi.String("Managed by Pulumi"),
			Folder:  pulumi.String("ngfw-shared"),
			Ips: scm.TunnelInterfaceIpArray{
				&scm.TunnelInterfaceIpArgs{
					Name: pulumi.String("198.18.1.1/32"),
				},
			},
		})
		if err != nil {
			return err
		}
		// Creates a tunnel interface with static ipv4 address, with default value tunnel.123
		_, err = scm.NewTunnelInterface(ctx, "scm_tunnel_intf_2", &scm.TunnelInterfaceArgs{
			Name:    pulumi.String("$scm_tunnel_intf_2"),
			Comment: pulumi.String("Managed by Pulumi"),
			Folder:  pulumi.String("ngfw-shared"),
			Ips: scm.TunnelInterfaceIpArray{
				&scm.TunnelInterfaceIpArgs{
					Name: pulumi.String("198.18.1.2/32"),
				},
			},
		})
		if err != nil {
			return err
		}
		// Creates an ip subnet variable used in the subsequent example
		scmIpv6Prefix, err := scm.NewVariable(ctx, "scm_ipv6_prefix", &scm.VariableArgs{
			Folder:      pulumi.String("ngfw-shared"),
			Name:        pulumi.String("$scm_ipv6_prefix"),
			Description: pulumi.String("Managed by Pulumi"),
			Type:        pulumi.String("ip-netmask"),
			Value:       pulumi.String("2001:0db8:abcd:0001::/64"),
		})
		if err != nil {
			return err
		}
		// Creates a tunnel interface with ipv6 address, with default value tunnel.321
		_, err = scm.NewTunnelInterface(ctx, "scm_tunnel_intf_3", &scm.TunnelInterfaceArgs{
			Name:         pulumi.String("$scm_tunnel_intf_3"),
			Comment:      pulumi.String("Managed by Pulumi"),
			Folder:       pulumi.String("ngfw-shared"),
			DefaultValue: pulumi.String("tunnel.321"),
			Ipv6: &scm.TunnelInterfaceIpv6Args{
				Enabled:     pulumi.Bool(true),
				InterfaceId: pulumi.String("EUI-64"),
				Addresses: scm.TunnelInterfaceIpv6AddressArray{
					&scm.TunnelInterfaceIpv6AddressArgs{
						Name:   pulumi.String("$scm_ipv6_prefix"),
						Prefix: &scm.TunnelInterfaceIpv6AddressPrefixArgs{},
					},
				},
			},
		}, pulumi.DependsOn([]pulumi.Resource{
			scmIpv6Prefix,
		}))
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    //
    // Creates a tunnel interface with static ipv4 address
    //
    var scmTunnelIntf = new Scm.TunnelInterface("scm_tunnel_intf", new()
    {
        Name = "$scm_tunnel_intf",
        Comment = "Managed by Pulumi",
        Folder = "ngfw-shared",
        Ips = new[]
        {
            new Scm.Inputs.TunnelInterfaceIpArgs
            {
                Name = "198.18.1.1/32",
            },
        },
    });

    //
    // Creates a tunnel interface with static ipv4 address, with default value tunnel.123
    //
    var scmTunnelIntf2 = new Scm.TunnelInterface("scm_tunnel_intf_2", new()
    {
        Name = "$scm_tunnel_intf_2",
        Comment = "Managed by Pulumi",
        Folder = "ngfw-shared",
        Ips = new[]
        {
            new Scm.Inputs.TunnelInterfaceIpArgs
            {
                Name = "198.18.1.2/32",
            },
        },
    });

    //
    // Creates an ip subnet variable used in the subsequent example
    //
    var scmIpv6Prefix = new Scm.Variable("scm_ipv6_prefix", new()
    {
        Folder = "ngfw-shared",
        Name = "$scm_ipv6_prefix",
        Description = "Managed by Pulumi",
        Type = "ip-netmask",
        Value = "2001:0db8:abcd:0001::/64",
    });

    //
    // Creates a tunnel interface with ipv6 address, with default value tunnel.321
    //
    var scmTunnelIntf3 = new Scm.TunnelInterface("scm_tunnel_intf_3", new()
    {
        Name = "$scm_tunnel_intf_3",
        Comment = "Managed by Pulumi",
        Folder = "ngfw-shared",
        DefaultValue = "tunnel.321",
        Ipv6 = new Scm.Inputs.TunnelInterfaceIpv6Args
        {
            Enabled = true,
            InterfaceId = "EUI-64",
            Addresses = new[]
            {
                new Scm.Inputs.TunnelInterfaceIpv6AddressArgs
                {
                    Name = "$scm_ipv6_prefix",
                    Prefix = null,
                },
            },
        },
    }, new CustomResourceOptions
    {
        DependsOn =
        {
            scmIpv6Prefix,
        },
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.scm.TunnelInterface;
import com.pulumi.scm.TunnelInterfaceArgs;
import com.pulumi.scm.inputs.TunnelInterfaceIpArgs;
import com.pulumi.scm.Variable;
import com.pulumi.scm.VariableArgs;
import com.pulumi.scm.inputs.TunnelInterfaceIpv6Args;
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) {
        //
        // Creates a tunnel interface with static ipv4 address
        //
        var scmTunnelIntf = new TunnelInterface("scmTunnelIntf", TunnelInterfaceArgs.builder()
            .name("$scm_tunnel_intf")
            .comment("Managed by Pulumi")
            .folder("ngfw-shared")
            .ips(TunnelInterfaceIpArgs.builder()
                .name("198.18.1.1/32")
                .build())
            .build());

        //
        // Creates a tunnel interface with static ipv4 address, with default value tunnel.123
        //
        var scmTunnelIntf2 = new TunnelInterface("scmTunnelIntf2", TunnelInterfaceArgs.builder()
            .name("$scm_tunnel_intf_2")
            .comment("Managed by Pulumi")
            .folder("ngfw-shared")
            .ips(TunnelInterfaceIpArgs.builder()
                .name("198.18.1.2/32")
                .build())
            .build());

        //
        // Creates an ip subnet variable used in the subsequent example
        //
        var scmIpv6Prefix = new Variable("scmIpv6Prefix", VariableArgs.builder()
            .folder("ngfw-shared")
            .name("$scm_ipv6_prefix")
            .description("Managed by Pulumi")
            .type("ip-netmask")
            .value("2001:0db8:abcd:0001::/64")
            .build());

        //
        // Creates a tunnel interface with ipv6 address, with default value tunnel.321
        //
        var scmTunnelIntf3 = new TunnelInterface("scmTunnelIntf3", TunnelInterfaceArgs.builder()
            .name("$scm_tunnel_intf_3")
            .comment("Managed by Pulumi")
            .folder("ngfw-shared")
            .defaultValue("tunnel.321")
            .ipv6(TunnelInterfaceIpv6Args.builder()
                .enabled(true)
                .interfaceId("EUI-64")
                .addresses(TunnelInterfaceIpv6AddressArgs.builder()
                    .name("$scm_ipv6_prefix")
                    .prefix(TunnelInterfaceIpv6AddressPrefixArgs.builder()
                        .build())
                    .build())
                .build())
            .build(), CustomResourceOptions.builder()
                .dependsOn(scmIpv6Prefix)
                .build());

    }
}

resources:
  #
  # Creates a tunnel interface with static ipv4 address
  #
  scmTunnelIntf:
    type: scm:TunnelInterface
    name: scm_tunnel_intf
    properties:
      name: $scm_tunnel_intf
      comment: Managed by Pulumi
      folder: ngfw-shared
      ips:
        - name: 198.18.1.1/32
  #
  # Creates a tunnel interface with static ipv4 address, with default value tunnel.123
  #
  scmTunnelIntf2:
    type: scm:TunnelInterface
    name: scm_tunnel_intf_2
    properties:
      name: $scm_tunnel_intf_2
      comment: Managed by Pulumi
      folder: ngfw-shared
      ips:
        - name: 198.18.1.2/32
  #
  # Creates an ip subnet variable used in the subsequent example
  #
  scmIpv6Prefix:
    type: scm:Variable
    name: scm_ipv6_prefix
    properties:
      folder: ngfw-shared
      name: $scm_ipv6_prefix
      description: Managed by Pulumi
      type: ip-netmask
      value: 2001:0db8:abcd:0001::/64
  #
  # Creates a tunnel interface with ipv6 address, with default value tunnel.321
  #
  scmTunnelIntf3:
    type: scm:TunnelInterface
    name: scm_tunnel_intf_3
    properties:
      name: $scm_tunnel_intf_3
      comment: Managed by Pulumi
      folder: ngfw-shared
      defaultValue: tunnel.321
      ipv6:
        enabled: true
        interfaceId: EUI-64
        addresses:
          - name: $scm_ipv6_prefix
            prefix: {}
    options:
      dependsOn:
        - ${scmIpv6Prefix}

Create TunnelInterface Resource

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

Constructor syntax

new TunnelInterface(name: string, args?: TunnelInterfaceArgs, opts?: CustomResourceOptions);

@overload
def TunnelInterface(resource_name: str,
                    args: Optional[TunnelInterfaceArgs] = None,
                    opts: Optional[ResourceOptions] = None)

@overload
def TunnelInterface(resource_name: str,
                    opts: Optional[ResourceOptions] = None,
                    comment: Optional[str] = None,
                    default_value: Optional[str] = None,
                    device: Optional[str] = None,
                    folder: Optional[str] = None,
                    interface_management_profile: Optional[str] = None,
                    ips: Optional[Sequence[TunnelInterfaceIpArgs]] = None,
                    ipv6: Optional[TunnelInterfaceIpv6Args] = None,
                    mtu: Optional[int] = None,
                    name: Optional[str] = None,
                    snippet: Optional[str] = None)

func NewTunnelInterface(ctx *Context, name string, args *TunnelInterfaceArgs, opts ...ResourceOption) (*TunnelInterface, error)

public TunnelInterface(string name, TunnelInterfaceArgs? args = null, CustomResourceOptions? opts = null)

public TunnelInterface(String name, TunnelInterfaceArgs args)
public TunnelInterface(String name, TunnelInterfaceArgs args, CustomResourceOptions options)

type: scm:TunnelInterface
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 TunnelInterfaceArgs: 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 TunnelInterfaceArgs: 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 TunnelInterfaceArgs: The arguments to resource properties.
opts ResourceOption: Bag of options to control resource's behavior.

name string: The unique name of the resource.
args TunnelInterfaceArgs: The arguments to resource properties.
opts CustomResourceOptions: Bag of options to control resource's behavior.

name String: The unique name of the resource.
args TunnelInterfaceArgs: 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 tunnelInterfaceResource = new Scm.TunnelInterface("tunnelInterfaceResource", new()
{
    Comment = "string",
    DefaultValue = "string",
    Device = "string",
    Folder = "string",
    InterfaceManagementProfile = "string",
    Ips = new[]
    {
        new Scm.Inputs.TunnelInterfaceIpArgs
        {
            Name = "string",
        },
    },
    Ipv6 = new Scm.Inputs.TunnelInterfaceIpv6Args
    {
        Addresses = new[]
        {
            new Scm.Inputs.TunnelInterfaceIpv6AddressArgs
            {
                Anycast = null,
                EnableOnInterface = false,
                Name = "string",
                Prefix = null,
            },
        },
        Enabled = false,
        InterfaceId = "string",
    },
    Mtu = 0,
    Name = "string",
    Snippet = "string",
});

example, err := scm.NewTunnelInterface(ctx, "tunnelInterfaceResource", &scm.TunnelInterfaceArgs{
	Comment:                    pulumi.String("string"),
	DefaultValue:               pulumi.String("string"),
	Device:                     pulumi.String("string"),
	Folder:                     pulumi.String("string"),
	InterfaceManagementProfile: pulumi.String("string"),
	Ips: scm.TunnelInterfaceIpArray{
		&scm.TunnelInterfaceIpArgs{
			Name: pulumi.String("string"),
		},
	},
	Ipv6: &scm.TunnelInterfaceIpv6Args{
		Addresses: scm.TunnelInterfaceIpv6AddressArray{
			&scm.TunnelInterfaceIpv6AddressArgs{
				Anycast:           &scm.TunnelInterfaceIpv6AddressAnycastArgs{},
				EnableOnInterface: pulumi.Bool(false),
				Name:              pulumi.String("string"),
				Prefix:            &scm.TunnelInterfaceIpv6AddressPrefixArgs{},
			},
		},
		Enabled:     pulumi.Bool(false),
		InterfaceId: pulumi.String("string"),
	},
	Mtu:     pulumi.Int(0),
	Name:    pulumi.String("string"),
	Snippet: pulumi.String("string"),
})

var tunnelInterfaceResource = new TunnelInterface("tunnelInterfaceResource", TunnelInterfaceArgs.builder()
    .comment("string")
    .defaultValue("string")
    .device("string")
    .folder("string")
    .interfaceManagementProfile("string")
    .ips(TunnelInterfaceIpArgs.builder()
        .name("string")
        .build())
    .ipv6(TunnelInterfaceIpv6Args.builder()
        .addresses(TunnelInterfaceIpv6AddressArgs.builder()
            .anycast(TunnelInterfaceIpv6AddressAnycastArgs.builder()
                .build())
            .enableOnInterface(false)
            .name("string")
            .prefix(TunnelInterfaceIpv6AddressPrefixArgs.builder()
                .build())
            .build())
        .enabled(false)
        .interfaceId("string")
        .build())
    .mtu(0)
    .name("string")
    .snippet("string")
    .build());

tunnel_interface_resource = scm.TunnelInterface("tunnelInterfaceResource",
    comment="string",
    default_value="string",
    device="string",
    folder="string",
    interface_management_profile="string",
    ips=[{
        "name": "string",
    }],
    ipv6={
        "addresses": [{
            "anycast": {},
            "enable_on_interface": False,
            "name": "string",
            "prefix": {},
        }],
        "enabled": False,
        "interface_id": "string",
    },
    mtu=0,
    name="string",
    snippet="string")

const tunnelInterfaceResource = new scm.TunnelInterface("tunnelInterfaceResource", {
    comment: "string",
    defaultValue: "string",
    device: "string",
    folder: "string",
    interfaceManagementProfile: "string",
    ips: [{
        name: "string",
    }],
    ipv6: {
        addresses: [{
            anycast: {},
            enableOnInterface: false,
            name: "string",
            prefix: {},
        }],
        enabled: false,
        interfaceId: "string",
    },
    mtu: 0,
    name: "string",
    snippet: "string",
});

type: scm:TunnelInterface
properties:
    comment: string
    defaultValue: string
    device: string
    folder: string
    interfaceManagementProfile: string
    ips:
        - name: string
    ipv6:
        addresses:
            - anycast: {}
              enableOnInterface: false
              name: string
              prefix: {}
        enabled: false
        interfaceId: string
    mtu: 0
    name: string
    snippet: string

TunnelInterface 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 TunnelInterface resource accepts the following input properties:

Comment string: Description
DefaultValue string: Default interface assignment
Device string: The device in which the resource is defined
Folder string: The folder in which the resource is defined
ℹ️ Note: You must specify exactly one of device, folder, and snippet.
InterfaceManagementProfile string: Interface management profile
Ips List<TunnelInterfaceIp>: Tunnel Interface IP Parent
Ipv6 TunnelInterfaceIpv6: Tunnel Interface IPv6 Configuration
Mtu int: MTU
Name string: L3 sub-interface name
Snippet string: The snippet in which the resource is defined
ℹ️ Note: You must specify exactly one of device, folder, and snippet.

Comment string: Description
DefaultValue string: Default interface assignment
Device string: The device in which the resource is defined
Folder string: The folder in which the resource is defined
ℹ️ Note: You must specify exactly one of device, folder, and snippet.
InterfaceManagementProfile string: Interface management profile
Ips []TunnelInterfaceIpArgs: Tunnel Interface IP Parent
Ipv6 TunnelInterfaceIpv6Args: Tunnel Interface IPv6 Configuration
Mtu int: MTU
Name string: L3 sub-interface name
Snippet string: The snippet in which the resource is defined
ℹ️ Note: You must specify exactly one of device, folder, and snippet.

comment String: Description
defaultValue String: Default interface assignment
device String: The device in which the resource is defined
folder String: The folder in which the resource is defined
ℹ️ Note: You must specify exactly one of device, folder, and snippet.
interfaceManagementProfile String: Interface management profile
ips List<TunnelInterfaceIp>: Tunnel Interface IP Parent
ipv6 TunnelInterfaceIpv6: Tunnel Interface IPv6 Configuration
mtu Integer: MTU
name String: L3 sub-interface name
snippet String: The snippet in which the resource is defined
ℹ️ Note: You must specify exactly one of device, folder, and snippet.

comment string: Description
defaultValue string: Default interface assignment
device string: The device in which the resource is defined
folder string: The folder in which the resource is defined
ℹ️ Note: You must specify exactly one of device, folder, and snippet.
interfaceManagementProfile string: Interface management profile
ips TunnelInterfaceIp[]: Tunnel Interface IP Parent
ipv6 TunnelInterfaceIpv6: Tunnel Interface IPv6 Configuration
mtu number: MTU
name string: L3 sub-interface name
snippet string: The snippet in which the resource is defined
ℹ️ Note: You must specify exactly one of device, folder, and snippet.

comment str: Description
default_value str: Default interface assignment
device str: The device in which the resource is defined
folder str: The folder in which the resource is defined
ℹ️ Note: You must specify exactly one of device, folder, and snippet.
interface_management_profile str: Interface management profile
ips Sequence[TunnelInterfaceIpArgs]: Tunnel Interface IP Parent
ipv6 TunnelInterfaceIpv6Args: Tunnel Interface IPv6 Configuration
mtu int: MTU
name str: L3 sub-interface name
snippet str: The snippet in which the resource is defined
ℹ️ Note: You must specify exactly one of device, folder, and snippet.

comment String: Description
defaultValue String: Default interface assignment
device String: The device in which the resource is defined
folder String: The folder in which the resource is defined
ℹ️ Note: You must specify exactly one of device, folder, and snippet.
interfaceManagementProfile String: Interface management profile
ips List<Property Map>: Tunnel Interface IP Parent
ipv6 Property Map: Tunnel Interface IPv6 Configuration
mtu Number: MTU
name String: L3 sub-interface name
snippet String: The snippet in which the resource is defined
ℹ️ Note: You must specify exactly one of device, folder, and snippet.

Outputs

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

Id string: The provider-assigned unique ID for this managed resource.
Tfid string

Id string: The provider-assigned unique ID for this managed resource.
Tfid string

id String: The provider-assigned unique ID for this managed resource.
tfid String

id string: The provider-assigned unique ID for this managed resource.
tfid string

id str: The provider-assigned unique ID for this managed resource.
tfid str

id String: The provider-assigned unique ID for this managed resource.
tfid String

Look up Existing TunnelInterface Resource

Get an existing TunnelInterface 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?: TunnelInterfaceState, opts?: CustomResourceOptions): TunnelInterface

@staticmethod
def get(resource_name: str,
        id: str,
        opts: Optional[ResourceOptions] = None,
        comment: Optional[str] = None,
        default_value: Optional[str] = None,
        device: Optional[str] = None,
        folder: Optional[str] = None,
        interface_management_profile: Optional[str] = None,
        ips: Optional[Sequence[TunnelInterfaceIpArgs]] = None,
        ipv6: Optional[TunnelInterfaceIpv6Args] = None,
        mtu: Optional[int] = None,
        name: Optional[str] = None,
        snippet: Optional[str] = None,
        tfid: Optional[str] = None) -> TunnelInterface

func GetTunnelInterface(ctx *Context, name string, id IDInput, state *TunnelInterfaceState, opts ...ResourceOption) (*TunnelInterface, error)

public static TunnelInterface Get(string name, Input<string> id, TunnelInterfaceState? state, CustomResourceOptions? opts = null)

public static TunnelInterface get(String name, Output<String> id, TunnelInterfaceState state, CustomResourceOptions options)

resources:  _:    type: scm:TunnelInterface    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:

Comment string: Description
DefaultValue string: Default interface assignment
Device string: The device in which the resource is defined
Folder string: The folder in which the resource is defined
ℹ️ Note: You must specify exactly one of device, folder, and snippet.
InterfaceManagementProfile string: Interface management profile
Ips List<TunnelInterfaceIp>: Tunnel Interface IP Parent
Ipv6 TunnelInterfaceIpv6: Tunnel Interface IPv6 Configuration
Mtu int: MTU
Name string: L3 sub-interface name
Snippet string: The snippet in which the resource is defined
ℹ️ Note: You must specify exactly one of device, folder, and snippet.
Tfid string

Comment string: Description
DefaultValue string: Default interface assignment
Device string: The device in which the resource is defined
Folder string: The folder in which the resource is defined
ℹ️ Note: You must specify exactly one of device, folder, and snippet.
InterfaceManagementProfile string: Interface management profile
Ips []TunnelInterfaceIpArgs: Tunnel Interface IP Parent
Ipv6 TunnelInterfaceIpv6Args: Tunnel Interface IPv6 Configuration
Mtu int: MTU
Name string: L3 sub-interface name
Snippet string: The snippet in which the resource is defined
ℹ️ Note: You must specify exactly one of device, folder, and snippet.
Tfid string

comment String: Description
defaultValue String: Default interface assignment
device String: The device in which the resource is defined
folder String: The folder in which the resource is defined
ℹ️ Note: You must specify exactly one of device, folder, and snippet.
interfaceManagementProfile String: Interface management profile
ips List<TunnelInterfaceIp>: Tunnel Interface IP Parent
ipv6 TunnelInterfaceIpv6: Tunnel Interface IPv6 Configuration
mtu Integer: MTU
name String: L3 sub-interface name
snippet String: The snippet in which the resource is defined
ℹ️ Note: You must specify exactly one of device, folder, and snippet.
tfid String

comment string: Description
defaultValue string: Default interface assignment
device string: The device in which the resource is defined
folder string: The folder in which the resource is defined
ℹ️ Note: You must specify exactly one of device, folder, and snippet.
interfaceManagementProfile string: Interface management profile
ips TunnelInterfaceIp[]: Tunnel Interface IP Parent
ipv6 TunnelInterfaceIpv6: Tunnel Interface IPv6 Configuration
mtu number: MTU
name string: L3 sub-interface name
snippet string: The snippet in which the resource is defined
ℹ️ Note: You must specify exactly one of device, folder, and snippet.
tfid string

comment str: Description
default_value str: Default interface assignment
device str: The device in which the resource is defined
folder str: The folder in which the resource is defined
ℹ️ Note: You must specify exactly one of device, folder, and snippet.
interface_management_profile str: Interface management profile
ips Sequence[TunnelInterfaceIpArgs]: Tunnel Interface IP Parent
ipv6 TunnelInterfaceIpv6Args: Tunnel Interface IPv6 Configuration
mtu int: MTU
name str: L3 sub-interface name
snippet str: The snippet in which the resource is defined
ℹ️ Note: You must specify exactly one of device, folder, and snippet.
tfid str

comment String: Description
defaultValue String: Default interface assignment
device String: The device in which the resource is defined
folder String: The folder in which the resource is defined
ℹ️ Note: You must specify exactly one of device, folder, and snippet.
interfaceManagementProfile String: Interface management profile
ips List<Property Map>: Tunnel Interface IP Parent
ipv6 Property Map: Tunnel Interface IPv6 Configuration
mtu Number: MTU
name String: L3 sub-interface name
snippet String: The snippet in which the resource is defined
ℹ️ Note: You must specify exactly one of device, folder, and snippet.
tfid String

Supporting Types

TunnelInterfaceIp, TunnelInterfaceIpArgs

Name string: Tunnel Interface IP address(es)

Name string: Tunnel Interface IP address(es)

name String: Tunnel Interface IP address(es)

name string: Tunnel Interface IP address(es)

name str: Tunnel Interface IP address(es)

name String: Tunnel Interface IP address(es)

TunnelInterfaceIpv6, TunnelInterfaceIpv6Args

Addresses List<TunnelInterfaceIpv6Address>: IPv6 Address Parent
Enabled bool: Enable IPv6
InterfaceId string: Interface ID

Addresses []TunnelInterfaceIpv6Address: IPv6 Address Parent
Enabled bool: Enable IPv6
InterfaceId string: Interface ID

addresses List<TunnelInterfaceIpv6Address>: IPv6 Address Parent
enabled Boolean: Enable IPv6
interfaceId String: Interface ID

addresses TunnelInterfaceIpv6Address[]: IPv6 Address Parent
enabled boolean: Enable IPv6
interfaceId string: Interface ID

addresses Sequence[TunnelInterfaceIpv6Address]: IPv6 Address Parent
enabled bool: Enable IPv6
interface_id str: Interface ID

addresses List<Property Map>: IPv6 Address Parent
enabled Boolean: Enable IPv6
interfaceId String: Interface ID

TunnelInterfaceIpv6Address, TunnelInterfaceIpv6AddressArgs

Anycast TunnelInterfaceIpv6AddressAnycast: Anycast
EnableOnInterface bool: Enable Address on Interface
Name string: IPv6 Address
Prefix TunnelInterfaceIpv6AddressPrefix: Use interface ID as host portion

Anycast TunnelInterfaceIpv6AddressAnycast: Anycast
EnableOnInterface bool: Enable Address on Interface
Name string: IPv6 Address
Prefix TunnelInterfaceIpv6AddressPrefix: Use interface ID as host portion

anycast TunnelInterfaceIpv6AddressAnycast: Anycast
enableOnInterface Boolean: Enable Address on Interface
name String: IPv6 Address
prefix TunnelInterfaceIpv6AddressPrefix: Use interface ID as host portion

anycast TunnelInterfaceIpv6AddressAnycast: Anycast
enableOnInterface boolean: Enable Address on Interface
name string: IPv6 Address
prefix TunnelInterfaceIpv6AddressPrefix: Use interface ID as host portion

anycast TunnelInterfaceIpv6AddressAnycast: Anycast
enable_on_interface bool: Enable Address on Interface
name str: IPv6 Address
prefix TunnelInterfaceIpv6AddressPrefix: Use interface ID as host portion

anycast Property Map: Anycast
enableOnInterface Boolean: Enable Address on Interface
name String: IPv6 Address
prefix Property Map: Use interface ID as host portion

Import

The following command can be used to import a resource not managed by Terraform:

bash

$ pulumi import scm:index/tunnelInterface:TunnelInterface example folder:::id

bash

$ pulumi import scm:index/tunnelInterface:TunnelInterface example :snippet::id

bash

$ pulumi import scm:index/tunnelInterface:TunnelInterface example ::device:id

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

Package Details

Repository: scm pulumi/pulumi-scm
License: Apache-2.0
Notes: This Pulumi package is based on the scm Terraform Provider.

Strata Cloud Manager v1.0.3 published on Thursday, Jan 22, 2026 by Pulumi

Schema (JSON)

pulumi/pulumi-scm

scm.TunnelInterface

On this page

On this page

Example Usage

Create TunnelInterface Resource

Constructor syntax

Parameters

Constructor example

TunnelInterface Resource Properties

Inputs

Outputs

Look up Existing TunnelInterface Resource

Supporting Types

TunnelInterfaceIp, TunnelInterfaceIpArgs

TunnelInterfaceIpv6, TunnelInterfaceIpv6Args

TunnelInterfaceIpv6Address, TunnelInterfaceIpv6AddressArgs

Import

Package Details

On this page

On this page