tencentcloud.getPostgresqlBackupDownloadUrls

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

const logBackups = tencentcloud.getPostgresqlLogBackups({
    minFinishTime: "%s",
    maxFinishTime: "%s",
    filters: [{
        name: "db-instance-id",
        values: [local.pgsql_id],
    }],
    orderBy: "StartTime",
    orderByType: "desc",
});
const backupDownloadUrls = logBackups.then(logBackups => tencentcloud.getPostgresqlBackupDownloadUrls({
    dbInstanceId: local.pgsql_id,
    backupType: "LogBackup",
    backupId: logBackups.logBackupSets?.[0]?.id,
    urlExpireTime: 12,
    backupDownloadRestriction: {
        restrictionType: "NONE",
        vpcRestrictionEffect: "ALLOW",
        vpcIdSets: [local.vpc_id],
        ipRestrictionEffect: "ALLOW",
        ipSets: ["0.0.0.0"],
    },
}));

import pulumi
import pulumi_tencentcloud as tencentcloud

log_backups = tencentcloud.get_postgresql_log_backups(min_finish_time="%s",
    max_finish_time="%s",
    filters=[{
        "name": "db-instance-id",
        "values": [local["pgsql_id"]],
    }],
    order_by="StartTime",
    order_by_type="desc")
backup_download_urls = tencentcloud.get_postgresql_backup_download_urls(db_instance_id=local["pgsql_id"],
    backup_type="LogBackup",
    backup_id=log_backups.log_backup_sets[0].id,
    url_expire_time=12,
    backup_download_restriction={
        "restriction_type": "NONE",
        "vpc_restriction_effect": "ALLOW",
        "vpc_id_sets": [local["vpc_id"]],
        "ip_restriction_effect": "ALLOW",
        "ip_sets": ["0.0.0.0"],
    })

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 {
logBackups, err := tencentcloud.GetPostgresqlLogBackups(ctx, &tencentcloud.GetPostgresqlLogBackupsArgs{
MinFinishTime: pulumi.StringRef("%s"),
MaxFinishTime: pulumi.StringRef("%s"),
Filters: []tencentcloud.GetPostgresqlLogBackupsFilter{
{
Name: pulumi.StringRef("db-instance-id"),
Values: interface{}{
local.Pgsql_id,
},
},
},
OrderBy: pulumi.StringRef("StartTime"),
OrderByType: pulumi.StringRef("desc"),
}, nil);
if err != nil {
return err
}
_, err = tencentcloud.GetPostgresqlBackupDownloadUrls(ctx, &tencentcloud.GetPostgresqlBackupDownloadUrlsArgs{
DbInstanceId: local.Pgsql_id,
BackupType: "LogBackup",
BackupId: logBackups.LogBackupSets[0].Id,
UrlExpireTime: pulumi.Float64Ref(12),
BackupDownloadRestriction: tencentcloud.GetPostgresqlBackupDownloadUrlsBackupDownloadRestriction{
RestrictionType: pulumi.StringRef("NONE"),
VpcRestrictionEffect: pulumi.StringRef("ALLOW"),
VpcIdSets: interface{}{
local.Vpc_id,
},
IpRestrictionEffect: pulumi.StringRef("ALLOW"),
IpSets: []string{
"0.0.0.0",
},
},
}, nil);
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 logBackups = Tencentcloud.GetPostgresqlLogBackups.Invoke(new()
    {
        MinFinishTime = "%s",
        MaxFinishTime = "%s",
        Filters = new[]
        {
            new Tencentcloud.Inputs.GetPostgresqlLogBackupsFilterInputArgs
            {
                Name = "db-instance-id",
                Values = new[]
                {
                    local.Pgsql_id,
                },
            },
        },
        OrderBy = "StartTime",
        OrderByType = "desc",
    });

    var backupDownloadUrls = Tencentcloud.GetPostgresqlBackupDownloadUrls.Invoke(new()
    {
        DbInstanceId = local.Pgsql_id,
        BackupType = "LogBackup",
        BackupId = logBackups.Apply(getPostgresqlLogBackupsResult => getPostgresqlLogBackupsResult.LogBackupSets[0]?.Id),
        UrlExpireTime = 12,
        BackupDownloadRestriction = new Tencentcloud.Inputs.GetPostgresqlBackupDownloadUrlsBackupDownloadRestrictionInputArgs
        {
            RestrictionType = "NONE",
            VpcRestrictionEffect = "ALLOW",
            VpcIdSets = new[]
            {
                local.Vpc_id,
            },
            IpRestrictionEffect = "ALLOW",
            IpSets = new[]
            {
                "0.0.0.0",
            },
        },
    });

});

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.GetPostgresqlLogBackupsArgs;
import com.pulumi.tencentcloud.inputs.GetPostgresqlBackupDownloadUrlsArgs;
import com.pulumi.tencentcloud.inputs.GetPostgresqlBackupDownloadUrlsBackupDownloadRestrictionArgs;
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 logBackups = TencentcloudFunctions.getPostgresqlLogBackups(GetPostgresqlLogBackupsArgs.builder()
            .minFinishTime("%s")
            .maxFinishTime("%s")
            .filters(GetPostgresqlLogBackupsFilterArgs.builder()
                .name("db-instance-id")
                .values(local.pgsql_id())
                .build())
            .orderBy("StartTime")
            .orderByType("desc")
            .build());

        final var backupDownloadUrls = TencentcloudFunctions.getPostgresqlBackupDownloadUrls(GetPostgresqlBackupDownloadUrlsArgs.builder()
            .dbInstanceId(local.pgsql_id())
            .backupType("LogBackup")
            .backupId(logBackups.applyValue(getPostgresqlLogBackupsResult -> getPostgresqlLogBackupsResult.logBackupSets()[0].id()))
            .urlExpireTime(12)
            .backupDownloadRestriction(GetPostgresqlBackupDownloadUrlsBackupDownloadRestrictionArgs.builder()
                .restrictionType("NONE")
                .vpcRestrictionEffect("ALLOW")
                .vpcIdSets(local.vpc_id())
                .ipRestrictionEffect("ALLOW")
                .ipSets("0.0.0.0")
                .build())
            .build());

    }
}

variables:
  logBackups:
    fn::invoke:
      function: tencentcloud:getPostgresqlLogBackups
      arguments:
        minFinishTime: '%s'
        maxFinishTime: '%s'
        filters:
          - name: db-instance-id
            values:
              - ${local.pgsql_id}
        orderBy: StartTime
        orderByType: desc
  backupDownloadUrls:
    fn::invoke:
      function: tencentcloud:getPostgresqlBackupDownloadUrls
      arguments:
        dbInstanceId: ${local.pgsql_id}
        backupType: LogBackup
        backupId: ${logBackups.logBackupSets[0].id}
        urlExpireTime: 12
        backupDownloadRestriction:
          restrictionType: NONE
          vpcRestrictionEffect: ALLOW
          vpcIdSets:
            - ${local.vpc_id}
          ipRestrictionEffect: ALLOW
          ipSets:
            - 0.0.0.0

function getPostgresqlBackupDownloadUrls(args: GetPostgresqlBackupDownloadUrlsArgs, opts?: InvokeOptions): Promise<GetPostgresqlBackupDownloadUrlsResult>
function getPostgresqlBackupDownloadUrlsOutput(args: GetPostgresqlBackupDownloadUrlsOutputArgs, opts?: InvokeOptions): Output<GetPostgresqlBackupDownloadUrlsResult>

def get_postgresql_backup_download_urls(backup_download_restriction: Optional[GetPostgresqlBackupDownloadUrlsBackupDownloadRestriction] = None,
                                        backup_id: Optional[str] = None,
                                        backup_type: Optional[str] = None,
                                        db_instance_id: Optional[str] = None,
                                        id: Optional[str] = None,
                                        result_output_file: Optional[str] = None,
                                        url_expire_time: Optional[float] = None,
                                        opts: Optional[InvokeOptions] = None) -> GetPostgresqlBackupDownloadUrlsResult
def get_postgresql_backup_download_urls_output(backup_download_restriction: Optional[pulumi.Input[GetPostgresqlBackupDownloadUrlsBackupDownloadRestrictionArgs]] = None,
                                        backup_id: Optional[pulumi.Input[str]] = None,
                                        backup_type: Optional[pulumi.Input[str]] = None,
                                        db_instance_id: Optional[pulumi.Input[str]] = None,
                                        id: Optional[pulumi.Input[str]] = None,
                                        result_output_file: Optional[pulumi.Input[str]] = None,
                                        url_expire_time: Optional[pulumi.Input[float]] = None,
                                        opts: Optional[InvokeOptions] = None) -> Output[GetPostgresqlBackupDownloadUrlsResult]

func GetPostgresqlBackupDownloadUrls(ctx *Context, args *GetPostgresqlBackupDownloadUrlsArgs, opts ...InvokeOption) (*GetPostgresqlBackupDownloadUrlsResult, error)
func GetPostgresqlBackupDownloadUrlsOutput(ctx *Context, args *GetPostgresqlBackupDownloadUrlsOutputArgs, opts ...InvokeOption) GetPostgresqlBackupDownloadUrlsResultOutput

public static class GetPostgresqlBackupDownloadUrls 
{
    public static Task<GetPostgresqlBackupDownloadUrlsResult> InvokeAsync(GetPostgresqlBackupDownloadUrlsArgs args, InvokeOptions? opts = null)
    public static Output<GetPostgresqlBackupDownloadUrlsResult> Invoke(GetPostgresqlBackupDownloadUrlsInvokeArgs args, InvokeOptions? opts = null)
}

public static CompletableFuture<GetPostgresqlBackupDownloadUrlsResult> getPostgresqlBackupDownloadUrls(GetPostgresqlBackupDownloadUrlsArgs args, InvokeOptions options)
public static Output<GetPostgresqlBackupDownloadUrlsResult> getPostgresqlBackupDownloadUrls(GetPostgresqlBackupDownloadUrlsArgs args, InvokeOptions options)

fn::invoke:
  function: tencentcloud:index/getPostgresqlBackupDownloadUrls:getPostgresqlBackupDownloadUrls
  arguments:
    # arguments dictionary