azure.datafactory.LinkedServiceAzureFunction

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 exampleFunctionApp = Azure.AppService.GetFunctionApp.Invoke(new Azure.AppService.GetFunctionAppInvokeArgs
        {
            Name = "test-azure-functions",
            ResourceGroupName = exampleResourceGroup.Name,
        });
        var exampleFactory = new Azure.DataFactory.Factory("exampleFactory", new Azure.DataFactory.FactoryArgs
        {
            Location = exampleResourceGroup.Location,
            ResourceGroupName = exampleResourceGroup.Name,
        });
        var exampleLinkedServiceAzureFunction = new Azure.DataFactory.LinkedServiceAzureFunction("exampleLinkedServiceAzureFunction", new Azure.DataFactory.LinkedServiceAzureFunctionArgs
        {
            ResourceGroupName = exampleResourceGroup.Name,
            DataFactoryId = exampleFactory.Id,
            Url = exampleFunctionApp.Apply(exampleFunctionApp => $"https://{exampleFunctionApp.DefaultHostname}"),
            Key = "foo",
        });
    }

}

package main

import (
	"fmt"

	"github.com/pulumi/pulumi-azure/sdk/v4/go/azure/appservice"
	"github.com/pulumi/pulumi-azure/sdk/v4/go/azure/core"
	"github.com/pulumi/pulumi-azure/sdk/v4/go/azure/datafactory"
	"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
		}
		exampleFunctionApp := appservice.LookupFunctionAppOutput(ctx, appservice.GetFunctionAppOutputArgs{
			Name:              pulumi.String("test-azure-functions"),
			ResourceGroupName: exampleResourceGroup.Name,
		}, nil)
		exampleFactory, err := datafactory.NewFactory(ctx, "exampleFactory", &datafactory.FactoryArgs{
			Location:          exampleResourceGroup.Location,
			ResourceGroupName: exampleResourceGroup.Name,
		})
		if err != nil {
			return err
		}
		_, err = datafactory.NewLinkedServiceAzureFunction(ctx, "exampleLinkedServiceAzureFunction", &datafactory.LinkedServiceAzureFunctionArgs{
			ResourceGroupName: exampleResourceGroup.Name,
			DataFactoryId:     exampleFactory.ID(),
			Url: exampleFunctionApp.ApplyT(func(exampleFunctionApp appservice.GetFunctionAppResult) (string, error) {
				return fmt.Sprintf("%v%v", "https://", exampleFunctionApp.DefaultHostname), nil
			}).(pulumi.StringOutput),
			Key: pulumi.String("foo"),
		})
		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 exampleFunctionApp = azure.appservice.getFunctionAppOutput({
    name: "test-azure-functions",
    resourceGroupName: exampleResourceGroup.name,
});
const exampleFactory = new azure.datafactory.Factory("exampleFactory", {
    location: exampleResourceGroup.location,
    resourceGroupName: exampleResourceGroup.name,
});
const exampleLinkedServiceAzureFunction = new azure.datafactory.LinkedServiceAzureFunction("exampleLinkedServiceAzureFunction", {
    resourceGroupName: exampleResourceGroup.name,
    dataFactoryId: exampleFactory.id,
    url: exampleFunctionApp.apply(exampleFunctionApp => `https://${exampleFunctionApp.defaultHostname}`),
    key: "foo",
});

import pulumi
import pulumi_azure as azure

example_resource_group = azure.core.ResourceGroup("exampleResourceGroup", location="West Europe")
example_function_app = azure.appservice.get_function_app_output(name="test-azure-functions",
    resource_group_name=example_resource_group.name)
example_factory = azure.datafactory.Factory("exampleFactory",
    location=example_resource_group.location,
    resource_group_name=example_resource_group.name)
example_linked_service_azure_function = azure.datafactory.LinkedServiceAzureFunction("exampleLinkedServiceAzureFunction",
    resource_group_name=example_resource_group.name,
    data_factory_id=example_factory.id,
    url=example_function_app.apply(lambda example_function_app: f"https://{example_function_app.default_hostname}"),
    key="foo")