alicloud.gpdb.getApiKeys

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

const config = new pulumi.Config();
const workspaceId = config.get("workspaceId") || "ws-xxxxxxx";
const _default = alicloud.gpdb.getApiKeys({
    workspaceId: workspaceId,
});
export const gpdbApiKeyId = _default.then(_default => _default.keys?.[0]?.keyId);

import pulumi
import pulumi_alicloud as alicloud

config = pulumi.Config()
workspace_id = config.get("workspaceId")
if workspace_id is None:
    workspace_id = "ws-xxxxxxx"
default = alicloud.gpdb.get_api_keys(workspace_id=workspace_id)
pulumi.export("gpdbApiKeyId", default.keys[0].key_id)

package main

import (
	"github.com/pulumi/pulumi-alicloud/sdk/v3/go/alicloud/gpdb"
	"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, "")
		workspaceId := "ws-xxxxxxx"
		if param := cfg.Get("workspaceId"); param != "" {
			workspaceId = param
		}
		_default, err := gpdb.GetApiKeys(ctx, &gpdb.GetApiKeysArgs{
			WorkspaceId: workspaceId,
		}, nil)
		if err != nil {
			return err
		}
		ctx.Export("gpdbApiKeyId", _default.Keys[0].KeyId)
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var config = new Config();
    var workspaceId = config.Get("workspaceId") ?? "ws-xxxxxxx";
    var @default = AliCloud.Gpdb.GetApiKeys.Invoke(new()
    {
        WorkspaceId = workspaceId,
    });

    return new Dictionary<string, object?>
    {
        ["gpdbApiKeyId"] = @default.Apply(@default => @default.Apply(getApiKeysResult => getApiKeysResult.Keys[0]?.KeyId)),
    };
});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.alicloud.gpdb.GpdbFunctions;
import com.pulumi.alicloud.gpdb.inputs.GetApiKeysArgs;
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 workspaceId = config.get("workspaceId").orElse("ws-xxxxxxx");
        final var default = GpdbFunctions.getApiKeys(GetApiKeysArgs.builder()
            .workspaceId(workspaceId)
            .build());

        ctx.export("gpdbApiKeyId", default_.keys()[0].keyId());
    }
}

configuration:
  workspaceId:
    type: string
    default: ws-xxxxxxx
variables:
  default:
    fn::invoke:
      function: alicloud:gpdb:getApiKeys
      arguments:
        workspaceId: ${workspaceId}
outputs:
  gpdbApiKeyId: ${default.keys[0].keyId}

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

data "alicloud_gpdb_getapikeys" "default" {
  workspace_id = var.workspaceId
}

variable "workspaceId" {
  type    = string
  default = "ws-xxxxxxx"
}
output "gpdbApiKeyId" {
  value = data.alicloud_gpdb_getapikeys.default.keys[0].key_id
}

function getApiKeys(args: GetApiKeysArgs, opts?: InvokeOptions): Promise<GetApiKeysResult>
function getApiKeysOutput(args: GetApiKeysOutputArgs, opts?: InvokeOutputOptions): Output<GetApiKeysResult>

def get_api_keys(ids: Optional[Sequence[str]] = None,
                 output_file: Optional[str] = None,
                 workspace_id: Optional[str] = None,
                 opts: Optional[InvokeOptions] = None) -> GetApiKeysResult
def get_api_keys_output(ids: pulumi.Input[Optional[Sequence[pulumi.Input[str]]]] = None,
                 output_file: pulumi.Input[Optional[str]] = None,
                 workspace_id: pulumi.Input[Optional[str]] = None,
                 opts: Optional[InvokeOutputOptions] = None) -> Output[GetApiKeysResult]

func GetApiKeys(ctx *Context, args *GetApiKeysArgs, opts ...InvokeOption) (*GetApiKeysResult, error)
func GetApiKeysOutput(ctx *Context, args *GetApiKeysOutputArgs, opts ...InvokeOption) GetApiKeysResultOutput

public static class GetApiKeys 
{
    public static Task<GetApiKeysResult> InvokeAsync(GetApiKeysArgs args, InvokeOptions? opts = null)
    public static Output<GetApiKeysResult> Invoke(GetApiKeysInvokeArgs args, InvokeOptions? opts = null)
    public static Output<GetApiKeysResult> Invoke(GetApiKeysInvokeArgs args, InvokeOutputOptions opts)
}

public static CompletableFuture<GetApiKeysResult> getApiKeys(GetApiKeysArgs args, InvokeOptions options)
public static Output<GetApiKeysResult> getApiKeys(GetApiKeysArgs args, InvokeOptions options)
public static Output<GetApiKeysResult> getApiKeys(GetApiKeysArgs args, InvokeOutputOptions options)

fn::invoke:
  function: alicloud:gpdb/getApiKeys:getApiKeys
  arguments:
    # arguments dictionary

data "alicloud_gpdb_get_api_keys" "name" {
    # arguments
}