azure.datafactory.FlowletDataFlow

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

return await Deployment.RunAsync(() => 
{
    var exampleResourceGroup = new Azure.Core.ResourceGroup("exampleResourceGroup", new()
    {
        Location = "West Europe",
    });

    var exampleAccount = new Azure.Storage.Account("exampleAccount", new()
    {
        Location = exampleResourceGroup.Location,
        ResourceGroupName = exampleResourceGroup.Name,
        AccountTier = "Standard",
        AccountReplicationType = "LRS",
    });

    var exampleFactory = new Azure.DataFactory.Factory("exampleFactory", new()
    {
        Location = exampleResourceGroup.Location,
        ResourceGroupName = exampleResourceGroup.Name,
    });

    var exampleLinkedCustomService = new Azure.DataFactory.LinkedCustomService("exampleLinkedCustomService", new()
    {
        DataFactoryId = exampleFactory.Id,
        Type = "AzureBlobStorage",
        TypePropertiesJson = exampleAccount.PrimaryConnectionString.Apply(primaryConnectionString => @$"{{
  ""connectionString"": ""{primaryConnectionString}""
}}
"),
    });

    var example1DatasetJson = new Azure.DataFactory.DatasetJson("example1DatasetJson", new()
    {
        DataFactoryId = exampleFactory.Id,
        LinkedServiceName = exampleLinkedCustomService.Name,
        AzureBlobStorageLocation = new Azure.DataFactory.Inputs.DatasetJsonAzureBlobStorageLocationArgs
        {
            Container = "container",
            Path = "foo/bar/",
            Filename = "foo.txt",
        },
        Encoding = "UTF-8",
    });

    var example2DatasetJson = new Azure.DataFactory.DatasetJson("example2DatasetJson", new()
    {
        DataFactoryId = exampleFactory.Id,
        LinkedServiceName = exampleLinkedCustomService.Name,
        AzureBlobStorageLocation = new Azure.DataFactory.Inputs.DatasetJsonAzureBlobStorageLocationArgs
        {
            Container = "container",
            Path = "foo/bar/",
            Filename = "bar.txt",
        },
        Encoding = "UTF-8",
    });

    var example1FlowletDataFlow = new Azure.DataFactory.FlowletDataFlow("example1FlowletDataFlow", new()
    {
        DataFactoryId = exampleFactory.Id,
        Sources = new[]
        {
            new Azure.DataFactory.Inputs.FlowletDataFlowSourceArgs
            {
                Name = "source1",
                LinkedService = new Azure.DataFactory.Inputs.FlowletDataFlowSourceLinkedServiceArgs
                {
                    Name = exampleLinkedCustomService.Name,
                },
            },
        },
        Sinks = new[]
        {
            new Azure.DataFactory.Inputs.FlowletDataFlowSinkArgs
            {
                Name = "sink1",
                LinkedService = new Azure.DataFactory.Inputs.FlowletDataFlowSinkLinkedServiceArgs
                {
                    Name = exampleLinkedCustomService.Name,
                },
            },
        },
        Script = @"source(
  allowSchemaDrift: true, 
  validateSchema: false, 
  limit: 100, 
  ignoreNoFilesFound: false, 
  documentForm: 'documentPerLine') ~> source1 
source1 sink(
  allowSchemaDrift: true, 
  validateSchema: false, 
  skipDuplicateMapInputs: true, 
  skipDuplicateMapOutputs: true) ~> sink1
",
    });

    var example2FlowletDataFlow = new Azure.DataFactory.FlowletDataFlow("example2FlowletDataFlow", new()
    {
        DataFactoryId = exampleFactory.Id,
        Sources = new[]
        {
            new Azure.DataFactory.Inputs.FlowletDataFlowSourceArgs
            {
                Name = "source1",
                LinkedService = new Azure.DataFactory.Inputs.FlowletDataFlowSourceLinkedServiceArgs
                {
                    Name = exampleLinkedCustomService.Name,
                },
            },
        },
        Sinks = new[]
        {
            new Azure.DataFactory.Inputs.FlowletDataFlowSinkArgs
            {
                Name = "sink1",
                LinkedService = new Azure.DataFactory.Inputs.FlowletDataFlowSinkLinkedServiceArgs
                {
                    Name = exampleLinkedCustomService.Name,
                },
            },
        },
        Script = @"source(
  allowSchemaDrift: true, 
  validateSchema: false, 
  limit: 100, 
  ignoreNoFilesFound: false, 
  documentForm: 'documentPerLine') ~> source1 
source1 sink(
  allowSchemaDrift: true, 
  validateSchema: false, 
  skipDuplicateMapInputs: true, 
  skipDuplicateMapOutputs: true) ~> sink1
",
    });

    var exampleFlowletDataFlow = new Azure.DataFactory.FlowletDataFlow("exampleFlowletDataFlow", new()
    {
        DataFactoryId = exampleFactory.Id,
        Sources = new[]
        {
            new Azure.DataFactory.Inputs.FlowletDataFlowSourceArgs
            {
                Name = "source1",
                Flowlet = new Azure.DataFactory.Inputs.FlowletDataFlowSourceFlowletArgs
                {
                    Name = example1FlowletDataFlow.Name,
                },
                LinkedService = new Azure.DataFactory.Inputs.FlowletDataFlowSourceLinkedServiceArgs
                {
                    Name = exampleLinkedCustomService.Name,
                },
            },
        },
        Sinks = new[]
        {
            new Azure.DataFactory.Inputs.FlowletDataFlowSinkArgs
            {
                Name = "sink1",
                Flowlet = new Azure.DataFactory.Inputs.FlowletDataFlowSinkFlowletArgs
                {
                    Name = example2FlowletDataFlow.Name,
                },
                LinkedService = new Azure.DataFactory.Inputs.FlowletDataFlowSinkLinkedServiceArgs
                {
                    Name = exampleLinkedCustomService.Name,
                },
            },
        },
        Script = @"source(
  allowSchemaDrift: true, 
  validateSchema: false, 
  limit: 100, 
  ignoreNoFilesFound: false, 
  documentForm: 'documentPerLine') ~> source1 
source1 sink(
  allowSchemaDrift: true, 
  validateSchema: false, 
  skipDuplicateMapInputs: true, 
  skipDuplicateMapOutputs: true) ~> sink1
",
    });

});

package main

import (
	"fmt"

	"github.com/pulumi/pulumi-azure/sdk/v5/go/azure/core"
	"github.com/pulumi/pulumi-azure/sdk/v5/go/azure/datafactory"
	"github.com/pulumi/pulumi-azure/sdk/v5/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
		}
		exampleAccount, err := storage.NewAccount(ctx, "exampleAccount", &storage.AccountArgs{
			Location:               exampleResourceGroup.Location,
			ResourceGroupName:      exampleResourceGroup.Name,
			AccountTier:            pulumi.String("Standard"),
			AccountReplicationType: pulumi.String("LRS"),
		})
		if err != nil {
			return err
		}
		exampleFactory, err := datafactory.NewFactory(ctx, "exampleFactory", &datafactory.FactoryArgs{
			Location:          exampleResourceGroup.Location,
			ResourceGroupName: exampleResourceGroup.Name,
		})
		if err != nil {
			return err
		}
		exampleLinkedCustomService, err := datafactory.NewLinkedCustomService(ctx, "exampleLinkedCustomService", &datafactory.LinkedCustomServiceArgs{
			DataFactoryId: exampleFactory.ID(),
			Type:          pulumi.String("AzureBlobStorage"),
			TypePropertiesJson: exampleAccount.PrimaryConnectionString.ApplyT(func(primaryConnectionString string) (string, error) {
				return fmt.Sprintf("{\n  \"connectionString\": \"%v\"\n}\n", primaryConnectionString), nil
			}).(pulumi.StringOutput),
		})
		if err != nil {
			return err
		}
		_, err = datafactory.NewDatasetJson(ctx, "example1DatasetJson", &datafactory.DatasetJsonArgs{
			DataFactoryId:     exampleFactory.ID(),
			LinkedServiceName: exampleLinkedCustomService.Name,
			AzureBlobStorageLocation: &datafactory.DatasetJsonAzureBlobStorageLocationArgs{
				Container: pulumi.String("container"),
				Path:      pulumi.String("foo/bar/"),
				Filename:  pulumi.String("foo.txt"),
			},
			Encoding: pulumi.String("UTF-8"),
		})
		if err != nil {
			return err
		}
		_, err = datafactory.NewDatasetJson(ctx, "example2DatasetJson", &datafactory.DatasetJsonArgs{
			DataFactoryId:     exampleFactory.ID(),
			LinkedServiceName: exampleLinkedCustomService.Name,
			AzureBlobStorageLocation: &datafactory.DatasetJsonAzureBlobStorageLocationArgs{
				Container: pulumi.String("container"),
				Path:      pulumi.String("foo/bar/"),
				Filename:  pulumi.String("bar.txt"),
			},
			Encoding: pulumi.String("UTF-8"),
		})
		if err != nil {
			return err
		}
		example1FlowletDataFlow, err := datafactory.NewFlowletDataFlow(ctx, "example1FlowletDataFlow", &datafactory.FlowletDataFlowArgs{
			DataFactoryId: exampleFactory.ID(),
			Sources: datafactory.FlowletDataFlowSourceArray{
				&datafactory.FlowletDataFlowSourceArgs{
					Name: pulumi.String("source1"),
					LinkedService: &datafactory.FlowletDataFlowSourceLinkedServiceArgs{
						Name: exampleLinkedCustomService.Name,
					},
				},
			},
			Sinks: datafactory.FlowletDataFlowSinkArray{
				&datafactory.FlowletDataFlowSinkArgs{
					Name: pulumi.String("sink1"),
					LinkedService: &datafactory.FlowletDataFlowSinkLinkedServiceArgs{
						Name: exampleLinkedCustomService.Name,
					},
				},
			},
			Script: pulumi.String(`source(
  allowSchemaDrift: true, 
  validateSchema: false, 
  limit: 100, 
  ignoreNoFilesFound: false, 
  documentForm: 'documentPerLine') ~> source1 
source1 sink(
  allowSchemaDrift: true, 
  validateSchema: false, 
  skipDuplicateMapInputs: true, 
  skipDuplicateMapOutputs: true) ~> sink1
`),
		})
		if err != nil {
			return err
		}
		example2FlowletDataFlow, err := datafactory.NewFlowletDataFlow(ctx, "example2FlowletDataFlow", &datafactory.FlowletDataFlowArgs{
			DataFactoryId: exampleFactory.ID(),
			Sources: datafactory.FlowletDataFlowSourceArray{
				&datafactory.FlowletDataFlowSourceArgs{
					Name: pulumi.String("source1"),
					LinkedService: &datafactory.FlowletDataFlowSourceLinkedServiceArgs{
						Name: exampleLinkedCustomService.Name,
					},
				},
			},
			Sinks: datafactory.FlowletDataFlowSinkArray{
				&datafactory.FlowletDataFlowSinkArgs{
					Name: pulumi.String("sink1"),
					LinkedService: &datafactory.FlowletDataFlowSinkLinkedServiceArgs{
						Name: exampleLinkedCustomService.Name,
					},
				},
			},
			Script: pulumi.String(`source(
  allowSchemaDrift: true, 
  validateSchema: false, 
  limit: 100, 
  ignoreNoFilesFound: false, 
  documentForm: 'documentPerLine') ~> source1 
source1 sink(
  allowSchemaDrift: true, 
  validateSchema: false, 
  skipDuplicateMapInputs: true, 
  skipDuplicateMapOutputs: true) ~> sink1
`),
		})
		if err != nil {
			return err
		}
		_, err = datafactory.NewFlowletDataFlow(ctx, "exampleFlowletDataFlow", &datafactory.FlowletDataFlowArgs{
			DataFactoryId: exampleFactory.ID(),
			Sources: datafactory.FlowletDataFlowSourceArray{
				&datafactory.FlowletDataFlowSourceArgs{
					Name: pulumi.String("source1"),
					Flowlet: &datafactory.FlowletDataFlowSourceFlowletArgs{
						Name: example1FlowletDataFlow.Name,
					},
					LinkedService: &datafactory.FlowletDataFlowSourceLinkedServiceArgs{
						Name: exampleLinkedCustomService.Name,
					},
				},
			},
			Sinks: datafactory.FlowletDataFlowSinkArray{
				&datafactory.FlowletDataFlowSinkArgs{
					Name: pulumi.String("sink1"),
					Flowlet: &datafactory.FlowletDataFlowSinkFlowletArgs{
						Name: example2FlowletDataFlow.Name,
					},
					LinkedService: &datafactory.FlowletDataFlowSinkLinkedServiceArgs{
						Name: exampleLinkedCustomService.Name,
					},
				},
			},
			Script: pulumi.String(`source(
  allowSchemaDrift: true, 
  validateSchema: false, 
  limit: 100, 
  ignoreNoFilesFound: false, 
  documentForm: 'documentPerLine') ~> source1 
source1 sink(
  allowSchemaDrift: true, 
  validateSchema: false, 
  skipDuplicateMapInputs: true, 
  skipDuplicateMapOutputs: true) ~> sink1
`),
		})
		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.azure.core.ResourceGroup;
import com.pulumi.azure.core.ResourceGroupArgs;
import com.pulumi.azure.storage.Account;
import com.pulumi.azure.storage.AccountArgs;
import com.pulumi.azure.datafactory.Factory;
import com.pulumi.azure.datafactory.FactoryArgs;
import com.pulumi.azure.datafactory.LinkedCustomService;
import com.pulumi.azure.datafactory.LinkedCustomServiceArgs;
import com.pulumi.azure.datafactory.DatasetJson;
import com.pulumi.azure.datafactory.DatasetJsonArgs;
import com.pulumi.azure.datafactory.inputs.DatasetJsonAzureBlobStorageLocationArgs;
import com.pulumi.azure.datafactory.FlowletDataFlow;
import com.pulumi.azure.datafactory.FlowletDataFlowArgs;
import com.pulumi.azure.datafactory.inputs.FlowletDataFlowSourceArgs;
import com.pulumi.azure.datafactory.inputs.FlowletDataFlowSourceLinkedServiceArgs;
import com.pulumi.azure.datafactory.inputs.FlowletDataFlowSinkArgs;
import com.pulumi.azure.datafactory.inputs.FlowletDataFlowSinkLinkedServiceArgs;
import com.pulumi.azure.datafactory.inputs.FlowletDataFlowSourceFlowletArgs;
import com.pulumi.azure.datafactory.inputs.FlowletDataFlowSinkFlowletArgs;
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 exampleResourceGroup = new ResourceGroup("exampleResourceGroup", ResourceGroupArgs.builder()        
            .location("West Europe")
            .build());

        var exampleAccount = new Account("exampleAccount", AccountArgs.builder()        
            .location(exampleResourceGroup.location())
            .resourceGroupName(exampleResourceGroup.name())
            .accountTier("Standard")
            .accountReplicationType("LRS")
            .build());

        var exampleFactory = new Factory("exampleFactory", FactoryArgs.builder()        
            .location(exampleResourceGroup.location())
            .resourceGroupName(exampleResourceGroup.name())
            .build());

        var exampleLinkedCustomService = new LinkedCustomService("exampleLinkedCustomService", LinkedCustomServiceArgs.builder()        
            .dataFactoryId(exampleFactory.id())
            .type("AzureBlobStorage")
            .typePropertiesJson(exampleAccount.primaryConnectionString().applyValue(primaryConnectionString -> """
{
  "connectionString": "%s"
}
", primaryConnectionString)))
            .build());

        var example1DatasetJson = new DatasetJson("example1DatasetJson", DatasetJsonArgs.builder()        
            .dataFactoryId(exampleFactory.id())
            .linkedServiceName(exampleLinkedCustomService.name())
            .azureBlobStorageLocation(DatasetJsonAzureBlobStorageLocationArgs.builder()
                .container("container")
                .path("foo/bar/")
                .filename("foo.txt")
                .build())
            .encoding("UTF-8")
            .build());

        var example2DatasetJson = new DatasetJson("example2DatasetJson", DatasetJsonArgs.builder()        
            .dataFactoryId(exampleFactory.id())
            .linkedServiceName(exampleLinkedCustomService.name())
            .azureBlobStorageLocation(DatasetJsonAzureBlobStorageLocationArgs.builder()
                .container("container")
                .path("foo/bar/")
                .filename("bar.txt")
                .build())
            .encoding("UTF-8")
            .build());

        var example1FlowletDataFlow = new FlowletDataFlow("example1FlowletDataFlow", FlowletDataFlowArgs.builder()        
            .dataFactoryId(exampleFactory.id())
            .sources(FlowletDataFlowSourceArgs.builder()
                .name("source1")
                .linkedService(FlowletDataFlowSourceLinkedServiceArgs.builder()
                    .name(exampleLinkedCustomService.name())
                    .build())
                .build())
            .sinks(FlowletDataFlowSinkArgs.builder()
                .name("sink1")
                .linkedService(FlowletDataFlowSinkLinkedServiceArgs.builder()
                    .name(exampleLinkedCustomService.name())
                    .build())
                .build())
            .script("""
source(
  allowSchemaDrift: true, 
  validateSchema: false, 
  limit: 100, 
  ignoreNoFilesFound: false, 
  documentForm: 'documentPerLine') ~> source1 
source1 sink(
  allowSchemaDrift: true, 
  validateSchema: false, 
  skipDuplicateMapInputs: true, 
  skipDuplicateMapOutputs: true) ~> sink1
            """)
            .build());

        var example2FlowletDataFlow = new FlowletDataFlow("example2FlowletDataFlow", FlowletDataFlowArgs.builder()        
            .dataFactoryId(exampleFactory.id())
            .sources(FlowletDataFlowSourceArgs.builder()
                .name("source1")
                .linkedService(FlowletDataFlowSourceLinkedServiceArgs.builder()
                    .name(exampleLinkedCustomService.name())
                    .build())
                .build())
            .sinks(FlowletDataFlowSinkArgs.builder()
                .name("sink1")
                .linkedService(FlowletDataFlowSinkLinkedServiceArgs.builder()
                    .name(exampleLinkedCustomService.name())
                    .build())
                .build())
            .script("""
source(
  allowSchemaDrift: true, 
  validateSchema: false, 
  limit: 100, 
  ignoreNoFilesFound: false, 
  documentForm: 'documentPerLine') ~> source1 
source1 sink(
  allowSchemaDrift: true, 
  validateSchema: false, 
  skipDuplicateMapInputs: true, 
  skipDuplicateMapOutputs: true) ~> sink1
            """)
            .build());

        var exampleFlowletDataFlow = new FlowletDataFlow("exampleFlowletDataFlow", FlowletDataFlowArgs.builder()        
            .dataFactoryId(exampleFactory.id())
            .sources(FlowletDataFlowSourceArgs.builder()
                .name("source1")
                .flowlet(FlowletDataFlowSourceFlowletArgs.builder()
                    .name(example1FlowletDataFlow.name())
                    .build())
                .linkedService(FlowletDataFlowSourceLinkedServiceArgs.builder()
                    .name(exampleLinkedCustomService.name())
                    .build())
                .build())
            .sinks(FlowletDataFlowSinkArgs.builder()
                .name("sink1")
                .flowlet(FlowletDataFlowSinkFlowletArgs.builder()
                    .name(example2FlowletDataFlow.name())
                    .build())
                .linkedService(FlowletDataFlowSinkLinkedServiceArgs.builder()
                    .name(exampleLinkedCustomService.name())
                    .build())
                .build())
            .script("""
source(
  allowSchemaDrift: true, 
  validateSchema: false, 
  limit: 100, 
  ignoreNoFilesFound: false, 
  documentForm: 'documentPerLine') ~> source1 
source1 sink(
  allowSchemaDrift: true, 
  validateSchema: false, 
  skipDuplicateMapInputs: true, 
  skipDuplicateMapOutputs: true) ~> sink1
            """)
            .build());

    }
}

import pulumi
import pulumi_azure as azure

example_resource_group = azure.core.ResourceGroup("exampleResourceGroup", location="West Europe")
example_account = azure.storage.Account("exampleAccount",
    location=example_resource_group.location,
    resource_group_name=example_resource_group.name,
    account_tier="Standard",
    account_replication_type="LRS")
example_factory = azure.datafactory.Factory("exampleFactory",
    location=example_resource_group.location,
    resource_group_name=example_resource_group.name)
example_linked_custom_service = azure.datafactory.LinkedCustomService("exampleLinkedCustomService",
    data_factory_id=example_factory.id,
    type="AzureBlobStorage",
    type_properties_json=example_account.primary_connection_string.apply(lambda primary_connection_string: f"""{{
  "connectionString": "{primary_connection_string}"
}}
"""))
example1_dataset_json = azure.datafactory.DatasetJson("example1DatasetJson",
    data_factory_id=example_factory.id,
    linked_service_name=example_linked_custom_service.name,
    azure_blob_storage_location=azure.datafactory.DatasetJsonAzureBlobStorageLocationArgs(
        container="container",
        path="foo/bar/",
        filename="foo.txt",
    ),
    encoding="UTF-8")
example2_dataset_json = azure.datafactory.DatasetJson("example2DatasetJson",
    data_factory_id=example_factory.id,
    linked_service_name=example_linked_custom_service.name,
    azure_blob_storage_location=azure.datafactory.DatasetJsonAzureBlobStorageLocationArgs(
        container="container",
        path="foo/bar/",
        filename="bar.txt",
    ),
    encoding="UTF-8")
example1_flowlet_data_flow = azure.datafactory.FlowletDataFlow("example1FlowletDataFlow",
    data_factory_id=example_factory.id,
    sources=[azure.datafactory.FlowletDataFlowSourceArgs(
        name="source1",
        linked_service=azure.datafactory.FlowletDataFlowSourceLinkedServiceArgs(
            name=example_linked_custom_service.name,
        ),
    )],
    sinks=[azure.datafactory.FlowletDataFlowSinkArgs(
        name="sink1",
        linked_service=azure.datafactory.FlowletDataFlowSinkLinkedServiceArgs(
            name=example_linked_custom_service.name,
        ),
    )],
    script="""source(
  allowSchemaDrift: true, 
  validateSchema: false, 
  limit: 100, 
  ignoreNoFilesFound: false, 
  documentForm: 'documentPerLine') ~> source1 
source1 sink(
  allowSchemaDrift: true, 
  validateSchema: false, 
  skipDuplicateMapInputs: true, 
  skipDuplicateMapOutputs: true) ~> sink1
""")
example2_flowlet_data_flow = azure.datafactory.FlowletDataFlow("example2FlowletDataFlow",
    data_factory_id=example_factory.id,
    sources=[azure.datafactory.FlowletDataFlowSourceArgs(
        name="source1",
        linked_service=azure.datafactory.FlowletDataFlowSourceLinkedServiceArgs(
            name=example_linked_custom_service.name,
        ),
    )],
    sinks=[azure.datafactory.FlowletDataFlowSinkArgs(
        name="sink1",
        linked_service=azure.datafactory.FlowletDataFlowSinkLinkedServiceArgs(
            name=example_linked_custom_service.name,
        ),
    )],
    script="""source(
  allowSchemaDrift: true, 
  validateSchema: false, 
  limit: 100, 
  ignoreNoFilesFound: false, 
  documentForm: 'documentPerLine') ~> source1 
source1 sink(
  allowSchemaDrift: true, 
  validateSchema: false, 
  skipDuplicateMapInputs: true, 
  skipDuplicateMapOutputs: true) ~> sink1
""")
example_flowlet_data_flow = azure.datafactory.FlowletDataFlow("exampleFlowletDataFlow",
    data_factory_id=example_factory.id,
    sources=[azure.datafactory.FlowletDataFlowSourceArgs(
        name="source1",
        flowlet=azure.datafactory.FlowletDataFlowSourceFlowletArgs(
            name=example1_flowlet_data_flow.name,
        ),
        linked_service=azure.datafactory.FlowletDataFlowSourceLinkedServiceArgs(
            name=example_linked_custom_service.name,
        ),
    )],
    sinks=[azure.datafactory.FlowletDataFlowSinkArgs(
        name="sink1",
        flowlet=azure.datafactory.FlowletDataFlowSinkFlowletArgs(
            name=example2_flowlet_data_flow.name,
        ),
        linked_service=azure.datafactory.FlowletDataFlowSinkLinkedServiceArgs(
            name=example_linked_custom_service.name,
        ),
    )],
    script="""source(
  allowSchemaDrift: true, 
  validateSchema: false, 
  limit: 100, 
  ignoreNoFilesFound: false, 
  documentForm: 'documentPerLine') ~> source1 
source1 sink(
  allowSchemaDrift: true, 
  validateSchema: false, 
  skipDuplicateMapInputs: true, 
  skipDuplicateMapOutputs: true) ~> sink1
""")

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

const exampleResourceGroup = new azure.core.ResourceGroup("exampleResourceGroup", {location: "West Europe"});
const exampleAccount = new azure.storage.Account("exampleAccount", {
    location: exampleResourceGroup.location,
    resourceGroupName: exampleResourceGroup.name,
    accountTier: "Standard",
    accountReplicationType: "LRS",
});
const exampleFactory = new azure.datafactory.Factory("exampleFactory", {
    location: exampleResourceGroup.location,
    resourceGroupName: exampleResourceGroup.name,
});
const exampleLinkedCustomService = new azure.datafactory.LinkedCustomService("exampleLinkedCustomService", {
    dataFactoryId: exampleFactory.id,
    type: "AzureBlobStorage",
    typePropertiesJson: pulumi.interpolate`{
  "connectionString": "${exampleAccount.primaryConnectionString}"
}
`,
});
const example1DatasetJson = new azure.datafactory.DatasetJson("example1DatasetJson", {
    dataFactoryId: exampleFactory.id,
    linkedServiceName: exampleLinkedCustomService.name,
    azureBlobStorageLocation: {
        container: "container",
        path: "foo/bar/",
        filename: "foo.txt",
    },
    encoding: "UTF-8",
});
const example2DatasetJson = new azure.datafactory.DatasetJson("example2DatasetJson", {
    dataFactoryId: exampleFactory.id,
    linkedServiceName: exampleLinkedCustomService.name,
    azureBlobStorageLocation: {
        container: "container",
        path: "foo/bar/",
        filename: "bar.txt",
    },
    encoding: "UTF-8",
});
const example1FlowletDataFlow = new azure.datafactory.FlowletDataFlow("example1FlowletDataFlow", {
    dataFactoryId: exampleFactory.id,
    sources: [{
        name: "source1",
        linkedService: {
            name: exampleLinkedCustomService.name,
        },
    }],
    sinks: [{
        name: "sink1",
        linkedService: {
            name: exampleLinkedCustomService.name,
        },
    }],
    script: `source(
  allowSchemaDrift: true, 
  validateSchema: false, 
  limit: 100, 
  ignoreNoFilesFound: false, 
  documentForm: 'documentPerLine') ~> source1 
source1 sink(
  allowSchemaDrift: true, 
  validateSchema: false, 
  skipDuplicateMapInputs: true, 
  skipDuplicateMapOutputs: true) ~> sink1
`,
});
const example2FlowletDataFlow = new azure.datafactory.FlowletDataFlow("example2FlowletDataFlow", {
    dataFactoryId: exampleFactory.id,
    sources: [{
        name: "source1",
        linkedService: {
            name: exampleLinkedCustomService.name,
        },
    }],
    sinks: [{
        name: "sink1",
        linkedService: {
            name: exampleLinkedCustomService.name,
        },
    }],
    script: `source(
  allowSchemaDrift: true, 
  validateSchema: false, 
  limit: 100, 
  ignoreNoFilesFound: false, 
  documentForm: 'documentPerLine') ~> source1 
source1 sink(
  allowSchemaDrift: true, 
  validateSchema: false, 
  skipDuplicateMapInputs: true, 
  skipDuplicateMapOutputs: true) ~> sink1
`,
});
const exampleFlowletDataFlow = new azure.datafactory.FlowletDataFlow("exampleFlowletDataFlow", {
    dataFactoryId: exampleFactory.id,
    sources: [{
        name: "source1",
        flowlet: {
            name: example1FlowletDataFlow.name,
        },
        linkedService: {
            name: exampleLinkedCustomService.name,
        },
    }],
    sinks: [{
        name: "sink1",
        flowlet: {
            name: example2FlowletDataFlow.name,
        },
        linkedService: {
            name: exampleLinkedCustomService.name,
        },
    }],
    script: `source(
  allowSchemaDrift: true, 
  validateSchema: false, 
  limit: 100, 
  ignoreNoFilesFound: false, 
  documentForm: 'documentPerLine') ~> source1 
source1 sink(
  allowSchemaDrift: true, 
  validateSchema: false, 
  skipDuplicateMapInputs: true, 
  skipDuplicateMapOutputs: true) ~> sink1
`,
});

resources:
  exampleResourceGroup:
    type: azure:core:ResourceGroup
    properties:
      location: West Europe
  exampleAccount:
    type: azure:storage:Account
    properties:
      location: ${exampleResourceGroup.location}
      resourceGroupName: ${exampleResourceGroup.name}
      accountTier: Standard
      accountReplicationType: LRS
  exampleFactory:
    type: azure:datafactory:Factory
    properties:
      location: ${exampleResourceGroup.location}
      resourceGroupName: ${exampleResourceGroup.name}
  exampleLinkedCustomService:
    type: azure:datafactory:LinkedCustomService
    properties:
      dataFactoryId: ${exampleFactory.id}
      type: AzureBlobStorage
      typePropertiesJson: |
        {
          "connectionString": "${exampleAccount.primaryConnectionString}"
        }        
  example1DatasetJson:
    type: azure:datafactory:DatasetJson
    properties:
      dataFactoryId: ${exampleFactory.id}
      linkedServiceName: ${exampleLinkedCustomService.name}
      azureBlobStorageLocation:
        container: container
        path: foo/bar/
        filename: foo.txt
      encoding: UTF-8
  example2DatasetJson:
    type: azure:datafactory:DatasetJson
    properties:
      dataFactoryId: ${exampleFactory.id}
      linkedServiceName: ${exampleLinkedCustomService.name}
      azureBlobStorageLocation:
        container: container
        path: foo/bar/
        filename: bar.txt
      encoding: UTF-8
  exampleFlowletDataFlow:
    type: azure:datafactory:FlowletDataFlow
    properties:
      dataFactoryId: ${exampleFactory.id}
      sources:
        - name: source1
          flowlet:
            name: ${example1FlowletDataFlow.name}
          linkedService:
            name: ${exampleLinkedCustomService.name}
      sinks:
        - name: sink1
          flowlet:
            name: ${example2FlowletDataFlow.name}
          linkedService:
            name: ${exampleLinkedCustomService.name}
      script: "source(\n  allowSchemaDrift: true, \n  validateSchema: false, \n  limit: 100, \n  ignoreNoFilesFound: false, \n  documentForm: 'documentPerLine') ~> source1 \nsource1 sink(\n  allowSchemaDrift: true, \n  validateSchema: false, \n  skipDuplicateMapInputs: true, \n  skipDuplicateMapOutputs: true) ~> sink1\n"
  example1FlowletDataFlow:
    type: azure:datafactory:FlowletDataFlow
    properties:
      dataFactoryId: ${exampleFactory.id}
      sources:
        - name: source1
          linkedService:
            name: ${exampleLinkedCustomService.name}
      sinks:
        - name: sink1
          linkedService:
            name: ${exampleLinkedCustomService.name}
      script: "source(\n  allowSchemaDrift: true, \n  validateSchema: false, \n  limit: 100, \n  ignoreNoFilesFound: false, \n  documentForm: 'documentPerLine') ~> source1 \nsource1 sink(\n  allowSchemaDrift: true, \n  validateSchema: false, \n  skipDuplicateMapInputs: true, \n  skipDuplicateMapOutputs: true) ~> sink1\n"
  example2FlowletDataFlow:
    type: azure:datafactory:FlowletDataFlow
    properties:
      dataFactoryId: ${exampleFactory.id}
      sources:
        - name: source1
          linkedService:
            name: ${exampleLinkedCustomService.name}
      sinks:
        - name: sink1
          linkedService:
            name: ${exampleLinkedCustomService.name}
      script: "source(\n  allowSchemaDrift: true, \n  validateSchema: false, \n  limit: 100, \n  ignoreNoFilesFound: false, \n  documentForm: 'documentPerLine') ~> source1 \nsource1 sink(\n  allowSchemaDrift: true, \n  validateSchema: false, \n  skipDuplicateMapInputs: true, \n  skipDuplicateMapOutputs: true) ~> sink1\n"