alicloud.dts.SubscriptionJob

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

const config = new pulumi.Config();
const name = config.get("name") || "terraform-example";
const exampleRegions = alicloud.getRegions({
    current: true,
});
const exampleZones = alicloud.rds.getZones({
    engine: "MySQL",
    engineVersion: "8.0",
    instanceChargeType: "PostPaid",
    category: "Basic",
    dbInstanceStorageType: "cloud_essd",
});
const exampleInstanceClasses = exampleZones.then(exampleZones => alicloud.rds.getInstanceClasses({
    zoneId: exampleZones.zones?.[0]?.id,
    engine: "MySQL",
    engineVersion: "8.0",
    instanceChargeType: "PostPaid",
    category: "Basic",
    dbInstanceStorageType: "cloud_essd",
}));
const exampleNetwork = new alicloud.vpc.Network("exampleNetwork", {
    vpcName: name,
    cidrBlock: "172.16.0.0/16",
});
const exampleSwitch = new alicloud.vpc.Switch("exampleSwitch", {
    vpcId: exampleNetwork.id,
    cidrBlock: "172.16.0.0/24",
    zoneId: exampleZones.then(exampleZones => exampleZones.zones?.[0]?.id),
    vswitchName: name,
});
const exampleSecurityGroup = new alicloud.ecs.SecurityGroup("exampleSecurityGroup", {vpcId: exampleNetwork.id});
const exampleInstance = new alicloud.rds.Instance("exampleInstance", {
    engine: "MySQL",
    engineVersion: "8.0",
    instanceType: exampleInstanceClasses.then(exampleInstanceClasses => exampleInstanceClasses.instanceClasses?.[0]?.instanceClass),
    instanceStorage: exampleInstanceClasses.then(exampleInstanceClasses => exampleInstanceClasses.instanceClasses?.[0]?.storageRange?.min),
    instanceChargeType: "Postpaid",
    instanceName: name,
    vswitchId: exampleSwitch.id,
    monitoringPeriod: 60,
    dbInstanceStorageType: "cloud_essd",
    securityGroupIds: [exampleSecurityGroup.id],
});
const exampleRdsAccount = new alicloud.rds.RdsAccount("exampleRdsAccount", {
    dbInstanceId: exampleInstance.id,
    accountName: "test_mysql",
    accountPassword: "N1cetest",
});
const exampleDatabase = new alicloud.rds.Database("exampleDatabase", {instanceId: exampleInstance.id});
const exampleAccountPrivilege = new alicloud.rds.AccountPrivilege("exampleAccountPrivilege", {
    instanceId: exampleInstance.id,
    accountName: exampleRdsAccount.name,
    privilege: "ReadWrite",
    dbNames: [exampleDatabase.name],
});
const exampleSubscriptionJob = new alicloud.dts.SubscriptionJob("exampleSubscriptionJob", {
    dtsJobName: name,
    paymentType: "PayAsYouGo",
    sourceEndpointEngineName: "MySQL",
    sourceEndpointRegion: exampleRegions.then(exampleRegions => exampleRegions.regions?.[0]?.id),
    sourceEndpointInstanceType: "RDS",
    sourceEndpointInstanceId: exampleInstance.id,
    sourceEndpointDatabaseName: exampleDatabase.name,
    sourceEndpointUserName: exampleRdsAccount.accountName,
    sourceEndpointPassword: exampleRdsAccount.accountPassword,
    dbList: pulumi.jsonStringify(pulumi.all([exampleDatabase.name, exampleDatabase.name]).apply(([exampleDatabaseName, exampleDatabaseName1]) => {
        [exampleDatabaseName]: {
            name: exampleDatabaseName1,
            all: true,
        },
    })),
    subscriptionInstanceNetworkType: "vpc",
    subscriptionInstanceVpcId: exampleNetwork.id,
    subscriptionInstanceVswitchId: exampleSwitch.id,
    status: "Normal",
});

import pulumi
import json
import pulumi_alicloud as alicloud

config = pulumi.Config()
name = config.get("name")
if name is None:
    name = "terraform-example"
example_regions = alicloud.get_regions(current=True)
example_zones = alicloud.rds.get_zones(engine="MySQL",
    engine_version="8.0",
    instance_charge_type="PostPaid",
    category="Basic",
    db_instance_storage_type="cloud_essd")
example_instance_classes = alicloud.rds.get_instance_classes(zone_id=example_zones.zones[0].id,
    engine="MySQL",
    engine_version="8.0",
    instance_charge_type="PostPaid",
    category="Basic",
    db_instance_storage_type="cloud_essd")
example_network = alicloud.vpc.Network("exampleNetwork",
    vpc_name=name,
    cidr_block="172.16.0.0/16")
example_switch = alicloud.vpc.Switch("exampleSwitch",
    vpc_id=example_network.id,
    cidr_block="172.16.0.0/24",
    zone_id=example_zones.zones[0].id,
    vswitch_name=name)
example_security_group = alicloud.ecs.SecurityGroup("exampleSecurityGroup", vpc_id=example_network.id)
example_instance = alicloud.rds.Instance("exampleInstance",
    engine="MySQL",
    engine_version="8.0",
    instance_type=example_instance_classes.instance_classes[0].instance_class,
    instance_storage=example_instance_classes.instance_classes[0].storage_range.min,
    instance_charge_type="Postpaid",
    instance_name=name,
    vswitch_id=example_switch.id,
    monitoring_period=60,
    db_instance_storage_type="cloud_essd",
    security_group_ids=[example_security_group.id])
example_rds_account = alicloud.rds.RdsAccount("exampleRdsAccount",
    db_instance_id=example_instance.id,
    account_name="test_mysql",
    account_password="N1cetest")
example_database = alicloud.rds.Database("exampleDatabase", instance_id=example_instance.id)
example_account_privilege = alicloud.rds.AccountPrivilege("exampleAccountPrivilege",
    instance_id=example_instance.id,
    account_name=example_rds_account.name,
    privilege="ReadWrite",
    db_names=[example_database.name])
example_subscription_job = alicloud.dts.SubscriptionJob("exampleSubscriptionJob",
    dts_job_name=name,
    payment_type="PayAsYouGo",
    source_endpoint_engine_name="MySQL",
    source_endpoint_region=example_regions.regions[0].id,
    source_endpoint_instance_type="RDS",
    source_endpoint_instance_id=example_instance.id,
    source_endpoint_database_name=example_database.name,
    source_endpoint_user_name=example_rds_account.account_name,
    source_endpoint_password=example_rds_account.account_password,
    db_list=pulumi.Output.json_dumps(pulumi.Output.all(example_database.name, example_database.name).apply(lambda exampleDatabaseName, exampleDatabaseName1: {
        example_database_name: {
            "name": example_database_name1,
            "all": True,
        },
    })),
    subscription_instance_network_type="vpc",
    subscription_instance_vpc_id=example_network.id,
    subscription_instance_vswitch_id=example_switch.id,
    status="Normal")

package main

import (
	"encoding/json"

	"github.com/pulumi/pulumi-alicloud/sdk/v3/go/alicloud"
	"github.com/pulumi/pulumi-alicloud/sdk/v3/go/alicloud/dts"
	"github.com/pulumi/pulumi-alicloud/sdk/v3/go/alicloud/ecs"
	"github.com/pulumi/pulumi-alicloud/sdk/v3/go/alicloud/rds"
	"github.com/pulumi/pulumi-alicloud/sdk/v3/go/alicloud/vpc"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi/config"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		cfg := config.New(ctx, "")
		name := "terraform-example"
		if param := cfg.Get("name"); param != "" {
			name = param
		}
		exampleRegions, err := alicloud.GetRegions(ctx, &alicloud.GetRegionsArgs{
			Current: pulumi.BoolRef(true),
		}, nil)
		if err != nil {
			return err
		}
		exampleZones, err := rds.GetZones(ctx, &rds.GetZonesArgs{
			Engine:                pulumi.StringRef("MySQL"),
			EngineVersion:         pulumi.StringRef("8.0"),
			InstanceChargeType:    pulumi.StringRef("PostPaid"),
			Category:              pulumi.StringRef("Basic"),
			DbInstanceStorageType: pulumi.StringRef("cloud_essd"),
		}, nil)
		if err != nil {
			return err
		}
		exampleInstanceClasses, err := rds.GetInstanceClasses(ctx, &rds.GetInstanceClassesArgs{
			ZoneId:                pulumi.StringRef(exampleZones.Zones[0].Id),
			Engine:                pulumi.StringRef("MySQL"),
			EngineVersion:         pulumi.StringRef("8.0"),
			InstanceChargeType:    pulumi.StringRef("PostPaid"),
			Category:              pulumi.StringRef("Basic"),
			DbInstanceStorageType: pulumi.StringRef("cloud_essd"),
		}, nil)
		if err != nil {
			return err
		}
		exampleNetwork, err := vpc.NewNetwork(ctx, "exampleNetwork", &vpc.NetworkArgs{
			VpcName:   pulumi.String(name),
			CidrBlock: pulumi.String("172.16.0.0/16"),
		})
		if err != nil {
			return err
		}
		exampleSwitch, err := vpc.NewSwitch(ctx, "exampleSwitch", &vpc.SwitchArgs{
			VpcId:       exampleNetwork.ID(),
			CidrBlock:   pulumi.String("172.16.0.0/24"),
			ZoneId:      pulumi.String(exampleZones.Zones[0].Id),
			VswitchName: pulumi.String(name),
		})
		if err != nil {
			return err
		}
		exampleSecurityGroup, err := ecs.NewSecurityGroup(ctx, "exampleSecurityGroup", &ecs.SecurityGroupArgs{
			VpcId: exampleNetwork.ID(),
		})
		if err != nil {
			return err
		}
		exampleInstance, err := rds.NewInstance(ctx, "exampleInstance", &rds.InstanceArgs{
			Engine:                pulumi.String("MySQL"),
			EngineVersion:         pulumi.String("8.0"),
			InstanceType:          pulumi.String(exampleInstanceClasses.InstanceClasses[0].InstanceClass),
			InstanceStorage:       pulumi.String(exampleInstanceClasses.InstanceClasses[0].StorageRange.Min),
			InstanceChargeType:    pulumi.String("Postpaid"),
			InstanceName:          pulumi.String(name),
			VswitchId:             exampleSwitch.ID(),
			MonitoringPeriod:      pulumi.Int(60),
			DbInstanceStorageType: pulumi.String("cloud_essd"),
			SecurityGroupIds: pulumi.StringArray{
				exampleSecurityGroup.ID(),
			},
		})
		if err != nil {
			return err
		}
		exampleRdsAccount, err := rds.NewRdsAccount(ctx, "exampleRdsAccount", &rds.RdsAccountArgs{
			DbInstanceId:    exampleInstance.ID(),
			AccountName:     pulumi.String("test_mysql"),
			AccountPassword: pulumi.String("N1cetest"),
		})
		if err != nil {
			return err
		}
		exampleDatabase, err := rds.NewDatabase(ctx, "exampleDatabase", &rds.DatabaseArgs{
			InstanceId: exampleInstance.ID(),
		})
		if err != nil {
			return err
		}
		_, err = rds.NewAccountPrivilege(ctx, "exampleAccountPrivilege", &rds.AccountPrivilegeArgs{
			InstanceId:  exampleInstance.ID(),
			AccountName: exampleRdsAccount.Name,
			Privilege:   pulumi.String("ReadWrite"),
			DbNames: pulumi.StringArray{
				exampleDatabase.Name,
			},
		})
		if err != nil {
			return err
		}
		_, err = dts.NewSubscriptionJob(ctx, "exampleSubscriptionJob", &dts.SubscriptionJobArgs{
			DtsJobName:                 pulumi.String(name),
			PaymentType:                pulumi.String("PayAsYouGo"),
			SourceEndpointEngineName:   pulumi.String("MySQL"),
			SourceEndpointRegion:       pulumi.String(exampleRegions.Regions[0].Id),
			SourceEndpointInstanceType: pulumi.String("RDS"),
			SourceEndpointInstanceId:   exampleInstance.ID(),
			SourceEndpointDatabaseName: exampleDatabase.Name,
			SourceEndpointUserName:     exampleRdsAccount.AccountName,
			SourceEndpointPassword:     exampleRdsAccount.AccountPassword,
			DbList: pulumi.All(exampleDatabase.Name, exampleDatabase.Name).ApplyT(func(_args []interface{}) (string, error) {
				exampleDatabaseName := _args[0].(string)
				exampleDatabaseName1 := _args[1].(string)
				var _zero string
				tmpJSON0, err := json.Marshal(map[string]map[string]interface{}{
					exampleDatabaseName: map[string]interface{}{
						"name": exampleDatabaseName1,
						"all":  true,
					},
				})
				if err != nil {
					return _zero, err
				}
				json0 := string(tmpJSON0)
				return json0, nil
			}).(pulumi.StringOutput),
			SubscriptionInstanceNetworkType: pulumi.String("vpc"),
			SubscriptionInstanceVpcId:       exampleNetwork.ID(),
			SubscriptionInstanceVswitchId:   exampleSwitch.ID(),
			Status:                          pulumi.String("Normal"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

using System.Collections.Generic;
using System.Linq;
using System.Text.Json;
using Pulumi;
using AliCloud = Pulumi.AliCloud;

return await Deployment.RunAsync(() => 
{
    var config = new Config();
    var name = config.Get("name") ?? "terraform-example";
    var exampleRegions = AliCloud.GetRegions.Invoke(new()
    {
        Current = true,
    });

    var exampleZones = AliCloud.Rds.GetZones.Invoke(new()
    {
        Engine = "MySQL",
        EngineVersion = "8.0",
        InstanceChargeType = "PostPaid",
        Category = "Basic",
        DbInstanceStorageType = "cloud_essd",
    });

    var exampleInstanceClasses = AliCloud.Rds.GetInstanceClasses.Invoke(new()
    {
        ZoneId = exampleZones.Apply(getZonesResult => getZonesResult.Zones[0]?.Id),
        Engine = "MySQL",
        EngineVersion = "8.0",
        InstanceChargeType = "PostPaid",
        Category = "Basic",
        DbInstanceStorageType = "cloud_essd",
    });

    var exampleNetwork = new AliCloud.Vpc.Network("exampleNetwork", new()
    {
        VpcName = name,
        CidrBlock = "172.16.0.0/16",
    });

    var exampleSwitch = new AliCloud.Vpc.Switch("exampleSwitch", new()
    {
        VpcId = exampleNetwork.Id,
        CidrBlock = "172.16.0.0/24",
        ZoneId = exampleZones.Apply(getZonesResult => getZonesResult.Zones[0]?.Id),
        VswitchName = name,
    });

    var exampleSecurityGroup = new AliCloud.Ecs.SecurityGroup("exampleSecurityGroup", new()
    {
        VpcId = exampleNetwork.Id,
    });

    var exampleInstance = new AliCloud.Rds.Instance("exampleInstance", new()
    {
        Engine = "MySQL",
        EngineVersion = "8.0",
        InstanceType = exampleInstanceClasses.Apply(getInstanceClassesResult => getInstanceClassesResult.InstanceClasses[0]?.InstanceClass),
        InstanceStorage = exampleInstanceClasses.Apply(getInstanceClassesResult => getInstanceClassesResult.InstanceClasses[0]?.StorageRange?.Min),
        InstanceChargeType = "Postpaid",
        InstanceName = name,
        VswitchId = exampleSwitch.Id,
        MonitoringPeriod = 60,
        DbInstanceStorageType = "cloud_essd",
        SecurityGroupIds = new[]
        {
            exampleSecurityGroup.Id,
        },
    });

    var exampleRdsAccount = new AliCloud.Rds.RdsAccount("exampleRdsAccount", new()
    {
        DbInstanceId = exampleInstance.Id,
        AccountName = "test_mysql",
        AccountPassword = "N1cetest",
    });

    var exampleDatabase = new AliCloud.Rds.Database("exampleDatabase", new()
    {
        InstanceId = exampleInstance.Id,
    });

    var exampleAccountPrivilege = new AliCloud.Rds.AccountPrivilege("exampleAccountPrivilege", new()
    {
        InstanceId = exampleInstance.Id,
        AccountName = exampleRdsAccount.Name,
        Privilege = "ReadWrite",
        DbNames = new[]
        {
            exampleDatabase.Name,
        },
    });

    var exampleSubscriptionJob = new AliCloud.Dts.SubscriptionJob("exampleSubscriptionJob", new()
    {
        DtsJobName = name,
        PaymentType = "PayAsYouGo",
        SourceEndpointEngineName = "MySQL",
        SourceEndpointRegion = exampleRegions.Apply(getRegionsResult => getRegionsResult.Regions[0]?.Id),
        SourceEndpointInstanceType = "RDS",
        SourceEndpointInstanceId = exampleInstance.Id,
        SourceEndpointDatabaseName = exampleDatabase.Name,
        SourceEndpointUserName = exampleRdsAccount.AccountName,
        SourceEndpointPassword = exampleRdsAccount.AccountPassword,
        DbList = Output.JsonSerialize(Output.Create(Output.Tuple(exampleDatabase.Name, exampleDatabase.Name).Apply(values =>
        {
            var exampleDatabaseName = values.Item1;
            var exampleDatabaseName1 = values.Item2;
            return 
            {
                { exampleDatabaseName, 
                {
                    { "name", exampleDatabaseName1 },
                    { "all", true },
                } },
            };
        }))),
        SubscriptionInstanceNetworkType = "vpc",
        SubscriptionInstanceVpcId = exampleNetwork.Id,
        SubscriptionInstanceVswitchId = exampleSwitch.Id,
        Status = "Normal",
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.alicloud.AlicloudFunctions;
import com.pulumi.alicloud.inputs.GetRegionsArgs;
import com.pulumi.alicloud.rds.RdsFunctions;
import com.pulumi.alicloud.rds.inputs.GetZonesArgs;
import com.pulumi.alicloud.rds.inputs.GetInstanceClassesArgs;
import com.pulumi.alicloud.vpc.Network;
import com.pulumi.alicloud.vpc.NetworkArgs;
import com.pulumi.alicloud.vpc.Switch;
import com.pulumi.alicloud.vpc.SwitchArgs;
import com.pulumi.alicloud.ecs.SecurityGroup;
import com.pulumi.alicloud.ecs.SecurityGroupArgs;
import com.pulumi.alicloud.rds.Instance;
import com.pulumi.alicloud.rds.InstanceArgs;
import com.pulumi.alicloud.rds.RdsAccount;
import com.pulumi.alicloud.rds.RdsAccountArgs;
import com.pulumi.alicloud.rds.Database;
import com.pulumi.alicloud.rds.DatabaseArgs;
import com.pulumi.alicloud.rds.AccountPrivilege;
import com.pulumi.alicloud.rds.AccountPrivilegeArgs;
import com.pulumi.alicloud.dts.SubscriptionJob;
import com.pulumi.alicloud.dts.SubscriptionJobArgs;
import static com.pulumi.codegen.internal.Serialization.*;
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 config = ctx.config();
        final var name = config.get("name").orElse("terraform-example");
        final var exampleRegions = AlicloudFunctions.getRegions(GetRegionsArgs.builder()
            .current(true)
            .build());

        final var exampleZones = RdsFunctions.getZones(GetZonesArgs.builder()
            .engine("MySQL")
            .engineVersion("8.0")
            .instanceChargeType("PostPaid")
            .category("Basic")
            .dbInstanceStorageType("cloud_essd")
            .build());

        final var exampleInstanceClasses = RdsFunctions.getInstanceClasses(GetInstanceClassesArgs.builder()
            .zoneId(exampleZones.applyValue(getZonesResult -> getZonesResult.zones()[0].id()))
            .engine("MySQL")
            .engineVersion("8.0")
            .instanceChargeType("PostPaid")
            .category("Basic")
            .dbInstanceStorageType("cloud_essd")
            .build());

        var exampleNetwork = new Network("exampleNetwork", NetworkArgs.builder()        
            .vpcName(name)
            .cidrBlock("172.16.0.0/16")
            .build());

        var exampleSwitch = new Switch("exampleSwitch", SwitchArgs.builder()        
            .vpcId(exampleNetwork.id())
            .cidrBlock("172.16.0.0/24")
            .zoneId(exampleZones.applyValue(getZonesResult -> getZonesResult.zones()[0].id()))
            .vswitchName(name)
            .build());

        var exampleSecurityGroup = new SecurityGroup("exampleSecurityGroup", SecurityGroupArgs.builder()        
            .vpcId(exampleNetwork.id())
            .build());

        var exampleInstance = new Instance("exampleInstance", InstanceArgs.builder()        
            .engine("MySQL")
            .engineVersion("8.0")
            .instanceType(exampleInstanceClasses.applyValue(getInstanceClassesResult -> getInstanceClassesResult.instanceClasses()[0].instanceClass()))
            .instanceStorage(exampleInstanceClasses.applyValue(getInstanceClassesResult -> getInstanceClassesResult.instanceClasses()[0].storageRange().min()))
            .instanceChargeType("Postpaid")
            .instanceName(name)
            .vswitchId(exampleSwitch.id())
            .monitoringPeriod("60")
            .dbInstanceStorageType("cloud_essd")
            .securityGroupIds(exampleSecurityGroup.id())
            .build());

        var exampleRdsAccount = new RdsAccount("exampleRdsAccount", RdsAccountArgs.builder()        
            .dbInstanceId(exampleInstance.id())
            .accountName("test_mysql")
            .accountPassword("N1cetest")
            .build());

        var exampleDatabase = new Database("exampleDatabase", DatabaseArgs.builder()        
            .instanceId(exampleInstance.id())
            .build());

        var exampleAccountPrivilege = new AccountPrivilege("exampleAccountPrivilege", AccountPrivilegeArgs.builder()        
            .instanceId(exampleInstance.id())
            .accountName(exampleRdsAccount.name())
            .privilege("ReadWrite")
            .dbNames(exampleDatabase.name())
            .build());

        var exampleSubscriptionJob = new SubscriptionJob("exampleSubscriptionJob", SubscriptionJobArgs.builder()        
            .dtsJobName(name)
            .paymentType("PayAsYouGo")
            .sourceEndpointEngineName("MySQL")
            .sourceEndpointRegion(exampleRegions.applyValue(getRegionsResult -> getRegionsResult.regions()[0].id()))
            .sourceEndpointInstanceType("RDS")
            .sourceEndpointInstanceId(exampleInstance.id())
            .sourceEndpointDatabaseName(exampleDatabase.name())
            .sourceEndpointUserName(exampleRdsAccount.accountName())
            .sourceEndpointPassword(exampleRdsAccount.accountPassword())
            .dbList(Output.tuple(exampleDatabase.name(), exampleDatabase.name()).applyValue(values -> {
                var exampleDatabaseName = values.t1;
                var exampleDatabaseName1 = values.t2;
                return serializeJson(
                    jsonObject(
                        jsonProperty(exampleDatabaseName, jsonObject(
                            jsonProperty("name", exampleDatabaseName1),
                            jsonProperty("all", true)
                        ))
                    ));
            }))
            .subscriptionInstanceNetworkType("vpc")
            .subscriptionInstanceVpcId(exampleNetwork.id())
            .subscriptionInstanceVswitchId(exampleSwitch.id())
            .status("Normal")
            .build());

    }
}

configuration:
  name:
    type: string
    default: terraform-example
resources:
  exampleNetwork:
    type: alicloud:vpc:Network
    properties:
      vpcName: ${name}
      cidrBlock: 172.16.0.0/16
  exampleSwitch:
    type: alicloud:vpc:Switch
    properties:
      vpcId: ${exampleNetwork.id}
      cidrBlock: 172.16.0.0/24
      zoneId: ${exampleZones.zones[0].id}
      vswitchName: ${name}
  exampleSecurityGroup:
    type: alicloud:ecs:SecurityGroup
    properties:
      vpcId: ${exampleNetwork.id}
  exampleInstance:
    type: alicloud:rds:Instance
    properties:
      engine: MySQL
      engineVersion: '8.0'
      instanceType: ${exampleInstanceClasses.instanceClasses[0].instanceClass}
      instanceStorage: ${exampleInstanceClasses.instanceClasses[0].storageRange.min}
      instanceChargeType: Postpaid
      instanceName: ${name}
      vswitchId: ${exampleSwitch.id}
      monitoringPeriod: '60'
      dbInstanceStorageType: cloud_essd
      securityGroupIds:
        - ${exampleSecurityGroup.id}
  exampleRdsAccount:
    type: alicloud:rds:RdsAccount
    properties:
      dbInstanceId: ${exampleInstance.id}
      accountName: test_mysql
      accountPassword: N1cetest
  exampleDatabase:
    type: alicloud:rds:Database
    properties:
      instanceId: ${exampleInstance.id}
  exampleAccountPrivilege:
    type: alicloud:rds:AccountPrivilege
    properties:
      instanceId: ${exampleInstance.id}
      accountName: ${exampleRdsAccount.name}
      privilege: ReadWrite
      dbNames:
        - ${exampleDatabase.name}
  exampleSubscriptionJob:
    type: alicloud:dts:SubscriptionJob
    properties:
      dtsJobName: ${name}
      paymentType: PayAsYouGo
      sourceEndpointEngineName: MySQL
      sourceEndpointRegion: ${exampleRegions.regions[0].id}
      sourceEndpointInstanceType: RDS
      sourceEndpointInstanceId: ${exampleInstance.id}
      sourceEndpointDatabaseName: ${exampleDatabase.name}
      sourceEndpointUserName: ${exampleRdsAccount.accountName}
      sourceEndpointPassword: ${exampleRdsAccount.accountPassword}
      dbList:
        fn::toJSON:
          ${exampleDatabase.name}:
            name: ${exampleDatabase.name}
            all: true
      subscriptionInstanceNetworkType: vpc
      subscriptionInstanceVpcId: ${exampleNetwork.id}
      subscriptionInstanceVswitchId: ${exampleSwitch.id}
      status: Normal
variables:
  exampleRegions:
    fn::invoke:
      Function: alicloud:getRegions
      Arguments:
        current: true
  exampleZones:
    fn::invoke:
      Function: alicloud:rds:getZones
      Arguments:
        engine: MySQL
        engineVersion: '8.0'
        instanceChargeType: PostPaid
        category: Basic
        dbInstanceStorageType: cloud_essd
  exampleInstanceClasses:
    fn::invoke:
      Function: alicloud:rds:getInstanceClasses
      Arguments:
        zoneId: ${exampleZones.zones[0].id}
        engine: MySQL
        engineVersion: '8.0'
        instanceChargeType: PostPaid
        category: Basic
        dbInstanceStorageType: cloud_essd

var subscriptionJobResource = new AliCloud.Dts.SubscriptionJob("subscriptionJobResource", new()
{
    PaymentType = "string",
    SourceEndpointRegion = "string",
    SourceEndpointInstanceType = "string",
    SourceEndpointEngineName = "string",
    DtsInstanceId = "string",
    DatabaseCount = 0,
    DelayRuleTime = "string",
    DestinationEndpointEngineName = "string",
    DestinationRegion = "string",
    Checkpoint = "string",
    DtsJobName = "string",
    ErrorNotice = false,
    ErrorPhone = "string",
    InstanceClass = "string",
    PaymentDuration = 0,
    PaymentDurationUnit = "string",
    DelayNotice = false,
    Reserve = "string",
    SourceEndpointDatabaseName = "string",
    DbList = "string",
    SourceEndpointInstanceId = "string",
    DelayPhone = "string",
    SourceEndpointIp = "string",
    SourceEndpointOracleSid = "string",
    SourceEndpointOwnerId = "string",
    SourceEndpointPassword = "string",
    SourceEndpointPort = "string",
    ComputeUnit = 0,
    SourceEndpointRole = "string",
    SourceEndpointUserName = "string",
    Status = "string",
    SubscriptionDataTypeDdl = false,
    SubscriptionDataTypeDml = false,
    SubscriptionInstanceNetworkType = "string",
    SubscriptionInstanceVpcId = "string",
    SubscriptionInstanceVswitchId = "string",
    SyncArchitecture = "string",
    SynchronizationDirection = "string",
    Tags = 
    {
        { "string", "any" },
    },
});

example, err := dts.NewSubscriptionJob(ctx, "subscriptionJobResource", &dts.SubscriptionJobArgs{
	PaymentType:                     pulumi.String("string"),
	SourceEndpointRegion:            pulumi.String("string"),
	SourceEndpointInstanceType:      pulumi.String("string"),
	SourceEndpointEngineName:        pulumi.String("string"),
	DtsInstanceId:                   pulumi.String("string"),
	DatabaseCount:                   pulumi.Int(0),
	DelayRuleTime:                   pulumi.String("string"),
	DestinationEndpointEngineName:   pulumi.String("string"),
	DestinationRegion:               pulumi.String("string"),
	Checkpoint:                      pulumi.String("string"),
	DtsJobName:                      pulumi.String("string"),
	ErrorNotice:                     pulumi.Bool(false),
	ErrorPhone:                      pulumi.String("string"),
	InstanceClass:                   pulumi.String("string"),
	PaymentDuration:                 pulumi.Int(0),
	PaymentDurationUnit:             pulumi.String("string"),
	DelayNotice:                     pulumi.Bool(false),
	Reserve:                         pulumi.String("string"),
	SourceEndpointDatabaseName:      pulumi.String("string"),
	DbList:                          pulumi.String("string"),
	SourceEndpointInstanceId:        pulumi.String("string"),
	DelayPhone:                      pulumi.String("string"),
	SourceEndpointIp:                pulumi.String("string"),
	SourceEndpointOracleSid:         pulumi.String("string"),
	SourceEndpointOwnerId:           pulumi.String("string"),
	SourceEndpointPassword:          pulumi.String("string"),
	SourceEndpointPort:              pulumi.String("string"),
	ComputeUnit:                     pulumi.Int(0),
	SourceEndpointRole:              pulumi.String("string"),
	SourceEndpointUserName:          pulumi.String("string"),
	Status:                          pulumi.String("string"),
	SubscriptionDataTypeDdl:         pulumi.Bool(false),
	SubscriptionDataTypeDml:         pulumi.Bool(false),
	SubscriptionInstanceNetworkType: pulumi.String("string"),
	SubscriptionInstanceVpcId:       pulumi.String("string"),
	SubscriptionInstanceVswitchId:   pulumi.String("string"),
	SyncArchitecture:                pulumi.String("string"),
	SynchronizationDirection:        pulumi.String("string"),
	Tags: pulumi.Map{
		"string": pulumi.Any("any"),
	},
})

var subscriptionJobResource = new SubscriptionJob("subscriptionJobResource", SubscriptionJobArgs.builder()        
    .paymentType("string")
    .sourceEndpointRegion("string")
    .sourceEndpointInstanceType("string")
    .sourceEndpointEngineName("string")
    .dtsInstanceId("string")
    .databaseCount(0)
    .delayRuleTime("string")
    .destinationEndpointEngineName("string")
    .destinationRegion("string")
    .checkpoint("string")
    .dtsJobName("string")
    .errorNotice(false)
    .errorPhone("string")
    .instanceClass("string")
    .paymentDuration(0)
    .paymentDurationUnit("string")
    .delayNotice(false)
    .reserve("string")
    .sourceEndpointDatabaseName("string")
    .dbList("string")
    .sourceEndpointInstanceId("string")
    .delayPhone("string")
    .sourceEndpointIp("string")
    .sourceEndpointOracleSid("string")
    .sourceEndpointOwnerId("string")
    .sourceEndpointPassword("string")
    .sourceEndpointPort("string")
    .computeUnit(0)
    .sourceEndpointRole("string")
    .sourceEndpointUserName("string")
    .status("string")
    .subscriptionDataTypeDdl(false)
    .subscriptionDataTypeDml(false)
    .subscriptionInstanceNetworkType("string")
    .subscriptionInstanceVpcId("string")
    .subscriptionInstanceVswitchId("string")
    .syncArchitecture("string")
    .synchronizationDirection("string")
    .tags(Map.of("string", "any"))
    .build());

subscription_job_resource = alicloud.dts.SubscriptionJob("subscriptionJobResource",
    payment_type="string",
    source_endpoint_region="string",
    source_endpoint_instance_type="string",
    source_endpoint_engine_name="string",
    dts_instance_id="string",
    database_count=0,
    delay_rule_time="string",
    destination_endpoint_engine_name="string",
    destination_region="string",
    checkpoint="string",
    dts_job_name="string",
    error_notice=False,
    error_phone="string",
    instance_class="string",
    payment_duration=0,
    payment_duration_unit="string",
    delay_notice=False,
    reserve="string",
    source_endpoint_database_name="string",
    db_list="string",
    source_endpoint_instance_id="string",
    delay_phone="string",
    source_endpoint_ip="string",
    source_endpoint_oracle_sid="string",
    source_endpoint_owner_id="string",
    source_endpoint_password="string",
    source_endpoint_port="string",
    compute_unit=0,
    source_endpoint_role="string",
    source_endpoint_user_name="string",
    status="string",
    subscription_data_type_ddl=False,
    subscription_data_type_dml=False,
    subscription_instance_network_type="string",
    subscription_instance_vpc_id="string",
    subscription_instance_vswitch_id="string",
    sync_architecture="string",
    synchronization_direction="string",
    tags={
        "string": "any",
    })

const subscriptionJobResource = new alicloud.dts.SubscriptionJob("subscriptionJobResource", {
    paymentType: "string",
    sourceEndpointRegion: "string",
    sourceEndpointInstanceType: "string",
    sourceEndpointEngineName: "string",
    dtsInstanceId: "string",
    databaseCount: 0,
    delayRuleTime: "string",
    destinationEndpointEngineName: "string",
    destinationRegion: "string",
    checkpoint: "string",
    dtsJobName: "string",
    errorNotice: false,
    errorPhone: "string",
    instanceClass: "string",
    paymentDuration: 0,
    paymentDurationUnit: "string",
    delayNotice: false,
    reserve: "string",
    sourceEndpointDatabaseName: "string",
    dbList: "string",
    sourceEndpointInstanceId: "string",
    delayPhone: "string",
    sourceEndpointIp: "string",
    sourceEndpointOracleSid: "string",
    sourceEndpointOwnerId: "string",
    sourceEndpointPassword: "string",
    sourceEndpointPort: "string",
    computeUnit: 0,
    sourceEndpointRole: "string",
    sourceEndpointUserName: "string",
    status: "string",
    subscriptionDataTypeDdl: false,
    subscriptionDataTypeDml: false,
    subscriptionInstanceNetworkType: "string",
    subscriptionInstanceVpcId: "string",
    subscriptionInstanceVswitchId: "string",
    syncArchitecture: "string",
    synchronizationDirection: "string",
    tags: {
        string: "any",
    },
});

type: alicloud:dts:SubscriptionJob
properties:
    checkpoint: string
    computeUnit: 0
    databaseCount: 0
    dbList: string
    delayNotice: false
    delayPhone: string
    delayRuleTime: string
    destinationEndpointEngineName: string
    destinationRegion: string
    dtsInstanceId: string
    dtsJobName: string
    errorNotice: false
    errorPhone: string
    instanceClass: string
    paymentDuration: 0
    paymentDurationUnit: string
    paymentType: string
    reserve: string
    sourceEndpointDatabaseName: string
    sourceEndpointEngineName: string
    sourceEndpointInstanceId: string
    sourceEndpointInstanceType: string
    sourceEndpointIp: string
    sourceEndpointOracleSid: string
    sourceEndpointOwnerId: string
    sourceEndpointPassword: string
    sourceEndpointPort: string
    sourceEndpointRegion: string
    sourceEndpointRole: string
    sourceEndpointUserName: string
    status: string
    subscriptionDataTypeDdl: false
    subscriptionDataTypeDml: false
    subscriptionInstanceNetworkType: string
    subscriptionInstanceVpcId: string
    subscriptionInstanceVswitchId: string
    syncArchitecture: string
    synchronizationDirection: string
    tags:
        string: any