azure.kusto.EventGridDataConnection

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 exampleCluster = new Azure.Kusto.Cluster("exampleCluster", new Azure.Kusto.ClusterArgs
        {
            Location = exampleResourceGroup.Location,
            ResourceGroupName = exampleResourceGroup.Name,
            Sku = new Azure.Kusto.Inputs.ClusterSkuArgs
            {
                Name = "Standard_D13_v2",
                Capacity = 2,
            },
        });
        var exampleDatabase = new Azure.Kusto.Database("exampleDatabase", new Azure.Kusto.DatabaseArgs
        {
            ResourceGroupName = exampleResourceGroup.Name,
            Location = exampleResourceGroup.Location,
            ClusterName = exampleCluster.Name,
            HotCachePeriod = "P7D",
            SoftDeletePeriod = "P31D",
        });
        var exampleAccount = new Azure.Storage.Account("exampleAccount", new Azure.Storage.AccountArgs
        {
            ResourceGroupName = exampleResourceGroup.Name,
            Location = exampleResourceGroup.Location,
            AccountTier = "Standard",
            AccountReplicationType = "GRS",
        });
        var testEventHubNamespace = new Azure.EventHub.EventHubNamespace("testEventHubNamespace", new Azure.EventHub.EventHubNamespaceArgs
        {
            Location = exampleResourceGroup.Location,
            ResourceGroupName = exampleResourceGroup.Name,
            Sku = "Standard",
        });
        var testEventHub = new Azure.EventHub.EventHub("testEventHub", new Azure.EventHub.EventHubArgs
        {
            NamespaceName = azurerm_eventhub_namespace.Example.Name,
            ResourceGroupName = exampleResourceGroup.Name,
            PartitionCount = 1,
            MessageRetention = 1,
        });
        var exampleConsumerGroup = new Azure.EventHub.ConsumerGroup("exampleConsumerGroup", new Azure.EventHub.ConsumerGroupArgs
        {
            NamespaceName = azurerm_eventhub_namespace.Example.Name,
            EventhubName = azurerm_eventhub.Example.Name,
            ResourceGroupName = exampleResourceGroup.Name,
        });
        var exampleEventSubscription = new Azure.EventGrid.EventSubscription("exampleEventSubscription", new Azure.EventGrid.EventSubscriptionArgs
        {
            Scope = exampleAccount.Id,
            EventhubEndpointId = azurerm_eventhub.Example.Id,
            EventDeliverySchema = "EventGridSchema",
            IncludedEventTypes = 
            {
                "Microsoft.Storage.BlobCreated",
                "Microsoft.Storage.BlobRenamed",
            },
            RetryPolicy = new Azure.EventGrid.Inputs.EventSubscriptionRetryPolicyArgs
            {
                EventTimeToLive = 144,
                MaxDeliveryAttempts = 10,
            },
        });
        var exampleEventGridDataConnection = new Azure.Kusto.EventGridDataConnection("exampleEventGridDataConnection", new Azure.Kusto.EventGridDataConnectionArgs
        {
            ResourceGroupName = exampleResourceGroup.Name,
            Location = exampleResourceGroup.Location,
            ClusterName = exampleCluster.Name,
            DatabaseName = exampleDatabase.Name,
            StorageAccountId = exampleAccount.Id,
            EventhubId = azurerm_eventhub.Example.Id,
            EventhubConsumerGroupName = exampleConsumerGroup.Name,
            TableName = "my-table",
            MappingRuleName = "my-table-mapping",
            DataFormat = "JSON",
        }, new CustomResourceOptions
        {
            DependsOn = 
            {
                exampleEventSubscription,
            },
        });
    }

}

package main

import (
	"github.com/pulumi/pulumi-azure/sdk/v4/go/azure/core"
	"github.com/pulumi/pulumi-azure/sdk/v4/go/azure/eventgrid"
	"github.com/pulumi/pulumi-azure/sdk/v4/go/azure/eventhub"
	"github.com/pulumi/pulumi-azure/sdk/v4/go/azure/kusto"
	"github.com/pulumi/pulumi-azure/sdk/v4/go/azure/storage"
	"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
		}
		exampleCluster, err := kusto.NewCluster(ctx, "exampleCluster", &kusto.ClusterArgs{
			Location:          exampleResourceGroup.Location,
			ResourceGroupName: exampleResourceGroup.Name,
			Sku: &kusto.ClusterSkuArgs{
				Name:     pulumi.String("Standard_D13_v2"),
				Capacity: pulumi.Int(2),
			},
		})
		if err != nil {
			return err
		}
		exampleDatabase, err := kusto.NewDatabase(ctx, "exampleDatabase", &kusto.DatabaseArgs{
			ResourceGroupName: exampleResourceGroup.Name,
			Location:          exampleResourceGroup.Location,
			ClusterName:       exampleCluster.Name,
			HotCachePeriod:    pulumi.String("P7D"),
			SoftDeletePeriod:  pulumi.String("P31D"),
		})
		if err != nil {
			return err
		}
		exampleAccount, err := storage.NewAccount(ctx, "exampleAccount", &storage.AccountArgs{
			ResourceGroupName:      exampleResourceGroup.Name,
			Location:               exampleResourceGroup.Location,
			AccountTier:            pulumi.String("Standard"),
			AccountReplicationType: pulumi.String("GRS"),
		})
		if err != nil {
			return err
		}
		_, err = eventhub.NewEventHubNamespace(ctx, "testEventHubNamespace", &eventhub.EventHubNamespaceArgs{
			Location:          exampleResourceGroup.Location,
			ResourceGroupName: exampleResourceGroup.Name,
			Sku:               pulumi.String("Standard"),
		})
		if err != nil {
			return err
		}
		_, err = eventhub.NewEventHub(ctx, "testEventHub", &eventhub.EventHubArgs{
			NamespaceName:     pulumi.Any(azurerm_eventhub_namespace.Example.Name),
			ResourceGroupName: exampleResourceGroup.Name,
			PartitionCount:    pulumi.Int(1),
			MessageRetention:  pulumi.Int(1),
		})
		if err != nil {
			return err
		}
		exampleConsumerGroup, err := eventhub.NewConsumerGroup(ctx, "exampleConsumerGroup", &eventhub.ConsumerGroupArgs{
			NamespaceName:     pulumi.Any(azurerm_eventhub_namespace.Example.Name),
			EventhubName:      pulumi.Any(azurerm_eventhub.Example.Name),
			ResourceGroupName: exampleResourceGroup.Name,
		})
		if err != nil {
			return err
		}
		exampleEventSubscription, err := eventgrid.NewEventSubscription(ctx, "exampleEventSubscription", &eventgrid.EventSubscriptionArgs{
			Scope:               exampleAccount.ID(),
			EventhubEndpointId:  pulumi.Any(azurerm_eventhub.Example.Id),
			EventDeliverySchema: pulumi.String("EventGridSchema"),
			IncludedEventTypes: pulumi.StringArray{
				pulumi.String("Microsoft.Storage.BlobCreated"),
				pulumi.String("Microsoft.Storage.BlobRenamed"),
			},
			RetryPolicy: &eventgrid.EventSubscriptionRetryPolicyArgs{
				EventTimeToLive:     pulumi.Int(144),
				MaxDeliveryAttempts: pulumi.Int(10),
			},
		})
		if err != nil {
			return err
		}
		_, err = kusto.NewEventGridDataConnection(ctx, "exampleEventGridDataConnection", &kusto.EventGridDataConnectionArgs{
			ResourceGroupName:         exampleResourceGroup.Name,
			Location:                  exampleResourceGroup.Location,
			ClusterName:               exampleCluster.Name,
			DatabaseName:              exampleDatabase.Name,
			StorageAccountId:          exampleAccount.ID(),
			EventhubId:                pulumi.Any(azurerm_eventhub.Example.Id),
			EventhubConsumerGroupName: exampleConsumerGroup.Name,
			TableName:                 pulumi.String("my-table"),
			MappingRuleName:           pulumi.String("my-table-mapping"),
			DataFormat:                pulumi.String("JSON"),
		}, pulumi.DependsOn([]pulumi.Resource{
			exampleEventSubscription,
		}))
		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 exampleCluster = new azure.kusto.Cluster("exampleCluster", {
    location: exampleResourceGroup.location,
    resourceGroupName: exampleResourceGroup.name,
    sku: {
        name: "Standard_D13_v2",
        capacity: 2,
    },
});
const exampleDatabase = new azure.kusto.Database("exampleDatabase", {
    resourceGroupName: exampleResourceGroup.name,
    location: exampleResourceGroup.location,
    clusterName: exampleCluster.name,
    hotCachePeriod: "P7D",
    softDeletePeriod: "P31D",
});
const exampleAccount = new azure.storage.Account("exampleAccount", {
    resourceGroupName: exampleResourceGroup.name,
    location: exampleResourceGroup.location,
    accountTier: "Standard",
    accountReplicationType: "GRS",
});
const testEventHubNamespace = new azure.eventhub.EventHubNamespace("testEventHubNamespace", {
    location: exampleResourceGroup.location,
    resourceGroupName: exampleResourceGroup.name,
    sku: "Standard",
});
const testEventHub = new azure.eventhub.EventHub("testEventHub", {
    namespaceName: azurerm_eventhub_namespace.example.name,
    resourceGroupName: exampleResourceGroup.name,
    partitionCount: 1,
    messageRetention: 1,
});
const exampleConsumerGroup = new azure.eventhub.ConsumerGroup("exampleConsumerGroup", {
    namespaceName: azurerm_eventhub_namespace.example.name,
    eventhubName: azurerm_eventhub.example.name,
    resourceGroupName: exampleResourceGroup.name,
});
const exampleEventSubscription = new azure.eventgrid.EventSubscription("exampleEventSubscription", {
    scope: exampleAccount.id,
    eventhubEndpointId: azurerm_eventhub.example.id,
    eventDeliverySchema: "EventGridSchema",
    includedEventTypes: [
        "Microsoft.Storage.BlobCreated",
        "Microsoft.Storage.BlobRenamed",
    ],
    retryPolicy: {
        eventTimeToLive: 144,
        maxDeliveryAttempts: 10,
    },
});
const exampleEventGridDataConnection = new azure.kusto.EventGridDataConnection("exampleEventGridDataConnection", {
    resourceGroupName: exampleResourceGroup.name,
    location: exampleResourceGroup.location,
    clusterName: exampleCluster.name,
    databaseName: exampleDatabase.name,
    storageAccountId: exampleAccount.id,
    eventhubId: azurerm_eventhub.example.id,
    eventhubConsumerGroupName: exampleConsumerGroup.name,
    tableName: "my-table",
    mappingRuleName: "my-table-mapping",
    dataFormat: "JSON",
}, {
    dependsOn: [exampleEventSubscription],
});

import pulumi
import pulumi_azure as azure

example_resource_group = azure.core.ResourceGroup("exampleResourceGroup", location="West Europe")
example_cluster = azure.kusto.Cluster("exampleCluster",
    location=example_resource_group.location,
    resource_group_name=example_resource_group.name,
    sku=azure.kusto.ClusterSkuArgs(
        name="Standard_D13_v2",
        capacity=2,
    ))
example_database = azure.kusto.Database("exampleDatabase",
    resource_group_name=example_resource_group.name,
    location=example_resource_group.location,
    cluster_name=example_cluster.name,
    hot_cache_period="P7D",
    soft_delete_period="P31D")
example_account = azure.storage.Account("exampleAccount",
    resource_group_name=example_resource_group.name,
    location=example_resource_group.location,
    account_tier="Standard",
    account_replication_type="GRS")
test_event_hub_namespace = azure.eventhub.EventHubNamespace("testEventHubNamespace",
    location=example_resource_group.location,
    resource_group_name=example_resource_group.name,
    sku="Standard")
test_event_hub = azure.eventhub.EventHub("testEventHub",
    namespace_name=azurerm_eventhub_namespace["example"]["name"],
    resource_group_name=example_resource_group.name,
    partition_count=1,
    message_retention=1)
example_consumer_group = azure.eventhub.ConsumerGroup("exampleConsumerGroup",
    namespace_name=azurerm_eventhub_namespace["example"]["name"],
    eventhub_name=azurerm_eventhub["example"]["name"],
    resource_group_name=example_resource_group.name)
example_event_subscription = azure.eventgrid.EventSubscription("exampleEventSubscription",
    scope=example_account.id,
    eventhub_endpoint_id=azurerm_eventhub["example"]["id"],
    event_delivery_schema="EventGridSchema",
    included_event_types=[
        "Microsoft.Storage.BlobCreated",
        "Microsoft.Storage.BlobRenamed",
    ],
    retry_policy=azure.eventgrid.EventSubscriptionRetryPolicyArgs(
        event_time_to_live=144,
        max_delivery_attempts=10,
    ))
example_event_grid_data_connection = azure.kusto.EventGridDataConnection("exampleEventGridDataConnection",
    resource_group_name=example_resource_group.name,
    location=example_resource_group.location,
    cluster_name=example_cluster.name,
    database_name=example_database.name,
    storage_account_id=example_account.id,
    eventhub_id=azurerm_eventhub["example"]["id"],
    eventhub_consumer_group_name=example_consumer_group.name,
    table_name="my-table",
    mapping_rule_name="my-table-mapping",
    data_format="JSON",
    opts=pulumi.ResourceOptions(depends_on=[example_event_subscription]))