@pulumi/mongodbatlas 3.35.0-alpha.1754634093 → 3.35.0-alpha.1754930219
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/alertConfiguration.d.ts +3 -3
- package/apiKeyProjectAssignment.d.ts +125 -0
- package/apiKeyProjectAssignment.js +112 -0
- package/apiKeyProjectAssignment.js.map +1 -0
- package/encryptionAtRestPrivateEndpoint.d.ts +1 -1
- package/encryptionAtRestPrivateEndpoint.js +1 -1
- package/eventTrigger.d.ts +3 -3
- package/federatedDatabaseInstance.d.ts +64 -9
- package/federatedDatabaseInstance.js +49 -0
- package/federatedDatabaseInstance.js.map +1 -1
- package/federatedSettingsOrgRoleMapping.d.ts +3 -3
- package/getApiKeyProjectAssignment.d.ts +135 -0
- package/getApiKeyProjectAssignment.js +112 -0
- package/getApiKeyProjectAssignment.js.map +1 -0
- package/getApiKeyProjectAssignments.d.ts +124 -0
- package/getApiKeyProjectAssignments.js +110 -0
- package/getApiKeyProjectAssignments.js.map +1 -0
- package/getEncryptionAtRest.d.ts +2 -2
- package/getEncryptionAtRest.js +2 -2
- package/getEventTrigger.d.ts +2 -2
- package/getEventTriggers.d.ts +2 -2
- package/getFederatedDatabaseInstance.d.ts +14 -14
- package/getFederatedDatabaseInstance.js +14 -14
- package/getFederatedDatabaseInstances.d.ts +2 -2
- package/getFederatedDatabaseInstances.js +2 -2
- package/getFederatedSettingsOrgRoleMapping.d.ts +7 -1
- package/getFederatedSettingsOrgRoleMapping.js.map +1 -1
- package/getOnlineArchive.d.ts +2 -2
- package/getOnlineArchive.js +2 -2
- package/getOnlineArchives.d.ts +2 -2
- package/getOnlineArchives.js +2 -2
- package/getStreamAccountDetails.d.ts +3 -3
- package/getStreamConnections.d.ts +3 -0
- package/getStreamConnections.js.map +1 -1
- package/getStreamInstances.d.ts +3 -0
- package/getStreamInstances.js.map +1 -1
- package/getThirdPartyIntegration.d.ts +6 -2
- package/getThirdPartyIntegration.js.map +1 -1
- package/globalClusterConfig.d.ts +1 -1
- package/globalClusterConfig.js +1 -1
- package/index.d.ts +9 -0
- package/index.js +17 -6
- package/index.js.map +1 -1
- package/mongodbEmployeeAccessGrant.d.ts +1 -1
- package/mongodbEmployeeAccessGrant.js +1 -1
- package/organization.d.ts +33 -22
- package/organization.js +14 -12
- package/organization.js.map +1 -1
- package/package.json +2 -2
- package/privatelinkEndpointServiceDataFederationOnlineArchive.d.ts +1 -1
- package/privatelinkEndpointServiceDataFederationOnlineArchive.js +1 -1
- package/pushBasedLogExport.d.ts +1 -1
- package/pushBasedLogExport.js +1 -1
- package/resourcePolicy.d.ts +1 -1
- package/resourcePolicy.js +1 -1
- package/streamProcessor.d.ts +1 -1
- package/streamProcessor.js +1 -1
- package/thirdPartyIntegration.d.ts +3 -0
- package/thirdPartyIntegration.js +2 -0
- package/thirdPartyIntegration.js.map +1 -1
- package/types/input.d.ts +55 -7
- package/types/output.d.ts +89 -24
|
@@ -0,0 +1,135 @@
|
|
|
1
|
+
import * as pulumi from "@pulumi/pulumi";
|
|
2
|
+
/**
|
|
3
|
+
* ## # Data Source: mongodbatlas.ApiKeyProjectAssignment
|
|
4
|
+
*
|
|
5
|
+
* `mongodbatlas.ApiKeyProjectAssignment` describes an API Key Project Assignment.
|
|
6
|
+
*
|
|
7
|
+
* ## Example Usage
|
|
8
|
+
*
|
|
9
|
+
* ### S
|
|
10
|
+
*
|
|
11
|
+
* ```typescript
|
|
12
|
+
* import * as pulumi from "@pulumi/pulumi";
|
|
13
|
+
* import * as mongodbatlas from "@pulumi/mongodbatlas";
|
|
14
|
+
*
|
|
15
|
+
* const _this = new mongodbatlas.ApiKey("this", {
|
|
16
|
+
* orgId: orgId,
|
|
17
|
+
* description: "Test API Key",
|
|
18
|
+
* roleNames: ["ORG_READ_ONLY"],
|
|
19
|
+
* });
|
|
20
|
+
* const firstProject = new mongodbatlas.Project("first_project", {
|
|
21
|
+
* name: "First Project",
|
|
22
|
+
* orgId: orgId,
|
|
23
|
+
* });
|
|
24
|
+
* const secondProject = new mongodbatlas.Project("second_project", {
|
|
25
|
+
* name: "Second Project",
|
|
26
|
+
* orgId: orgId,
|
|
27
|
+
* });
|
|
28
|
+
* const firstAssignment = new mongodbatlas.ApiKeyProjectAssignment("first_assignment", {
|
|
29
|
+
* projectId: firstProject.id,
|
|
30
|
+
* apiKeyId: _this.apiKeyId,
|
|
31
|
+
* roles: ["GROUP_OWNER"],
|
|
32
|
+
* });
|
|
33
|
+
* const secondAssignment = new mongodbatlas.ApiKeyProjectAssignment("second_assignment", {
|
|
34
|
+
* projectId: secondProject.id,
|
|
35
|
+
* apiKeyId: _this.apiKeyId,
|
|
36
|
+
* roles: ["GROUP_OWNER"],
|
|
37
|
+
* });
|
|
38
|
+
* // Add IP Access List Entry to Programmatic API Key
|
|
39
|
+
* const thisAccessListApiKey = new mongodbatlas.AccessListApiKey("this", {
|
|
40
|
+
* orgId: orgId,
|
|
41
|
+
* cidrBlock: "0.0.0.0/1",
|
|
42
|
+
* apiKeyId: _this.apiKeyId,
|
|
43
|
+
* });
|
|
44
|
+
* ```
|
|
45
|
+
*/
|
|
46
|
+
export declare function getApiKeyProjectAssignment(args: GetApiKeyProjectAssignmentArgs, opts?: pulumi.InvokeOptions): Promise<GetApiKeyProjectAssignmentResult>;
|
|
47
|
+
/**
|
|
48
|
+
* A collection of arguments for invoking getApiKeyProjectAssignment.
|
|
49
|
+
*/
|
|
50
|
+
export interface GetApiKeyProjectAssignmentArgs {
|
|
51
|
+
/**
|
|
52
|
+
* Unique 24-hexadecimal digit string that identifies this organization API key that you want to assign to one project.
|
|
53
|
+
*/
|
|
54
|
+
apiKeyId: string;
|
|
55
|
+
/**
|
|
56
|
+
* Unique 24-hexadecimal digit string that identifies your project. Use the /groups endpoint to retrieve all projects to which the authenticated user has access.
|
|
57
|
+
*/
|
|
58
|
+
projectId: string;
|
|
59
|
+
}
|
|
60
|
+
/**
|
|
61
|
+
* A collection of values returned by getApiKeyProjectAssignment.
|
|
62
|
+
*/
|
|
63
|
+
export interface GetApiKeyProjectAssignmentResult {
|
|
64
|
+
/**
|
|
65
|
+
* Unique 24-hexadecimal digit string that identifies this organization API key that you want to assign to one project.
|
|
66
|
+
*/
|
|
67
|
+
readonly apiKeyId: string;
|
|
68
|
+
/**
|
|
69
|
+
* The provider-assigned unique ID for this managed resource.
|
|
70
|
+
*/
|
|
71
|
+
readonly id: string;
|
|
72
|
+
/**
|
|
73
|
+
* Unique 24-hexadecimal digit string that identifies your project. Use the /groups endpoint to retrieve all projects to which the authenticated user has access.
|
|
74
|
+
*/
|
|
75
|
+
readonly projectId: string;
|
|
76
|
+
readonly roles: string[];
|
|
77
|
+
}
|
|
78
|
+
/**
|
|
79
|
+
* ## # Data Source: mongodbatlas.ApiKeyProjectAssignment
|
|
80
|
+
*
|
|
81
|
+
* `mongodbatlas.ApiKeyProjectAssignment` describes an API Key Project Assignment.
|
|
82
|
+
*
|
|
83
|
+
* ## Example Usage
|
|
84
|
+
*
|
|
85
|
+
* ### S
|
|
86
|
+
*
|
|
87
|
+
* ```typescript
|
|
88
|
+
* import * as pulumi from "@pulumi/pulumi";
|
|
89
|
+
* import * as mongodbatlas from "@pulumi/mongodbatlas";
|
|
90
|
+
*
|
|
91
|
+
* const _this = new mongodbatlas.ApiKey("this", {
|
|
92
|
+
* orgId: orgId,
|
|
93
|
+
* description: "Test API Key",
|
|
94
|
+
* roleNames: ["ORG_READ_ONLY"],
|
|
95
|
+
* });
|
|
96
|
+
* const firstProject = new mongodbatlas.Project("first_project", {
|
|
97
|
+
* name: "First Project",
|
|
98
|
+
* orgId: orgId,
|
|
99
|
+
* });
|
|
100
|
+
* const secondProject = new mongodbatlas.Project("second_project", {
|
|
101
|
+
* name: "Second Project",
|
|
102
|
+
* orgId: orgId,
|
|
103
|
+
* });
|
|
104
|
+
* const firstAssignment = new mongodbatlas.ApiKeyProjectAssignment("first_assignment", {
|
|
105
|
+
* projectId: firstProject.id,
|
|
106
|
+
* apiKeyId: _this.apiKeyId,
|
|
107
|
+
* roles: ["GROUP_OWNER"],
|
|
108
|
+
* });
|
|
109
|
+
* const secondAssignment = new mongodbatlas.ApiKeyProjectAssignment("second_assignment", {
|
|
110
|
+
* projectId: secondProject.id,
|
|
111
|
+
* apiKeyId: _this.apiKeyId,
|
|
112
|
+
* roles: ["GROUP_OWNER"],
|
|
113
|
+
* });
|
|
114
|
+
* // Add IP Access List Entry to Programmatic API Key
|
|
115
|
+
* const thisAccessListApiKey = new mongodbatlas.AccessListApiKey("this", {
|
|
116
|
+
* orgId: orgId,
|
|
117
|
+
* cidrBlock: "0.0.0.0/1",
|
|
118
|
+
* apiKeyId: _this.apiKeyId,
|
|
119
|
+
* });
|
|
120
|
+
* ```
|
|
121
|
+
*/
|
|
122
|
+
export declare function getApiKeyProjectAssignmentOutput(args: GetApiKeyProjectAssignmentOutputArgs, opts?: pulumi.InvokeOutputOptions): pulumi.Output<GetApiKeyProjectAssignmentResult>;
|
|
123
|
+
/**
|
|
124
|
+
* A collection of arguments for invoking getApiKeyProjectAssignment.
|
|
125
|
+
*/
|
|
126
|
+
export interface GetApiKeyProjectAssignmentOutputArgs {
|
|
127
|
+
/**
|
|
128
|
+
* Unique 24-hexadecimal digit string that identifies this organization API key that you want to assign to one project.
|
|
129
|
+
*/
|
|
130
|
+
apiKeyId: pulumi.Input<string>;
|
|
131
|
+
/**
|
|
132
|
+
* Unique 24-hexadecimal digit string that identifies your project. Use the /groups endpoint to retrieve all projects to which the authenticated user has access.
|
|
133
|
+
*/
|
|
134
|
+
projectId: pulumi.Input<string>;
|
|
135
|
+
}
|
|
@@ -0,0 +1,112 @@
|
|
|
1
|
+
"use strict";
|
|
2
|
+
// *** WARNING: this file was generated by pulumi-language-nodejs. ***
|
|
3
|
+
// *** Do not edit by hand unless you're certain you know what you are doing! ***
|
|
4
|
+
Object.defineProperty(exports, "__esModule", { value: true });
|
|
5
|
+
exports.getApiKeyProjectAssignmentOutput = exports.getApiKeyProjectAssignment = void 0;
|
|
6
|
+
const pulumi = require("@pulumi/pulumi");
|
|
7
|
+
const utilities = require("./utilities");
|
|
8
|
+
/**
|
|
9
|
+
* ## # Data Source: mongodbatlas.ApiKeyProjectAssignment
|
|
10
|
+
*
|
|
11
|
+
* `mongodbatlas.ApiKeyProjectAssignment` describes an API Key Project Assignment.
|
|
12
|
+
*
|
|
13
|
+
* ## Example Usage
|
|
14
|
+
*
|
|
15
|
+
* ### S
|
|
16
|
+
*
|
|
17
|
+
* ```typescript
|
|
18
|
+
* import * as pulumi from "@pulumi/pulumi";
|
|
19
|
+
* import * as mongodbatlas from "@pulumi/mongodbatlas";
|
|
20
|
+
*
|
|
21
|
+
* const _this = new mongodbatlas.ApiKey("this", {
|
|
22
|
+
* orgId: orgId,
|
|
23
|
+
* description: "Test API Key",
|
|
24
|
+
* roleNames: ["ORG_READ_ONLY"],
|
|
25
|
+
* });
|
|
26
|
+
* const firstProject = new mongodbatlas.Project("first_project", {
|
|
27
|
+
* name: "First Project",
|
|
28
|
+
* orgId: orgId,
|
|
29
|
+
* });
|
|
30
|
+
* const secondProject = new mongodbatlas.Project("second_project", {
|
|
31
|
+
* name: "Second Project",
|
|
32
|
+
* orgId: orgId,
|
|
33
|
+
* });
|
|
34
|
+
* const firstAssignment = new mongodbatlas.ApiKeyProjectAssignment("first_assignment", {
|
|
35
|
+
* projectId: firstProject.id,
|
|
36
|
+
* apiKeyId: _this.apiKeyId,
|
|
37
|
+
* roles: ["GROUP_OWNER"],
|
|
38
|
+
* });
|
|
39
|
+
* const secondAssignment = new mongodbatlas.ApiKeyProjectAssignment("second_assignment", {
|
|
40
|
+
* projectId: secondProject.id,
|
|
41
|
+
* apiKeyId: _this.apiKeyId,
|
|
42
|
+
* roles: ["GROUP_OWNER"],
|
|
43
|
+
* });
|
|
44
|
+
* // Add IP Access List Entry to Programmatic API Key
|
|
45
|
+
* const thisAccessListApiKey = new mongodbatlas.AccessListApiKey("this", {
|
|
46
|
+
* orgId: orgId,
|
|
47
|
+
* cidrBlock: "0.0.0.0/1",
|
|
48
|
+
* apiKeyId: _this.apiKeyId,
|
|
49
|
+
* });
|
|
50
|
+
* ```
|
|
51
|
+
*/
|
|
52
|
+
function getApiKeyProjectAssignment(args, opts) {
|
|
53
|
+
opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts || {});
|
|
54
|
+
return pulumi.runtime.invoke("mongodbatlas:index/getApiKeyProjectAssignment:getApiKeyProjectAssignment", {
|
|
55
|
+
"apiKeyId": args.apiKeyId,
|
|
56
|
+
"projectId": args.projectId,
|
|
57
|
+
}, opts);
|
|
58
|
+
}
|
|
59
|
+
exports.getApiKeyProjectAssignment = getApiKeyProjectAssignment;
|
|
60
|
+
/**
|
|
61
|
+
* ## # Data Source: mongodbatlas.ApiKeyProjectAssignment
|
|
62
|
+
*
|
|
63
|
+
* `mongodbatlas.ApiKeyProjectAssignment` describes an API Key Project Assignment.
|
|
64
|
+
*
|
|
65
|
+
* ## Example Usage
|
|
66
|
+
*
|
|
67
|
+
* ### S
|
|
68
|
+
*
|
|
69
|
+
* ```typescript
|
|
70
|
+
* import * as pulumi from "@pulumi/pulumi";
|
|
71
|
+
* import * as mongodbatlas from "@pulumi/mongodbatlas";
|
|
72
|
+
*
|
|
73
|
+
* const _this = new mongodbatlas.ApiKey("this", {
|
|
74
|
+
* orgId: orgId,
|
|
75
|
+
* description: "Test API Key",
|
|
76
|
+
* roleNames: ["ORG_READ_ONLY"],
|
|
77
|
+
* });
|
|
78
|
+
* const firstProject = new mongodbatlas.Project("first_project", {
|
|
79
|
+
* name: "First Project",
|
|
80
|
+
* orgId: orgId,
|
|
81
|
+
* });
|
|
82
|
+
* const secondProject = new mongodbatlas.Project("second_project", {
|
|
83
|
+
* name: "Second Project",
|
|
84
|
+
* orgId: orgId,
|
|
85
|
+
* });
|
|
86
|
+
* const firstAssignment = new mongodbatlas.ApiKeyProjectAssignment("first_assignment", {
|
|
87
|
+
* projectId: firstProject.id,
|
|
88
|
+
* apiKeyId: _this.apiKeyId,
|
|
89
|
+
* roles: ["GROUP_OWNER"],
|
|
90
|
+
* });
|
|
91
|
+
* const secondAssignment = new mongodbatlas.ApiKeyProjectAssignment("second_assignment", {
|
|
92
|
+
* projectId: secondProject.id,
|
|
93
|
+
* apiKeyId: _this.apiKeyId,
|
|
94
|
+
* roles: ["GROUP_OWNER"],
|
|
95
|
+
* });
|
|
96
|
+
* // Add IP Access List Entry to Programmatic API Key
|
|
97
|
+
* const thisAccessListApiKey = new mongodbatlas.AccessListApiKey("this", {
|
|
98
|
+
* orgId: orgId,
|
|
99
|
+
* cidrBlock: "0.0.0.0/1",
|
|
100
|
+
* apiKeyId: _this.apiKeyId,
|
|
101
|
+
* });
|
|
102
|
+
* ```
|
|
103
|
+
*/
|
|
104
|
+
function getApiKeyProjectAssignmentOutput(args, opts) {
|
|
105
|
+
opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts || {});
|
|
106
|
+
return pulumi.runtime.invokeOutput("mongodbatlas:index/getApiKeyProjectAssignment:getApiKeyProjectAssignment", {
|
|
107
|
+
"apiKeyId": args.apiKeyId,
|
|
108
|
+
"projectId": args.projectId,
|
|
109
|
+
}, opts);
|
|
110
|
+
}
|
|
111
|
+
exports.getApiKeyProjectAssignmentOutput = getApiKeyProjectAssignmentOutput;
|
|
112
|
+
//# sourceMappingURL=getApiKeyProjectAssignment.js.map
|
|
@@ -0,0 +1 @@
|
|
|
1
|
+
{"version":3,"file":"getApiKeyProjectAssignment.js","sourceRoot":"","sources":["../getApiKeyProjectAssignment.ts"],"names":[],"mappings":";AAAA,sEAAsE;AACtE,iFAAiF;;;AAEjF,yCAAyC;AACzC,yCAAyC;AAEzC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AACH,SAAgB,0BAA0B,CAAC,IAAoC,EAAE,IAA2B;IACxG,IAAI,GAAG,MAAM,CAAC,YAAY,CAAC,SAAS,CAAC,oBAAoB,EAAE,EAAE,IAAI,IAAI,EAAE,CAAC,CAAC;IACzE,OAAO,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,0EAA0E,EAAE;QACrG,UAAU,EAAE,IAAI,CAAC,QAAQ;QACzB,WAAW,EAAE,IAAI,CAAC,SAAS;KAC9B,EAAE,IAAI,CAAC,CAAC;AACb,CAAC;AAND,gEAMC;AAkCD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AACH,SAAgB,gCAAgC,CAAC,IAA0C,EAAE,IAAiC;IAC1H,IAAI,GAAG,MAAM,CAAC,YAAY,CAAC,SAAS,CAAC,oBAAoB,EAAE,EAAE,IAAI,IAAI,EAAE,CAAC,CAAC;IACzE,OAAO,MAAM,CAAC,OAAO,CAAC,YAAY,CAAC,0EAA0E,EAAE;QAC3G,UAAU,EAAE,IAAI,CAAC,QAAQ;QACzB,WAAW,EAAE,IAAI,CAAC,SAAS;KAC9B,EAAE,IAAI,CAAC,CAAC;AACb,CAAC;AAND,4EAMC"}
|
|
@@ -0,0 +1,124 @@
|
|
|
1
|
+
import * as pulumi from "@pulumi/pulumi";
|
|
2
|
+
import * as outputs from "./types/output";
|
|
3
|
+
/**
|
|
4
|
+
* ## # Data Source: mongodbatlas.getApiKeyProjectAssignments
|
|
5
|
+
*
|
|
6
|
+
* `mongodbatlas.getApiKeyProjectAssignments` provides an API Key Project Assignments data source. The data source lets you list all API key project assignments for an organization.
|
|
7
|
+
*
|
|
8
|
+
* ## Example Usage
|
|
9
|
+
*
|
|
10
|
+
* ### S
|
|
11
|
+
*
|
|
12
|
+
* ```typescript
|
|
13
|
+
* import * as pulumi from "@pulumi/pulumi";
|
|
14
|
+
* import * as mongodbatlas from "@pulumi/mongodbatlas";
|
|
15
|
+
*
|
|
16
|
+
* const _this = new mongodbatlas.ApiKey("this", {
|
|
17
|
+
* orgId: orgId,
|
|
18
|
+
* description: "Test API Key",
|
|
19
|
+
* roleNames: ["ORG_READ_ONLY"],
|
|
20
|
+
* });
|
|
21
|
+
* const firstProject = new mongodbatlas.Project("first_project", {
|
|
22
|
+
* name: "First Project",
|
|
23
|
+
* orgId: orgId,
|
|
24
|
+
* });
|
|
25
|
+
* const secondProject = new mongodbatlas.Project("second_project", {
|
|
26
|
+
* name: "Second Project",
|
|
27
|
+
* orgId: orgId,
|
|
28
|
+
* });
|
|
29
|
+
* const firstAssignment = new mongodbatlas.ApiKeyProjectAssignment("first_assignment", {
|
|
30
|
+
* projectId: firstProject.id,
|
|
31
|
+
* apiKeyId: _this.apiKeyId,
|
|
32
|
+
* roles: ["GROUP_OWNER"],
|
|
33
|
+
* });
|
|
34
|
+
* const secondAssignment = new mongodbatlas.ApiKeyProjectAssignment("second_assignment", {
|
|
35
|
+
* projectId: secondProject.id,
|
|
36
|
+
* apiKeyId: _this.apiKeyId,
|
|
37
|
+
* roles: ["GROUP_OWNER"],
|
|
38
|
+
* });
|
|
39
|
+
* // Add IP Access List Entry to Programmatic API Key
|
|
40
|
+
* const thisAccessListApiKey = new mongodbatlas.AccessListApiKey("this", {
|
|
41
|
+
* orgId: orgId,
|
|
42
|
+
* cidrBlock: "0.0.0.0/1",
|
|
43
|
+
* apiKeyId: _this.apiKeyId,
|
|
44
|
+
* });
|
|
45
|
+
* ```
|
|
46
|
+
*/
|
|
47
|
+
export declare function getApiKeyProjectAssignments(args: GetApiKeyProjectAssignmentsArgs, opts?: pulumi.InvokeOptions): Promise<GetApiKeyProjectAssignmentsResult>;
|
|
48
|
+
/**
|
|
49
|
+
* A collection of arguments for invoking getApiKeyProjectAssignments.
|
|
50
|
+
*/
|
|
51
|
+
export interface GetApiKeyProjectAssignmentsArgs {
|
|
52
|
+
/**
|
|
53
|
+
* Unique 24-hexadecimal digit string that identifies your project. Use the /groups endpoint to retrieve all projects to which the authenticated user has access.
|
|
54
|
+
*/
|
|
55
|
+
projectId: string;
|
|
56
|
+
}
|
|
57
|
+
/**
|
|
58
|
+
* A collection of values returned by getApiKeyProjectAssignments.
|
|
59
|
+
*/
|
|
60
|
+
export interface GetApiKeyProjectAssignmentsResult {
|
|
61
|
+
/**
|
|
62
|
+
* The provider-assigned unique ID for this managed resource.
|
|
63
|
+
*/
|
|
64
|
+
readonly id: string;
|
|
65
|
+
/**
|
|
66
|
+
* Unique 24-hexadecimal digit string that identifies your project. Use the /groups endpoint to retrieve all projects to which the authenticated user has access.
|
|
67
|
+
*/
|
|
68
|
+
readonly projectId: string;
|
|
69
|
+
readonly results: outputs.GetApiKeyProjectAssignmentsResult[];
|
|
70
|
+
}
|
|
71
|
+
/**
|
|
72
|
+
* ## # Data Source: mongodbatlas.getApiKeyProjectAssignments
|
|
73
|
+
*
|
|
74
|
+
* `mongodbatlas.getApiKeyProjectAssignments` provides an API Key Project Assignments data source. The data source lets you list all API key project assignments for an organization.
|
|
75
|
+
*
|
|
76
|
+
* ## Example Usage
|
|
77
|
+
*
|
|
78
|
+
* ### S
|
|
79
|
+
*
|
|
80
|
+
* ```typescript
|
|
81
|
+
* import * as pulumi from "@pulumi/pulumi";
|
|
82
|
+
* import * as mongodbatlas from "@pulumi/mongodbatlas";
|
|
83
|
+
*
|
|
84
|
+
* const _this = new mongodbatlas.ApiKey("this", {
|
|
85
|
+
* orgId: orgId,
|
|
86
|
+
* description: "Test API Key",
|
|
87
|
+
* roleNames: ["ORG_READ_ONLY"],
|
|
88
|
+
* });
|
|
89
|
+
* const firstProject = new mongodbatlas.Project("first_project", {
|
|
90
|
+
* name: "First Project",
|
|
91
|
+
* orgId: orgId,
|
|
92
|
+
* });
|
|
93
|
+
* const secondProject = new mongodbatlas.Project("second_project", {
|
|
94
|
+
* name: "Second Project",
|
|
95
|
+
* orgId: orgId,
|
|
96
|
+
* });
|
|
97
|
+
* const firstAssignment = new mongodbatlas.ApiKeyProjectAssignment("first_assignment", {
|
|
98
|
+
* projectId: firstProject.id,
|
|
99
|
+
* apiKeyId: _this.apiKeyId,
|
|
100
|
+
* roles: ["GROUP_OWNER"],
|
|
101
|
+
* });
|
|
102
|
+
* const secondAssignment = new mongodbatlas.ApiKeyProjectAssignment("second_assignment", {
|
|
103
|
+
* projectId: secondProject.id,
|
|
104
|
+
* apiKeyId: _this.apiKeyId,
|
|
105
|
+
* roles: ["GROUP_OWNER"],
|
|
106
|
+
* });
|
|
107
|
+
* // Add IP Access List Entry to Programmatic API Key
|
|
108
|
+
* const thisAccessListApiKey = new mongodbatlas.AccessListApiKey("this", {
|
|
109
|
+
* orgId: orgId,
|
|
110
|
+
* cidrBlock: "0.0.0.0/1",
|
|
111
|
+
* apiKeyId: _this.apiKeyId,
|
|
112
|
+
* });
|
|
113
|
+
* ```
|
|
114
|
+
*/
|
|
115
|
+
export declare function getApiKeyProjectAssignmentsOutput(args: GetApiKeyProjectAssignmentsOutputArgs, opts?: pulumi.InvokeOutputOptions): pulumi.Output<GetApiKeyProjectAssignmentsResult>;
|
|
116
|
+
/**
|
|
117
|
+
* A collection of arguments for invoking getApiKeyProjectAssignments.
|
|
118
|
+
*/
|
|
119
|
+
export interface GetApiKeyProjectAssignmentsOutputArgs {
|
|
120
|
+
/**
|
|
121
|
+
* Unique 24-hexadecimal digit string that identifies your project. Use the /groups endpoint to retrieve all projects to which the authenticated user has access.
|
|
122
|
+
*/
|
|
123
|
+
projectId: pulumi.Input<string>;
|
|
124
|
+
}
|
|
@@ -0,0 +1,110 @@
|
|
|
1
|
+
"use strict";
|
|
2
|
+
// *** WARNING: this file was generated by pulumi-language-nodejs. ***
|
|
3
|
+
// *** Do not edit by hand unless you're certain you know what you are doing! ***
|
|
4
|
+
Object.defineProperty(exports, "__esModule", { value: true });
|
|
5
|
+
exports.getApiKeyProjectAssignmentsOutput = exports.getApiKeyProjectAssignments = void 0;
|
|
6
|
+
const pulumi = require("@pulumi/pulumi");
|
|
7
|
+
const utilities = require("./utilities");
|
|
8
|
+
/**
|
|
9
|
+
* ## # Data Source: mongodbatlas.getApiKeyProjectAssignments
|
|
10
|
+
*
|
|
11
|
+
* `mongodbatlas.getApiKeyProjectAssignments` provides an API Key Project Assignments data source. The data source lets you list all API key project assignments for an organization.
|
|
12
|
+
*
|
|
13
|
+
* ## Example Usage
|
|
14
|
+
*
|
|
15
|
+
* ### S
|
|
16
|
+
*
|
|
17
|
+
* ```typescript
|
|
18
|
+
* import * as pulumi from "@pulumi/pulumi";
|
|
19
|
+
* import * as mongodbatlas from "@pulumi/mongodbatlas";
|
|
20
|
+
*
|
|
21
|
+
* const _this = new mongodbatlas.ApiKey("this", {
|
|
22
|
+
* orgId: orgId,
|
|
23
|
+
* description: "Test API Key",
|
|
24
|
+
* roleNames: ["ORG_READ_ONLY"],
|
|
25
|
+
* });
|
|
26
|
+
* const firstProject = new mongodbatlas.Project("first_project", {
|
|
27
|
+
* name: "First Project",
|
|
28
|
+
* orgId: orgId,
|
|
29
|
+
* });
|
|
30
|
+
* const secondProject = new mongodbatlas.Project("second_project", {
|
|
31
|
+
* name: "Second Project",
|
|
32
|
+
* orgId: orgId,
|
|
33
|
+
* });
|
|
34
|
+
* const firstAssignment = new mongodbatlas.ApiKeyProjectAssignment("first_assignment", {
|
|
35
|
+
* projectId: firstProject.id,
|
|
36
|
+
* apiKeyId: _this.apiKeyId,
|
|
37
|
+
* roles: ["GROUP_OWNER"],
|
|
38
|
+
* });
|
|
39
|
+
* const secondAssignment = new mongodbatlas.ApiKeyProjectAssignment("second_assignment", {
|
|
40
|
+
* projectId: secondProject.id,
|
|
41
|
+
* apiKeyId: _this.apiKeyId,
|
|
42
|
+
* roles: ["GROUP_OWNER"],
|
|
43
|
+
* });
|
|
44
|
+
* // Add IP Access List Entry to Programmatic API Key
|
|
45
|
+
* const thisAccessListApiKey = new mongodbatlas.AccessListApiKey("this", {
|
|
46
|
+
* orgId: orgId,
|
|
47
|
+
* cidrBlock: "0.0.0.0/1",
|
|
48
|
+
* apiKeyId: _this.apiKeyId,
|
|
49
|
+
* });
|
|
50
|
+
* ```
|
|
51
|
+
*/
|
|
52
|
+
function getApiKeyProjectAssignments(args, opts) {
|
|
53
|
+
opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts || {});
|
|
54
|
+
return pulumi.runtime.invoke("mongodbatlas:index/getApiKeyProjectAssignments:getApiKeyProjectAssignments", {
|
|
55
|
+
"projectId": args.projectId,
|
|
56
|
+
}, opts);
|
|
57
|
+
}
|
|
58
|
+
exports.getApiKeyProjectAssignments = getApiKeyProjectAssignments;
|
|
59
|
+
/**
|
|
60
|
+
* ## # Data Source: mongodbatlas.getApiKeyProjectAssignments
|
|
61
|
+
*
|
|
62
|
+
* `mongodbatlas.getApiKeyProjectAssignments` provides an API Key Project Assignments data source. The data source lets you list all API key project assignments for an organization.
|
|
63
|
+
*
|
|
64
|
+
* ## Example Usage
|
|
65
|
+
*
|
|
66
|
+
* ### S
|
|
67
|
+
*
|
|
68
|
+
* ```typescript
|
|
69
|
+
* import * as pulumi from "@pulumi/pulumi";
|
|
70
|
+
* import * as mongodbatlas from "@pulumi/mongodbatlas";
|
|
71
|
+
*
|
|
72
|
+
* const _this = new mongodbatlas.ApiKey("this", {
|
|
73
|
+
* orgId: orgId,
|
|
74
|
+
* description: "Test API Key",
|
|
75
|
+
* roleNames: ["ORG_READ_ONLY"],
|
|
76
|
+
* });
|
|
77
|
+
* const firstProject = new mongodbatlas.Project("first_project", {
|
|
78
|
+
* name: "First Project",
|
|
79
|
+
* orgId: orgId,
|
|
80
|
+
* });
|
|
81
|
+
* const secondProject = new mongodbatlas.Project("second_project", {
|
|
82
|
+
* name: "Second Project",
|
|
83
|
+
* orgId: orgId,
|
|
84
|
+
* });
|
|
85
|
+
* const firstAssignment = new mongodbatlas.ApiKeyProjectAssignment("first_assignment", {
|
|
86
|
+
* projectId: firstProject.id,
|
|
87
|
+
* apiKeyId: _this.apiKeyId,
|
|
88
|
+
* roles: ["GROUP_OWNER"],
|
|
89
|
+
* });
|
|
90
|
+
* const secondAssignment = new mongodbatlas.ApiKeyProjectAssignment("second_assignment", {
|
|
91
|
+
* projectId: secondProject.id,
|
|
92
|
+
* apiKeyId: _this.apiKeyId,
|
|
93
|
+
* roles: ["GROUP_OWNER"],
|
|
94
|
+
* });
|
|
95
|
+
* // Add IP Access List Entry to Programmatic API Key
|
|
96
|
+
* const thisAccessListApiKey = new mongodbatlas.AccessListApiKey("this", {
|
|
97
|
+
* orgId: orgId,
|
|
98
|
+
* cidrBlock: "0.0.0.0/1",
|
|
99
|
+
* apiKeyId: _this.apiKeyId,
|
|
100
|
+
* });
|
|
101
|
+
* ```
|
|
102
|
+
*/
|
|
103
|
+
function getApiKeyProjectAssignmentsOutput(args, opts) {
|
|
104
|
+
opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts || {});
|
|
105
|
+
return pulumi.runtime.invokeOutput("mongodbatlas:index/getApiKeyProjectAssignments:getApiKeyProjectAssignments", {
|
|
106
|
+
"projectId": args.projectId,
|
|
107
|
+
}, opts);
|
|
108
|
+
}
|
|
109
|
+
exports.getApiKeyProjectAssignmentsOutput = getApiKeyProjectAssignmentsOutput;
|
|
110
|
+
//# sourceMappingURL=getApiKeyProjectAssignments.js.map
|
|
@@ -0,0 +1 @@
|
|
|
1
|
+
{"version":3,"file":"getApiKeyProjectAssignments.js","sourceRoot":"","sources":["../getApiKeyProjectAssignments.ts"],"names":[],"mappings":";AAAA,sEAAsE;AACtE,iFAAiF;;;AAEjF,yCAAyC;AAGzC,yCAAyC;AAEzC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AACH,SAAgB,2BAA2B,CAAC,IAAqC,EAAE,IAA2B;IAC1G,IAAI,GAAG,MAAM,CAAC,YAAY,CAAC,SAAS,CAAC,oBAAoB,EAAE,EAAE,IAAI,IAAI,EAAE,CAAC,CAAC;IACzE,OAAO,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,4EAA4E,EAAE;QACvG,WAAW,EAAE,IAAI,CAAC,SAAS;KAC9B,EAAE,IAAI,CAAC,CAAC;AACb,CAAC;AALD,kEAKC;AA0BD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AACH,SAAgB,iCAAiC,CAAC,IAA2C,EAAE,IAAiC;IAC5H,IAAI,GAAG,MAAM,CAAC,YAAY,CAAC,SAAS,CAAC,oBAAoB,EAAE,EAAE,IAAI,IAAI,EAAE,CAAC,CAAC;IACzE,OAAO,MAAM,CAAC,OAAO,CAAC,YAAY,CAAC,4EAA4E,EAAE;QAC7G,WAAW,EAAE,IAAI,CAAC,SAAS;KAC9B,EAAE,IAAI,CAAC,CAAC;AACb,CAAC;AALD,8EAKC"}
|
package/getEncryptionAtRest.d.ts
CHANGED
|
@@ -11,7 +11,7 @@ import * as outputs from "./types/output";
|
|
|
11
11
|
*
|
|
12
12
|
* > **IMPORTANT** By default, Atlas enables encryption at rest for all cluster storage and snapshot volumes.
|
|
13
13
|
*
|
|
14
|
-
* > **IMPORTANT** Atlas limits this feature to dedicated cluster tiers of M10 and greater. For more information see: https://www.mongodb.com/docs/
|
|
14
|
+
* > **IMPORTANT** Atlas limits this feature to dedicated cluster tiers of M10 and greater. For more information see: https://www.mongodb.com/docs/api/doc/atlas-admin-api-v2/group/endpoint-encryption-at-rest-using-customer-key-management
|
|
15
15
|
*
|
|
16
16
|
* > **NOTE:** Groups and projects are synonymous terms. You may find `groupId` in the official documentation.
|
|
17
17
|
*
|
|
@@ -165,7 +165,7 @@ export interface GetEncryptionAtRestResult {
|
|
|
165
165
|
*
|
|
166
166
|
* > **IMPORTANT** By default, Atlas enables encryption at rest for all cluster storage and snapshot volumes.
|
|
167
167
|
*
|
|
168
|
-
* > **IMPORTANT** Atlas limits this feature to dedicated cluster tiers of M10 and greater. For more information see: https://www.mongodb.com/docs/
|
|
168
|
+
* > **IMPORTANT** Atlas limits this feature to dedicated cluster tiers of M10 and greater. For more information see: https://www.mongodb.com/docs/api/doc/atlas-admin-api-v2/group/endpoint-encryption-at-rest-using-customer-key-management
|
|
169
169
|
*
|
|
170
170
|
* > **NOTE:** Groups and projects are synonymous terms. You may find `groupId` in the official documentation.
|
|
171
171
|
*
|
package/getEncryptionAtRest.js
CHANGED
|
@@ -16,7 +16,7 @@ const utilities = require("./utilities");
|
|
|
16
16
|
*
|
|
17
17
|
* > **IMPORTANT** By default, Atlas enables encryption at rest for all cluster storage and snapshot volumes.
|
|
18
18
|
*
|
|
19
|
-
* > **IMPORTANT** Atlas limits this feature to dedicated cluster tiers of M10 and greater. For more information see: https://www.mongodb.com/docs/
|
|
19
|
+
* > **IMPORTANT** Atlas limits this feature to dedicated cluster tiers of M10 and greater. For more information see: https://www.mongodb.com/docs/api/doc/atlas-admin-api-v2/group/endpoint-encryption-at-rest-using-customer-key-management
|
|
20
20
|
*
|
|
21
21
|
* > **NOTE:** Groups and projects are synonymous terms. You may find `groupId` in the official documentation.
|
|
22
22
|
*
|
|
@@ -138,7 +138,7 @@ exports.getEncryptionAtRest = getEncryptionAtRest;
|
|
|
138
138
|
*
|
|
139
139
|
* > **IMPORTANT** By default, Atlas enables encryption at rest for all cluster storage and snapshot volumes.
|
|
140
140
|
*
|
|
141
|
-
* > **IMPORTANT** Atlas limits this feature to dedicated cluster tiers of M10 and greater. For more information see: https://www.mongodb.com/docs/
|
|
141
|
+
* > **IMPORTANT** Atlas limits this feature to dedicated cluster tiers of M10 and greater. For more information see: https://www.mongodb.com/docs/api/doc/atlas-admin-api-v2/group/endpoint-encryption-at-rest-using-customer-key-management
|
|
142
142
|
*
|
|
143
143
|
* > **NOTE:** Groups and projects are synonymous terms. You may find `groupId` in the official documentation.
|
|
144
144
|
*
|
package/getEventTrigger.d.ts
CHANGED
|
@@ -12,7 +12,7 @@ export declare function getEventTrigger(args: GetEventTriggerArgs, opts?: pulumi
|
|
|
12
12
|
export interface GetEventTriggerArgs {
|
|
13
13
|
/**
|
|
14
14
|
* The ObjectID of your application.
|
|
15
|
-
* * For more details on `projectId` and `appId` see: https://www.mongodb.com/docs/atlas
|
|
15
|
+
* * For more details on `projectId` and `appId` see: https://www.mongodb.com/docs/api/doc/atlas-app-services-admin-api-v3/#topic-project-amp-application-ids
|
|
16
16
|
*/
|
|
17
17
|
appId: string;
|
|
18
18
|
/**
|
|
@@ -118,7 +118,7 @@ export declare function getEventTriggerOutput(args: GetEventTriggerOutputArgs, o
|
|
|
118
118
|
export interface GetEventTriggerOutputArgs {
|
|
119
119
|
/**
|
|
120
120
|
* The ObjectID of your application.
|
|
121
|
-
* * For more details on `projectId` and `appId` see: https://www.mongodb.com/docs/atlas
|
|
121
|
+
* * For more details on `projectId` and `appId` see: https://www.mongodb.com/docs/api/doc/atlas-app-services-admin-api-v3/#topic-project-amp-application-ids
|
|
122
122
|
*/
|
|
123
123
|
appId: pulumi.Input<string>;
|
|
124
124
|
/**
|
package/getEventTriggers.d.ts
CHANGED
|
@@ -12,7 +12,7 @@ export declare function getEventTriggers(args: GetEventTriggersArgs, opts?: pulu
|
|
|
12
12
|
export interface GetEventTriggersArgs {
|
|
13
13
|
/**
|
|
14
14
|
* The ObjectID of your application.
|
|
15
|
-
* * For more details on `projectId` and `appId` see: https://www.mongodb.com/docs/atlas
|
|
15
|
+
* * For more details on `projectId` and `appId` see: https://www.mongodb.com/docs/api/doc/atlas-app-services-admin-api-v3/#topic-project-amp-application-ids
|
|
16
16
|
*/
|
|
17
17
|
appId: string;
|
|
18
18
|
/**
|
|
@@ -47,7 +47,7 @@ export declare function getEventTriggersOutput(args: GetEventTriggersOutputArgs,
|
|
|
47
47
|
export interface GetEventTriggersOutputArgs {
|
|
48
48
|
/**
|
|
49
49
|
* The ObjectID of your application.
|
|
50
|
-
* * For more details on `projectId` and `appId` see: https://www.mongodb.com/docs/atlas
|
|
50
|
+
* * For more details on `projectId` and `appId` see: https://www.mongodb.com/docs/api/doc/atlas-app-services-admin-api-v3/#topic-project-amp-application-ids
|
|
51
51
|
*/
|
|
52
52
|
appId: pulumi.Input<string>;
|
|
53
53
|
/**
|
|
@@ -19,24 +19,24 @@ import * as outputs from "./types/output";
|
|
|
19
19
|
* import * as mongodbatlas from "@pulumi/mongodbatlas";
|
|
20
20
|
*
|
|
21
21
|
* const test = mongodbatlas.getFederatedDatabaseInstance({
|
|
22
|
-
* projectId: "
|
|
22
|
+
* projectId: "<PROJECT_ID>",
|
|
23
23
|
* name: "TENANT NAME OF THE FEDERATED DATABASE INSTANCE",
|
|
24
24
|
* });
|
|
25
25
|
* ```
|
|
26
26
|
*
|
|
27
|
-
*
|
|
27
|
+
* ## Example of Azure Blob Storage as storage database
|
|
28
28
|
*
|
|
29
29
|
* ```typescript
|
|
30
30
|
* import * as pulumi from "@pulumi/pulumi";
|
|
31
31
|
* import * as mongodbatlas from "@pulumi/mongodbatlas";
|
|
32
32
|
*
|
|
33
33
|
* const test = mongodbatlas.getFederatedDatabaseInstance({
|
|
34
|
-
* projectId: "
|
|
35
|
-
* name: "
|
|
34
|
+
* projectId: "<PROJECT_ID>",
|
|
35
|
+
* name: "<TENANT_NAME_OF_THE_FEDERATED_DATABASE_INSTANCE>",
|
|
36
36
|
* cloudProviderConfig: {
|
|
37
|
-
*
|
|
38
|
-
*
|
|
39
|
-
* },
|
|
37
|
+
* azures: [{
|
|
38
|
+
* roleId: "<AZURE_ROLE_ID>",
|
|
39
|
+
* }],
|
|
40
40
|
* },
|
|
41
41
|
* });
|
|
42
42
|
* ```
|
|
@@ -144,24 +144,24 @@ export interface GetFederatedDatabaseInstanceResult {
|
|
|
144
144
|
* import * as mongodbatlas from "@pulumi/mongodbatlas";
|
|
145
145
|
*
|
|
146
146
|
* const test = mongodbatlas.getFederatedDatabaseInstance({
|
|
147
|
-
* projectId: "
|
|
147
|
+
* projectId: "<PROJECT_ID>",
|
|
148
148
|
* name: "TENANT NAME OF THE FEDERATED DATABASE INSTANCE",
|
|
149
149
|
* });
|
|
150
150
|
* ```
|
|
151
151
|
*
|
|
152
|
-
*
|
|
152
|
+
* ## Example of Azure Blob Storage as storage database
|
|
153
153
|
*
|
|
154
154
|
* ```typescript
|
|
155
155
|
* import * as pulumi from "@pulumi/pulumi";
|
|
156
156
|
* import * as mongodbatlas from "@pulumi/mongodbatlas";
|
|
157
157
|
*
|
|
158
158
|
* const test = mongodbatlas.getFederatedDatabaseInstance({
|
|
159
|
-
* projectId: "
|
|
160
|
-
* name: "
|
|
159
|
+
* projectId: "<PROJECT_ID>",
|
|
160
|
+
* name: "<TENANT_NAME_OF_THE_FEDERATED_DATABASE_INSTANCE>",
|
|
161
161
|
* cloudProviderConfig: {
|
|
162
|
-
*
|
|
163
|
-
*
|
|
164
|
-
* },
|
|
162
|
+
* azures: [{
|
|
163
|
+
* roleId: "<AZURE_ROLE_ID>",
|
|
164
|
+
* }],
|
|
165
165
|
* },
|
|
166
166
|
* });
|
|
167
167
|
* ```
|