vault.identity.getOidcClientCreds

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

const app = new vault.identity.OidcClient("app", {
    redirectUris: [
        "http://127.0.0.1:9200/v1/auth-methods/oidc:authenticate:callback",
        "http://127.0.0.1:8251/callback",
        "http://127.0.0.1:8080/callback",
    ],
    idTokenTtl: 2400,
    accessTokenTtl: 7200,
});
const creds = vault.identity.getOidcClientCredsOutput({
    name: app.name,
});

import pulumi
import pulumi_vault as vault

app = vault.identity.OidcClient("app",
    redirect_uris=[
        "http://127.0.0.1:9200/v1/auth-methods/oidc:authenticate:callback",
        "http://127.0.0.1:8251/callback",
        "http://127.0.0.1:8080/callback",
    ],
    id_token_ttl=2400,
    access_token_ttl=7200)
creds = vault.identity.get_oidc_client_creds_output(name=app.name)

package main

import (
	"github.com/pulumi/pulumi-vault/sdk/v6/go/vault/identity"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		app, err := identity.NewOidcClient(ctx, "app", &identity.OidcClientArgs{
			RedirectUris: pulumi.StringArray{
				pulumi.String("http://127.0.0.1:9200/v1/auth-methods/oidc:authenticate:callback"),
				pulumi.String("http://127.0.0.1:8251/callback"),
				pulumi.String("http://127.0.0.1:8080/callback"),
			},
			IdTokenTtl:     pulumi.Int(2400),
			AccessTokenTtl: pulumi.Int(7200),
		})
		if err != nil {
			return err
		}
		_ = identity.GetOidcClientCredsOutput(ctx, identity.GetOidcClientCredsOutputArgs{
			Name: app.Name,
		}, nil)
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var app = new Vault.Identity.OidcClient("app", new()
    {
        RedirectUris = new[]
        {
            "http://127.0.0.1:9200/v1/auth-methods/oidc:authenticate:callback",
            "http://127.0.0.1:8251/callback",
            "http://127.0.0.1:8080/callback",
        },
        IdTokenTtl = 2400,
        AccessTokenTtl = 7200,
    });

    var creds = Vault.Identity.GetOidcClientCreds.Invoke(new()
    {
        Name = app.Name,
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.vault.identity.OidcClient;
import com.pulumi.vault.identity.OidcClientArgs;
import com.pulumi.vault.identity.IdentityFunctions;
import com.pulumi.vault.identity.inputs.GetOidcClientCredsArgs;
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) {
        var app = new OidcClient("app", OidcClientArgs.builder()        
            .redirectUris(            
                "http://127.0.0.1:9200/v1/auth-methods/oidc:authenticate:callback",
                "http://127.0.0.1:8251/callback",
                "http://127.0.0.1:8080/callback")
            .idTokenTtl(2400)
            .accessTokenTtl(7200)
            .build());

        final var creds = IdentityFunctions.getOidcClientCreds(GetOidcClientCredsArgs.builder()
            .name(app.name())
            .build());

    }
}

resources:
  app:
    type: vault:identity:OidcClient
    properties:
      redirectUris:
        - http://127.0.0.1:9200/v1/auth-methods/oidc:authenticate:callback
        - http://127.0.0.1:8251/callback
        - http://127.0.0.1:8080/callback
      idTokenTtl: 2400
      accessTokenTtl: 7200
variables:
  creds:
    fn::invoke:
      Function: vault:identity:getOidcClientCreds
      Arguments:
        name: ${app.name}

function getOidcClientCreds(args: GetOidcClientCredsArgs, opts?: InvokeOptions): Promise<GetOidcClientCredsResult>
function getOidcClientCredsOutput(args: GetOidcClientCredsOutputArgs, opts?: InvokeOptions): Output<GetOidcClientCredsResult>

def get_oidc_client_creds(name: Optional[str] = None,
                          namespace: Optional[str] = None,
                          opts: Optional[InvokeOptions] = None) -> GetOidcClientCredsResult
def get_oidc_client_creds_output(name: Optional[pulumi.Input[str]] = None,
                          namespace: Optional[pulumi.Input[str]] = None,
                          opts: Optional[InvokeOptions] = None) -> Output[GetOidcClientCredsResult]

func GetOidcClientCreds(ctx *Context, args *GetOidcClientCredsArgs, opts ...InvokeOption) (*GetOidcClientCredsResult, error)
func GetOidcClientCredsOutput(ctx *Context, args *GetOidcClientCredsOutputArgs, opts ...InvokeOption) GetOidcClientCredsResultOutput

public static class GetOidcClientCreds 
{
    public static Task<GetOidcClientCredsResult> InvokeAsync(GetOidcClientCredsArgs args, InvokeOptions? opts = null)
    public static Output<GetOidcClientCredsResult> Invoke(GetOidcClientCredsInvokeArgs args, InvokeOptions? opts = null)
}

public static CompletableFuture<GetOidcClientCredsResult> getOidcClientCreds(GetOidcClientCredsArgs args, InvokeOptions options)
// Output-based functions aren't available in Java yet

fn::invoke:
  function: vault:identity/getOidcClientCreds:getOidcClientCreds
  arguments:
    # arguments dictionary