mongodbatlas.getApiKeyProjectAssignment

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

const _this = new mongodbatlas.ApiKey("this", {
    orgId: orgId,
    description: "Test API Key",
    roleNames: ["ORG_READ_ONLY"],
});
const firstProject = new mongodbatlas.Project("first_project", {
    name: "First Project",
    orgId: orgId,
});
const secondProject = new mongodbatlas.Project("second_project", {
    name: "Second Project",
    orgId: orgId,
});
const firstAssignmentApiKeyProjectAssignment = new mongodbatlas.ApiKeyProjectAssignment("first_assignment", {
    projectId: firstProject.id,
    apiKeyId: _this.apiKeyId,
    roles: ["GROUP_OWNER"],
});
const secondAssignment = new mongodbatlas.ApiKeyProjectAssignment("second_assignment", {
    projectId: secondProject.id,
    apiKeyId: _this.apiKeyId,
    roles: ["GROUP_OWNER"],
});
// Add IP Access List Entry to Programmatic API Key 
const thisAccessListApiKey = new mongodbatlas.AccessListApiKey("this", {
    orgId: orgId,
    cidrBlock: "0.0.0.0/1",
    apiKeyId: _this.apiKeyId,
});
// Data source to read a single API key project assignment
const firstAssignment = mongodbatlas.getApiKeyProjectAssignmentOutput({
    projectId: firstAssignmentApiKeyProjectAssignment.projectId,
    apiKeyId: firstAssignmentApiKeyProjectAssignment.apiKeyId,
});
// Data source to read all API key project assignments for a project
const allAssignments = mongodbatlas.getApiKeyProjectAssignmentsOutput({
    projectId: firstProject.id,
});
export const firstAssignmentProjectId = firstAssignment.apply(firstAssignment => firstAssignment.projectId);
export const allAssignmentsProjectIds = allAssignments.apply(allAssignments => .map(assignment => (assignment.projectId)));

import pulumi
import pulumi_mongodbatlas as mongodbatlas

this = mongodbatlas.ApiKey("this",
    org_id=org_id,
    description="Test API Key",
    role_names=["ORG_READ_ONLY"])
first_project = mongodbatlas.Project("first_project",
    name="First Project",
    org_id=org_id)
second_project = mongodbatlas.Project("second_project",
    name="Second Project",
    org_id=org_id)
first_assignment_api_key_project_assignment = mongodbatlas.ApiKeyProjectAssignment("first_assignment",
    project_id=first_project.id,
    api_key_id=this.api_key_id,
    roles=["GROUP_OWNER"])
second_assignment = mongodbatlas.ApiKeyProjectAssignment("second_assignment",
    project_id=second_project.id,
    api_key_id=this.api_key_id,
    roles=["GROUP_OWNER"])
# Add IP Access List Entry to Programmatic API Key 
this_access_list_api_key = mongodbatlas.AccessListApiKey("this",
    org_id=org_id,
    cidr_block="0.0.0.0/1",
    api_key_id=this.api_key_id)
# Data source to read a single API key project assignment
first_assignment = mongodbatlas.get_api_key_project_assignment_output(project_id=first_assignment_api_key_project_assignment.project_id,
    api_key_id=first_assignment_api_key_project_assignment.api_key_id)
# Data source to read all API key project assignments for a project
all_assignments = mongodbatlas.get_api_key_project_assignments_output(project_id=first_project.id)
pulumi.export("firstAssignmentProjectId", first_assignment.project_id)
pulumi.export("allAssignmentsProjectIds", all_assignments.apply(lambda all_assignments: [assignment.project_id for assignment in all_assignments.results]))

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

return await Deployment.RunAsync(() => 
{
    var @this = new Mongodbatlas.Index.ApiKey("this", new()
    {
        OrgId = orgId,
        Description = "Test API Key",
        RoleNames = new[]
        {
            "ORG_READ_ONLY",
        },
    });

    var firstProject = new Mongodbatlas.Index.Project("first_project", new()
    {
        Name = "First Project",
        OrgId = orgId,
    });

    var secondProject = new Mongodbatlas.Index.Project("second_project", new()
    {
        Name = "Second Project",
        OrgId = orgId,
    });

    var firstAssignmentApiKeyProjectAssignment = new Mongodbatlas.Index.ApiKeyProjectAssignment("first_assignment", new()
    {
        ProjectId = firstProject.Id,
        ApiKeyId = @this.ApiKeyId,
        Roles = new[]
        {
            "GROUP_OWNER",
        },
    });

    var secondAssignment = new Mongodbatlas.Index.ApiKeyProjectAssignment("second_assignment", new()
    {
        ProjectId = secondProject.Id,
        ApiKeyId = @this.ApiKeyId,
        Roles = new[]
        {
            "GROUP_OWNER",
        },
    });

    // Add IP Access List Entry to Programmatic API Key 
    var thisAccessListApiKey = new Mongodbatlas.Index.AccessListApiKey("this", new()
    {
        OrgId = orgId,
        CidrBlock = "0.0.0.0/1",
        ApiKeyId = @this.ApiKeyId,
    });

    // Data source to read a single API key project assignment
    var firstAssignment = Mongodbatlas.Index.GetApiKeyProjectAssignment.Invoke(new()
    {
        ProjectId = firstAssignmentApiKeyProjectAssignment.ProjectId,
        ApiKeyId = firstAssignmentApiKeyProjectAssignment.ApiKeyId,
    });

    // Data source to read all API key project assignments for a project
    var allAssignments = Mongodbatlas.Index.GetApiKeyProjectAssignments.Invoke(new()
    {
        ProjectId = firstProject.Id,
    });

    return new Dictionary<string, object?>
    {
        ["firstAssignmentProjectId"] = firstAssignment.Apply(getApiKeyProjectAssignmentResult => getApiKeyProjectAssignmentResult.ProjectId),
        ["allAssignmentsProjectIds"] = .Select(assignment => 
        {
            return assignment.ProjectId;
        }).ToList(),
    };
});

function getApiKeyProjectAssignment(args: GetApiKeyProjectAssignmentArgs, opts?: InvokeOptions): Promise<GetApiKeyProjectAssignmentResult>
function getApiKeyProjectAssignmentOutput(args: GetApiKeyProjectAssignmentOutputArgs, opts?: InvokeOptions): Output<GetApiKeyProjectAssignmentResult>

def get_api_key_project_assignment(api_key_id: Optional[str] = None,
                                   project_id: Optional[str] = None,
                                   opts: Optional[InvokeOptions] = None) -> GetApiKeyProjectAssignmentResult
def get_api_key_project_assignment_output(api_key_id: Optional[pulumi.Input[str]] = None,
                                   project_id: Optional[pulumi.Input[str]] = None,
                                   opts: Optional[InvokeOptions] = None) -> Output[GetApiKeyProjectAssignmentResult]

func LookupApiKeyProjectAssignment(ctx *Context, args *LookupApiKeyProjectAssignmentArgs, opts ...InvokeOption) (*LookupApiKeyProjectAssignmentResult, error)
func LookupApiKeyProjectAssignmentOutput(ctx *Context, args *LookupApiKeyProjectAssignmentOutputArgs, opts ...InvokeOption) LookupApiKeyProjectAssignmentResultOutput

public static class GetApiKeyProjectAssignment 
{
    public static Task<GetApiKeyProjectAssignmentResult> InvokeAsync(GetApiKeyProjectAssignmentArgs args, InvokeOptions? opts = null)
    public static Output<GetApiKeyProjectAssignmentResult> Invoke(GetApiKeyProjectAssignmentInvokeArgs args, InvokeOptions? opts = null)
}

public static CompletableFuture<GetApiKeyProjectAssignmentResult> getApiKeyProjectAssignment(GetApiKeyProjectAssignmentArgs args, InvokeOptions options)
public static Output<GetApiKeyProjectAssignmentResult> getApiKeyProjectAssignment(GetApiKeyProjectAssignmentArgs args, InvokeOptions options)

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