azure.streamanalytics.OutputTable

using Pulumi;
using Azure = Pulumi.Azure;

class MyStack : Stack
{
    public MyStack()
    {
        var exampleResourceGroup = Output.Create(Azure.Core.GetResourceGroup.InvokeAsync(new Azure.Core.GetResourceGroupArgs
        {
            Name = "example-resources",
        }));
        var exampleJob = Output.Create(Azure.StreamAnalytics.GetJob.InvokeAsync(new Azure.StreamAnalytics.GetJobArgs
        {
            Name = "example-job",
            ResourceGroupName = azurerm_resource_group.Example.Name,
        }));
        var exampleAccount = new Azure.Storage.Account("exampleAccount", new Azure.Storage.AccountArgs
        {
            ResourceGroupName = exampleResourceGroup.Apply(exampleResourceGroup => exampleResourceGroup.Name),
            Location = exampleResourceGroup.Apply(exampleResourceGroup => exampleResourceGroup.Location),
            AccountTier = "Standard",
            AccountReplicationType = "LRS",
        });
        var exampleTable = new Azure.Storage.Table("exampleTable", new Azure.Storage.TableArgs
        {
            StorageAccountName = exampleAccount.Name,
        });
        var exampleOutputTable = new Azure.StreamAnalytics.OutputTable("exampleOutputTable", new Azure.StreamAnalytics.OutputTableArgs
        {
            StreamAnalyticsJobName = azurerm_stream_analytics_job.Example.Name,
            ResourceGroupName = azurerm_stream_analytics_job.Example.Resource_group_name,
            StorageAccountName = exampleAccount.Name,
            StorageAccountKey = exampleAccount.PrimaryAccessKey,
            Table = exampleTable.Name,
            PartitionKey = "foo",
            RowKey = "bar",
            BatchSize = 100,
        });
    }

}

package main

import (
	"github.com/pulumi/pulumi-azure/sdk/v4/go/azure/core"
	"github.com/pulumi/pulumi-azure/sdk/v4/go/azure/storage"
	"github.com/pulumi/pulumi-azure/sdk/v4/go/azure/streamanalytics"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		exampleResourceGroup, err := core.LookupResourceGroup(ctx, &core.LookupResourceGroupArgs{
			Name: "example-resources",
		}, nil)
		if err != nil {
			return err
		}
		_, err = streamanalytics.LookupJob(ctx, &streamanalytics.LookupJobArgs{
			Name:              "example-job",
			ResourceGroupName: azurerm_resource_group.Example.Name,
		}, nil)
		if err != nil {
			return err
		}
		exampleAccount, err := storage.NewAccount(ctx, "exampleAccount", &storage.AccountArgs{
			ResourceGroupName:      pulumi.String(exampleResourceGroup.Name),
			Location:               pulumi.String(exampleResourceGroup.Location),
			AccountTier:            pulumi.String("Standard"),
			AccountReplicationType: pulumi.String("LRS"),
		})
		if err != nil {
			return err
		}
		exampleTable, err := storage.NewTable(ctx, "exampleTable", &storage.TableArgs{
			StorageAccountName: exampleAccount.Name,
		})
		if err != nil {
			return err
		}
		_, err = streamanalytics.NewOutputTable(ctx, "exampleOutputTable", &streamanalytics.OutputTableArgs{
			StreamAnalyticsJobName: pulumi.Any(azurerm_stream_analytics_job.Example.Name),
			ResourceGroupName:      pulumi.Any(azurerm_stream_analytics_job.Example.Resource_group_name),
			StorageAccountName:     exampleAccount.Name,
			StorageAccountKey:      exampleAccount.PrimaryAccessKey,
			Table:                  exampleTable.Name,
			PartitionKey:           pulumi.String("foo"),
			RowKey:                 pulumi.String("bar"),
			BatchSize:              pulumi.Int(100),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

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

const exampleResourceGroup = azure.core.getResourceGroup({
    name: "example-resources",
});
const exampleJob = azure.streamanalytics.getJob({
    name: "example-job",
    resourceGroupName: azurerm_resource_group.example.name,
});
const exampleAccount = new azure.storage.Account("exampleAccount", {
    resourceGroupName: exampleResourceGroup.then(exampleResourceGroup => exampleResourceGroup.name),
    location: exampleResourceGroup.then(exampleResourceGroup => exampleResourceGroup.location),
    accountTier: "Standard",
    accountReplicationType: "LRS",
});
const exampleTable = new azure.storage.Table("exampleTable", {storageAccountName: exampleAccount.name});
const exampleOutputTable = new azure.streamanalytics.OutputTable("exampleOutputTable", {
    streamAnalyticsJobName: azurerm_stream_analytics_job.example.name,
    resourceGroupName: azurerm_stream_analytics_job.example.resource_group_name,
    storageAccountName: exampleAccount.name,
    storageAccountKey: exampleAccount.primaryAccessKey,
    table: exampleTable.name,
    partitionKey: "foo",
    rowKey: "bar",
    batchSize: 100,
});

import pulumi
import pulumi_azure as azure

example_resource_group = azure.core.get_resource_group(name="example-resources")
example_job = azure.streamanalytics.get_job(name="example-job",
    resource_group_name=azurerm_resource_group["example"]["name"])
example_account = azure.storage.Account("exampleAccount",
    resource_group_name=example_resource_group.name,
    location=example_resource_group.location,
    account_tier="Standard",
    account_replication_type="LRS")
example_table = azure.storage.Table("exampleTable", storage_account_name=example_account.name)
example_output_table = azure.streamanalytics.OutputTable("exampleOutputTable",
    stream_analytics_job_name=azurerm_stream_analytics_job["example"]["name"],
    resource_group_name=azurerm_stream_analytics_job["example"]["resource_group_name"],
    storage_account_name=example_account.name,
    storage_account_key=example_account.primary_access_key,
    table=example_table.name,
    partition_key="foo",
    row_key="bar",
    batch_size=100)