@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
|
@@ -78,111 +78,6 @@ 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
|
-
*
|
|
186
81
|
* ### AWS S3 Privatelink
|
|
187
82
|
* ```typescript
|
|
188
83
|
* import * as pulumi from "@pulumi/pulumi";
|
|
@@ -190,22 +85,22 @@ import * as pulumi from "@pulumi/pulumi";
|
|
|
190
85
|
* import * as mongodbatlas from "@pulumi/mongodbatlas";
|
|
191
86
|
*
|
|
192
87
|
* // S3 bucket for stream data
|
|
193
|
-
* const streamBucket = new aws.
|
|
88
|
+
* const streamBucket = new aws.index.S3Bucket("stream_bucket", {
|
|
194
89
|
* bucket: s3BucketName,
|
|
195
90
|
* forceDestroy: true,
|
|
196
91
|
* });
|
|
197
|
-
* const streamBucketVersioning = new aws.
|
|
92
|
+
* const streamBucketVersioning = new aws.index.S3BucketVersioning("stream_bucket_versioning", {
|
|
198
93
|
* bucket: streamBucket.id,
|
|
199
|
-
* versioningConfiguration: {
|
|
94
|
+
* versioningConfiguration: [{
|
|
200
95
|
* status: "Enabled",
|
|
201
|
-
* },
|
|
96
|
+
* }],
|
|
202
97
|
* });
|
|
203
|
-
* const streamBucketEncryption = new aws.
|
|
98
|
+
* const streamBucketEncryption = new aws.index.S3BucketServerSideEncryptionConfiguration("stream_bucket_encryption", {
|
|
204
99
|
* bucket: streamBucket.id,
|
|
205
|
-
*
|
|
206
|
-
* applyServerSideEncryptionByDefault: {
|
|
100
|
+
* rule: [{
|
|
101
|
+
* applyServerSideEncryptionByDefault: [{
|
|
207
102
|
* sseAlgorithm: "AES256",
|
|
208
|
-
* },
|
|
103
|
+
* }],
|
|
209
104
|
* }],
|
|
210
105
|
* });
|
|
211
106
|
* // PrivateLink for S3
|
|
@@ -325,111 +220,6 @@ export interface GetStreamPrivatelinkEndpointResult {
|
|
|
325
220
|
* export const interfaceEndpointIds = pluralDatasource.then(pluralDatasource => pluralDatasource.results.map(__item => __item.interfaceEndpointId));
|
|
326
221
|
* ```
|
|
327
222
|
*
|
|
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
|
-
*
|
|
433
223
|
* ### AWS S3 Privatelink
|
|
434
224
|
* ```typescript
|
|
435
225
|
* import * as pulumi from "@pulumi/pulumi";
|
|
@@ -437,22 +227,22 @@ export interface GetStreamPrivatelinkEndpointResult {
|
|
|
437
227
|
* import * as mongodbatlas from "@pulumi/mongodbatlas";
|
|
438
228
|
*
|
|
439
229
|
* // S3 bucket for stream data
|
|
440
|
-
* const streamBucket = new aws.
|
|
230
|
+
* const streamBucket = new aws.index.S3Bucket("stream_bucket", {
|
|
441
231
|
* bucket: s3BucketName,
|
|
442
232
|
* forceDestroy: true,
|
|
443
233
|
* });
|
|
444
|
-
* const streamBucketVersioning = new aws.
|
|
234
|
+
* const streamBucketVersioning = new aws.index.S3BucketVersioning("stream_bucket_versioning", {
|
|
445
235
|
* bucket: streamBucket.id,
|
|
446
|
-
* versioningConfiguration: {
|
|
236
|
+
* versioningConfiguration: [{
|
|
447
237
|
* status: "Enabled",
|
|
448
|
-
* },
|
|
238
|
+
* }],
|
|
449
239
|
* });
|
|
450
|
-
* const streamBucketEncryption = new aws.
|
|
240
|
+
* const streamBucketEncryption = new aws.index.S3BucketServerSideEncryptionConfiguration("stream_bucket_encryption", {
|
|
451
241
|
* bucket: streamBucket.id,
|
|
452
|
-
*
|
|
453
|
-
* applyServerSideEncryptionByDefault: {
|
|
242
|
+
* rule: [{
|
|
243
|
+
* applyServerSideEncryptionByDefault: [{
|
|
454
244
|
* sseAlgorithm: "AES256",
|
|
455
|
-
* },
|
|
245
|
+
* }],
|
|
456
246
|
* }],
|
|
457
247
|
* });
|
|
458
248
|
* // 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
|
|
@@ -312,111 +207,6 @@ exports.getStreamPrivatelinkEndpoint = getStreamPrivatelinkEndpoint;
|
|
|
312
207
|
* export const interfaceEndpointIds = pluralDatasource.then(pluralDatasource => pluralDatasource.results.map(__item => __item.interfaceEndpointId));
|
|
313
208
|
* ```
|
|
314
209
|
*
|
|
315
|
-
* ### AWS MSK Privatelink
|
|
316
|
-
* ```typescript
|
|
317
|
-
* import * as pulumi from "@pulumi/pulumi";
|
|
318
|
-
* import * as aws from "@pulumi/aws";
|
|
319
|
-
* import * as mongodbatlas from "@pulumi/mongodbatlas";
|
|
320
|
-
*
|
|
321
|
-
* const vpc = new aws.ec2.Vpc("vpc", {cidrBlock: "192.168.0.0/22"});
|
|
322
|
-
* const azs = aws.getAvailabilityZones({
|
|
323
|
-
* state: "available",
|
|
324
|
-
* });
|
|
325
|
-
* const subnetAz1 = new aws.ec2.Subnet("subnet_az1", {
|
|
326
|
-
* availabilityZone: azs.then(azs => azs.names?.[0]),
|
|
327
|
-
* cidrBlock: "192.168.0.0/24",
|
|
328
|
-
* vpcId: vpc.id,
|
|
329
|
-
* });
|
|
330
|
-
* const subnetAz2 = new aws.ec2.Subnet("subnet_az2", {
|
|
331
|
-
* availabilityZone: azs.then(azs => azs.names?.[1]),
|
|
332
|
-
* cidrBlock: "192.168.1.0/24",
|
|
333
|
-
* vpcId: vpc.id,
|
|
334
|
-
* });
|
|
335
|
-
* const sg = new aws.ec2.SecurityGroup("sg", {vpcId: vpc.id});
|
|
336
|
-
* const exampleConfiguration = new aws.msk.Configuration("example", {
|
|
337
|
-
* name: `${mskClusterName}-msk-configuration`,
|
|
338
|
-
* serverProperties: `auto.create.topics.enable=false
|
|
339
|
-
* default.replication.factor=3
|
|
340
|
-
* min.insync.replicas=2
|
|
341
|
-
* num.io.threads=8
|
|
342
|
-
* num.network.threads=5
|
|
343
|
-
* num.partitions=1
|
|
344
|
-
* num.replica.fetchers=2
|
|
345
|
-
* replica.lag.time.max.ms=30000
|
|
346
|
-
* socket.receive.buffer.bytes=102400
|
|
347
|
-
* socket.request.max.bytes=104857600
|
|
348
|
-
* socket.send.buffer.bytes=102400
|
|
349
|
-
* unclean.leader.election.enable=true
|
|
350
|
-
* allow.everyone.if.no.acl.found=false
|
|
351
|
-
* `,
|
|
352
|
-
* });
|
|
353
|
-
* const example = new aws.msk.Cluster("example", {
|
|
354
|
-
* clusterName: mskClusterName,
|
|
355
|
-
* kafkaVersion: "3.6.0",
|
|
356
|
-
* numberOfBrokerNodes: 2,
|
|
357
|
-
* brokerNodeGroupInfo: {
|
|
358
|
-
* instanceType: "kafka.m5.large",
|
|
359
|
-
* clientSubnets: [
|
|
360
|
-
* subnetAz1.id,
|
|
361
|
-
* subnetAz2.id,
|
|
362
|
-
* ],
|
|
363
|
-
* securityGroups: [sg.id],
|
|
364
|
-
* connectivityInfo: {
|
|
365
|
-
* vpcConnectivity: {
|
|
366
|
-
* clientAuthentication: {
|
|
367
|
-
* sasl: {
|
|
368
|
-
* scram: true,
|
|
369
|
-
* },
|
|
370
|
-
* },
|
|
371
|
-
* },
|
|
372
|
-
* },
|
|
373
|
-
* },
|
|
374
|
-
* clientAuthentication: {
|
|
375
|
-
* sasl: {
|
|
376
|
-
* scram: true,
|
|
377
|
-
* },
|
|
378
|
-
* },
|
|
379
|
-
* configurationInfo: {
|
|
380
|
-
* arn: exampleConfiguration.arn,
|
|
381
|
-
* revision: exampleConfiguration.latestRevision,
|
|
382
|
-
* },
|
|
383
|
-
* });
|
|
384
|
-
* const exampleClusterPolicy = new aws.msk.ClusterPolicy("example", {
|
|
385
|
-
* clusterArn: example.arn,
|
|
386
|
-
* policy: pulumi.jsonStringify({
|
|
387
|
-
* Version: "2012-10-17",
|
|
388
|
-
* Statement: [{
|
|
389
|
-
* Effect: "Allow",
|
|
390
|
-
* Principal: {
|
|
391
|
-
* AWS: `arn:aws:iam::${awsAccountId}:root`,
|
|
392
|
-
* },
|
|
393
|
-
* Action: [
|
|
394
|
-
* "kafka:CreateVpcConnection",
|
|
395
|
-
* "kafka:GetBootstrapBrokers",
|
|
396
|
-
* "kafka:DescribeCluster",
|
|
397
|
-
* "kafka:DescribeClusterV2",
|
|
398
|
-
* ],
|
|
399
|
-
* Resource: example.arn,
|
|
400
|
-
* }],
|
|
401
|
-
* }),
|
|
402
|
-
* });
|
|
403
|
-
* const exampleMskSingleScramSecretAssociation = new aws.index.MskSingleScramSecretAssociation("example", {
|
|
404
|
-
* clusterArn: example.arn,
|
|
405
|
-
* secretArn: awsSecretArn,
|
|
406
|
-
* });
|
|
407
|
-
* const test = new mongodbatlas.StreamPrivatelinkEndpoint("test", {
|
|
408
|
-
* projectId: projectId,
|
|
409
|
-
* providerName: "AWS",
|
|
410
|
-
* vendor: "MSK",
|
|
411
|
-
* arn: example.arn,
|
|
412
|
-
* });
|
|
413
|
-
* const singularDatasource = test.id.apply(id => mongodbatlas.getStreamPrivatelinkEndpointOutput({
|
|
414
|
-
* projectId: projectId,
|
|
415
|
-
* id: id,
|
|
416
|
-
* }));
|
|
417
|
-
* export const privatelinkEndpointId = singularDatasource.apply(singularDatasource => singularDatasource.id);
|
|
418
|
-
* ```
|
|
419
|
-
*
|
|
420
210
|
* ### AWS S3 Privatelink
|
|
421
211
|
* ```typescript
|
|
422
212
|
* import * as pulumi from "@pulumi/pulumi";
|
|
@@ -424,22 +214,22 @@ exports.getStreamPrivatelinkEndpoint = getStreamPrivatelinkEndpoint;
|
|
|
424
214
|
* import * as mongodbatlas from "@pulumi/mongodbatlas";
|
|
425
215
|
*
|
|
426
216
|
* // S3 bucket for stream data
|
|
427
|
-
* const streamBucket = new aws.
|
|
217
|
+
* const streamBucket = new aws.index.S3Bucket("stream_bucket", {
|
|
428
218
|
* bucket: s3BucketName,
|
|
429
219
|
* forceDestroy: true,
|
|
430
220
|
* });
|
|
431
|
-
* const streamBucketVersioning = new aws.
|
|
221
|
+
* const streamBucketVersioning = new aws.index.S3BucketVersioning("stream_bucket_versioning", {
|
|
432
222
|
* bucket: streamBucket.id,
|
|
433
|
-
* versioningConfiguration: {
|
|
223
|
+
* versioningConfiguration: [{
|
|
434
224
|
* status: "Enabled",
|
|
435
|
-
* },
|
|
225
|
+
* }],
|
|
436
226
|
* });
|
|
437
|
-
* const streamBucketEncryption = new aws.
|
|
227
|
+
* const streamBucketEncryption = new aws.index.S3BucketServerSideEncryptionConfiguration("stream_bucket_encryption", {
|
|
438
228
|
* bucket: streamBucket.id,
|
|
439
|
-
*
|
|
440
|
-
* applyServerSideEncryptionByDefault: {
|
|
229
|
+
* rule: [{
|
|
230
|
+
* applyServerSideEncryptionByDefault: [{
|
|
441
231
|
* sseAlgorithm: "AES256",
|
|
442
|
-
* },
|
|
232
|
+
* }],
|
|
443
233
|
* }],
|
|
444
234
|
* });
|
|
445
235
|
* // PrivateLink for S3
|
|
@@ -1 +1 @@
|
|
|
1
|
-
{"version":3,"file":"getStreamPrivatelinkEndpoint.js","sourceRoot":"","sources":["../getStreamPrivatelinkEndpoint.ts"],"names":[],"mappings":";AAAA,sEAAsE;AACtE,iFAAiF;;;AAEjF,yCAAyC;AACzC,yCAAyC;AAEzC
|
|
1
|
+
{"version":3,"file":"getStreamPrivatelinkEndpoint.js","sourceRoot":"","sources":["../getStreamPrivatelinkEndpoint.ts"],"names":[],"mappings":";AAAA,sEAAsE;AACtE,iFAAiF;;;AAEjF,yCAAyC;AACzC,yCAAyC;AAEzC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkHG;AACH,SAAgB,4BAA4B,CAAC,IAAsC,EAAE,IAA2B;IAC5G,IAAI,GAAG,MAAM,CAAC,YAAY,CAAC,SAAS,CAAC,oBAAoB,EAAE,EAAE,IAAI,IAAI,EAAE,CAAC,CAAC;IACzE,OAAO,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,8EAA8E,EAAE;QACzG,IAAI,EAAE,IAAI,CAAC,EAAE;QACb,WAAW,EAAE,IAAI,CAAC,SAAS;KAC9B,EAAE,IAAI,CAAC,CAAC;AACb,CAAC;AAND,oEAMC;AA6BD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkHG;AACH,SAAgB,kCAAkC,CAAC,IAA4C,EAAE,IAAiC;IAC9H,IAAI,GAAG,MAAM,CAAC,YAAY,CAAC,SAAS,CAAC,oBAAoB,EAAE,EAAE,IAAI,IAAI,EAAE,CAAC,CAAC;IACzE,OAAO,MAAM,CAAC,OAAO,CAAC,YAAY,CAAC,8EAA8E,EAAE;QAC/G,IAAI,EAAE,IAAI,CAAC,EAAE;QACb,WAAW,EAAE,IAAI,CAAC,SAAS;KAC9B,EAAE,IAAI,CAAC,CAAC;AACb,CAAC;AAND,gFAMC"}
|