authentik.getCertificateKeyPair

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

const generated = authentik.getCertificateKeyPair({
    name: "authentik Self-signed Certificate",
});

import pulumi
import pulumi_authentik as authentik

generated = authentik.get_certificate_key_pair(name="authentik Self-signed Certificate")

package main

import (
	"github.com/pulumi/pulumi-terraform-provider/sdks/go/authentik/v2025/authentik"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := authentik.LookupCertificateKeyPair(ctx, &authentik.LookupCertificateKeyPairArgs{
			Name: "authentik Self-signed Certificate",
		}, nil)
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var generated = Authentik.GetCertificateKeyPair.Invoke(new()
    {
        Name = "authentik Self-signed Certificate",
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.authentik.AuthentikFunctions;
import com.pulumi.authentik.inputs.GetCertificateKeyPairArgs;
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 generated = AuthentikFunctions.getCertificateKeyPair(GetCertificateKeyPairArgs.builder()
            .name("authentik Self-signed Certificate")
            .build());

    }
}

variables:
  generated:
    fn::invoke:
      function: authentik:getCertificateKeyPair
      arguments:
        name: authentik Self-signed Certificate

function getCertificateKeyPair(args: GetCertificateKeyPairArgs, opts?: InvokeOptions): Promise<GetCertificateKeyPairResult>
function getCertificateKeyPairOutput(args: GetCertificateKeyPairOutputArgs, opts?: InvokeOptions): Output<GetCertificateKeyPairResult>

def get_certificate_key_pair(fetch_certificate: Optional[bool] = None,
                             fetch_key: Optional[bool] = None,
                             key_data: Optional[str] = None,
                             name: Optional[str] = None,
                             opts: Optional[InvokeOptions] = None) -> GetCertificateKeyPairResult
def get_certificate_key_pair_output(fetch_certificate: Optional[pulumi.Input[bool]] = None,
                             fetch_key: Optional[pulumi.Input[bool]] = None,
                             key_data: Optional[pulumi.Input[str]] = None,
                             name: Optional[pulumi.Input[str]] = None,
                             opts: Optional[InvokeOptions] = None) -> Output[GetCertificateKeyPairResult]

func LookupCertificateKeyPair(ctx *Context, args *LookupCertificateKeyPairArgs, opts ...InvokeOption) (*LookupCertificateKeyPairResult, error)
func LookupCertificateKeyPairOutput(ctx *Context, args *LookupCertificateKeyPairOutputArgs, opts ...InvokeOption) LookupCertificateKeyPairResultOutput

public static class GetCertificateKeyPair 
{
    public static Task<GetCertificateKeyPairResult> InvokeAsync(GetCertificateKeyPairArgs args, InvokeOptions? opts = null)
    public static Output<GetCertificateKeyPairResult> Invoke(GetCertificateKeyPairInvokeArgs args, InvokeOptions? opts = null)
}

public static CompletableFuture<GetCertificateKeyPairResult> getCertificateKeyPair(GetCertificateKeyPairArgs args, InvokeOptions options)
public static Output<GetCertificateKeyPairResult> getCertificateKeyPair(GetCertificateKeyPairArgs args, InvokeOptions options)

fn::invoke:
  function: authentik:index/getCertificateKeyPair:getCertificateKeyPair
  arguments:
    # arguments dictionary