alicloud.mongodb.getBackups

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 zoneId = config.get("zoneId") || "cn-shanghai-b";
const cidrBlock = config.get("cidrBlock") || "10.0.0.0/24";
const defaultNetwork = new alicloud.vpc.Network("default", {
    cidrBlock: "10.0.0.0/8",
    vpcName: "bgg-vpc-shanghai-b",
});
const defaultSwitch = new alicloud.vpc.Switch("default", {
    vpcId: defaultNetwork.id,
    zoneId: zoneId,
    cidrBlock: cidrBlock,
});
const defaultInstance = new alicloud.mongodb.Instance("default", {
    engineVersion: "5.0",
    storageType: "cloud_essd1",
    vswitchId: defaultSwitch.id,
    dbInstanceStorage: 20,
    vpcId: defaultNetwork.id,
    dbInstanceClass: "mdb.shard.4x.large.d",
    storageEngine: "WiredTiger",
    networkType: "VPC",
    zoneId: zoneId,
    replicationFactor: 3,
    readonlyReplicas: 0,
});
const defaultBackup = new alicloud.mongodb.Backup("default", {
    backupMethod: "Snapshot",
    dbInstanceId: defaultInstance.id,
    backupRetentionPeriod: 7,
});
const _default = alicloud.mongodb.getBackupsOutput({
    ids: [defaultBackup.id],
    dbInstanceId: defaultInstance.id,
});
export const alicloudMongodbBackupExampleId = _default.apply(_default => _default.backups?.[0]?.id);

import pulumi
import pulumi_alicloud as alicloud

config = pulumi.Config()
name = config.get("name")
if name is None:
    name = "terraform-example"
zone_id = config.get("zoneId")
if zone_id is None:
    zone_id = "cn-shanghai-b"
cidr_block = config.get("cidrBlock")
if cidr_block is None:
    cidr_block = "10.0.0.0/24"
default_network = alicloud.vpc.Network("default",
    cidr_block="10.0.0.0/8",
    vpc_name="bgg-vpc-shanghai-b")
default_switch = alicloud.vpc.Switch("default",
    vpc_id=default_network.id,
    zone_id=zone_id,
    cidr_block=cidr_block)
default_instance = alicloud.mongodb.Instance("default",
    engine_version="5.0",
    storage_type="cloud_essd1",
    vswitch_id=default_switch.id,
    db_instance_storage=20,
    vpc_id=default_network.id,
    db_instance_class="mdb.shard.4x.large.d",
    storage_engine="WiredTiger",
    network_type="VPC",
    zone_id=zone_id,
    replication_factor=3,
    readonly_replicas=0)
default_backup = alicloud.mongodb.Backup("default",
    backup_method="Snapshot",
    db_instance_id=default_instance.id,
    backup_retention_period=7)
default = alicloud.mongodb.get_backups_output(ids=[default_backup.id],
    db_instance_id=default_instance.id)
pulumi.export("alicloudMongodbBackupExampleId", default.backups[0].id)

package main

import (
	"github.com/pulumi/pulumi-alicloud/sdk/v3/go/alicloud/mongodb"
	"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
		}
		zoneId := "cn-shanghai-b"
		if param := cfg.Get("zoneId"); param != "" {
			zoneId = param
		}
		cidrBlock := "10.0.0.0/24"
		if param := cfg.Get("cidrBlock"); param != "" {
			cidrBlock = param
		}
		defaultNetwork, err := vpc.NewNetwork(ctx, "default", &vpc.NetworkArgs{
			CidrBlock: pulumi.String("10.0.0.0/8"),
			VpcName:   pulumi.String("bgg-vpc-shanghai-b"),
		})
		if err != nil {
			return err
		}
		defaultSwitch, err := vpc.NewSwitch(ctx, "default", &vpc.SwitchArgs{
			VpcId:     defaultNetwork.ID().ToIDOutput().ToStringOutput(),
			ZoneId:    pulumi.String(zoneId),
			CidrBlock: pulumi.String(cidrBlock),
		})
		if err != nil {
			return err
		}
		defaultInstance, err := mongodb.NewInstance(ctx, "default", &mongodb.InstanceArgs{
			EngineVersion:     pulumi.String("5.0"),
			StorageType:       pulumi.String("cloud_essd1"),
			VswitchId:         defaultSwitch.ID().ToIDOutput().ToStringOutput(),
			DbInstanceStorage: pulumi.Int(20),
			VpcId:             defaultNetwork.ID().ToIDOutput().ToStringOutput(),
			DbInstanceClass:   pulumi.String("mdb.shard.4x.large.d"),
			StorageEngine:     pulumi.String("WiredTiger"),
			NetworkType:       pulumi.String("VPC"),
			ZoneId:            pulumi.String(zoneId),
			ReplicationFactor: pulumi.Int(3),
			ReadonlyReplicas:  pulumi.Int(0),
		})
		if err != nil {
			return err
		}
		defaultBackup, err := mongodb.NewBackup(ctx, "default", &mongodb.BackupArgs{
			BackupMethod:          pulumi.String("Snapshot"),
			DbInstanceId:          defaultInstance.ID().ToIDOutput().ToStringOutput(),
			BackupRetentionPeriod: pulumi.Int(7),
		})
		if err != nil {
			return err
		}
		_default := mongodb.GetBackupsOutput(ctx, mongodb.GetBackupsOutputArgs{
			Ids: pulumi.StringArray{
				defaultBackup.ID().ToIDOutput().ToStringOutput(),
			},
			DbInstanceId: defaultInstance.ID().ToIDOutput().ToStringOutput(),
		}, nil)
		ctx.Export("alicloudMongodbBackupExampleId", _default.ApplyT(func(_default mongodb.GetBackupsResult) (*string, error) {
			return _default.Backups[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 config = new Config();
    var name = config.Get("name") ?? "terraform-example";
    var zoneId = config.Get("zoneId") ?? "cn-shanghai-b";
    var cidrBlock = config.Get("cidrBlock") ?? "10.0.0.0/24";
    var defaultNetwork = new AliCloud.Vpc.Network("default", new()
    {
        CidrBlock = "10.0.0.0/8",
        VpcName = "bgg-vpc-shanghai-b",
    });

    var defaultSwitch = new AliCloud.Vpc.Switch("default", new()
    {
        VpcId = defaultNetwork.Id,
        ZoneId = zoneId,
        CidrBlock = cidrBlock,
    });

    var defaultInstance = new AliCloud.MongoDB.Instance("default", new()
    {
        EngineVersion = "5.0",
        StorageType = "cloud_essd1",
        VswitchId = defaultSwitch.Id,
        DbInstanceStorage = 20,
        VpcId = defaultNetwork.Id,
        DbInstanceClass = "mdb.shard.4x.large.d",
        StorageEngine = "WiredTiger",
        NetworkType = "VPC",
        ZoneId = zoneId,
        ReplicationFactor = 3,
        ReadonlyReplicas = 0,
    });

    var defaultBackup = new AliCloud.MongoDB.Backup("default", new()
    {
        BackupMethod = "Snapshot",
        DbInstanceId = defaultInstance.Id,
        BackupRetentionPeriod = 7,
    });

    var @default = AliCloud.MongoDB.GetBackups.Invoke(new()
    {
        Ids = new[]
        {
            defaultBackup.Id,
        },
        DbInstanceId = defaultInstance.Id,
    });

    return new Dictionary<string, object?>
    {
        ["alicloudMongodbBackupExampleId"] = @default.Apply(@default => @default.Apply(getBackupsResult => getBackupsResult.Backups[0]?.Id)),
    };
});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
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.mongodb.Instance;
import com.pulumi.alicloud.mongodb.InstanceArgs;
import com.pulumi.alicloud.mongodb.Backup;
import com.pulumi.alicloud.mongodb.BackupArgs;
import com.pulumi.alicloud.mongodb.MongodbFunctions;
import com.pulumi.alicloud.mongodb.inputs.GetBackupsArgs;
import java.util.ArrayList;
import java.util.Arrays;
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 zoneId = config.get("zoneId").orElse("cn-shanghai-b");
        final var cidrBlock = config.get("cidrBlock").orElse("10.0.0.0/24");
        var defaultNetwork = new Network("defaultNetwork", NetworkArgs.builder()
            .cidrBlock("10.0.0.0/8")
            .vpcName("bgg-vpc-shanghai-b")
            .build());

        var defaultSwitch = new Switch("defaultSwitch", SwitchArgs.builder()
            .vpcId(defaultNetwork.id())
            .zoneId(zoneId)
            .cidrBlock(cidrBlock)
            .build());

        var defaultInstance = new Instance("defaultInstance", InstanceArgs.builder()
            .engineVersion("5.0")
            .storageType("cloud_essd1")
            .vswitchId(defaultSwitch.id())
            .dbInstanceStorage(20)
            .vpcId(defaultNetwork.id())
            .dbInstanceClass("mdb.shard.4x.large.d")
            .storageEngine("WiredTiger")
            .networkType("VPC")
            .zoneId(zoneId)
            .replicationFactor(3)
            .readonlyReplicas(0)
            .build());

        var defaultBackup = new Backup("defaultBackup", BackupArgs.builder()
            .backupMethod("Snapshot")
            .dbInstanceId(defaultInstance.id())
            .backupRetentionPeriod(7)
            .build());

        final var default = MongodbFunctions.getBackups(GetBackupsArgs.builder()
            .ids(defaultBackup.id())
            .dbInstanceId(defaultInstance.id())
            .build());

        ctx.export("alicloudMongodbBackupExampleId", default_.applyValue(_default_ -> _default_.backups()[0].id()));
    }
}

configuration:
  name:
    type: string
    default: terraform-example
  zoneId:
    type: string
    default: cn-shanghai-b
  cidrBlock:
    type: string
    default: 10.0.0.0/24
resources:
  defaultNetwork:
    type: alicloud:vpc:Network
    name: default
    properties:
      cidrBlock: 10.0.0.0/8
      vpcName: bgg-vpc-shanghai-b
  defaultSwitch:
    type: alicloud:vpc:Switch
    name: default
    properties:
      vpcId: ${defaultNetwork.id}
      zoneId: ${zoneId}
      cidrBlock: ${cidrBlock}
  defaultInstance:
    type: alicloud:mongodb:Instance
    name: default
    properties:
      engineVersion: '5.0'
      storageType: cloud_essd1
      vswitchId: ${defaultSwitch.id}
      dbInstanceStorage: '20'
      vpcId: ${defaultNetwork.id}
      dbInstanceClass: mdb.shard.4x.large.d
      storageEngine: WiredTiger
      networkType: VPC
      zoneId: ${zoneId}
      replicationFactor: '3'
      readonlyReplicas: '0'
  defaultBackup:
    type: alicloud:mongodb:Backup
    name: default
    properties:
      backupMethod: Snapshot
      dbInstanceId: ${defaultInstance.id}
      backupRetentionPeriod: 7
variables:
  default:
    fn::invoke:
      function: alicloud:mongodb:getBackups
      arguments:
        ids:
          - ${defaultBackup.id}
        dbInstanceId: ${defaultInstance.id}
outputs:
  alicloudMongodbBackupExampleId: ${default.backups[0].id}

pulumi {
  required_providers {
    alicloud = {
      source = "pulumi/alicloud"
    }
  }
}

data "alicloud_mongodb_getbackups" "default" {
  ids            = [alicloud_mongodb_backup.default.id]
  db_instance_id = alicloud_mongodb_instance.default.id
}

resource "alicloud_vpc_network" "default" {
  cidr_block = "10.0.0.0/8"
  vpc_name   = "bgg-vpc-shanghai-b"
}
resource "alicloud_vpc_switch" "default" {
  vpc_id     = alicloud_vpc_network.default.id
  zone_id    = var.zoneId
  cidr_block = var.cidrBlock
}
resource "alicloud_mongodb_instance" "default" {
  engine_version      = "5.0"
  storage_type        = "cloud_essd1"
  vswitch_id          = alicloud_vpc_switch.default.id
  db_instance_storage = "20"
  vpc_id              = alicloud_vpc_network.default.id
  db_instance_class   = "mdb.shard.4x.large.d"
  storage_engine      = "WiredTiger"
  network_type        = "VPC"
  zone_id             = var.zoneId
  replication_factor  = "3"
  readonly_replicas   = "0"
}
resource "alicloud_mongodb_backup" "default" {
  backup_method           = "Snapshot"
  db_instance_id          = alicloud_mongodb_instance.default.id
  backup_retention_period = 7
}
variable "name" {
  type    = string
  default = "terraform-example"
}
variable "zoneId" {
  type    = string
  default = "cn-shanghai-b"
}
variable "cidrBlock" {
  type    = string
  default = "10.0.0.0/24"
}
output "alicloudMongodbBackupExampleId" {
  value = data.alicloud_mongodb_getbackups.default.backups[0].id
}

function getBackups(args: GetBackupsArgs, opts?: InvokeOptions): Promise<GetBackupsResult>
function getBackupsOutput(args: GetBackupsOutputArgs, opts?: InvokeOutputOptions): Output<GetBackupsResult>

def get_backups(backup_id: Optional[str] = None,
                db_instance_id: Optional[str] = None,
                enable_details: Optional[bool] = None,
                end_time: Optional[str] = None,
                ids: Optional[Sequence[str]] = None,
                output_file: Optional[str] = None,
                start_time: Optional[str] = None,
                opts: Optional[InvokeOptions] = None) -> GetBackupsResult
def get_backups_output(backup_id: pulumi.Input[Optional[str]] = None,
                db_instance_id: pulumi.Input[Optional[str]] = None,
                enable_details: pulumi.Input[Optional[bool]] = None,
                end_time: pulumi.Input[Optional[str]] = None,
                ids: pulumi.Input[Optional[Sequence[pulumi.Input[str]]]] = None,
                output_file: pulumi.Input[Optional[str]] = None,
                start_time: pulumi.Input[Optional[str]] = None,
                opts: Optional[InvokeOutputOptions] = None) -> Output[GetBackupsResult]

func GetBackups(ctx *Context, args *GetBackupsArgs, opts ...InvokeOption) (*GetBackupsResult, error)
func GetBackupsOutput(ctx *Context, args *GetBackupsOutputArgs, opts ...InvokeOption) GetBackupsResultOutput

public static class GetBackups 
{
    public static Task<GetBackupsResult> InvokeAsync(GetBackupsArgs args, InvokeOptions? opts = null)
    public static Output<GetBackupsResult> Invoke(GetBackupsInvokeArgs args, InvokeOptions? opts = null)
    public static Output<GetBackupsResult> Invoke(GetBackupsInvokeArgs args, InvokeOutputOptions opts)
}

public static CompletableFuture<GetBackupsResult> getBackups(GetBackupsArgs args, InvokeOptions options)
public static Output<GetBackupsResult> getBackups(GetBackupsArgs args, InvokeOptions options)
public static Output<GetBackupsResult> getBackups(GetBackupsArgs args, InvokeOutputOptions options)

fn::invoke:
  function: alicloud:mongodb/getBackups:getBackups
  arguments:
    # arguments dictionary

data "alicloud_mongodb_get_backups" "name" {
    # arguments
}