@pulumi/mongodbatlas 3.38.0-alpha.1764802483 → 3.38.0-alpha.1764888551
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/getStreamPrivatelinkEndpoint.d.ts +16 -226
- package/getStreamPrivatelinkEndpoint.js +16 -226
- package/getStreamPrivatelinkEndpoint.js.map +1 -1
- package/getStreamPrivatelinkEndpoints.d.ts +16 -226
- package/getStreamPrivatelinkEndpoints.js +16 -226
- package/getStreamPrivatelinkEndpoints.js.map +1 -1
- package/networkPeering.d.ts +1 -55
- package/networkPeering.js +1 -55
- 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/streamPrivatelinkEndpoint.d.ts +8 -113
- package/streamPrivatelinkEndpoint.js +8 -113
- package/streamPrivatelinkEndpoint.js.map +1 -1
|
@@ -79,111 +79,6 @@ import * as outputs from "./types/output";
|
|
|
79
79
|
* export const interfaceEndpointIds = pluralDatasource.then(pluralDatasource => pluralDatasource.results.map(__item => __item.interfaceEndpointId));
|
|
80
80
|
* ```
|
|
81
81
|
*
|
|
82
|
-
* ### AWS MSK Privatelink
|
|
83
|
-
* ```typescript
|
|
84
|
-
* import * as pulumi from "@pulumi/pulumi";
|
|
85
|
-
* import * as aws from "@pulumi/aws";
|
|
86
|
-
* import * as mongodbatlas from "@pulumi/mongodbatlas";
|
|
87
|
-
*
|
|
88
|
-
* const vpc = new aws.ec2.Vpc("vpc", {cidrBlock: "192.168.0.0/22"});
|
|
89
|
-
* const azs = aws.getAvailabilityZones({
|
|
90
|
-
* state: "available",
|
|
91
|
-
* });
|
|
92
|
-
* const subnetAz1 = new aws.ec2.Subnet("subnet_az1", {
|
|
93
|
-
* availabilityZone: azs.then(azs => azs.names?.[0]),
|
|
94
|
-
* cidrBlock: "192.168.0.0/24",
|
|
95
|
-
* vpcId: vpc.id,
|
|
96
|
-
* });
|
|
97
|
-
* const subnetAz2 = new aws.ec2.Subnet("subnet_az2", {
|
|
98
|
-
* availabilityZone: azs.then(azs => azs.names?.[1]),
|
|
99
|
-
* cidrBlock: "192.168.1.0/24",
|
|
100
|
-
* vpcId: vpc.id,
|
|
101
|
-
* });
|
|
102
|
-
* const sg = new aws.ec2.SecurityGroup("sg", {vpcId: vpc.id});
|
|
103
|
-
* const exampleConfiguration = new aws.msk.Configuration("example", {
|
|
104
|
-
* name: `${mskClusterName}-msk-configuration`,
|
|
105
|
-
* serverProperties: `auto.create.topics.enable=false
|
|
106
|
-
* default.replication.factor=3
|
|
107
|
-
* min.insync.replicas=2
|
|
108
|
-
* num.io.threads=8
|
|
109
|
-
* num.network.threads=5
|
|
110
|
-
* num.partitions=1
|
|
111
|
-
* num.replica.fetchers=2
|
|
112
|
-
* replica.lag.time.max.ms=30000
|
|
113
|
-
* socket.receive.buffer.bytes=102400
|
|
114
|
-
* socket.request.max.bytes=104857600
|
|
115
|
-
* socket.send.buffer.bytes=102400
|
|
116
|
-
* unclean.leader.election.enable=true
|
|
117
|
-
* allow.everyone.if.no.acl.found=false
|
|
118
|
-
* `,
|
|
119
|
-
* });
|
|
120
|
-
* const example = new aws.msk.Cluster("example", {
|
|
121
|
-
* clusterName: mskClusterName,
|
|
122
|
-
* kafkaVersion: "3.6.0",
|
|
123
|
-
* numberOfBrokerNodes: 2,
|
|
124
|
-
* brokerNodeGroupInfo: {
|
|
125
|
-
* instanceType: "kafka.m5.large",
|
|
126
|
-
* clientSubnets: [
|
|
127
|
-
* subnetAz1.id,
|
|
128
|
-
* subnetAz2.id,
|
|
129
|
-
* ],
|
|
130
|
-
* securityGroups: [sg.id],
|
|
131
|
-
* connectivityInfo: {
|
|
132
|
-
* vpcConnectivity: {
|
|
133
|
-
* clientAuthentication: {
|
|
134
|
-
* sasl: {
|
|
135
|
-
* scram: true,
|
|
136
|
-
* },
|
|
137
|
-
* },
|
|
138
|
-
* },
|
|
139
|
-
* },
|
|
140
|
-
* },
|
|
141
|
-
* clientAuthentication: {
|
|
142
|
-
* sasl: {
|
|
143
|
-
* scram: true,
|
|
144
|
-
* },
|
|
145
|
-
* },
|
|
146
|
-
* configurationInfo: {
|
|
147
|
-
* arn: exampleConfiguration.arn,
|
|
148
|
-
* revision: exampleConfiguration.latestRevision,
|
|
149
|
-
* },
|
|
150
|
-
* });
|
|
151
|
-
* const exampleClusterPolicy = new aws.msk.ClusterPolicy("example", {
|
|
152
|
-
* clusterArn: example.arn,
|
|
153
|
-
* policy: pulumi.jsonStringify({
|
|
154
|
-
* Version: "2012-10-17",
|
|
155
|
-
* Statement: [{
|
|
156
|
-
* Effect: "Allow",
|
|
157
|
-
* Principal: {
|
|
158
|
-
* AWS: `arn:aws:iam::${awsAccountId}:root`,
|
|
159
|
-
* },
|
|
160
|
-
* Action: [
|
|
161
|
-
* "kafka:CreateVpcConnection",
|
|
162
|
-
* "kafka:GetBootstrapBrokers",
|
|
163
|
-
* "kafka:DescribeCluster",
|
|
164
|
-
* "kafka:DescribeClusterV2",
|
|
165
|
-
* ],
|
|
166
|
-
* Resource: example.arn,
|
|
167
|
-
* }],
|
|
168
|
-
* }),
|
|
169
|
-
* });
|
|
170
|
-
* const exampleMskSingleScramSecretAssociation = new aws.index.MskSingleScramSecretAssociation("example", {
|
|
171
|
-
* clusterArn: example.arn,
|
|
172
|
-
* secretArn: awsSecretArn,
|
|
173
|
-
* });
|
|
174
|
-
* const test = new mongodbatlas.StreamPrivatelinkEndpoint("test", {
|
|
175
|
-
* projectId: projectId,
|
|
176
|
-
* providerName: "AWS",
|
|
177
|
-
* vendor: "MSK",
|
|
178
|
-
* arn: example.arn,
|
|
179
|
-
* });
|
|
180
|
-
* const singularDatasource = test.id.apply(id => mongodbatlas.getStreamPrivatelinkEndpointOutput({
|
|
181
|
-
* projectId: projectId,
|
|
182
|
-
* id: id,
|
|
183
|
-
* }));
|
|
184
|
-
* export const privatelinkEndpointId = singularDatasource.apply(singularDatasource => singularDatasource.id);
|
|
185
|
-
* ```
|
|
186
|
-
*
|
|
187
82
|
* ### AWS S3 Privatelink
|
|
188
83
|
* ```typescript
|
|
189
84
|
* import * as pulumi from "@pulumi/pulumi";
|
|
@@ -191,22 +86,22 @@ import * as outputs from "./types/output";
|
|
|
191
86
|
* import * as mongodbatlas from "@pulumi/mongodbatlas";
|
|
192
87
|
*
|
|
193
88
|
* // S3 bucket for stream data
|
|
194
|
-
* const streamBucket = new aws.
|
|
89
|
+
* const streamBucket = new aws.index.S3Bucket("stream_bucket", {
|
|
195
90
|
* bucket: s3BucketName,
|
|
196
91
|
* forceDestroy: true,
|
|
197
92
|
* });
|
|
198
|
-
* const streamBucketVersioning = new aws.
|
|
93
|
+
* const streamBucketVersioning = new aws.index.S3BucketVersioning("stream_bucket_versioning", {
|
|
199
94
|
* bucket: streamBucket.id,
|
|
200
|
-
* versioningConfiguration: {
|
|
95
|
+
* versioningConfiguration: [{
|
|
201
96
|
* status: "Enabled",
|
|
202
|
-
* },
|
|
97
|
+
* }],
|
|
203
98
|
* });
|
|
204
|
-
* const streamBucketEncryption = new aws.
|
|
99
|
+
* const streamBucketEncryption = new aws.index.S3BucketServerSideEncryptionConfiguration("stream_bucket_encryption", {
|
|
205
100
|
* bucket: streamBucket.id,
|
|
206
|
-
*
|
|
207
|
-
* applyServerSideEncryptionByDefault: {
|
|
101
|
+
* rule: [{
|
|
102
|
+
* applyServerSideEncryptionByDefault: [{
|
|
208
103
|
* sseAlgorithm: "AES256",
|
|
209
|
-
* },
|
|
104
|
+
* }],
|
|
210
105
|
* }],
|
|
211
106
|
* });
|
|
212
107
|
* // PrivateLink for S3
|
|
@@ -317,111 +212,6 @@ export interface GetStreamPrivatelinkEndpointsResult {
|
|
|
317
212
|
* export const interfaceEndpointIds = pluralDatasource.then(pluralDatasource => pluralDatasource.results.map(__item => __item.interfaceEndpointId));
|
|
318
213
|
* ```
|
|
319
214
|
*
|
|
320
|
-
* ### AWS MSK Privatelink
|
|
321
|
-
* ```typescript
|
|
322
|
-
* import * as pulumi from "@pulumi/pulumi";
|
|
323
|
-
* import * as aws from "@pulumi/aws";
|
|
324
|
-
* import * as mongodbatlas from "@pulumi/mongodbatlas";
|
|
325
|
-
*
|
|
326
|
-
* const vpc = new aws.ec2.Vpc("vpc", {cidrBlock: "192.168.0.0/22"});
|
|
327
|
-
* const azs = aws.getAvailabilityZones({
|
|
328
|
-
* state: "available",
|
|
329
|
-
* });
|
|
330
|
-
* const subnetAz1 = new aws.ec2.Subnet("subnet_az1", {
|
|
331
|
-
* availabilityZone: azs.then(azs => azs.names?.[0]),
|
|
332
|
-
* cidrBlock: "192.168.0.0/24",
|
|
333
|
-
* vpcId: vpc.id,
|
|
334
|
-
* });
|
|
335
|
-
* const subnetAz2 = new aws.ec2.Subnet("subnet_az2", {
|
|
336
|
-
* availabilityZone: azs.then(azs => azs.names?.[1]),
|
|
337
|
-
* cidrBlock: "192.168.1.0/24",
|
|
338
|
-
* vpcId: vpc.id,
|
|
339
|
-
* });
|
|
340
|
-
* const sg = new aws.ec2.SecurityGroup("sg", {vpcId: vpc.id});
|
|
341
|
-
* const exampleConfiguration = new aws.msk.Configuration("example", {
|
|
342
|
-
* name: `${mskClusterName}-msk-configuration`,
|
|
343
|
-
* serverProperties: `auto.create.topics.enable=false
|
|
344
|
-
* default.replication.factor=3
|
|
345
|
-
* min.insync.replicas=2
|
|
346
|
-
* num.io.threads=8
|
|
347
|
-
* num.network.threads=5
|
|
348
|
-
* num.partitions=1
|
|
349
|
-
* num.replica.fetchers=2
|
|
350
|
-
* replica.lag.time.max.ms=30000
|
|
351
|
-
* socket.receive.buffer.bytes=102400
|
|
352
|
-
* socket.request.max.bytes=104857600
|
|
353
|
-
* socket.send.buffer.bytes=102400
|
|
354
|
-
* unclean.leader.election.enable=true
|
|
355
|
-
* allow.everyone.if.no.acl.found=false
|
|
356
|
-
* `,
|
|
357
|
-
* });
|
|
358
|
-
* const example = new aws.msk.Cluster("example", {
|
|
359
|
-
* clusterName: mskClusterName,
|
|
360
|
-
* kafkaVersion: "3.6.0",
|
|
361
|
-
* numberOfBrokerNodes: 2,
|
|
362
|
-
* brokerNodeGroupInfo: {
|
|
363
|
-
* instanceType: "kafka.m5.large",
|
|
364
|
-
* clientSubnets: [
|
|
365
|
-
* subnetAz1.id,
|
|
366
|
-
* subnetAz2.id,
|
|
367
|
-
* ],
|
|
368
|
-
* securityGroups: [sg.id],
|
|
369
|
-
* connectivityInfo: {
|
|
370
|
-
* vpcConnectivity: {
|
|
371
|
-
* clientAuthentication: {
|
|
372
|
-
* sasl: {
|
|
373
|
-
* scram: true,
|
|
374
|
-
* },
|
|
375
|
-
* },
|
|
376
|
-
* },
|
|
377
|
-
* },
|
|
378
|
-
* },
|
|
379
|
-
* clientAuthentication: {
|
|
380
|
-
* sasl: {
|
|
381
|
-
* scram: true,
|
|
382
|
-
* },
|
|
383
|
-
* },
|
|
384
|
-
* configurationInfo: {
|
|
385
|
-
* arn: exampleConfiguration.arn,
|
|
386
|
-
* revision: exampleConfiguration.latestRevision,
|
|
387
|
-
* },
|
|
388
|
-
* });
|
|
389
|
-
* const exampleClusterPolicy = new aws.msk.ClusterPolicy("example", {
|
|
390
|
-
* clusterArn: example.arn,
|
|
391
|
-
* policy: pulumi.jsonStringify({
|
|
392
|
-
* Version: "2012-10-17",
|
|
393
|
-
* Statement: [{
|
|
394
|
-
* Effect: "Allow",
|
|
395
|
-
* Principal: {
|
|
396
|
-
* AWS: `arn:aws:iam::${awsAccountId}:root`,
|
|
397
|
-
* },
|
|
398
|
-
* Action: [
|
|
399
|
-
* "kafka:CreateVpcConnection",
|
|
400
|
-
* "kafka:GetBootstrapBrokers",
|
|
401
|
-
* "kafka:DescribeCluster",
|
|
402
|
-
* "kafka:DescribeClusterV2",
|
|
403
|
-
* ],
|
|
404
|
-
* Resource: example.arn,
|
|
405
|
-
* }],
|
|
406
|
-
* }),
|
|
407
|
-
* });
|
|
408
|
-
* const exampleMskSingleScramSecretAssociation = new aws.index.MskSingleScramSecretAssociation("example", {
|
|
409
|
-
* clusterArn: example.arn,
|
|
410
|
-
* secretArn: awsSecretArn,
|
|
411
|
-
* });
|
|
412
|
-
* const test = new mongodbatlas.StreamPrivatelinkEndpoint("test", {
|
|
413
|
-
* projectId: projectId,
|
|
414
|
-
* providerName: "AWS",
|
|
415
|
-
* vendor: "MSK",
|
|
416
|
-
* arn: example.arn,
|
|
417
|
-
* });
|
|
418
|
-
* const singularDatasource = test.id.apply(id => mongodbatlas.getStreamPrivatelinkEndpointOutput({
|
|
419
|
-
* projectId: projectId,
|
|
420
|
-
* id: id,
|
|
421
|
-
* }));
|
|
422
|
-
* export const privatelinkEndpointId = singularDatasource.apply(singularDatasource => singularDatasource.id);
|
|
423
|
-
* ```
|
|
424
|
-
*
|
|
425
215
|
* ### AWS S3 Privatelink
|
|
426
216
|
* ```typescript
|
|
427
217
|
* import * as pulumi from "@pulumi/pulumi";
|
|
@@ -429,22 +219,22 @@ export interface GetStreamPrivatelinkEndpointsResult {
|
|
|
429
219
|
* import * as mongodbatlas from "@pulumi/mongodbatlas";
|
|
430
220
|
*
|
|
431
221
|
* // S3 bucket for stream data
|
|
432
|
-
* const streamBucket = new aws.
|
|
222
|
+
* const streamBucket = new aws.index.S3Bucket("stream_bucket", {
|
|
433
223
|
* bucket: s3BucketName,
|
|
434
224
|
* forceDestroy: true,
|
|
435
225
|
* });
|
|
436
|
-
* const streamBucketVersioning = new aws.
|
|
226
|
+
* const streamBucketVersioning = new aws.index.S3BucketVersioning("stream_bucket_versioning", {
|
|
437
227
|
* bucket: streamBucket.id,
|
|
438
|
-
* versioningConfiguration: {
|
|
228
|
+
* versioningConfiguration: [{
|
|
439
229
|
* status: "Enabled",
|
|
440
|
-
* },
|
|
230
|
+
* }],
|
|
441
231
|
* });
|
|
442
|
-
* const streamBucketEncryption = new aws.
|
|
232
|
+
* const streamBucketEncryption = new aws.index.S3BucketServerSideEncryptionConfiguration("stream_bucket_encryption", {
|
|
443
233
|
* bucket: streamBucket.id,
|
|
444
|
-
*
|
|
445
|
-
* applyServerSideEncryptionByDefault: {
|
|
234
|
+
* rule: [{
|
|
235
|
+
* applyServerSideEncryptionByDefault: [{
|
|
446
236
|
* sseAlgorithm: "AES256",
|
|
447
|
-
* },
|
|
237
|
+
* }],
|
|
448
238
|
* }],
|
|
449
239
|
* });
|
|
450
240
|
* // PrivateLink for S3
|
|
@@ -84,111 +84,6 @@ const utilities = require("./utilities");
|
|
|
84
84
|
* export const interfaceEndpointIds = pluralDatasource.then(pluralDatasource => pluralDatasource.results.map(__item => __item.interfaceEndpointId));
|
|
85
85
|
* ```
|
|
86
86
|
*
|
|
87
|
-
* ### AWS MSK Privatelink
|
|
88
|
-
* ```typescript
|
|
89
|
-
* import * as pulumi from "@pulumi/pulumi";
|
|
90
|
-
* import * as aws from "@pulumi/aws";
|
|
91
|
-
* import * as mongodbatlas from "@pulumi/mongodbatlas";
|
|
92
|
-
*
|
|
93
|
-
* const vpc = new aws.ec2.Vpc("vpc", {cidrBlock: "192.168.0.0/22"});
|
|
94
|
-
* const azs = aws.getAvailabilityZones({
|
|
95
|
-
* state: "available",
|
|
96
|
-
* });
|
|
97
|
-
* const subnetAz1 = new aws.ec2.Subnet("subnet_az1", {
|
|
98
|
-
* availabilityZone: azs.then(azs => azs.names?.[0]),
|
|
99
|
-
* cidrBlock: "192.168.0.0/24",
|
|
100
|
-
* vpcId: vpc.id,
|
|
101
|
-
* });
|
|
102
|
-
* const subnetAz2 = new aws.ec2.Subnet("subnet_az2", {
|
|
103
|
-
* availabilityZone: azs.then(azs => azs.names?.[1]),
|
|
104
|
-
* cidrBlock: "192.168.1.0/24",
|
|
105
|
-
* vpcId: vpc.id,
|
|
106
|
-
* });
|
|
107
|
-
* const sg = new aws.ec2.SecurityGroup("sg", {vpcId: vpc.id});
|
|
108
|
-
* const exampleConfiguration = new aws.msk.Configuration("example", {
|
|
109
|
-
* name: `${mskClusterName}-msk-configuration`,
|
|
110
|
-
* serverProperties: `auto.create.topics.enable=false
|
|
111
|
-
* default.replication.factor=3
|
|
112
|
-
* min.insync.replicas=2
|
|
113
|
-
* num.io.threads=8
|
|
114
|
-
* num.network.threads=5
|
|
115
|
-
* num.partitions=1
|
|
116
|
-
* num.replica.fetchers=2
|
|
117
|
-
* replica.lag.time.max.ms=30000
|
|
118
|
-
* socket.receive.buffer.bytes=102400
|
|
119
|
-
* socket.request.max.bytes=104857600
|
|
120
|
-
* socket.send.buffer.bytes=102400
|
|
121
|
-
* unclean.leader.election.enable=true
|
|
122
|
-
* allow.everyone.if.no.acl.found=false
|
|
123
|
-
* `,
|
|
124
|
-
* });
|
|
125
|
-
* const example = new aws.msk.Cluster("example", {
|
|
126
|
-
* clusterName: mskClusterName,
|
|
127
|
-
* kafkaVersion: "3.6.0",
|
|
128
|
-
* numberOfBrokerNodes: 2,
|
|
129
|
-
* brokerNodeGroupInfo: {
|
|
130
|
-
* instanceType: "kafka.m5.large",
|
|
131
|
-
* clientSubnets: [
|
|
132
|
-
* subnetAz1.id,
|
|
133
|
-
* subnetAz2.id,
|
|
134
|
-
* ],
|
|
135
|
-
* securityGroups: [sg.id],
|
|
136
|
-
* connectivityInfo: {
|
|
137
|
-
* vpcConnectivity: {
|
|
138
|
-
* clientAuthentication: {
|
|
139
|
-
* sasl: {
|
|
140
|
-
* scram: true,
|
|
141
|
-
* },
|
|
142
|
-
* },
|
|
143
|
-
* },
|
|
144
|
-
* },
|
|
145
|
-
* },
|
|
146
|
-
* clientAuthentication: {
|
|
147
|
-
* sasl: {
|
|
148
|
-
* scram: true,
|
|
149
|
-
* },
|
|
150
|
-
* },
|
|
151
|
-
* configurationInfo: {
|
|
152
|
-
* arn: exampleConfiguration.arn,
|
|
153
|
-
* revision: exampleConfiguration.latestRevision,
|
|
154
|
-
* },
|
|
155
|
-
* });
|
|
156
|
-
* const exampleClusterPolicy = new aws.msk.ClusterPolicy("example", {
|
|
157
|
-
* clusterArn: example.arn,
|
|
158
|
-
* policy: pulumi.jsonStringify({
|
|
159
|
-
* Version: "2012-10-17",
|
|
160
|
-
* Statement: [{
|
|
161
|
-
* Effect: "Allow",
|
|
162
|
-
* Principal: {
|
|
163
|
-
* AWS: `arn:aws:iam::${awsAccountId}:root`,
|
|
164
|
-
* },
|
|
165
|
-
* Action: [
|
|
166
|
-
* "kafka:CreateVpcConnection",
|
|
167
|
-
* "kafka:GetBootstrapBrokers",
|
|
168
|
-
* "kafka:DescribeCluster",
|
|
169
|
-
* "kafka:DescribeClusterV2",
|
|
170
|
-
* ],
|
|
171
|
-
* Resource: example.arn,
|
|
172
|
-
* }],
|
|
173
|
-
* }),
|
|
174
|
-
* });
|
|
175
|
-
* const exampleMskSingleScramSecretAssociation = new aws.index.MskSingleScramSecretAssociation("example", {
|
|
176
|
-
* clusterArn: example.arn,
|
|
177
|
-
* secretArn: awsSecretArn,
|
|
178
|
-
* });
|
|
179
|
-
* const test = new mongodbatlas.StreamPrivatelinkEndpoint("test", {
|
|
180
|
-
* projectId: projectId,
|
|
181
|
-
* providerName: "AWS",
|
|
182
|
-
* vendor: "MSK",
|
|
183
|
-
* arn: example.arn,
|
|
184
|
-
* });
|
|
185
|
-
* const singularDatasource = test.id.apply(id => mongodbatlas.getStreamPrivatelinkEndpointOutput({
|
|
186
|
-
* projectId: projectId,
|
|
187
|
-
* id: id,
|
|
188
|
-
* }));
|
|
189
|
-
* export const privatelinkEndpointId = singularDatasource.apply(singularDatasource => singularDatasource.id);
|
|
190
|
-
* ```
|
|
191
|
-
*
|
|
192
87
|
* ### AWS S3 Privatelink
|
|
193
88
|
* ```typescript
|
|
194
89
|
* import * as pulumi from "@pulumi/pulumi";
|
|
@@ -196,22 +91,22 @@ const utilities = require("./utilities");
|
|
|
196
91
|
* import * as mongodbatlas from "@pulumi/mongodbatlas";
|
|
197
92
|
*
|
|
198
93
|
* // S3 bucket for stream data
|
|
199
|
-
* const streamBucket = new aws.
|
|
94
|
+
* const streamBucket = new aws.index.S3Bucket("stream_bucket", {
|
|
200
95
|
* bucket: s3BucketName,
|
|
201
96
|
* forceDestroy: true,
|
|
202
97
|
* });
|
|
203
|
-
* const streamBucketVersioning = new aws.
|
|
98
|
+
* const streamBucketVersioning = new aws.index.S3BucketVersioning("stream_bucket_versioning", {
|
|
204
99
|
* bucket: streamBucket.id,
|
|
205
|
-
* versioningConfiguration: {
|
|
100
|
+
* versioningConfiguration: [{
|
|
206
101
|
* status: "Enabled",
|
|
207
|
-
* },
|
|
102
|
+
* }],
|
|
208
103
|
* });
|
|
209
|
-
* const streamBucketEncryption = new aws.
|
|
104
|
+
* const streamBucketEncryption = new aws.index.S3BucketServerSideEncryptionConfiguration("stream_bucket_encryption", {
|
|
210
105
|
* bucket: streamBucket.id,
|
|
211
|
-
*
|
|
212
|
-
* applyServerSideEncryptionByDefault: {
|
|
106
|
+
* rule: [{
|
|
107
|
+
* applyServerSideEncryptionByDefault: [{
|
|
213
108
|
* sseAlgorithm: "AES256",
|
|
214
|
-
* },
|
|
109
|
+
* }],
|
|
215
110
|
* }],
|
|
216
111
|
* });
|
|
217
112
|
* // PrivateLink for S3
|
|
@@ -311,111 +206,6 @@ exports.getStreamPrivatelinkEndpoints = getStreamPrivatelinkEndpoints;
|
|
|
311
206
|
* export const interfaceEndpointIds = pluralDatasource.then(pluralDatasource => pluralDatasource.results.map(__item => __item.interfaceEndpointId));
|
|
312
207
|
* ```
|
|
313
208
|
*
|
|
314
|
-
* ### AWS MSK Privatelink
|
|
315
|
-
* ```typescript
|
|
316
|
-
* import * as pulumi from "@pulumi/pulumi";
|
|
317
|
-
* import * as aws from "@pulumi/aws";
|
|
318
|
-
* import * as mongodbatlas from "@pulumi/mongodbatlas";
|
|
319
|
-
*
|
|
320
|
-
* const vpc = new aws.ec2.Vpc("vpc", {cidrBlock: "192.168.0.0/22"});
|
|
321
|
-
* const azs = aws.getAvailabilityZones({
|
|
322
|
-
* state: "available",
|
|
323
|
-
* });
|
|
324
|
-
* const subnetAz1 = new aws.ec2.Subnet("subnet_az1", {
|
|
325
|
-
* availabilityZone: azs.then(azs => azs.names?.[0]),
|
|
326
|
-
* cidrBlock: "192.168.0.0/24",
|
|
327
|
-
* vpcId: vpc.id,
|
|
328
|
-
* });
|
|
329
|
-
* const subnetAz2 = new aws.ec2.Subnet("subnet_az2", {
|
|
330
|
-
* availabilityZone: azs.then(azs => azs.names?.[1]),
|
|
331
|
-
* cidrBlock: "192.168.1.0/24",
|
|
332
|
-
* vpcId: vpc.id,
|
|
333
|
-
* });
|
|
334
|
-
* const sg = new aws.ec2.SecurityGroup("sg", {vpcId: vpc.id});
|
|
335
|
-
* const exampleConfiguration = new aws.msk.Configuration("example", {
|
|
336
|
-
* name: `${mskClusterName}-msk-configuration`,
|
|
337
|
-
* serverProperties: `auto.create.topics.enable=false
|
|
338
|
-
* default.replication.factor=3
|
|
339
|
-
* min.insync.replicas=2
|
|
340
|
-
* num.io.threads=8
|
|
341
|
-
* num.network.threads=5
|
|
342
|
-
* num.partitions=1
|
|
343
|
-
* num.replica.fetchers=2
|
|
344
|
-
* replica.lag.time.max.ms=30000
|
|
345
|
-
* socket.receive.buffer.bytes=102400
|
|
346
|
-
* socket.request.max.bytes=104857600
|
|
347
|
-
* socket.send.buffer.bytes=102400
|
|
348
|
-
* unclean.leader.election.enable=true
|
|
349
|
-
* allow.everyone.if.no.acl.found=false
|
|
350
|
-
* `,
|
|
351
|
-
* });
|
|
352
|
-
* const example = new aws.msk.Cluster("example", {
|
|
353
|
-
* clusterName: mskClusterName,
|
|
354
|
-
* kafkaVersion: "3.6.0",
|
|
355
|
-
* numberOfBrokerNodes: 2,
|
|
356
|
-
* brokerNodeGroupInfo: {
|
|
357
|
-
* instanceType: "kafka.m5.large",
|
|
358
|
-
* clientSubnets: [
|
|
359
|
-
* subnetAz1.id,
|
|
360
|
-
* subnetAz2.id,
|
|
361
|
-
* ],
|
|
362
|
-
* securityGroups: [sg.id],
|
|
363
|
-
* connectivityInfo: {
|
|
364
|
-
* vpcConnectivity: {
|
|
365
|
-
* clientAuthentication: {
|
|
366
|
-
* sasl: {
|
|
367
|
-
* scram: true,
|
|
368
|
-
* },
|
|
369
|
-
* },
|
|
370
|
-
* },
|
|
371
|
-
* },
|
|
372
|
-
* },
|
|
373
|
-
* clientAuthentication: {
|
|
374
|
-
* sasl: {
|
|
375
|
-
* scram: true,
|
|
376
|
-
* },
|
|
377
|
-
* },
|
|
378
|
-
* configurationInfo: {
|
|
379
|
-
* arn: exampleConfiguration.arn,
|
|
380
|
-
* revision: exampleConfiguration.latestRevision,
|
|
381
|
-
* },
|
|
382
|
-
* });
|
|
383
|
-
* const exampleClusterPolicy = new aws.msk.ClusterPolicy("example", {
|
|
384
|
-
* clusterArn: example.arn,
|
|
385
|
-
* policy: pulumi.jsonStringify({
|
|
386
|
-
* Version: "2012-10-17",
|
|
387
|
-
* Statement: [{
|
|
388
|
-
* Effect: "Allow",
|
|
389
|
-
* Principal: {
|
|
390
|
-
* AWS: `arn:aws:iam::${awsAccountId}:root`,
|
|
391
|
-
* },
|
|
392
|
-
* Action: [
|
|
393
|
-
* "kafka:CreateVpcConnection",
|
|
394
|
-
* "kafka:GetBootstrapBrokers",
|
|
395
|
-
* "kafka:DescribeCluster",
|
|
396
|
-
* "kafka:DescribeClusterV2",
|
|
397
|
-
* ],
|
|
398
|
-
* Resource: example.arn,
|
|
399
|
-
* }],
|
|
400
|
-
* }),
|
|
401
|
-
* });
|
|
402
|
-
* const exampleMskSingleScramSecretAssociation = new aws.index.MskSingleScramSecretAssociation("example", {
|
|
403
|
-
* clusterArn: example.arn,
|
|
404
|
-
* secretArn: awsSecretArn,
|
|
405
|
-
* });
|
|
406
|
-
* const test = new mongodbatlas.StreamPrivatelinkEndpoint("test", {
|
|
407
|
-
* projectId: projectId,
|
|
408
|
-
* providerName: "AWS",
|
|
409
|
-
* vendor: "MSK",
|
|
410
|
-
* arn: example.arn,
|
|
411
|
-
* });
|
|
412
|
-
* const singularDatasource = test.id.apply(id => mongodbatlas.getStreamPrivatelinkEndpointOutput({
|
|
413
|
-
* projectId: projectId,
|
|
414
|
-
* id: id,
|
|
415
|
-
* }));
|
|
416
|
-
* export const privatelinkEndpointId = singularDatasource.apply(singularDatasource => singularDatasource.id);
|
|
417
|
-
* ```
|
|
418
|
-
*
|
|
419
209
|
* ### AWS S3 Privatelink
|
|
420
210
|
* ```typescript
|
|
421
211
|
* import * as pulumi from "@pulumi/pulumi";
|
|
@@ -423,22 +213,22 @@ exports.getStreamPrivatelinkEndpoints = getStreamPrivatelinkEndpoints;
|
|
|
423
213
|
* import * as mongodbatlas from "@pulumi/mongodbatlas";
|
|
424
214
|
*
|
|
425
215
|
* // S3 bucket for stream data
|
|
426
|
-
* const streamBucket = new aws.
|
|
216
|
+
* const streamBucket = new aws.index.S3Bucket("stream_bucket", {
|
|
427
217
|
* bucket: s3BucketName,
|
|
428
218
|
* forceDestroy: true,
|
|
429
219
|
* });
|
|
430
|
-
* const streamBucketVersioning = new aws.
|
|
220
|
+
* const streamBucketVersioning = new aws.index.S3BucketVersioning("stream_bucket_versioning", {
|
|
431
221
|
* bucket: streamBucket.id,
|
|
432
|
-
* versioningConfiguration: {
|
|
222
|
+
* versioningConfiguration: [{
|
|
433
223
|
* status: "Enabled",
|
|
434
|
-
* },
|
|
224
|
+
* }],
|
|
435
225
|
* });
|
|
436
|
-
* const streamBucketEncryption = new aws.
|
|
226
|
+
* const streamBucketEncryption = new aws.index.S3BucketServerSideEncryptionConfiguration("stream_bucket_encryption", {
|
|
437
227
|
* bucket: streamBucket.id,
|
|
438
|
-
*
|
|
439
|
-
* applyServerSideEncryptionByDefault: {
|
|
228
|
+
* rule: [{
|
|
229
|
+
* applyServerSideEncryptionByDefault: [{
|
|
440
230
|
* sseAlgorithm: "AES256",
|
|
441
|
-
* },
|
|
231
|
+
* }],
|
|
442
232
|
* }],
|
|
443
233
|
* });
|
|
444
234
|
* // PrivateLink for S3
|
|
@@ -1 +1 @@
|
|
|
1
|
-
{"version":3,"file":"getStreamPrivatelinkEndpoints.js","sourceRoot":"","sources":["../getStreamPrivatelinkEndpoints.ts"],"names":[],"mappings":";AAAA,sEAAsE;AACtE,iFAAiF;;;AAEjF,yCAAyC;AAGzC,yCAAyC;AAEzC
|
|
1
|
+
{"version":3,"file":"getStreamPrivatelinkEndpoints.js","sourceRoot":"","sources":["../getStreamPrivatelinkEndpoints.ts"],"names":[],"mappings":";AAAA,sEAAsE;AACtE,iFAAiF;;;AAEjF,yCAAyC;AAGzC,yCAAyC;AAEzC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkHG;AACH,SAAgB,6BAA6B,CAAC,IAAuC,EAAE,IAA2B;IAC9G,IAAI,GAAG,MAAM,CAAC,YAAY,CAAC,SAAS,CAAC,oBAAoB,EAAE,EAAE,IAAI,IAAI,EAAE,CAAC,CAAC;IACzE,OAAO,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,gFAAgF,EAAE;QAC3G,WAAW,EAAE,IAAI,CAAC,SAAS;KAC9B,EAAE,IAAI,CAAC,CAAC;AACb,CAAC;AALD,sEAKC;AAoBD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkHG;AACH,SAAgB,mCAAmC,CAAC,IAA6C,EAAE,IAAiC;IAChI,IAAI,GAAG,MAAM,CAAC,YAAY,CAAC,SAAS,CAAC,oBAAoB,EAAE,EAAE,IAAI,IAAI,EAAE,CAAC,CAAC;IACzE,OAAO,MAAM,CAAC,OAAO,CAAC,YAAY,CAAC,gFAAgF,EAAE;QACjH,WAAW,EAAE,IAAI,CAAC,SAAS;KAC9B,EAAE,IAAI,CAAC,CAAC;AACb,CAAC;AALD,kFAKC"}
|
package/networkPeering.d.ts
CHANGED
|
@@ -50,66 +50,12 @@ import * as pulumi from "@pulumi/pulumi";
|
|
|
50
50
|
* });
|
|
51
51
|
* // the following assumes an AWS provider is configured
|
|
52
52
|
* // Accept the peering connection request
|
|
53
|
-
* const peer = new aws.
|
|
53
|
+
* const peer = new aws.index.VpcPeeringConnectionAccepter("peer", {
|
|
54
54
|
* vpcPeeringConnectionId: testNetworkPeering.connectionId,
|
|
55
55
|
* autoAccept: true,
|
|
56
56
|
* });
|
|
57
57
|
* ```
|
|
58
58
|
*
|
|
59
|
-
* ### Example with GCP
|
|
60
|
-
*
|
|
61
|
-
* ```typescript
|
|
62
|
-
* import * as pulumi from "@pulumi/pulumi";
|
|
63
|
-
* import * as gcp from "@pulumi/gcp";
|
|
64
|
-
* import * as mongodbatlas from "@pulumi/mongodbatlas";
|
|
65
|
-
*
|
|
66
|
-
* // Container example provided but not always required,
|
|
67
|
-
* // see network_container documentation for details.
|
|
68
|
-
* const test = new mongodbatlas.NetworkContainer("test", {
|
|
69
|
-
* projectId: projectId,
|
|
70
|
-
* atlasCidrBlock: "10.8.0.0/21",
|
|
71
|
-
* providerName: "GCP",
|
|
72
|
-
* });
|
|
73
|
-
* // Create the peering connection request
|
|
74
|
-
* const testNetworkPeering = new mongodbatlas.NetworkPeering("test", {
|
|
75
|
-
* projectId: projectId,
|
|
76
|
-
* containerId: test.containerId,
|
|
77
|
-
* providerName: "GCP",
|
|
78
|
-
* gcpProjectId: GCP_PROJECT_ID,
|
|
79
|
-
* networkName: "default",
|
|
80
|
-
* });
|
|
81
|
-
* // the following assumes a GCP provider is configured
|
|
82
|
-
* const _default = gcp.compute.getNetwork({
|
|
83
|
-
* name: "default",
|
|
84
|
-
* });
|
|
85
|
-
* // Create the GCP peer
|
|
86
|
-
* const peering = new gcp.compute.NetworkPeering("peering", {
|
|
87
|
-
* name: "peering-gcp-terraform-test",
|
|
88
|
-
* network: _default.then(_default => _default.selfLink),
|
|
89
|
-
* peerNetwork: pulumi.interpolate`https://www.googleapis.com/compute/v1/projects/${testNetworkPeering.atlasGcpProjectId}/global/networks/${testNetworkPeering.atlasVpcName}`,
|
|
90
|
-
* });
|
|
91
|
-
* // Create the cluster once the peering connection is completed
|
|
92
|
-
* const testAdvancedCluster = new mongodbatlas.AdvancedCluster("test", {
|
|
93
|
-
* projectId: projectId,
|
|
94
|
-
* name: "terraform-manually-test",
|
|
95
|
-
* clusterType: "REPLICASET",
|
|
96
|
-
* backupEnabled: true,
|
|
97
|
-
* replicationSpecs: [{
|
|
98
|
-
* regionConfigs: [{
|
|
99
|
-
* priority: 7,
|
|
100
|
-
* providerName: "GCP",
|
|
101
|
-
* regionName: "US_EAST_4",
|
|
102
|
-
* electableSpecs: {
|
|
103
|
-
* instanceSize: "M10",
|
|
104
|
-
* nodeCount: 3,
|
|
105
|
-
* },
|
|
106
|
-
* }],
|
|
107
|
-
* }],
|
|
108
|
-
* }, {
|
|
109
|
-
* dependsOn: [peering],
|
|
110
|
-
* });
|
|
111
|
-
* ```
|
|
112
|
-
*
|
|
113
59
|
* ### Example with Azure
|
|
114
60
|
*
|
|
115
61
|
* ```typescript
|