pulumi-azure-native-kotlin/com.pulumi.azurenative.managednetworkfabric.kotlin/NetworkTapRule

NetworkTapRule

class NetworkTapRule : KotlinCustomResource

The NetworkTapRule resource definition. Azure REST API version: 2023-06-15.

Example Usage

NetworkTapRules_Create_MaximumSet_Gen

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using AzureNative = Pulumi.AzureNative;
return await Deployment.RunAsync(() =>
{
    var networkTapRule = new AzureNative.ManagedNetworkFabric.NetworkTapRule("networkTapRule", new()
    {
        Annotation = "annotation",
        ConfigurationType = "File",
        DynamicMatchConfigurations = new[]
        {
            new AzureNative.ManagedNetworkFabric.Inputs.CommonDynamicMatchConfigurationArgs
            {
                IpGroups = new[]
                {
                    new AzureNative.ManagedNetworkFabric.Inputs.IpGroupPropertiesArgs
                    {
                        IpAddressType = "IPv4",
                        IpPrefixes = new[]
                        {
                            "10.10.10.10/30",
                        },
                        Name = "example-ipGroup1",
                    },
                },
                PortGroups = new[]
                {
                    new AzureNative.ManagedNetworkFabric.Inputs.PortGroupPropertiesArgs
                    {
                        Name = "example-portGroup1",
                        Ports = new[]
                        {
                            "100-200",
                        },
                    },
                    new AzureNative.ManagedNetworkFabric.Inputs.PortGroupPropertiesArgs
                    {
                        Name = "example-portGroup2",
                        Ports = new[]
                        {
                            "900",
                            "1000-2000",
                        },
                    },
                },
                VlanGroups = new[]
                {
                    new AzureNative.ManagedNetworkFabric.Inputs.VlanGroupPropertiesArgs
                    {
                        Name = "exmaple-vlanGroup",
                        Vlans = new[]
                        {
                            "10",
                            "100-200",
                        },
                    },
                },
            },
        },
        Location = "eastus",
        MatchConfigurations = new[]
        {
            new AzureNative.ManagedNetworkFabric.Inputs.NetworkTapRuleMatchConfigurationArgs
            {
                Actions = new[]
                {
                    new AzureNative.ManagedNetworkFabric.Inputs.NetworkTapRuleActionArgs
                    {
                        DestinationId = "/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourcegroups/example-rg/providers/Microsoft.ManagedNetworkFabric/neighborGroups/example-neighborGroup",
                        IsTimestampEnabled = "True",
                        MatchConfigurationName = "match1",
                        Truncate = "100",
                        Type = "Drop",
                    },
                },
                IpAddressType = "IPv4",
                MatchConditions = new[]
                {
                    new AzureNative.ManagedNetworkFabric.Inputs.NetworkTapRuleMatchConditionArgs
                    {
                        EncapsulationType = "None",
                        IpCondition = new AzureNative.ManagedNetworkFabric.Inputs.IpMatchConditionArgs
                        {
                            IpGroupNames = new[]
                            {
                                "example-ipGroup",
                            },
                            IpPrefixValues = new[]
                            {
                                "10.10.10.10/20",
                            },
                            PrefixType = "Prefix",
                            Type = "SourceIP",
                        },
                        PortCondition = new AzureNative.ManagedNetworkFabric.Inputs.PortConditionArgs
                        {
                            Layer4Protocol = "TCP",
                            PortGroupNames = new[]
                            {
                                "example-portGroup1",
                            },
                            PortType = "SourcePort",
                            Ports = new[]
                            {
                                "100",
                            },
                        },
                        ProtocolTypes = new[]
                        {
                            "TCP",
                        },
                        VlanMatchCondition = new AzureNative.ManagedNetworkFabric.Inputs.VlanMatchConditionArgs
                        {
                            InnerVlans = new[]
                            {
                                "11-20",
                            },
                            VlanGroupNames = new[]
                            {
                                "exmaple-vlanGroup",
                            },
                            Vlans = new[]
                            {
                                "10",
                            },
                        },
                    },
                },
                MatchConfigurationName = "config1",
                SequenceNumber = 10,
            },
        },
        NetworkTapRuleName = "example-tapRule",
        PollingIntervalInSeconds = 30,
        ResourceGroupName = "example-rg",
        Tags =
        {
            { "keyID", "keyValue" },
        },
        TapRulesUrl = "https://microsoft.com/a",
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-azure-native-sdk/managednetworkfabric/v2"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := managednetworkfabric.NewNetworkTapRule(ctx, "networkTapRule", &managednetworkfabric.NetworkTapRuleArgs{
			Annotation:        pulumi.String("annotation"),
			ConfigurationType: pulumi.String("File"),
			DynamicMatchConfigurations: []managednetworkfabric.CommonDynamicMatchConfigurationArgs{
				{
					IpGroups: managednetworkfabric.IpGroupPropertiesArray{
						{
							IpAddressType: pulumi.String("IPv4"),
							IpPrefixes: pulumi.StringArray{
								pulumi.String("10.10.10.10/30"),
							},
							Name: pulumi.String("example-ipGroup1"),
						},
					},
					PortGroups: managednetworkfabric.PortGroupPropertiesArray{
						{
							Name: pulumi.String("example-portGroup1"),
							Ports: pulumi.StringArray{
								pulumi.String("100-200"),
							},
						},
						{
							Name: pulumi.String("example-portGroup2"),
							Ports: pulumi.StringArray{
								pulumi.String("900"),
								pulumi.String("1000-2000"),
							},
						},
					},
					VlanGroups: managednetworkfabric.VlanGroupPropertiesArray{
						{
							Name: pulumi.String("exmaple-vlanGroup"),
							Vlans: pulumi.StringArray{
								pulumi.String("10"),
								pulumi.String("100-200"),
							},
						},
					},
				},
			},
			Location: pulumi.String("eastus"),
			MatchConfigurations: []managednetworkfabric.NetworkTapRuleMatchConfigurationArgs{
				{
					Actions: managednetworkfabric.NetworkTapRuleActionArray{
						{
							DestinationId:          pulumi.String("/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourcegroups/example-rg/providers/Microsoft.ManagedNetworkFabric/neighborGroups/example-neighborGroup"),
							IsTimestampEnabled:     pulumi.String("True"),
							MatchConfigurationName: pulumi.String("match1"),
							Truncate:               pulumi.String("100"),
							Type:                   pulumi.String("Drop"),
						},
					},
					IpAddressType: pulumi.String("IPv4"),
					MatchConditions: managednetworkfabric.NetworkTapRuleMatchConditionArray{
						{
							EncapsulationType: pulumi.String("None"),
							IpCondition: {
								IpGroupNames: pulumi.StringArray{
									pulumi.String("example-ipGroup"),
								},
								IpPrefixValues: pulumi.StringArray{
									pulumi.String("10.10.10.10/20"),
								},
								PrefixType: pulumi.String("Prefix"),
								Type:       pulumi.String("SourceIP"),
							},
							PortCondition: {
								Layer4Protocol: pulumi.String("TCP"),
								PortGroupNames: pulumi.StringArray{
									pulumi.String("example-portGroup1"),
								},
								PortType: pulumi.String("SourcePort"),
								Ports: pulumi.StringArray{
									pulumi.String("100"),
								},
							},
							ProtocolTypes: pulumi.StringArray{
								pulumi.String("TCP"),
							},
							VlanMatchCondition: {
								InnerVlans: pulumi.StringArray{
									pulumi.String("11-20"),
								},
								VlanGroupNames: pulumi.StringArray{
									pulumi.String("exmaple-vlanGroup"),
								},
								Vlans: pulumi.StringArray{
									pulumi.String("10"),
								},
							},
						},
					},
					MatchConfigurationName: pulumi.String("config1"),
					SequenceNumber:         pulumi.Float64(10),
				},
			},
			NetworkTapRuleName:       pulumi.String("example-tapRule"),
			PollingIntervalInSeconds: pulumi.Int(30),
			ResourceGroupName:        pulumi.String("example-rg"),
			Tags: pulumi.StringMap{
				"keyID": pulumi.String("keyValue"),
			},
			TapRulesUrl: pulumi.String("https://microsoft.com/a"),
		})
		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.azurenative.managednetworkfabric.NetworkTapRule;
import com.pulumi.azurenative.managednetworkfabric.NetworkTapRuleArgs;
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 networkTapRule = new NetworkTapRule("networkTapRule", NetworkTapRuleArgs.builder()
            .annotation("annotation")
            .configurationType("File")
            .dynamicMatchConfigurations(Map.ofEntries(
                Map.entry("ipGroups", Map.ofEntries(
                    Map.entry("ipAddressType", "IPv4"),
                    Map.entry("ipPrefixes", "10.10.10.10/30"),
                    Map.entry("name", "example-ipGroup1")
                )),
                Map.entry("portGroups",
                    Map.ofEntries(
                        Map.entry("name", "example-portGroup1"),
                        Map.entry("ports", "100-200")
                    ),
                    Map.ofEntries(
                        Map.entry("name", "example-portGroup2"),
                        Map.entry("ports",
                            "900",
                            "1000-2000")
                    )),
                Map.entry("vlanGroups", Map.ofEntries(
                    Map.entry("name", "exmaple-vlanGroup"),
                    Map.entry("vlans",
                        "10",
                        "100-200")
                ))
            ))
            .location("eastus")
            .matchConfigurations(Map.ofEntries(
                Map.entry("actions", Map.ofEntries(
                    Map.entry("destinationId", "/subscriptions/1234ABCD-0A1B-1234-5678-123456ABCDEF/resourcegroups/example-rg/providers/Microsoft.ManagedNetworkFabric/neighborGroups/example-neighborGroup"),
                    Map.entry("isTimestampEnabled", "True"),
                    Map.entry("matchConfigurationName", "match1"),
                    Map.entry("truncate", "100"),
                    Map.entry("type", "Drop")
                )),
                Map.entry("ipAddressType", "IPv4"),
                Map.entry("matchConditions", Map.ofEntries(
                    Map.entry("encapsulationType", "None"),
                    Map.entry("ipCondition", Map.ofEntries(
                        Map.entry("ipGroupNames", "example-ipGroup"),
                        Map.entry("ipPrefixValues", "10.10.10.10/20"),
                        Map.entry("prefixType", "Prefix"),
                        Map.entry("type", "SourceIP")
                    )),
                    Map.entry("portCondition", Map.ofEntries(
                        Map.entry("layer4Protocol", "TCP"),
                        Map.entry("portGroupNames", "example-portGroup1"),
                        Map.entry("portType", "SourcePort"),
                        Map.entry("ports", "100")
                    )),
                    Map.entry("protocolTypes", "TCP"),
                    Map.entry("vlanMatchCondition", Map.ofEntries(
                        Map.entry("innerVlans", "11-20"),
                        Map.entry("vlanGroupNames", "exmaple-vlanGroup"),
                        Map.entry("vlans", "10")
                    ))
                )),
                Map.entry("matchConfigurationName", "config1"),
                Map.entry("sequenceNumber", 10)
            ))
            .networkTapRuleName("example-tapRule")
            .pollingIntervalInSeconds(30)
            .resourceGroupName("example-rg")
            .tags(Map.of("keyID", "keyValue"))
            .tapRulesUrl("https://microsoft.com/a")
            .build());
    }
}
Content copied to clipboard

Import

An existing resource can be imported using its type token, name, and identifier, e.g.

$ pulumi import azure-native:managednetworkfabric:NetworkTapRule example-tapRule /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ManagedNetworkFabric/networkTapRules/{networkTapRuleName}
Content copied to clipboard

Properties

Link copied to clipboard
val administrativeState: Output<String>

Administrative state of the resource.

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

Switch configuration description.

Link copied to clipboard
val configurationState: Output<String>

Configuration state of the resource.

Link copied to clipboard
val configurationType: Output<String>

Input method to configure Network Tap Rule.

Link copied to clipboard
val dynamicMatchConfigurations: Output<List<CommonDynamicMatchConfigurationResponse>>?

List of dynamic match configurations.

Link copied to clipboard
val id: Output<String>
Link copied to clipboard
val lastSyncedTime: Output<String>

The last sync timestamp.

Link copied to clipboard
val location: Output<String>

The geo-location where the resource lives

Link copied to clipboard
val matchConfigurations: Output<List<NetworkTapRuleMatchConfigurationResponse>>?

List of match configurations.

Link copied to clipboard
val name: Output<String>

The name of the resource

Link copied to clipboard
val networkTapId: Output<String>

The ARM resource Id of the NetworkTap.

Link copied to clipboard
val pollingIntervalInSeconds: Output<Int>?

Polling interval in seconds.

Link copied to clipboard
val provisioningState: Output<String>

Provisioning state of the resource.

Link copied to clipboard
val pulumiChildResources: Set<KotlinResource>
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
val systemData: Output<SystemDataResponse>

Azure Resource Manager metadata containing createdBy and modifiedBy information.

Link copied to clipboard
val tags: Output<Map<String, String>>?

Resource tags.

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

Network Tap Rules file URL.

Link copied to clipboard
val type: Output<String>

The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or "Microsoft.Storage/storageAccounts"

Link copied to clipboard
val urn: Output<String>