networkmanagement

package
v5.26.0 Latest Latest
Warning

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

 Go to latest Published: Nov 1, 2021 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 ConnectivityTest 

type ConnectivityTest struct {
	pulumi.CustomResourceState

	// The user-supplied description of the Connectivity Test.
	// Maximum of 512 characters.
	Description pulumi.StringPtrOutput `pulumi:"description"`
	// Required. Destination specification of the Connectivity Test.
	// You can use a combination of destination IP address, Compute
	// Engine VM instance, or VPC network to uniquely identify the
	// destination location.
	// Even if the destination IP address is not unique, the source IP
	// location is unique. Usually, the analysis can infer the destination
	// endpoint from route information.
	// If the destination you specify is a VM instance and the instance has
	// multiple network interfaces, then you must also specify either a
	// destination IP address or VPC network to identify the destination
	// interface.
	// A reachability analysis proceeds even if the destination location
	// is ambiguous. However, the result can include endpoints that you
	// don't intend to test.
	// Structure is documented below.
	Destination ConnectivityTestDestinationOutput `pulumi:"destination"`
	// Resource labels to represent user-provided metadata.
	Labels pulumi.StringMapOutput `pulumi:"labels"`
	// Unique name for the connectivity test.
	Name pulumi.StringOutput `pulumi:"name"`
	// The ID of the project in which the resource belongs.
	// If it is not provided, the provider project is used.
	Project pulumi.StringOutput `pulumi:"project"`
	// IP Protocol of the test. When not provided, "TCP" is assumed.
	Protocol pulumi.StringPtrOutput `pulumi:"protocol"`
	// Other projects that may be relevant for reachability analysis.
	// This is applicable to scenarios where a test can cross project
	// boundaries.
	RelatedProjects pulumi.StringArrayOutput `pulumi:"relatedProjects"`
	// Required. Source specification of the Connectivity Test.
	// You can use a combination of source IP address, virtual machine
	// (VM) instance, or Compute Engine network to uniquely identify the
	// source location.
	// Examples: If the source IP address is an internal IP address within
	// a Google Cloud Virtual Private Cloud (VPC) network, then you must
	// also specify the VPC network. Otherwise, specify the VM instance,
	// which already contains its internal IP address and VPC network
	// information.
	// If the source of the test is within an on-premises network, then
	// you must provide the destination VPC network.
	// If the source endpoint is a Compute Engine VM instance with multiple
	// network interfaces, the instance itself is not sufficient to
	// identify the endpoint. So, you must also specify the source IP
	// address or VPC network.
	// A reachability analysis proceeds even if the source location is
	// ambiguous. However, the test result may include endpoints that
	// you don't intend to test.
	// Structure is documented below.
	Source ConnectivityTestSourceOutput `pulumi:"source"`
}

A connectivity test are a static analysis of your resource configurations that enables you to evaluate connectivity to and from Google Cloud resources in your Virtual Private Cloud (VPC) network.

To get more information about ConnectivityTest, see:

* [API documentation](https://cloud.google.com/network-intelligence-center/docs/connectivity-tests/reference/networkmanagement/rest/v1/projects.locations.global.connectivityTests) * How-to Guides

## Example Usage ### Network Management Connectivity Test Instances

```go package main

import ( 

"github.com/pulumi/pulumi-gcp/sdk/v5/go/gcp/compute"
"github.com/pulumi/pulumi-gcp/sdk/v5/go/gcp/networkmanagement"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		vpc, err := compute.NewNetwork(ctx, "vpc", nil)
		if err != nil {
			return err
		}
		opt0 := "debian-9"
		opt1 := "debian-cloud"
		debian9, err := compute.LookupImage(ctx, &compute.LookupImageArgs{
			Family:  &opt0,
			Project: &opt1,
		}, nil)
		if err != nil {
			return err
		}
		source, err := compute.NewInstance(ctx, "source", &compute.InstanceArgs{
			MachineType: pulumi.String("e2-medium"),
			BootDisk: &compute.InstanceBootDiskArgs{
				InitializeParams: &compute.InstanceBootDiskInitializeParamsArgs{
					Image: pulumi.String(debian9.Id),
				},
			},
			NetworkInterfaces: compute.InstanceNetworkInterfaceArray{
				&compute.InstanceNetworkInterfaceArgs{
					Network: vpc.ID(),
					AccessConfigs: compute.InstanceNetworkInterfaceAccessConfigArray{
						nil,
					},
				},
			},
		})
		if err != nil {
			return err
		}
		destination, err := compute.NewInstance(ctx, "destination", &compute.InstanceArgs{
			MachineType: pulumi.String("e2-medium"),
			BootDisk: &compute.InstanceBootDiskArgs{
				InitializeParams: &compute.InstanceBootDiskInitializeParamsArgs{
					Image: pulumi.String(debian9.Id),
				},
			},
			NetworkInterfaces: compute.InstanceNetworkInterfaceArray{
				&compute.InstanceNetworkInterfaceArgs{
					Network: vpc.ID(),
					AccessConfigs: compute.InstanceNetworkInterfaceAccessConfigArray{
						nil,
					},
				},
			},
		})
		if err != nil {
			return err
		}
		_, err = networkmanagement.NewConnectivityTest(ctx, "instance_test", &networkmanagement.ConnectivityTestArgs{
			Source: &networkmanagement.ConnectivityTestSourceArgs{
				Instance: source.ID(),
			},
			Destination: &networkmanagement.ConnectivityTestDestinationArgs{
				Instance: destination.ID(),
			},
			Protocol: pulumi.String("TCP"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

``` ### Network Management Connectivity Test Addresses

```go package main

import ( 

"github.com/pulumi/pulumi-gcp/sdk/v5/go/gcp/compute"
"github.com/pulumi/pulumi-gcp/sdk/v5/go/gcp/networkmanagement"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		vpc, err := compute.NewNetwork(ctx, "vpc", nil)
		if err != nil {
			return err
		}
		subnet, err := compute.NewSubnetwork(ctx, "subnet", &compute.SubnetworkArgs{
			IpCidrRange: pulumi.String("10.0.0.0/16"),
			Region:      pulumi.String("us-central1"),
			Network:     vpc.ID(),
		})
		if err != nil {
			return err
		}
		_, err = compute.NewAddress(ctx, "source_addr", &compute.AddressArgs{
			Subnetwork:  subnet.ID(),
			AddressType: pulumi.String("INTERNAL"),
			Address:     pulumi.String("10.0.42.42"),
			Region:      pulumi.String("us-central1"),
		})
		if err != nil {
			return err
		}
		_, err = compute.NewAddress(ctx, "dest_addr", &compute.AddressArgs{
			Subnetwork:  subnet.ID(),
			AddressType: pulumi.String("INTERNAL"),
			Address:     pulumi.String("10.0.43.43"),
			Region:      pulumi.String("us-central1"),
		})
		if err != nil {
			return err
		}
		_, err = networkmanagement.NewConnectivityTest(ctx, "address_test", &networkmanagement.ConnectivityTestArgs{
			Source: &networkmanagement.ConnectivityTestSourceArgs{
				IpAddress:   source_addr.Address,
				ProjectId:   source_addr.Project,
				Network:     vpc.ID(),
				NetworkType: pulumi.String("GCP_NETWORK"),
			},
			Destination: &networkmanagement.ConnectivityTestDestinationArgs{
				IpAddress: dest_addr.Address,
				ProjectId: dest_addr.Project,
				Network:   vpc.ID(),
			},
			Protocol: pulumi.String("UDP"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

ConnectivityTest can be imported using any of these accepted formats

```sh 

$ pulumi import gcp:networkmanagement/connectivityTest:ConnectivityTest default projects/{{project}}/locations/global/connectivityTests/{{name}}

```

```sh 

$ pulumi import gcp:networkmanagement/connectivityTest:ConnectivityTest default {{project}}/{{name}}

```

```sh 

$ pulumi import gcp:networkmanagement/connectivityTest:ConnectivityTest default {{name}}

```

func GetConnectivityTest 

func GetConnectivityTest(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *ConnectivityTestState, opts ...pulumi.ResourceOption) (*ConnectivityTest, error)

GetConnectivityTest gets an existing ConnectivityTest 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 NewConnectivityTest 

func NewConnectivityTest(ctx *pulumi.Context,
	name string, args *ConnectivityTestArgs, opts ...pulumi.ResourceOption) (*ConnectivityTest, error)

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

func (*ConnectivityTest) ElementType 

func (*ConnectivityTest) ElementType() reflect.Type

func (*ConnectivityTest) ToConnectivityTestOutput 

func (i *ConnectivityTest) ToConnectivityTestOutput() ConnectivityTestOutput

func (*ConnectivityTest) ToConnectivityTestOutputWithContext 

func (i *ConnectivityTest) ToConnectivityTestOutputWithContext(ctx context.Context) ConnectivityTestOutput

func (*ConnectivityTest) ToConnectivityTestPtrOutput 

func (i *ConnectivityTest) ToConnectivityTestPtrOutput() ConnectivityTestPtrOutput

func (*ConnectivityTest) ToConnectivityTestPtrOutputWithContext 

func (i *ConnectivityTest) ToConnectivityTestPtrOutputWithContext(ctx context.Context) ConnectivityTestPtrOutput

type ConnectivityTestArgs 

type ConnectivityTestArgs struct {
	// The user-supplied description of the Connectivity Test.
	// Maximum of 512 characters.
	Description pulumi.StringPtrInput
	// Required. Destination specification of the Connectivity Test.
	// You can use a combination of destination IP address, Compute
	// Engine VM instance, or VPC network to uniquely identify the
	// destination location.
	// Even if the destination IP address is not unique, the source IP
	// location is unique. Usually, the analysis can infer the destination
	// endpoint from route information.
	// If the destination you specify is a VM instance and the instance has
	// multiple network interfaces, then you must also specify either a
	// destination IP address or VPC network to identify the destination
	// interface.
	// A reachability analysis proceeds even if the destination location
	// is ambiguous. However, the result can include endpoints that you
	// don't intend to test.
	// Structure is documented below.
	Destination ConnectivityTestDestinationInput
	// Resource labels to represent user-provided metadata.
	Labels pulumi.StringMapInput
	// Unique name for the connectivity test.
	Name pulumi.StringPtrInput
	// The ID of the project in which the resource belongs.
	// If it is not provided, the provider project is used.
	Project pulumi.StringPtrInput
	// IP Protocol of the test. When not provided, "TCP" is assumed.
	Protocol pulumi.StringPtrInput
	// Other projects that may be relevant for reachability analysis.
	// This is applicable to scenarios where a test can cross project
	// boundaries.
	RelatedProjects pulumi.StringArrayInput
	// Required. Source specification of the Connectivity Test.
	// You can use a combination of source IP address, virtual machine
	// (VM) instance, or Compute Engine network to uniquely identify the
	// source location.
	// Examples: If the source IP address is an internal IP address within
	// a Google Cloud Virtual Private Cloud (VPC) network, then you must
	// also specify the VPC network. Otherwise, specify the VM instance,
	// which already contains its internal IP address and VPC network
	// information.
	// If the source of the test is within an on-premises network, then
	// you must provide the destination VPC network.
	// If the source endpoint is a Compute Engine VM instance with multiple
	// network interfaces, the instance itself is not sufficient to
	// identify the endpoint. So, you must also specify the source IP
	// address or VPC network.
	// A reachability analysis proceeds even if the source location is
	// ambiguous. However, the test result may include endpoints that
	// you don't intend to test.
	// Structure is documented below.
	Source ConnectivityTestSourceInput
}

The set of arguments for constructing a ConnectivityTest resource.

func (ConnectivityTestArgs) ElementType 

func (ConnectivityTestArgs) ElementType() reflect.Type

type ConnectivityTestArray 

type ConnectivityTestArray []ConnectivityTestInput

func (ConnectivityTestArray) ElementType 

func (ConnectivityTestArray) ElementType() reflect.Type

func (ConnectivityTestArray) ToConnectivityTestArrayOutput 

func (i ConnectivityTestArray) ToConnectivityTestArrayOutput() ConnectivityTestArrayOutput

func (ConnectivityTestArray) ToConnectivityTestArrayOutputWithContext 

func (i ConnectivityTestArray) ToConnectivityTestArrayOutputWithContext(ctx context.Context) ConnectivityTestArrayOutput

type ConnectivityTestArrayInput 

type ConnectivityTestArrayInput interface {
	pulumi.Input

	ToConnectivityTestArrayOutput() ConnectivityTestArrayOutput
	ToConnectivityTestArrayOutputWithContext(context.Context) ConnectivityTestArrayOutput
}

ConnectivityTestArrayInput is an input type that accepts ConnectivityTestArray and ConnectivityTestArrayOutput values. You can construct a concrete instance of `ConnectivityTestArrayInput` via: 

ConnectivityTestArray{ ConnectivityTestArgs{...} }

type ConnectivityTestArrayOutput 

type ConnectivityTestArrayOutput struct{ *pulumi.OutputState }

func (ConnectivityTestArrayOutput) ElementType 

func (ConnectivityTestArrayOutput) ElementType() reflect.Type

func (ConnectivityTestArrayOutput) Index 

func (o ConnectivityTestArrayOutput) Index(i pulumi.IntInput) ConnectivityTestOutput

func (ConnectivityTestArrayOutput) ToConnectivityTestArrayOutput 

func (o ConnectivityTestArrayOutput) ToConnectivityTestArrayOutput() ConnectivityTestArrayOutput

func (ConnectivityTestArrayOutput) ToConnectivityTestArrayOutputWithContext 

func (o ConnectivityTestArrayOutput) ToConnectivityTestArrayOutputWithContext(ctx context.Context) ConnectivityTestArrayOutput

type ConnectivityTestDestination 

type ConnectivityTestDestination struct {
	// A Compute Engine instance URI.
	Instance *string `pulumi:"instance"`
	// The IP address of the endpoint, which can be an external or
	// internal IP. An IPv6 address is only allowed when the test's
	// destination is a global load balancer VIP.
	IpAddress *string `pulumi:"ipAddress"`
	// A Compute Engine network URI.
	Network *string `pulumi:"network"`
	// The IP protocol port of the endpoint. Only applicable when
	// protocol is TCP or UDP.
	Port *int `pulumi:"port"`
	// Project ID where the endpoint is located. The Project ID can be
	// derived from the URI if you provide a VM instance or network URI.
	// The following are two cases where you must provide the project ID:
	// 1. Only the IP address is specified, and the IP address is within
	//    a GCP project. 2. When you are using Shared VPC and the IP address
	//    that you provide is from the service project. In this case, the
	//    network that the IP address resides in is defined in the host
	//    project.
	ProjectId *string `pulumi:"projectId"`
}

type ConnectivityTestDestinationArgs 

type ConnectivityTestDestinationArgs struct {
	// A Compute Engine instance URI.
	Instance pulumi.StringPtrInput `pulumi:"instance"`
	// The IP address of the endpoint, which can be an external or
	// internal IP. An IPv6 address is only allowed when the test's
	// destination is a global load balancer VIP.
	IpAddress pulumi.StringPtrInput `pulumi:"ipAddress"`
	// A Compute Engine network URI.
	Network pulumi.StringPtrInput `pulumi:"network"`
	// The IP protocol port of the endpoint. Only applicable when
	// protocol is TCP or UDP.
	Port pulumi.IntPtrInput `pulumi:"port"`
	// Project ID where the endpoint is located. The Project ID can be
	// derived from the URI if you provide a VM instance or network URI.
	// The following are two cases where you must provide the project ID:
	// 1. Only the IP address is specified, and the IP address is within
	//    a GCP project. 2. When you are using Shared VPC and the IP address
	//    that you provide is from the service project. In this case, the
	//    network that the IP address resides in is defined in the host
	//    project.
	ProjectId pulumi.StringPtrInput `pulumi:"projectId"`
}

func (ConnectivityTestDestinationArgs) ElementType 

func (ConnectivityTestDestinationArgs) ElementType() reflect.Type

func (ConnectivityTestDestinationArgs) ToConnectivityTestDestinationOutput 

func (i ConnectivityTestDestinationArgs) ToConnectivityTestDestinationOutput() ConnectivityTestDestinationOutput

func (ConnectivityTestDestinationArgs) ToConnectivityTestDestinationOutputWithContext 

func (i ConnectivityTestDestinationArgs) ToConnectivityTestDestinationOutputWithContext(ctx context.Context) ConnectivityTestDestinationOutput

func (ConnectivityTestDestinationArgs) ToConnectivityTestDestinationPtrOutput 

func (i ConnectivityTestDestinationArgs) ToConnectivityTestDestinationPtrOutput() ConnectivityTestDestinationPtrOutput

func (ConnectivityTestDestinationArgs) ToConnectivityTestDestinationPtrOutputWithContext 

func (i ConnectivityTestDestinationArgs) ToConnectivityTestDestinationPtrOutputWithContext(ctx context.Context) ConnectivityTestDestinationPtrOutput

type ConnectivityTestDestinationInput 

type ConnectivityTestDestinationInput interface {
	pulumi.Input

	ToConnectivityTestDestinationOutput() ConnectivityTestDestinationOutput
	ToConnectivityTestDestinationOutputWithContext(context.Context) ConnectivityTestDestinationOutput
}

ConnectivityTestDestinationInput is an input type that accepts ConnectivityTestDestinationArgs and ConnectivityTestDestinationOutput values. You can construct a concrete instance of `ConnectivityTestDestinationInput` via: 

ConnectivityTestDestinationArgs{...}

type ConnectivityTestDestinationOutput 

type ConnectivityTestDestinationOutput struct{ *pulumi.OutputState }

func (ConnectivityTestDestinationOutput) ElementType 

func (ConnectivityTestDestinationOutput) ElementType() reflect.Type

func (ConnectivityTestDestinationOutput) Instance 

func (o ConnectivityTestDestinationOutput) Instance() pulumi.StringPtrOutput

A Compute Engine instance URI.

func (ConnectivityTestDestinationOutput) IpAddress 

func (o ConnectivityTestDestinationOutput) IpAddress() pulumi.StringPtrOutput

The IP address of the endpoint, which can be an external or internal IP. An IPv6 address is only allowed when the test's destination is a global load balancer VIP.

func (ConnectivityTestDestinationOutput) Network 

func (o ConnectivityTestDestinationOutput) Network() pulumi.StringPtrOutput

A Compute Engine network URI.

func (ConnectivityTestDestinationOutput) Port 

func (o ConnectivityTestDestinationOutput) Port() pulumi.IntPtrOutput

The IP protocol port of the endpoint. Only applicable when protocol is TCP or UDP.

func (ConnectivityTestDestinationOutput) ProjectId 

func (o ConnectivityTestDestinationOutput) ProjectId() pulumi.StringPtrOutput

Project ID where the endpoint is located. The Project ID can be derived from the URI if you provide a VM instance or network URI. The following are two cases where you must provide the project ID:

  1. Only the IP address is specified, and the IP address is within a GCP project. 2. When you are using Shared VPC and the IP address that you provide is from the service project. In this case, the network that the IP address resides in is defined in the host project.

func (ConnectivityTestDestinationOutput) ToConnectivityTestDestinationOutput 

func (o ConnectivityTestDestinationOutput) ToConnectivityTestDestinationOutput() ConnectivityTestDestinationOutput

func (ConnectivityTestDestinationOutput) ToConnectivityTestDestinationOutputWithContext 

func (o ConnectivityTestDestinationOutput) ToConnectivityTestDestinationOutputWithContext(ctx context.Context) ConnectivityTestDestinationOutput

func (ConnectivityTestDestinationOutput) ToConnectivityTestDestinationPtrOutput 

func (o ConnectivityTestDestinationOutput) ToConnectivityTestDestinationPtrOutput() ConnectivityTestDestinationPtrOutput

func (ConnectivityTestDestinationOutput) ToConnectivityTestDestinationPtrOutputWithContext 

func (o ConnectivityTestDestinationOutput) ToConnectivityTestDestinationPtrOutputWithContext(ctx context.Context) ConnectivityTestDestinationPtrOutput

type ConnectivityTestDestinationPtrInput 

type ConnectivityTestDestinationPtrInput interface {
	pulumi.Input

	ToConnectivityTestDestinationPtrOutput() ConnectivityTestDestinationPtrOutput
	ToConnectivityTestDestinationPtrOutputWithContext(context.Context) ConnectivityTestDestinationPtrOutput
}

ConnectivityTestDestinationPtrInput is an input type that accepts ConnectivityTestDestinationArgs, ConnectivityTestDestinationPtr and ConnectivityTestDestinationPtrOutput values. You can construct a concrete instance of `ConnectivityTestDestinationPtrInput` via: 

        ConnectivityTestDestinationArgs{...}

or:

        nil

func ConnectivityTestDestinationPtr 

func ConnectivityTestDestinationPtr(v *ConnectivityTestDestinationArgs) ConnectivityTestDestinationPtrInput

type ConnectivityTestDestinationPtrOutput 

type ConnectivityTestDestinationPtrOutput struct{ *pulumi.OutputState }

func (ConnectivityTestDestinationPtrOutput) Elem 

func (o ConnectivityTestDestinationPtrOutput) Elem() ConnectivityTestDestinationOutput

func (ConnectivityTestDestinationPtrOutput) ElementType 

func (ConnectivityTestDestinationPtrOutput) ElementType() reflect.Type

func (ConnectivityTestDestinationPtrOutput) Instance 

func (o ConnectivityTestDestinationPtrOutput) Instance() pulumi.StringPtrOutput

A Compute Engine instance URI.

func (ConnectivityTestDestinationPtrOutput) IpAddress 

func (o ConnectivityTestDestinationPtrOutput) IpAddress() pulumi.StringPtrOutput

The IP address of the endpoint, which can be an external or internal IP. An IPv6 address is only allowed when the test's destination is a global load balancer VIP.

func (ConnectivityTestDestinationPtrOutput) Network 

func (o ConnectivityTestDestinationPtrOutput) Network() pulumi.StringPtrOutput

A Compute Engine network URI.

func (ConnectivityTestDestinationPtrOutput) Port 

func (o ConnectivityTestDestinationPtrOutput) Port() pulumi.IntPtrOutput

The IP protocol port of the endpoint. Only applicable when protocol is TCP or UDP.

func (ConnectivityTestDestinationPtrOutput) ProjectId 

func (o ConnectivityTestDestinationPtrOutput) ProjectId() pulumi.StringPtrOutput

Project ID where the endpoint is located. The Project ID can be derived from the URI if you provide a VM instance or network URI. The following are two cases where you must provide the project ID:

  1. Only the IP address is specified, and the IP address is within a GCP project. 2. When you are using Shared VPC and the IP address that you provide is from the service project. In this case, the network that the IP address resides in is defined in the host project.

func (ConnectivityTestDestinationPtrOutput) ToConnectivityTestDestinationPtrOutput 

func (o ConnectivityTestDestinationPtrOutput) ToConnectivityTestDestinationPtrOutput() ConnectivityTestDestinationPtrOutput

func (ConnectivityTestDestinationPtrOutput) ToConnectivityTestDestinationPtrOutputWithContext 

func (o ConnectivityTestDestinationPtrOutput) ToConnectivityTestDestinationPtrOutputWithContext(ctx context.Context) ConnectivityTestDestinationPtrOutput

type ConnectivityTestInput 

type ConnectivityTestInput interface {
	pulumi.Input

	ToConnectivityTestOutput() ConnectivityTestOutput
	ToConnectivityTestOutputWithContext(ctx context.Context) ConnectivityTestOutput
}

type ConnectivityTestMap 

type ConnectivityTestMap map[string]ConnectivityTestInput

func (ConnectivityTestMap) ElementType 

func (ConnectivityTestMap) ElementType() reflect.Type

func (ConnectivityTestMap) ToConnectivityTestMapOutput 

func (i ConnectivityTestMap) ToConnectivityTestMapOutput() ConnectivityTestMapOutput

func (ConnectivityTestMap) ToConnectivityTestMapOutputWithContext 

func (i ConnectivityTestMap) ToConnectivityTestMapOutputWithContext(ctx context.Context) ConnectivityTestMapOutput

type ConnectivityTestMapInput 

type ConnectivityTestMapInput interface {
	pulumi.Input

	ToConnectivityTestMapOutput() ConnectivityTestMapOutput
	ToConnectivityTestMapOutputWithContext(context.Context) ConnectivityTestMapOutput
}

ConnectivityTestMapInput is an input type that accepts ConnectivityTestMap and ConnectivityTestMapOutput values. You can construct a concrete instance of `ConnectivityTestMapInput` via: 

ConnectivityTestMap{ "key": ConnectivityTestArgs{...} }

type ConnectivityTestMapOutput 

type ConnectivityTestMapOutput struct{ *pulumi.OutputState }

func (ConnectivityTestMapOutput) ElementType 

func (ConnectivityTestMapOutput) ElementType() reflect.Type

func (ConnectivityTestMapOutput) MapIndex 

func (o ConnectivityTestMapOutput) MapIndex(k pulumi.StringInput) ConnectivityTestOutput

func (ConnectivityTestMapOutput) ToConnectivityTestMapOutput 

func (o ConnectivityTestMapOutput) ToConnectivityTestMapOutput() ConnectivityTestMapOutput

func (ConnectivityTestMapOutput) ToConnectivityTestMapOutputWithContext 

func (o ConnectivityTestMapOutput) ToConnectivityTestMapOutputWithContext(ctx context.Context) ConnectivityTestMapOutput

type ConnectivityTestOutput 

type ConnectivityTestOutput struct{ *pulumi.OutputState }

func (ConnectivityTestOutput) ElementType 

func (ConnectivityTestOutput) ElementType() reflect.Type

func (ConnectivityTestOutput) ToConnectivityTestOutput 

func (o ConnectivityTestOutput) ToConnectivityTestOutput() ConnectivityTestOutput

func (ConnectivityTestOutput) ToConnectivityTestOutputWithContext 

func (o ConnectivityTestOutput) ToConnectivityTestOutputWithContext(ctx context.Context) ConnectivityTestOutput

func (ConnectivityTestOutput) ToConnectivityTestPtrOutput 

func (o ConnectivityTestOutput) ToConnectivityTestPtrOutput() ConnectivityTestPtrOutput

func (ConnectivityTestOutput) ToConnectivityTestPtrOutputWithContext 

func (o ConnectivityTestOutput) ToConnectivityTestPtrOutputWithContext(ctx context.Context) ConnectivityTestPtrOutput

type ConnectivityTestPtrInput 

type ConnectivityTestPtrInput interface {
	pulumi.Input

	ToConnectivityTestPtrOutput() ConnectivityTestPtrOutput
	ToConnectivityTestPtrOutputWithContext(ctx context.Context) ConnectivityTestPtrOutput
}

type ConnectivityTestPtrOutput 

type ConnectivityTestPtrOutput struct{ *pulumi.OutputState }

func (ConnectivityTestPtrOutput) Elem added in v5.21.0 

func (o ConnectivityTestPtrOutput) Elem() ConnectivityTestOutput

func (ConnectivityTestPtrOutput) ElementType 

func (ConnectivityTestPtrOutput) ElementType() reflect.Type

func (ConnectivityTestPtrOutput) ToConnectivityTestPtrOutput 

func (o ConnectivityTestPtrOutput) ToConnectivityTestPtrOutput() ConnectivityTestPtrOutput

func (ConnectivityTestPtrOutput) ToConnectivityTestPtrOutputWithContext 

func (o ConnectivityTestPtrOutput) ToConnectivityTestPtrOutputWithContext(ctx context.Context) ConnectivityTestPtrOutput

type ConnectivityTestSource 

type ConnectivityTestSource struct {
	// A Compute Engine instance URI.
	Instance *string `pulumi:"instance"`
	// The IP address of the endpoint, which can be an external or
	// internal IP. An IPv6 address is only allowed when the test's
	// destination is a global load balancer VIP.
	IpAddress *string `pulumi:"ipAddress"`
	// A Compute Engine network URI.
	Network *string `pulumi:"network"`
	// Type of the network where the endpoint is located.
	// Possible values are `GCP_NETWORK` and `NON_GCP_NETWORK`.
	NetworkType *string `pulumi:"networkType"`
	// The IP protocol port of the endpoint. Only applicable when
	// protocol is TCP or UDP.
	Port *int `pulumi:"port"`
	// Project ID where the endpoint is located. The Project ID can be
	// derived from the URI if you provide a VM instance or network URI.
	// The following are two cases where you must provide the project ID:
	// 1. Only the IP address is specified, and the IP address is within
	//    a GCP project. 2. When you are using Shared VPC and the IP address
	//    that you provide is from the service project. In this case, the
	//    network that the IP address resides in is defined in the host
	//    project.
	ProjectId *string `pulumi:"projectId"`
}

type ConnectivityTestSourceArgs 

type ConnectivityTestSourceArgs struct {
	// A Compute Engine instance URI.
	Instance pulumi.StringPtrInput `pulumi:"instance"`
	// The IP address of the endpoint, which can be an external or
	// internal IP. An IPv6 address is only allowed when the test's
	// destination is a global load balancer VIP.
	IpAddress pulumi.StringPtrInput `pulumi:"ipAddress"`
	// A Compute Engine network URI.
	Network pulumi.StringPtrInput `pulumi:"network"`
	// Type of the network where the endpoint is located.
	// Possible values are `GCP_NETWORK` and `NON_GCP_NETWORK`.
	NetworkType pulumi.StringPtrInput `pulumi:"networkType"`
	// The IP protocol port of the endpoint. Only applicable when
	// protocol is TCP or UDP.
	Port pulumi.IntPtrInput `pulumi:"port"`
	// Project ID where the endpoint is located. The Project ID can be
	// derived from the URI if you provide a VM instance or network URI.
	// The following are two cases where you must provide the project ID:
	// 1. Only the IP address is specified, and the IP address is within
	//    a GCP project. 2. When you are using Shared VPC and the IP address
	//    that you provide is from the service project. In this case, the
	//    network that the IP address resides in is defined in the host
	//    project.
	ProjectId pulumi.StringPtrInput `pulumi:"projectId"`
}

func (ConnectivityTestSourceArgs) ElementType 

func (ConnectivityTestSourceArgs) ElementType() reflect.Type

func (ConnectivityTestSourceArgs) ToConnectivityTestSourceOutput 

func (i ConnectivityTestSourceArgs) ToConnectivityTestSourceOutput() ConnectivityTestSourceOutput

func (ConnectivityTestSourceArgs) ToConnectivityTestSourceOutputWithContext 

func (i ConnectivityTestSourceArgs) ToConnectivityTestSourceOutputWithContext(ctx context.Context) ConnectivityTestSourceOutput

func (ConnectivityTestSourceArgs) ToConnectivityTestSourcePtrOutput 

func (i ConnectivityTestSourceArgs) ToConnectivityTestSourcePtrOutput() ConnectivityTestSourcePtrOutput

func (ConnectivityTestSourceArgs) ToConnectivityTestSourcePtrOutputWithContext 

func (i ConnectivityTestSourceArgs) ToConnectivityTestSourcePtrOutputWithContext(ctx context.Context) ConnectivityTestSourcePtrOutput

type ConnectivityTestSourceInput 

type ConnectivityTestSourceInput interface {
	pulumi.Input

	ToConnectivityTestSourceOutput() ConnectivityTestSourceOutput
	ToConnectivityTestSourceOutputWithContext(context.Context) ConnectivityTestSourceOutput
}

ConnectivityTestSourceInput is an input type that accepts ConnectivityTestSourceArgs and ConnectivityTestSourceOutput values. You can construct a concrete instance of `ConnectivityTestSourceInput` via: 

ConnectivityTestSourceArgs{...}

type ConnectivityTestSourceOutput 

type ConnectivityTestSourceOutput struct{ *pulumi.OutputState }

func (ConnectivityTestSourceOutput) ElementType 

func (ConnectivityTestSourceOutput) ElementType() reflect.Type

func (ConnectivityTestSourceOutput) Instance 

func (o ConnectivityTestSourceOutput) Instance() pulumi.StringPtrOutput

A Compute Engine instance URI.

func (ConnectivityTestSourceOutput) IpAddress 

func (o ConnectivityTestSourceOutput) IpAddress() pulumi.StringPtrOutput

The IP address of the endpoint, which can be an external or internal IP. An IPv6 address is only allowed when the test's destination is a global load balancer VIP.

func (ConnectivityTestSourceOutput) Network 

func (o ConnectivityTestSourceOutput) Network() pulumi.StringPtrOutput

A Compute Engine network URI.

func (ConnectivityTestSourceOutput) NetworkType 

func (o ConnectivityTestSourceOutput) NetworkType() pulumi.StringPtrOutput

Type of the network where the endpoint is located. Possible values are `GCP_NETWORK` and `NON_GCP_NETWORK`.

func (ConnectivityTestSourceOutput) Port 

func (o ConnectivityTestSourceOutput) Port() pulumi.IntPtrOutput

The IP protocol port of the endpoint. Only applicable when protocol is TCP or UDP.

func (ConnectivityTestSourceOutput) ProjectId 

func (o ConnectivityTestSourceOutput) ProjectId() pulumi.StringPtrOutput

Project ID where the endpoint is located. The Project ID can be derived from the URI if you provide a VM instance or network URI. The following are two cases where you must provide the project ID:

  1. Only the IP address is specified, and the IP address is within a GCP project. 2. When you are using Shared VPC and the IP address that you provide is from the service project. In this case, the network that the IP address resides in is defined in the host project.

func (ConnectivityTestSourceOutput) ToConnectivityTestSourceOutput 

func (o ConnectivityTestSourceOutput) ToConnectivityTestSourceOutput() ConnectivityTestSourceOutput

func (ConnectivityTestSourceOutput) ToConnectivityTestSourceOutputWithContext 

func (o ConnectivityTestSourceOutput) ToConnectivityTestSourceOutputWithContext(ctx context.Context) ConnectivityTestSourceOutput

func (ConnectivityTestSourceOutput) ToConnectivityTestSourcePtrOutput 

func (o ConnectivityTestSourceOutput) ToConnectivityTestSourcePtrOutput() ConnectivityTestSourcePtrOutput

func (ConnectivityTestSourceOutput) ToConnectivityTestSourcePtrOutputWithContext 

func (o ConnectivityTestSourceOutput) ToConnectivityTestSourcePtrOutputWithContext(ctx context.Context) ConnectivityTestSourcePtrOutput

type ConnectivityTestSourcePtrInput 

type ConnectivityTestSourcePtrInput interface {
	pulumi.Input

	ToConnectivityTestSourcePtrOutput() ConnectivityTestSourcePtrOutput
	ToConnectivityTestSourcePtrOutputWithContext(context.Context) ConnectivityTestSourcePtrOutput
}

ConnectivityTestSourcePtrInput is an input type that accepts ConnectivityTestSourceArgs, ConnectivityTestSourcePtr and ConnectivityTestSourcePtrOutput values. You can construct a concrete instance of `ConnectivityTestSourcePtrInput` via: 

        ConnectivityTestSourceArgs{...}

or:

        nil

func ConnectivityTestSourcePtr 

func ConnectivityTestSourcePtr(v *ConnectivityTestSourceArgs) ConnectivityTestSourcePtrInput

type ConnectivityTestSourcePtrOutput 

type ConnectivityTestSourcePtrOutput struct{ *pulumi.OutputState }

func (ConnectivityTestSourcePtrOutput) Elem 

func (o ConnectivityTestSourcePtrOutput) Elem() ConnectivityTestSourceOutput

func (ConnectivityTestSourcePtrOutput) ElementType 

func (ConnectivityTestSourcePtrOutput) ElementType() reflect.Type

func (ConnectivityTestSourcePtrOutput) Instance 

func (o ConnectivityTestSourcePtrOutput) Instance() pulumi.StringPtrOutput

A Compute Engine instance URI.

func (ConnectivityTestSourcePtrOutput) IpAddress 

func (o ConnectivityTestSourcePtrOutput) IpAddress() pulumi.StringPtrOutput

The IP address of the endpoint, which can be an external or internal IP. An IPv6 address is only allowed when the test's destination is a global load balancer VIP.

func (ConnectivityTestSourcePtrOutput) Network 

func (o ConnectivityTestSourcePtrOutput) Network() pulumi.StringPtrOutput

A Compute Engine network URI.

func (ConnectivityTestSourcePtrOutput) NetworkType 

func (o ConnectivityTestSourcePtrOutput) NetworkType() pulumi.StringPtrOutput

Type of the network where the endpoint is located. Possible values are `GCP_NETWORK` and `NON_GCP_NETWORK`.

func (ConnectivityTestSourcePtrOutput) Port 

func (o ConnectivityTestSourcePtrOutput) Port() pulumi.IntPtrOutput

The IP protocol port of the endpoint. Only applicable when protocol is TCP or UDP.

func (ConnectivityTestSourcePtrOutput) ProjectId 

func (o ConnectivityTestSourcePtrOutput) ProjectId() pulumi.StringPtrOutput

Project ID where the endpoint is located. The Project ID can be derived from the URI if you provide a VM instance or network URI. The following are two cases where you must provide the project ID:

  1. Only the IP address is specified, and the IP address is within a GCP project. 2. When you are using Shared VPC and the IP address that you provide is from the service project. In this case, the network that the IP address resides in is defined in the host project.

func (ConnectivityTestSourcePtrOutput) ToConnectivityTestSourcePtrOutput 

func (o ConnectivityTestSourcePtrOutput) ToConnectivityTestSourcePtrOutput() ConnectivityTestSourcePtrOutput

func (ConnectivityTestSourcePtrOutput) ToConnectivityTestSourcePtrOutputWithContext 

func (o ConnectivityTestSourcePtrOutput) ToConnectivityTestSourcePtrOutputWithContext(ctx context.Context) ConnectivityTestSourcePtrOutput

type ConnectivityTestState 

type ConnectivityTestState struct {
	// The user-supplied description of the Connectivity Test.
	// Maximum of 512 characters.
	Description pulumi.StringPtrInput
	// Required. Destination specification of the Connectivity Test.
	// You can use a combination of destination IP address, Compute
	// Engine VM instance, or VPC network to uniquely identify the
	// destination location.
	// Even if the destination IP address is not unique, the source IP
	// location is unique. Usually, the analysis can infer the destination
	// endpoint from route information.
	// If the destination you specify is a VM instance and the instance has
	// multiple network interfaces, then you must also specify either a
	// destination IP address or VPC network to identify the destination
	// interface.
	// A reachability analysis proceeds even if the destination location
	// is ambiguous. However, the result can include endpoints that you
	// don't intend to test.
	// Structure is documented below.
	Destination ConnectivityTestDestinationPtrInput
	// Resource labels to represent user-provided metadata.
	Labels pulumi.StringMapInput
	// Unique name for the connectivity test.
	Name pulumi.StringPtrInput
	// The ID of the project in which the resource belongs.
	// If it is not provided, the provider project is used.
	Project pulumi.StringPtrInput
	// IP Protocol of the test. When not provided, "TCP" is assumed.
	Protocol pulumi.StringPtrInput
	// Other projects that may be relevant for reachability analysis.
	// This is applicable to scenarios where a test can cross project
	// boundaries.
	RelatedProjects pulumi.StringArrayInput
	// Required. Source specification of the Connectivity Test.
	// You can use a combination of source IP address, virtual machine
	// (VM) instance, or Compute Engine network to uniquely identify the
	// source location.
	// Examples: If the source IP address is an internal IP address within
	// a Google Cloud Virtual Private Cloud (VPC) network, then you must
	// also specify the VPC network. Otherwise, specify the VM instance,
	// which already contains its internal IP address and VPC network
	// information.
	// If the source of the test is within an on-premises network, then
	// you must provide the destination VPC network.
	// If the source endpoint is a Compute Engine VM instance with multiple
	// network interfaces, the instance itself is not sufficient to
	// identify the endpoint. So, you must also specify the source IP
	// address or VPC network.
	// A reachability analysis proceeds even if the source location is
	// ambiguous. However, the test result may include endpoints that
	// you don't intend to test.
	// Structure is documented below.
	Source ConnectivityTestSourcePtrInput
}

func (ConnectivityTestState) ElementType 

func (ConnectivityTestState) 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.