alicloud.rds.AccountPrivilege

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

return await Deployment.RunAsync(() => 
{
    var config = new Config();
    var creation = config.Get("creation") ?? "Rds";
    var name = config.Get("name") ?? "dbaccountprivilegebasic";
    var defaultZones = AliCloud.GetZones.Invoke(new()
    {
        AvailableResourceCreation = creation,
    });

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

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

    var instance = new AliCloud.Rds.Instance("instance", new()
    {
        Engine = "MySQL",
        EngineVersion = "5.6",
        InstanceType = "rds.mysql.s1.small",
        InstanceStorage = 10,
        VswitchId = defaultSwitch.Id,
        InstanceName = name,
    });

    var db = new List<AliCloud.Rds.Database>();
    for (var rangeIndex = 0; rangeIndex < 2; rangeIndex++)
    {
        var range = new { Value = rangeIndex };
        db.Add(new AliCloud.Rds.Database($"db-{range.Value}", new()
        {
            InstanceId = instance.Id,
            Description = "from terraform",
        }));
    }
    var account = new AliCloud.Rds.Account("account", new()
    {
        InstanceId = instance.Id,
        Password = "Test12345",
        Description = "from terraform",
    });

    var privilege = new AliCloud.Rds.AccountPrivilege("privilege", new()
    {
        InstanceId = instance.Id,
        AccountName = account.Name,
        Privilege = "ReadOnly",
        DbNames = db.Select(__item => __item.Name).ToList(),
    });

});

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.GetZonesArgs;
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.rds.Instance;
import com.pulumi.alicloud.rds.InstanceArgs;
import com.pulumi.alicloud.rds.Database;
import com.pulumi.alicloud.rds.DatabaseArgs;
import com.pulumi.alicloud.rds.Account;
import com.pulumi.alicloud.rds.AccountArgs;
import com.pulumi.alicloud.rds.AccountPrivilege;
import com.pulumi.alicloud.rds.AccountPrivilegeArgs;
import com.pulumi.codegen.internal.KeyedValue;
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 creation = config.get("creation").orElse("Rds");
        final var name = config.get("name").orElse("dbaccountprivilegebasic");
        final var defaultZones = AlicloudFunctions.getZones(GetZonesArgs.builder()
            .availableResourceCreation(creation)
            .build());

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

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

        var instance = new Instance("instance", InstanceArgs.builder()        
            .engine("MySQL")
            .engineVersion("5.6")
            .instanceType("rds.mysql.s1.small")
            .instanceStorage("10")
            .vswitchId(defaultSwitch.id())
            .instanceName(name)
            .build());

        for (var i = 0; i < 2; i++) {
            new Database("db-" + i, DatabaseArgs.builder()            
                .instanceId(instance.id())
                .description("from terraform")
                .build());

        
}
        var account = new Account("account", AccountArgs.builder()        
            .instanceId(instance.id())
            .password("Test12345")
            .description("from terraform")
            .build());

        var privilege = new AccountPrivilege("privilege", AccountPrivilegeArgs.builder()        
            .instanceId(instance.id())
            .accountName(account.name())
            .privilege("ReadOnly")
            .dbNames(db.stream().map(element -> element.name()).collect(toList()))
            .build());

    }
}

import pulumi
import pulumi_alicloud as alicloud

config = pulumi.Config()
creation = config.get("creation")
if creation is None:
    creation = "Rds"
name = config.get("name")
if name is None:
    name = "dbaccountprivilegebasic"
default_zones = alicloud.get_zones(available_resource_creation=creation)
default_network = alicloud.vpc.Network("defaultNetwork",
    vpc_name=name,
    cidr_block="172.16.0.0/16")
default_switch = alicloud.vpc.Switch("defaultSwitch",
    vpc_id=default_network.id,
    cidr_block="172.16.0.0/24",
    zone_id=default_zones.zones[0].id,
    vswitch_name=name)
instance = alicloud.rds.Instance("instance",
    engine="MySQL",
    engine_version="5.6",
    instance_type="rds.mysql.s1.small",
    instance_storage=10,
    vswitch_id=default_switch.id,
    instance_name=name)
db = []
for range in [{"value": i} for i in range(0, 2)]:
    db.append(alicloud.rds.Database(f"db-{range['value']}",
        instance_id=instance.id,
        description="from terraform"))
account = alicloud.rds.Account("account",
    instance_id=instance.id,
    password="Test12345",
    description="from terraform")
privilege = alicloud.rds.AccountPrivilege("privilege",
    instance_id=instance.id,
    account_name=account.name,
    privilege="ReadOnly",
    db_names=[__item.name for __item in db])

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

const config = new pulumi.Config();
const creation = config.get("creation") || "Rds";
const name = config.get("name") || "dbaccountprivilegebasic";
const defaultZones = alicloud.getZones({
    availableResourceCreation: creation,
});
const defaultNetwork = new alicloud.vpc.Network("defaultNetwork", {
    vpcName: name,
    cidrBlock: "172.16.0.0/16",
});
const defaultSwitch = new alicloud.vpc.Switch("defaultSwitch", {
    vpcId: defaultNetwork.id,
    cidrBlock: "172.16.0.0/24",
    zoneId: defaultZones.then(defaultZones => defaultZones.zones?.[0]?.id),
    vswitchName: name,
});
const instance = new alicloud.rds.Instance("instance", {
    engine: "MySQL",
    engineVersion: "5.6",
    instanceType: "rds.mysql.s1.small",
    instanceStorage: 10,
    vswitchId: defaultSwitch.id,
    instanceName: name,
});
const db: alicloud.rds.Database[] = [];
for (const range = {value: 0}; range.value < 2; range.value++) {
    db.push(new alicloud.rds.Database(`db-${range.value}`, {
        instanceId: instance.id,
        description: "from terraform",
    }));
}
const account = new alicloud.rds.Account("account", {
    instanceId: instance.id,
    password: "Test12345",
    description: "from terraform",
});
const privilege = new alicloud.rds.AccountPrivilege("privilege", {
    instanceId: instance.id,
    accountName: account.name,
    privilege: "ReadOnly",
    dbNames: db.map(__item => __item.name),
});