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

AccessControlList

class AccessControlList : KotlinCustomResource

The Access Control List resource definition. Uses Azure REST API version 2023-06-15. In version 2.x of the Azure Native provider, it used API version 2023-02-01-preview. Other available API versions: 2023-02-01-preview. These can be accessed by generating a local SDK package using the CLI command pulumi package add azure-native managednetworkfabric [ApiVersion]. See the ../../../version-guide/#accessing-any-api-version-via-local-packages for details.

Example Usage

AccessControlLists_Create_MaximumSet_Gen

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using AzureNative = Pulumi.AzureNative;
return await Deployment.RunAsync(() =>
{
    var accessControlList = new AzureNative.ManagedNetworkFabric.AccessControlList("accessControlList", new()
    {
        AccessControlListName = "example-acl",
        AclsUrl = "https://ACL-Storage-URL",
        Annotation = "annotation",
        ConfigurationType = AzureNative.ManagedNetworkFabric.ConfigurationType.File,
        DefaultAction = AzureNative.ManagedNetworkFabric.CommunityActionTypes.Permit,
        DynamicMatchConfigurations = new[]
        {
            new AzureNative.ManagedNetworkFabric.Inputs.CommonDynamicMatchConfigurationArgs
            {
                IpGroups = new[]
                {
                    new AzureNative.ManagedNetworkFabric.Inputs.IpGroupPropertiesArgs
                    {
                        IpAddressType = AzureNative.ManagedNetworkFabric.IPAddressType.IPv4,
                        IpPrefixes = new[]
                        {
                            "10.20.3.1/20",
                        },
                        Name = "example-ipGroup",
                    },
                },
                PortGroups = new[]
                {
                    new AzureNative.ManagedNetworkFabric.Inputs.PortGroupPropertiesArgs
                    {
                        Name = "example-portGroup",
                        Ports = new[]
                        {
                            "100-200",
                        },
                    },
                },
                VlanGroups = new[]
                {
                    new AzureNative.ManagedNetworkFabric.Inputs.VlanGroupPropertiesArgs
                    {
                        Name = "example-vlanGroup",
                        Vlans = new[]
                        {
                            "20-30",
                        },
                    },
                },
            },
        },
        Location = "eastUs",
        MatchConfigurations = new[]
        {
            new AzureNative.ManagedNetworkFabric.Inputs.AccessControlListMatchConfigurationArgs
            {
                Actions = new[]
                {
                    new AzureNative.ManagedNetworkFabric.Inputs.AccessControlListActionArgs
                    {
                        CounterName = "example-counter",
                        Type = AzureNative.ManagedNetworkFabric.AclActionType.Count,
                    },
                },
                IpAddressType = AzureNative.ManagedNetworkFabric.IPAddressType.IPv4,
                MatchConditions = new[]
                {
                    new AzureNative.ManagedNetworkFabric.Inputs.AccessControlListMatchConditionArgs
                    {
                        DscpMarkings = new[]
                        {
                            "32",
                        },
                        EtherTypes = new[]
                        {
                            "0x1",
                        },
                        Fragments = new[]
                        {
                            "0xff00-0xffff",
                        },
                        IpCondition = new AzureNative.ManagedNetworkFabric.Inputs.IpMatchConditionArgs
                        {
                            IpGroupNames = new[]
                            {
                                "example-ipGroup",
                            },
                            IpPrefixValues = new[]
                            {
                                "10.20.20.20/12",
                            },
                            PrefixType = AzureNative.ManagedNetworkFabric.PrefixType.Prefix,
                            Type = AzureNative.ManagedNetworkFabric.SourceDestinationType.SourceIP,
                        },
                        IpLengths = new[]
                        {
                            "4094-9214",
                        },
                        PortCondition = new AzureNative.ManagedNetworkFabric.Inputs.AccessControlListPortConditionArgs
                        {
                            Flags = new[]
                            {
                                "established",
                            },
                            Layer4Protocol = AzureNative.ManagedNetworkFabric.Layer4Protocol.TCP,
                            PortGroupNames = new[]
                            {
                                "example-portGroup",
                            },
                            PortType = AzureNative.ManagedNetworkFabric.PortType.SourcePort,
                            Ports = new[]
                            {
                                "1-20",
                            },
                        },
                        ProtocolTypes = new[]
                        {
                            "TCP",
                        },
                        TtlValues = new[]
                        {
                            "23",
                        },
                        VlanMatchCondition = new AzureNative.ManagedNetworkFabric.Inputs.VlanMatchConditionArgs
                        {
                            InnerVlans = new[]
                            {
                                "30",
                            },
                            VlanGroupNames = new[]
                            {
                                "example-vlanGroup",
                            },
                            Vlans = new[]
                            {
                                "20-30",
                            },
                        },
                    },
                },
                MatchConfigurationName = "example-match",
                SequenceNumber = 123,
            },
        },
        ResourceGroupName = "example-rg",
        Tags =
        {
            { "keyID", "KeyValue" },
        },
    });
});
Content copied to clipboard
package main
import (
	managednetworkfabric "github.com/pulumi/pulumi-azure-native-sdk/managednetworkfabric/v3"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := managednetworkfabric.NewAccessControlList(ctx, "accessControlList", &managednetworkfabric.AccessControlListArgs{
			AccessControlListName: pulumi.String("example-acl"),
			AclsUrl:               pulumi.String("https://ACL-Storage-URL"),
			Annotation:            pulumi.String("annotation"),
			ConfigurationType:     pulumi.String(managednetworkfabric.ConfigurationTypeFile),
			DefaultAction:         pulumi.String(managednetworkfabric.CommunityActionTypesPermit),
			DynamicMatchConfigurations: managednetworkfabric.CommonDynamicMatchConfigurationArray{
				&managednetworkfabric.CommonDynamicMatchConfigurationArgs{
					IpGroups: managednetworkfabric.IpGroupPropertiesArray{
						&managednetworkfabric.IpGroupPropertiesArgs{
							IpAddressType: pulumi.String(managednetworkfabric.IPAddressTypeIPv4),
							IpPrefixes: pulumi.StringArray{
								pulumi.String("10.20.3.1/20"),
							},
							Name: pulumi.String("example-ipGroup"),
						},
					},
					PortGroups: managednetworkfabric.PortGroupPropertiesArray{
						&managednetworkfabric.PortGroupPropertiesArgs{
							Name: pulumi.String("example-portGroup"),
							Ports: pulumi.StringArray{
								pulumi.String("100-200"),
							},
						},
					},
					VlanGroups: managednetworkfabric.VlanGroupPropertiesArray{
						&managednetworkfabric.VlanGroupPropertiesArgs{
							Name: pulumi.String("example-vlanGroup"),
							Vlans: pulumi.StringArray{
								pulumi.String("20-30"),
							},
						},
					},
				},
			},
			Location: pulumi.String("eastUs"),
			MatchConfigurations: managednetworkfabric.AccessControlListMatchConfigurationArray{
				&managednetworkfabric.AccessControlListMatchConfigurationArgs{
					Actions: managednetworkfabric.AccessControlListActionArray{
						&managednetworkfabric.AccessControlListActionArgs{
							CounterName: pulumi.String("example-counter"),
							Type:        pulumi.String(managednetworkfabric.AclActionTypeCount),
						},
					},
					IpAddressType: pulumi.String(managednetworkfabric.IPAddressTypeIPv4),
					MatchConditions: managednetworkfabric.AccessControlListMatchConditionArray{
						&managednetworkfabric.AccessControlListMatchConditionArgs{
							DscpMarkings: pulumi.StringArray{
								pulumi.String("32"),
							},
							EtherTypes: pulumi.StringArray{
								pulumi.String("0x1"),
							},
							Fragments: pulumi.StringArray{
								pulumi.String("0xff00-0xffff"),
							},
							IpCondition: &managednetworkfabric.IpMatchConditionArgs{
								IpGroupNames: pulumi.StringArray{
									pulumi.String("example-ipGroup"),
								},
								IpPrefixValues: pulumi.StringArray{
									pulumi.String("10.20.20.20/12"),
								},
								PrefixType: pulumi.String(managednetworkfabric.PrefixTypePrefix),
								Type:       pulumi.String(managednetworkfabric.SourceDestinationTypeSourceIP),
							},
							IpLengths: pulumi.StringArray{
								pulumi.String("4094-9214"),
							},
							PortCondition: &managednetworkfabric.AccessControlListPortConditionArgs{
								Flags: pulumi.StringArray{
									pulumi.String("established"),
								},
								Layer4Protocol: pulumi.String(managednetworkfabric.Layer4ProtocolTCP),
								PortGroupNames: pulumi.StringArray{
									pulumi.String("example-portGroup"),
								},
								PortType: pulumi.String(managednetworkfabric.PortTypeSourcePort),
								Ports: pulumi.StringArray{
									pulumi.String("1-20"),
								},
							},
							ProtocolTypes: pulumi.StringArray{
								pulumi.String("TCP"),
							},
							TtlValues: pulumi.StringArray{
								pulumi.String("23"),
							},
							VlanMatchCondition: &managednetworkfabric.VlanMatchConditionArgs{
								InnerVlans: pulumi.StringArray{
									pulumi.String("30"),
								},
								VlanGroupNames: pulumi.StringArray{
									pulumi.String("example-vlanGroup"),
								},
								Vlans: pulumi.StringArray{
									pulumi.String("20-30"),
								},
							},
						},
					},
					MatchConfigurationName: pulumi.String("example-match"),
					SequenceNumber:         pulumi.Float64(123),
				},
			},
			ResourceGroupName: pulumi.String("example-rg"),
			Tags: pulumi.StringMap{
				"keyID": pulumi.String("KeyValue"),
			},
		})
		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.AccessControlList;
import com.pulumi.azurenative.managednetworkfabric.AccessControlListArgs;
import com.pulumi.azurenative.managednetworkfabric.inputs.CommonDynamicMatchConfigurationArgs;
import com.pulumi.azurenative.managednetworkfabric.inputs.AccessControlListMatchConfigurationArgs;
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 accessControlList = new AccessControlList("accessControlList", AccessControlListArgs.builder()
            .accessControlListName("example-acl")
            .aclsUrl("https://ACL-Storage-URL")
            .annotation("annotation")
            .configurationType("File")
            .defaultAction("Permit")
            .dynamicMatchConfigurations(CommonDynamicMatchConfigurationArgs.builder()
                .ipGroups(IpGroupPropertiesArgs.builder()
                    .ipAddressType("IPv4")
                    .ipPrefixes("10.20.3.1/20")
                    .name("example-ipGroup")
                    .build())
                .portGroups(PortGroupPropertiesArgs.builder()
                    .name("example-portGroup")
                    .ports("100-200")
                    .build())
                .vlanGroups(VlanGroupPropertiesArgs.builder()
                    .name("example-vlanGroup")
                    .vlans("20-30")
                    .build())
                .build())
            .location("eastUs")
            .matchConfigurations(AccessControlListMatchConfigurationArgs.builder()
                .actions(AccessControlListActionArgs.builder()
                    .counterName("example-counter")
                    .type("Count")
                    .build())
                .ipAddressType("IPv4")
                .matchConditions(AccessControlListMatchConditionArgs.builder()
                    .dscpMarkings("32")
                    .etherTypes("0x1")
                    .fragments("0xff00-0xffff")
                    .ipCondition(IpMatchConditionArgs.builder()
                        .ipGroupNames("example-ipGroup")
                        .ipPrefixValues("10.20.20.20/12")
                        .prefixType("Prefix")
                        .type("SourceIP")
                        .build())
                    .ipLengths("4094-9214")
                    .portCondition(AccessControlListPortConditionArgs.builder()
                        .flags("established")
                        .layer4Protocol("TCP")
                        .portGroupNames("example-portGroup")
                        .portType("SourcePort")
                        .ports("1-20")
                        .build())
                    .protocolTypes("TCP")
                    .ttlValues("23")
                    .vlanMatchCondition(VlanMatchConditionArgs.builder()
                        .innerVlans("30")
                        .vlanGroupNames("example-vlanGroup")
                        .vlans("20-30")
                        .build())
                    .build())
                .matchConfigurationName("example-match")
                .sequenceNumber(123.0)
                .build())
            .resourceGroupName("example-rg")
            .tags(Map.of("keyID", "KeyValue"))
            .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:AccessControlList example-acl /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ManagedNetworkFabric/accessControlLists/{accessControlListName}
Content copied to clipboard

Properties

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

Access Control List file URL.

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 azureApiVersion: Output<String>

The Azure API version of the resource.

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 Access Control List.

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

Default action that needs to be applied when no condition is matched. Example: Permit | Deny.

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 synced timestamp.

Link copied to clipboard
val location: Output<String>

The geo-location where the resource lives

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

List of match configurations.

Link copied to clipboard
val name: Output<String>

The name of the resource

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