@pulumi/mongodbatlas 3.37.0-alpha.1764050941 → 3.37.0
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/cloudProviderAccessAuthorization.d.ts +2 -0
- package/cloudProviderAccessAuthorization.js +2 -0
- package/cloudProviderAccessAuthorization.js.map +1 -1
- package/cloudProviderAccessSetup.d.ts +2 -0
- package/cloudProviderAccessSetup.js +2 -0
- package/cloudProviderAccessSetup.js.map +1 -1
- package/getCloudProviderAccessSetup.d.ts +44 -9
- package/getCloudProviderAccessSetup.js +36 -2
- package/getCloudProviderAccessSetup.js.map +1 -1
- package/getEncryptionAtRest.d.ts +4 -0
- package/getEncryptionAtRest.js +4 -0
- package/getEncryptionAtRest.js.map +1 -1
- package/getStreamPrivatelinkEndpoint.d.ts +226 -16
- package/getStreamPrivatelinkEndpoint.js +226 -16
- package/getStreamPrivatelinkEndpoint.js.map +1 -1
- package/getStreamPrivatelinkEndpoints.d.ts +226 -16
- package/getStreamPrivatelinkEndpoints.js +226 -16
- package/getStreamPrivatelinkEndpoints.js.map +1 -1
- package/networkPeering.d.ts +55 -1
- package/networkPeering.js +55 -1
- package/networkPeering.js.map +1 -1
- package/package.json +2 -2
- package/privatelinkEndpointServiceDataFederationOnlineArchive.d.ts +2 -2
- package/privatelinkEndpointServiceDataFederationOnlineArchive.js +2 -2
- package/privatelinkEndpointServiceServerless.d.ts +7 -7
- package/privatelinkEndpointServiceServerless.js +7 -7
- package/project.d.ts +3 -3
- package/streamPrivatelinkEndpoint.d.ts +113 -8
- package/streamPrivatelinkEndpoint.js +113 -8
- package/streamPrivatelinkEndpoint.js.map +1 -1
- package/types/input.d.ts +11 -0
- package/types/output.d.ts +25 -0
|
@@ -21,6 +21,7 @@ export declare class CloudProviderAccessAuthorization extends pulumi.CustomResou
|
|
|
21
21
|
readonly aws: pulumi.Output<outputs.CloudProviderAccessAuthorizationAws | undefined>;
|
|
22
22
|
readonly azure: pulumi.Output<outputs.CloudProviderAccessAuthorizationAzure | undefined>;
|
|
23
23
|
readonly featureUsages: pulumi.Output<outputs.CloudProviderAccessAuthorizationFeatureUsage[]>;
|
|
24
|
+
readonly gcps: pulumi.Output<outputs.CloudProviderAccessAuthorizationGcp[]>;
|
|
24
25
|
readonly projectId: pulumi.Output<string>;
|
|
25
26
|
readonly roleId: pulumi.Output<string>;
|
|
26
27
|
/**
|
|
@@ -40,6 +41,7 @@ export interface CloudProviderAccessAuthorizationState {
|
|
|
40
41
|
aws?: pulumi.Input<inputs.CloudProviderAccessAuthorizationAws>;
|
|
41
42
|
azure?: pulumi.Input<inputs.CloudProviderAccessAuthorizationAzure>;
|
|
42
43
|
featureUsages?: pulumi.Input<pulumi.Input<inputs.CloudProviderAccessAuthorizationFeatureUsage>[]>;
|
|
44
|
+
gcps?: pulumi.Input<pulumi.Input<inputs.CloudProviderAccessAuthorizationGcp>[]>;
|
|
43
45
|
projectId?: pulumi.Input<string>;
|
|
44
46
|
roleId?: pulumi.Input<string>;
|
|
45
47
|
}
|
|
@@ -37,6 +37,7 @@ class CloudProviderAccessAuthorization extends pulumi.CustomResource {
|
|
|
37
37
|
resourceInputs["aws"] = state?.aws;
|
|
38
38
|
resourceInputs["azure"] = state?.azure;
|
|
39
39
|
resourceInputs["featureUsages"] = state?.featureUsages;
|
|
40
|
+
resourceInputs["gcps"] = state?.gcps;
|
|
40
41
|
resourceInputs["projectId"] = state?.projectId;
|
|
41
42
|
resourceInputs["roleId"] = state?.roleId;
|
|
42
43
|
}
|
|
@@ -54,6 +55,7 @@ class CloudProviderAccessAuthorization extends pulumi.CustomResource {
|
|
|
54
55
|
resourceInputs["roleId"] = args?.roleId;
|
|
55
56
|
resourceInputs["authorizedDate"] = undefined /*out*/;
|
|
56
57
|
resourceInputs["featureUsages"] = undefined /*out*/;
|
|
58
|
+
resourceInputs["gcps"] = undefined /*out*/;
|
|
57
59
|
}
|
|
58
60
|
opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts);
|
|
59
61
|
super(CloudProviderAccessAuthorization.__pulumiType, name, resourceInputs, opts);
|
|
@@ -1 +1 @@
|
|
|
1
|
-
{"version":3,"file":"cloudProviderAccessAuthorization.js","sourceRoot":"","sources":["../cloudProviderAccessAuthorization.ts"],"names":[],"mappings":";AAAA,sEAAsE;AACtE,iFAAiF;;;AAEjF,yCAAyC;AAGzC,yCAAyC;AAEzC,MAAa,gCAAiC,SAAQ,MAAM,CAAC,cAAc;IACvE;;;;;;;;OAQG;IACI,MAAM,CAAC,GAAG,CAAC,IAAY,EAAE,EAA2B,EAAE,KAA6C,EAAE,IAAmC;QAC3I,OAAO,IAAI,gCAAgC,CAAC,IAAI,EAAO,KAAK,EAAE,EAAE,GAAG,IAAI,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC;IACvF,CAAC;IAKD;;;OAGG;IACI,MAAM,CAAC,UAAU,CAAC,GAAQ;QAC7B,IAAI,GAAG,KAAK,SAAS,IAAI,GAAG,KAAK,IAAI,EAAE;YACnC,OAAO,KAAK,CAAC;SAChB;QACD,OAAO,GAAG,CAAC,cAAc,CAAC,KAAK,gCAAgC,CAAC,YAAY,CAAC;IACjF,CAAC;
|
|
1
|
+
{"version":3,"file":"cloudProviderAccessAuthorization.js","sourceRoot":"","sources":["../cloudProviderAccessAuthorization.ts"],"names":[],"mappings":";AAAA,sEAAsE;AACtE,iFAAiF;;;AAEjF,yCAAyC;AAGzC,yCAAyC;AAEzC,MAAa,gCAAiC,SAAQ,MAAM,CAAC,cAAc;IACvE;;;;;;;;OAQG;IACI,MAAM,CAAC,GAAG,CAAC,IAAY,EAAE,EAA2B,EAAE,KAA6C,EAAE,IAAmC;QAC3I,OAAO,IAAI,gCAAgC,CAAC,IAAI,EAAO,KAAK,EAAE,EAAE,GAAG,IAAI,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC;IACvF,CAAC;IAKD;;;OAGG;IACI,MAAM,CAAC,UAAU,CAAC,GAAQ;QAC7B,IAAI,GAAG,KAAK,SAAS,IAAI,GAAG,KAAK,IAAI,EAAE;YACnC,OAAO,KAAK,CAAC;SAChB;QACD,OAAO,GAAG,CAAC,cAAc,CAAC,KAAK,gCAAgC,CAAC,YAAY,CAAC;IACjF,CAAC;IAkBD,YAAY,IAAY,EAAE,WAA0F,EAAE,IAAmC;QACrJ,IAAI,cAAc,GAAkB,EAAE,CAAC;QACvC,IAAI,GAAG,IAAI,IAAI,EAAE,CAAC;QAClB,IAAI,IAAI,CAAC,EAAE,EAAE;YACT,MAAM,KAAK,GAAG,WAAgE,CAAC;YAC/E,cAAc,CAAC,gBAAgB,CAAC,GAAG,KAAK,EAAE,cAAc,CAAC;YACzD,cAAc,CAAC,KAAK,CAAC,GAAG,KAAK,EAAE,GAAG,CAAC;YACnC,cAAc,CAAC,OAAO,CAAC,GAAG,KAAK,EAAE,KAAK,CAAC;YACvC,cAAc,CAAC,eAAe,CAAC,GAAG,KAAK,EAAE,aAAa,CAAC;YACvD,cAAc,CAAC,MAAM,CAAC,GAAG,KAAK,EAAE,IAAI,CAAC;YACrC,cAAc,CAAC,WAAW,CAAC,GAAG,KAAK,EAAE,SAAS,CAAC;YAC/C,cAAc,CAAC,QAAQ,CAAC,GAAG,KAAK,EAAE,MAAM,CAAC;SAC5C;aAAM;YACH,MAAM,IAAI,GAAG,WAA+D,CAAC;YAC7E,IAAI,IAAI,EAAE,SAAS,KAAK,SAAS,IAAI,CAAC,IAAI,CAAC,GAAG,EAAE;gBAC5C,MAAM,IAAI,KAAK,CAAC,uCAAuC,CAAC,CAAC;aAC5D;YACD,IAAI,IAAI,EAAE,MAAM,KAAK,SAAS,IAAI,CAAC,IAAI,CAAC,GAAG,EAAE;gBACzC,MAAM,IAAI,KAAK,CAAC,oCAAoC,CAAC,CAAC;aACzD;YACD,cAAc,CAAC,KAAK,CAAC,GAAG,IAAI,EAAE,GAAG,CAAC;YAClC,cAAc,CAAC,OAAO,CAAC,GAAG,IAAI,EAAE,KAAK,CAAC;YACtC,cAAc,CAAC,WAAW,CAAC,GAAG,IAAI,EAAE,SAAS,CAAC;YAC9C,cAAc,CAAC,QAAQ,CAAC,GAAG,IAAI,EAAE,MAAM,CAAC;YACxC,cAAc,CAAC,gBAAgB,CAAC,GAAG,SAAS,CAAC,OAAO,CAAC;YACrD,cAAc,CAAC,eAAe,CAAC,GAAG,SAAS,CAAC,OAAO,CAAC;YACpD,cAAc,CAAC,MAAM,CAAC,GAAG,SAAS,CAAC,OAAO,CAAC;SAC9C;QACD,IAAI,GAAG,MAAM,CAAC,YAAY,CAAC,SAAS,CAAC,oBAAoB,EAAE,EAAE,IAAI,CAAC,CAAC;QACnE,KAAK,CAAC,gCAAgC,CAAC,YAAY,EAAE,IAAI,EAAE,cAAc,EAAE,IAAI,CAAC,CAAC;IACrF,CAAC;;AA1EL,4EA2EC;AA7DG,gBAAgB;AACO,6CAAY,GAAG,sFAAsF,CAAC"}
|
|
@@ -20,6 +20,7 @@ export declare class CloudProviderAccessSetup extends pulumi.CustomResource {
|
|
|
20
20
|
readonly awsConfigs: pulumi.Output<outputs.CloudProviderAccessSetupAwsConfig[]>;
|
|
21
21
|
readonly azureConfigs: pulumi.Output<outputs.CloudProviderAccessSetupAzureConfig[] | undefined>;
|
|
22
22
|
readonly createdDate: pulumi.Output<string>;
|
|
23
|
+
readonly gcpConfigs: pulumi.Output<outputs.CloudProviderAccessSetupGcpConfig[]>;
|
|
23
24
|
readonly lastUpdatedDate: pulumi.Output<string>;
|
|
24
25
|
readonly projectId: pulumi.Output<string>;
|
|
25
26
|
readonly providerName: pulumi.Output<string>;
|
|
@@ -40,6 +41,7 @@ export interface CloudProviderAccessSetupState {
|
|
|
40
41
|
awsConfigs?: pulumi.Input<pulumi.Input<inputs.CloudProviderAccessSetupAwsConfig>[]>;
|
|
41
42
|
azureConfigs?: pulumi.Input<pulumi.Input<inputs.CloudProviderAccessSetupAzureConfig>[]>;
|
|
42
43
|
createdDate?: pulumi.Input<string>;
|
|
44
|
+
gcpConfigs?: pulumi.Input<pulumi.Input<inputs.CloudProviderAccessSetupGcpConfig>[]>;
|
|
43
45
|
lastUpdatedDate?: pulumi.Input<string>;
|
|
44
46
|
projectId?: pulumi.Input<string>;
|
|
45
47
|
providerName?: pulumi.Input<string>;
|
|
@@ -36,6 +36,7 @@ class CloudProviderAccessSetup extends pulumi.CustomResource {
|
|
|
36
36
|
resourceInputs["awsConfigs"] = state?.awsConfigs;
|
|
37
37
|
resourceInputs["azureConfigs"] = state?.azureConfigs;
|
|
38
38
|
resourceInputs["createdDate"] = state?.createdDate;
|
|
39
|
+
resourceInputs["gcpConfigs"] = state?.gcpConfigs;
|
|
39
40
|
resourceInputs["lastUpdatedDate"] = state?.lastUpdatedDate;
|
|
40
41
|
resourceInputs["projectId"] = state?.projectId;
|
|
41
42
|
resourceInputs["providerName"] = state?.providerName;
|
|
@@ -54,6 +55,7 @@ class CloudProviderAccessSetup extends pulumi.CustomResource {
|
|
|
54
55
|
resourceInputs["providerName"] = args?.providerName;
|
|
55
56
|
resourceInputs["awsConfigs"] = undefined /*out*/;
|
|
56
57
|
resourceInputs["createdDate"] = undefined /*out*/;
|
|
58
|
+
resourceInputs["gcpConfigs"] = undefined /*out*/;
|
|
57
59
|
resourceInputs["lastUpdatedDate"] = undefined /*out*/;
|
|
58
60
|
resourceInputs["roleId"] = undefined /*out*/;
|
|
59
61
|
}
|
|
@@ -1 +1 @@
|
|
|
1
|
-
{"version":3,"file":"cloudProviderAccessSetup.js","sourceRoot":"","sources":["../cloudProviderAccessSetup.ts"],"names":[],"mappings":";AAAA,sEAAsE;AACtE,iFAAiF;;;AAEjF,yCAAyC;AAGzC,yCAAyC;AAEzC,MAAa,wBAAyB,SAAQ,MAAM,CAAC,cAAc;IAC/D;;;;;;;;OAQG;IACI,MAAM,CAAC,GAAG,CAAC,IAAY,EAAE,EAA2B,EAAE,KAAqC,EAAE,IAAmC;QACnI,OAAO,IAAI,wBAAwB,CAAC,IAAI,EAAO,KAAK,EAAE,EAAE,GAAG,IAAI,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC;IAC/E,CAAC;IAKD;;;OAGG;IACI,MAAM,CAAC,UAAU,CAAC,GAAQ;QAC7B,IAAI,GAAG,KAAK,SAAS,IAAI,GAAG,KAAK,IAAI,EAAE;YACnC,OAAO,KAAK,CAAC;SAChB;QACD,OAAO,GAAG,CAAC,cAAc,CAAC,KAAK,wBAAwB,CAAC,YAAY,CAAC;IACzE,CAAC;
|
|
1
|
+
{"version":3,"file":"cloudProviderAccessSetup.js","sourceRoot":"","sources":["../cloudProviderAccessSetup.ts"],"names":[],"mappings":";AAAA,sEAAsE;AACtE,iFAAiF;;;AAEjF,yCAAyC;AAGzC,yCAAyC;AAEzC,MAAa,wBAAyB,SAAQ,MAAM,CAAC,cAAc;IAC/D;;;;;;;;OAQG;IACI,MAAM,CAAC,GAAG,CAAC,IAAY,EAAE,EAA2B,EAAE,KAAqC,EAAE,IAAmC;QACnI,OAAO,IAAI,wBAAwB,CAAC,IAAI,EAAO,KAAK,EAAE,EAAE,GAAG,IAAI,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC;IAC/E,CAAC;IAKD;;;OAGG;IACI,MAAM,CAAC,UAAU,CAAC,GAAQ;QAC7B,IAAI,GAAG,KAAK,SAAS,IAAI,GAAG,KAAK,IAAI,EAAE;YACnC,OAAO,KAAK,CAAC;SAChB;QACD,OAAO,GAAG,CAAC,cAAc,CAAC,KAAK,wBAAwB,CAAC,YAAY,CAAC;IACzE,CAAC;IAmBD,YAAY,IAAY,EAAE,WAA0E,EAAE,IAAmC;QACrI,IAAI,cAAc,GAAkB,EAAE,CAAC;QACvC,IAAI,GAAG,IAAI,IAAI,EAAE,CAAC;QAClB,IAAI,IAAI,CAAC,EAAE,EAAE;YACT,MAAM,KAAK,GAAG,WAAwD,CAAC;YACvE,cAAc,CAAC,YAAY,CAAC,GAAG,KAAK,EAAE,UAAU,CAAC;YACjD,cAAc,CAAC,cAAc,CAAC,GAAG,KAAK,EAAE,YAAY,CAAC;YACrD,cAAc,CAAC,aAAa,CAAC,GAAG,KAAK,EAAE,WAAW,CAAC;YACnD,cAAc,CAAC,YAAY,CAAC,GAAG,KAAK,EAAE,UAAU,CAAC;YACjD,cAAc,CAAC,iBAAiB,CAAC,GAAG,KAAK,EAAE,eAAe,CAAC;YAC3D,cAAc,CAAC,WAAW,CAAC,GAAG,KAAK,EAAE,SAAS,CAAC;YAC/C,cAAc,CAAC,cAAc,CAAC,GAAG,KAAK,EAAE,YAAY,CAAC;YACrD,cAAc,CAAC,QAAQ,CAAC,GAAG,KAAK,EAAE,MAAM,CAAC;SAC5C;aAAM;YACH,MAAM,IAAI,GAAG,WAAuD,CAAC;YACrE,IAAI,IAAI,EAAE,SAAS,KAAK,SAAS,IAAI,CAAC,IAAI,CAAC,GAAG,EAAE;gBAC5C,MAAM,IAAI,KAAK,CAAC,uCAAuC,CAAC,CAAC;aAC5D;YACD,IAAI,IAAI,EAAE,YAAY,KAAK,SAAS,IAAI,CAAC,IAAI,CAAC,GAAG,EAAE;gBAC/C,MAAM,IAAI,KAAK,CAAC,0CAA0C,CAAC,CAAC;aAC/D;YACD,cAAc,CAAC,cAAc,CAAC,GAAG,IAAI,EAAE,YAAY,CAAC;YACpD,cAAc,CAAC,WAAW,CAAC,GAAG,IAAI,EAAE,SAAS,CAAC;YAC9C,cAAc,CAAC,cAAc,CAAC,GAAG,IAAI,EAAE,YAAY,CAAC;YACpD,cAAc,CAAC,YAAY,CAAC,GAAG,SAAS,CAAC,OAAO,CAAC;YACjD,cAAc,CAAC,aAAa,CAAC,GAAG,SAAS,CAAC,OAAO,CAAC;YAClD,cAAc,CAAC,YAAY,CAAC,GAAG,SAAS,CAAC,OAAO,CAAC;YACjD,cAAc,CAAC,iBAAiB,CAAC,GAAG,SAAS,CAAC,OAAO,CAAC;YACtD,cAAc,CAAC,QAAQ,CAAC,GAAG,SAAS,CAAC,OAAO,CAAC;SAChD;QACD,IAAI,GAAG,MAAM,CAAC,YAAY,CAAC,SAAS,CAAC,oBAAoB,EAAE,EAAE,IAAI,CAAC,CAAC;QACnE,KAAK,CAAC,wBAAwB,CAAC,YAAY,EAAE,IAAI,EAAE,cAAc,EAAE,IAAI,CAAC,CAAC;IAC7E,CAAC;;AA7EL,4DA8EC;AAhEG,gBAAgB;AACO,qCAAY,GAAG,sEAAsE,CAAC"}
|
|
@@ -4,7 +4,7 @@ import * as outputs from "./types/output";
|
|
|
4
4
|
/**
|
|
5
5
|
* ## # Data Source: mongodbatlas.CloudProviderAccessSetup
|
|
6
6
|
*
|
|
7
|
-
* `mongodbatlas.CloudProviderAccessSetup` allows you to get a single role for a provider access role setup
|
|
7
|
+
* `mongodbatlas.CloudProviderAccessSetup` allows you to get a single role for a provider access role setup. Supported providers: AWS, AZURE and GCP.
|
|
8
8
|
*
|
|
9
9
|
* > **NOTE:** Groups and projects are synonymous terms. You may find `groupId` in the official documentation.
|
|
10
10
|
*
|
|
@@ -46,6 +46,23 @@ import * as outputs from "./types/output";
|
|
|
46
46
|
* roleId: testRole.roleId,
|
|
47
47
|
* });
|
|
48
48
|
* ```
|
|
49
|
+
*
|
|
50
|
+
* ### With GCP
|
|
51
|
+
*
|
|
52
|
+
* ```typescript
|
|
53
|
+
* import * as pulumi from "@pulumi/pulumi";
|
|
54
|
+
* import * as mongodbatlas from "@pulumi/mongodbatlas";
|
|
55
|
+
*
|
|
56
|
+
* const testRole = new mongodbatlas.CloudProviderAccessSetup("test_role", {
|
|
57
|
+
* projectId: "64259ee860c43338194b0f8e",
|
|
58
|
+
* providerName: "GCP",
|
|
59
|
+
* });
|
|
60
|
+
* const singleSetup = mongodbatlas.getCloudProviderAccessSetupOutput({
|
|
61
|
+
* projectId: testRole.projectId,
|
|
62
|
+
* providerName: testRole.providerName,
|
|
63
|
+
* roleId: testRole.roleId,
|
|
64
|
+
* });
|
|
65
|
+
* ```
|
|
49
66
|
*/
|
|
50
67
|
export declare function getCloudProviderAccessSetup(args: GetCloudProviderAccessSetupArgs, opts?: pulumi.InvokeOptions): Promise<GetCloudProviderAccessSetupResult>;
|
|
51
68
|
/**
|
|
@@ -61,11 +78,11 @@ export interface GetCloudProviderAccessSetupArgs {
|
|
|
61
78
|
*/
|
|
62
79
|
projectId: string;
|
|
63
80
|
/**
|
|
64
|
-
* cloud provider name
|
|
81
|
+
* cloud provider name. Supported values: `AWS`, `AZURE`, and `GCP`.
|
|
65
82
|
*/
|
|
66
83
|
providerName: string;
|
|
67
84
|
/**
|
|
68
|
-
* unique role id among all the
|
|
85
|
+
* unique role id among all the roles provided by MongoDB Atlas.
|
|
69
86
|
*/
|
|
70
87
|
roleId: string;
|
|
71
88
|
}
|
|
@@ -73,9 +90,6 @@ export interface GetCloudProviderAccessSetupArgs {
|
|
|
73
90
|
* A collection of values returned by getCloudProviderAccessSetup.
|
|
74
91
|
*/
|
|
75
92
|
export interface GetCloudProviderAccessSetupResult {
|
|
76
|
-
/**
|
|
77
|
-
* aws related role information
|
|
78
|
-
*/
|
|
79
93
|
readonly aws: {
|
|
80
94
|
[key: string]: string;
|
|
81
95
|
};
|
|
@@ -91,6 +105,10 @@ export interface GetCloudProviderAccessSetupResult {
|
|
|
91
105
|
* Date on which this role was created.
|
|
92
106
|
*/
|
|
93
107
|
readonly createdDate: string;
|
|
108
|
+
/**
|
|
109
|
+
* gcp related configurations
|
|
110
|
+
*/
|
|
111
|
+
readonly gcpConfigs: outputs.GetCloudProviderAccessSetupGcpConfig[];
|
|
94
112
|
/**
|
|
95
113
|
* The provider-assigned unique ID for this managed resource.
|
|
96
114
|
*/
|
|
@@ -106,7 +124,7 @@ export interface GetCloudProviderAccessSetupResult {
|
|
|
106
124
|
/**
|
|
107
125
|
* ## # Data Source: mongodbatlas.CloudProviderAccessSetup
|
|
108
126
|
*
|
|
109
|
-
* `mongodbatlas.CloudProviderAccessSetup` allows you to get a single role for a provider access role setup
|
|
127
|
+
* `mongodbatlas.CloudProviderAccessSetup` allows you to get a single role for a provider access role setup. Supported providers: AWS, AZURE and GCP.
|
|
110
128
|
*
|
|
111
129
|
* > **NOTE:** Groups and projects are synonymous terms. You may find `groupId` in the official documentation.
|
|
112
130
|
*
|
|
@@ -148,6 +166,23 @@ export interface GetCloudProviderAccessSetupResult {
|
|
|
148
166
|
* roleId: testRole.roleId,
|
|
149
167
|
* });
|
|
150
168
|
* ```
|
|
169
|
+
*
|
|
170
|
+
* ### With GCP
|
|
171
|
+
*
|
|
172
|
+
* ```typescript
|
|
173
|
+
* import * as pulumi from "@pulumi/pulumi";
|
|
174
|
+
* import * as mongodbatlas from "@pulumi/mongodbatlas";
|
|
175
|
+
*
|
|
176
|
+
* const testRole = new mongodbatlas.CloudProviderAccessSetup("test_role", {
|
|
177
|
+
* projectId: "64259ee860c43338194b0f8e",
|
|
178
|
+
* providerName: "GCP",
|
|
179
|
+
* });
|
|
180
|
+
* const singleSetup = mongodbatlas.getCloudProviderAccessSetupOutput({
|
|
181
|
+
* projectId: testRole.projectId,
|
|
182
|
+
* providerName: testRole.providerName,
|
|
183
|
+
* roleId: testRole.roleId,
|
|
184
|
+
* });
|
|
185
|
+
* ```
|
|
151
186
|
*/
|
|
152
187
|
export declare function getCloudProviderAccessSetupOutput(args: GetCloudProviderAccessSetupOutputArgs, opts?: pulumi.InvokeOutputOptions): pulumi.Output<GetCloudProviderAccessSetupResult>;
|
|
153
188
|
/**
|
|
@@ -163,11 +198,11 @@ export interface GetCloudProviderAccessSetupOutputArgs {
|
|
|
163
198
|
*/
|
|
164
199
|
projectId: pulumi.Input<string>;
|
|
165
200
|
/**
|
|
166
|
-
* cloud provider name
|
|
201
|
+
* cloud provider name. Supported values: `AWS`, `AZURE`, and `GCP`.
|
|
167
202
|
*/
|
|
168
203
|
providerName: pulumi.Input<string>;
|
|
169
204
|
/**
|
|
170
|
-
* unique role id among all the
|
|
205
|
+
* unique role id among all the roles provided by MongoDB Atlas.
|
|
171
206
|
*/
|
|
172
207
|
roleId: pulumi.Input<string>;
|
|
173
208
|
}
|
|
@@ -8,7 +8,7 @@ const utilities = require("./utilities");
|
|
|
8
8
|
/**
|
|
9
9
|
* ## # Data Source: mongodbatlas.CloudProviderAccessSetup
|
|
10
10
|
*
|
|
11
|
-
* `mongodbatlas.CloudProviderAccessSetup` allows you to get a single role for a provider access role setup
|
|
11
|
+
* `mongodbatlas.CloudProviderAccessSetup` allows you to get a single role for a provider access role setup. Supported providers: AWS, AZURE and GCP.
|
|
12
12
|
*
|
|
13
13
|
* > **NOTE:** Groups and projects are synonymous terms. You may find `groupId` in the official documentation.
|
|
14
14
|
*
|
|
@@ -50,6 +50,23 @@ const utilities = require("./utilities");
|
|
|
50
50
|
* roleId: testRole.roleId,
|
|
51
51
|
* });
|
|
52
52
|
* ```
|
|
53
|
+
*
|
|
54
|
+
* ### With GCP
|
|
55
|
+
*
|
|
56
|
+
* ```typescript
|
|
57
|
+
* import * as pulumi from "@pulumi/pulumi";
|
|
58
|
+
* import * as mongodbatlas from "@pulumi/mongodbatlas";
|
|
59
|
+
*
|
|
60
|
+
* const testRole = new mongodbatlas.CloudProviderAccessSetup("test_role", {
|
|
61
|
+
* projectId: "64259ee860c43338194b0f8e",
|
|
62
|
+
* providerName: "GCP",
|
|
63
|
+
* });
|
|
64
|
+
* const singleSetup = mongodbatlas.getCloudProviderAccessSetupOutput({
|
|
65
|
+
* projectId: testRole.projectId,
|
|
66
|
+
* providerName: testRole.providerName,
|
|
67
|
+
* roleId: testRole.roleId,
|
|
68
|
+
* });
|
|
69
|
+
* ```
|
|
53
70
|
*/
|
|
54
71
|
function getCloudProviderAccessSetup(args, opts) {
|
|
55
72
|
opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts || {});
|
|
@@ -64,7 +81,7 @@ exports.getCloudProviderAccessSetup = getCloudProviderAccessSetup;
|
|
|
64
81
|
/**
|
|
65
82
|
* ## # Data Source: mongodbatlas.CloudProviderAccessSetup
|
|
66
83
|
*
|
|
67
|
-
* `mongodbatlas.CloudProviderAccessSetup` allows you to get a single role for a provider access role setup
|
|
84
|
+
* `mongodbatlas.CloudProviderAccessSetup` allows you to get a single role for a provider access role setup. Supported providers: AWS, AZURE and GCP.
|
|
68
85
|
*
|
|
69
86
|
* > **NOTE:** Groups and projects are synonymous terms. You may find `groupId` in the official documentation.
|
|
70
87
|
*
|
|
@@ -106,6 +123,23 @@ exports.getCloudProviderAccessSetup = getCloudProviderAccessSetup;
|
|
|
106
123
|
* roleId: testRole.roleId,
|
|
107
124
|
* });
|
|
108
125
|
* ```
|
|
126
|
+
*
|
|
127
|
+
* ### With GCP
|
|
128
|
+
*
|
|
129
|
+
* ```typescript
|
|
130
|
+
* import * as pulumi from "@pulumi/pulumi";
|
|
131
|
+
* import * as mongodbatlas from "@pulumi/mongodbatlas";
|
|
132
|
+
*
|
|
133
|
+
* const testRole = new mongodbatlas.CloudProviderAccessSetup("test_role", {
|
|
134
|
+
* projectId: "64259ee860c43338194b0f8e",
|
|
135
|
+
* providerName: "GCP",
|
|
136
|
+
* });
|
|
137
|
+
* const singleSetup = mongodbatlas.getCloudProviderAccessSetupOutput({
|
|
138
|
+
* projectId: testRole.projectId,
|
|
139
|
+
* providerName: testRole.providerName,
|
|
140
|
+
* roleId: testRole.roleId,
|
|
141
|
+
* });
|
|
142
|
+
* ```
|
|
109
143
|
*/
|
|
110
144
|
function getCloudProviderAccessSetupOutput(args, opts) {
|
|
111
145
|
opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts || {});
|
|
@@ -1 +1 @@
|
|
|
1
|
-
{"version":3,"file":"getCloudProviderAccessSetup.js","sourceRoot":"","sources":["../getCloudProviderAccessSetup.ts"],"names":[],"mappings":";AAAA,sEAAsE;AACtE,iFAAiF;;;AAEjF,yCAAyC;AAGzC,yCAAyC;AAEzC
|
|
1
|
+
{"version":3,"file":"getCloudProviderAccessSetup.js","sourceRoot":"","sources":["../getCloudProviderAccessSetup.ts"],"names":[],"mappings":";AAAA,sEAAsE;AACtE,iFAAiF;;;AAEjF,yCAAyC;AAGzC,yCAAyC;AAEzC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8DG;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,cAAc,EAAE,IAAI,CAAC,YAAY;QACjC,WAAW,EAAE,IAAI,CAAC,SAAS;QAC3B,cAAc,EAAE,IAAI,CAAC,YAAY;QACjC,QAAQ,EAAE,IAAI,CAAC,MAAM;KACxB,EAAE,IAAI,CAAC,CAAC;AACb,CAAC;AARD,kEAQC;AAyDD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8DG;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,cAAc,EAAE,IAAI,CAAC,YAAY;QACjC,WAAW,EAAE,IAAI,CAAC,SAAS;QAC3B,cAAc,EAAE,IAAI,CAAC,YAAY;QACjC,QAAQ,EAAE,IAAI,CAAC,MAAM;KACxB,EAAE,IAAI,CAAC,CAAC;AACb,CAAC;AARD,8EAQC"}
|
package/getEncryptionAtRest.d.ts
CHANGED
|
@@ -97,6 +97,8 @@ import * as outputs from "./types/output";
|
|
|
97
97
|
* > **NOTE:** It is possible to configure Atlas Encryption at Rest to communicate with Customer Managed Keys (Azure Key Vault or AWS KMS) over private network interfaces (Azure Private Link or AWS PrivateLink). This requires enabling the `azure_key_vault_config.require_private_networking` or the `aws_kms_config.require_private_networking` attribute, together with the configuration of the `mongodbatlas.EncryptionAtRestPrivateEndpoint` resource. Please review the `mongodbatlas.EncryptionAtRestPrivateEndpoint` resource for details.
|
|
98
98
|
*
|
|
99
99
|
* ### Configuring encryption at rest using customer key management in GCP
|
|
100
|
+
* For authentication, you must provide either serviceAccountKey (static credentials) or roleId (service-account–based authentication). Once roleId is configured, serviceAccountKey is no longer supported.
|
|
101
|
+
*
|
|
100
102
|
* ```typescript
|
|
101
103
|
* import * as pulumi from "@pulumi/pulumi";
|
|
102
104
|
* import * as mongodbatlas from "@pulumi/mongodbatlas";
|
|
@@ -251,6 +253,8 @@ export interface GetEncryptionAtRestResult {
|
|
|
251
253
|
* > **NOTE:** It is possible to configure Atlas Encryption at Rest to communicate with Customer Managed Keys (Azure Key Vault or AWS KMS) over private network interfaces (Azure Private Link or AWS PrivateLink). This requires enabling the `azure_key_vault_config.require_private_networking` or the `aws_kms_config.require_private_networking` attribute, together with the configuration of the `mongodbatlas.EncryptionAtRestPrivateEndpoint` resource. Please review the `mongodbatlas.EncryptionAtRestPrivateEndpoint` resource for details.
|
|
252
254
|
*
|
|
253
255
|
* ### Configuring encryption at rest using customer key management in GCP
|
|
256
|
+
* For authentication, you must provide either serviceAccountKey (static credentials) or roleId (service-account–based authentication). Once roleId is configured, serviceAccountKey is no longer supported.
|
|
257
|
+
*
|
|
254
258
|
* ```typescript
|
|
255
259
|
* import * as pulumi from "@pulumi/pulumi";
|
|
256
260
|
* import * as mongodbatlas from "@pulumi/mongodbatlas";
|
package/getEncryptionAtRest.js
CHANGED
|
@@ -102,6 +102,8 @@ const utilities = require("./utilities");
|
|
|
102
102
|
* > **NOTE:** It is possible to configure Atlas Encryption at Rest to communicate with Customer Managed Keys (Azure Key Vault or AWS KMS) over private network interfaces (Azure Private Link or AWS PrivateLink). This requires enabling the `azure_key_vault_config.require_private_networking` or the `aws_kms_config.require_private_networking` attribute, together with the configuration of the `mongodbatlas.EncryptionAtRestPrivateEndpoint` resource. Please review the `mongodbatlas.EncryptionAtRestPrivateEndpoint` resource for details.
|
|
103
103
|
*
|
|
104
104
|
* ### Configuring encryption at rest using customer key management in GCP
|
|
105
|
+
* For authentication, you must provide either serviceAccountKey (static credentials) or roleId (service-account–based authentication). Once roleId is configured, serviceAccountKey is no longer supported.
|
|
106
|
+
*
|
|
105
107
|
* ```typescript
|
|
106
108
|
* import * as pulumi from "@pulumi/pulumi";
|
|
107
109
|
* import * as mongodbatlas from "@pulumi/mongodbatlas";
|
|
@@ -224,6 +226,8 @@ exports.getEncryptionAtRest = getEncryptionAtRest;
|
|
|
224
226
|
* > **NOTE:** It is possible to configure Atlas Encryption at Rest to communicate with Customer Managed Keys (Azure Key Vault or AWS KMS) over private network interfaces (Azure Private Link or AWS PrivateLink). This requires enabling the `azure_key_vault_config.require_private_networking` or the `aws_kms_config.require_private_networking` attribute, together with the configuration of the `mongodbatlas.EncryptionAtRestPrivateEndpoint` resource. Please review the `mongodbatlas.EncryptionAtRestPrivateEndpoint` resource for details.
|
|
225
227
|
*
|
|
226
228
|
* ### Configuring encryption at rest using customer key management in GCP
|
|
229
|
+
* For authentication, you must provide either serviceAccountKey (static credentials) or roleId (service-account–based authentication). Once roleId is configured, serviceAccountKey is no longer supported.
|
|
230
|
+
*
|
|
227
231
|
* ```typescript
|
|
228
232
|
* import * as pulumi from "@pulumi/pulumi";
|
|
229
233
|
* import * as mongodbatlas from "@pulumi/mongodbatlas";
|
|
@@ -1 +1 @@
|
|
|
1
|
-
{"version":3,"file":"getEncryptionAtRest.js","sourceRoot":"","sources":["../getEncryptionAtRest.ts"],"names":[],"mappings":";AAAA,sEAAsE;AACtE,iFAAiF;;;AAEjF,yCAAyC;AAGzC,yCAAyC;AAEzC
|
|
1
|
+
{"version":3,"file":"getEncryptionAtRest.js","sourceRoot":"","sources":["../getEncryptionAtRest.ts"],"names":[],"mappings":";AAAA,sEAAsE;AACtE,iFAAiF;;;AAEjF,yCAAyC;AAGzC,yCAAyC;AAEzC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoHG;AACH,SAAgB,mBAAmB,CAAC,IAA6B,EAAE,IAA2B;IAC1F,IAAI,GAAG,MAAM,CAAC,YAAY,CAAC,SAAS,CAAC,oBAAoB,EAAE,EAAE,IAAI,IAAI,EAAE,CAAC,CAAC;IACzE,OAAO,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,4DAA4D,EAAE;QACvF,WAAW,EAAE,IAAI,CAAC,SAAS;KAC9B,EAAE,IAAI,CAAC,CAAC;AACb,CAAC;AALD,kDAKC;AAyCD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoHG;AACH,SAAgB,yBAAyB,CAAC,IAAmC,EAAE,IAAiC;IAC5G,IAAI,GAAG,MAAM,CAAC,YAAY,CAAC,SAAS,CAAC,oBAAoB,EAAE,EAAE,IAAI,IAAI,EAAE,CAAC,CAAC;IACzE,OAAO,MAAM,CAAC,OAAO,CAAC,YAAY,CAAC,4DAA4D,EAAE;QAC7F,WAAW,EAAE,IAAI,CAAC,SAAS;KAC9B,EAAE,IAAI,CAAC,CAAC;AACb,CAAC;AALD,8DAKC"}
|
|
@@ -78,6 +78,111 @@ import * as pulumi from "@pulumi/pulumi";
|
|
|
78
78
|
* export const interfaceEndpointIds = pluralDatasource.then(pluralDatasource => pluralDatasource.results.map(__item => __item.interfaceEndpointId));
|
|
79
79
|
* ```
|
|
80
80
|
*
|
|
81
|
+
* ### AWS MSK Privatelink
|
|
82
|
+
* ```typescript
|
|
83
|
+
* import * as pulumi from "@pulumi/pulumi";
|
|
84
|
+
* import * as aws from "@pulumi/aws";
|
|
85
|
+
* import * as mongodbatlas from "@pulumi/mongodbatlas";
|
|
86
|
+
*
|
|
87
|
+
* const vpc = new aws.ec2.Vpc("vpc", {cidrBlock: "192.168.0.0/22"});
|
|
88
|
+
* const azs = aws.getAvailabilityZones({
|
|
89
|
+
* state: "available",
|
|
90
|
+
* });
|
|
91
|
+
* const subnetAz1 = new aws.ec2.Subnet("subnet_az1", {
|
|
92
|
+
* availabilityZone: azs.then(azs => azs.names?.[0]),
|
|
93
|
+
* cidrBlock: "192.168.0.0/24",
|
|
94
|
+
* vpcId: vpc.id,
|
|
95
|
+
* });
|
|
96
|
+
* const subnetAz2 = new aws.ec2.Subnet("subnet_az2", {
|
|
97
|
+
* availabilityZone: azs.then(azs => azs.names?.[1]),
|
|
98
|
+
* cidrBlock: "192.168.1.0/24",
|
|
99
|
+
* vpcId: vpc.id,
|
|
100
|
+
* });
|
|
101
|
+
* const sg = new aws.ec2.SecurityGroup("sg", {vpcId: vpc.id});
|
|
102
|
+
* const exampleConfiguration = new aws.msk.Configuration("example", {
|
|
103
|
+
* name: `${mskClusterName}-msk-configuration`,
|
|
104
|
+
* serverProperties: `auto.create.topics.enable=false
|
|
105
|
+
* default.replication.factor=3
|
|
106
|
+
* min.insync.replicas=2
|
|
107
|
+
* num.io.threads=8
|
|
108
|
+
* num.network.threads=5
|
|
109
|
+
* num.partitions=1
|
|
110
|
+
* num.replica.fetchers=2
|
|
111
|
+
* replica.lag.time.max.ms=30000
|
|
112
|
+
* socket.receive.buffer.bytes=102400
|
|
113
|
+
* socket.request.max.bytes=104857600
|
|
114
|
+
* socket.send.buffer.bytes=102400
|
|
115
|
+
* unclean.leader.election.enable=true
|
|
116
|
+
* allow.everyone.if.no.acl.found=false
|
|
117
|
+
* `,
|
|
118
|
+
* });
|
|
119
|
+
* const example = new aws.msk.Cluster("example", {
|
|
120
|
+
* clusterName: mskClusterName,
|
|
121
|
+
* kafkaVersion: "3.6.0",
|
|
122
|
+
* numberOfBrokerNodes: 2,
|
|
123
|
+
* brokerNodeGroupInfo: {
|
|
124
|
+
* instanceType: "kafka.m5.large",
|
|
125
|
+
* clientSubnets: [
|
|
126
|
+
* subnetAz1.id,
|
|
127
|
+
* subnetAz2.id,
|
|
128
|
+
* ],
|
|
129
|
+
* securityGroups: [sg.id],
|
|
130
|
+
* connectivityInfo: {
|
|
131
|
+
* vpcConnectivity: {
|
|
132
|
+
* clientAuthentication: {
|
|
133
|
+
* sasl: {
|
|
134
|
+
* scram: true,
|
|
135
|
+
* },
|
|
136
|
+
* },
|
|
137
|
+
* },
|
|
138
|
+
* },
|
|
139
|
+
* },
|
|
140
|
+
* clientAuthentication: {
|
|
141
|
+
* sasl: {
|
|
142
|
+
* scram: true,
|
|
143
|
+
* },
|
|
144
|
+
* },
|
|
145
|
+
* configurationInfo: {
|
|
146
|
+
* arn: exampleConfiguration.arn,
|
|
147
|
+
* revision: exampleConfiguration.latestRevision,
|
|
148
|
+
* },
|
|
149
|
+
* });
|
|
150
|
+
* const exampleClusterPolicy = new aws.msk.ClusterPolicy("example", {
|
|
151
|
+
* clusterArn: example.arn,
|
|
152
|
+
* policy: pulumi.jsonStringify({
|
|
153
|
+
* Version: "2012-10-17",
|
|
154
|
+
* Statement: [{
|
|
155
|
+
* Effect: "Allow",
|
|
156
|
+
* Principal: {
|
|
157
|
+
* AWS: `arn:aws:iam::${awsAccountId}:root`,
|
|
158
|
+
* },
|
|
159
|
+
* Action: [
|
|
160
|
+
* "kafka:CreateVpcConnection",
|
|
161
|
+
* "kafka:GetBootstrapBrokers",
|
|
162
|
+
* "kafka:DescribeCluster",
|
|
163
|
+
* "kafka:DescribeClusterV2",
|
|
164
|
+
* ],
|
|
165
|
+
* Resource: example.arn,
|
|
166
|
+
* }],
|
|
167
|
+
* }),
|
|
168
|
+
* });
|
|
169
|
+
* const exampleMskSingleScramSecretAssociation = new aws.index.MskSingleScramSecretAssociation("example", {
|
|
170
|
+
* clusterArn: example.arn,
|
|
171
|
+
* secretArn: awsSecretArn,
|
|
172
|
+
* });
|
|
173
|
+
* const test = new mongodbatlas.StreamPrivatelinkEndpoint("test", {
|
|
174
|
+
* projectId: projectId,
|
|
175
|
+
* providerName: "AWS",
|
|
176
|
+
* vendor: "MSK",
|
|
177
|
+
* arn: example.arn,
|
|
178
|
+
* });
|
|
179
|
+
* const singularDatasource = test.id.apply(id => mongodbatlas.getStreamPrivatelinkEndpointOutput({
|
|
180
|
+
* projectId: projectId,
|
|
181
|
+
* id: id,
|
|
182
|
+
* }));
|
|
183
|
+
* export const privatelinkEndpointId = singularDatasource.apply(singularDatasource => singularDatasource.id);
|
|
184
|
+
* ```
|
|
185
|
+
*
|
|
81
186
|
* ### AWS S3 Privatelink
|
|
82
187
|
* ```typescript
|
|
83
188
|
* import * as pulumi from "@pulumi/pulumi";
|
|
@@ -85,22 +190,22 @@ import * as pulumi from "@pulumi/pulumi";
|
|
|
85
190
|
* import * as mongodbatlas from "@pulumi/mongodbatlas";
|
|
86
191
|
*
|
|
87
192
|
* // S3 bucket for stream data
|
|
88
|
-
* const streamBucket = new aws.
|
|
193
|
+
* const streamBucket = new aws.s3.BucketV2("stream_bucket", {
|
|
89
194
|
* bucket: s3BucketName,
|
|
90
195
|
* forceDestroy: true,
|
|
91
196
|
* });
|
|
92
|
-
* const streamBucketVersioning = new aws.
|
|
197
|
+
* const streamBucketVersioning = new aws.s3.BucketVersioningV2("stream_bucket_versioning", {
|
|
93
198
|
* bucket: streamBucket.id,
|
|
94
|
-
* versioningConfiguration:
|
|
199
|
+
* versioningConfiguration: {
|
|
95
200
|
* status: "Enabled",
|
|
96
|
-
* }
|
|
201
|
+
* },
|
|
97
202
|
* });
|
|
98
|
-
* const streamBucketEncryption = new aws.
|
|
203
|
+
* const streamBucketEncryption = new aws.s3.BucketServerSideEncryptionConfigurationV2("stream_bucket_encryption", {
|
|
99
204
|
* bucket: streamBucket.id,
|
|
100
|
-
*
|
|
101
|
-
* applyServerSideEncryptionByDefault:
|
|
205
|
+
* rules: [{
|
|
206
|
+
* applyServerSideEncryptionByDefault: {
|
|
102
207
|
* sseAlgorithm: "AES256",
|
|
103
|
-
* }
|
|
208
|
+
* },
|
|
104
209
|
* }],
|
|
105
210
|
* });
|
|
106
211
|
* // PrivateLink for S3
|
|
@@ -220,6 +325,111 @@ export interface GetStreamPrivatelinkEndpointResult {
|
|
|
220
325
|
* export const interfaceEndpointIds = pluralDatasource.then(pluralDatasource => pluralDatasource.results.map(__item => __item.interfaceEndpointId));
|
|
221
326
|
* ```
|
|
222
327
|
*
|
|
328
|
+
* ### AWS MSK Privatelink
|
|
329
|
+
* ```typescript
|
|
330
|
+
* import * as pulumi from "@pulumi/pulumi";
|
|
331
|
+
* import * as aws from "@pulumi/aws";
|
|
332
|
+
* import * as mongodbatlas from "@pulumi/mongodbatlas";
|
|
333
|
+
*
|
|
334
|
+
* const vpc = new aws.ec2.Vpc("vpc", {cidrBlock: "192.168.0.0/22"});
|
|
335
|
+
* const azs = aws.getAvailabilityZones({
|
|
336
|
+
* state: "available",
|
|
337
|
+
* });
|
|
338
|
+
* const subnetAz1 = new aws.ec2.Subnet("subnet_az1", {
|
|
339
|
+
* availabilityZone: azs.then(azs => azs.names?.[0]),
|
|
340
|
+
* cidrBlock: "192.168.0.0/24",
|
|
341
|
+
* vpcId: vpc.id,
|
|
342
|
+
* });
|
|
343
|
+
* const subnetAz2 = new aws.ec2.Subnet("subnet_az2", {
|
|
344
|
+
* availabilityZone: azs.then(azs => azs.names?.[1]),
|
|
345
|
+
* cidrBlock: "192.168.1.0/24",
|
|
346
|
+
* vpcId: vpc.id,
|
|
347
|
+
* });
|
|
348
|
+
* const sg = new aws.ec2.SecurityGroup("sg", {vpcId: vpc.id});
|
|
349
|
+
* const exampleConfiguration = new aws.msk.Configuration("example", {
|
|
350
|
+
* name: `${mskClusterName}-msk-configuration`,
|
|
351
|
+
* serverProperties: `auto.create.topics.enable=false
|
|
352
|
+
* default.replication.factor=3
|
|
353
|
+
* min.insync.replicas=2
|
|
354
|
+
* num.io.threads=8
|
|
355
|
+
* num.network.threads=5
|
|
356
|
+
* num.partitions=1
|
|
357
|
+
* num.replica.fetchers=2
|
|
358
|
+
* replica.lag.time.max.ms=30000
|
|
359
|
+
* socket.receive.buffer.bytes=102400
|
|
360
|
+
* socket.request.max.bytes=104857600
|
|
361
|
+
* socket.send.buffer.bytes=102400
|
|
362
|
+
* unclean.leader.election.enable=true
|
|
363
|
+
* allow.everyone.if.no.acl.found=false
|
|
364
|
+
* `,
|
|
365
|
+
* });
|
|
366
|
+
* const example = new aws.msk.Cluster("example", {
|
|
367
|
+
* clusterName: mskClusterName,
|
|
368
|
+
* kafkaVersion: "3.6.0",
|
|
369
|
+
* numberOfBrokerNodes: 2,
|
|
370
|
+
* brokerNodeGroupInfo: {
|
|
371
|
+
* instanceType: "kafka.m5.large",
|
|
372
|
+
* clientSubnets: [
|
|
373
|
+
* subnetAz1.id,
|
|
374
|
+
* subnetAz2.id,
|
|
375
|
+
* ],
|
|
376
|
+
* securityGroups: [sg.id],
|
|
377
|
+
* connectivityInfo: {
|
|
378
|
+
* vpcConnectivity: {
|
|
379
|
+
* clientAuthentication: {
|
|
380
|
+
* sasl: {
|
|
381
|
+
* scram: true,
|
|
382
|
+
* },
|
|
383
|
+
* },
|
|
384
|
+
* },
|
|
385
|
+
* },
|
|
386
|
+
* },
|
|
387
|
+
* clientAuthentication: {
|
|
388
|
+
* sasl: {
|
|
389
|
+
* scram: true,
|
|
390
|
+
* },
|
|
391
|
+
* },
|
|
392
|
+
* configurationInfo: {
|
|
393
|
+
* arn: exampleConfiguration.arn,
|
|
394
|
+
* revision: exampleConfiguration.latestRevision,
|
|
395
|
+
* },
|
|
396
|
+
* });
|
|
397
|
+
* const exampleClusterPolicy = new aws.msk.ClusterPolicy("example", {
|
|
398
|
+
* clusterArn: example.arn,
|
|
399
|
+
* policy: pulumi.jsonStringify({
|
|
400
|
+
* Version: "2012-10-17",
|
|
401
|
+
* Statement: [{
|
|
402
|
+
* Effect: "Allow",
|
|
403
|
+
* Principal: {
|
|
404
|
+
* AWS: `arn:aws:iam::${awsAccountId}:root`,
|
|
405
|
+
* },
|
|
406
|
+
* Action: [
|
|
407
|
+
* "kafka:CreateVpcConnection",
|
|
408
|
+
* "kafka:GetBootstrapBrokers",
|
|
409
|
+
* "kafka:DescribeCluster",
|
|
410
|
+
* "kafka:DescribeClusterV2",
|
|
411
|
+
* ],
|
|
412
|
+
* Resource: example.arn,
|
|
413
|
+
* }],
|
|
414
|
+
* }),
|
|
415
|
+
* });
|
|
416
|
+
* const exampleMskSingleScramSecretAssociation = new aws.index.MskSingleScramSecretAssociation("example", {
|
|
417
|
+
* clusterArn: example.arn,
|
|
418
|
+
* secretArn: awsSecretArn,
|
|
419
|
+
* });
|
|
420
|
+
* const test = new mongodbatlas.StreamPrivatelinkEndpoint("test", {
|
|
421
|
+
* projectId: projectId,
|
|
422
|
+
* providerName: "AWS",
|
|
423
|
+
* vendor: "MSK",
|
|
424
|
+
* arn: example.arn,
|
|
425
|
+
* });
|
|
426
|
+
* const singularDatasource = test.id.apply(id => mongodbatlas.getStreamPrivatelinkEndpointOutput({
|
|
427
|
+
* projectId: projectId,
|
|
428
|
+
* id: id,
|
|
429
|
+
* }));
|
|
430
|
+
* export const privatelinkEndpointId = singularDatasource.apply(singularDatasource => singularDatasource.id);
|
|
431
|
+
* ```
|
|
432
|
+
*
|
|
223
433
|
* ### AWS S3 Privatelink
|
|
224
434
|
* ```typescript
|
|
225
435
|
* import * as pulumi from "@pulumi/pulumi";
|
|
@@ -227,22 +437,22 @@ export interface GetStreamPrivatelinkEndpointResult {
|
|
|
227
437
|
* import * as mongodbatlas from "@pulumi/mongodbatlas";
|
|
228
438
|
*
|
|
229
439
|
* // S3 bucket for stream data
|
|
230
|
-
* const streamBucket = new aws.
|
|
440
|
+
* const streamBucket = new aws.s3.BucketV2("stream_bucket", {
|
|
231
441
|
* bucket: s3BucketName,
|
|
232
442
|
* forceDestroy: true,
|
|
233
443
|
* });
|
|
234
|
-
* const streamBucketVersioning = new aws.
|
|
444
|
+
* const streamBucketVersioning = new aws.s3.BucketVersioningV2("stream_bucket_versioning", {
|
|
235
445
|
* bucket: streamBucket.id,
|
|
236
|
-
* versioningConfiguration:
|
|
446
|
+
* versioningConfiguration: {
|
|
237
447
|
* status: "Enabled",
|
|
238
|
-
* }
|
|
448
|
+
* },
|
|
239
449
|
* });
|
|
240
|
-
* const streamBucketEncryption = new aws.
|
|
450
|
+
* const streamBucketEncryption = new aws.s3.BucketServerSideEncryptionConfigurationV2("stream_bucket_encryption", {
|
|
241
451
|
* bucket: streamBucket.id,
|
|
242
|
-
*
|
|
243
|
-
* applyServerSideEncryptionByDefault:
|
|
452
|
+
* rules: [{
|
|
453
|
+
* applyServerSideEncryptionByDefault: {
|
|
244
454
|
* sseAlgorithm: "AES256",
|
|
245
|
-
* }
|
|
455
|
+
* },
|
|
246
456
|
* }],
|
|
247
457
|
* });
|
|
248
458
|
* // PrivateLink for S3
|