ovh.CloudProjectDatabase.getKafkaUserAccess

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

const access = ovh.CloudProjectDatabase.getKafkaUserAccess({
    serviceName: "XXX",
    clusterId: "YYY",
    userId: "ZZZ",
});
export const accessCert = access.then(access => access.cert);

import pulumi
import pulumi_ovh as ovh

access = ovh.CloudProjectDatabase.get_kafka_user_access(service_name="XXX",
    cluster_id="YYY",
    user_id="ZZZ")
pulumi.export("accessCert", access.cert)

package main

import (
	"github.com/ovh/pulumi-ovh/sdk/go/ovh/CloudProjectDatabase"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		access, err := CloudProjectDatabase.GetKafkaUserAccess(ctx, &cloudprojectdatabase.GetKafkaUserAccessArgs{
			ServiceName: "XXX",
			ClusterId:   "YYY",
			UserId:      "ZZZ",
		}, nil)
		if err != nil {
			return err
		}
		ctx.Export("accessCert", access.Cert)
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var access = Ovh.CloudProjectDatabase.GetKafkaUserAccess.Invoke(new()
    {
        ServiceName = "XXX",
        ClusterId = "YYY",
        UserId = "ZZZ",
    });

    return new Dictionary<string, object?>
    {
        ["accessCert"] = access.Apply(getKafkaUserAccessResult => getKafkaUserAccessResult.Cert),
    };
});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.ovh.CloudProjectDatabase.CloudProjectDatabaseFunctions;
import com.pulumi.ovh.CloudProjectDatabase.inputs.GetKafkaUserAccessArgs;
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 access = CloudProjectDatabaseFunctions.getKafkaUserAccess(GetKafkaUserAccessArgs.builder()
            .serviceName("XXX")
            .clusterId("YYY")
            .userId("ZZZ")
            .build());

        ctx.export("accessCert", access.applyValue(getKafkaUserAccessResult -> getKafkaUserAccessResult.cert()));
    }
}

variables:
  access:
    fn::invoke:
      Function: ovh:CloudProjectDatabase:getKafkaUserAccess
      Arguments:
        serviceName: XXX
        clusterId: YYY
        userId: ZZZ
outputs:
  accessCert: ${access.cert}

function getKafkaUserAccess(args: GetKafkaUserAccessArgs, opts?: InvokeOptions): Promise<GetKafkaUserAccessResult>
function getKafkaUserAccessOutput(args: GetKafkaUserAccessOutputArgs, opts?: InvokeOptions): Output<GetKafkaUserAccessResult>

def get_kafka_user_access(cluster_id: Optional[str] = None,
                          service_name: Optional[str] = None,
                          user_id: Optional[str] = None,
                          opts: Optional[InvokeOptions] = None) -> GetKafkaUserAccessResult
def get_kafka_user_access_output(cluster_id: Optional[pulumi.Input[str]] = None,
                          service_name: Optional[pulumi.Input[str]] = None,
                          user_id: Optional[pulumi.Input[str]] = None,
                          opts: Optional[InvokeOptions] = None) -> Output[GetKafkaUserAccessResult]

func GetKafkaUserAccess(ctx *Context, args *GetKafkaUserAccessArgs, opts ...InvokeOption) (*GetKafkaUserAccessResult, error)
func GetKafkaUserAccessOutput(ctx *Context, args *GetKafkaUserAccessOutputArgs, opts ...InvokeOption) GetKafkaUserAccessResultOutput

public static class GetKafkaUserAccess 
{
    public static Task<GetKafkaUserAccessResult> InvokeAsync(GetKafkaUserAccessArgs args, InvokeOptions? opts = null)
    public static Output<GetKafkaUserAccessResult> Invoke(GetKafkaUserAccessInvokeArgs args, InvokeOptions? opts = null)
}

public static CompletableFuture<GetKafkaUserAccessResult> getKafkaUserAccess(GetKafkaUserAccessArgs args, InvokeOptions options)
// Output-based functions aren't available in Java yet

fn::invoke:
  function: ovh:CloudProjectDatabase/getKafkaUserAccess:getKafkaUserAccess
  arguments:
    # arguments dictionary