mongodbatlas.getApiKeyProjectAssignments

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 firstAssignment = 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,
});

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 = 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)

package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		this, err := mongodbatlas.NewApiKey(ctx, "this", &mongodbatlas.ApiKeyArgs{
			OrgId:       pulumi.Any(orgId),
			Description: pulumi.String("Test API Key"),
			RoleNames: pulumi.StringArray{
				pulumi.String("ORG_READ_ONLY"),
			},
		})
		if err != nil {
			return err
		}
		firstProject, err := mongodbatlas.NewProject(ctx, "first_project", &mongodbatlas.ProjectArgs{
			Name:  pulumi.String("First Project"),
			OrgId: pulumi.Any(orgId),
		})
		if err != nil {
			return err
		}
		secondProject, err := mongodbatlas.NewProject(ctx, "second_project", &mongodbatlas.ProjectArgs{
			Name:  pulumi.String("Second Project"),
			OrgId: pulumi.Any(orgId),
		})
		if err != nil {
			return err
		}
		_, err = mongodbatlas.NewApiKeyProjectAssignment(ctx, "first_assignment", &mongodbatlas.ApiKeyProjectAssignmentArgs{
			ProjectId: firstProject.ID(),
			ApiKeyId:  this.ApiKeyId,
			Roles: pulumi.StringArray{
				pulumi.String("GROUP_OWNER"),
			},
		})
		if err != nil {
			return err
		}
		_, err = mongodbatlas.NewApiKeyProjectAssignment(ctx, "second_assignment", &mongodbatlas.ApiKeyProjectAssignmentArgs{
			ProjectId: secondProject.ID(),
			ApiKeyId:  this.ApiKeyId,
			Roles: pulumi.StringArray{
				pulumi.String("GROUP_OWNER"),
			},
		})
		if err != nil {
			return err
		}
		// Add IP Access List Entry to Programmatic API Key
		_, err = mongodbatlas.NewAccessListApiKey(ctx, "this", &mongodbatlas.AccessListApiKeyArgs{
			OrgId:     pulumi.Any(orgId),
			CidrBlock: pulumi.String("0.0.0.0/1"),
			ApiKeyId:  this.ApiKeyId,
		})
		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 @this = new Mongodbatlas.ApiKey("this", new()
    {
        OrgId = orgId,
        Description = "Test API Key",
        RoleNames = new[]
        {
            "ORG_READ_ONLY",
        },
    });

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

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

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

    var secondAssignment = new Mongodbatlas.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.AccessListApiKey("this", new()
    {
        OrgId = orgId,
        CidrBlock = "0.0.0.0/1",
        ApiKeyId = @this.ApiKeyId,
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.mongodbatlas.ApiKey;
import com.pulumi.mongodbatlas.ApiKeyArgs;
import com.pulumi.mongodbatlas.Project;
import com.pulumi.mongodbatlas.ProjectArgs;
import com.pulumi.mongodbatlas.ApiKeyProjectAssignment;
import com.pulumi.mongodbatlas.ApiKeyProjectAssignmentArgs;
import com.pulumi.mongodbatlas.AccessListApiKey;
import com.pulumi.mongodbatlas.AccessListApiKeyArgs;
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 this_ = new ApiKey("this", ApiKeyArgs.builder()
            .orgId(orgId)
            .description("Test API Key")
            .roleNames("ORG_READ_ONLY")
            .build());

        var firstProject = new Project("firstProject", ProjectArgs.builder()
            .name("First Project")
            .orgId(orgId)
            .build());

        var secondProject = new Project("secondProject", ProjectArgs.builder()
            .name("Second Project")
            .orgId(orgId)
            .build());

        var firstAssignment = new ApiKeyProjectAssignment("firstAssignment", ApiKeyProjectAssignmentArgs.builder()
            .projectId(firstProject.id())
            .apiKeyId(this_.apiKeyId())
            .roles("GROUP_OWNER")
            .build());

        var secondAssignment = new ApiKeyProjectAssignment("secondAssignment", ApiKeyProjectAssignmentArgs.builder()
            .projectId(secondProject.id())
            .apiKeyId(this_.apiKeyId())
            .roles("GROUP_OWNER")
            .build());

        // Add IP Access List Entry to Programmatic API Key 
        var thisAccessListApiKey = new AccessListApiKey("thisAccessListApiKey", AccessListApiKeyArgs.builder()
            .orgId(orgId)
            .cidrBlock("0.0.0.0/1")
            .apiKeyId(this_.apiKeyId())
            .build());

    }
}

resources:
  this:
    type: mongodbatlas:ApiKey
    properties:
      orgId: ${orgId}
      description: Test API Key
      roleNames:
        - ORG_READ_ONLY
  firstProject:
    type: mongodbatlas:Project
    name: first_project
    properties:
      name: First Project
      orgId: ${orgId}
  secondProject:
    type: mongodbatlas:Project
    name: second_project
    properties:
      name: Second Project
      orgId: ${orgId}
  firstAssignment:
    type: mongodbatlas:ApiKeyProjectAssignment
    name: first_assignment
    properties:
      projectId: ${firstProject.id}
      apiKeyId: ${this.apiKeyId}
      roles:
        - GROUP_OWNER
  secondAssignment:
    type: mongodbatlas:ApiKeyProjectAssignment
    name: second_assignment
    properties:
      projectId: ${secondProject.id}
      apiKeyId: ${this.apiKeyId}
      roles:
        - GROUP_OWNER
  # Add IP Access List Entry to Programmatic API Key
  thisAccessListApiKey:
    type: mongodbatlas:AccessListApiKey
    name: this
    properties:
      orgId: ${orgId}
      cidrBlock: 0.0.0.0/1
      apiKeyId: ${this.apiKeyId}

function getApiKeyProjectAssignments(args: GetApiKeyProjectAssignmentsArgs, opts?: InvokeOptions): Promise<GetApiKeyProjectAssignmentsResult>
function getApiKeyProjectAssignmentsOutput(args: GetApiKeyProjectAssignmentsOutputArgs, opts?: InvokeOptions): Output<GetApiKeyProjectAssignmentsResult>

def get_api_key_project_assignments(project_id: Optional[str] = None,
                                    opts: Optional[InvokeOptions] = None) -> GetApiKeyProjectAssignmentsResult
def get_api_key_project_assignments_output(project_id: Optional[pulumi.Input[str]] = None,
                                    opts: Optional[InvokeOptions] = None) -> Output[GetApiKeyProjectAssignmentsResult]

func LookupApiKeyProjectAssignments(ctx *Context, args *LookupApiKeyProjectAssignmentsArgs, opts ...InvokeOption) (*LookupApiKeyProjectAssignmentsResult, error)
func LookupApiKeyProjectAssignmentsOutput(ctx *Context, args *LookupApiKeyProjectAssignmentsOutputArgs, opts ...InvokeOption) LookupApiKeyProjectAssignmentsResultOutput

public static class GetApiKeyProjectAssignments 
{
    public static Task<GetApiKeyProjectAssignmentsResult> InvokeAsync(GetApiKeyProjectAssignmentsArgs args, InvokeOptions? opts = null)
    public static Output<GetApiKeyProjectAssignmentsResult> Invoke(GetApiKeyProjectAssignmentsInvokeArgs args, InvokeOptions? opts = null)
}

public static CompletableFuture<GetApiKeyProjectAssignmentsResult> getApiKeyProjectAssignments(GetApiKeyProjectAssignmentsArgs args, InvokeOptions options)
public static Output<GetApiKeyProjectAssignmentsResult> getApiKeyProjectAssignments(GetApiKeyProjectAssignmentsArgs args, InvokeOptions options)

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