vpn

package
v0.0.0-...-a632b15 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Aug 27, 2025 License: Apache-2.0 Imports: 7 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type VpnTunnel 

type VpnTunnel struct {
	pulumi.CustomResourceState

	Description pulumi.StringPtrOutput `pulumi:"description"`
	// Valid values are `ipsec-transport`, `ipsec-tunnel`, `ip-ip` and `gre`.
	Encapsulation pulumi.StringOutput `pulumi:"encapsulation"`
	Name          pulumi.StringOutput `pulumi:"name"`
	// Valid values are `planned`, `active` and `disabled`.
	Status        pulumi.StringOutput      `pulumi:"status"`
	Tags          pulumi.StringArrayOutput `pulumi:"tags"`
	TagsAlls      pulumi.StringArrayOutput `pulumi:"tagsAlls"`
	TenantId      pulumi.IntPtrOutput      `pulumi:"tenantId"`
	TunnelGroupId pulumi.IntOutput         `pulumi:"tunnelGroupId"`
	TunnelId      pulumi.IntPtrOutput      `pulumi:"tunnelId"`
}

From the [official documentation](https://docs.netbox.dev/en/stable/features/vpn-tunnels/):

> NetBox can model private tunnels formed among virtual termination points across your network. Typical tunnel implementations include GRE, IP-in-IP, and IPSec. A tunnel may be terminated to two or more device or virtual machine interfaces. For convenient organization, tunnels may be assigned to user-defined groups.

## Example Usage

```go package main

import ( 

"github.com/NatzkaLabsOpenSource/pulumi-netbox/sdk/go/netbox/vpn"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		test, err := vpn.NewVpnTunnelGroup(ctx, "test", &vpn.VpnTunnelGroupArgs{
			Name: pulumi.String("my-tunnel-group"),
		})
		if err != nil {
			return err
		}
		_, err = vpn.NewVpnTunnel(ctx, "test", &vpn.VpnTunnelArgs{
			Name:          pulumi.String("my-tunnel"),
			Encapsulation: pulumi.String("ipsec-transport"),
			Status:        pulumi.String("active"),
			TunnelGroupId: test.ID(),
			Description:   pulumi.String("This is a description."),
			TunnelId:      pulumi.Int(3),
			TenantId:      pulumi.Int(2),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

func GetVpnTunnel 

func GetVpnTunnel(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *VpnTunnelState, opts ...pulumi.ResourceOption) (*VpnTunnel, error)

GetVpnTunnel gets an existing VpnTunnel resource's state with the given name, ID, and optional state properties that are used to uniquely qualify the lookup (nil if not required).

func NewVpnTunnel 

func NewVpnTunnel(ctx *pulumi.Context,
	name string, args *VpnTunnelArgs, opts ...pulumi.ResourceOption) (*VpnTunnel, error)

NewVpnTunnel registers a new resource with the given unique name, arguments, and options.

func (*VpnTunnel) ElementType 

func (*VpnTunnel) ElementType() reflect.Type

func (*VpnTunnel) ToVpnTunnelOutput 

func (i *VpnTunnel) ToVpnTunnelOutput() VpnTunnelOutput

func (*VpnTunnel) ToVpnTunnelOutputWithContext 

func (i *VpnTunnel) ToVpnTunnelOutputWithContext(ctx context.Context) VpnTunnelOutput

type VpnTunnelArgs 

type VpnTunnelArgs struct {
	Description pulumi.StringPtrInput
	// Valid values are `ipsec-transport`, `ipsec-tunnel`, `ip-ip` and `gre`.
	Encapsulation pulumi.StringInput
	Name          pulumi.StringPtrInput
	// Valid values are `planned`, `active` and `disabled`.
	Status        pulumi.StringInput
	Tags          pulumi.StringArrayInput
	TenantId      pulumi.IntPtrInput
	TunnelGroupId pulumi.IntInput
	TunnelId      pulumi.IntPtrInput
}

The set of arguments for constructing a VpnTunnel resource.

func (VpnTunnelArgs) ElementType 

func (VpnTunnelArgs) ElementType() reflect.Type

type VpnTunnelArray 

type VpnTunnelArray []VpnTunnelInput

func (VpnTunnelArray) ElementType 

func (VpnTunnelArray) ElementType() reflect.Type

func (VpnTunnelArray) ToVpnTunnelArrayOutput 

func (i VpnTunnelArray) ToVpnTunnelArrayOutput() VpnTunnelArrayOutput

func (VpnTunnelArray) ToVpnTunnelArrayOutputWithContext 

func (i VpnTunnelArray) ToVpnTunnelArrayOutputWithContext(ctx context.Context) VpnTunnelArrayOutput

type VpnTunnelArrayInput 

type VpnTunnelArrayInput interface {
	pulumi.Input

	ToVpnTunnelArrayOutput() VpnTunnelArrayOutput
	ToVpnTunnelArrayOutputWithContext(context.Context) VpnTunnelArrayOutput
}

VpnTunnelArrayInput is an input type that accepts VpnTunnelArray and VpnTunnelArrayOutput values. You can construct a concrete instance of `VpnTunnelArrayInput` via: 

VpnTunnelArray{ VpnTunnelArgs{...} }

type VpnTunnelArrayOutput 

type VpnTunnelArrayOutput struct{ *pulumi.OutputState }

func (VpnTunnelArrayOutput) ElementType 

func (VpnTunnelArrayOutput) ElementType() reflect.Type

func (VpnTunnelArrayOutput) Index 

func (o VpnTunnelArrayOutput) Index(i pulumi.IntInput) VpnTunnelOutput

func (VpnTunnelArrayOutput) ToVpnTunnelArrayOutput 

func (o VpnTunnelArrayOutput) ToVpnTunnelArrayOutput() VpnTunnelArrayOutput

func (VpnTunnelArrayOutput) ToVpnTunnelArrayOutputWithContext 

func (o VpnTunnelArrayOutput) ToVpnTunnelArrayOutputWithContext(ctx context.Context) VpnTunnelArrayOutput

type VpnTunnelGroup 

type VpnTunnelGroup struct {
	pulumi.CustomResourceState

	Description pulumi.StringPtrOutput `pulumi:"description"`
	Name        pulumi.StringOutput    `pulumi:"name"`
	Slug        pulumi.StringOutput    `pulumi:"slug"`
}

From the [official documentation](https://docs.netbox.dev/en/stable/features/vpn-tunnels/):

> NetBox can model private tunnels formed among virtual termination points across your network. Typical tunnel implementations include GRE, IP-in-IP, and IPSec. A tunnel may be terminated to two or more device or virtual machine interfaces. For convenient organization, tunnels may be assigned to user-defined groups.

## Example Usage

```go package main

import ( 

"github.com/NatzkaLabsOpenSource/pulumi-netbox/sdk/go/netbox/vpn"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := vpn.NewVpnTunnelGroup(ctx, "test", &vpn.VpnTunnelGroupArgs{
			Name:        pulumi.String("my-tunnel-group"),
			Description: pulumi.String("My description"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

func GetVpnTunnelGroup 

func GetVpnTunnelGroup(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *VpnTunnelGroupState, opts ...pulumi.ResourceOption) (*VpnTunnelGroup, error)

GetVpnTunnelGroup gets an existing VpnTunnelGroup resource's state with the given name, ID, and optional state properties that are used to uniquely qualify the lookup (nil if not required).

func NewVpnTunnelGroup 

func NewVpnTunnelGroup(ctx *pulumi.Context,
	name string, args *VpnTunnelGroupArgs, opts ...pulumi.ResourceOption) (*VpnTunnelGroup, error)

NewVpnTunnelGroup registers a new resource with the given unique name, arguments, and options.

func (*VpnTunnelGroup) ElementType 

func (*VpnTunnelGroup) ElementType() reflect.Type

func (*VpnTunnelGroup) ToVpnTunnelGroupOutput 

func (i *VpnTunnelGroup) ToVpnTunnelGroupOutput() VpnTunnelGroupOutput

func (*VpnTunnelGroup) ToVpnTunnelGroupOutputWithContext 

func (i *VpnTunnelGroup) ToVpnTunnelGroupOutputWithContext(ctx context.Context) VpnTunnelGroupOutput

type VpnTunnelGroupArgs 

type VpnTunnelGroupArgs struct {
	Description pulumi.StringPtrInput
	Name        pulumi.StringPtrInput
	Slug        pulumi.StringPtrInput
}

The set of arguments for constructing a VpnTunnelGroup resource.

func (VpnTunnelGroupArgs) ElementType 

func (VpnTunnelGroupArgs) ElementType() reflect.Type

type VpnTunnelGroupArray 

type VpnTunnelGroupArray []VpnTunnelGroupInput

func (VpnTunnelGroupArray) ElementType 

func (VpnTunnelGroupArray) ElementType() reflect.Type

func (VpnTunnelGroupArray) ToVpnTunnelGroupArrayOutput 

func (i VpnTunnelGroupArray) ToVpnTunnelGroupArrayOutput() VpnTunnelGroupArrayOutput

func (VpnTunnelGroupArray) ToVpnTunnelGroupArrayOutputWithContext 

func (i VpnTunnelGroupArray) ToVpnTunnelGroupArrayOutputWithContext(ctx context.Context) VpnTunnelGroupArrayOutput

type VpnTunnelGroupArrayInput 

type VpnTunnelGroupArrayInput interface {
	pulumi.Input

	ToVpnTunnelGroupArrayOutput() VpnTunnelGroupArrayOutput
	ToVpnTunnelGroupArrayOutputWithContext(context.Context) VpnTunnelGroupArrayOutput
}

VpnTunnelGroupArrayInput is an input type that accepts VpnTunnelGroupArray and VpnTunnelGroupArrayOutput values. You can construct a concrete instance of `VpnTunnelGroupArrayInput` via: 

VpnTunnelGroupArray{ VpnTunnelGroupArgs{...} }

type VpnTunnelGroupArrayOutput 

type VpnTunnelGroupArrayOutput struct{ *pulumi.OutputState }

func (VpnTunnelGroupArrayOutput) ElementType 

func (VpnTunnelGroupArrayOutput) ElementType() reflect.Type

func (VpnTunnelGroupArrayOutput) Index 

func (o VpnTunnelGroupArrayOutput) Index(i pulumi.IntInput) VpnTunnelGroupOutput

func (VpnTunnelGroupArrayOutput) ToVpnTunnelGroupArrayOutput 

func (o VpnTunnelGroupArrayOutput) ToVpnTunnelGroupArrayOutput() VpnTunnelGroupArrayOutput

func (VpnTunnelGroupArrayOutput) ToVpnTunnelGroupArrayOutputWithContext 

func (o VpnTunnelGroupArrayOutput) ToVpnTunnelGroupArrayOutputWithContext(ctx context.Context) VpnTunnelGroupArrayOutput

type VpnTunnelGroupInput 

type VpnTunnelGroupInput interface {
	pulumi.Input

	ToVpnTunnelGroupOutput() VpnTunnelGroupOutput
	ToVpnTunnelGroupOutputWithContext(ctx context.Context) VpnTunnelGroupOutput
}

type VpnTunnelGroupMap 

type VpnTunnelGroupMap map[string]VpnTunnelGroupInput

func (VpnTunnelGroupMap) ElementType 

func (VpnTunnelGroupMap) ElementType() reflect.Type

func (VpnTunnelGroupMap) ToVpnTunnelGroupMapOutput 

func (i VpnTunnelGroupMap) ToVpnTunnelGroupMapOutput() VpnTunnelGroupMapOutput

func (VpnTunnelGroupMap) ToVpnTunnelGroupMapOutputWithContext 

func (i VpnTunnelGroupMap) ToVpnTunnelGroupMapOutputWithContext(ctx context.Context) VpnTunnelGroupMapOutput

type VpnTunnelGroupMapInput 

type VpnTunnelGroupMapInput interface {
	pulumi.Input

	ToVpnTunnelGroupMapOutput() VpnTunnelGroupMapOutput
	ToVpnTunnelGroupMapOutputWithContext(context.Context) VpnTunnelGroupMapOutput
}

VpnTunnelGroupMapInput is an input type that accepts VpnTunnelGroupMap and VpnTunnelGroupMapOutput values. You can construct a concrete instance of `VpnTunnelGroupMapInput` via: 

VpnTunnelGroupMap{ "key": VpnTunnelGroupArgs{...} }

type VpnTunnelGroupMapOutput 

type VpnTunnelGroupMapOutput struct{ *pulumi.OutputState }

func (VpnTunnelGroupMapOutput) ElementType 

func (VpnTunnelGroupMapOutput) ElementType() reflect.Type

func (VpnTunnelGroupMapOutput) MapIndex 

func (o VpnTunnelGroupMapOutput) MapIndex(k pulumi.StringInput) VpnTunnelGroupOutput

func (VpnTunnelGroupMapOutput) ToVpnTunnelGroupMapOutput 

func (o VpnTunnelGroupMapOutput) ToVpnTunnelGroupMapOutput() VpnTunnelGroupMapOutput

func (VpnTunnelGroupMapOutput) ToVpnTunnelGroupMapOutputWithContext 

func (o VpnTunnelGroupMapOutput) ToVpnTunnelGroupMapOutputWithContext(ctx context.Context) VpnTunnelGroupMapOutput

type VpnTunnelGroupOutput 

type VpnTunnelGroupOutput struct{ *pulumi.OutputState }

func (VpnTunnelGroupOutput) Description 

func (o VpnTunnelGroupOutput) Description() pulumi.StringPtrOutput

func (VpnTunnelGroupOutput) ElementType 

func (VpnTunnelGroupOutput) ElementType() reflect.Type

func (VpnTunnelGroupOutput) Name 

func (o VpnTunnelGroupOutput) Name() pulumi.StringOutput

func (VpnTunnelGroupOutput) Slug 

func (o VpnTunnelGroupOutput) Slug() pulumi.StringOutput

func (VpnTunnelGroupOutput) ToVpnTunnelGroupOutput 

func (o VpnTunnelGroupOutput) ToVpnTunnelGroupOutput() VpnTunnelGroupOutput

func (VpnTunnelGroupOutput) ToVpnTunnelGroupOutputWithContext 

func (o VpnTunnelGroupOutput) ToVpnTunnelGroupOutputWithContext(ctx context.Context) VpnTunnelGroupOutput

type VpnTunnelGroupState 

type VpnTunnelGroupState struct {
	Description pulumi.StringPtrInput
	Name        pulumi.StringPtrInput
	Slug        pulumi.StringPtrInput
}

func (VpnTunnelGroupState) ElementType 

func (VpnTunnelGroupState) ElementType() reflect.Type

type VpnTunnelInput 

type VpnTunnelInput interface {
	pulumi.Input

	ToVpnTunnelOutput() VpnTunnelOutput
	ToVpnTunnelOutputWithContext(ctx context.Context) VpnTunnelOutput
}

type VpnTunnelMap 

type VpnTunnelMap map[string]VpnTunnelInput

func (VpnTunnelMap) ElementType 

func (VpnTunnelMap) ElementType() reflect.Type

func (VpnTunnelMap) ToVpnTunnelMapOutput 

func (i VpnTunnelMap) ToVpnTunnelMapOutput() VpnTunnelMapOutput

func (VpnTunnelMap) ToVpnTunnelMapOutputWithContext 

func (i VpnTunnelMap) ToVpnTunnelMapOutputWithContext(ctx context.Context) VpnTunnelMapOutput

type VpnTunnelMapInput 

type VpnTunnelMapInput interface {
	pulumi.Input

	ToVpnTunnelMapOutput() VpnTunnelMapOutput
	ToVpnTunnelMapOutputWithContext(context.Context) VpnTunnelMapOutput
}

VpnTunnelMapInput is an input type that accepts VpnTunnelMap and VpnTunnelMapOutput values. You can construct a concrete instance of `VpnTunnelMapInput` via: 

VpnTunnelMap{ "key": VpnTunnelArgs{...} }

type VpnTunnelMapOutput 

type VpnTunnelMapOutput struct{ *pulumi.OutputState }

func (VpnTunnelMapOutput) ElementType 

func (VpnTunnelMapOutput) ElementType() reflect.Type

func (VpnTunnelMapOutput) MapIndex 

func (o VpnTunnelMapOutput) MapIndex(k pulumi.StringInput) VpnTunnelOutput

func (VpnTunnelMapOutput) ToVpnTunnelMapOutput 

func (o VpnTunnelMapOutput) ToVpnTunnelMapOutput() VpnTunnelMapOutput

func (VpnTunnelMapOutput) ToVpnTunnelMapOutputWithContext 

func (o VpnTunnelMapOutput) ToVpnTunnelMapOutputWithContext(ctx context.Context) VpnTunnelMapOutput

type VpnTunnelOutput 

type VpnTunnelOutput struct{ *pulumi.OutputState }

func (VpnTunnelOutput) Description 

func (o VpnTunnelOutput) Description() pulumi.StringPtrOutput

func (VpnTunnelOutput) ElementType 

func (VpnTunnelOutput) ElementType() reflect.Type

func (VpnTunnelOutput) Encapsulation 

func (o VpnTunnelOutput) Encapsulation() pulumi.StringOutput

Valid values are `ipsec-transport`, `ipsec-tunnel`, `ip-ip` and `gre`.

func (VpnTunnelOutput) Name 

func (o VpnTunnelOutput) Name() pulumi.StringOutput

func (VpnTunnelOutput) Status 

func (o VpnTunnelOutput) Status() pulumi.StringOutput

Valid values are `planned`, `active` and `disabled`.

func (VpnTunnelOutput) Tags 

func (o VpnTunnelOutput) Tags() pulumi.StringArrayOutput

func (VpnTunnelOutput) TagsAlls 

func (o VpnTunnelOutput) TagsAlls() pulumi.StringArrayOutput

func (VpnTunnelOutput) TenantId 

func (o VpnTunnelOutput) TenantId() pulumi.IntPtrOutput

func (VpnTunnelOutput) ToVpnTunnelOutput 

func (o VpnTunnelOutput) ToVpnTunnelOutput() VpnTunnelOutput

func (VpnTunnelOutput) ToVpnTunnelOutputWithContext 

func (o VpnTunnelOutput) ToVpnTunnelOutputWithContext(ctx context.Context) VpnTunnelOutput

func (VpnTunnelOutput) TunnelGroupId 

func (o VpnTunnelOutput) TunnelGroupId() pulumi.IntOutput

func (VpnTunnelOutput) TunnelId 

func (o VpnTunnelOutput) TunnelId() pulumi.IntPtrOutput

type VpnTunnelState 

type VpnTunnelState struct {
	Description pulumi.StringPtrInput
	// Valid values are `ipsec-transport`, `ipsec-tunnel`, `ip-ip` and `gre`.
	Encapsulation pulumi.StringPtrInput
	Name          pulumi.StringPtrInput
	// Valid values are `planned`, `active` and `disabled`.
	Status        pulumi.StringPtrInput
	Tags          pulumi.StringArrayInput
	TagsAlls      pulumi.StringArrayInput
	TenantId      pulumi.IntPtrInput
	TunnelGroupId pulumi.IntPtrInput
	TunnelId      pulumi.IntPtrInput
}

func (VpnTunnelState) ElementType 

func (VpnTunnelState) ElementType() reflect.Type

type VpnTunnelTermination 

type VpnTunnelTermination struct {
	pulumi.CustomResourceState

	// Exactly one of `virtualMachineInterfaceId` or `deviceInterfaceId` must be given.
	DeviceInterfaceId  pulumi.IntPtrOutput `pulumi:"deviceInterfaceId"`
	OutsideIpAddressId pulumi.IntPtrOutput `pulumi:"outsideIpAddressId"`
	// Valid values are `peer`, `hub` and `spoke`.
	Role     pulumi.StringOutput      `pulumi:"role"`
	Tags     pulumi.StringArrayOutput `pulumi:"tags"`
	TagsAlls pulumi.StringArrayOutput `pulumi:"tagsAlls"`
	TunnelId pulumi.IntOutput         `pulumi:"tunnelId"`
	// Exactly one of `virtualMachineInterfaceId` or `deviceInterfaceId` must be given.
	VirtualMachineInterfaceId pulumi.IntPtrOutput `pulumi:"virtualMachineInterfaceId"`
}

From the [official documentation](https://docs.netbox.dev/en/stable/features/vpn-tunnels/):

> NetBox can model private tunnels formed among virtual termination points across your network. Typical tunnel implementations include GRE, IP-in-IP, and IPSec. A tunnel may be terminated to two or more device or virtual machine interfaces. For convenient organization, tunnels may be assigned to user-defined groups.

## Example Usage

```go package main

import ( 

"github.com/NatzkaLabsOpenSource/pulumi-netbox/sdk/go/netbox/vpn"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		test, err := vpn.NewVpnTunnelGroup(ctx, "test", &vpn.VpnTunnelGroupArgs{
			Name:        pulumi.String("my-tunnel-group"),
			Description: pulumi.String("description"),
		})
		if err != nil {
			return err
		}
		testVpnTunnel, err := vpn.NewVpnTunnel(ctx, "test", &vpn.VpnTunnelArgs{
			Name:          pulumi.String("my-tunnel"),
			Encapsulation: pulumi.String("ipsec-transport"),
			Status:        pulumi.String("active"),
			TunnelGroupId: test.ID(),
		})
		if err != nil {
			return err
		}
		_, err = vpn.NewVpnTunnelTermination(ctx, "device", &vpn.VpnTunnelTerminationArgs{
			Role:              pulumi.String("peer"),
			TunnelId:          testVpnTunnel.ID(),
			DeviceInterfaceId: pulumi.Int(123),
		})
		if err != nil {
			return err
		}
		_, err = vpn.NewVpnTunnelTermination(ctx, "vm", &vpn.VpnTunnelTerminationArgs{
			Role:                      pulumi.String("peer"),
			TunnelId:                  testVpnTunnel.ID(),
			VirtualMachineInterfaceId: pulumi.Int(234),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

func GetVpnTunnelTermination 

func GetVpnTunnelTermination(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *VpnTunnelTerminationState, opts ...pulumi.ResourceOption) (*VpnTunnelTermination, error)

GetVpnTunnelTermination gets an existing VpnTunnelTermination resource's state with the given name, ID, and optional state properties that are used to uniquely qualify the lookup (nil if not required).

func NewVpnTunnelTermination 

func NewVpnTunnelTermination(ctx *pulumi.Context,
	name string, args *VpnTunnelTerminationArgs, opts ...pulumi.ResourceOption) (*VpnTunnelTermination, error)

NewVpnTunnelTermination registers a new resource with the given unique name, arguments, and options.

func (*VpnTunnelTermination) ElementType 

func (*VpnTunnelTermination) ElementType() reflect.Type

func (*VpnTunnelTermination) ToVpnTunnelTerminationOutput 

func (i *VpnTunnelTermination) ToVpnTunnelTerminationOutput() VpnTunnelTerminationOutput

func (*VpnTunnelTermination) ToVpnTunnelTerminationOutputWithContext 

func (i *VpnTunnelTermination) ToVpnTunnelTerminationOutputWithContext(ctx context.Context) VpnTunnelTerminationOutput

type VpnTunnelTerminationArgs 

type VpnTunnelTerminationArgs struct {
	// Exactly one of `virtualMachineInterfaceId` or `deviceInterfaceId` must be given.
	DeviceInterfaceId  pulumi.IntPtrInput
	OutsideIpAddressId pulumi.IntPtrInput
	// Valid values are `peer`, `hub` and `spoke`.
	Role     pulumi.StringInput
	Tags     pulumi.StringArrayInput
	TunnelId pulumi.IntInput
	// Exactly one of `virtualMachineInterfaceId` or `deviceInterfaceId` must be given.
	VirtualMachineInterfaceId pulumi.IntPtrInput
}

The set of arguments for constructing a VpnTunnelTermination resource.

func (VpnTunnelTerminationArgs) ElementType 

func (VpnTunnelTerminationArgs) ElementType() reflect.Type

type VpnTunnelTerminationArray 

type VpnTunnelTerminationArray []VpnTunnelTerminationInput

func (VpnTunnelTerminationArray) ElementType 

func (VpnTunnelTerminationArray) ElementType() reflect.Type

func (VpnTunnelTerminationArray) ToVpnTunnelTerminationArrayOutput 

func (i VpnTunnelTerminationArray) ToVpnTunnelTerminationArrayOutput() VpnTunnelTerminationArrayOutput

func (VpnTunnelTerminationArray) ToVpnTunnelTerminationArrayOutputWithContext 

func (i VpnTunnelTerminationArray) ToVpnTunnelTerminationArrayOutputWithContext(ctx context.Context) VpnTunnelTerminationArrayOutput

type VpnTunnelTerminationArrayInput 

type VpnTunnelTerminationArrayInput interface {
	pulumi.Input

	ToVpnTunnelTerminationArrayOutput() VpnTunnelTerminationArrayOutput
	ToVpnTunnelTerminationArrayOutputWithContext(context.Context) VpnTunnelTerminationArrayOutput
}

VpnTunnelTerminationArrayInput is an input type that accepts VpnTunnelTerminationArray and VpnTunnelTerminationArrayOutput values. You can construct a concrete instance of `VpnTunnelTerminationArrayInput` via: 

VpnTunnelTerminationArray{ VpnTunnelTerminationArgs{...} }

type VpnTunnelTerminationArrayOutput 

type VpnTunnelTerminationArrayOutput struct{ *pulumi.OutputState }

func (VpnTunnelTerminationArrayOutput) ElementType 

func (VpnTunnelTerminationArrayOutput) ElementType() reflect.Type

func (VpnTunnelTerminationArrayOutput) Index 

func (o VpnTunnelTerminationArrayOutput) Index(i pulumi.IntInput) VpnTunnelTerminationOutput

func (VpnTunnelTerminationArrayOutput) ToVpnTunnelTerminationArrayOutput 

func (o VpnTunnelTerminationArrayOutput) ToVpnTunnelTerminationArrayOutput() VpnTunnelTerminationArrayOutput

func (VpnTunnelTerminationArrayOutput) ToVpnTunnelTerminationArrayOutputWithContext 

func (o VpnTunnelTerminationArrayOutput) ToVpnTunnelTerminationArrayOutputWithContext(ctx context.Context) VpnTunnelTerminationArrayOutput

type VpnTunnelTerminationInput 

type VpnTunnelTerminationInput interface {
	pulumi.Input

	ToVpnTunnelTerminationOutput() VpnTunnelTerminationOutput
	ToVpnTunnelTerminationOutputWithContext(ctx context.Context) VpnTunnelTerminationOutput
}

type VpnTunnelTerminationMap 

type VpnTunnelTerminationMap map[string]VpnTunnelTerminationInput

func (VpnTunnelTerminationMap) ElementType 

func (VpnTunnelTerminationMap) ElementType() reflect.Type

func (VpnTunnelTerminationMap) ToVpnTunnelTerminationMapOutput 

func (i VpnTunnelTerminationMap) ToVpnTunnelTerminationMapOutput() VpnTunnelTerminationMapOutput

func (VpnTunnelTerminationMap) ToVpnTunnelTerminationMapOutputWithContext 

func (i VpnTunnelTerminationMap) ToVpnTunnelTerminationMapOutputWithContext(ctx context.Context) VpnTunnelTerminationMapOutput

type VpnTunnelTerminationMapInput 

type VpnTunnelTerminationMapInput interface {
	pulumi.Input

	ToVpnTunnelTerminationMapOutput() VpnTunnelTerminationMapOutput
	ToVpnTunnelTerminationMapOutputWithContext(context.Context) VpnTunnelTerminationMapOutput
}

VpnTunnelTerminationMapInput is an input type that accepts VpnTunnelTerminationMap and VpnTunnelTerminationMapOutput values. You can construct a concrete instance of `VpnTunnelTerminationMapInput` via: 

VpnTunnelTerminationMap{ "key": VpnTunnelTerminationArgs{...} }

type VpnTunnelTerminationMapOutput 

type VpnTunnelTerminationMapOutput struct{ *pulumi.OutputState }

func (VpnTunnelTerminationMapOutput) ElementType 

func (VpnTunnelTerminationMapOutput) ElementType() reflect.Type

func (VpnTunnelTerminationMapOutput) MapIndex 

func (o VpnTunnelTerminationMapOutput) MapIndex(k pulumi.StringInput) VpnTunnelTerminationOutput

func (VpnTunnelTerminationMapOutput) ToVpnTunnelTerminationMapOutput 

func (o VpnTunnelTerminationMapOutput) ToVpnTunnelTerminationMapOutput() VpnTunnelTerminationMapOutput

func (VpnTunnelTerminationMapOutput) ToVpnTunnelTerminationMapOutputWithContext 

func (o VpnTunnelTerminationMapOutput) ToVpnTunnelTerminationMapOutputWithContext(ctx context.Context) VpnTunnelTerminationMapOutput

type VpnTunnelTerminationOutput 

type VpnTunnelTerminationOutput struct{ *pulumi.OutputState }

func (VpnTunnelTerminationOutput) DeviceInterfaceId 

func (o VpnTunnelTerminationOutput) DeviceInterfaceId() pulumi.IntPtrOutput

Exactly one of `virtualMachineInterfaceId` or `deviceInterfaceId` must be given.

func (VpnTunnelTerminationOutput) ElementType 

func (VpnTunnelTerminationOutput) ElementType() reflect.Type

func (VpnTunnelTerminationOutput) OutsideIpAddressId 

func (o VpnTunnelTerminationOutput) OutsideIpAddressId() pulumi.IntPtrOutput

func (VpnTunnelTerminationOutput) Role 

func (o VpnTunnelTerminationOutput) Role() pulumi.StringOutput

Valid values are `peer`, `hub` and `spoke`.

func (VpnTunnelTerminationOutput) Tags 

func (o VpnTunnelTerminationOutput) Tags() pulumi.StringArrayOutput

func (VpnTunnelTerminationOutput) TagsAlls 

func (o VpnTunnelTerminationOutput) TagsAlls() pulumi.StringArrayOutput

func (VpnTunnelTerminationOutput) ToVpnTunnelTerminationOutput 

func (o VpnTunnelTerminationOutput) ToVpnTunnelTerminationOutput() VpnTunnelTerminationOutput

func (VpnTunnelTerminationOutput) ToVpnTunnelTerminationOutputWithContext 

func (o VpnTunnelTerminationOutput) ToVpnTunnelTerminationOutputWithContext(ctx context.Context) VpnTunnelTerminationOutput

func (VpnTunnelTerminationOutput) TunnelId 

func (o VpnTunnelTerminationOutput) TunnelId() pulumi.IntOutput

func (VpnTunnelTerminationOutput) VirtualMachineInterfaceId 

func (o VpnTunnelTerminationOutput) VirtualMachineInterfaceId() pulumi.IntPtrOutput

Exactly one of `virtualMachineInterfaceId` or `deviceInterfaceId` must be given.

type VpnTunnelTerminationState 

type VpnTunnelTerminationState struct {
	// Exactly one of `virtualMachineInterfaceId` or `deviceInterfaceId` must be given.
	DeviceInterfaceId  pulumi.IntPtrInput
	OutsideIpAddressId pulumi.IntPtrInput
	// Valid values are `peer`, `hub` and `spoke`.
	Role     pulumi.StringPtrInput
	Tags     pulumi.StringArrayInput
	TagsAlls pulumi.StringArrayInput
	TunnelId pulumi.IntPtrInput
	// Exactly one of `virtualMachineInterfaceId` or `deviceInterfaceId` must be given.
	VirtualMachineInterfaceId pulumi.IntPtrInput
}

func (VpnTunnelTerminationState) ElementType 

func (VpnTunnelTerminationState) ElementType() reflect.Type

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.