azure-native.signalrservice.SignalR

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

return await Deployment.RunAsync(() => 
{
    var signalR = new AzureNative.SignalRService.SignalR("signalR", new()
    {
        Cors = new AzureNative.SignalRService.Inputs.SignalRCorsSettingsArgs
        {
            AllowedOrigins = new[]
            {
                "https://foo.com",
                "https://bar.com",
            },
        },
        DisableAadAuth = false,
        DisableLocalAuth = false,
        Features = new[]
        {
            new AzureNative.SignalRService.Inputs.SignalRFeatureArgs
            {
                Flag = AzureNative.SignalRService.FeatureFlags.ServiceMode,
                Properties = null,
                Value = "Serverless",
            },
            new AzureNative.SignalRService.Inputs.SignalRFeatureArgs
            {
                Flag = AzureNative.SignalRService.FeatureFlags.EnableConnectivityLogs,
                Properties = null,
                Value = "True",
            },
            new AzureNative.SignalRService.Inputs.SignalRFeatureArgs
            {
                Flag = AzureNative.SignalRService.FeatureFlags.EnableMessagingLogs,
                Properties = null,
                Value = "False",
            },
            new AzureNative.SignalRService.Inputs.SignalRFeatureArgs
            {
                Flag = AzureNative.SignalRService.FeatureFlags.EnableLiveTrace,
                Properties = null,
                Value = "False",
            },
        },
        Identity = new AzureNative.SignalRService.Inputs.ManagedIdentityArgs
        {
            Type = AzureNative.SignalRService.ManagedIdentityType.SystemAssigned,
        },
        Kind = AzureNative.SignalRService.ServiceKind.SignalR,
        LiveTraceConfiguration = new AzureNative.SignalRService.Inputs.LiveTraceConfigurationArgs
        {
            Categories = new[]
            {
                new AzureNative.SignalRService.Inputs.LiveTraceCategoryArgs
                {
                    Enabled = "true",
                    Name = "ConnectivityLogs",
                },
            },
            Enabled = "false",
        },
        Location = "eastus",
        NetworkACLs = new AzureNative.SignalRService.Inputs.SignalRNetworkACLsArgs
        {
            DefaultAction = AzureNative.SignalRService.ACLAction.Deny,
            PrivateEndpoints = new[]
            {
                new AzureNative.SignalRService.Inputs.PrivateEndpointACLArgs
                {
                    Allow = new[]
                    {
                        AzureNative.SignalRService.SignalRRequestType.ServerConnection,
                    },
                    Name = "mysignalrservice.1fa229cd-bf3f-47f0-8c49-afb36723997e",
                },
            },
            PublicNetwork = new AzureNative.SignalRService.Inputs.NetworkACLArgs
            {
                Allow = new[]
                {
                    AzureNative.SignalRService.SignalRRequestType.ClientConnection,
                },
            },
        },
        PublicNetworkAccess = "Enabled",
        ResourceGroupName = "myResourceGroup",
        ResourceName = "mySignalRService",
        Serverless = new AzureNative.SignalRService.Inputs.ServerlessSettingsArgs
        {
            ConnectionTimeoutInSeconds = 5,
        },
        Sku = new AzureNative.SignalRService.Inputs.ResourceSkuArgs
        {
            Capacity = 1,
            Name = "Premium_P1",
            Tier = AzureNative.SignalRService.SignalRSkuTier.Premium,
        },
        Tags = 
        {
            { "key1", "value1" },
        },
        Tls = new AzureNative.SignalRService.Inputs.SignalRTlsSettingsArgs
        {
            ClientCertEnabled = false,
        },
        Upstream = new AzureNative.SignalRService.Inputs.ServerlessUpstreamSettingsArgs
        {
            Templates = new[]
            {
                new AzureNative.SignalRService.Inputs.UpstreamTemplateArgs
                {
                    Auth = new AzureNative.SignalRService.Inputs.UpstreamAuthSettingsArgs
                    {
                        ManagedIdentity = new AzureNative.SignalRService.Inputs.ManagedIdentitySettingsArgs
                        {
                            Resource = "api://example",
                        },
                        Type = AzureNative.SignalRService.UpstreamAuthType.ManagedIdentity,
                    },
                    CategoryPattern = "*",
                    EventPattern = "connect,disconnect",
                    HubPattern = "*",
                    UrlTemplate = "https://example.com/chat/api/connect",
                },
            },
        },
    });

});

package main

import (
	signalrservice "github.com/pulumi/pulumi-azure-native-sdk/signalrservice/v2"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := signalrservice.NewSignalR(ctx, "signalR", &signalrservice.SignalRArgs{
			Cors: &signalrservice.SignalRCorsSettingsArgs{
				AllowedOrigins: pulumi.StringArray{
					pulumi.String("https://foo.com"),
					pulumi.String("https://bar.com"),
				},
			},
			DisableAadAuth:   pulumi.Bool(false),
			DisableLocalAuth: pulumi.Bool(false),
			Features: signalrservice.SignalRFeatureArray{
				&signalrservice.SignalRFeatureArgs{
					Flag:       pulumi.String(signalrservice.FeatureFlagsServiceMode),
					Properties: nil,
					Value:      pulumi.String("Serverless"),
				},
				&signalrservice.SignalRFeatureArgs{
					Flag:       pulumi.String(signalrservice.FeatureFlagsEnableConnectivityLogs),
					Properties: nil,
					Value:      pulumi.String("True"),
				},
				&signalrservice.SignalRFeatureArgs{
					Flag:       pulumi.String(signalrservice.FeatureFlagsEnableMessagingLogs),
					Properties: nil,
					Value:      pulumi.String("False"),
				},
				&signalrservice.SignalRFeatureArgs{
					Flag:       pulumi.String(signalrservice.FeatureFlagsEnableLiveTrace),
					Properties: nil,
					Value:      pulumi.String("False"),
				},
			},
			Identity: &signalrservice.ManagedIdentityArgs{
				Type: pulumi.String(signalrservice.ManagedIdentityTypeSystemAssigned),
			},
			Kind: pulumi.String(signalrservice.ServiceKindSignalR),
			LiveTraceConfiguration: &signalrservice.LiveTraceConfigurationArgs{
				Categories: signalrservice.LiveTraceCategoryArray{
					&signalrservice.LiveTraceCategoryArgs{
						Enabled: pulumi.String("true"),
						Name:    pulumi.String("ConnectivityLogs"),
					},
				},
				Enabled: pulumi.String("false"),
			},
			Location: pulumi.String("eastus"),
			NetworkACLs: &signalrservice.SignalRNetworkACLsArgs{
				DefaultAction: pulumi.String(signalrservice.ACLActionDeny),
				PrivateEndpoints: signalrservice.PrivateEndpointACLArray{
					&signalrservice.PrivateEndpointACLArgs{
						Allow: pulumi.StringArray{
							pulumi.String(signalrservice.SignalRRequestTypeServerConnection),
						},
						Name: pulumi.String("mysignalrservice.1fa229cd-bf3f-47f0-8c49-afb36723997e"),
					},
				},
				PublicNetwork: &signalrservice.NetworkACLArgs{
					Allow: pulumi.StringArray{
						pulumi.String(signalrservice.SignalRRequestTypeClientConnection),
					},
				},
			},
			PublicNetworkAccess: pulumi.String("Enabled"),
			ResourceGroupName:   pulumi.String("myResourceGroup"),
			ResourceName:        pulumi.String("mySignalRService"),
			Serverless: &signalrservice.ServerlessSettingsArgs{
				ConnectionTimeoutInSeconds: pulumi.Int(5),
			},
			Sku: &signalrservice.ResourceSkuArgs{
				Capacity: pulumi.Int(1),
				Name:     pulumi.String("Premium_P1"),
				Tier:     pulumi.String(signalrservice.SignalRSkuTierPremium),
			},
			Tags: pulumi.StringMap{
				"key1": pulumi.String("value1"),
			},
			Tls: &signalrservice.SignalRTlsSettingsArgs{
				ClientCertEnabled: pulumi.Bool(false),
			},
			Upstream: &signalrservice.ServerlessUpstreamSettingsArgs{
				Templates: signalrservice.UpstreamTemplateArray{
					&signalrservice.UpstreamTemplateArgs{
						Auth: &signalrservice.UpstreamAuthSettingsArgs{
							ManagedIdentity: &signalrservice.ManagedIdentitySettingsArgs{
								Resource: pulumi.String("api://example"),
							},
							Type: pulumi.String(signalrservice.UpstreamAuthTypeManagedIdentity),
						},
						CategoryPattern: pulumi.String("*"),
						EventPattern:    pulumi.String("connect,disconnect"),
						HubPattern:      pulumi.String("*"),
						UrlTemplate:     pulumi.String("https://example.com/chat/api/connect"),
					},
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.signalrservice.SignalR;
import com.pulumi.azurenative.signalrservice.SignalRArgs;
import com.pulumi.azurenative.signalrservice.inputs.SignalRCorsSettingsArgs;
import com.pulumi.azurenative.signalrservice.inputs.SignalRFeatureArgs;
import com.pulumi.azurenative.signalrservice.inputs.ManagedIdentityArgs;
import com.pulumi.azurenative.signalrservice.inputs.LiveTraceConfigurationArgs;
import com.pulumi.azurenative.signalrservice.inputs.SignalRNetworkACLsArgs;
import com.pulumi.azurenative.signalrservice.inputs.NetworkACLArgs;
import com.pulumi.azurenative.signalrservice.inputs.ServerlessSettingsArgs;
import com.pulumi.azurenative.signalrservice.inputs.ResourceSkuArgs;
import com.pulumi.azurenative.signalrservice.inputs.SignalRTlsSettingsArgs;
import com.pulumi.azurenative.signalrservice.inputs.ServerlessUpstreamSettingsArgs;
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 signalR = new SignalR("signalR", SignalRArgs.builder()
            .cors(SignalRCorsSettingsArgs.builder()
                .allowedOrigins(                
                    "https://foo.com",
                    "https://bar.com")
                .build())
            .disableAadAuth(false)
            .disableLocalAuth(false)
            .features(            
                SignalRFeatureArgs.builder()
                    .flag("ServiceMode")
                    .properties()
                    .value("Serverless")
                    .build(),
                SignalRFeatureArgs.builder()
                    .flag("EnableConnectivityLogs")
                    .properties()
                    .value("True")
                    .build(),
                SignalRFeatureArgs.builder()
                    .flag("EnableMessagingLogs")
                    .properties()
                    .value("False")
                    .build(),
                SignalRFeatureArgs.builder()
                    .flag("EnableLiveTrace")
                    .properties()
                    .value("False")
                    .build())
            .identity(ManagedIdentityArgs.builder()
                .type("SystemAssigned")
                .build())
            .kind("SignalR")
            .liveTraceConfiguration(LiveTraceConfigurationArgs.builder()
                .categories(LiveTraceCategoryArgs.builder()
                    .enabled("true")
                    .name("ConnectivityLogs")
                    .build())
                .enabled("false")
                .build())
            .location("eastus")
            .networkACLs(SignalRNetworkACLsArgs.builder()
                .defaultAction("Deny")
                .privateEndpoints(PrivateEndpointACLArgs.builder()
                    .allow("ServerConnection")
                    .name("mysignalrservice.1fa229cd-bf3f-47f0-8c49-afb36723997e")
                    .build())
                .publicNetwork(NetworkACLArgs.builder()
                    .allow("ClientConnection")
                    .build())
                .build())
            .publicNetworkAccess("Enabled")
            .resourceGroupName("myResourceGroup")
            .resourceName("mySignalRService")
            .serverless(ServerlessSettingsArgs.builder()
                .connectionTimeoutInSeconds(5)
                .build())
            .sku(ResourceSkuArgs.builder()
                .capacity(1)
                .name("Premium_P1")
                .tier("Premium")
                .build())
            .tags(Map.of("key1", "value1"))
            .tls(SignalRTlsSettingsArgs.builder()
                .clientCertEnabled(false)
                .build())
            .upstream(ServerlessUpstreamSettingsArgs.builder()
                .templates(UpstreamTemplateArgs.builder()
                    .auth(UpstreamAuthSettingsArgs.builder()
                        .managedIdentity(ManagedIdentitySettingsArgs.builder()
                            .resource("api://example")
                            .build())
                        .type("ManagedIdentity")
                        .build())
                    .categoryPattern("*")
                    .eventPattern("connect,disconnect")
                    .hubPattern("*")
                    .urlTemplate("https://example.com/chat/api/connect")
                    .build())
                .build())
            .build());

    }
}

import pulumi
import pulumi_azure_native as azure_native

signal_r = azure_native.signalrservice.SignalR("signalR",
    cors=azure_native.signalrservice.SignalRCorsSettingsArgs(
        allowed_origins=[
            "https://foo.com",
            "https://bar.com",
        ],
    ),
    disable_aad_auth=False,
    disable_local_auth=False,
    features=[
        azure_native.signalrservice.SignalRFeatureArgs(
            flag=azure_native.signalrservice.FeatureFlags.SERVICE_MODE,
            properties={},
            value="Serverless",
        ),
        azure_native.signalrservice.SignalRFeatureArgs(
            flag=azure_native.signalrservice.FeatureFlags.ENABLE_CONNECTIVITY_LOGS,
            properties={},
            value="True",
        ),
        azure_native.signalrservice.SignalRFeatureArgs(
            flag=azure_native.signalrservice.FeatureFlags.ENABLE_MESSAGING_LOGS,
            properties={},
            value="False",
        ),
        azure_native.signalrservice.SignalRFeatureArgs(
            flag=azure_native.signalrservice.FeatureFlags.ENABLE_LIVE_TRACE,
            properties={},
            value="False",
        ),
    ],
    identity=azure_native.signalrservice.ManagedIdentityArgs(
        type=azure_native.signalrservice.ManagedIdentityType.SYSTEM_ASSIGNED,
    ),
    kind=azure_native.signalrservice.ServiceKind.SIGNAL_R,
    live_trace_configuration=azure_native.signalrservice.LiveTraceConfigurationArgs(
        categories=[azure_native.signalrservice.LiveTraceCategoryArgs(
            enabled="true",
            name="ConnectivityLogs",
        )],
        enabled="false",
    ),
    location="eastus",
    network_acls=azure_native.signalrservice.SignalRNetworkACLsArgs(
        default_action=azure_native.signalrservice.ACLAction.DENY,
        private_endpoints=[azure_native.signalrservice.PrivateEndpointACLArgs(
            allow=[azure_native.signalrservice.SignalRRequestType.SERVER_CONNECTION],
            name="mysignalrservice.1fa229cd-bf3f-47f0-8c49-afb36723997e",
        )],
        public_network=azure_native.signalrservice.NetworkACLArgs(
            allow=[azure_native.signalrservice.SignalRRequestType.CLIENT_CONNECTION],
        ),
    ),
    public_network_access="Enabled",
    resource_group_name="myResourceGroup",
    resource_name_="mySignalRService",
    serverless=azure_native.signalrservice.ServerlessSettingsArgs(
        connection_timeout_in_seconds=5,
    ),
    sku=azure_native.signalrservice.ResourceSkuArgs(
        capacity=1,
        name="Premium_P1",
        tier=azure_native.signalrservice.SignalRSkuTier.PREMIUM,
    ),
    tags={
        "key1": "value1",
    },
    tls=azure_native.signalrservice.SignalRTlsSettingsArgs(
        client_cert_enabled=False,
    ),
    upstream=azure_native.signalrservice.ServerlessUpstreamSettingsArgs(
        templates=[azure_native.signalrservice.UpstreamTemplateArgs(
            auth=azure_native.signalrservice.UpstreamAuthSettingsArgs(
                managed_identity=azure_native.signalrservice.ManagedIdentitySettingsArgs(
                    resource="api://example",
                ),
                type=azure_native.signalrservice.UpstreamAuthType.MANAGED_IDENTITY,
            ),
            category_pattern="*",
            event_pattern="connect,disconnect",
            hub_pattern="*",
            url_template="https://example.com/chat/api/connect",
        )],
    ))

import * as pulumi from "@pulumi/pulumi";
import * as azure_native from "@pulumi/azure-native";

const signalR = new azure_native.signalrservice.SignalR("signalR", {
    cors: {
        allowedOrigins: [
            "https://foo.com",
            "https://bar.com",
        ],
    },
    disableAadAuth: false,
    disableLocalAuth: false,
    features: [
        {
            flag: azure_native.signalrservice.FeatureFlags.ServiceMode,
            properties: {},
            value: "Serverless",
        },
        {
            flag: azure_native.signalrservice.FeatureFlags.EnableConnectivityLogs,
            properties: {},
            value: "True",
        },
        {
            flag: azure_native.signalrservice.FeatureFlags.EnableMessagingLogs,
            properties: {},
            value: "False",
        },
        {
            flag: azure_native.signalrservice.FeatureFlags.EnableLiveTrace,
            properties: {},
            value: "False",
        },
    ],
    identity: {
        type: azure_native.signalrservice.ManagedIdentityType.SystemAssigned,
    },
    kind: azure_native.signalrservice.ServiceKind.SignalR,
    liveTraceConfiguration: {
        categories: [{
            enabled: "true",
            name: "ConnectivityLogs",
        }],
        enabled: "false",
    },
    location: "eastus",
    networkACLs: {
        defaultAction: azure_native.signalrservice.ACLAction.Deny,
        privateEndpoints: [{
            allow: [azure_native.signalrservice.SignalRRequestType.ServerConnection],
            name: "mysignalrservice.1fa229cd-bf3f-47f0-8c49-afb36723997e",
        }],
        publicNetwork: {
            allow: [azure_native.signalrservice.SignalRRequestType.ClientConnection],
        },
    },
    publicNetworkAccess: "Enabled",
    resourceGroupName: "myResourceGroup",
    resourceName: "mySignalRService",
    serverless: {
        connectionTimeoutInSeconds: 5,
    },
    sku: {
        capacity: 1,
        name: "Premium_P1",
        tier: azure_native.signalrservice.SignalRSkuTier.Premium,
    },
    tags: {
        key1: "value1",
    },
    tls: {
        clientCertEnabled: false,
    },
    upstream: {
        templates: [{
            auth: {
                managedIdentity: {
                    resource: "api://example",
                },
                type: azure_native.signalrservice.UpstreamAuthType.ManagedIdentity,
            },
            categoryPattern: "*",
            eventPattern: "connect,disconnect",
            hubPattern: "*",
            urlTemplate: "https://example.com/chat/api/connect",
        }],
    },
});

resources:
  signalR:
    type: azure-native:signalrservice:SignalR
    properties:
      cors:
        allowedOrigins:
          - https://foo.com
          - https://bar.com
      disableAadAuth: false
      disableLocalAuth: false
      features:
        - flag: ServiceMode
          properties: {}
          value: Serverless
        - flag: EnableConnectivityLogs
          properties: {}
          value: True
        - flag: EnableMessagingLogs
          properties: {}
          value: False
        - flag: EnableLiveTrace
          properties: {}
          value: False
      identity:
        type: SystemAssigned
      kind: SignalR
      liveTraceConfiguration:
        categories:
          - enabled: 'true'
            name: ConnectivityLogs
        enabled: 'false'
      location: eastus
      networkACLs:
        defaultAction: Deny
        privateEndpoints:
          - allow:
              - ServerConnection
            name: mysignalrservice.1fa229cd-bf3f-47f0-8c49-afb36723997e
        publicNetwork:
          allow:
            - ClientConnection
      publicNetworkAccess: Enabled
      resourceGroupName: myResourceGroup
      resourceName: mySignalRService
      serverless:
        connectionTimeoutInSeconds: 5
      sku:
        capacity: 1
        name: Premium_P1
        tier: Premium
      tags:
        key1: value1
      tls:
        clientCertEnabled: false
      upstream:
        templates:
          - auth:
              managedIdentity:
                resource: api://example
              type: ManagedIdentity
            categoryPattern: '*'
            eventPattern: connect,disconnect
            hubPattern: '*'
            urlTemplate: https://example.com/chat/api/connect