pulumi-azure-kotlin/com.pulumi.azure.datafactory.kotlin/LinkedServiceAzureFunction

LinkedServiceAzureFunction

class LinkedServiceAzureFunction : KotlinCustomResource

Manages a Linked Service (connection) between an Azure Function and Azure Data Factory.

Example Usage

import * as pulumi from "@pulumi/pulumi";
import * as azure from "@pulumi/azure";
const exampleResourceGroup = new azure.core.ResourceGroup("example", {
    name: "example-resources",
    location: "West Europe",
});
const example = azure.appservice.getFunctionAppOutput({
    name: "test-azure-functions",
    resourceGroupName: exampleResourceGroup.name,
});
const exampleFactory = new azure.datafactory.Factory("example", {
    name: "example",
    location: exampleResourceGroup.location,
    resourceGroupName: exampleResourceGroup.name,
});
const exampleLinkedServiceAzureFunction = new azure.datafactory.LinkedServiceAzureFunction("example", {
    name: "example",
    dataFactoryId: exampleFactory.id,
    url: example.apply(example => `https://${example.defaultHostname}`),
    key: "foo",
});

import pulumi
import pulumi_azure as azure
example_resource_group = azure.core.ResourceGroup("example",
    name="example-resources",
    location="West Europe")
example = azure.appservice.get_function_app_output(name="test-azure-functions",
    resource_group_name=example_resource_group.name)
example_factory = azure.datafactory.Factory("example",
    name="example",
    location=example_resource_group.location,
    resource_group_name=example_resource_group.name)
example_linked_service_azure_function = azure.datafactory.LinkedServiceAzureFunction("example",
    name="example",
    data_factory_id=example_factory.id,
    url=example.apply(lambda example: f"https://{example.default_hostname}"),
    key="foo")

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Azure = Pulumi.Azure;
return await Deployment.RunAsync(() =>
{
    var exampleResourceGroup = new Azure.Core.ResourceGroup("example", new()
    {
        Name = "example-resources",
        Location = "West Europe",
    });
    var example = Azure.AppService.GetFunctionApp.Invoke(new()
    {
        Name = "test-azure-functions",
        ResourceGroupName = exampleResourceGroup.Name,
    });
    var exampleFactory = new Azure.DataFactory.Factory("example", new()
    {
        Name = "example",
        Location = exampleResourceGroup.Location,
        ResourceGroupName = exampleResourceGroup.Name,
    });
    var exampleLinkedServiceAzureFunction = new Azure.DataFactory.LinkedServiceAzureFunction("example", new()
    {
        Name = "example",
        DataFactoryId = exampleFactory.Id,
        Url = $"https://{example.Apply(getFunctionAppResult => getFunctionAppResult.DefaultHostname)}",
        Key = "foo",
    });
});

package main
import (
	"fmt"
	"github.com/pulumi/pulumi-azure/sdk/v6/go/azure/appservice"
	"github.com/pulumi/pulumi-azure/sdk/v6/go/azure/core"
	"github.com/pulumi/pulumi-azure/sdk/v6/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, "example", &core.ResourceGroupArgs{
			Name:     pulumi.String("example-resources"),
			Location: pulumi.String("West Europe"),
		})
		if err != nil {
			return err
		}
		example := appservice.LookupFunctionAppOutput(ctx, appservice.GetFunctionAppOutputArgs{
			Name:              pulumi.String("test-azure-functions"),
			ResourceGroupName: exampleResourceGroup.Name,
		}, nil)
		exampleFactory, err := datafactory.NewFactory(ctx, "example", &datafactory.FactoryArgs{
			Name:              pulumi.String("example"),
			Location:          exampleResourceGroup.Location,
			ResourceGroupName: exampleResourceGroup.Name,
		})
		if err != nil {
			return err
		}
		_, err = datafactory.NewLinkedServiceAzureFunction(ctx, "example", &datafactory.LinkedServiceAzureFunctionArgs{
			Name:          pulumi.String("example"),
			DataFactoryId: exampleFactory.ID(),
			Url: example.ApplyT(func(example appservice.GetFunctionAppResult) (string, error) {
				return fmt.Sprintf("https://%v", example.DefaultHostname), nil
			}).(pulumi.StringOutput),
			Key: pulumi.String("foo"),
		})
		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.appservice.AppserviceFunctions;
import com.pulumi.azure.appservice.inputs.GetFunctionAppArgs;
import com.pulumi.azure.datafactory.Factory;
import com.pulumi.azure.datafactory.FactoryArgs;
import com.pulumi.azure.datafactory.LinkedServiceAzureFunction;
import com.pulumi.azure.datafactory.LinkedServiceAzureFunctionArgs;
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()
            .name("example-resources")
            .location("West Europe")
            .build());
        final var example = AppserviceFunctions.getFunctionApp(GetFunctionAppArgs.builder()
            .name("test-azure-functions")
            .resourceGroupName(exampleResourceGroup.name())
            .build());
        var exampleFactory = new Factory("exampleFactory", FactoryArgs.builder()
            .name("example")
            .location(exampleResourceGroup.location())
            .resourceGroupName(exampleResourceGroup.name())
            .build());
        var exampleLinkedServiceAzureFunction = new LinkedServiceAzureFunction("exampleLinkedServiceAzureFunction", LinkedServiceAzureFunctionArgs.builder()
            .name("example")
            .dataFactoryId(exampleFactory.id())
            .url(example.applyValue(_example -> String.format("https://%s", _example.defaultHostname())))
            .key("foo")
            .build());
    }
}

resources:
  exampleResourceGroup:
    type: azure:core:ResourceGroup
    name: example
    properties:
      name: example-resources
      location: West Europe
  exampleFactory:
    type: azure:datafactory:Factory
    name: example
    properties:
      name: example
      location: ${exampleResourceGroup.location}
      resourceGroupName: ${exampleResourceGroup.name}
  exampleLinkedServiceAzureFunction:
    type: azure:datafactory:LinkedServiceAzureFunction
    name: example
    properties:
      name: example
      dataFactoryId: ${exampleFactory.id}
      url: https://${example.defaultHostname}
      key: foo
variables:
  example:
    fn::invoke:
      function: azure:appservice:getFunctionApp
      arguments:
        name: test-azure-functions
        resourceGroupName: ${exampleResourceGroup.name}

Import

Data Factory Linked Service's can be imported using the resource id, e.g.

$ pulumi import azure:datafactory/linkedServiceAzureFunction:LinkedServiceAzureFunction example /subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/example/providers/Microsoft.DataFactory/factories/example/linkedservices/example

Properties

additionalProperties

val additionalProperties: Output<Map<String, String>>?

A map of additional properties to associate with the Data Factory Linked Service. The following supported arguments are specific to Azure Function Linked Service:

annotations

val annotations: Output<List<String>>?

List of tags that can be used for describing the Data Factory Linked Service.

dataFactoryId

val dataFactoryId: Output<String>

The Data Factory ID in which to associate the Linked Service with. Changing this forces a new resource.

description

val description: Output<String>?

The description for the Data Factory Linked Service.

val id: Output<String>

integrationRuntimeName

val integrationRuntimeName: Output<String>?

The integration runtime reference to associate with the Data Factory Linked Service.

key

val key: Output<String>?

The system key of the Azure Function. Exactly one of either key or key_vault_key is required

keyVaultKey

val keyVaultKey: Output<LinkedServiceAzureFunctionKeyVaultKey>?

A key_vault_key block as defined below. Use this Argument to store the system key of the Azure Function in an existing Key Vault. It needs an existing Key Vault Data Factory Linked Service. Exactly one of either key or key_vault_key is required.

name

val name: Output<String>

Specifies the name of the Data Factory Linked Service. Changing this forces a new resource to be created. Must be unique within a data factory. See the Microsoft documentation for all restrictions.

parameters

val parameters: Output<Map<String, String>>?

A map of parameters to associate with the Data Factory Linked Service.

pulumiChildResources

val pulumiChildResources: Set<KotlinResource>

pulumiResourceName

val pulumiResourceName: String

pulumiResourceType

val pulumiResourceType: String

url

val url: Output<String>

The url of the Azure Function.

urn

val urn: Output<String>