Docs Home Pulumi IaC Pulumi ESC Pulumi Cloud Packages Tutorials
  1. Packages
  2. Mongodbatlas Provider
  3. API Docs
  4. getDatabaseUsers
MongoDB Atlas v3.20.4 published on Wednesday, Oct 30, 2024 by Pulumi
pulumi/pulumi-mongodbatlas

mongodbatlas.getDatabaseUsers

Explore with Pulumi AI

mongodbatlas logo
MongoDB Atlas v3.20.4 published on Wednesday, Oct 30, 2024 by Pulumi
pulumi/pulumi-mongodbatlas

    # Data Source: mongodbatlas.getDatabaseUsers

    mongodbatlas.getDatabaseUsers describes all Database Users. This represents a database user which will be applied to all clusters within the project.

    Each user has a set of roles that provide access to the project’s databases. User’s roles apply to all the clusters in the project: if two clusters have a products database and a user has a role granting read access on the products database, the user has that access on both clusters.

    NOTE: Groups and projects are synonymous terms. You may find groupId in the official documentation.

    Example Usage

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

const testDatabaseUser = new mongodbatlas.DatabaseUser("test", {
    username: "test-acc-username",
    password: "test-acc-password",
    projectId: "<PROJECT-ID>",
    authDatabaseName: "admin",
    roles: [
        {
            roleName: "readWrite",
            databaseName: "admin",
        },
        {
            roleName: "atlasAdmin",
            databaseName: "admin",
        },
    ],
    labels: [
        {
            key: "key 1",
            value: "value 1",
        },
        {
            key: "key 2",
            value: "value 2",
        },
    ],
});
const test = mongodbatlas.getDatabaseUsersOutput({
    projectId: testDatabaseUser.projectId,
});

    import pulumi
import pulumi_mongodbatlas as mongodbatlas

test_database_user = mongodbatlas.DatabaseUser("test",
    username="test-acc-username",
    password="test-acc-password",
    project_id="<PROJECT-ID>",
    auth_database_name="admin",
    roles=[
        {
            "role_name": "readWrite",
            "database_name": "admin",
        },
        {
            "role_name": "atlasAdmin",
            "database_name": "admin",
        },
    ],
    labels=[
        {
            "key": "key 1",
            "value": "value 1",
        },
        {
            "key": "key 2",
            "value": "value 2",
        },
    ])
test = mongodbatlas.get_database_users_output(project_id=test_database_user.project_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 {
		testDatabaseUser, err := mongodbatlas.NewDatabaseUser(ctx, "test", &mongodbatlas.DatabaseUserArgs{
			Username:         pulumi.String("test-acc-username"),
			Password:         pulumi.String("test-acc-password"),
			ProjectId:        pulumi.String("<PROJECT-ID>"),
			AuthDatabaseName: pulumi.String("admin"),
			Roles: mongodbatlas.DatabaseUserRoleArray{
				&mongodbatlas.DatabaseUserRoleArgs{
					RoleName:     pulumi.String("readWrite"),
					DatabaseName: pulumi.String("admin"),
				},
				&mongodbatlas.DatabaseUserRoleArgs{
					RoleName:     pulumi.String("atlasAdmin"),
					DatabaseName: pulumi.String("admin"),
				},
			},
			Labels: mongodbatlas.DatabaseUserLabelArray{
				&mongodbatlas.DatabaseUserLabelArgs{
					Key:   pulumi.String("key 1"),
					Value: pulumi.String("value 1"),
				},
				&mongodbatlas.DatabaseUserLabelArgs{
					Key:   pulumi.String("key 2"),
					Value: pulumi.String("value 2"),
				},
			},
		})
		if err != nil {
			return err
		}
		_ = mongodbatlas.LookupDatabaseUsersOutput(ctx, mongodbatlas.GetDatabaseUsersOutputArgs{
			ProjectId: testDatabaseUser.ProjectId,
		}, nil)
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var testDatabaseUser = new Mongodbatlas.DatabaseUser("test", new()
    {
        Username = "test-acc-username",
        Password = "test-acc-password",
        ProjectId = "<PROJECT-ID>",
        AuthDatabaseName = "admin",
        Roles = new[]
        {
            new Mongodbatlas.Inputs.DatabaseUserRoleArgs
            {
                RoleName = "readWrite",
                DatabaseName = "admin",
            },
            new Mongodbatlas.Inputs.DatabaseUserRoleArgs
            {
                RoleName = "atlasAdmin",
                DatabaseName = "admin",
            },
        },
        Labels = new[]
        {
            new Mongodbatlas.Inputs.DatabaseUserLabelArgs
            {
                Key = "key 1",
                Value = "value 1",
            },
            new Mongodbatlas.Inputs.DatabaseUserLabelArgs
            {
                Key = "key 2",
                Value = "value 2",
            },
        },
    });

    var test = Mongodbatlas.GetDatabaseUsers.Invoke(new()
    {
        ProjectId = testDatabaseUser.ProjectId,
    });

});

    package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.mongodbatlas.DatabaseUser;
import com.pulumi.mongodbatlas.DatabaseUserArgs;
import com.pulumi.mongodbatlas.inputs.DatabaseUserRoleArgs;
import com.pulumi.mongodbatlas.inputs.DatabaseUserLabelArgs;
import com.pulumi.mongodbatlas.MongodbatlasFunctions;
import com.pulumi.mongodbatlas.inputs.GetDatabaseUsersArgs;
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 testDatabaseUser = new DatabaseUser("testDatabaseUser", DatabaseUserArgs.builder()
            .username("test-acc-username")
            .password("test-acc-password")
            .projectId("<PROJECT-ID>")
            .authDatabaseName("admin")
            .roles(            
                DatabaseUserRoleArgs.builder()
                    .roleName("readWrite")
                    .databaseName("admin")
                    .build(),
                DatabaseUserRoleArgs.builder()
                    .roleName("atlasAdmin")
                    .databaseName("admin")
                    .build())
            .labels(            
                DatabaseUserLabelArgs.builder()
                    .key("key 1")
                    .value("value 1")
                    .build(),
                DatabaseUserLabelArgs.builder()
                    .key("key 2")
                    .value("value 2")
                    .build())
            .build());

        final var test = MongodbatlasFunctions.getDatabaseUsers(GetDatabaseUsersArgs.builder()
            .projectId(testDatabaseUser.projectId())
            .build());

    }
}

    resources:
  testDatabaseUser:
    type: mongodbatlas:DatabaseUser
    name: test
    properties:
      username: test-acc-username
      password: test-acc-password
      projectId: <PROJECT-ID>
      authDatabaseName: admin
      roles:
        - roleName: readWrite
          databaseName: admin
        - roleName: atlasAdmin
          databaseName: admin
      labels:
        - key: key 1
          value: value 1
        - key: key 2
          value: value 2
variables:
  test:
    fn::invoke:
      Function: mongodbatlas:getDatabaseUsers
      Arguments:
        projectId: ${testDatabaseUser.projectId}

    Example of usage with a OIDC federated authentication user

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

const testDatabaseUser = new mongodbatlas.DatabaseUser("test", {
    username: "64d613677e1ad50839cce4db/testUserOrGroup",
    projectId: "6414908c207f4d22f4d8f232",
    authDatabaseName: "admin",
    oidcAuthType: "IDP_GROUP",
    roles: [{
        roleName: "readWriteAnyDatabase",
        databaseName: "admin",
    }],
});
const test = mongodbatlas.getDatabaseUsers({
    projectId: "6414908c207f4d22f4d8f232",
});

    import pulumi
import pulumi_mongodbatlas as mongodbatlas

test_database_user = mongodbatlas.DatabaseUser("test",
    username="64d613677e1ad50839cce4db/testUserOrGroup",
    project_id="6414908c207f4d22f4d8f232",
    auth_database_name="admin",
    oidc_auth_type="IDP_GROUP",
    roles=[{
        "role_name": "readWriteAnyDatabase",
        "database_name": "admin",
    }])
test = mongodbatlas.get_database_users(project_id="6414908c207f4d22f4d8f232")

    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 {
		_, err := mongodbatlas.NewDatabaseUser(ctx, "test", &mongodbatlas.DatabaseUserArgs{
			Username:         pulumi.String("64d613677e1ad50839cce4db/testUserOrGroup"),
			ProjectId:        pulumi.String("6414908c207f4d22f4d8f232"),
			AuthDatabaseName: pulumi.String("admin"),
			OidcAuthType:     pulumi.String("IDP_GROUP"),
			Roles: mongodbatlas.DatabaseUserRoleArray{
				&mongodbatlas.DatabaseUserRoleArgs{
					RoleName:     pulumi.String("readWriteAnyDatabase"),
					DatabaseName: pulumi.String("admin"),
				},
			},
		})
		if err != nil {
			return err
		}
		_, err = mongodbatlas.LookupDatabaseUsers(ctx, &mongodbatlas.LookupDatabaseUsersArgs{
			ProjectId: "6414908c207f4d22f4d8f232",
		}, 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 testDatabaseUser = new Mongodbatlas.DatabaseUser("test", new()
    {
        Username = "64d613677e1ad50839cce4db/testUserOrGroup",
        ProjectId = "6414908c207f4d22f4d8f232",
        AuthDatabaseName = "admin",
        OidcAuthType = "IDP_GROUP",
        Roles = new[]
        {
            new Mongodbatlas.Inputs.DatabaseUserRoleArgs
            {
                RoleName = "readWriteAnyDatabase",
                DatabaseName = "admin",
            },
        },
    });

    var test = Mongodbatlas.GetDatabaseUsers.Invoke(new()
    {
        ProjectId = "6414908c207f4d22f4d8f232",
    });

});

    package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.mongodbatlas.DatabaseUser;
import com.pulumi.mongodbatlas.DatabaseUserArgs;
import com.pulumi.mongodbatlas.inputs.DatabaseUserRoleArgs;
import com.pulumi.mongodbatlas.MongodbatlasFunctions;
import com.pulumi.mongodbatlas.inputs.GetDatabaseUsersArgs;
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 testDatabaseUser = new DatabaseUser("testDatabaseUser", DatabaseUserArgs.builder()
            .username("64d613677e1ad50839cce4db/testUserOrGroup")
            .projectId("6414908c207f4d22f4d8f232")
            .authDatabaseName("admin")
            .oidcAuthType("IDP_GROUP")
            .roles(DatabaseUserRoleArgs.builder()
                .roleName("readWriteAnyDatabase")
                .databaseName("admin")
                .build())
            .build());

        final var test = MongodbatlasFunctions.getDatabaseUsers(GetDatabaseUsersArgs.builder()
            .projectId("6414908c207f4d22f4d8f232")
            .build());

    }
}

    resources:
  testDatabaseUser:
    type: mongodbatlas:DatabaseUser
    name: test
    properties:
      username: 64d613677e1ad50839cce4db/testUserOrGroup
      projectId: 6414908c207f4d22f4d8f232
      authDatabaseName: admin
      oidcAuthType: IDP_GROUP
      roles:
        - roleName: readWriteAnyDatabase
          databaseName: admin
variables:
  test:
    fn::invoke:
      Function: mongodbatlas:getDatabaseUsers
      Arguments:
        projectId: 6414908c207f4d22f4d8f232

    Note: OIDC support is only avalible starting in MongoDB 7.0 or later. To learn more, see the MongoDB Atlas documentation.

    Using getDatabaseUsers

    Two invocation forms are available. The direct form accepts plain arguments and either blocks until the result value is available, or returns a Promise-wrapped result. The output form accepts Input-wrapped arguments and returns an Output-wrapped result.

    function getDatabaseUsers(args: GetDatabaseUsersArgs, opts?: InvokeOptions): Promise<GetDatabaseUsersResult>
function getDatabaseUsersOutput(args: GetDatabaseUsersOutputArgs, opts?: InvokeOptions): Output<GetDatabaseUsersResult>
    def get_database_users(project_id: Optional[str] = None,
                       opts: Optional[InvokeOptions] = None) -> GetDatabaseUsersResult
def get_database_users_output(project_id: Optional[pulumi.Input[str]] = None,
                       opts: Optional[InvokeOptions] = None) -> Output[GetDatabaseUsersResult]
    func LookupDatabaseUsers(ctx *Context, args *LookupDatabaseUsersArgs, opts ...InvokeOption) (*LookupDatabaseUsersResult, error)
func LookupDatabaseUsersOutput(ctx *Context, args *LookupDatabaseUsersOutputArgs, opts ...InvokeOption) LookupDatabaseUsersResultOutput

    > Note: This function is named LookupDatabaseUsers in the Go SDK.

    public static class GetDatabaseUsers 
{
    public static Task<GetDatabaseUsersResult> InvokeAsync(GetDatabaseUsersArgs args, InvokeOptions? opts = null)
    public static Output<GetDatabaseUsersResult> Invoke(GetDatabaseUsersInvokeArgs args, InvokeOptions? opts = null)
}
    public static CompletableFuture<GetDatabaseUsersResult> getDatabaseUsers(GetDatabaseUsersArgs args, InvokeOptions options)
// Output-based functions aren't available in Java yet

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

    The following arguments are supported:

    ProjectId string
    The unique ID for the project to get all database users.
    ProjectId string
    The unique ID for the project to get all database users.
    projectId String
    The unique ID for the project to get all database users.
    projectId string
    The unique ID for the project to get all database users.
    project_id str
    The unique ID for the project to get all database users.
    projectId String
    The unique ID for the project to get all database users.

    getDatabaseUsers Result

    The following output properties are available:

    Id string
    Autogenerated Unique ID for this data source.
    ProjectId string
    ID of the Atlas project the user belongs to.
    Results List<GetDatabaseUsersResult>
    A list where each represents a Database user.
    Id string
    Autogenerated Unique ID for this data source.
    ProjectId string
    ID of the Atlas project the user belongs to.
    Results []GetDatabaseUsersResult
    A list where each represents a Database user.
    id String
    Autogenerated Unique ID for this data source.
    projectId String
    ID of the Atlas project the user belongs to.
    results List<GetDatabaseUsersResult>
    A list where each represents a Database user.
    id string
    Autogenerated Unique ID for this data source.
    projectId string
    ID of the Atlas project the user belongs to.
    results GetDatabaseUsersResult[]
    A list where each represents a Database user.
    id str
    Autogenerated Unique ID for this data source.
    project_id str
    ID of the Atlas project the user belongs to.
    results Sequence[GetDatabaseUsersResult]
    A list where each represents a Database user.
    id String
    Autogenerated Unique ID for this data source.
    projectId String
    ID of the Atlas project the user belongs to.
    results List<Property Map>
    A list where each represents a Database user.

    Supporting Types

    GetDatabaseUsersResult

    AuthDatabaseName string
    (Required) Database against which Atlas authenticates the user. A user must provide both a username and authentication database to log into MongoDB. Possible values include:
    AwsIamType string
    The new database user authenticates with AWS IAM credentials. Default is NONE, USER means user has AWS IAM user credentials, ROLE - means user has credentials associated with an AWS IAM role.
    Id string
    Autogenerated Unique ID for this data source.
    Labels List<GetDatabaseUsersResultLabel>
    LdapAuthType string
    Method by which the provided username is authenticated. Default is NONE. Other valid values are: USER, GROUP.
    OidcAuthType string
    (Optional) Human-readable label that indicates whether the new database user authenticates with OIDC (OpenID Connect) federated authentication. If no value is given, Atlas uses the default value of NONE. The accepted types are:

    ProjectId string
    The unique ID for the project to get all database users.
    Roles List<GetDatabaseUsersResultRole>
    List of user’s roles and the databases / collections on which the roles apply. A role allows the user to perform particular actions on the specified database. A role on the admin database can include privileges that apply to the other databases as well. See Roles below for more details.
    Scopes List<GetDatabaseUsersResultScope>
    Array of clusters and Atlas Data Lakes that this user has access to.
    Username string
    Username for authenticating to MongoDB.
    X509Type string
    X.509 method by which the provided username is authenticated.
    AuthDatabaseName string
    (Required) Database against which Atlas authenticates the user. A user must provide both a username and authentication database to log into MongoDB. Possible values include:
    AwsIamType string
    The new database user authenticates with AWS IAM credentials. Default is NONE, USER means user has AWS IAM user credentials, ROLE - means user has credentials associated with an AWS IAM role.
    Id string
    Autogenerated Unique ID for this data source.
    Labels []GetDatabaseUsersResultLabel
    LdapAuthType string
    Method by which the provided username is authenticated. Default is NONE. Other valid values are: USER, GROUP.
    OidcAuthType string
    (Optional) Human-readable label that indicates whether the new database user authenticates with OIDC (OpenID Connect) federated authentication. If no value is given, Atlas uses the default value of NONE. The accepted types are:

    ProjectId string
    The unique ID for the project to get all database users.
    Roles []GetDatabaseUsersResultRole
    List of user’s roles and the databases / collections on which the roles apply. A role allows the user to perform particular actions on the specified database. A role on the admin database can include privileges that apply to the other databases as well. See Roles below for more details.
    Scopes []GetDatabaseUsersResultScope
    Array of clusters and Atlas Data Lakes that this user has access to.
    Username string
    Username for authenticating to MongoDB.
    X509Type string
    X.509 method by which the provided username is authenticated.
    authDatabaseName String
    (Required) Database against which Atlas authenticates the user. A user must provide both a username and authentication database to log into MongoDB. Possible values include:
    awsIamType String
    The new database user authenticates with AWS IAM credentials. Default is NONE, USER means user has AWS IAM user credentials, ROLE - means user has credentials associated with an AWS IAM role.
    id String
    Autogenerated Unique ID for this data source.
    labels List<GetDatabaseUsersResultLabel>
    ldapAuthType String
    Method by which the provided username is authenticated. Default is NONE. Other valid values are: USER, GROUP.
    oidcAuthType String
    (Optional) Human-readable label that indicates whether the new database user authenticates with OIDC (OpenID Connect) federated authentication. If no value is given, Atlas uses the default value of NONE. The accepted types are:

    projectId String
    The unique ID for the project to get all database users.
    roles List<GetDatabaseUsersResultRole>
    List of user’s roles and the databases / collections on which the roles apply. A role allows the user to perform particular actions on the specified database. A role on the admin database can include privileges that apply to the other databases as well. See Roles below for more details.
    scopes List<GetDatabaseUsersResultScope>
    Array of clusters and Atlas Data Lakes that this user has access to.
    username String
    Username for authenticating to MongoDB.
    x509Type String
    X.509 method by which the provided username is authenticated.
    authDatabaseName string
    (Required) Database against which Atlas authenticates the user. A user must provide both a username and authentication database to log into MongoDB. Possible values include:
    awsIamType string
    The new database user authenticates with AWS IAM credentials. Default is NONE, USER means user has AWS IAM user credentials, ROLE - means user has credentials associated with an AWS IAM role.
    id string
    Autogenerated Unique ID for this data source.
    labels GetDatabaseUsersResultLabel[]
    ldapAuthType string
    Method by which the provided username is authenticated. Default is NONE. Other valid values are: USER, GROUP.
    oidcAuthType string
    (Optional) Human-readable label that indicates whether the new database user authenticates with OIDC (OpenID Connect) federated authentication. If no value is given, Atlas uses the default value of NONE. The accepted types are:

    projectId string
    The unique ID for the project to get all database users.
    roles GetDatabaseUsersResultRole[]
    List of user’s roles and the databases / collections on which the roles apply. A role allows the user to perform particular actions on the specified database. A role on the admin database can include privileges that apply to the other databases as well. See Roles below for more details.
    scopes GetDatabaseUsersResultScope[]
    Array of clusters and Atlas Data Lakes that this user has access to.
    username string
    Username for authenticating to MongoDB.
    x509Type string
    X.509 method by which the provided username is authenticated.
    auth_database_name str
    (Required) Database against which Atlas authenticates the user. A user must provide both a username and authentication database to log into MongoDB. Possible values include:
    aws_iam_type str
    The new database user authenticates with AWS IAM credentials. Default is NONE, USER means user has AWS IAM user credentials, ROLE - means user has credentials associated with an AWS IAM role.
    id str
    Autogenerated Unique ID for this data source.
    labels Sequence[GetDatabaseUsersResultLabel]
    ldap_auth_type str
    Method by which the provided username is authenticated. Default is NONE. Other valid values are: USER, GROUP.
    oidc_auth_type str
    (Optional) Human-readable label that indicates whether the new database user authenticates with OIDC (OpenID Connect) federated authentication. If no value is given, Atlas uses the default value of NONE. The accepted types are:

    project_id str
    The unique ID for the project to get all database users.
    roles Sequence[GetDatabaseUsersResultRole]
    List of user’s roles and the databases / collections on which the roles apply. A role allows the user to perform particular actions on the specified database. A role on the admin database can include privileges that apply to the other databases as well. See Roles below for more details.
    scopes Sequence[GetDatabaseUsersResultScope]
    Array of clusters and Atlas Data Lakes that this user has access to.
    username str
    Username for authenticating to MongoDB.
    x509_type str
    X.509 method by which the provided username is authenticated.
    authDatabaseName String
    (Required) Database against which Atlas authenticates the user. A user must provide both a username and authentication database to log into MongoDB. Possible values include:
    awsIamType String
    The new database user authenticates with AWS IAM credentials. Default is NONE, USER means user has AWS IAM user credentials, ROLE - means user has credentials associated with an AWS IAM role.
    id String
    Autogenerated Unique ID for this data source.
    labels List<Property Map>
    ldapAuthType String
    Method by which the provided username is authenticated. Default is NONE. Other valid values are: USER, GROUP.
    oidcAuthType String
    (Optional) Human-readable label that indicates whether the new database user authenticates with OIDC (OpenID Connect) federated authentication. If no value is given, Atlas uses the default value of NONE. The accepted types are:

    projectId String
    The unique ID for the project to get all database users.
    roles List<Property Map>
    List of user’s roles and the databases / collections on which the roles apply. A role allows the user to perform particular actions on the specified database. A role on the admin database can include privileges that apply to the other databases as well. See Roles below for more details.
    scopes List<Property Map>
    Array of clusters and Atlas Data Lakes that this user has access to.
    username String
    Username for authenticating to MongoDB.
    x509Type String
    X.509 method by which the provided username is authenticated.

    GetDatabaseUsersResultLabel

    Key string
    The key that you want to write.
    Value string
    The value that you want to write.
    Key string
    The key that you want to write.
    Value string
    The value that you want to write.
    key String
    The key that you want to write.
    value String
    The value that you want to write.
    key string
    The key that you want to write.
    value string
    The value that you want to write.
    key str
    The key that you want to write.
    value str
    The value that you want to write.
    key String
    The key that you want to write.
    value String
    The value that you want to write.

    GetDatabaseUsersResultRole

    CollectionName string
    Collection for which the role applies. You can specify a collection for the read and readWrite roles. If you do not specify a collection for read and readWrite, the role applies to all collections in the database (excluding some collections in the system. database).
    DatabaseName string
    Database on which the user has the specified role. A role on the admin database can include privileges that apply to the other databases.
    RoleName string
    CollectionName string
    Collection for which the role applies. You can specify a collection for the read and readWrite roles. If you do not specify a collection for read and readWrite, the role applies to all collections in the database (excluding some collections in the system. database).
    DatabaseName string
    Database on which the user has the specified role. A role on the admin database can include privileges that apply to the other databases.
    RoleName string
    collectionName String
    Collection for which the role applies. You can specify a collection for the read and readWrite roles. If you do not specify a collection for read and readWrite, the role applies to all collections in the database (excluding some collections in the system. database).
    databaseName String
    Database on which the user has the specified role. A role on the admin database can include privileges that apply to the other databases.
    roleName String
    collectionName string
    Collection for which the role applies. You can specify a collection for the read and readWrite roles. If you do not specify a collection for read and readWrite, the role applies to all collections in the database (excluding some collections in the system. database).
    databaseName string
    Database on which the user has the specified role. A role on the admin database can include privileges that apply to the other databases.
    roleName string
    collection_name str
    Collection for which the role applies. You can specify a collection for the read and readWrite roles. If you do not specify a collection for read and readWrite, the role applies to all collections in the database (excluding some collections in the system. database).
    database_name str
    Database on which the user has the specified role. A role on the admin database can include privileges that apply to the other databases.
    role_name str
    collectionName String
    Collection for which the role applies. You can specify a collection for the read and readWrite roles. If you do not specify a collection for read and readWrite, the role applies to all collections in the database (excluding some collections in the system. database).
    databaseName String
    Database on which the user has the specified role. A role on the admin database can include privileges that apply to the other databases.
    roleName String

    GetDatabaseUsersResultScope

    Name string
    Name of the role to grant.
    Type string
    Type of resource that the user has access to. Valid values are: CLUSTER and DATA_LAKE
    Name string
    Name of the role to grant.
    Type string
    Type of resource that the user has access to. Valid values are: CLUSTER and DATA_LAKE
    name String
    Name of the role to grant.
    type String
    Type of resource that the user has access to. Valid values are: CLUSTER and DATA_LAKE
    name string
    Name of the role to grant.
    type string
    Type of resource that the user has access to. Valid values are: CLUSTER and DATA_LAKE
    name str
    Name of the role to grant.
    type str
    Type of resource that the user has access to. Valid values are: CLUSTER and DATA_LAKE
    name String
    Name of the role to grant.
    type String
    Type of resource that the user has access to. Valid values are: CLUSTER and DATA_LAKE

    Package Details

    Repository
    MongoDB Atlas pulumi/pulumi-mongodbatlas
    License
    Apache-2.0
    Notes
    This Pulumi package is based on the mongodbatlas Terraform Provider.
    mongodbatlas logo
    MongoDB Atlas v3.20.4 published on Wednesday, Oct 30, 2024 by Pulumi
    pulumi/pulumi-mongodbatlas