alicloud.polardb.getGlobalDatabaseNetworks

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

const _this = alicloud.polardb.getNodeClasses({
    dbType: "MySQL",
    dbVersion: "8.0",
    payType: "PostPaid",
    category: "Normal",
});
const _default = new alicloud.vpc.Network("default", {
    vpcName: "terraform-example",
    cidrBlock: "172.16.0.0/16",
});
const defaultSwitch = new alicloud.vpc.Switch("default", {
    vpcId: _default.id,
    cidrBlock: "172.16.0.0/24",
    zoneId: _this.then(_this => _this.classes?.[0]?.zoneId),
    vswitchName: "terraform-example",
});
const cluster = new alicloud.polardb.Cluster("cluster", {
    dbType: "MySQL",
    dbVersion: "8.0",
    payType: "PostPaid",
    dbNodeCount: 2,
    dbNodeClass: _this.then(_this => _this.classes?.[0]?.supportedEngines?.[0]?.availableResources?.[0]?.dbNodeClass),
    vswitchId: defaultSwitch.id,
});
const defaultGlobalDatabaseNetwork = new alicloud.polardb.GlobalDatabaseNetwork("default", {
    dbClusterId: cluster.id,
    description: cluster.id,
});
const ids = alicloud.polardb.getGlobalDatabaseNetworksOutput({
    ids: [defaultGlobalDatabaseNetwork.id],
});
export const polardbGlobalDatabaseNetworkId1 = ids.apply(ids => ids.networks?.[0]?.id);
const description = alicloud.polardb.getGlobalDatabaseNetworksOutput({
    description: defaultGlobalDatabaseNetwork.description,
});
export const polardbGlobalDatabaseNetworkId2 = description.apply(description => description.networks?.[0]?.id);

import pulumi
import pulumi_alicloud as alicloud

this = alicloud.polardb.get_node_classes(db_type="MySQL",
    db_version="8.0",
    pay_type="PostPaid",
    category="Normal")
default = alicloud.vpc.Network("default",
    vpc_name="terraform-example",
    cidr_block="172.16.0.0/16")
default_switch = alicloud.vpc.Switch("default",
    vpc_id=default.id,
    cidr_block="172.16.0.0/24",
    zone_id=this.classes[0].zone_id,
    vswitch_name="terraform-example")
cluster = alicloud.polardb.Cluster("cluster",
    db_type="MySQL",
    db_version="8.0",
    pay_type="PostPaid",
    db_node_count=2,
    db_node_class=this.classes[0].supported_engines[0].available_resources[0].db_node_class,
    vswitch_id=default_switch.id)
default_global_database_network = alicloud.polardb.GlobalDatabaseNetwork("default",
    db_cluster_id=cluster.id,
    description=cluster.id)
ids = alicloud.polardb.get_global_database_networks_output(ids=[default_global_database_network.id])
pulumi.export("polardbGlobalDatabaseNetworkId1", ids.networks[0].id)
description = alicloud.polardb.get_global_database_networks_output(description=default_global_database_network.description)
pulumi.export("polardbGlobalDatabaseNetworkId2", description.networks[0].id)

package main

import (
	"github.com/pulumi/pulumi-alicloud/sdk/v3/go/alicloud/polardb"
	"github.com/pulumi/pulumi-alicloud/sdk/v3/go/alicloud/vpc"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		this, err := polardb.GetNodeClasses(ctx, &polardb.GetNodeClassesArgs{
			DbType:    pulumi.StringRef("MySQL"),
			DbVersion: pulumi.StringRef("8.0"),
			PayType:   "PostPaid",
			Category:  pulumi.StringRef("Normal"),
		}, nil)
		if err != nil {
			return err
		}
		_default, err := vpc.NewNetwork(ctx, "default", &vpc.NetworkArgs{
			VpcName:   pulumi.String("terraform-example"),
			CidrBlock: pulumi.String("172.16.0.0/16"),
		})
		if err != nil {
			return err
		}
		defaultSwitch, err := vpc.NewSwitch(ctx, "default", &vpc.SwitchArgs{
			VpcId:       _default.ID(),
			CidrBlock:   pulumi.String("172.16.0.0/24"),
			ZoneId:      pulumi.String(this.Classes[0].ZoneId),
			VswitchName: pulumi.String("terraform-example"),
		})
		if err != nil {
			return err
		}
		cluster, err := polardb.NewCluster(ctx, "cluster", &polardb.ClusterArgs{
			DbType:      pulumi.String("MySQL"),
			DbVersion:   pulumi.String("8.0"),
			PayType:     pulumi.String("PostPaid"),
			DbNodeCount: pulumi.Int(2),
			DbNodeClass: pulumi.String(this.Classes[0].SupportedEngines[0].AvailableResources[0].DbNodeClass),
			VswitchId:   defaultSwitch.ID(),
		})
		if err != nil {
			return err
		}
		defaultGlobalDatabaseNetwork, err := polardb.NewGlobalDatabaseNetwork(ctx, "default", &polardb.GlobalDatabaseNetworkArgs{
			DbClusterId: cluster.ID(),
			Description: cluster.ID(),
		})
		if err != nil {
			return err
		}
		ids := polardb.GetGlobalDatabaseNetworksOutput(ctx, polardb.GetGlobalDatabaseNetworksOutputArgs{
			Ids: pulumi.StringArray{
				defaultGlobalDatabaseNetwork.ID(),
			},
		}, nil)
		ctx.Export("polardbGlobalDatabaseNetworkId1", ids.ApplyT(func(ids polardb.GetGlobalDatabaseNetworksResult) (*string, error) {
			return &ids.Networks[0].Id, nil
		}).(pulumi.StringPtrOutput))
		description := polardb.GetGlobalDatabaseNetworksOutput(ctx, polardb.GetGlobalDatabaseNetworksOutputArgs{
			Description: defaultGlobalDatabaseNetwork.Description,
		}, nil)
		ctx.Export("polardbGlobalDatabaseNetworkId2", description.ApplyT(func(description polardb.GetGlobalDatabaseNetworksResult) (*string, error) {
			return &description.Networks[0].Id, nil
		}).(pulumi.StringPtrOutput))
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var @this = AliCloud.PolarDB.GetNodeClasses.Invoke(new()
    {
        DbType = "MySQL",
        DbVersion = "8.0",
        PayType = "PostPaid",
        Category = "Normal",
    });

    var @default = new AliCloud.Vpc.Network("default", new()
    {
        VpcName = "terraform-example",
        CidrBlock = "172.16.0.0/16",
    });

    var defaultSwitch = new AliCloud.Vpc.Switch("default", new()
    {
        VpcId = @default.Id,
        CidrBlock = "172.16.0.0/24",
        ZoneId = @this.Apply(@this => @this.Apply(getNodeClassesResult => getNodeClassesResult.Classes[0]?.ZoneId)),
        VswitchName = "terraform-example",
    });

    var cluster = new AliCloud.PolarDB.Cluster("cluster", new()
    {
        DbType = "MySQL",
        DbVersion = "8.0",
        PayType = "PostPaid",
        DbNodeCount = 2,
        DbNodeClass = @this.Apply(@this => @this.Apply(getNodeClassesResult => getNodeClassesResult.Classes[0]?.SupportedEngines[0]?.AvailableResources[0]?.DbNodeClass)),
        VswitchId = defaultSwitch.Id,
    });

    var defaultGlobalDatabaseNetwork = new AliCloud.PolarDB.GlobalDatabaseNetwork("default", new()
    {
        DbClusterId = cluster.Id,
        Description = cluster.Id,
    });

    var ids = AliCloud.PolarDB.GetGlobalDatabaseNetworks.Invoke(new()
    {
        Ids = new[]
        {
            defaultGlobalDatabaseNetwork.Id,
        },
    });

    var description = AliCloud.PolarDB.GetGlobalDatabaseNetworks.Invoke(new()
    {
        Description = defaultGlobalDatabaseNetwork.Description,
    });

    return new Dictionary<string, object?>
    {
        ["polardbGlobalDatabaseNetworkId1"] = ids.Apply(getGlobalDatabaseNetworksResult => getGlobalDatabaseNetworksResult.Networks[0]?.Id),
        ["polardbGlobalDatabaseNetworkId2"] = description.Apply(getGlobalDatabaseNetworksResult => getGlobalDatabaseNetworksResult.Networks[0]?.Id),
    };
});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.alicloud.polardb.PolardbFunctions;
import com.pulumi.alicloud.polardb.inputs.GetNodeClassesArgs;
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.polardb.Cluster;
import com.pulumi.alicloud.polardb.ClusterArgs;
import com.pulumi.alicloud.polardb.GlobalDatabaseNetwork;
import com.pulumi.alicloud.polardb.GlobalDatabaseNetworkArgs;
import com.pulumi.alicloud.polardb.inputs.GetGlobalDatabaseNetworksArgs;
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 this = PolardbFunctions.getNodeClasses(GetNodeClassesArgs.builder()
            .dbType("MySQL")
            .dbVersion("8.0")
            .payType("PostPaid")
            .category("Normal")
            .build());

        var default_ = new Network("default", NetworkArgs.builder()
            .vpcName("terraform-example")
            .cidrBlock("172.16.0.0/16")
            .build());

        var defaultSwitch = new Switch("defaultSwitch", SwitchArgs.builder()
            .vpcId(default_.id())
            .cidrBlock("172.16.0.0/24")
            .zoneId(this_.classes()[0].zoneId())
            .vswitchName("terraform-example")
            .build());

        var cluster = new Cluster("cluster", ClusterArgs.builder()
            .dbType("MySQL")
            .dbVersion("8.0")
            .payType("PostPaid")
            .dbNodeCount(2)
            .dbNodeClass(this_.classes()[0].supportedEngines()[0].availableResources()[0].dbNodeClass())
            .vswitchId(defaultSwitch.id())
            .build());

        var defaultGlobalDatabaseNetwork = new GlobalDatabaseNetwork("defaultGlobalDatabaseNetwork", GlobalDatabaseNetworkArgs.builder()
            .dbClusterId(cluster.id())
            .description(cluster.id())
            .build());

        final var ids = PolardbFunctions.getGlobalDatabaseNetworks(GetGlobalDatabaseNetworksArgs.builder()
            .ids(defaultGlobalDatabaseNetwork.id())
            .build());

        ctx.export("polardbGlobalDatabaseNetworkId1", ids.applyValue(_ids -> _ids.networks()[0].id()));
        final var description = PolardbFunctions.getGlobalDatabaseNetworks(GetGlobalDatabaseNetworksArgs.builder()
            .description(defaultGlobalDatabaseNetwork.description())
            .build());

        ctx.export("polardbGlobalDatabaseNetworkId2", description.applyValue(_description -> _description.networks()[0].id()));
    }
}

resources:
  default:
    type: alicloud:vpc:Network
    properties:
      vpcName: terraform-example
      cidrBlock: 172.16.0.0/16
  defaultSwitch:
    type: alicloud:vpc:Switch
    name: default
    properties:
      vpcId: ${default.id}
      cidrBlock: 172.16.0.0/24
      zoneId: ${this.classes[0].zoneId}
      vswitchName: terraform-example
  cluster:
    type: alicloud:polardb:Cluster
    properties:
      dbType: MySQL
      dbVersion: '8.0'
      payType: PostPaid
      dbNodeCount: '2'
      dbNodeClass: ${this.classes[0].supportedEngines[0].availableResources[0].dbNodeClass}
      vswitchId: ${defaultSwitch.id}
  defaultGlobalDatabaseNetwork:
    type: alicloud:polardb:GlobalDatabaseNetwork
    name: default
    properties:
      dbClusterId: ${cluster.id}
      description: ${cluster.id}
variables:
  this:
    fn::invoke:
      function: alicloud:polardb:getNodeClasses
      arguments:
        dbType: MySQL
        dbVersion: '8.0'
        payType: PostPaid
        category: Normal
  ids:
    fn::invoke:
      function: alicloud:polardb:getGlobalDatabaseNetworks
      arguments:
        ids:
          - ${defaultGlobalDatabaseNetwork.id}
  description:
    fn::invoke:
      function: alicloud:polardb:getGlobalDatabaseNetworks
      arguments:
        description: ${defaultGlobalDatabaseNetwork.description}
outputs:
  polardbGlobalDatabaseNetworkId1: ${ids.networks[0].id}
  polardbGlobalDatabaseNetworkId2: ${description.networks[0].id}

function getGlobalDatabaseNetworks(args: GetGlobalDatabaseNetworksArgs, opts?: InvokeOptions): Promise<GetGlobalDatabaseNetworksResult>
function getGlobalDatabaseNetworksOutput(args: GetGlobalDatabaseNetworksOutputArgs, opts?: InvokeOptions): Output<GetGlobalDatabaseNetworksResult>

def get_global_database_networks(db_cluster_id: Optional[str] = None,
                                 description: Optional[str] = None,
                                 gdn_id: Optional[str] = None,
                                 ids: Optional[Sequence[str]] = None,
                                 output_file: Optional[str] = None,
                                 page_number: Optional[int] = None,
                                 page_size: Optional[int] = None,
                                 status: Optional[str] = None,
                                 opts: Optional[InvokeOptions] = None) -> GetGlobalDatabaseNetworksResult
def get_global_database_networks_output(db_cluster_id: Optional[pulumi.Input[str]] = None,
                                 description: Optional[pulumi.Input[str]] = None,
                                 gdn_id: Optional[pulumi.Input[str]] = None,
                                 ids: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                                 output_file: Optional[pulumi.Input[str]] = None,
                                 page_number: Optional[pulumi.Input[int]] = None,
                                 page_size: Optional[pulumi.Input[int]] = None,
                                 status: Optional[pulumi.Input[str]] = None,
                                 opts: Optional[InvokeOptions] = None) -> Output[GetGlobalDatabaseNetworksResult]

func GetGlobalDatabaseNetworks(ctx *Context, args *GetGlobalDatabaseNetworksArgs, opts ...InvokeOption) (*GetGlobalDatabaseNetworksResult, error)
func GetGlobalDatabaseNetworksOutput(ctx *Context, args *GetGlobalDatabaseNetworksOutputArgs, opts ...InvokeOption) GetGlobalDatabaseNetworksResultOutput

public static class GetGlobalDatabaseNetworks 
{
    public static Task<GetGlobalDatabaseNetworksResult> InvokeAsync(GetGlobalDatabaseNetworksArgs args, InvokeOptions? opts = null)
    public static Output<GetGlobalDatabaseNetworksResult> Invoke(GetGlobalDatabaseNetworksInvokeArgs args, InvokeOptions? opts = null)
}

public static CompletableFuture<GetGlobalDatabaseNetworksResult> getGlobalDatabaseNetworks(GetGlobalDatabaseNetworksArgs args, InvokeOptions options)
public static Output<GetGlobalDatabaseNetworksResult> getGlobalDatabaseNetworks(GetGlobalDatabaseNetworksArgs args, InvokeOptions options)

fn::invoke:
  function: alicloud:polardb/getGlobalDatabaseNetworks:getGlobalDatabaseNetworks
  arguments:
    # arguments dictionary