azure.datashare.DatasetDataLakeGen1

using Pulumi;
using Azure = Pulumi.Azure;
using AzureAD = Pulumi.AzureAD;

class MyStack : Stack
{
    public MyStack()
    {
        var exampleResourceGroup = new Azure.Core.ResourceGroup("exampleResourceGroup", new Azure.Core.ResourceGroupArgs
        {
            Location = "West Europe",
        });
        var exampleAccount = new Azure.DataShare.Account("exampleAccount", new Azure.DataShare.AccountArgs
        {
            Location = exampleResourceGroup.Location,
            ResourceGroupName = exampleResourceGroup.Name,
            Identity = new Azure.DataShare.Inputs.AccountIdentityArgs
            {
                Type = "SystemAssigned",
            },
        });
        var exampleShare = new Azure.DataShare.Share("exampleShare", new Azure.DataShare.ShareArgs
        {
            AccountId = exampleAccount.Id,
            Kind = "CopyBased",
        });
        var exampleStore = new Azure.DataLake.Store("exampleStore", new Azure.DataLake.StoreArgs
        {
            ResourceGroupName = exampleResourceGroup.Name,
            Location = exampleResourceGroup.Location,
            FirewallState = "Disabled",
        });
        var exampleStoreFile = new Azure.DataLake.StoreFile("exampleStoreFile", new Azure.DataLake.StoreFileArgs
        {
            AccountName = exampleStore.Name,
            LocalFilePath = "./example/myfile.txt",
            RemoteFilePath = "/example/myfile.txt",
        });
        var exampleServicePrincipal = AzureAD.GetServicePrincipal.Invoke(new AzureAD.GetServicePrincipalInvokeArgs
        {
            DisplayName = exampleAccount.Name,
        });
        var exampleAssignment = new Azure.Authorization.Assignment("exampleAssignment", new Azure.Authorization.AssignmentArgs
        {
            Scope = exampleStore.Id,
            RoleDefinitionName = "Owner",
            PrincipalId = exampleServicePrincipal.Apply(exampleServicePrincipal => exampleServicePrincipal.ObjectId),
        });
        var exampleDatasetDataLakeGen1 = new Azure.DataShare.DatasetDataLakeGen1("exampleDatasetDataLakeGen1", new Azure.DataShare.DatasetDataLakeGen1Args
        {
            DataShareId = exampleShare.Id,
            DataLakeStoreId = exampleStore.Id,
            FileName = "myfile.txt",
            FolderPath = "example",
        }, new CustomResourceOptions
        {
            DependsOn = 
            {
                exampleAssignment,
            },
        });
    }

}

package main

import (
	"github.com/pulumi/pulumi-azure/sdk/v4/go/azure/authorization"
	"github.com/pulumi/pulumi-azure/sdk/v4/go/azure/core"
	"github.com/pulumi/pulumi-azure/sdk/v4/go/azure/datalake"
	"github.com/pulumi/pulumi-azure/sdk/v4/go/azure/datashare"
	"github.com/pulumi/pulumi-azuread/sdk/v4/go/azuread"
	"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
		}
		exampleAccount, err := datashare.NewAccount(ctx, "exampleAccount", &datashare.AccountArgs{
			Location:          exampleResourceGroup.Location,
			ResourceGroupName: exampleResourceGroup.Name,
			Identity: &datashare.AccountIdentityArgs{
				Type: pulumi.String("SystemAssigned"),
			},
		})
		if err != nil {
			return err
		}
		exampleShare, err := datashare.NewShare(ctx, "exampleShare", &datashare.ShareArgs{
			AccountId: exampleAccount.ID(),
			Kind:      pulumi.String("CopyBased"),
		})
		if err != nil {
			return err
		}
		exampleStore, err := datalake.NewStore(ctx, "exampleStore", &datalake.StoreArgs{
			ResourceGroupName: exampleResourceGroup.Name,
			Location:          exampleResourceGroup.Location,
			FirewallState:     pulumi.String("Disabled"),
		})
		if err != nil {
			return err
		}
		_, err = datalake.NewStoreFile(ctx, "exampleStoreFile", &datalake.StoreFileArgs{
			AccountName:    exampleStore.Name,
			LocalFilePath:  pulumi.String("./example/myfile.txt"),
			RemoteFilePath: pulumi.String("/example/myfile.txt"),
		})
		if err != nil {
			return err
		}
		exampleServicePrincipal := azuread.LookupServicePrincipalOutput(ctx, GetServicePrincipalOutputArgs{
			DisplayName: exampleAccount.Name,
		}, nil)
		exampleAssignment, err := authorization.NewAssignment(ctx, "exampleAssignment", &authorization.AssignmentArgs{
			Scope:              exampleStore.ID(),
			RoleDefinitionName: pulumi.String("Owner"),
			PrincipalId: exampleServicePrincipal.ApplyT(func(exampleServicePrincipal GetServicePrincipalResult) (string, error) {
				return exampleServicePrincipal.ObjectId, nil
			}).(pulumi.StringOutput),
		})
		if err != nil {
			return err
		}
		_, err = datashare.NewDatasetDataLakeGen1(ctx, "exampleDatasetDataLakeGen1", &datashare.DatasetDataLakeGen1Args{
			DataShareId:     exampleShare.ID(),
			DataLakeStoreId: exampleStore.ID(),
			FileName:        pulumi.String("myfile.txt"),
			FolderPath:      pulumi.String("example"),
		}, pulumi.DependsOn([]pulumi.Resource{
			exampleAssignment,
		}))
		if err != nil {
			return err
		}
		return nil
	})
}

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

const exampleResourceGroup = new azure.core.ResourceGroup("exampleResourceGroup", {location: "West Europe"});
const exampleAccount = new azure.datashare.Account("exampleAccount", {
    location: exampleResourceGroup.location,
    resourceGroupName: exampleResourceGroup.name,
    identity: {
        type: "SystemAssigned",
    },
});
const exampleShare = new azure.datashare.Share("exampleShare", {
    accountId: exampleAccount.id,
    kind: "CopyBased",
});
const exampleStore = new azure.datalake.Store("exampleStore", {
    resourceGroupName: exampleResourceGroup.name,
    location: exampleResourceGroup.location,
    firewallState: "Disabled",
});
const exampleStoreFile = new azure.datalake.StoreFile("exampleStoreFile", {
    accountName: exampleStore.name,
    localFilePath: "./example/myfile.txt",
    remoteFilePath: "/example/myfile.txt",
});
const exampleServicePrincipal = azuread.getServicePrincipalOutput({
    displayName: exampleAccount.name,
});
const exampleAssignment = new azure.authorization.Assignment("exampleAssignment", {
    scope: exampleStore.id,
    roleDefinitionName: "Owner",
    principalId: exampleServicePrincipal.apply(exampleServicePrincipal => exampleServicePrincipal.objectId),
});
const exampleDatasetDataLakeGen1 = new azure.datashare.DatasetDataLakeGen1("exampleDatasetDataLakeGen1", {
    dataShareId: exampleShare.id,
    dataLakeStoreId: exampleStore.id,
    fileName: "myfile.txt",
    folderPath: "example",
}, {
    dependsOn: [exampleAssignment],
});

import pulumi
import pulumi_azure as azure
import pulumi_azuread as azuread

example_resource_group = azure.core.ResourceGroup("exampleResourceGroup", location="West Europe")
example_account = azure.datashare.Account("exampleAccount",
    location=example_resource_group.location,
    resource_group_name=example_resource_group.name,
    identity=azure.datashare.AccountIdentityArgs(
        type="SystemAssigned",
    ))
example_share = azure.datashare.Share("exampleShare",
    account_id=example_account.id,
    kind="CopyBased")
example_store = azure.datalake.Store("exampleStore",
    resource_group_name=example_resource_group.name,
    location=example_resource_group.location,
    firewall_state="Disabled")
example_store_file = azure.datalake.StoreFile("exampleStoreFile",
    account_name=example_store.name,
    local_file_path="./example/myfile.txt",
    remote_file_path="/example/myfile.txt")
example_service_principal = azuread.get_service_principal_output(display_name=example_account.name)
example_assignment = azure.authorization.Assignment("exampleAssignment",
    scope=example_store.id,
    role_definition_name="Owner",
    principal_id=example_service_principal.object_id)
example_dataset_data_lake_gen1 = azure.datashare.DatasetDataLakeGen1("exampleDatasetDataLakeGen1",
    data_share_id=example_share.id,
    data_lake_store_id=example_store.id,
    file_name="myfile.txt",
    folder_path="example",
    opts=pulumi.ResourceOptions(depends_on=[example_assignment]))