pulumi-gcp-kotlin/com.pulumi.gcp.compute.kotlin/PacketMirroring

PacketMirroring

class PacketMirroring : KotlinCustomResource

Packet Mirroring mirrors traffic to and from particular VM instances. You can use the collected traffic to help you detect security threats and monitor application performance. To get more information about PacketMirroring, see:

Example Usage

Compute Packet Mirroring Full

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.Instance;
import com.pulumi.gcp.compute.InstanceArgs;
import com.pulumi.gcp.compute.inputs.InstanceBootDiskArgs;
import com.pulumi.gcp.compute.inputs.InstanceBootDiskInitializeParamsArgs;
import com.pulumi.gcp.compute.inputs.InstanceNetworkInterfaceArgs;
import com.pulumi.gcp.compute.Subnetwork;
import com.pulumi.gcp.compute.SubnetworkArgs;
import com.pulumi.gcp.compute.HealthCheck;
import com.pulumi.gcp.compute.HealthCheckArgs;
import com.pulumi.gcp.compute.inputs.HealthCheckTcpHealthCheckArgs;
import com.pulumi.gcp.compute.RegionBackendService;
import com.pulumi.gcp.compute.RegionBackendServiceArgs;
import com.pulumi.gcp.compute.ForwardingRule;
import com.pulumi.gcp.compute.ForwardingRuleArgs;
import com.pulumi.gcp.compute.PacketMirroring;
import com.pulumi.gcp.compute.PacketMirroringArgs;
import com.pulumi.gcp.compute.inputs.PacketMirroringNetworkArgs;
import com.pulumi.gcp.compute.inputs.PacketMirroringCollectorIlbArgs;
import com.pulumi.gcp.compute.inputs.PacketMirroringMirroredResourcesArgs;
import com.pulumi.gcp.compute.inputs.PacketMirroringFilterArgs;
import com.pulumi.resources.CustomResourceOptions;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;
public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }
    public static void stack(Context ctx) {
        var defaultNetwork = new Network("defaultNetwork");
        var mirror = new Instance("mirror", InstanceArgs.builder()
            .machineType("e2-medium")
            .bootDisk(InstanceBootDiskArgs.builder()
                .initializeParams(InstanceBootDiskInitializeParamsArgs.builder()
                    .image("debian-cloud/debian-11")
                    .build())
                .build())
            .networkInterfaces(InstanceNetworkInterfaceArgs.builder()
                .network(defaultNetwork.id())
                .accessConfigs()
                .build())
            .build());
        var defaultSubnetwork = new Subnetwork("defaultSubnetwork", SubnetworkArgs.builder()
            .network(defaultNetwork.id())
            .ipCidrRange("10.2.0.0/16")
            .build());
        var defaultHealthCheck = new HealthCheck("defaultHealthCheck", HealthCheckArgs.builder()
            .checkIntervalSec(1)
            .timeoutSec(1)
            .tcpHealthCheck(HealthCheckTcpHealthCheckArgs.builder()
                .port("80")
                .build())
            .build());
        var defaultRegionBackendService = new RegionBackendService("defaultRegionBackendService", RegionBackendServiceArgs.builder()
            .healthChecks(defaultHealthCheck.id())
            .build());
        var defaultForwardingRule = new ForwardingRule("defaultForwardingRule", ForwardingRuleArgs.builder()
            .isMirroringCollector(true)
            .ipProtocol("TCP")
            .loadBalancingScheme("INTERNAL")
            .backendService(defaultRegionBackendService.id())
            .allPorts(true)
            .network(defaultNetwork.id())
            .subnetwork(defaultSubnetwork.id())
            .networkTier("PREMIUM")
            .build(), CustomResourceOptions.builder()
                .dependsOn(defaultSubnetwork)
                .build());
        var foobar = new PacketMirroring("foobar", PacketMirroringArgs.builder()
            .description("bar")
            .network(PacketMirroringNetworkArgs.builder()
                .url(defaultNetwork.id())
                .build())
            .collectorIlb(PacketMirroringCollectorIlbArgs.builder()
                .url(defaultForwardingRule.id())
                .build())
            .mirroredResources(PacketMirroringMirroredResourcesArgs.builder()
                .tags("foo")
                .instances(PacketMirroringMirroredResourcesInstanceArgs.builder()
                    .url(mirror.id())
                    .build())
                .build())
            .filter(PacketMirroringFilterArgs.builder()
                .ipProtocols("tcp")
                .cidrRanges("0.0.0.0/0")
                .direction("BOTH")
                .build())
            .build());
    }
}
Content copied to clipboard

Import

PacketMirroring can be imported using any of these accepted formats

$ pulumi import gcp:compute/packetMirroring:PacketMirroring default projects/{{project}}/regions/{{region}}/packetMirrorings/{{name}}
Content copied to clipboard
$ pulumi import gcp:compute/packetMirroring:PacketMirroring default {{project}}/{{region}}/{{name}}
Content copied to clipboard
$ pulumi import gcp:compute/packetMirroring:PacketMirroring default {{region}}/{{name}}
Content copied to clipboard
$ pulumi import gcp:compute/packetMirroring:PacketMirroring default {{name}}
Content copied to clipboard

Properties

Link copied to clipboard
val collectorIlb: Output<PacketMirroringCollectorIlb>

The Forwarding Rule resource (of type load_balancing_scheme=INTERNAL) that will be used as collector for mirrored traffic. The specified forwarding rule must have is_mirroring_collector set to true. Structure is documented below.

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

A human-readable description of the rule.

Link copied to clipboard
val filter: Output<PacketMirroringFilter>?

A filter for mirrored traffic. If unset, all traffic is mirrored. Structure is documented below.

Link copied to clipboard
val id: Output<String>
Link copied to clipboard
val mirroredResources: Output<PacketMirroringMirroredResources>

A means of specifying which resources to mirror. Structure is documented below.

Link copied to clipboard
val name: Output<String>

The name of the packet mirroring rule

Link copied to clipboard
val network: Output<PacketMirroringNetwork>

Specifies the mirrored VPC network. Only packets in this network will be mirrored. All mirrored VMs should have a NIC in the given network. All mirrored subnetworks should belong to the given network. Structure is documented below.

Link copied to clipboard
val priority: Output<Int>

Since only one rule can be active at a time, priority is used to break ties in the case of two rules that apply to the same instances.

Link copied to clipboard
val project: Output<String>

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

Link copied to clipboard
val pulumiChildResources: Set<KotlinResource>
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
val region: Output<String>

The Region in which the created address should reside. If it is not provided, the provider region is used.

Link copied to clipboard
val urn: Output<String>