tencentcloud.getCamOidcConfig

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

const oidcConfig = tencentcloud.getCamOidcConfig({
    name: "cls-kzilgv5m",
});
export const identityKey = oidcConfig.then(oidcConfig => oidcConfig.identityKey);
export const identityUrl = oidcConfig.then(oidcConfig => oidcConfig.identityUrl);

import pulumi
import pulumi_tencentcloud as tencentcloud

oidc_config = tencentcloud.get_cam_oidc_config(name="cls-kzilgv5m")
pulumi.export("identityKey", oidc_config.identity_key)
pulumi.export("identityUrl", oidc_config.identity_url)

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 {
		oidcConfig, err := tencentcloud.GetCamOidcConfig(ctx, &tencentcloud.GetCamOidcConfigArgs{
			Name: "cls-kzilgv5m",
		}, nil)
		if err != nil {
			return err
		}
		ctx.Export("identityKey", oidcConfig.IdentityKey)
		ctx.Export("identityUrl", oidcConfig.IdentityUrl)
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var oidcConfig = Tencentcloud.GetCamOidcConfig.Invoke(new()
    {
        Name = "cls-kzilgv5m",
    });

    return new Dictionary<string, object?>
    {
        ["identityKey"] = oidcConfig.Apply(getCamOidcConfigResult => getCamOidcConfigResult.IdentityKey),
        ["identityUrl"] = oidcConfig.Apply(getCamOidcConfigResult => getCamOidcConfigResult.IdentityUrl),
    };
});

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.GetCamOidcConfigArgs;
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 oidcConfig = TencentcloudFunctions.getCamOidcConfig(GetCamOidcConfigArgs.builder()
            .name("cls-kzilgv5m")
            .build());

        ctx.export("identityKey", oidcConfig.applyValue(getCamOidcConfigResult -> getCamOidcConfigResult.identityKey()));
        ctx.export("identityUrl", oidcConfig.applyValue(getCamOidcConfigResult -> getCamOidcConfigResult.identityUrl()));
    }
}

variables:
  oidcConfig:
    fn::invoke:
      function: tencentcloud:getCamOidcConfig
      arguments:
        name: cls-kzilgv5m
outputs:
  identityKey: ${oidcConfig.identityKey}
  identityUrl: ${oidcConfig.identityUrl}

function getCamOidcConfig(args: GetCamOidcConfigArgs, opts?: InvokeOptions): Promise<GetCamOidcConfigResult>
function getCamOidcConfigOutput(args: GetCamOidcConfigOutputArgs, opts?: InvokeOptions): Output<GetCamOidcConfigResult>

def get_cam_oidc_config(id: Optional[str] = None,
                        name: Optional[str] = None,
                        result_output_file: Optional[str] = None,
                        opts: Optional[InvokeOptions] = None) -> GetCamOidcConfigResult
def get_cam_oidc_config_output(id: Optional[pulumi.Input[str]] = None,
                        name: Optional[pulumi.Input[str]] = None,
                        result_output_file: Optional[pulumi.Input[str]] = None,
                        opts: Optional[InvokeOptions] = None) -> Output[GetCamOidcConfigResult]

func GetCamOidcConfig(ctx *Context, args *GetCamOidcConfigArgs, opts ...InvokeOption) (*GetCamOidcConfigResult, error)
func GetCamOidcConfigOutput(ctx *Context, args *GetCamOidcConfigOutputArgs, opts ...InvokeOption) GetCamOidcConfigResultOutput

public static class GetCamOidcConfig 
{
    public static Task<GetCamOidcConfigResult> InvokeAsync(GetCamOidcConfigArgs args, InvokeOptions? opts = null)
    public static Output<GetCamOidcConfigResult> Invoke(GetCamOidcConfigInvokeArgs args, InvokeOptions? opts = null)
}

public static CompletableFuture<GetCamOidcConfigResult> getCamOidcConfig(GetCamOidcConfigArgs args, InvokeOptions options)
public static Output<GetCamOidcConfigResult> getCamOidcConfig(GetCamOidcConfigArgs args, InvokeOptions options)

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