incident.getApiKey

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

// Look up an existing API key by name, such as one created in the dashboard.
const ci = incident.getApiKey({
    name: "CI deploy key",
});
// Or by ID, to reference a key another module manages. Names aren't unique, so an ID is
// the way through an ambiguous lookup.
const reporting = incident.getApiKey({
    id: "01G0J1EXE7AXZ2C93K61WBPYEH",
});
export const ciKeyRoles = ci.then(ci => ci.roleNames);
export const ciKeyLastUsedAt = ci.then(ci => ci.lastUsedAt);

import pulumi
import pulumi_incident as incident

# Look up an existing API key by name, such as one created in the dashboard.
ci = incident.get_api_key(name="CI deploy key")
# Or by ID, to reference a key another module manages. Names aren't unique, so an ID is
# the way through an ambiguous lookup.
reporting = incident.get_api_key(id="01G0J1EXE7AXZ2C93K61WBPYEH")
pulumi.export("ciKeyRoles", ci.role_names)
pulumi.export("ciKeyLastUsedAt", ci.last_used_at)

package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		// Look up an existing API key by name, such as one created in the dashboard.
		ci, err := incident.LookupApiKey(ctx, &incident.LookupApiKeyArgs{
			Name: pulumi.StringRef("CI deploy key"),
		}, nil)
		if err != nil {
			return err
		}
		// Or by ID, to reference a key another module manages. Names aren't unique, so an ID is
		// the way through an ambiguous lookup.
		_, err = incident.LookupApiKey(ctx, &incident.LookupApiKeyArgs{
			Id: pulumi.StringRef("01G0J1EXE7AXZ2C93K61WBPYEH"),
		}, nil)
		if err != nil {
			return err
		}
		ctx.Export("ciKeyRoles", ci.RoleNames)
		ctx.Export("ciKeyLastUsedAt", ci.LastUsedAt)
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    // Look up an existing API key by name, such as one created in the dashboard.
    var ci = Incident.GetApiKey.Invoke(new()
    {
        Name = "CI deploy key",
    });

    // Or by ID, to reference a key another module manages. Names aren't unique, so an ID is
    // the way through an ambiguous lookup.
    var reporting = Incident.GetApiKey.Invoke(new()
    {
        Id = "01G0J1EXE7AXZ2C93K61WBPYEH",
    });

    return new Dictionary<string, object?>
    {
        ["ciKeyRoles"] = ci.Apply(getApiKeyResult => getApiKeyResult.RoleNames),
        ["ciKeyLastUsedAt"] = ci.Apply(getApiKeyResult => getApiKeyResult.LastUsedAt),
    };
});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.incident.IncidentFunctions;
import com.pulumi.incident.inputs.GetApiKeyArgs;
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) {
        // Look up an existing API key by name, such as one created in the dashboard.
        final var ci = IncidentFunctions.getApiKey(GetApiKeyArgs.builder()
            .name("CI deploy key")
            .build());

        // Or by ID, to reference a key another module manages. Names aren't unique, so an ID is
        // the way through an ambiguous lookup.
        final var reporting = IncidentFunctions.getApiKey(GetApiKeyArgs.builder()
            .id("01G0J1EXE7AXZ2C93K61WBPYEH")
            .build());

        ctx.export("ciKeyRoles", ci.roleNames());
        ctx.export("ciKeyLastUsedAt", ci.lastUsedAt());
    }
}

variables:
  # Look up an existing API key by name, such as one created in the dashboard.
  ci:
    fn::invoke:
      function: incident:getApiKey
      arguments:
        name: CI deploy key
  # Or by ID, to reference a key another module manages. Names aren't unique, so an ID is
  # the way through an ambiguous lookup.
  reporting:
    fn::invoke:
      function: incident:getApiKey
      arguments:
        id: 01G0J1EXE7AXZ2C93K61WBPYEH
outputs:
  # A lookup can tell you what a key may do, but never how to authenticate as it: the token
  # is returned only when incident.io issues one, so there's no token attribute here.
  ciKeyRoles: ${ci.roleNames}
  # last_used_at is null for a key nothing has authenticated with, which is how you find the
  # ones worth deleting.
  ciKeyLastUsedAt: ${ci.lastUsedAt}

function getApiKey(args: GetApiKeyArgs, opts?: InvokeOptions): Promise<GetApiKeyResult>
function getApiKeyOutput(args: GetApiKeyOutputArgs, opts?: InvokeOutputOptions): Output<GetApiKeyResult>

def get_api_key(id: Optional[str] = None,
                name: Optional[str] = None,
                opts: Optional[InvokeOptions] = None) -> GetApiKeyResult
def get_api_key_output(id: pulumi.Input[Optional[str]] = None,
                name: pulumi.Input[Optional[str]] = None,
                opts: Optional[InvokeOutputOptions] = None) -> Output[GetApiKeyResult]

func LookupApiKey(ctx *Context, args *LookupApiKeyArgs, opts ...InvokeOption) (*LookupApiKeyResult, error)
func LookupApiKeyOutput(ctx *Context, args *LookupApiKeyOutputArgs, opts ...InvokeOption) LookupApiKeyResultOutput

public static class GetApiKey 
{
    public static Task<GetApiKeyResult> InvokeAsync(GetApiKeyArgs args, InvokeOptions? opts = null)
    public static Output<GetApiKeyResult> Invoke(GetApiKeyInvokeArgs args, InvokeOptions? opts = null)
    public static Output<GetApiKeyResult> Invoke(GetApiKeyInvokeArgs args, InvokeOutputOptions opts)
}

public static CompletableFuture<GetApiKeyResult> getApiKey(GetApiKeyArgs args, InvokeOptions options)
public static Output<GetApiKeyResult> getApiKey(GetApiKeyArgs args, InvokeOptions options)
public static Output<GetApiKeyResult> getApiKey(GetApiKeyArgs args, InvokeOutputOptions options)

fn::invoke:
  function: incident:index/getApiKey:getApiKey
  arguments:
    # arguments dictionary

data "incident_get_api_key" "name" {
    # arguments
}