tencentcloud.SqlserverMigration

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

const zones = tencentcloud.getAvailabilityZonesByProduct({
    product: "sqlserver",
});
const vpc = new tencentcloud.Vpc("vpc", {cidrBlock: "10.0.0.0/16"});
const subnet = new tencentcloud.Subnet("subnet", {
    availabilityZone: zones.then(zones => zones.zones?.[4]?.name),
    vpcId: vpc.vpcId,
    cidrBlock: "10.0.0.0/16",
    isMulticast: false,
});
const securityGroup = new tencentcloud.SecurityGroup("securityGroup", {description: "desc."});
const srcExample = new tencentcloud.SqlserverBasicInstance("srcExample", {
    availabilityZone: zones.then(zones => zones.zones?.[4]?.name),
    chargeType: "POSTPAID_BY_HOUR",
    vpcId: vpc.vpcId,
    subnetId: subnet.subnetId,
    projectId: 0,
    memory: 4,
    storage: 100,
    cpu: 2,
    machineType: "CLOUD_PREMIUM",
    maintenanceWeekSets: [
        1,
        2,
        3,
    ],
    maintenanceStartTime: "09:00",
    maintenanceTimeSpan: 3,
    securityGroups: [securityGroup.securityGroupId],
    tags: {
        test: "test",
    },
});
const dstExample = new tencentcloud.SqlserverBasicInstance("dstExample", {
    availabilityZone: zones.then(zones => zones.zones?.[4]?.name),
    chargeType: "POSTPAID_BY_HOUR",
    vpcId: vpc.vpcId,
    subnetId: subnet.subnetId,
    projectId: 0,
    memory: 4,
    storage: 100,
    cpu: 2,
    machineType: "CLOUD_PREMIUM",
    maintenanceWeekSets: [
        1,
        2,
        3,
    ],
    maintenanceStartTime: "09:00",
    maintenanceTimeSpan: 3,
    securityGroups: [securityGroup.securityGroupId],
    tags: {
        test: "test",
    },
});
const srcSqlserverDb = new tencentcloud.SqlserverDb("srcSqlserverDb", {
    instanceId: srcExample.sqlserverBasicInstanceId,
    charset: "Chinese_PRC_BIN",
    remark: "testACC-remark",
});
const dstSqlserverDb = new tencentcloud.SqlserverDb("dstSqlserverDb", {
    instanceId: dstExample.sqlserverBasicInstanceId,
    charset: "Chinese_PRC_BIN",
    remark: "testACC-remark",
});
const srcSqlserverAccount = new tencentcloud.SqlserverAccount("srcSqlserverAccount", {
    instanceId: srcExample.sqlserverBasicInstanceId,
    password: "Qwer@234",
    isAdmin: true,
});
const dstSqlserverAccount = new tencentcloud.SqlserverAccount("dstSqlserverAccount", {
    instanceId: dstExample.sqlserverBasicInstanceId,
    password: "Qwer@234",
    isAdmin: true,
});
const srcSqlserverAccountDbAttachment = new tencentcloud.SqlserverAccountDbAttachment("srcSqlserverAccountDbAttachment", {
    instanceId: srcExample.sqlserverBasicInstanceId,
    accountName: srcSqlserverAccount.name,
    dbName: srcSqlserverDb.name,
    privilege: "ReadWrite",
});
const dstSqlserverAccountDbAttachment = new tencentcloud.SqlserverAccountDbAttachment("dstSqlserverAccountDbAttachment", {
    instanceId: dstExample.sqlserverBasicInstanceId,
    accountName: dstSqlserverAccount.name,
    dbName: dstSqlserverDb.name,
    privilege: "ReadWrite",
});
const migration = new tencentcloud.SqlserverMigration("migration", {
    migrateName: "tf_test_migration",
    migrateType: 1,
    sourceType: 1,
    source: {
        instanceId: srcExample.sqlserverBasicInstanceId,
        userName: srcSqlserverAccount.name,
        password: srcSqlserverAccount.password,
    },
    target: {
        instanceId: dstExample.sqlserverBasicInstanceId,
        userName: dstSqlserverAccount.name,
        password: dstSqlserverAccount.password,
    },
    migrateDbSets: [{
        dbName: srcSqlserverDb.name,
    }],
});

import pulumi
import pulumi_tencentcloud as tencentcloud

zones = tencentcloud.get_availability_zones_by_product(product="sqlserver")
vpc = tencentcloud.Vpc("vpc", cidr_block="10.0.0.0/16")
subnet = tencentcloud.Subnet("subnet",
    availability_zone=zones.zones[4].name,
    vpc_id=vpc.vpc_id,
    cidr_block="10.0.0.0/16",
    is_multicast=False)
security_group = tencentcloud.SecurityGroup("securityGroup", description="desc.")
src_example = tencentcloud.SqlserverBasicInstance("srcExample",
    availability_zone=zones.zones[4].name,
    charge_type="POSTPAID_BY_HOUR",
    vpc_id=vpc.vpc_id,
    subnet_id=subnet.subnet_id,
    project_id=0,
    memory=4,
    storage=100,
    cpu=2,
    machine_type="CLOUD_PREMIUM",
    maintenance_week_sets=[
        1,
        2,
        3,
    ],
    maintenance_start_time="09:00",
    maintenance_time_span=3,
    security_groups=[security_group.security_group_id],
    tags={
        "test": "test",
    })
dst_example = tencentcloud.SqlserverBasicInstance("dstExample",
    availability_zone=zones.zones[4].name,
    charge_type="POSTPAID_BY_HOUR",
    vpc_id=vpc.vpc_id,
    subnet_id=subnet.subnet_id,
    project_id=0,
    memory=4,
    storage=100,
    cpu=2,
    machine_type="CLOUD_PREMIUM",
    maintenance_week_sets=[
        1,
        2,
        3,
    ],
    maintenance_start_time="09:00",
    maintenance_time_span=3,
    security_groups=[security_group.security_group_id],
    tags={
        "test": "test",
    })
src_sqlserver_db = tencentcloud.SqlserverDb("srcSqlserverDb",
    instance_id=src_example.sqlserver_basic_instance_id,
    charset="Chinese_PRC_BIN",
    remark="testACC-remark")
dst_sqlserver_db = tencentcloud.SqlserverDb("dstSqlserverDb",
    instance_id=dst_example.sqlserver_basic_instance_id,
    charset="Chinese_PRC_BIN",
    remark="testACC-remark")
src_sqlserver_account = tencentcloud.SqlserverAccount("srcSqlserverAccount",
    instance_id=src_example.sqlserver_basic_instance_id,
    password="Qwer@234",
    is_admin=True)
dst_sqlserver_account = tencentcloud.SqlserverAccount("dstSqlserverAccount",
    instance_id=dst_example.sqlserver_basic_instance_id,
    password="Qwer@234",
    is_admin=True)
src_sqlserver_account_db_attachment = tencentcloud.SqlserverAccountDbAttachment("srcSqlserverAccountDbAttachment",
    instance_id=src_example.sqlserver_basic_instance_id,
    account_name=src_sqlserver_account.name,
    db_name=src_sqlserver_db.name,
    privilege="ReadWrite")
dst_sqlserver_account_db_attachment = tencentcloud.SqlserverAccountDbAttachment("dstSqlserverAccountDbAttachment",
    instance_id=dst_example.sqlserver_basic_instance_id,
    account_name=dst_sqlserver_account.name,
    db_name=dst_sqlserver_db.name,
    privilege="ReadWrite")
migration = tencentcloud.SqlserverMigration("migration",
    migrate_name="tf_test_migration",
    migrate_type=1,
    source_type=1,
    source={
        "instance_id": src_example.sqlserver_basic_instance_id,
        "user_name": src_sqlserver_account.name,
        "password": src_sqlserver_account.password,
    },
    target={
        "instance_id": dst_example.sqlserver_basic_instance_id,
        "user_name": dst_sqlserver_account.name,
        "password": dst_sqlserver_account.password,
    },
    migrate_db_sets=[{
        "db_name": src_sqlserver_db.name,
    }])

package main

import (
	"github.com/pulumi/pulumi-terraform-provider/sdks/go/tencentcloud/tencentcloud"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		zones, err := tencentcloud.GetAvailabilityZonesByProduct(ctx, &tencentcloud.GetAvailabilityZonesByProductArgs{
			Product: "sqlserver",
		}, nil)
		if err != nil {
			return err
		}
		vpc, err := tencentcloud.NewVpc(ctx, "vpc", &tencentcloud.VpcArgs{
			CidrBlock: pulumi.String("10.0.0.0/16"),
		})
		if err != nil {
			return err
		}
		subnet, err := tencentcloud.NewSubnet(ctx, "subnet", &tencentcloud.SubnetArgs{
			AvailabilityZone: pulumi.String(zones.Zones[4].Name),
			VpcId:            vpc.VpcId,
			CidrBlock:        pulumi.String("10.0.0.0/16"),
			IsMulticast:      pulumi.Bool(false),
		})
		if err != nil {
			return err
		}
		securityGroup, err := tencentcloud.NewSecurityGroup(ctx, "securityGroup", &tencentcloud.SecurityGroupArgs{
			Description: pulumi.String("desc."),
		})
		if err != nil {
			return err
		}
		srcExample, err := tencentcloud.NewSqlserverBasicInstance(ctx, "srcExample", &tencentcloud.SqlserverBasicInstanceArgs{
			AvailabilityZone: pulumi.String(zones.Zones[4].Name),
			ChargeType:       pulumi.String("POSTPAID_BY_HOUR"),
			VpcId:            vpc.VpcId,
			SubnetId:         subnet.SubnetId,
			ProjectId:        pulumi.Float64(0),
			Memory:           pulumi.Float64(4),
			Storage:          pulumi.Float64(100),
			Cpu:              pulumi.Float64(2),
			MachineType:      pulumi.String("CLOUD_PREMIUM"),
			MaintenanceWeekSets: pulumi.Float64Array{
				pulumi.Float64(1),
				pulumi.Float64(2),
				pulumi.Float64(3),
			},
			MaintenanceStartTime: pulumi.String("09:00"),
			MaintenanceTimeSpan:  pulumi.Float64(3),
			SecurityGroups: pulumi.StringArray{
				securityGroup.SecurityGroupId,
			},
			Tags: pulumi.StringMap{
				"test": pulumi.String("test"),
			},
		})
		if err != nil {
			return err
		}
		dstExample, err := tencentcloud.NewSqlserverBasicInstance(ctx, "dstExample", &tencentcloud.SqlserverBasicInstanceArgs{
			AvailabilityZone: pulumi.String(zones.Zones[4].Name),
			ChargeType:       pulumi.String("POSTPAID_BY_HOUR"),
			VpcId:            vpc.VpcId,
			SubnetId:         subnet.SubnetId,
			ProjectId:        pulumi.Float64(0),
			Memory:           pulumi.Float64(4),
			Storage:          pulumi.Float64(100),
			Cpu:              pulumi.Float64(2),
			MachineType:      pulumi.String("CLOUD_PREMIUM"),
			MaintenanceWeekSets: pulumi.Float64Array{
				pulumi.Float64(1),
				pulumi.Float64(2),
				pulumi.Float64(3),
			},
			MaintenanceStartTime: pulumi.String("09:00"),
			MaintenanceTimeSpan:  pulumi.Float64(3),
			SecurityGroups: pulumi.StringArray{
				securityGroup.SecurityGroupId,
			},
			Tags: pulumi.StringMap{
				"test": pulumi.String("test"),
			},
		})
		if err != nil {
			return err
		}
		srcSqlserverDb, err := tencentcloud.NewSqlserverDb(ctx, "srcSqlserverDb", &tencentcloud.SqlserverDbArgs{
			InstanceId: srcExample.SqlserverBasicInstanceId,
			Charset:    pulumi.String("Chinese_PRC_BIN"),
			Remark:     pulumi.String("testACC-remark"),
		})
		if err != nil {
			return err
		}
		dstSqlserverDb, err := tencentcloud.NewSqlserverDb(ctx, "dstSqlserverDb", &tencentcloud.SqlserverDbArgs{
			InstanceId: dstExample.SqlserverBasicInstanceId,
			Charset:    pulumi.String("Chinese_PRC_BIN"),
			Remark:     pulumi.String("testACC-remark"),
		})
		if err != nil {
			return err
		}
		srcSqlserverAccount, err := tencentcloud.NewSqlserverAccount(ctx, "srcSqlserverAccount", &tencentcloud.SqlserverAccountArgs{
			InstanceId: srcExample.SqlserverBasicInstanceId,
			Password:   pulumi.String("Qwer@234"),
			IsAdmin:    pulumi.Bool(true),
		})
		if err != nil {
			return err
		}
		dstSqlserverAccount, err := tencentcloud.NewSqlserverAccount(ctx, "dstSqlserverAccount", &tencentcloud.SqlserverAccountArgs{
			InstanceId: dstExample.SqlserverBasicInstanceId,
			Password:   pulumi.String("Qwer@234"),
			IsAdmin:    pulumi.Bool(true),
		})
		if err != nil {
			return err
		}
		_, err = tencentcloud.NewSqlserverAccountDbAttachment(ctx, "srcSqlserverAccountDbAttachment", &tencentcloud.SqlserverAccountDbAttachmentArgs{
			InstanceId:  srcExample.SqlserverBasicInstanceId,
			AccountName: srcSqlserverAccount.Name,
			DbName:      srcSqlserverDb.Name,
			Privilege:   pulumi.String("ReadWrite"),
		})
		if err != nil {
			return err
		}
		_, err = tencentcloud.NewSqlserverAccountDbAttachment(ctx, "dstSqlserverAccountDbAttachment", &tencentcloud.SqlserverAccountDbAttachmentArgs{
			InstanceId:  dstExample.SqlserverBasicInstanceId,
			AccountName: dstSqlserverAccount.Name,
			DbName:      dstSqlserverDb.Name,
			Privilege:   pulumi.String("ReadWrite"),
		})
		if err != nil {
			return err
		}
		_, err = tencentcloud.NewSqlserverMigration(ctx, "migration", &tencentcloud.SqlserverMigrationArgs{
			MigrateName: pulumi.String("tf_test_migration"),
			MigrateType: pulumi.Float64(1),
			SourceType:  pulumi.Float64(1),
			Source: &tencentcloud.SqlserverMigrationSourceArgs{
				InstanceId: srcExample.SqlserverBasicInstanceId,
				UserName:   srcSqlserverAccount.Name,
				Password:   srcSqlserverAccount.Password,
			},
			Target: &tencentcloud.SqlserverMigrationTargetArgs{
				InstanceId: dstExample.SqlserverBasicInstanceId,
				UserName:   dstSqlserverAccount.Name,
				Password:   dstSqlserverAccount.Password,
			},
			MigrateDbSets: tencentcloud.SqlserverMigrationMigrateDbSetArray{
				&tencentcloud.SqlserverMigrationMigrateDbSetArgs{
					DbName: srcSqlserverDb.Name,
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var zones = Tencentcloud.GetAvailabilityZonesByProduct.Invoke(new()
    {
        Product = "sqlserver",
    });

    var vpc = new Tencentcloud.Vpc("vpc", new()
    {
        CidrBlock = "10.0.0.0/16",
    });

    var subnet = new Tencentcloud.Subnet("subnet", new()
    {
        AvailabilityZone = zones.Apply(getAvailabilityZonesByProductResult => getAvailabilityZonesByProductResult.Zones[4]?.Name),
        VpcId = vpc.VpcId,
        CidrBlock = "10.0.0.0/16",
        IsMulticast = false,
    });

    var securityGroup = new Tencentcloud.SecurityGroup("securityGroup", new()
    {
        Description = "desc.",
    });

    var srcExample = new Tencentcloud.SqlserverBasicInstance("srcExample", new()
    {
        AvailabilityZone = zones.Apply(getAvailabilityZonesByProductResult => getAvailabilityZonesByProductResult.Zones[4]?.Name),
        ChargeType = "POSTPAID_BY_HOUR",
        VpcId = vpc.VpcId,
        SubnetId = subnet.SubnetId,
        ProjectId = 0,
        Memory = 4,
        Storage = 100,
        Cpu = 2,
        MachineType = "CLOUD_PREMIUM",
        MaintenanceWeekSets = new[]
        {
            1,
            2,
            3,
        },
        MaintenanceStartTime = "09:00",
        MaintenanceTimeSpan = 3,
        SecurityGroups = new[]
        {
            securityGroup.SecurityGroupId,
        },
        Tags = 
        {
            { "test", "test" },
        },
    });

    var dstExample = new Tencentcloud.SqlserverBasicInstance("dstExample", new()
    {
        AvailabilityZone = zones.Apply(getAvailabilityZonesByProductResult => getAvailabilityZonesByProductResult.Zones[4]?.Name),
        ChargeType = "POSTPAID_BY_HOUR",
        VpcId = vpc.VpcId,
        SubnetId = subnet.SubnetId,
        ProjectId = 0,
        Memory = 4,
        Storage = 100,
        Cpu = 2,
        MachineType = "CLOUD_PREMIUM",
        MaintenanceWeekSets = new[]
        {
            1,
            2,
            3,
        },
        MaintenanceStartTime = "09:00",
        MaintenanceTimeSpan = 3,
        SecurityGroups = new[]
        {
            securityGroup.SecurityGroupId,
        },
        Tags = 
        {
            { "test", "test" },
        },
    });

    var srcSqlserverDb = new Tencentcloud.SqlserverDb("srcSqlserverDb", new()
    {
        InstanceId = srcExample.SqlserverBasicInstanceId,
        Charset = "Chinese_PRC_BIN",
        Remark = "testACC-remark",
    });

    var dstSqlserverDb = new Tencentcloud.SqlserverDb("dstSqlserverDb", new()
    {
        InstanceId = dstExample.SqlserverBasicInstanceId,
        Charset = "Chinese_PRC_BIN",
        Remark = "testACC-remark",
    });

    var srcSqlserverAccount = new Tencentcloud.SqlserverAccount("srcSqlserverAccount", new()
    {
        InstanceId = srcExample.SqlserverBasicInstanceId,
        Password = "Qwer@234",
        IsAdmin = true,
    });

    var dstSqlserverAccount = new Tencentcloud.SqlserverAccount("dstSqlserverAccount", new()
    {
        InstanceId = dstExample.SqlserverBasicInstanceId,
        Password = "Qwer@234",
        IsAdmin = true,
    });

    var srcSqlserverAccountDbAttachment = new Tencentcloud.SqlserverAccountDbAttachment("srcSqlserverAccountDbAttachment", new()
    {
        InstanceId = srcExample.SqlserverBasicInstanceId,
        AccountName = srcSqlserverAccount.Name,
        DbName = srcSqlserverDb.Name,
        Privilege = "ReadWrite",
    });

    var dstSqlserverAccountDbAttachment = new Tencentcloud.SqlserverAccountDbAttachment("dstSqlserverAccountDbAttachment", new()
    {
        InstanceId = dstExample.SqlserverBasicInstanceId,
        AccountName = dstSqlserverAccount.Name,
        DbName = dstSqlserverDb.Name,
        Privilege = "ReadWrite",
    });

    var migration = new Tencentcloud.SqlserverMigration("migration", new()
    {
        MigrateName = "tf_test_migration",
        MigrateType = 1,
        SourceType = 1,
        Source = new Tencentcloud.Inputs.SqlserverMigrationSourceArgs
        {
            InstanceId = srcExample.SqlserverBasicInstanceId,
            UserName = srcSqlserverAccount.Name,
            Password = srcSqlserverAccount.Password,
        },
        Target = new Tencentcloud.Inputs.SqlserverMigrationTargetArgs
        {
            InstanceId = dstExample.SqlserverBasicInstanceId,
            UserName = dstSqlserverAccount.Name,
            Password = dstSqlserverAccount.Password,
        },
        MigrateDbSets = new[]
        {
            new Tencentcloud.Inputs.SqlserverMigrationMigrateDbSetArgs
            {
                DbName = srcSqlserverDb.Name,
            },
        },
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.tencentcloud.TencentcloudFunctions;
import com.pulumi.tencentcloud.inputs.GetAvailabilityZonesByProductArgs;
import com.pulumi.tencentcloud.Vpc;
import com.pulumi.tencentcloud.VpcArgs;
import com.pulumi.tencentcloud.Subnet;
import com.pulumi.tencentcloud.SubnetArgs;
import com.pulumi.tencentcloud.SecurityGroup;
import com.pulumi.tencentcloud.SecurityGroupArgs;
import com.pulumi.tencentcloud.SqlserverBasicInstance;
import com.pulumi.tencentcloud.SqlserverBasicInstanceArgs;
import com.pulumi.tencentcloud.SqlserverDb;
import com.pulumi.tencentcloud.SqlserverDbArgs;
import com.pulumi.tencentcloud.SqlserverAccount;
import com.pulumi.tencentcloud.SqlserverAccountArgs;
import com.pulumi.tencentcloud.SqlserverAccountDbAttachment;
import com.pulumi.tencentcloud.SqlserverAccountDbAttachmentArgs;
import com.pulumi.tencentcloud.SqlserverMigration;
import com.pulumi.tencentcloud.SqlserverMigrationArgs;
import com.pulumi.tencentcloud.inputs.SqlserverMigrationSourceArgs;
import com.pulumi.tencentcloud.inputs.SqlserverMigrationTargetArgs;
import com.pulumi.tencentcloud.inputs.SqlserverMigrationMigrateDbSetArgs;
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) {
        final var zones = TencentcloudFunctions.getAvailabilityZonesByProduct(GetAvailabilityZonesByProductArgs.builder()
            .product("sqlserver")
            .build());

        var vpc = new Vpc("vpc", VpcArgs.builder()
            .cidrBlock("10.0.0.0/16")
            .build());

        var subnet = new Subnet("subnet", SubnetArgs.builder()
            .availabilityZone(zones.applyValue(getAvailabilityZonesByProductResult -> getAvailabilityZonesByProductResult.zones()[4].name()))
            .vpcId(vpc.vpcId())
            .cidrBlock("10.0.0.0/16")
            .isMulticast(false)
            .build());

        var securityGroup = new SecurityGroup("securityGroup", SecurityGroupArgs.builder()
            .description("desc.")
            .build());

        var srcExample = new SqlserverBasicInstance("srcExample", SqlserverBasicInstanceArgs.builder()
            .availabilityZone(zones.applyValue(getAvailabilityZonesByProductResult -> getAvailabilityZonesByProductResult.zones()[4].name()))
            .chargeType("POSTPAID_BY_HOUR")
            .vpcId(vpc.vpcId())
            .subnetId(subnet.subnetId())
            .projectId(0)
            .memory(4)
            .storage(100)
            .cpu(2)
            .machineType("CLOUD_PREMIUM")
            .maintenanceWeekSets(            
                1,
                2,
                3)
            .maintenanceStartTime("09:00")
            .maintenanceTimeSpan(3)
            .securityGroups(securityGroup.securityGroupId())
            .tags(Map.of("test", "test"))
            .build());

        var dstExample = new SqlserverBasicInstance("dstExample", SqlserverBasicInstanceArgs.builder()
            .availabilityZone(zones.applyValue(getAvailabilityZonesByProductResult -> getAvailabilityZonesByProductResult.zones()[4].name()))
            .chargeType("POSTPAID_BY_HOUR")
            .vpcId(vpc.vpcId())
            .subnetId(subnet.subnetId())
            .projectId(0)
            .memory(4)
            .storage(100)
            .cpu(2)
            .machineType("CLOUD_PREMIUM")
            .maintenanceWeekSets(            
                1,
                2,
                3)
            .maintenanceStartTime("09:00")
            .maintenanceTimeSpan(3)
            .securityGroups(securityGroup.securityGroupId())
            .tags(Map.of("test", "test"))
            .build());

        var srcSqlserverDb = new SqlserverDb("srcSqlserverDb", SqlserverDbArgs.builder()
            .instanceId(srcExample.sqlserverBasicInstanceId())
            .charset("Chinese_PRC_BIN")
            .remark("testACC-remark")
            .build());

        var dstSqlserverDb = new SqlserverDb("dstSqlserverDb", SqlserverDbArgs.builder()
            .instanceId(dstExample.sqlserverBasicInstanceId())
            .charset("Chinese_PRC_BIN")
            .remark("testACC-remark")
            .build());

        var srcSqlserverAccount = new SqlserverAccount("srcSqlserverAccount", SqlserverAccountArgs.builder()
            .instanceId(srcExample.sqlserverBasicInstanceId())
            .password("Qwer@234")
            .isAdmin(true)
            .build());

        var dstSqlserverAccount = new SqlserverAccount("dstSqlserverAccount", SqlserverAccountArgs.builder()
            .instanceId(dstExample.sqlserverBasicInstanceId())
            .password("Qwer@234")
            .isAdmin(true)
            .build());

        var srcSqlserverAccountDbAttachment = new SqlserverAccountDbAttachment("srcSqlserverAccountDbAttachment", SqlserverAccountDbAttachmentArgs.builder()
            .instanceId(srcExample.sqlserverBasicInstanceId())
            .accountName(srcSqlserverAccount.name())
            .dbName(srcSqlserverDb.name())
            .privilege("ReadWrite")
            .build());

        var dstSqlserverAccountDbAttachment = new SqlserverAccountDbAttachment("dstSqlserverAccountDbAttachment", SqlserverAccountDbAttachmentArgs.builder()
            .instanceId(dstExample.sqlserverBasicInstanceId())
            .accountName(dstSqlserverAccount.name())
            .dbName(dstSqlserverDb.name())
            .privilege("ReadWrite")
            .build());

        var migration = new SqlserverMigration("migration", SqlserverMigrationArgs.builder()
            .migrateName("tf_test_migration")
            .migrateType(1)
            .sourceType(1)
            .source(SqlserverMigrationSourceArgs.builder()
                .instanceId(srcExample.sqlserverBasicInstanceId())
                .userName(srcSqlserverAccount.name())
                .password(srcSqlserverAccount.password())
                .build())
            .target(SqlserverMigrationTargetArgs.builder()
                .instanceId(dstExample.sqlserverBasicInstanceId())
                .userName(dstSqlserverAccount.name())
                .password(dstSqlserverAccount.password())
                .build())
            .migrateDbSets(SqlserverMigrationMigrateDbSetArgs.builder()
                .dbName(srcSqlserverDb.name())
                .build())
            .build());

    }
}

resources:
  vpc:
    type: tencentcloud:Vpc
    properties:
      cidrBlock: 10.0.0.0/16
  subnet:
    type: tencentcloud:Subnet
    properties:
      availabilityZone: ${zones.zones[4].name}
      vpcId: ${vpc.vpcId}
      cidrBlock: 10.0.0.0/16
      isMulticast: false
  securityGroup:
    type: tencentcloud:SecurityGroup
    properties:
      description: desc.
  srcExample:
    type: tencentcloud:SqlserverBasicInstance
    properties:
      availabilityZone: ${zones.zones[4].name}
      chargeType: POSTPAID_BY_HOUR
      vpcId: ${vpc.vpcId}
      subnetId: ${subnet.subnetId}
      projectId: 0
      memory: 4
      storage: 100
      cpu: 2
      machineType: CLOUD_PREMIUM
      maintenanceWeekSets:
        - 1
        - 2
        - 3
      maintenanceStartTime: 09:00
      maintenanceTimeSpan: 3
      securityGroups:
        - ${securityGroup.securityGroupId}
      tags:
        test: test
  dstExample:
    type: tencentcloud:SqlserverBasicInstance
    properties:
      availabilityZone: ${zones.zones[4].name}
      chargeType: POSTPAID_BY_HOUR
      vpcId: ${vpc.vpcId}
      subnetId: ${subnet.subnetId}
      projectId: 0
      memory: 4
      storage: 100
      cpu: 2
      machineType: CLOUD_PREMIUM
      maintenanceWeekSets:
        - 1
        - 2
        - 3
      maintenanceStartTime: 09:00
      maintenanceTimeSpan: 3
      securityGroups:
        - ${securityGroup.securityGroupId}
      tags:
        test: test
  srcSqlserverDb:
    type: tencentcloud:SqlserverDb
    properties:
      instanceId: ${srcExample.sqlserverBasicInstanceId}
      charset: Chinese_PRC_BIN
      remark: testACC-remark
  dstSqlserverDb:
    type: tencentcloud:SqlserverDb
    properties:
      instanceId: ${dstExample.sqlserverBasicInstanceId}
      charset: Chinese_PRC_BIN
      remark: testACC-remark
  srcSqlserverAccount:
    type: tencentcloud:SqlserverAccount
    properties:
      instanceId: ${srcExample.sqlserverBasicInstanceId}
      password: Qwer@234
      isAdmin: true
  dstSqlserverAccount:
    type: tencentcloud:SqlserverAccount
    properties:
      instanceId: ${dstExample.sqlserverBasicInstanceId}
      password: Qwer@234
      isAdmin: true
  srcSqlserverAccountDbAttachment:
    type: tencentcloud:SqlserverAccountDbAttachment
    properties:
      instanceId: ${srcExample.sqlserverBasicInstanceId}
      accountName: ${srcSqlserverAccount.name}
      dbName: ${srcSqlserverDb.name}
      privilege: ReadWrite
  dstSqlserverAccountDbAttachment:
    type: tencentcloud:SqlserverAccountDbAttachment
    properties:
      instanceId: ${dstExample.sqlserverBasicInstanceId}
      accountName: ${dstSqlserverAccount.name}
      dbName: ${dstSqlserverDb.name}
      privilege: ReadWrite
  migration:
    type: tencentcloud:SqlserverMigration
    properties:
      migrateName: tf_test_migration
      migrateType: 1
      sourceType: 1
      source:
        instanceId: ${srcExample.sqlserverBasicInstanceId}
        userName: ${srcSqlserverAccount.name}
        password: ${srcSqlserverAccount.password}
      target:
        instanceId: ${dstExample.sqlserverBasicInstanceId}
        userName: ${dstSqlserverAccount.name}
        password: ${dstSqlserverAccount.password}
      migrateDbSets:
        - dbName: ${srcSqlserverDb.name}
variables:
  zones:
    fn::invoke:
      function: tencentcloud:getAvailabilityZonesByProduct
      arguments:
        product: sqlserver