ConnectivityTest class

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
• How-to Guides
• Official Documentation

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",
    },
});

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",
    })

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" },
        },
    });

});

package main

import (
	"github.com/pulumi/pulumi-gcp/sdk/v9/go/gcp/compute"
	"github.com/pulumi/pulumi-gcp/sdk/v9/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().ToIDOutput().ToStringOutput(),
				},
			},
			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().ToIDOutput().ToStringOutput(),
				},
			},
			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().ToIDOutput().ToStringOutput(),
			},
			Destination: &networkmanagement.ConnectivityTestDestinationArgs{
				Instance: destination.ID().ToIDOutput().ToStringOutput(),
			},
			Protocol: pulumi.String("TCP"),
			Labels: pulumi.StringMap{
				"env": pulumi.String("test"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

pulumi {
  required_providers {
    gcp = {
      source = "pulumi/gcp"
    }
  }
}

data "gcp_compute_getimage" "debian9" {
  family  = "debian-11"
  project = "debian-cloud"
}

resource "gcp_networkmanagement_connectivitytest" "instance-test" {
  name = "conn-test-instances"
  source = {
    instance = gcp_compute_instance.source.id
  }
  destination = {
    instance = gcp_compute_instance.destination.id
  }
  protocol = "TCP"
  labels = {
    "env" = "test"
  }
}
resource "gcp_compute_instance" "source" {
  network_interfaces {
    access_configs {
    }
    network = gcp_compute_network.vpc.id
  }
  name         = "source-vm"
  machine_type = "e2-medium"
  boot_disk = {
    initialize_params = {
      image = data.gcp_compute_getimage.debian9.id
    }
  }
}
resource "gcp_compute_instance" "destination" {
  network_interfaces {
    access_configs {
    }
    network = gcp_compute_network.vpc.id
  }
  name         = "dest-vm"
  machine_type = "e2-medium"
  boot_disk = {
    initialize_params = {
      image = data.gcp_compute_getimage.debian9.id
    }
  }
}
resource "gcp_compute_network" "vpc" {
  name = "conn-test-net"
}

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.InstanceNetworkInterfaceAccessConfigArgs;
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.ArrayList;
import java.util.Arrays;
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());

    }
}

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

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",
});

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")

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",
    });

});

package main

import (
	"github.com/pulumi/pulumi-gcp/sdk/v9/go/gcp/compute"
	"github.com/pulumi/pulumi-gcp/sdk/v9/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().ToIDOutput().ToStringOutput(),
		})
		if err != nil {
			return err
		}
		source_addr, err := compute.NewAddress(ctx, "source-addr", &compute.AddressArgs{
			Name:        pulumi.String("src-addr"),
			Subnetwork:  subnet.ID().ToIDOutput().ToStringOutput(),
			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().ToIDOutput().ToStringOutput(),
			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().ToIDOutput().ToStringOutput(),
				NetworkType: pulumi.String("GCP_NETWORK"),
			},
			Destination: &networkmanagement.ConnectivityTestDestinationArgs{
				IpAddress: dest_addr.Address,
				ProjectId: dest_addr.Project,
				Network:   vpc.ID().ToIDOutput().ToStringOutput(),
			},
			Protocol: pulumi.String("UDP"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

pulumi {
  required_providers {
    gcp = {
      source = "pulumi/gcp"
    }
  }
}

resource "gcp_networkmanagement_connectivitytest" "address-test" {
  name = "conn-test-addr"
  source = {
    ip_address   = gcp_compute_address.source-addr.address
    project_id   = gcp_compute_address.source-addr.project
    network      = gcp_compute_network.vpc.id
    network_type = "GCP_NETWORK"
  }
  destination = {
    ip_address = gcp_compute_address.dest-addr.address
    project_id = gcp_compute_address.dest-addr.project
    network    = gcp_compute_network.vpc.id
  }
  protocol = "UDP"
}
resource "gcp_compute_network" "vpc" {
  name = "connectivity-vpc"
}
resource "gcp_compute_subnetwork" "subnet" {
  name          = "connectivity-vpc-subnet"
  ip_cidr_range = "10.0.0.0/16"
  region        = "us-central1"
  network       = gcp_compute_network.vpc.id
}
resource "gcp_compute_address" "source-addr" {
  name         = "src-addr"
  subnetwork   = gcp_compute_subnetwork.subnet.id
  address_type = "INTERNAL"
  address      = "10.0.42.42"
  region       = "us-central1"
}
resource "gcp_compute_address" "dest-addr" {
  name         = "dest-addr"
  subnetwork   = gcp_compute_subnetwork.subnet.id
  address_type = "INTERNAL"
  address      = "10.0.43.43"
  region       = "us-central1"
}

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.ArrayList;
import java.util.Arrays;
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());

    }
}

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

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,
});

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)

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,
    });

});

package main

import (
	"github.com/pulumi/pulumi-gcp/sdk/v9/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
	})
}

pulumi {
  required_providers {
    gcp = {
      source = "pulumi/gcp"
    }
  }
}

resource "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
}

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.ArrayList;
import java.util.Arrays;
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());

    }
}

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

Network Management Connectivity Test Gke Pod

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

const pod_test = new gcp.networkmanagement.ConnectivityTest("pod-test", {
    name: "conn-test-pod",
    source: {
        ipAddress: "10.0.0.1",
        projectId: "test-project",
        networkType: "GCP_NETWORK",
    },
    destination: {
        ipAddress: "10.0.0.2",
        projectId: "test-project",
        networkType: "GCP_NETWORK",
        gkePod: "projects/test-project/locations/us-central1/clusters/cluster-name/namespaces/default/pods/pod-name",
    },
    protocol: "TCP",
});

import pulumi
import pulumi_gcp as gcp

pod_test = gcp.networkmanagement.ConnectivityTest("pod-test",
    name="conn-test-pod",
    source={
        "ip_address": "10.0.0.1",
        "project_id": "test-project",
        "network_type": "GCP_NETWORK",
    },
    destination={
        "ip_address": "10.0.0.2",
        "project_id": "test-project",
        "network_type": "GCP_NETWORK",
        "gke_pod": "projects/test-project/locations/us-central1/clusters/cluster-name/namespaces/default/pods/pod-name",
    },
    protocol="TCP")

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

return await Deployment.RunAsync(() =>
{
    var pod_test = new Gcp.NetworkManagement.ConnectivityTest("pod-test", new()
    {
        Name = "conn-test-pod",
        Source = new Gcp.NetworkManagement.Inputs.ConnectivityTestSourceArgs
        {
            IpAddress = "10.0.0.1",
            ProjectId = "test-project",
            NetworkType = "GCP_NETWORK",
        },
        Destination = new Gcp.NetworkManagement.Inputs.ConnectivityTestDestinationArgs
        {
            IpAddress = "10.0.0.2",
            ProjectId = "test-project",
            NetworkType = "GCP_NETWORK",
            GkePod = "projects/test-project/locations/us-central1/clusters/cluster-name/namespaces/default/pods/pod-name",
        },
        Protocol = "TCP",
    });

});

package main

import (
	"github.com/pulumi/pulumi-gcp/sdk/v9/go/gcp/networkmanagement"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := networkmanagement.NewConnectivityTest(ctx, "pod-test", &networkmanagement.ConnectivityTestArgs{
			Name: pulumi.String("conn-test-pod"),
			Source: &networkmanagement.ConnectivityTestSourceArgs{
				IpAddress:   pulumi.String("10.0.0.1"),
				ProjectId:   pulumi.String("test-project"),
				NetworkType: pulumi.String("GCP_NETWORK"),
			},
			Destination: &networkmanagement.ConnectivityTestDestinationArgs{
				IpAddress:   pulumi.String("10.0.0.2"),
				ProjectId:   pulumi.String("test-project"),
				NetworkType: pulumi.String("GCP_NETWORK"),
				GkePod:      pulumi.String("projects/test-project/locations/us-central1/clusters/cluster-name/namespaces/default/pods/pod-name"),
			},
			Protocol: pulumi.String("TCP"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

pulumi {
  required_providers {
    gcp = {
      source = "pulumi/gcp"
    }
  }
}

resource "gcp_networkmanagement_connectivitytest" "pod-test" {
  name = "conn-test-pod"
  source = {
    ip_address   = "10.0.0.1"
    project_id   = "test-project"
    network_type = "GCP_NETWORK"
  }
  destination = {
    ip_address   = "10.0.0.2"
    project_id   = "test-project"
    network_type = "GCP_NETWORK"
    gke_pod      = "projects/test-project/locations/us-central1/clusters/cluster-name/namespaces/default/pods/pod-name"
  }
  protocol = "TCP"
}

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.ConnectivityTestDestinationArgs;
import java.util.ArrayList;
import java.util.Arrays;
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 pod_test = new ConnectivityTest("pod-test", ConnectivityTestArgs.builder()
            .name("conn-test-pod")
            .source(ConnectivityTestSourceArgs.builder()
                .ipAddress("10.0.0.1")
                .projectId("test-project")
                .networkType("GCP_NETWORK")
                .build())
            .destination(ConnectivityTestDestinationArgs.builder()
                .ipAddress("10.0.0.2")
                .projectId("test-project")
                .networkType("GCP_NETWORK")
                .gkePod("projects/test-project/locations/us-central1/clusters/cluster-name/namespaces/default/pods/pod-name")
                .build())
            .protocol("TCP")
            .build());

    }
}

resources:
  pod-test:
    type: gcp:networkmanagement:ConnectivityTest
    properties:
      name: conn-test-pod
      source:
        ipAddress: 10.0.0.1
        projectId: test-project
        networkType: GCP_NETWORK
      destination:
        ipAddress: 10.0.0.2
        projectId: test-project
        networkType: GCP_NETWORK
        gkePod: projects/test-project/locations/us-central1/clusters/cluster-name/namespaces/default/pods/pod-name
      protocol: TCP

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}}
$ pulumi import gcp:networkmanagement/connectivityTest:ConnectivityTest default {{project}}/{{name}}
$ pulumi import gcp:networkmanagement/connectivityTest:ConnectivityTest default {{name}}

Constructors

ConnectivityTest(String name, {ConnectivityTestArgs? args, CustomResourceOptions? options})

Creates a new ConnectivityTest. name The Pulumi resource name. args Arguments used to configure this ConnectivityTest. The set of arguments for ConnectivityTest. options Resource options controlling this resource's behavior.

ConnectivityTest.reference(String urn)

Creates a typed reference to an existing ConnectivityTest resource.

Properties

bypassFirewallChecks ↔ Output<bool?>

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

late, final

childResources → Set<Resource>

final, inherited

completionSources ↔ Map<String, IOutputCompletionSource>

late, final, inherited

deletionPolicy ↔ Output<String>

Whether Terraform will be prevented from destroying the resource. Defaults to DELETE. When a 'terraform destroy' or 'pulumi up' would delete the resource, the command will fail if this field is set to "PREVENT" in Terraform state. When set to "ABANDON", the command will remove the resource from Terraform management without updating or deleting the resource in the API. When set to "DELETE", deleting the resource is allowed.

late, final

description ↔ Output<String?>

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

late, final

destination ↔ Output<ConnectivityTestDestination>

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.

late, final

effectiveLabels ↔ Output<Map<String, String>>

All of labels (key/value pairs) present on the resource in GCP, including the labels configured through Pulumi, other clients and services.

late, final

hashCode → int

The hash code for this object.

no setter, inherited

id ↔ Output<String>

getter/setter pair, inherited

isCustom → bool

Returns whether this resource is provider-managed.

no setter, inherited

isProtected → bool

Returns whether this resource is protected from deletion.

no setter, inherited

isRemote → bool

Whether this resource is registered as remote.

no setter, inherited

isResourceReference → bool

Whether this instance represents a resource value returned over RPC.

final, inherited

labels ↔ Output<Map<String, String>?>

Resource labels to represent user-provided metadata.

late, final

name ↔ Output<String>

Unique name for the connectivity test.

late, final

project ↔ Output<String>

The ID of the project in which the resource belongs. If it is not provided, the provider project is used.

late, final

protocol ↔ Output<String?>

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

late, final

pulumiLabels ↔ Output<Map<String, String>>

The combination of labels configured directly on the resource and default labels configured on the provider.

late, final

relatedProjects ↔ Output<List<String>?>

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

late, final

resourceTransforms → List<ResourceTransform>

Inherited/explicit async transforms.

no setter, inherited

roundTrip ↔ Output<bool?>

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

late, final

runtimeType → Type

A representation of the runtime type of the object.

no setter, inherited

source ↔ Output<ConnectivityTestSource>

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.

late, final

transformations → List<ResourceTransformation>

Inherited/explicit legacy transformations.

no setter, inherited

urn ↔ Output<String>

late, final, inherited

Methods

failId(Object error) → void

Completes this resource ID with an error when registration fails.

inherited

failOutputs(Object error) → void

Completes all output properties with error.

inherited

failUrn(Object error) → void

Completes this resource URN with an error when registration fails.

inherited

getProvider(String moduleMember) → ProviderResource?

Returns provider for moduleMember's package, if configured.

inherited

getResourceName() → String

Returns this resource's logical name.

inherited

getResourceType() → String

Returns this resource's Pulumi type token.

inherited

noSuchMethod(Invocation invocation) → dynamic

Invoked when a nonexistent method or property is accessed.

inherited

registerOutput<T>(String propertyName, {Object? decoder(Object?)?, bool isSecret = false}) → Output<T>

Registers a dynamic output property for this resource.

inherited

resolveId(String? value, {required bool isKnown}) → void

Resolves the provider-assigned ID for this resource.

inherited

resolveOutputs(Struct outputs) → void

Resolves all output properties from a monitor response payload.

inherited

resolveUrn(String value) → void

Resolves this resource's URN once assigned by the engine.

inherited

serializeProperties(Map<String, dynamic> properties) → Future<Struct>

Serializes resource properties for RPC transmission.

inherited

toString() → String

A string representation of this object.

inherited

Operators

operator ==(Object other) → bool

The equality operator.

inherited

Static Methods

get(String name, Input<String> id, {ConnectivityTestState? state, CustomResourceOptions? options}) → ConnectivityTest

Gets an existing ConnectivityTest resource's state with the given name and id.