azure.streamanalytics.OutputBlob

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 exampleContainer = new Azure.Storage.Container("exampleContainer", new Azure.Storage.ContainerArgs
        {
            StorageAccountName = exampleAccount.Name,
            ContainerAccessType = "private",
        });
        var exampleOutputBlob = new Azure.StreamAnalytics.OutputBlob("exampleOutputBlob", new Azure.StreamAnalytics.OutputBlobArgs
        {
            StreamAnalyticsJobName = exampleJob.Apply(exampleJob => exampleJob.Name),
            ResourceGroupName = exampleJob.Apply(exampleJob => exampleJob.ResourceGroupName),
            StorageAccountName = exampleAccount.Name,
            StorageAccountKey = exampleAccount.PrimaryAccessKey,
            StorageContainerName = exampleContainer.Name,
            PathPattern = "some-pattern",
            DateFormat = "yyyy-MM-dd",
            TimeFormat = "HH",
            Serialization = new Azure.StreamAnalytics.Inputs.OutputBlobSerializationArgs
            {
                Type = "Csv",
                Encoding = "UTF8",
                FieldDelimiter = ",",
            },
        });
    }

}

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
		}
		exampleJob, 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
		}
		exampleContainer, err := storage.NewContainer(ctx, "exampleContainer", &storage.ContainerArgs{
			StorageAccountName:  exampleAccount.Name,
			ContainerAccessType: pulumi.String("private"),
		})
		if err != nil {
			return err
		}
		_, err = streamanalytics.NewOutputBlob(ctx, "exampleOutputBlob", &streamanalytics.OutputBlobArgs{
			StreamAnalyticsJobName: pulumi.String(exampleJob.Name),
			ResourceGroupName:      pulumi.String(exampleJob.ResourceGroupName),
			StorageAccountName:     exampleAccount.Name,
			StorageAccountKey:      exampleAccount.PrimaryAccessKey,
			StorageContainerName:   exampleContainer.Name,
			PathPattern:            pulumi.String("some-pattern"),
			DateFormat:             pulumi.String("yyyy-MM-dd"),
			TimeFormat:             pulumi.String("HH"),
			Serialization: &streamanalytics.OutputBlobSerializationArgs{
				Type:           pulumi.String("Csv"),
				Encoding:       pulumi.String("UTF8"),
				FieldDelimiter: pulumi.String(","),
			},
		})
		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 exampleContainer = new azure.storage.Container("exampleContainer", {
    storageAccountName: exampleAccount.name,
    containerAccessType: "private",
});
const exampleOutputBlob = new azure.streamanalytics.OutputBlob("exampleOutputBlob", {
    streamAnalyticsJobName: exampleJob.then(exampleJob => exampleJob.name),
    resourceGroupName: exampleJob.then(exampleJob => exampleJob.resourceGroupName),
    storageAccountName: exampleAccount.name,
    storageAccountKey: exampleAccount.primaryAccessKey,
    storageContainerName: exampleContainer.name,
    pathPattern: "some-pattern",
    dateFormat: "yyyy-MM-dd",
    timeFormat: "HH",
    serialization: {
        type: "Csv",
        encoding: "UTF8",
        fieldDelimiter: ",",
    },
});

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_container = azure.storage.Container("exampleContainer",
    storage_account_name=example_account.name,
    container_access_type="private")
example_output_blob = azure.streamanalytics.OutputBlob("exampleOutputBlob",
    stream_analytics_job_name=example_job.name,
    resource_group_name=example_job.resource_group_name,
    storage_account_name=example_account.name,
    storage_account_key=example_account.primary_access_key,
    storage_container_name=example_container.name,
    path_pattern="some-pattern",
    date_format="yyyy-MM-dd",
    time_format="HH",
    serialization=azure.streamanalytics.OutputBlobSerializationArgs(
        type="Csv",
        encoding="UTF8",
        field_delimiter=",",
    ))