mongodbatlas.getAiModelApiKey

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

const thisAiModelApiKey = new mongodbatlas.AiModelApiKey("this", {
    projectId: projectId,
    name: "example-ai-model-key",
    cloud: "ANY",
    geography: "ANY",
});
const _this = mongodbatlas.getAiModelApiKeyOutput({
    projectId: projectId,
    apiKeyId: thisAiModelApiKey.apiKeyId,
});
const thisGetAiModelApiKeys = mongodbatlas.getAiModelApiKeys({
    projectId: projectId,
});
export const aiModelApiKeyId = thisAiModelApiKey.apiKeyId;
export const aiModelApiKeySecret = thisAiModelApiKey.secret;
export const aiModelApiKeyName = _this.name;
export const aiModelApiKeyEndpoint = _this.endpoint;
export const aiModelApiKeysResults = thisGetAiModelApiKeys.then(thisGetAiModelApiKeys => thisGetAiModelApiKeys.results);

import pulumi
import pulumi_mongodbatlas as mongodbatlas

this_ai_model_api_key = mongodbatlas.AiModelApiKey("this",
    project_id=project_id,
    name="example-ai-model-key",
    cloud="ANY",
    geography="ANY")
this = mongodbatlas.get_ai_model_api_key_output(project_id=project_id,
    api_key_id=this_ai_model_api_key.api_key_id)
this_get_ai_model_api_keys = mongodbatlas.get_ai_model_api_keys(project_id=project_id)
pulumi.export("aiModelApiKeyId", this_ai_model_api_key.api_key_id)
pulumi.export("aiModelApiKeySecret", this_ai_model_api_key.secret)
pulumi.export("aiModelApiKeyName", this.name)
pulumi.export("aiModelApiKeyEndpoint", this.endpoint)
pulumi.export("aiModelApiKeysResults", this_get_ai_model_api_keys.results)

package main

import (
	"github.com/pulumi/pulumi-mongodbatlas/sdk/v4/go/mongodbatlas"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		thisAiModelApiKey, err := mongodbatlas.NewAiModelApiKey(ctx, "this", &mongodbatlas.AiModelApiKeyArgs{
			ProjectId: pulumi.Any(projectId),
			Name:      pulumi.String("example-ai-model-key"),
			Cloud:     pulumi.String("ANY"),
			Geography: pulumi.String("ANY"),
		})
		if err != nil {
			return err
		}
		this := mongodbatlas.GetAiModelApiKeyOutput(ctx, mongodbatlas.GetAiModelApiKeyOutputArgs{
			ProjectId: pulumi.Any(projectId),
			ApiKeyId:  thisAiModelApiKey.ApiKeyId,
		}, nil)
		thisGetAiModelApiKeys, err := mongodbatlas.GetAiModelApiKeys(ctx, &mongodbatlas.LookupAiModelApiKeysArgs{
			ProjectId: projectId,
		}, nil)
		if err != nil {
			return err
		}
		ctx.Export("aiModelApiKeyId", thisAiModelApiKey.ApiKeyId)
		ctx.Export("aiModelApiKeySecret", thisAiModelApiKey.Secret)
		ctx.Export("aiModelApiKeyName", this.Name())
		ctx.Export("aiModelApiKeyEndpoint", this.Endpoint())
		ctx.Export("aiModelApiKeysResults", thisGetAiModelApiKeys.Results)
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var thisAiModelApiKey = new Mongodbatlas.AiModelApiKey("this", new()
    {
        ProjectId = projectId,
        Name = "example-ai-model-key",
        Cloud = "ANY",
        Geography = "ANY",
    });

    var @this = Mongodbatlas.GetAiModelApiKey.Invoke(new()
    {
        ProjectId = projectId,
        ApiKeyId = thisAiModelApiKey.ApiKeyId,
    });

    var thisGetAiModelApiKeys = Mongodbatlas.GetAiModelApiKeys.Invoke(new()
    {
        ProjectId = projectId,
    });

    return new Dictionary<string, object?>
    {
        ["aiModelApiKeyId"] = thisAiModelApiKey.ApiKeyId,
        ["aiModelApiKeySecret"] = thisAiModelApiKey.Secret,
        ["aiModelApiKeyName"] = @this.Apply(@this => @this.Apply(getAiModelApiKeyResult => getAiModelApiKeyResult.Name)),
        ["aiModelApiKeyEndpoint"] = @this.Apply(@this => @this.Apply(getAiModelApiKeyResult => getAiModelApiKeyResult.Endpoint)),
        ["aiModelApiKeysResults"] = thisGetAiModelApiKeys.Apply(getAiModelApiKeysResult => getAiModelApiKeysResult.Results),
    };
});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.mongodbatlas.AiModelApiKey;
import com.pulumi.mongodbatlas.AiModelApiKeyArgs;
import com.pulumi.mongodbatlas.MongodbatlasFunctions;
import com.pulumi.mongodbatlas.inputs.GetAiModelApiKeyArgs;
import com.pulumi.mongodbatlas.inputs.GetAiModelApiKeysArgs;
import java.util.ArrayList;
import java.util.Arrays;
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 thisAiModelApiKey = new AiModelApiKey("thisAiModelApiKey", AiModelApiKeyArgs.builder()
            .projectId(projectId)
            .name("example-ai-model-key")
            .cloud("ANY")
            .geography("ANY")
            .build());

        final var this = MongodbatlasFunctions.getAiModelApiKey(GetAiModelApiKeyArgs.builder()
            .projectId(projectId)
            .apiKeyId(thisAiModelApiKey.apiKeyId())
            .build());

        final var thisGetAiModelApiKeys = MongodbatlasFunctions.getAiModelApiKeys(GetAiModelApiKeysArgs.builder()
            .projectId(projectId)
            .build());

        ctx.export("aiModelApiKeyId", thisAiModelApiKey.apiKeyId());
        ctx.export("aiModelApiKeySecret", thisAiModelApiKey.secret());
        ctx.export("aiModelApiKeyName", this_.applyValue(_this_ -> _this_.name()));
        ctx.export("aiModelApiKeyEndpoint", this_.applyValue(_this_ -> _this_.endpoint()));
        ctx.export("aiModelApiKeysResults", thisGetAiModelApiKeys.results());
    }
}

resources:
  thisAiModelApiKey:
    type: mongodbatlas:AiModelApiKey
    name: this
    properties:
      projectId: ${projectId}
      name: example-ai-model-key
      cloud: ANY
      geography: ANY
variables:
  this:
    fn::invoke:
      function: mongodbatlas:getAiModelApiKey
      arguments:
        projectId: ${projectId}
        apiKeyId: ${thisAiModelApiKey.apiKeyId}
  thisGetAiModelApiKeys:
    fn::invoke:
      function: mongodbatlas:getAiModelApiKeys
      arguments:
        projectId: ${projectId}
outputs:
  aiModelApiKeyId: ${thisAiModelApiKey.apiKeyId}
  aiModelApiKeySecret: ${thisAiModelApiKey.secret}
  aiModelApiKeyName: ${this.name}
  aiModelApiKeyEndpoint: ${this.endpoint}
  aiModelApiKeysResults: ${thisGetAiModelApiKeys.results}

pulumi {
  required_providers {
    mongodbatlas = {
      source = "pulumi/mongodbatlas"
    }
  }
}

data "mongodbatlas_getaimodelapikey" "this" {
  project_id = projectId
  api_key_id = mongodbatlas_aimodelapikey.this.api_key_id
}
data "mongodbatlas_getaimodelapikeys" "thisGetAiModelApiKeys" {
  project_id = projectId
}

resource "mongodbatlas_aimodelapikey" "this" {
  project_id = projectId
  name       = "example-ai-model-key"
  cloud      = "ANY"
  geography  = "ANY"
}
output "aiModelApiKeyId" {
  value = mongodbatlas_aimodelapikey.this.api_key_id
}
output "aiModelApiKeySecret" {
  value = mongodbatlas_aimodelapikey.this.secret
}
output "aiModelApiKeyName" {
  value = data.mongodbatlas_getaimodelapikey.this.name
}
output "aiModelApiKeyEndpoint" {
  value = data.mongodbatlas_getaimodelapikey.this.endpoint
}
output "aiModelApiKeysResults" {
  value = data.mongodbatlas_getaimodelapikeys.thisGetAiModelApiKeys.results
}

function getAiModelApiKey(args: GetAiModelApiKeyArgs, opts?: InvokeOptions): Promise<GetAiModelApiKeyResult>
function getAiModelApiKeyOutput(args: GetAiModelApiKeyOutputArgs, opts?: InvokeOutputOptions): Output<GetAiModelApiKeyResult>

def get_ai_model_api_key(api_key_id: Optional[str] = None,
                         project_id: Optional[str] = None,
                         opts: Optional[InvokeOptions] = None) -> GetAiModelApiKeyResult
def get_ai_model_api_key_output(api_key_id: pulumi.Input[Optional[str]] = None,
                         project_id: pulumi.Input[Optional[str]] = None,
                         opts: Optional[InvokeOutputOptions] = None) -> Output[GetAiModelApiKeyResult]

func LookupAiModelApiKey(ctx *Context, args *LookupAiModelApiKeyArgs, opts ...InvokeOption) (*LookupAiModelApiKeyResult, error)
func LookupAiModelApiKeyOutput(ctx *Context, args *LookupAiModelApiKeyOutputArgs, opts ...InvokeOption) LookupAiModelApiKeyResultOutput

public static class GetAiModelApiKey 
{
    public static Task<GetAiModelApiKeyResult> InvokeAsync(GetAiModelApiKeyArgs args, InvokeOptions? opts = null)
    public static Output<GetAiModelApiKeyResult> Invoke(GetAiModelApiKeyInvokeArgs args, InvokeOptions? opts = null)
    public static Output<GetAiModelApiKeyResult> Invoke(GetAiModelApiKeyInvokeArgs args, InvokeOutputOptions opts)
}

public static CompletableFuture<GetAiModelApiKeyResult> getAiModelApiKey(GetAiModelApiKeyArgs args, InvokeOptions options)
public static Output<GetAiModelApiKeyResult> getAiModelApiKey(GetAiModelApiKeyArgs args, InvokeOptions options)
public static Output<GetAiModelApiKeyResult> getAiModelApiKey(GetAiModelApiKeyArgs args, InvokeOutputOptions options)

fn::invoke:
  function: mongodbatlas:index/getAiModelApiKey:getAiModelApiKey
  arguments:
    # arguments dictionary

data "mongodbatlas_get_ai_model_api_key" "name" {
    # arguments
}