azure.signalr.ServiceNetworkAcl

using Pulumi;
using Azure = Pulumi.Azure;

class MyStack : Stack
{
    public MyStack()
    {
        var exampleResourceGroup = new Azure.Core.ResourceGroup("exampleResourceGroup", new Azure.Core.ResourceGroupArgs
        {
            Location = "West Europe",
        });
        var exampleService = new Azure.SignalR.Service("exampleService", new Azure.SignalR.ServiceArgs
        {
            Location = exampleResourceGroup.Location,
            ResourceGroupName = exampleResourceGroup.Name,
            Sku = new Azure.SignalR.Inputs.ServiceSkuArgs
            {
                Name = "Standard_S1",
                Capacity = 1,
            },
        });
        var exampleVirtualNetwork = new Azure.Network.VirtualNetwork("exampleVirtualNetwork", new Azure.Network.VirtualNetworkArgs
        {
            ResourceGroupName = exampleResourceGroup.Name,
            Location = exampleResourceGroup.Location,
            AddressSpaces = 
            {
                "10.5.0.0/16",
            },
        });
        var exampleSubnet = new Azure.Network.Subnet("exampleSubnet", new Azure.Network.SubnetArgs
        {
            ResourceGroupName = exampleResourceGroup.Name,
            VirtualNetworkName = exampleVirtualNetwork.Name,
            AddressPrefixes = 
            {
                "10.5.2.0/24",
            },
            EnforcePrivateLinkEndpointNetworkPolicies = true,
        });
        var exampleEndpoint = new Azure.PrivateLink.Endpoint("exampleEndpoint", new Azure.PrivateLink.EndpointArgs
        {
            ResourceGroupName = exampleResourceGroup.Name,
            Location = exampleResourceGroup.Location,
            SubnetId = exampleSubnet.Id,
            PrivateServiceConnection = new Azure.PrivateLink.Inputs.EndpointPrivateServiceConnectionArgs
            {
                Name = "psc-sig-test",
                IsManualConnection = false,
                PrivateConnectionResourceId = exampleService.Id,
                SubresourceNames = 
                {
                    "signalr",
                },
            },
        });
        var exampleServiceNetworkAcl = new Azure.SignalR.ServiceNetworkAcl("exampleServiceNetworkAcl", new Azure.SignalR.ServiceNetworkAclArgs
        {
            SignalrServiceId = exampleService.Id,
            DefaultAction = "Deny",
            PublicNetwork = new Azure.SignalR.Inputs.ServiceNetworkAclPublicNetworkArgs
            {
                AllowedRequestTypes = 
                {
                    "ClientConnection",
                },
            },
            PrivateEndpoints = 
            {
                new Azure.SignalR.Inputs.ServiceNetworkAclPrivateEndpointArgs
                {
                    Id = exampleEndpoint.Id,
                    AllowedRequestTypes = 
                    {
                        "ServerConnection",
                    },
                },
            },
        });
    }

}

package main

import (
	"github.com/pulumi/pulumi-azure/sdk/v4/go/azure/core"
	"github.com/pulumi/pulumi-azure/sdk/v4/go/azure/network"
	"github.com/pulumi/pulumi-azure/sdk/v4/go/azure/privatelink"
	"github.com/pulumi/pulumi-azure/sdk/v4/go/azure/signalr"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		exampleResourceGroup, err := core.NewResourceGroup(ctx, "exampleResourceGroup", &core.ResourceGroupArgs{
			Location: pulumi.String("West Europe"),
		})
		if err != nil {
			return err
		}
		exampleService, err := signalr.NewService(ctx, "exampleService", &signalr.ServiceArgs{
			Location:          exampleResourceGroup.Location,
			ResourceGroupName: exampleResourceGroup.Name,
			Sku: &signalr.ServiceSkuArgs{
				Name:     pulumi.String("Standard_S1"),
				Capacity: pulumi.Int(1),
			},
		})
		if err != nil {
			return err
		}
		exampleVirtualNetwork, err := network.NewVirtualNetwork(ctx, "exampleVirtualNetwork", &network.VirtualNetworkArgs{
			ResourceGroupName: exampleResourceGroup.Name,
			Location:          exampleResourceGroup.Location,
			AddressSpaces: pulumi.StringArray{
				pulumi.String("10.5.0.0/16"),
			},
		})
		if err != nil {
			return err
		}
		exampleSubnet, err := network.NewSubnet(ctx, "exampleSubnet", &network.SubnetArgs{
			ResourceGroupName:  exampleResourceGroup.Name,
			VirtualNetworkName: exampleVirtualNetwork.Name,
			AddressPrefixes: pulumi.StringArray{
				pulumi.String("10.5.2.0/24"),
			},
			EnforcePrivateLinkEndpointNetworkPolicies: pulumi.Bool(true),
		})
		if err != nil {
			return err
		}
		exampleEndpoint, err := privatelink.NewEndpoint(ctx, "exampleEndpoint", &privatelink.EndpointArgs{
			ResourceGroupName: exampleResourceGroup.Name,
			Location:          exampleResourceGroup.Location,
			SubnetId:          exampleSubnet.ID(),
			PrivateServiceConnection: &privatelink.EndpointPrivateServiceConnectionArgs{
				Name:                        pulumi.String("psc-sig-test"),
				IsManualConnection:          pulumi.Bool(false),
				PrivateConnectionResourceId: exampleService.ID(),
				SubresourceNames: pulumi.StringArray{
					pulumi.String("signalr"),
				},
			},
		})
		if err != nil {
			return err
		}
		_, err = signalr.NewServiceNetworkAcl(ctx, "exampleServiceNetworkAcl", &signalr.ServiceNetworkAclArgs{
			SignalrServiceId: exampleService.ID(),
			DefaultAction:    pulumi.String("Deny"),
			PublicNetwork: &signalr.ServiceNetworkAclPublicNetworkArgs{
				AllowedRequestTypes: pulumi.StringArray{
					pulumi.String("ClientConnection"),
				},
			},
			PrivateEndpoints: signalr.ServiceNetworkAclPrivateEndpointArray{
				&signalr.ServiceNetworkAclPrivateEndpointArgs{
					Id: exampleEndpoint.ID(),
					AllowedRequestTypes: pulumi.StringArray{
						pulumi.String("ServerConnection"),
					},
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

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

const exampleResourceGroup = new azure.core.ResourceGroup("exampleResourceGroup", {location: "West Europe"});
const exampleService = new azure.signalr.Service("exampleService", {
    location: exampleResourceGroup.location,
    resourceGroupName: exampleResourceGroup.name,
    sku: {
        name: "Standard_S1",
        capacity: 1,
    },
});
const exampleVirtualNetwork = new azure.network.VirtualNetwork("exampleVirtualNetwork", {
    resourceGroupName: exampleResourceGroup.name,
    location: exampleResourceGroup.location,
    addressSpaces: ["10.5.0.0/16"],
});
const exampleSubnet = new azure.network.Subnet("exampleSubnet", {
    resourceGroupName: exampleResourceGroup.name,
    virtualNetworkName: exampleVirtualNetwork.name,
    addressPrefixes: ["10.5.2.0/24"],
    enforcePrivateLinkEndpointNetworkPolicies: true,
});
const exampleEndpoint = new azure.privatelink.Endpoint("exampleEndpoint", {
    resourceGroupName: exampleResourceGroup.name,
    location: exampleResourceGroup.location,
    subnetId: exampleSubnet.id,
    privateServiceConnection: {
        name: "psc-sig-test",
        isManualConnection: false,
        privateConnectionResourceId: exampleService.id,
        subresourceNames: ["signalr"],
    },
});
const exampleServiceNetworkAcl = new azure.signalr.ServiceNetworkAcl("exampleServiceNetworkAcl", {
    signalrServiceId: exampleService.id,
    defaultAction: "Deny",
    publicNetwork: {
        allowedRequestTypes: ["ClientConnection"],
    },
    privateEndpoints: [{
        id: exampleEndpoint.id,
        allowedRequestTypes: ["ServerConnection"],
    }],
});

import pulumi
import pulumi_azure as azure

example_resource_group = azure.core.ResourceGroup("exampleResourceGroup", location="West Europe")
example_service = azure.signalr.Service("exampleService",
    location=example_resource_group.location,
    resource_group_name=example_resource_group.name,
    sku=azure.signalr.ServiceSkuArgs(
        name="Standard_S1",
        capacity=1,
    ))
example_virtual_network = azure.network.VirtualNetwork("exampleVirtualNetwork",
    resource_group_name=example_resource_group.name,
    location=example_resource_group.location,
    address_spaces=["10.5.0.0/16"])
example_subnet = azure.network.Subnet("exampleSubnet",
    resource_group_name=example_resource_group.name,
    virtual_network_name=example_virtual_network.name,
    address_prefixes=["10.5.2.0/24"],
    enforce_private_link_endpoint_network_policies=True)
example_endpoint = azure.privatelink.Endpoint("exampleEndpoint",
    resource_group_name=example_resource_group.name,
    location=example_resource_group.location,
    subnet_id=example_subnet.id,
    private_service_connection=azure.privatelink.EndpointPrivateServiceConnectionArgs(
        name="psc-sig-test",
        is_manual_connection=False,
        private_connection_resource_id=example_service.id,
        subresource_names=["signalr"],
    ))
example_service_network_acl = azure.signalr.ServiceNetworkAcl("exampleServiceNetworkAcl",
    signalr_service_id=example_service.id,
    default_action="Deny",
    public_network=azure.signalr.ServiceNetworkAclPublicNetworkArgs(
        allowed_request_types=["ClientConnection"],
    ),
    private_endpoints=[azure.signalr.ServiceNetworkAclPrivateEndpointArgs(
        id=example_endpoint.id,
        allowed_request_types=["ServerConnection"],
    )])