pulumi-gcp-kotlin/com.pulumi.gcp.networkmanagement.kotlin/ConnectivityTestArgs

ConnectivityTestArgs

data class ConnectivityTestArgs(val bypassFirewallChecks: Output<Boolean>? = null, val description: Output<String>? = null, val destination: Output<ConnectivityTestDestinationArgs>? = null, val labels: Output<Map<String, String>>? = null, val name: Output<String>? = null, val project: Output<String>? = null, val protocol: Output<String>? = null, val relatedProjects: Output<List<String>>? = null, val roundTrip: Output<Boolean>? = null, val source: Output<ConnectivityTestSourceArgs>? = null) : ConvertibleToJava<ConnectivityTestArgs>

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:

Example Usage

Network Management Connectivity Test Instances

import * as pulumi from "@pulumi/pulumi";
import * as gcp from "@pulumi/gcp";
const vpc = new gcp.compute.Network("vpc", {name: "conn-test-net"});
const debian9 = gcp.compute.getImage({
    family: "debian-11",
    project: "debian-cloud",
});
const source = new gcp.compute.Instance("source", {
    networkInterfaces: [{
        accessConfigs: [{}],
        network: vpc.id,
    }],
    name: "source-vm",
    machineType: "e2-medium",
    bootDisk: {
        initializeParams: {
            image: debian9.then(debian9 => debian9.id),
        },
    },
});
const destination = new gcp.compute.Instance("destination", {
    networkInterfaces: [{
        accessConfigs: [{}],
        network: vpc.id,
    }],
    name: "dest-vm",
    machineType: "e2-medium",
    bootDisk: {
        initializeParams: {
            image: debian9.then(debian9 => debian9.id),
        },
    },
});
const instance_test = new gcp.networkmanagement.ConnectivityTest("instance-test", {
    name: "conn-test-instances",
    source: {
        instance: source.id,
    },
    destination: {
        instance: destination.id,
    },
    protocol: "TCP",
    labels: {
        env: "test",
    },
});
Content copied to clipboard
import pulumi
import pulumi_gcp as gcp
vpc = gcp.compute.Network("vpc", name="conn-test-net")
debian9 = gcp.compute.get_image(family="debian-11",
    project="debian-cloud")
source = gcp.compute.Instance("source",
    network_interfaces=[{
        "access_configs": [{}],
        "network": vpc.id,
    }],
    name="source-vm",
    machine_type="e2-medium",
    boot_disk={
        "initialize_params": {
            "image": debian9.id,
        },
    })
destination = gcp.compute.Instance("destination",
    network_interfaces=[{
        "access_configs": [{}],
        "network": vpc.id,
    }],
    name="dest-vm",
    machine_type="e2-medium",
    boot_disk={
        "initialize_params": {
            "image": debian9.id,
        },
    })
instance_test = gcp.networkmanagement.ConnectivityTest("instance-test",
    name="conn-test-instances",
    source={
        "instance": source.id,
    },
    destination={
        "instance": destination.id,
    },
    protocol="TCP",
    labels={
        "env": "test",
    })
Content copied to clipboard
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Gcp = Pulumi.Gcp;
return await Deployment.RunAsync(() =>
{
    var vpc = new Gcp.Compute.Network("vpc", new()
    {
        Name = "conn-test-net",
    });
    var debian9 = Gcp.Compute.GetImage.Invoke(new()
    {
        Family = "debian-11",
        Project = "debian-cloud",
    });
    var source = new Gcp.Compute.Instance("source", new()
    {
        NetworkInterfaces = new[]
        {
            new Gcp.Compute.Inputs.InstanceNetworkInterfaceArgs
            {
                AccessConfigs = new[]
                {
                    null,
                },
                Network = vpc.Id,
            },
        },
        Name = "source-vm",
        MachineType = "e2-medium",
        BootDisk = new Gcp.Compute.Inputs.InstanceBootDiskArgs
        {
            InitializeParams = new Gcp.Compute.Inputs.InstanceBootDiskInitializeParamsArgs
            {
                Image = debian9.Apply(getImageResult => getImageResult.Id),
            },
        },
    });
    var destination = new Gcp.Compute.Instance("destination", new()
    {
        NetworkInterfaces = new[]
        {
            new Gcp.Compute.Inputs.InstanceNetworkInterfaceArgs
            {
                AccessConfigs = new[]
                {
                    null,
                },
                Network = vpc.Id,
            },
        },
        Name = "dest-vm",
        MachineType = "e2-medium",
        BootDisk = new Gcp.Compute.Inputs.InstanceBootDiskArgs
        {
            InitializeParams = new Gcp.Compute.Inputs.InstanceBootDiskInitializeParamsArgs
            {
                Image = debian9.Apply(getImageResult => getImageResult.Id),
            },
        },
    });
    var instance_test = new Gcp.NetworkManagement.ConnectivityTest("instance-test", new()
    {
        Name = "conn-test-instances",
        Source = new Gcp.NetworkManagement.Inputs.ConnectivityTestSourceArgs
        {
            Instance = source.Id,
        },
        Destination = new Gcp.NetworkManagement.Inputs.ConnectivityTestDestinationArgs
        {
            Instance = destination.Id,
        },
        Protocol = "TCP",
        Labels =
        {
            { "env", "test" },
        },
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-gcp/sdk/v8/go/gcp/compute"
	"github.com/pulumi/pulumi-gcp/sdk/v8/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", &compute.NetworkArgs{
			Name: pulumi.String("conn-test-net"),
		})
		if err != nil {
			return err
		}
		debian9, err := compute.LookupImage(ctx, &compute.LookupImageArgs{
			Family:  pulumi.StringRef("debian-11"),
			Project: pulumi.StringRef("debian-cloud"),
		}, nil)
		if err != nil {
			return err
		}
		source, err := compute.NewInstance(ctx, "source", &compute.InstanceArgs{
			NetworkInterfaces: compute.InstanceNetworkInterfaceArray{
				&compute.InstanceNetworkInterfaceArgs{
					AccessConfigs: compute.InstanceNetworkInterfaceAccessConfigArray{
						&compute.InstanceNetworkInterfaceAccessConfigArgs{},
					},
					Network: vpc.ID(),
				},
			},
			Name:        pulumi.String("source-vm"),
			MachineType: pulumi.String("e2-medium"),
			BootDisk: &compute.InstanceBootDiskArgs{
				InitializeParams: &compute.InstanceBootDiskInitializeParamsArgs{
					Image: pulumi.String(debian9.Id),
				},
			},
		})
		if err != nil {
			return err
		}
		destination, err := compute.NewInstance(ctx, "destination", &compute.InstanceArgs{
			NetworkInterfaces: compute.InstanceNetworkInterfaceArray{
				&compute.InstanceNetworkInterfaceArgs{
					AccessConfigs: compute.InstanceNetworkInterfaceAccessConfigArray{
						&compute.InstanceNetworkInterfaceAccessConfigArgs{},
					},
					Network: vpc.ID(),
				},
			},
			Name:        pulumi.String("dest-vm"),
			MachineType: pulumi.String("e2-medium"),
			BootDisk: &compute.InstanceBootDiskArgs{
				InitializeParams: &compute.InstanceBootDiskInitializeParamsArgs{
					Image: pulumi.String(debian9.Id),
				},
			},
		})
		if err != nil {
			return err
		}
		_, err = networkmanagement.NewConnectivityTest(ctx, "instance-test", &networkmanagement.ConnectivityTestArgs{
			Name: pulumi.String("conn-test-instances"),
			Source: &networkmanagement.ConnectivityTestSourceArgs{
				Instance: source.ID(),
			},
			Destination: &networkmanagement.ConnectivityTestDestinationArgs{
				Instance: destination.ID(),
			},
			Protocol: pulumi.String("TCP"),
			Labels: pulumi.StringMap{
				"env": pulumi.String("test"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}
Content copied to clipboard
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.compute.Network;
import com.pulumi.gcp.compute.NetworkArgs;
import com.pulumi.gcp.compute.ComputeFunctions;
import com.pulumi.gcp.compute.inputs.GetImageArgs;
import com.pulumi.gcp.compute.Instance;
import com.pulumi.gcp.compute.InstanceArgs;
import com.pulumi.gcp.compute.inputs.InstanceNetworkInterfaceArgs;
import com.pulumi.gcp.compute.inputs.InstanceBootDiskArgs;
import com.pulumi.gcp.compute.inputs.InstanceBootDiskInitializeParamsArgs;
import com.pulumi.gcp.networkmanagement.ConnectivityTest;
import com.pulumi.gcp.networkmanagement.ConnectivityTestArgs;
import com.pulumi.gcp.networkmanagement.inputs.ConnectivityTestSourceArgs;
import com.pulumi.gcp.networkmanagement.inputs.ConnectivityTestDestinationArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;
public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }
    public static void stack(Context ctx) {
        var vpc = new Network("vpc", NetworkArgs.builder()
            .name("conn-test-net")
            .build());
        final var debian9 = ComputeFunctions.getImage(GetImageArgs.builder()
            .family("debian-11")
            .project("debian-cloud")
            .build());
        var source = new Instance("source", InstanceArgs.builder()
            .networkInterfaces(InstanceNetworkInterfaceArgs.builder()
                .accessConfigs(InstanceNetworkInterfaceAccessConfigArgs.builder()
                    .build())
                .network(vpc.id())
                .build())
            .name("source-vm")
            .machineType("e2-medium")
            .bootDisk(InstanceBootDiskArgs.builder()
                .initializeParams(InstanceBootDiskInitializeParamsArgs.builder()
                    .image(debian9.id())
                    .build())
                .build())
            .build());
        var destination = new Instance("destination", InstanceArgs.builder()
            .networkInterfaces(InstanceNetworkInterfaceArgs.builder()
                .accessConfigs(InstanceNetworkInterfaceAccessConfigArgs.builder()
                    .build())
                .network(vpc.id())
                .build())
            .name("dest-vm")
            .machineType("e2-medium")
            .bootDisk(InstanceBootDiskArgs.builder()
                .initializeParams(InstanceBootDiskInitializeParamsArgs.builder()
                    .image(debian9.id())
                    .build())
                .build())
            .build());
        var instance_test = new ConnectivityTest("instance-test", ConnectivityTestArgs.builder()
            .name("conn-test-instances")
            .source(ConnectivityTestSourceArgs.builder()
                .instance(source.id())
                .build())
            .destination(ConnectivityTestDestinationArgs.builder()
                .instance(destination.id())
                .build())
            .protocol("TCP")
            .labels(Map.of("env", "test"))
            .build());
    }
}
Content copied to clipboard
resources:
  instance-test:
    type: gcp:networkmanagement:ConnectivityTest
    properties:
      name: conn-test-instances
      source:
        instance: ${source.id}
      destination:
        instance: ${destination.id}
      protocol: TCP
      labels:
        env: test
  source:
    type: gcp:compute:Instance
    properties:
      networkInterfaces:
        - accessConfigs:
            - {}
          network: ${vpc.id}
      name: source-vm
      machineType: e2-medium
      bootDisk:
        initializeParams:
          image: ${debian9.id}
  destination:
    type: gcp:compute:Instance
    properties:
      networkInterfaces:
        - accessConfigs:
            - {}
          network: ${vpc.id}
      name: dest-vm
      machineType: e2-medium
      bootDisk:
        initializeParams:
          image: ${debian9.id}
  vpc:
    type: gcp:compute:Network
    properties:
      name: conn-test-net
variables:
  debian9:
    fn::invoke:
      function: gcp:compute:getImage
      arguments:
        family: debian-11
        project: debian-cloud
Content copied to clipboard

Network Management Connectivity Test Addresses

import * as pulumi from "@pulumi/pulumi";
import * as gcp from "@pulumi/gcp";
const vpc = new gcp.compute.Network("vpc", {name: "connectivity-vpc"});
const subnet = new gcp.compute.Subnetwork("subnet", {
    name: "connectivity-vpc-subnet",
    ipCidrRange: "10.0.0.0/16",
    region: "us-central1",
    network: vpc.id,
});
const source_addr = new gcp.compute.Address("source-addr", {
    name: "src-addr",
    subnetwork: subnet.id,
    addressType: "INTERNAL",
    address: "10.0.42.42",
    region: "us-central1",
});
const dest_addr = new gcp.compute.Address("dest-addr", {
    name: "dest-addr",
    subnetwork: subnet.id,
    addressType: "INTERNAL",
    address: "10.0.43.43",
    region: "us-central1",
});
const address_test = new gcp.networkmanagement.ConnectivityTest("address-test", {
    name: "conn-test-addr",
    source: {
        ipAddress: source_addr.address,
        projectId: source_addr.project,
        network: vpc.id,
        networkType: "GCP_NETWORK",
    },
    destination: {
        ipAddress: dest_addr.address,
        projectId: dest_addr.project,
        network: vpc.id,
    },
    protocol: "UDP",
});
Content copied to clipboard
import pulumi
import pulumi_gcp as gcp
vpc = gcp.compute.Network("vpc", name="connectivity-vpc")
subnet = gcp.compute.Subnetwork("subnet",
    name="connectivity-vpc-subnet",
    ip_cidr_range="10.0.0.0/16",
    region="us-central1",
    network=vpc.id)
source_addr = gcp.compute.Address("source-addr",
    name="src-addr",
    subnetwork=subnet.id,
    address_type="INTERNAL",
    address="10.0.42.42",
    region="us-central1")
dest_addr = gcp.compute.Address("dest-addr",
    name="dest-addr",
    subnetwork=subnet.id,
    address_type="INTERNAL",
    address="10.0.43.43",
    region="us-central1")
address_test = gcp.networkmanagement.ConnectivityTest("address-test",
    name="conn-test-addr",
    source={
        "ip_address": source_addr.address,
        "project_id": source_addr.project,
        "network": vpc.id,
        "network_type": "GCP_NETWORK",
    },
    destination={
        "ip_address": dest_addr.address,
        "project_id": dest_addr.project,
        "network": vpc.id,
    },
    protocol="UDP")
Content copied to clipboard
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Gcp = Pulumi.Gcp;
return await Deployment.RunAsync(() =>
{
    var vpc = new Gcp.Compute.Network("vpc", new()
    {
        Name = "connectivity-vpc",
    });
    var subnet = new Gcp.Compute.Subnetwork("subnet", new()
    {
        Name = "connectivity-vpc-subnet",
        IpCidrRange = "10.0.0.0/16",
        Region = "us-central1",
        Network = vpc.Id,
    });
    var source_addr = new Gcp.Compute.Address("source-addr", new()
    {
        Name = "src-addr",
        Subnetwork = subnet.Id,
        AddressType = "INTERNAL",
        IPAddress = "10.0.42.42",
        Region = "us-central1",
    });
    var dest_addr = new Gcp.Compute.Address("dest-addr", new()
    {
        Name = "dest-addr",
        Subnetwork = subnet.Id,
        AddressType = "INTERNAL",
        IPAddress = "10.0.43.43",
        Region = "us-central1",
    });
    var address_test = new Gcp.NetworkManagement.ConnectivityTest("address-test", new()
    {
        Name = "conn-test-addr",
        Source = new Gcp.NetworkManagement.Inputs.ConnectivityTestSourceArgs
        {
            IpAddress = source_addr.IPAddress,
            ProjectId = source_addr.Project,
            Network = vpc.Id,
            NetworkType = "GCP_NETWORK",
        },
        Destination = new Gcp.NetworkManagement.Inputs.ConnectivityTestDestinationArgs
        {
            IpAddress = dest_addr.IPAddress,
            ProjectId = dest_addr.Project,
            Network = vpc.Id,
        },
        Protocol = "UDP",
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-gcp/sdk/v8/go/gcp/compute"
	"github.com/pulumi/pulumi-gcp/sdk/v8/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", &compute.NetworkArgs{
			Name: pulumi.String("connectivity-vpc"),
		})
		if err != nil {
			return err
		}
		subnet, err := compute.NewSubnetwork(ctx, "subnet", &compute.SubnetworkArgs{
			Name:        pulumi.String("connectivity-vpc-subnet"),
			IpCidrRange: pulumi.String("10.0.0.0/16"),
			Region:      pulumi.String("us-central1"),
			Network:     vpc.ID(),
		})
		if err != nil {
			return err
		}
		source_addr, err := compute.NewAddress(ctx, "source-addr", &compute.AddressArgs{
			Name:        pulumi.String("src-addr"),
			Subnetwork:  subnet.ID(),
			AddressType: pulumi.String("INTERNAL"),
			Address:     pulumi.String("10.0.42.42"),
			Region:      pulumi.String("us-central1"),
		})
		if err != nil {
			return err
		}
		dest_addr, err := compute.NewAddress(ctx, "dest-addr", &compute.AddressArgs{
			Name:        pulumi.String("dest-addr"),
			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{
			Name: pulumi.String("conn-test-addr"),
			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
	})
}
Content copied to clipboard
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.compute.Network;
import com.pulumi.gcp.compute.NetworkArgs;
import com.pulumi.gcp.compute.Subnetwork;
import com.pulumi.gcp.compute.SubnetworkArgs;
import com.pulumi.gcp.compute.Address;
import com.pulumi.gcp.compute.AddressArgs;
import com.pulumi.gcp.networkmanagement.ConnectivityTest;
import com.pulumi.gcp.networkmanagement.ConnectivityTestArgs;
import com.pulumi.gcp.networkmanagement.inputs.ConnectivityTestSourceArgs;
import com.pulumi.gcp.networkmanagement.inputs.ConnectivityTestDestinationArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;
public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }
    public static void stack(Context ctx) {
        var vpc = new Network("vpc", NetworkArgs.builder()
            .name("connectivity-vpc")
            .build());
        var subnet = new Subnetwork("subnet", SubnetworkArgs.builder()
            .name("connectivity-vpc-subnet")
            .ipCidrRange("10.0.0.0/16")
            .region("us-central1")
            .network(vpc.id())
            .build());
        var source_addr = new Address("source-addr", AddressArgs.builder()
            .name("src-addr")
            .subnetwork(subnet.id())
            .addressType("INTERNAL")
            .address("10.0.42.42")
            .region("us-central1")
            .build());
        var dest_addr = new Address("dest-addr", AddressArgs.builder()
            .name("dest-addr")
            .subnetwork(subnet.id())
            .addressType("INTERNAL")
            .address("10.0.43.43")
            .region("us-central1")
            .build());
        var address_test = new ConnectivityTest("address-test", ConnectivityTestArgs.builder()
            .name("conn-test-addr")
            .source(ConnectivityTestSourceArgs.builder()
                .ipAddress(source_addr.address())
                .projectId(source_addr.project())
                .network(vpc.id())
                .networkType("GCP_NETWORK")
                .build())
            .destination(ConnectivityTestDestinationArgs.builder()
                .ipAddress(dest_addr.address())
                .projectId(dest_addr.project())
                .network(vpc.id())
                .build())
            .protocol("UDP")
            .build());
    }
}
Content copied to clipboard
resources:
  address-test:
    type: gcp:networkmanagement:ConnectivityTest
    properties:
      name: conn-test-addr
      source:
        ipAddress: ${["source-addr"].address}
        projectId: ${["source-addr"].project}
        network: ${vpc.id}
        networkType: GCP_NETWORK
      destination:
        ipAddress: ${["dest-addr"].address}
        projectId: ${["dest-addr"].project}
        network: ${vpc.id}
      protocol: UDP
  vpc:
    type: gcp:compute:Network
    properties:
      name: connectivity-vpc
  subnet:
    type: gcp:compute:Subnetwork
    properties:
      name: connectivity-vpc-subnet
      ipCidrRange: 10.0.0.0/16
      region: us-central1
      network: ${vpc.id}
  source-addr:
    type: gcp:compute:Address
    properties:
      name: src-addr
      subnetwork: ${subnet.id}
      addressType: INTERNAL
      address: 10.0.42.42
      region: us-central1
  dest-addr:
    type: gcp:compute:Address
    properties:
      name: dest-addr
      subnetwork: ${subnet.id}
      addressType: INTERNAL
      address: 10.0.43.43
      region: us-central1
Content copied to clipboard

Network Management Connectivity Test Endpoints

import * as pulumi from "@pulumi/pulumi";
import * as gcp from "@pulumi/gcp";
const endpoints_test = new gcp.networkmanagement.ConnectivityTest("endpoints-test", {
    name: "conn-test-endpoints",
    source: {
        gkeMasterCluster: "projects/test-project/locations/us-central1/clusters/name",
        cloudSqlInstance: "projects/test-project/instances/name",
        appEngineVersion: {
            uri: "apps/test-project/services/default/versions/name",
        },
        cloudFunction: {
            uri: "projects/test-project/locations/us-central1/functions/name",
        },
        cloudRunRevision: {
            uri: "projects/test-project/locations/us-central1/revisions/name",
        },
        port: 80,
    },
    destination: {
        port: 443,
        forwardingRule: "projects/test-project/regions/us-central1/forwardingRules/name",
        gkeMasterCluster: "projects/test-project/locations/us-central1/clusters/name",
        fqdn: "name.us-central1.gke.goog",
        cloudSqlInstance: "projects/test-project/instances/name",
        redisInstance: "projects/test-project/locations/us-central1/instances/name",
        redisCluster: "projects/test-project/locations/us-central1/clusters/name",
    },
    bypassFirewallChecks: true,
    roundTrip: true,
});
Content copied to clipboard
import pulumi
import pulumi_gcp as gcp
endpoints_test = gcp.networkmanagement.ConnectivityTest("endpoints-test",
    name="conn-test-endpoints",
    source={
        "gke_master_cluster": "projects/test-project/locations/us-central1/clusters/name",
        "cloud_sql_instance": "projects/test-project/instances/name",
        "app_engine_version": {
            "uri": "apps/test-project/services/default/versions/name",
        },
        "cloud_function": {
            "uri": "projects/test-project/locations/us-central1/functions/name",
        },
        "cloud_run_revision": {
            "uri": "projects/test-project/locations/us-central1/revisions/name",
        },
        "port": 80,
    },
    destination={
        "port": 443,
        "forwarding_rule": "projects/test-project/regions/us-central1/forwardingRules/name",
        "gke_master_cluster": "projects/test-project/locations/us-central1/clusters/name",
        "fqdn": "name.us-central1.gke.goog",
        "cloud_sql_instance": "projects/test-project/instances/name",
        "redis_instance": "projects/test-project/locations/us-central1/instances/name",
        "redis_cluster": "projects/test-project/locations/us-central1/clusters/name",
    },
    bypass_firewall_checks=True,
    round_trip=True)
Content copied to clipboard
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Gcp = Pulumi.Gcp;
return await Deployment.RunAsync(() =>
{
    var endpoints_test = new Gcp.NetworkManagement.ConnectivityTest("endpoints-test", new()
    {
        Name = "conn-test-endpoints",
        Source = new Gcp.NetworkManagement.Inputs.ConnectivityTestSourceArgs
        {
            GkeMasterCluster = "projects/test-project/locations/us-central1/clusters/name",
            CloudSqlInstance = "projects/test-project/instances/name",
            AppEngineVersion = new Gcp.NetworkManagement.Inputs.ConnectivityTestSourceAppEngineVersionArgs
            {
                Uri = "apps/test-project/services/default/versions/name",
            },
            CloudFunction = new Gcp.NetworkManagement.Inputs.ConnectivityTestSourceCloudFunctionArgs
            {
                Uri = "projects/test-project/locations/us-central1/functions/name",
            },
            CloudRunRevision = new Gcp.NetworkManagement.Inputs.ConnectivityTestSourceCloudRunRevisionArgs
            {
                Uri = "projects/test-project/locations/us-central1/revisions/name",
            },
            Port = 80,
        },
        Destination = new Gcp.NetworkManagement.Inputs.ConnectivityTestDestinationArgs
        {
            Port = 443,
            ForwardingRule = "projects/test-project/regions/us-central1/forwardingRules/name",
            GkeMasterCluster = "projects/test-project/locations/us-central1/clusters/name",
            Fqdn = "name.us-central1.gke.goog",
            CloudSqlInstance = "projects/test-project/instances/name",
            RedisInstance = "projects/test-project/locations/us-central1/instances/name",
            RedisCluster = "projects/test-project/locations/us-central1/clusters/name",
        },
        BypassFirewallChecks = true,
        RoundTrip = true,
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-gcp/sdk/v8/go/gcp/networkmanagement"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := networkmanagement.NewConnectivityTest(ctx, "endpoints-test", &networkmanagement.ConnectivityTestArgs{
			Name: pulumi.String("conn-test-endpoints"),
			Source: &networkmanagement.ConnectivityTestSourceArgs{
				GkeMasterCluster: pulumi.String("projects/test-project/locations/us-central1/clusters/name"),
				CloudSqlInstance: pulumi.String("projects/test-project/instances/name"),
				AppEngineVersion: &networkmanagement.ConnectivityTestSourceAppEngineVersionArgs{
					Uri: pulumi.String("apps/test-project/services/default/versions/name"),
				},
				CloudFunction: &networkmanagement.ConnectivityTestSourceCloudFunctionArgs{
					Uri: pulumi.String("projects/test-project/locations/us-central1/functions/name"),
				},
				CloudRunRevision: &networkmanagement.ConnectivityTestSourceCloudRunRevisionArgs{
					Uri: pulumi.String("projects/test-project/locations/us-central1/revisions/name"),
				},
				Port: pulumi.Int(80),
			},
			Destination: &networkmanagement.ConnectivityTestDestinationArgs{
				Port:             pulumi.Int(443),
				ForwardingRule:   pulumi.String("projects/test-project/regions/us-central1/forwardingRules/name"),
				GkeMasterCluster: pulumi.String("projects/test-project/locations/us-central1/clusters/name"),
				Fqdn:             pulumi.String("name.us-central1.gke.goog"),
				CloudSqlInstance: pulumi.String("projects/test-project/instances/name"),
				RedisInstance:    pulumi.String("projects/test-project/locations/us-central1/instances/name"),
				RedisCluster:     pulumi.String("projects/test-project/locations/us-central1/clusters/name"),
			},
			BypassFirewallChecks: pulumi.Bool(true),
			RoundTrip:            pulumi.Bool(true),
		})
		if err != nil {
			return err
		}
		return nil
	})
}
Content copied to clipboard
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.networkmanagement.ConnectivityTest;
import com.pulumi.gcp.networkmanagement.ConnectivityTestArgs;
import com.pulumi.gcp.networkmanagement.inputs.ConnectivityTestSourceArgs;
import com.pulumi.gcp.networkmanagement.inputs.ConnectivityTestSourceAppEngineVersionArgs;
import com.pulumi.gcp.networkmanagement.inputs.ConnectivityTestSourceCloudFunctionArgs;
import com.pulumi.gcp.networkmanagement.inputs.ConnectivityTestSourceCloudRunRevisionArgs;
import com.pulumi.gcp.networkmanagement.inputs.ConnectivityTestDestinationArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;
public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }
    public static void stack(Context ctx) {
        var endpoints_test = new ConnectivityTest("endpoints-test", ConnectivityTestArgs.builder()
            .name("conn-test-endpoints")
            .source(ConnectivityTestSourceArgs.builder()
                .gkeMasterCluster("projects/test-project/locations/us-central1/clusters/name")
                .cloudSqlInstance("projects/test-project/instances/name")
                .appEngineVersion(ConnectivityTestSourceAppEngineVersionArgs.builder()
                    .uri("apps/test-project/services/default/versions/name")
                    .build())
                .cloudFunction(ConnectivityTestSourceCloudFunctionArgs.builder()
                    .uri("projects/test-project/locations/us-central1/functions/name")
                    .build())
                .cloudRunRevision(ConnectivityTestSourceCloudRunRevisionArgs.builder()
                    .uri("projects/test-project/locations/us-central1/revisions/name")
                    .build())
                .port(80)
                .build())
            .destination(ConnectivityTestDestinationArgs.builder()
                .port(443)
                .forwardingRule("projects/test-project/regions/us-central1/forwardingRules/name")
                .gkeMasterCluster("projects/test-project/locations/us-central1/clusters/name")
                .fqdn("name.us-central1.gke.goog")
                .cloudSqlInstance("projects/test-project/instances/name")
                .redisInstance("projects/test-project/locations/us-central1/instances/name")
                .redisCluster("projects/test-project/locations/us-central1/clusters/name")
                .build())
            .bypassFirewallChecks(true)
            .roundTrip(true)
            .build());
    }
}
Content copied to clipboard
resources:
  endpoints-test:
    type: gcp:networkmanagement:ConnectivityTest
    properties:
      name: conn-test-endpoints
      source:
        gkeMasterCluster: projects/test-project/locations/us-central1/clusters/name
        cloudSqlInstance: projects/test-project/instances/name
        appEngineVersion:
          uri: apps/test-project/services/default/versions/name
        cloudFunction:
          uri: projects/test-project/locations/us-central1/functions/name
        cloudRunRevision:
          uri: projects/test-project/locations/us-central1/revisions/name
        port: 80
      destination:
        port: 443
        forwardingRule: projects/test-project/regions/us-central1/forwardingRules/name
        gkeMasterCluster: projects/test-project/locations/us-central1/clusters/name
        fqdn: name.us-central1.gke.goog
        cloudSqlInstance: projects/test-project/instances/name
        redisInstance: projects/test-project/locations/us-central1/instances/name
        redisCluster: projects/test-project/locations/us-central1/clusters/name
      bypassFirewallChecks: true
      roundTrip: true
Content copied to clipboard

Import

ConnectivityTest can be imported using any of these accepted formats:

  • projects/{{project}}/locations/global/connectivityTests/{{name}}

  • {{project}}/{{name}}

  • {{name}} When using the pulumi import command, ConnectivityTest can be imported using one of the formats above. For example:

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

Constructors

Link copied to clipboard
constructor(bypassFirewallChecks: Output<Boolean>? = null, description: Output<String>? = null, destination: Output<ConnectivityTestDestinationArgs>? = null, labels: Output<Map<String, String>>? = null, name: Output<String>? = null, project: Output<String>? = null, protocol: Output<String>? = null, relatedProjects: Output<List<String>>? = null, roundTrip: Output<Boolean>? = null, source: Output<ConnectivityTestSourceArgs>? = null)

Properties

Link copied to clipboard
val bypassFirewallChecks: Output<Boolean>? = null

Whether the analysis should skip firewall checking. Default value is false.

Link copied to clipboard
val description: Output<String>? = null

The user-supplied description of the Connectivity Test. Maximum of 512 characters.

Link copied to clipboard
val destination: Output<ConnectivityTestDestinationArgs>? = null

Required. Destination specification of the Connectivity Test. You can use a combination of destination IP address, URI of a supported endpoint, project ID, or VPC network to identify the destination location. Reachability analysis proceeds even if the destination location is ambiguous. However, the test result might include endpoints or use a destination that you don't intend to test. Structure is documented below.

Link copied to clipboard
val labels: Output<Map<String, String>>? = null

Resource labels to represent user-provided metadata. Note: This field is non-authoritative, and will only manage the labels present in your configuration. Please refer to the field 'effective_labels' for all of the labels present on the resource.

Link copied to clipboard
val name: Output<String>? = null

Unique name for the connectivity test.

Link copied to clipboard
val project: Output<String>? = null
Link copied to clipboard
val protocol: Output<String>? = null

IP Protocol of the test. When not provided, "TCP" is assumed.

Link copied to clipboard
val relatedProjects: Output<List<String>>? = null

Other projects that may be relevant for reachability analysis. This is applicable to scenarios where a test can cross project boundaries.

Link copied to clipboard
val roundTrip: Output<Boolean>? = null

Whether run analysis for the return path from destination to source. Default value is false.

Link copied to clipboard
val source: Output<ConnectivityTestSourceArgs>? = null

Required. Source specification of the Connectivity Test. You can use a combination of source IP address, URI of a supported endpoint, project ID, or VPC network to identify the source location. Reachability analysis might proceed even if the source location is ambiguous. However, the test result might include endpoints or use a source that you don't intend to test. Structure is documented below.

Functions

Link copied to clipboard
open override fun toJava(): ConnectivityTestArgs