Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance. Project price only 1 $
You can buy this project and download/modify it how often you want.
@file:Suppress("NAME_SHADOWING", "DEPRECATION")
package com.pulumi.azure.datafactory.kotlin
import com.pulumi.azure.datafactory.kotlin.outputs.LinkedServiceAzureSqlDatabaseKeyVaultConnectionString
import com.pulumi.azure.datafactory.kotlin.outputs.LinkedServiceAzureSqlDatabaseKeyVaultPassword
import com.pulumi.core.Output
import com.pulumi.kotlin.KotlinCustomResource
import com.pulumi.kotlin.PulumiTagMarker
import com.pulumi.kotlin.ResourceMapper
import com.pulumi.kotlin.options.CustomResourceOptions
import com.pulumi.kotlin.options.CustomResourceOptionsBuilder
import com.pulumi.resources.Resource
import kotlin.Boolean
import kotlin.String
import kotlin.Suppress
import kotlin.Unit
import kotlin.collections.List
import kotlin.collections.Map
import com.pulumi.azure.datafactory.kotlin.outputs.LinkedServiceAzureSqlDatabaseKeyVaultConnectionString.Companion.toKotlin as linkedServiceAzureSqlDatabaseKeyVaultConnectionStringToKotlin
import com.pulumi.azure.datafactory.kotlin.outputs.LinkedServiceAzureSqlDatabaseKeyVaultPassword.Companion.toKotlin as linkedServiceAzureSqlDatabaseKeyVaultPasswordToKotlin
/**
* Builder for [LinkedServiceAzureSqlDatabase].
*/
@PulumiTagMarker
public class LinkedServiceAzureSqlDatabaseResourceBuilder internal constructor() {
public var name: String? = null
public var args: LinkedServiceAzureSqlDatabaseArgs = LinkedServiceAzureSqlDatabaseArgs()
public var opts: CustomResourceOptions = CustomResourceOptions()
/**
* @param name The _unique_ name of the resulting resource.
*/
public fun name(`value`: String) {
this.name = value
}
/**
* @param block The arguments to use to populate this resource's properties.
*/
public suspend fun args(block: suspend LinkedServiceAzureSqlDatabaseArgsBuilder.() -> Unit) {
val builder = LinkedServiceAzureSqlDatabaseArgsBuilder()
block(builder)
this.args = builder.build()
}
/**
* @param block A bag of options that control this resource's behavior.
*/
public suspend fun opts(block: suspend CustomResourceOptionsBuilder.() -> Unit) {
this.opts = com.pulumi.kotlin.options.CustomResourceOptions.opts(block)
}
internal fun build(): LinkedServiceAzureSqlDatabase {
val builtJavaResource =
com.pulumi.azure.datafactory.LinkedServiceAzureSqlDatabase(
this.name,
this.args.toJava(),
this.opts.toJava(),
)
return LinkedServiceAzureSqlDatabase(builtJavaResource)
}
}
/**
* Manages a Linked Service (connection) between Azure SQL Database and Azure Data Factory.
* ## Example Usage
*
* ```typescript
* import * as pulumi from "@pulumi/pulumi";
* import * as azure from "@pulumi/azure";
* const example = new azure.core.ResourceGroup("example", {
* name: "example-resources",
* location: "West Europe",
* });
* const exampleFactory = new azure.datafactory.Factory("example", {
* name: "example",
* location: example.location,
* resourceGroupName: example.name,
* });
* const exampleLinkedServiceAzureSqlDatabase = new azure.datafactory.LinkedServiceAzureSqlDatabase("example", {
* name: "example",
* dataFactoryId: exampleFactory.id,
* connectionString: "data source=serverhostname;initial catalog=master;user id=testUser;Password=test;integrated security=False;encrypt=True;connection timeout=30",
* });
* ```
* ```python
* import pulumi
* import pulumi_azure as azure
* example = azure.core.ResourceGroup("example",
* name="example-resources",
* location="West Europe")
* example_factory = azure.datafactory.Factory("example",
* name="example",
* location=example.location,
* resource_group_name=example.name)
* example_linked_service_azure_sql_database = azure.datafactory.LinkedServiceAzureSqlDatabase("example",
* name="example",
* data_factory_id=example_factory.id,
* connection_string="data source=serverhostname;initial catalog=master;user id=testUser;Password=test;integrated security=False;encrypt=True;connection timeout=30")
* ```
* ```csharp
* using System.Collections.Generic;
* using System.Linq;
* using Pulumi;
* using Azure = Pulumi.Azure;
* return await Deployment.RunAsync(() =>
* {
* var example = new Azure.Core.ResourceGroup("example", new()
* {
* Name = "example-resources",
* Location = "West Europe",
* });
* var exampleFactory = new Azure.DataFactory.Factory("example", new()
* {
* Name = "example",
* Location = example.Location,
* ResourceGroupName = example.Name,
* });
* var exampleLinkedServiceAzureSqlDatabase = new Azure.DataFactory.LinkedServiceAzureSqlDatabase("example", new()
* {
* Name = "example",
* DataFactoryId = exampleFactory.Id,
* ConnectionString = "data source=serverhostname;initial catalog=master;user id=testUser;Password=test;integrated security=False;encrypt=True;connection timeout=30",
* });
* });
* ```
* ```go
* package main
* import (
* "github.com/pulumi/pulumi-azure/sdk/v5/go/azure/core"
* "github.com/pulumi/pulumi-azure/sdk/v5/go/azure/datafactory"
* "github.com/pulumi/pulumi/sdk/v3/go/pulumi"
* )
* func main() {
* pulumi.Run(func(ctx *pulumi.Context) error {
* example, err := core.NewResourceGroup(ctx, "example", &core.ResourceGroupArgs{
* Name: pulumi.String("example-resources"),
* Location: pulumi.String("West Europe"),
* })
* if err != nil {
* return err
* }
* exampleFactory, err := datafactory.NewFactory(ctx, "example", &datafactory.FactoryArgs{
* Name: pulumi.String("example"),
* Location: example.Location,
* ResourceGroupName: example.Name,
* })
* if err != nil {
* return err
* }
* _, err = datafactory.NewLinkedServiceAzureSqlDatabase(ctx, "example", &datafactory.LinkedServiceAzureSqlDatabaseArgs{
* Name: pulumi.String("example"),
* DataFactoryId: exampleFactory.ID(),
* ConnectionString: pulumi.String("data source=serverhostname;initial catalog=master;user id=testUser;Password=test;integrated security=False;encrypt=True;connection timeout=30"),
* })
* if err != nil {
* return err
* }
* return nil
* })
* }
* ```
* ```java
* 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.datafactory.Factory;
* import com.pulumi.azure.datafactory.FactoryArgs;
* import com.pulumi.azure.datafactory.LinkedServiceAzureSqlDatabase;
* import com.pulumi.azure.datafactory.LinkedServiceAzureSqlDatabaseArgs;
* 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 example = new ResourceGroup("example", ResourceGroupArgs.builder()
* .name("example-resources")
* .location("West Europe")
* .build());
* var exampleFactory = new Factory("exampleFactory", FactoryArgs.builder()
* .name("example")
* .location(example.location())
* .resourceGroupName(example.name())
* .build());
* var exampleLinkedServiceAzureSqlDatabase = new LinkedServiceAzureSqlDatabase("exampleLinkedServiceAzureSqlDatabase", LinkedServiceAzureSqlDatabaseArgs.builder()
* .name("example")
* .dataFactoryId(exampleFactory.id())
* .connectionString("data source=serverhostname;initial catalog=master;user id=testUser;Password=test;integrated security=False;encrypt=True;connection timeout=30")
* .build());
* }
* }
* ```
* ```yaml
* resources:
* example:
* type: azure:core:ResourceGroup
* properties:
* name: example-resources
* location: West Europe
* exampleFactory:
* type: azure:datafactory:Factory
* name: example
* properties:
* name: example
* location: ${example.location}
* resourceGroupName: ${example.name}
* exampleLinkedServiceAzureSqlDatabase:
* type: azure:datafactory:LinkedServiceAzureSqlDatabase
* name: example
* properties:
* name: example
* dataFactoryId: ${exampleFactory.id}
* connectionString: data source=serverhostname;initial catalog=master;user id=testUser;Password=test;integrated security=False;encrypt=True;connection timeout=30
* ```
*
* ## Import
* Data Factory Azure SQL Database Linked Service's can be imported using the `resource id`, e.g.
* ```sh
* $ pulumi import azure:datafactory/linkedServiceAzureSqlDatabase:LinkedServiceAzureSqlDatabase example /subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/example/providers/Microsoft.DataFactory/factories/example/linkedservices/example
* ```
*/
public class LinkedServiceAzureSqlDatabase internal constructor(
override val javaResource: com.pulumi.azure.datafactory.LinkedServiceAzureSqlDatabase,
) : KotlinCustomResource(javaResource, LinkedServiceAzureSqlDatabaseMapper) {
/**
* A map of additional properties to associate with the Data Factory Linked Service Azure SQL Database.
*/
public val additionalProperties: Output>?
get() = javaResource.additionalProperties().applyValue({ args0 ->
args0.map({ args0 ->
args0.map({ args0 -> args0.key.to(args0.value) }).toMap()
}).orElse(null)
})
/**
* List of tags that can be used for describing the Data Factory Linked Service Azure SQL Database.
*/
public val annotations: Output>?
get() = javaResource.annotations().applyValue({ args0 ->
args0.map({ args0 ->
args0.map({ args0 ->
args0
})
}).orElse(null)
})
/**
* The connection string in which to authenticate with Azure SQL Database. Exactly one of either `connection_string` or `key_vault_connection_string` is required.
*/
public val connectionString: Output?
get() = javaResource.connectionString().applyValue({ args0 ->
args0.map({ args0 ->
args0
}).orElse(null)
})
/**
* The Data Factory ID in which to associate the Linked Service with. Changing this forces a new resource.
*/
public val dataFactoryId: Output
get() = javaResource.dataFactoryId().applyValue({ args0 -> args0 })
/**
* The description for the Data Factory Linked Service Azure SQL Database.
*/
public val description: Output?
get() = javaResource.description().applyValue({ args0 ->
args0.map({ args0 ->
args0
}).orElse(null)
})
/**
* The integration runtime reference to associate with the Data Factory Linked Service Azure SQL Database.
*/
public val integrationRuntimeName: Output?
get() = javaResource.integrationRuntimeName().applyValue({ args0 ->
args0.map({ args0 ->
args0
}).orElse(null)
})
/**
* A `key_vault_connection_string` block as defined below. Use this argument to store Azure SQL Database connection string in an existing Key Vault. It needs an existing Key Vault Data Factory Linked Service. Exactly one of either `connection_string` or `key_vault_connection_string` is required.
*/
public val keyVaultConnectionString:
Output?
get() = javaResource.keyVaultConnectionString().applyValue({ args0 ->
args0.map({ args0 ->
args0.let({ args0 ->
linkedServiceAzureSqlDatabaseKeyVaultConnectionStringToKotlin(args0)
})
}).orElse(null)
})
/**
* A `key_vault_password` block as defined below. Use this argument to store SQL Server password in an existing Key Vault. It needs an existing Key Vault Data Factory Linked Service.
*/
public val keyVaultPassword: Output?
get() = javaResource.keyVaultPassword().applyValue({ args0 ->
args0.map({ args0 ->
args0.let({ args0 ->
linkedServiceAzureSqlDatabaseKeyVaultPasswordToKotlin(args0)
})
}).orElse(null)
})
/**
* Specifies the name of the Data Factory Linked Service Azure SQL Database. Changing this forces a new resource to be created. Must be unique within a data factory. See the [Microsoft documentation](https://docs.microsoft.com/azure/data-factory/naming-rules) for all restrictions.
*/
public val name: Output
get() = javaResource.name().applyValue({ args0 -> args0 })
/**
* A map of parameters to associate with the Data Factory Linked Service Azure SQL Database.
*/
public val parameters: Output>?
get() = javaResource.parameters().applyValue({ args0 ->
args0.map({ args0 ->
args0.map({ args0 ->
args0.key.to(args0.value)
}).toMap()
}).orElse(null)
})
/**
* The service principal id in which to authenticate against the Azure SQL Database. Required if `service_principal_key` is set.
*/
public val servicePrincipalId: Output?
get() = javaResource.servicePrincipalId().applyValue({ args0 ->
args0.map({ args0 ->
args0
}).orElse(null)
})
/**
* The service principal key in which to authenticate against the Azure SQL Database. Required if `service_principal_id` is set.
*/
public val servicePrincipalKey: Output?
get() = javaResource.servicePrincipalKey().applyValue({ args0 ->
args0.map({ args0 ->
args0
}).orElse(null)
})
/**
* The tenant id or name in which to authenticate against the Azure SQL Database.
*/
public val tenantId: Output?
get() = javaResource.tenantId().applyValue({ args0 -> args0.map({ args0 -> args0 }).orElse(null) })
/**
* Whether to use the Data Factory's managed identity to authenticate against the Azure SQL Database. Incompatible with `service_principal_id` and `service_principal_key`
*/
public val useManagedIdentity: Output?
get() = javaResource.useManagedIdentity().applyValue({ args0 ->
args0.map({ args0 ->
args0
}).orElse(null)
})
}
public object LinkedServiceAzureSqlDatabaseMapper : ResourceMapper {
override fun supportsMappingOfType(javaResource: Resource): Boolean =
com.pulumi.azure.datafactory.LinkedServiceAzureSqlDatabase::class == javaResource::class
override fun map(javaResource: Resource): LinkedServiceAzureSqlDatabase =
LinkedServiceAzureSqlDatabase(
javaResource as
com.pulumi.azure.datafactory.LinkedServiceAzureSqlDatabase,
)
}
/**
* @see [LinkedServiceAzureSqlDatabase].
* @param name The _unique_ name of the resulting resource.
* @param block Builder for [LinkedServiceAzureSqlDatabase].
*/
public suspend fun linkedServiceAzureSqlDatabase(
name: String,
block: suspend LinkedServiceAzureSqlDatabaseResourceBuilder.() -> Unit,
): LinkedServiceAzureSqlDatabase {
val builder = LinkedServiceAzureSqlDatabaseResourceBuilder()
builder.name(name)
block(builder)
return builder.build()
}
/**
* @see [LinkedServiceAzureSqlDatabase].
* @param name The _unique_ name of the resulting resource.
*/
public fun linkedServiceAzureSqlDatabase(name: String): LinkedServiceAzureSqlDatabase {
val builder = LinkedServiceAzureSqlDatabaseResourceBuilder()
builder.name(name)
return builder.build()
}
