mongodbatlas.getProjectApiKey

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

const testProjectApiKey = new mongodbatlas.ProjectApiKey("test", {
    description: "Description of your API key",
    projectAssignments: [{
        projectId: "64259ee860c43338194b0f8e",
        roleNames: ["GROUP_READ_ONLY"],
    }],
});
const test = mongodbatlas.getProjectApiKey({
    projectId: "64259ee860c43338194b0f8e",
    apiKeyId: testMongodbatlasApiKey.apiKeyId,
});

import pulumi
import pulumi_mongodbatlas as mongodbatlas

test_project_api_key = mongodbatlas.ProjectApiKey("test",
    description="Description of your API key",
    project_assignments=[{
        "project_id": "64259ee860c43338194b0f8e",
        "role_names": ["GROUP_READ_ONLY"],
    }])
test = mongodbatlas.get_project_api_key(project_id="64259ee860c43338194b0f8e",
    api_key_id=test_mongodbatlas_api_key["apiKeyId"])

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 {
		_, err := mongodbatlas.NewProjectApiKey(ctx, "test", &mongodbatlas.ProjectApiKeyArgs{
			Description: pulumi.String("Description of your API key"),
			ProjectAssignments: mongodbatlas.ProjectApiKeyProjectAssignmentArray{
				&mongodbatlas.ProjectApiKeyProjectAssignmentArgs{
					ProjectId: pulumi.String("64259ee860c43338194b0f8e"),
					RoleNames: pulumi.StringArray{
						pulumi.String("GROUP_READ_ONLY"),
					},
				},
			},
		})
		if err != nil {
			return err
		}
		_, err = mongodbatlas.LookupProjectApiKey(ctx, &mongodbatlas.LookupProjectApiKeyArgs{
			ProjectId: "64259ee860c43338194b0f8e",
			ApiKeyId:  testMongodbatlasApiKey.ApiKeyId,
		}, nil)
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var testProjectApiKey = new Mongodbatlas.ProjectApiKey("test", new()
    {
        Description = "Description of your API key",
        ProjectAssignments = new[]
        {
            new Mongodbatlas.Inputs.ProjectApiKeyProjectAssignmentArgs
            {
                ProjectId = "64259ee860c43338194b0f8e",
                RoleNames = new[]
                {
                    "GROUP_READ_ONLY",
                },
            },
        },
    });

    var test = Mongodbatlas.GetProjectApiKey.Invoke(new()
    {
        ProjectId = "64259ee860c43338194b0f8e",
        ApiKeyId = testMongodbatlasApiKey.ApiKeyId,
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.mongodbatlas.ProjectApiKey;
import com.pulumi.mongodbatlas.ProjectApiKeyArgs;
import com.pulumi.mongodbatlas.inputs.ProjectApiKeyProjectAssignmentArgs;
import com.pulumi.mongodbatlas.MongodbatlasFunctions;
import com.pulumi.mongodbatlas.inputs.GetProjectApiKeyArgs;
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 testProjectApiKey = new ProjectApiKey("testProjectApiKey", ProjectApiKeyArgs.builder()
            .description("Description of your API key")
            .projectAssignments(ProjectApiKeyProjectAssignmentArgs.builder()
                .projectId("64259ee860c43338194b0f8e")
                .roleNames("GROUP_READ_ONLY")
                .build())
            .build());

        final var test = MongodbatlasFunctions.getProjectApiKey(GetProjectApiKeyArgs.builder()
            .projectId("64259ee860c43338194b0f8e")
            .apiKeyId(testMongodbatlasApiKey.apiKeyId())
            .build());

    }
}

resources:
  testProjectApiKey:
    type: mongodbatlas:ProjectApiKey
    name: test
    properties:
      description: Description of your API key
      projectAssignments:
        - projectId: 64259ee860c43338194b0f8e
          roleNames:
            - GROUP_READ_ONLY
variables:
  test:
    fn::invoke:
      function: mongodbatlas:getProjectApiKey
      arguments:
        projectId: 64259ee860c43338194b0f8e
        apiKeyId: ${testMongodbatlasApiKey.apiKeyId}

function getProjectApiKey(args: GetProjectApiKeyArgs, opts?: InvokeOptions): Promise<GetProjectApiKeyResult>
function getProjectApiKeyOutput(args: GetProjectApiKeyOutputArgs, opts?: InvokeOptions): Output<GetProjectApiKeyResult>

def get_project_api_key(api_key_id: Optional[str] = None,
                        project_id: Optional[str] = None,
                        opts: Optional[InvokeOptions] = None) -> GetProjectApiKeyResult
def get_project_api_key_output(api_key_id: Optional[pulumi.Input[str]] = None,
                        project_id: Optional[pulumi.Input[str]] = None,
                        opts: Optional[InvokeOptions] = None) -> Output[GetProjectApiKeyResult]

func LookupProjectApiKey(ctx *Context, args *LookupProjectApiKeyArgs, opts ...InvokeOption) (*LookupProjectApiKeyResult, error)
func LookupProjectApiKeyOutput(ctx *Context, args *LookupProjectApiKeyOutputArgs, opts ...InvokeOption) LookupProjectApiKeyResultOutput

public static class GetProjectApiKey 
{
    public static Task<GetProjectApiKeyResult> InvokeAsync(GetProjectApiKeyArgs args, InvokeOptions? opts = null)
    public static Output<GetProjectApiKeyResult> Invoke(GetProjectApiKeyInvokeArgs args, InvokeOptions? opts = null)
}

public static CompletableFuture<GetProjectApiKeyResult> getProjectApiKey(GetProjectApiKeyArgs args, InvokeOptions options)
public static Output<GetProjectApiKeyResult> getProjectApiKey(GetProjectApiKeyArgs args, InvokeOptions options)

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