pulumi-azure-native-kotlin/com.pulumi.azurenative.azurearcdata.kotlin/SqlManagedInstanceArgs

SqlManagedInstanceArgs

data class SqlManagedInstanceArgs(val extendedLocation: Output<ExtendedLocationArgs>? = null, val location: Output<String>? = null, val properties: Output<SqlManagedInstancePropertiesArgs>? = null, val resourceGroupName: Output<String>? = null, val sku: Output<SqlManagedInstanceSkuArgs>? = null, val sqlManagedInstanceName: Output<String>? = null, val tags: Output<Map<String, String>>? = null) : ConvertibleToJava<SqlManagedInstanceArgs>

A SqlManagedInstance. Azure REST API version: 2023-01-15-preview. Prior API version in Azure Native 1.x: 2021-06-01-preview.

Example Usage

Create or update a SQL Managed Instance

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using AzureNative = Pulumi.AzureNative;
return await Deployment.RunAsync(() =>
{
    var sqlManagedInstance = new AzureNative.AzureArcData.SqlManagedInstance("sqlManagedInstance", new()
    {
        ExtendedLocation = new AzureNative.AzureArcData.Inputs.ExtendedLocationArgs
        {
            Name = "/subscriptions/00000000-1111-2222-3333-444444444444/resourceGroups/testrg/providers/Microsoft.ExtendedLocation/customLocations/arclocation",
            Type = "CustomLocation",
        },
        Location = "northeurope",
        Properties = new AzureNative.AzureArcData.Inputs.SqlManagedInstancePropertiesArgs
        {
            ActiveDirectoryInformation = new AzureNative.AzureArcData.Inputs.ActiveDirectoryInformationArgs
            {
                KeytabInformation = new AzureNative.AzureArcData.Inputs.KeytabInformationArgs
                {
                    Keytab = "********",
                },
            },
            Admin = "Admin user",
            BasicLoginInformation = new AzureNative.AzureArcData.Inputs.BasicLoginInformationArgs
            {
                Password = "********",
                Username = "username",
            },
            ClusterId = "/subscriptions/00000000-1111-2222-3333-444444444444/resourceGroups/testrg/providers/Microsoft.Kubernetes/connectedClusters/connectedk8s",
            EndTime = "Instance end time",
            ExtensionId = "/subscriptions/00000000-1111-2222-3333-444444444444/resourceGroups/testrg/providers/Microsoft.Kubernetes/connectedClusters/connectedk8s/providers/Microsoft.KubernetesConfiguration/extensions/extension",
            K8sRaw = new AzureNative.AzureArcData.Inputs.SqlManagedInstanceK8sRawArgs
            {
                Spec = new AzureNative.AzureArcData.Inputs.SqlManagedInstanceK8sSpecArgs
                {
                    Replicas = 1,
                    Scheduling = new AzureNative.AzureArcData.Inputs.K8sSchedulingArgs
                    {
                        Default = new AzureNative.AzureArcData.Inputs.K8sSchedulingOptionsArgs
                        {
                            Resources = new AzureNative.AzureArcData.Inputs.K8sResourceRequirementsArgs
                            {
                                Limits =
                                {
                                    { "additionalProperty", "additionalValue" },
                                    { "cpu", "1" },
                                    { "memory", "8Gi" },
                                },
                                Requests =
                                {
                                    { "additionalProperty", "additionalValue" },
                                    { "cpu", "1" },
                                    { "memory", "8Gi" },
                                },
                            },
                        },
                    },
                    Security = new AzureNative.AzureArcData.Inputs.K8sSecurityArgs
                    {
                        ActiveDirectory = new AzureNative.AzureArcData.Inputs.K8sActiveDirectoryArgs
                        {
                            AccountName = "Account name",
                            Connector = new AzureNative.AzureArcData.Inputs.K8sActiveDirectoryConnectorArgs
                            {
                                Name = "Name of connector",
                                Namespace = "Namespace of connector",
                            },
                            EncryptionTypes = new[]
                            {
                                "Encryption type item1, Encryption type item2,...",
                            },
                            KeytabSecret = "Key tab secret of account",
                        },
                        AdminLoginSecret = "test-sql-login-secret",
                        ServiceCertificateSecret = "Service Certificate Secret",
                        TransparentDataEncryption = new AzureNative.AzureArcData.Inputs.K8stransparentDataEncryptionArgs
                        {
                            Mode = "SystemManaged",
                        },
                    },
                    Settings = new AzureNative.AzureArcData.Inputs.K8sSettingsArgs
                    {
                        Network = new AzureNative.AzureArcData.Inputs.K8sNetworkSettingsArgs
                        {
                            Forceencryption = 0,
                            Tlsciphers = "ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES128-GCM-SHA256:ECDHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-AES128-SHA256:ECDHE-ECDSA-AES256-SHA384:ECDHE-RSA-AES128-SHA256:ECDHE-RSA-AES256-SHA384",
                            Tlsprotocols = "1.2",
                        },
                    },
                },
            },
            LicenseType = "LicenseIncluded",
            StartTime = "Instance start time",
        },
        ResourceGroupName = "testrg",
        Sku = new AzureNative.AzureArcData.Inputs.SqlManagedInstanceSkuArgs
        {
            Dev = true,
            Name = AzureNative.AzureArcData.SqlManagedInstanceSkuName.VCore,
            Tier = AzureNative.AzureArcData.SqlManagedInstanceSkuTier.GeneralPurpose,
        },
        SqlManagedInstanceName = "testsqlManagedInstance",
        Tags =
        {
            { "mytag", "myval" },
        },
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-azure-native-sdk/azurearcdata/v2"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
pulumi.Run(func(ctx *pulumi.Context) error {
_, err := azurearcdata.NewSqlManagedInstance(ctx, "sqlManagedInstance", &azurearcdata.SqlManagedInstanceArgs{
ExtendedLocation: &azurearcdata.ExtendedLocationArgs{
Name: pulumi.String("/subscriptions/00000000-1111-2222-3333-444444444444/resourceGroups/testrg/providers/Microsoft.ExtendedLocation/customLocations/arclocation"),
Type: pulumi.String("CustomLocation"),
},
Location: pulumi.String("northeurope"),
Properties: azurearcdata.SqlManagedInstancePropertiesResponse{
ActiveDirectoryInformation: &azurearcdata.ActiveDirectoryInformationArgs{
KeytabInformation: &azurearcdata.KeytabInformationArgs{
Keytab: pulumi.String("********"),
},
},
Admin: pulumi.String("Admin user"),
BasicLoginInformation: &azurearcdata.BasicLoginInformationArgs{
Password: pulumi.String("********"),
Username: pulumi.String("username"),
},
ClusterId: pulumi.String("/subscriptions/00000000-1111-2222-3333-444444444444/resourceGroups/testrg/providers/Microsoft.Kubernetes/connectedClusters/connectedk8s"),
EndTime: pulumi.String("Instance end time"),
ExtensionId: pulumi.String("/subscriptions/00000000-1111-2222-3333-444444444444/resourceGroups/testrg/providers/Microsoft.Kubernetes/connectedClusters/connectedk8s/providers/Microsoft.KubernetesConfiguration/extensions/extension"),
K8sRaw: interface{}{
Spec: interface{}{
Replicas: pulumi.Int(1),
Scheduling: interface{}{
Default: interface{}{
Resources: &azurearcdata.K8sResourceRequirementsArgs{
Limits: pulumi.StringMap{
"additionalProperty": pulumi.String("additionalValue"),
"cpu": pulumi.String("1"),
"memory": pulumi.String("8Gi"),
},
Requests: pulumi.StringMap{
"additionalProperty": pulumi.String("additionalValue"),
"cpu": pulumi.String("1"),
"memory": pulumi.String("8Gi"),
},
},
},
},
Security: interface{}{
ActiveDirectory: interface{}{
AccountName: pulumi.String("Account name"),
Connector: &azurearcdata.K8sActiveDirectoryConnectorArgs{
Name: pulumi.String("Name of connector"),
Namespace: pulumi.String("Namespace of connector"),
},
EncryptionTypes: pulumi.StringArray{
pulumi.String("Encryption type item1, Encryption type item2,..."),
},
KeytabSecret: pulumi.String("Key tab secret of account"),
},
AdminLoginSecret: pulumi.String("test-sql-login-secret"),
ServiceCertificateSecret: pulumi.String("Service Certificate Secret"),
TransparentDataEncryption: &azurearcdata.K8stransparentDataEncryptionArgs{
Mode: pulumi.String("SystemManaged"),
},
},
Settings: interface{}{
Network: &azurearcdata.K8sNetworkSettingsArgs{
Forceencryption: pulumi.Int(0),
Tlsciphers: pulumi.String("ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES128-GCM-SHA256:ECDHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-AES128-SHA256:ECDHE-ECDSA-AES256-SHA384:ECDHE-RSA-AES128-SHA256:ECDHE-RSA-AES256-SHA384"),
Tlsprotocols: pulumi.String("1.2"),
},
},
},
},
LicenseType: pulumi.String("LicenseIncluded"),
StartTime: pulumi.String("Instance start time"),
},
ResourceGroupName: pulumi.String("testrg"),
Sku: &azurearcdata.SqlManagedInstanceSkuArgs{
Dev: pulumi.Bool(true),
Name: azurearcdata.SqlManagedInstanceSkuNameVCore,
Tier: azurearcdata.SqlManagedInstanceSkuTierGeneralPurpose,
},
SqlManagedInstanceName: pulumi.String("testsqlManagedInstance"),
Tags: pulumi.StringMap{
"mytag": pulumi.String("myval"),
},
})
if err != nil {
return err
}
return nil
})
}
Content copied to clipboard
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.azurearcdata.SqlManagedInstance;
import com.pulumi.azurenative.azurearcdata.SqlManagedInstanceArgs;
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 sqlManagedInstance = new SqlManagedInstance("sqlManagedInstance", SqlManagedInstanceArgs.builder()
            .extendedLocation(Map.ofEntries(
                Map.entry("name", "/subscriptions/00000000-1111-2222-3333-444444444444/resourceGroups/testrg/providers/Microsoft.ExtendedLocation/customLocations/arclocation"),
                Map.entry("type", "CustomLocation")
            ))
            .location("northeurope")
            .properties(Map.ofEntries(
                Map.entry("activeDirectoryInformation", Map.of("keytabInformation", Map.of("keytab", "********"))),
                Map.entry("admin", "Admin user"),
                Map.entry("basicLoginInformation", Map.ofEntries(
                    Map.entry("password", "********"),
                    Map.entry("username", "username")
                )),
                Map.entry("clusterId", "/subscriptions/00000000-1111-2222-3333-444444444444/resourceGroups/testrg/providers/Microsoft.Kubernetes/connectedClusters/connectedk8s"),
                Map.entry("endTime", "Instance end time"),
                Map.entry("extensionId", "/subscriptions/00000000-1111-2222-3333-444444444444/resourceGroups/testrg/providers/Microsoft.Kubernetes/connectedClusters/connectedk8s/providers/Microsoft.KubernetesConfiguration/extensions/extension"),
                Map.entry("k8sRaw", Map.of("spec", Map.ofEntries(
                    Map.entry("replicas", 1),
                    Map.entry("scheduling", Map.of("default", Map.of("resources", Map.ofEntries(
                        Map.entry("limits", Map.ofEntries(
                            Map.entry("additionalProperty", "additionalValue"),
                            Map.entry("cpu", "1"),
                            Map.entry("memory", "8Gi")
                        )),
                        Map.entry("requests", Map.ofEntries(
                            Map.entry("additionalProperty", "additionalValue"),
                            Map.entry("cpu", "1"),
                            Map.entry("memory", "8Gi")
                        ))
                    )))),
                    Map.entry("security", Map.ofEntries(
                        Map.entry("activeDirectory", Map.ofEntries(
                            Map.entry("accountName", "Account name"),
                            Map.entry("connector", Map.ofEntries(
                                Map.entry("name", "Name of connector"),
                                Map.entry("namespace", "Namespace of connector")
                            )),
                            Map.entry("encryptionTypes", "Encryption type item1, Encryption type item2,..."),
                            Map.entry("keytabSecret", "Key tab secret of account")
                        )),
                        Map.entry("adminLoginSecret", "test-sql-login-secret"),
                        Map.entry("serviceCertificateSecret", "Service Certificate Secret"),
                        Map.entry("transparentDataEncryption", Map.of("mode", "SystemManaged"))
                    )),
                    Map.entry("settings", Map.of("network", Map.ofEntries(
                        Map.entry("forceencryption", 0),
                        Map.entry("tlsciphers", "ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES128-GCM-SHA256:ECDHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-AES128-SHA256:ECDHE-ECDSA-AES256-SHA384:ECDHE-RSA-AES128-SHA256:ECDHE-RSA-AES256-SHA384"),
                        Map.entry("tlsprotocols", "1.2")
                    )))
                ))),
                Map.entry("licenseType", "LicenseIncluded"),
                Map.entry("startTime", "Instance start time")
            ))
            .resourceGroupName("testrg")
            .sku(Map.ofEntries(
                Map.entry("dev", true),
                Map.entry("name", "vCore"),
                Map.entry("tier", "GeneralPurpose")
            ))
            .sqlManagedInstanceName("testsqlManagedInstance")
            .tags(Map.of("mytag", "myval"))
            .build());
    }
}
Content copied to clipboard

Import

An existing resource can be imported using its type token, name, and identifier, e.g.

$ pulumi import azure-native:azurearcdata:SqlManagedInstance testsqlManagedInstance /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.AzureArcData/sqlManagedInstances/{sqlManagedInstanceName}
Content copied to clipboard

Constructors

Link copied to clipboard
fun SqlManagedInstanceArgs(extendedLocation: Output<ExtendedLocationArgs>? = null, location: Output<String>? = null, properties: Output<SqlManagedInstancePropertiesArgs>? = null, resourceGroupName: Output<String>? = null, sku: Output<SqlManagedInstanceSkuArgs>? = null, sqlManagedInstanceName: Output<String>? = null, tags: Output<Map<String, String>>? = null)

Functions

Link copied to clipboard
open override fun toJava(): SqlManagedInstanceArgs

Properties

Link copied to clipboard
val extendedLocation: Output<ExtendedLocationArgs>? = null

The extendedLocation of the resource.

Link copied to clipboard
val location: Output<String>? = null

The geo-location where the resource lives

Link copied to clipboard
val properties: Output<SqlManagedInstancePropertiesArgs>? = null

null

Link copied to clipboard
val resourceGroupName: Output<String>? = null

The name of the Azure resource group

Link copied to clipboard
val sku: Output<SqlManagedInstanceSkuArgs>? = null

Resource sku.

Link copied to clipboard
val sqlManagedInstanceName: Output<String>? = null

Name of SQL Managed Instance

Link copied to clipboard
val tags: Output<Map<String, String>>? = null

Resource tags.