vault.identity.OidcKeyAllowedClientID

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

return await Deployment.RunAsync(() => 
{
    var key = new Vault.Identity.OidcKey("key", new()
    {
        Algorithm = "RS256",
    });

    var roleOidcRole = new Vault.Identity.OidcRole("roleOidcRole", new()
    {
        Key = key.Name,
    });

    var roleOidcKeyAllowedClientID = new Vault.Identity.OidcKeyAllowedClientID("roleOidcKeyAllowedClientID", new()
    {
        KeyName = key.Name,
        AllowedClientId = roleOidcRole.ClientId,
    });

});

package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		key, err := identity.NewOidcKey(ctx, "key", &identity.OidcKeyArgs{
			Algorithm: pulumi.String("RS256"),
		})
		if err != nil {
			return err
		}
		roleOidcRole, err := identity.NewOidcRole(ctx, "roleOidcRole", &identity.OidcRoleArgs{
			Key: key.Name,
		})
		if err != nil {
			return err
		}
		_, err = identity.NewOidcKeyAllowedClientID(ctx, "roleOidcKeyAllowedClientID", &identity.OidcKeyAllowedClientIDArgs{
			KeyName:         key.Name,
			AllowedClientId: roleOidcRole.ClientId,
		})
		if err != nil {
			return err
		}
		return nil
	})
}

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.vault.identity.OidcKey;
import com.pulumi.vault.identity.OidcKeyArgs;
import com.pulumi.vault.identity.OidcRole;
import com.pulumi.vault.identity.OidcRoleArgs;
import com.pulumi.vault.identity.OidcKeyAllowedClientID;
import com.pulumi.vault.identity.OidcKeyAllowedClientIDArgs;
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 key = new OidcKey("key", OidcKeyArgs.builder()        
            .algorithm("RS256")
            .build());

        var roleOidcRole = new OidcRole("roleOidcRole", OidcRoleArgs.builder()        
            .key(key.name())
            .build());

        var roleOidcKeyAllowedClientID = new OidcKeyAllowedClientID("roleOidcKeyAllowedClientID", OidcKeyAllowedClientIDArgs.builder()        
            .keyName(key.name())
            .allowedClientId(roleOidcRole.clientId())
            .build());

    }
}

import pulumi
import pulumi_vault as vault

key = vault.identity.OidcKey("key", algorithm="RS256")
role_oidc_role = vault.identity.OidcRole("roleOidcRole", key=key.name)
role_oidc_key_allowed_client_id = vault.identity.OidcKeyAllowedClientID("roleOidcKeyAllowedClientID",
    key_name=key.name,
    allowed_client_id=role_oidc_role.client_id)

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

const key = new vault.identity.OidcKey("key", {algorithm: "RS256"});
const roleOidcRole = new vault.identity.OidcRole("roleOidcRole", {key: key.name});
const roleOidcKeyAllowedClientID = new vault.identity.OidcKeyAllowedClientID("roleOidcKeyAllowedClientID", {
    keyName: key.name,
    allowedClientId: roleOidcRole.clientId,
});

resources:
  key:
    type: vault:identity:OidcKey
    properties:
      algorithm: RS256
  roleOidcRole:
    type: vault:identity:OidcRole
    properties:
      key: ${key.name}
  roleOidcKeyAllowedClientID:
    type: vault:identity:OidcKeyAllowedClientID
    properties:
      keyName: ${key.name}
      allowedClientId: ${roleOidcRole.clientId}