pulumi-mongodbatlas 3.38.0__py3-none-any.whl → 3.38.0a1764802483__py3-none-any.whl
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.
- pulumi_mongodbatlas/get_stream_privatelink_endpoint.py +210 -20
- pulumi_mongodbatlas/get_stream_privatelink_endpoints.py +210 -20
- pulumi_mongodbatlas/network_peering.py +104 -2
- pulumi_mongodbatlas/privatelink_endpoint_service_data_federation_online_archive.py +16 -16
- pulumi_mongodbatlas/privatelink_endpoint_service_serverless.py +38 -38
- pulumi_mongodbatlas/pulumi-plugin.json +1 -1
- pulumi_mongodbatlas/stream_privatelink_endpoint.py +210 -20
- {pulumi_mongodbatlas-3.38.0.dist-info → pulumi_mongodbatlas-3.38.0a1764802483.dist-info}/METADATA +1 -1
- {pulumi_mongodbatlas-3.38.0.dist-info → pulumi_mongodbatlas-3.38.0a1764802483.dist-info}/RECORD +11 -11
- {pulumi_mongodbatlas-3.38.0.dist-info → pulumi_mongodbatlas-3.38.0a1764802483.dist-info}/WHEEL +0 -0
- {pulumi_mongodbatlas-3.38.0.dist-info → pulumi_mongodbatlas-3.38.0a1764802483.dist-info}/top_level.txt +0 -0
|
@@ -235,6 +235,101 @@ def get_stream_privatelink_endpoint(id: Optional[_builtins.str] = None,
|
|
|
235
235
|
pulumi.export("interfaceEndpointIds", [__item.interface_endpoint_id for __item in plural_datasource.results])
|
|
236
236
|
```
|
|
237
237
|
|
|
238
|
+
### AWS MSK Privatelink
|
|
239
|
+
```python
|
|
240
|
+
import pulumi
|
|
241
|
+
import json
|
|
242
|
+
import pulumi_aws as aws
|
|
243
|
+
import pulumi_mongodbatlas as mongodbatlas
|
|
244
|
+
|
|
245
|
+
vpc = aws.ec2.Vpc("vpc", cidr_block="192.168.0.0/22")
|
|
246
|
+
azs = aws.get_availability_zones(state="available")
|
|
247
|
+
subnet_az1 = aws.ec2.Subnet("subnet_az1",
|
|
248
|
+
availability_zone=azs.names[0],
|
|
249
|
+
cidr_block="192.168.0.0/24",
|
|
250
|
+
vpc_id=vpc.id)
|
|
251
|
+
subnet_az2 = aws.ec2.Subnet("subnet_az2",
|
|
252
|
+
availability_zone=azs.names[1],
|
|
253
|
+
cidr_block="192.168.1.0/24",
|
|
254
|
+
vpc_id=vpc.id)
|
|
255
|
+
sg = aws.ec2.SecurityGroup("sg", vpc_id=vpc.id)
|
|
256
|
+
example_configuration = aws.msk.Configuration("example",
|
|
257
|
+
name=f"{msk_cluster_name}-msk-configuration",
|
|
258
|
+
server_properties=\"\"\"auto.create.topics.enable=false
|
|
259
|
+
default.replication.factor=3
|
|
260
|
+
min.insync.replicas=2
|
|
261
|
+
num.io.threads=8
|
|
262
|
+
num.network.threads=5
|
|
263
|
+
num.partitions=1
|
|
264
|
+
num.replica.fetchers=2
|
|
265
|
+
replica.lag.time.max.ms=30000
|
|
266
|
+
socket.receive.buffer.bytes=102400
|
|
267
|
+
socket.request.max.bytes=104857600
|
|
268
|
+
socket.send.buffer.bytes=102400
|
|
269
|
+
unclean.leader.election.enable=true
|
|
270
|
+
allow.everyone.if.no.acl.found=false
|
|
271
|
+
\"\"\")
|
|
272
|
+
example = aws.msk.Cluster("example",
|
|
273
|
+
cluster_name=msk_cluster_name,
|
|
274
|
+
kafka_version="3.6.0",
|
|
275
|
+
number_of_broker_nodes=2,
|
|
276
|
+
broker_node_group_info={
|
|
277
|
+
"instance_type": "kafka.m5.large",
|
|
278
|
+
"client_subnets": [
|
|
279
|
+
subnet_az1.id,
|
|
280
|
+
subnet_az2.id,
|
|
281
|
+
],
|
|
282
|
+
"security_groups": [sg.id],
|
|
283
|
+
"connectivity_info": {
|
|
284
|
+
"vpc_connectivity": {
|
|
285
|
+
"client_authentication": {
|
|
286
|
+
"sasl": {
|
|
287
|
+
"scram": True,
|
|
288
|
+
},
|
|
289
|
+
},
|
|
290
|
+
},
|
|
291
|
+
},
|
|
292
|
+
},
|
|
293
|
+
client_authentication={
|
|
294
|
+
"sasl": {
|
|
295
|
+
"scram": True,
|
|
296
|
+
},
|
|
297
|
+
},
|
|
298
|
+
configuration_info={
|
|
299
|
+
"arn": example_configuration.arn,
|
|
300
|
+
"revision": example_configuration.latest_revision,
|
|
301
|
+
})
|
|
302
|
+
example_cluster_policy = aws.msk.ClusterPolicy("example",
|
|
303
|
+
cluster_arn=example.arn,
|
|
304
|
+
policy=pulumi.Output.json_dumps({
|
|
305
|
+
"Version": "2012-10-17",
|
|
306
|
+
"Statement": [{
|
|
307
|
+
"Effect": "Allow",
|
|
308
|
+
"Principal": {
|
|
309
|
+
"AWS": f"arn:aws:iam::{aws_account_id}:root",
|
|
310
|
+
},
|
|
311
|
+
"Action": [
|
|
312
|
+
"kafka:CreateVpcConnection",
|
|
313
|
+
"kafka:GetBootstrapBrokers",
|
|
314
|
+
"kafka:DescribeCluster",
|
|
315
|
+
"kafka:DescribeClusterV2",
|
|
316
|
+
],
|
|
317
|
+
"Resource": example.arn,
|
|
318
|
+
}],
|
|
319
|
+
}))
|
|
320
|
+
example_msk_single_scram_secret_association = aws.index.MskSingleScramSecretAssociation("example",
|
|
321
|
+
cluster_arn=example.arn,
|
|
322
|
+
secret_arn=aws_secret_arn)
|
|
323
|
+
test = mongodbatlas.StreamPrivatelinkEndpoint("test",
|
|
324
|
+
project_id=project_id,
|
|
325
|
+
provider_name="AWS",
|
|
326
|
+
vendor="MSK",
|
|
327
|
+
arn=example.arn)
|
|
328
|
+
singular_datasource = test.id.apply(lambda id: mongodbatlas.get_stream_privatelink_endpoint_output(project_id=project_id,
|
|
329
|
+
id=id))
|
|
330
|
+
pulumi.export("privatelinkEndpointId", singular_datasource.id)
|
|
331
|
+
```
|
|
332
|
+
|
|
238
333
|
### AWS S3 Privatelink
|
|
239
334
|
```python
|
|
240
335
|
import pulumi
|
|
@@ -242,20 +337,20 @@ def get_stream_privatelink_endpoint(id: Optional[_builtins.str] = None,
|
|
|
242
337
|
import pulumi_mongodbatlas as mongodbatlas
|
|
243
338
|
|
|
244
339
|
# S3 bucket for stream data
|
|
245
|
-
stream_bucket = aws.
|
|
340
|
+
stream_bucket = aws.s3.BucketV2("stream_bucket",
|
|
246
341
|
bucket=s3_bucket_name,
|
|
247
342
|
force_destroy=True)
|
|
248
|
-
stream_bucket_versioning = aws.
|
|
343
|
+
stream_bucket_versioning = aws.s3.BucketVersioningV2("stream_bucket_versioning",
|
|
249
344
|
bucket=stream_bucket.id,
|
|
250
|
-
versioning_configuration=
|
|
251
|
-
status: Enabled,
|
|
252
|
-
}
|
|
253
|
-
stream_bucket_encryption = aws.
|
|
345
|
+
versioning_configuration={
|
|
346
|
+
"status": "Enabled",
|
|
347
|
+
})
|
|
348
|
+
stream_bucket_encryption = aws.s3.BucketServerSideEncryptionConfigurationV2("stream_bucket_encryption",
|
|
254
349
|
bucket=stream_bucket.id,
|
|
255
|
-
|
|
256
|
-
|
|
257
|
-
|
|
258
|
-
}
|
|
350
|
+
rules=[{
|
|
351
|
+
"apply_server_side_encryption_by_default": {
|
|
352
|
+
"sse_algorithm": "AES256",
|
|
353
|
+
},
|
|
259
354
|
}])
|
|
260
355
|
# PrivateLink for S3
|
|
261
356
|
this = mongodbatlas.StreamPrivatelinkEndpoint("this",
|
|
@@ -360,6 +455,101 @@ def get_stream_privatelink_endpoint_output(id: Optional[pulumi.Input[_builtins.s
|
|
|
360
455
|
pulumi.export("interfaceEndpointIds", [__item.interface_endpoint_id for __item in plural_datasource.results])
|
|
361
456
|
```
|
|
362
457
|
|
|
458
|
+
### AWS MSK Privatelink
|
|
459
|
+
```python
|
|
460
|
+
import pulumi
|
|
461
|
+
import json
|
|
462
|
+
import pulumi_aws as aws
|
|
463
|
+
import pulumi_mongodbatlas as mongodbatlas
|
|
464
|
+
|
|
465
|
+
vpc = aws.ec2.Vpc("vpc", cidr_block="192.168.0.0/22")
|
|
466
|
+
azs = aws.get_availability_zones(state="available")
|
|
467
|
+
subnet_az1 = aws.ec2.Subnet("subnet_az1",
|
|
468
|
+
availability_zone=azs.names[0],
|
|
469
|
+
cidr_block="192.168.0.0/24",
|
|
470
|
+
vpc_id=vpc.id)
|
|
471
|
+
subnet_az2 = aws.ec2.Subnet("subnet_az2",
|
|
472
|
+
availability_zone=azs.names[1],
|
|
473
|
+
cidr_block="192.168.1.0/24",
|
|
474
|
+
vpc_id=vpc.id)
|
|
475
|
+
sg = aws.ec2.SecurityGroup("sg", vpc_id=vpc.id)
|
|
476
|
+
example_configuration = aws.msk.Configuration("example",
|
|
477
|
+
name=f"{msk_cluster_name}-msk-configuration",
|
|
478
|
+
server_properties=\"\"\"auto.create.topics.enable=false
|
|
479
|
+
default.replication.factor=3
|
|
480
|
+
min.insync.replicas=2
|
|
481
|
+
num.io.threads=8
|
|
482
|
+
num.network.threads=5
|
|
483
|
+
num.partitions=1
|
|
484
|
+
num.replica.fetchers=2
|
|
485
|
+
replica.lag.time.max.ms=30000
|
|
486
|
+
socket.receive.buffer.bytes=102400
|
|
487
|
+
socket.request.max.bytes=104857600
|
|
488
|
+
socket.send.buffer.bytes=102400
|
|
489
|
+
unclean.leader.election.enable=true
|
|
490
|
+
allow.everyone.if.no.acl.found=false
|
|
491
|
+
\"\"\")
|
|
492
|
+
example = aws.msk.Cluster("example",
|
|
493
|
+
cluster_name=msk_cluster_name,
|
|
494
|
+
kafka_version="3.6.0",
|
|
495
|
+
number_of_broker_nodes=2,
|
|
496
|
+
broker_node_group_info={
|
|
497
|
+
"instance_type": "kafka.m5.large",
|
|
498
|
+
"client_subnets": [
|
|
499
|
+
subnet_az1.id,
|
|
500
|
+
subnet_az2.id,
|
|
501
|
+
],
|
|
502
|
+
"security_groups": [sg.id],
|
|
503
|
+
"connectivity_info": {
|
|
504
|
+
"vpc_connectivity": {
|
|
505
|
+
"client_authentication": {
|
|
506
|
+
"sasl": {
|
|
507
|
+
"scram": True,
|
|
508
|
+
},
|
|
509
|
+
},
|
|
510
|
+
},
|
|
511
|
+
},
|
|
512
|
+
},
|
|
513
|
+
client_authentication={
|
|
514
|
+
"sasl": {
|
|
515
|
+
"scram": True,
|
|
516
|
+
},
|
|
517
|
+
},
|
|
518
|
+
configuration_info={
|
|
519
|
+
"arn": example_configuration.arn,
|
|
520
|
+
"revision": example_configuration.latest_revision,
|
|
521
|
+
})
|
|
522
|
+
example_cluster_policy = aws.msk.ClusterPolicy("example",
|
|
523
|
+
cluster_arn=example.arn,
|
|
524
|
+
policy=pulumi.Output.json_dumps({
|
|
525
|
+
"Version": "2012-10-17",
|
|
526
|
+
"Statement": [{
|
|
527
|
+
"Effect": "Allow",
|
|
528
|
+
"Principal": {
|
|
529
|
+
"AWS": f"arn:aws:iam::{aws_account_id}:root",
|
|
530
|
+
},
|
|
531
|
+
"Action": [
|
|
532
|
+
"kafka:CreateVpcConnection",
|
|
533
|
+
"kafka:GetBootstrapBrokers",
|
|
534
|
+
"kafka:DescribeCluster",
|
|
535
|
+
"kafka:DescribeClusterV2",
|
|
536
|
+
],
|
|
537
|
+
"Resource": example.arn,
|
|
538
|
+
}],
|
|
539
|
+
}))
|
|
540
|
+
example_msk_single_scram_secret_association = aws.index.MskSingleScramSecretAssociation("example",
|
|
541
|
+
cluster_arn=example.arn,
|
|
542
|
+
secret_arn=aws_secret_arn)
|
|
543
|
+
test = mongodbatlas.StreamPrivatelinkEndpoint("test",
|
|
544
|
+
project_id=project_id,
|
|
545
|
+
provider_name="AWS",
|
|
546
|
+
vendor="MSK",
|
|
547
|
+
arn=example.arn)
|
|
548
|
+
singular_datasource = test.id.apply(lambda id: mongodbatlas.get_stream_privatelink_endpoint_output(project_id=project_id,
|
|
549
|
+
id=id))
|
|
550
|
+
pulumi.export("privatelinkEndpointId", singular_datasource.id)
|
|
551
|
+
```
|
|
552
|
+
|
|
363
553
|
### AWS S3 Privatelink
|
|
364
554
|
```python
|
|
365
555
|
import pulumi
|
|
@@ -367,20 +557,20 @@ def get_stream_privatelink_endpoint_output(id: Optional[pulumi.Input[_builtins.s
|
|
|
367
557
|
import pulumi_mongodbatlas as mongodbatlas
|
|
368
558
|
|
|
369
559
|
# S3 bucket for stream data
|
|
370
|
-
stream_bucket = aws.
|
|
560
|
+
stream_bucket = aws.s3.BucketV2("stream_bucket",
|
|
371
561
|
bucket=s3_bucket_name,
|
|
372
562
|
force_destroy=True)
|
|
373
|
-
stream_bucket_versioning = aws.
|
|
563
|
+
stream_bucket_versioning = aws.s3.BucketVersioningV2("stream_bucket_versioning",
|
|
374
564
|
bucket=stream_bucket.id,
|
|
375
|
-
versioning_configuration=
|
|
376
|
-
status: Enabled,
|
|
377
|
-
}
|
|
378
|
-
stream_bucket_encryption = aws.
|
|
565
|
+
versioning_configuration={
|
|
566
|
+
"status": "Enabled",
|
|
567
|
+
})
|
|
568
|
+
stream_bucket_encryption = aws.s3.BucketServerSideEncryptionConfigurationV2("stream_bucket_encryption",
|
|
379
569
|
bucket=stream_bucket.id,
|
|
380
|
-
|
|
381
|
-
|
|
382
|
-
|
|
383
|
-
}
|
|
570
|
+
rules=[{
|
|
571
|
+
"apply_server_side_encryption_by_default": {
|
|
572
|
+
"sse_algorithm": "AES256",
|
|
573
|
+
},
|
|
384
574
|
}])
|
|
385
575
|
# PrivateLink for S3
|
|
386
576
|
this = mongodbatlas.StreamPrivatelinkEndpoint("this",
|
|
@@ -139,6 +139,101 @@ def get_stream_privatelink_endpoints(project_id: Optional[_builtins.str] = None,
|
|
|
139
139
|
pulumi.export("interfaceEndpointIds", [__item.interface_endpoint_id for __item in plural_datasource.results])
|
|
140
140
|
```
|
|
141
141
|
|
|
142
|
+
### AWS MSK Privatelink
|
|
143
|
+
```python
|
|
144
|
+
import pulumi
|
|
145
|
+
import json
|
|
146
|
+
import pulumi_aws as aws
|
|
147
|
+
import pulumi_mongodbatlas as mongodbatlas
|
|
148
|
+
|
|
149
|
+
vpc = aws.ec2.Vpc("vpc", cidr_block="192.168.0.0/22")
|
|
150
|
+
azs = aws.get_availability_zones(state="available")
|
|
151
|
+
subnet_az1 = aws.ec2.Subnet("subnet_az1",
|
|
152
|
+
availability_zone=azs.names[0],
|
|
153
|
+
cidr_block="192.168.0.0/24",
|
|
154
|
+
vpc_id=vpc.id)
|
|
155
|
+
subnet_az2 = aws.ec2.Subnet("subnet_az2",
|
|
156
|
+
availability_zone=azs.names[1],
|
|
157
|
+
cidr_block="192.168.1.0/24",
|
|
158
|
+
vpc_id=vpc.id)
|
|
159
|
+
sg = aws.ec2.SecurityGroup("sg", vpc_id=vpc.id)
|
|
160
|
+
example_configuration = aws.msk.Configuration("example",
|
|
161
|
+
name=f"{msk_cluster_name}-msk-configuration",
|
|
162
|
+
server_properties=\"\"\"auto.create.topics.enable=false
|
|
163
|
+
default.replication.factor=3
|
|
164
|
+
min.insync.replicas=2
|
|
165
|
+
num.io.threads=8
|
|
166
|
+
num.network.threads=5
|
|
167
|
+
num.partitions=1
|
|
168
|
+
num.replica.fetchers=2
|
|
169
|
+
replica.lag.time.max.ms=30000
|
|
170
|
+
socket.receive.buffer.bytes=102400
|
|
171
|
+
socket.request.max.bytes=104857600
|
|
172
|
+
socket.send.buffer.bytes=102400
|
|
173
|
+
unclean.leader.election.enable=true
|
|
174
|
+
allow.everyone.if.no.acl.found=false
|
|
175
|
+
\"\"\")
|
|
176
|
+
example = aws.msk.Cluster("example",
|
|
177
|
+
cluster_name=msk_cluster_name,
|
|
178
|
+
kafka_version="3.6.0",
|
|
179
|
+
number_of_broker_nodes=2,
|
|
180
|
+
broker_node_group_info={
|
|
181
|
+
"instance_type": "kafka.m5.large",
|
|
182
|
+
"client_subnets": [
|
|
183
|
+
subnet_az1.id,
|
|
184
|
+
subnet_az2.id,
|
|
185
|
+
],
|
|
186
|
+
"security_groups": [sg.id],
|
|
187
|
+
"connectivity_info": {
|
|
188
|
+
"vpc_connectivity": {
|
|
189
|
+
"client_authentication": {
|
|
190
|
+
"sasl": {
|
|
191
|
+
"scram": True,
|
|
192
|
+
},
|
|
193
|
+
},
|
|
194
|
+
},
|
|
195
|
+
},
|
|
196
|
+
},
|
|
197
|
+
client_authentication={
|
|
198
|
+
"sasl": {
|
|
199
|
+
"scram": True,
|
|
200
|
+
},
|
|
201
|
+
},
|
|
202
|
+
configuration_info={
|
|
203
|
+
"arn": example_configuration.arn,
|
|
204
|
+
"revision": example_configuration.latest_revision,
|
|
205
|
+
})
|
|
206
|
+
example_cluster_policy = aws.msk.ClusterPolicy("example",
|
|
207
|
+
cluster_arn=example.arn,
|
|
208
|
+
policy=pulumi.Output.json_dumps({
|
|
209
|
+
"Version": "2012-10-17",
|
|
210
|
+
"Statement": [{
|
|
211
|
+
"Effect": "Allow",
|
|
212
|
+
"Principal": {
|
|
213
|
+
"AWS": f"arn:aws:iam::{aws_account_id}:root",
|
|
214
|
+
},
|
|
215
|
+
"Action": [
|
|
216
|
+
"kafka:CreateVpcConnection",
|
|
217
|
+
"kafka:GetBootstrapBrokers",
|
|
218
|
+
"kafka:DescribeCluster",
|
|
219
|
+
"kafka:DescribeClusterV2",
|
|
220
|
+
],
|
|
221
|
+
"Resource": example.arn,
|
|
222
|
+
}],
|
|
223
|
+
}))
|
|
224
|
+
example_msk_single_scram_secret_association = aws.index.MskSingleScramSecretAssociation("example",
|
|
225
|
+
cluster_arn=example.arn,
|
|
226
|
+
secret_arn=aws_secret_arn)
|
|
227
|
+
test = mongodbatlas.StreamPrivatelinkEndpoint("test",
|
|
228
|
+
project_id=project_id,
|
|
229
|
+
provider_name="AWS",
|
|
230
|
+
vendor="MSK",
|
|
231
|
+
arn=example.arn)
|
|
232
|
+
singular_datasource = test.id.apply(lambda id: mongodbatlas.get_stream_privatelink_endpoint_output(project_id=project_id,
|
|
233
|
+
id=id))
|
|
234
|
+
pulumi.export("privatelinkEndpointId", singular_datasource.id)
|
|
235
|
+
```
|
|
236
|
+
|
|
142
237
|
### AWS S3 Privatelink
|
|
143
238
|
```python
|
|
144
239
|
import pulumi
|
|
@@ -146,20 +241,20 @@ def get_stream_privatelink_endpoints(project_id: Optional[_builtins.str] = None,
|
|
|
146
241
|
import pulumi_mongodbatlas as mongodbatlas
|
|
147
242
|
|
|
148
243
|
# S3 bucket for stream data
|
|
149
|
-
stream_bucket = aws.
|
|
244
|
+
stream_bucket = aws.s3.BucketV2("stream_bucket",
|
|
150
245
|
bucket=s3_bucket_name,
|
|
151
246
|
force_destroy=True)
|
|
152
|
-
stream_bucket_versioning = aws.
|
|
247
|
+
stream_bucket_versioning = aws.s3.BucketVersioningV2("stream_bucket_versioning",
|
|
153
248
|
bucket=stream_bucket.id,
|
|
154
|
-
versioning_configuration=
|
|
155
|
-
status: Enabled,
|
|
156
|
-
}
|
|
157
|
-
stream_bucket_encryption = aws.
|
|
249
|
+
versioning_configuration={
|
|
250
|
+
"status": "Enabled",
|
|
251
|
+
})
|
|
252
|
+
stream_bucket_encryption = aws.s3.BucketServerSideEncryptionConfigurationV2("stream_bucket_encryption",
|
|
158
253
|
bucket=stream_bucket.id,
|
|
159
|
-
|
|
160
|
-
|
|
161
|
-
|
|
162
|
-
}
|
|
254
|
+
rules=[{
|
|
255
|
+
"apply_server_side_encryption_by_default": {
|
|
256
|
+
"sse_algorithm": "AES256",
|
|
257
|
+
},
|
|
163
258
|
}])
|
|
164
259
|
# PrivateLink for S3
|
|
165
260
|
this = mongodbatlas.StreamPrivatelinkEndpoint("this",
|
|
@@ -251,6 +346,101 @@ def get_stream_privatelink_endpoints_output(project_id: Optional[pulumi.Input[_b
|
|
|
251
346
|
pulumi.export("interfaceEndpointIds", [__item.interface_endpoint_id for __item in plural_datasource.results])
|
|
252
347
|
```
|
|
253
348
|
|
|
349
|
+
### AWS MSK Privatelink
|
|
350
|
+
```python
|
|
351
|
+
import pulumi
|
|
352
|
+
import json
|
|
353
|
+
import pulumi_aws as aws
|
|
354
|
+
import pulumi_mongodbatlas as mongodbatlas
|
|
355
|
+
|
|
356
|
+
vpc = aws.ec2.Vpc("vpc", cidr_block="192.168.0.0/22")
|
|
357
|
+
azs = aws.get_availability_zones(state="available")
|
|
358
|
+
subnet_az1 = aws.ec2.Subnet("subnet_az1",
|
|
359
|
+
availability_zone=azs.names[0],
|
|
360
|
+
cidr_block="192.168.0.0/24",
|
|
361
|
+
vpc_id=vpc.id)
|
|
362
|
+
subnet_az2 = aws.ec2.Subnet("subnet_az2",
|
|
363
|
+
availability_zone=azs.names[1],
|
|
364
|
+
cidr_block="192.168.1.0/24",
|
|
365
|
+
vpc_id=vpc.id)
|
|
366
|
+
sg = aws.ec2.SecurityGroup("sg", vpc_id=vpc.id)
|
|
367
|
+
example_configuration = aws.msk.Configuration("example",
|
|
368
|
+
name=f"{msk_cluster_name}-msk-configuration",
|
|
369
|
+
server_properties=\"\"\"auto.create.topics.enable=false
|
|
370
|
+
default.replication.factor=3
|
|
371
|
+
min.insync.replicas=2
|
|
372
|
+
num.io.threads=8
|
|
373
|
+
num.network.threads=5
|
|
374
|
+
num.partitions=1
|
|
375
|
+
num.replica.fetchers=2
|
|
376
|
+
replica.lag.time.max.ms=30000
|
|
377
|
+
socket.receive.buffer.bytes=102400
|
|
378
|
+
socket.request.max.bytes=104857600
|
|
379
|
+
socket.send.buffer.bytes=102400
|
|
380
|
+
unclean.leader.election.enable=true
|
|
381
|
+
allow.everyone.if.no.acl.found=false
|
|
382
|
+
\"\"\")
|
|
383
|
+
example = aws.msk.Cluster("example",
|
|
384
|
+
cluster_name=msk_cluster_name,
|
|
385
|
+
kafka_version="3.6.0",
|
|
386
|
+
number_of_broker_nodes=2,
|
|
387
|
+
broker_node_group_info={
|
|
388
|
+
"instance_type": "kafka.m5.large",
|
|
389
|
+
"client_subnets": [
|
|
390
|
+
subnet_az1.id,
|
|
391
|
+
subnet_az2.id,
|
|
392
|
+
],
|
|
393
|
+
"security_groups": [sg.id],
|
|
394
|
+
"connectivity_info": {
|
|
395
|
+
"vpc_connectivity": {
|
|
396
|
+
"client_authentication": {
|
|
397
|
+
"sasl": {
|
|
398
|
+
"scram": True,
|
|
399
|
+
},
|
|
400
|
+
},
|
|
401
|
+
},
|
|
402
|
+
},
|
|
403
|
+
},
|
|
404
|
+
client_authentication={
|
|
405
|
+
"sasl": {
|
|
406
|
+
"scram": True,
|
|
407
|
+
},
|
|
408
|
+
},
|
|
409
|
+
configuration_info={
|
|
410
|
+
"arn": example_configuration.arn,
|
|
411
|
+
"revision": example_configuration.latest_revision,
|
|
412
|
+
})
|
|
413
|
+
example_cluster_policy = aws.msk.ClusterPolicy("example",
|
|
414
|
+
cluster_arn=example.arn,
|
|
415
|
+
policy=pulumi.Output.json_dumps({
|
|
416
|
+
"Version": "2012-10-17",
|
|
417
|
+
"Statement": [{
|
|
418
|
+
"Effect": "Allow",
|
|
419
|
+
"Principal": {
|
|
420
|
+
"AWS": f"arn:aws:iam::{aws_account_id}:root",
|
|
421
|
+
},
|
|
422
|
+
"Action": [
|
|
423
|
+
"kafka:CreateVpcConnection",
|
|
424
|
+
"kafka:GetBootstrapBrokers",
|
|
425
|
+
"kafka:DescribeCluster",
|
|
426
|
+
"kafka:DescribeClusterV2",
|
|
427
|
+
],
|
|
428
|
+
"Resource": example.arn,
|
|
429
|
+
}],
|
|
430
|
+
}))
|
|
431
|
+
example_msk_single_scram_secret_association = aws.index.MskSingleScramSecretAssociation("example",
|
|
432
|
+
cluster_arn=example.arn,
|
|
433
|
+
secret_arn=aws_secret_arn)
|
|
434
|
+
test = mongodbatlas.StreamPrivatelinkEndpoint("test",
|
|
435
|
+
project_id=project_id,
|
|
436
|
+
provider_name="AWS",
|
|
437
|
+
vendor="MSK",
|
|
438
|
+
arn=example.arn)
|
|
439
|
+
singular_datasource = test.id.apply(lambda id: mongodbatlas.get_stream_privatelink_endpoint_output(project_id=project_id,
|
|
440
|
+
id=id))
|
|
441
|
+
pulumi.export("privatelinkEndpointId", singular_datasource.id)
|
|
442
|
+
```
|
|
443
|
+
|
|
254
444
|
### AWS S3 Privatelink
|
|
255
445
|
```python
|
|
256
446
|
import pulumi
|
|
@@ -258,20 +448,20 @@ def get_stream_privatelink_endpoints_output(project_id: Optional[pulumi.Input[_b
|
|
|
258
448
|
import pulumi_mongodbatlas as mongodbatlas
|
|
259
449
|
|
|
260
450
|
# S3 bucket for stream data
|
|
261
|
-
stream_bucket = aws.
|
|
451
|
+
stream_bucket = aws.s3.BucketV2("stream_bucket",
|
|
262
452
|
bucket=s3_bucket_name,
|
|
263
453
|
force_destroy=True)
|
|
264
|
-
stream_bucket_versioning = aws.
|
|
454
|
+
stream_bucket_versioning = aws.s3.BucketVersioningV2("stream_bucket_versioning",
|
|
265
455
|
bucket=stream_bucket.id,
|
|
266
|
-
versioning_configuration=
|
|
267
|
-
status: Enabled,
|
|
268
|
-
}
|
|
269
|
-
stream_bucket_encryption = aws.
|
|
456
|
+
versioning_configuration={
|
|
457
|
+
"status": "Enabled",
|
|
458
|
+
})
|
|
459
|
+
stream_bucket_encryption = aws.s3.BucketServerSideEncryptionConfigurationV2("stream_bucket_encryption",
|
|
270
460
|
bucket=stream_bucket.id,
|
|
271
|
-
|
|
272
|
-
|
|
273
|
-
|
|
274
|
-
}
|
|
461
|
+
rules=[{
|
|
462
|
+
"apply_server_side_encryption_by_default": {
|
|
463
|
+
"sse_algorithm": "AES256",
|
|
464
|
+
},
|
|
275
465
|
}])
|
|
276
466
|
# PrivateLink for S3
|
|
277
467
|
this = mongodbatlas.StreamPrivatelinkEndpoint("this",
|
|
@@ -753,11 +753,62 @@ class NetworkPeering(pulumi.CustomResource):
|
|
|
753
753
|
aws_account_id="abc123abc123")
|
|
754
754
|
# the following assumes an AWS provider is configured
|
|
755
755
|
# Accept the peering connection request
|
|
756
|
-
peer = aws.
|
|
756
|
+
peer = aws.ec2.VpcPeeringConnectionAccepter("peer",
|
|
757
757
|
vpc_peering_connection_id=test_network_peering.connection_id,
|
|
758
758
|
auto_accept=True)
|
|
759
759
|
```
|
|
760
760
|
|
|
761
|
+
### Example with GCP
|
|
762
|
+
|
|
763
|
+
```python
|
|
764
|
+
import pulumi
|
|
765
|
+
import pulumi_gcp as gcp
|
|
766
|
+
import pulumi_mongodbatlas as mongodbatlas
|
|
767
|
+
|
|
768
|
+
# Container example provided but not always required,
|
|
769
|
+
# see network_container documentation for details.
|
|
770
|
+
test = mongodbatlas.NetworkContainer("test",
|
|
771
|
+
project_id=project_id,
|
|
772
|
+
atlas_cidr_block="10.8.0.0/21",
|
|
773
|
+
provider_name="GCP")
|
|
774
|
+
# Create the peering connection request
|
|
775
|
+
test_network_peering = mongodbatlas.NetworkPeering("test",
|
|
776
|
+
project_id=project_id,
|
|
777
|
+
container_id=test.container_id,
|
|
778
|
+
provider_name="GCP",
|
|
779
|
+
gcp_project_id=gc_p__projec_t__id,
|
|
780
|
+
network_name="default")
|
|
781
|
+
# the following assumes a GCP provider is configured
|
|
782
|
+
default = gcp.compute.get_network(name="default")
|
|
783
|
+
# Create the GCP peer
|
|
784
|
+
peering = gcp.compute.NetworkPeering("peering",
|
|
785
|
+
name="peering-gcp-terraform-test",
|
|
786
|
+
network=default.self_link,
|
|
787
|
+
peer_network=pulumi.Output.all(
|
|
788
|
+
atlas_gcp_project_id=test_network_peering.atlas_gcp_project_id,
|
|
789
|
+
atlas_vpc_name=test_network_peering.atlas_vpc_name
|
|
790
|
+
).apply(lambda resolved_outputs: f"https://www.googleapis.com/compute/v1/projects/{resolved_outputs['atlas_gcp_project_id']}/global/networks/{resolved_outputs['atlas_vpc_name']}")
|
|
791
|
+
)
|
|
792
|
+
# Create the cluster once the peering connection is completed
|
|
793
|
+
test_advanced_cluster = mongodbatlas.AdvancedCluster("test",
|
|
794
|
+
project_id=project_id,
|
|
795
|
+
name="terraform-manually-test",
|
|
796
|
+
cluster_type="REPLICASET",
|
|
797
|
+
backup_enabled=True,
|
|
798
|
+
replication_specs=[{
|
|
799
|
+
"region_configs": [{
|
|
800
|
+
"priority": 7,
|
|
801
|
+
"provider_name": "GCP",
|
|
802
|
+
"region_name": "US_EAST_4",
|
|
803
|
+
"electable_specs": {
|
|
804
|
+
"instance_size": "M10",
|
|
805
|
+
"node_count": 3,
|
|
806
|
+
},
|
|
807
|
+
}],
|
|
808
|
+
}],
|
|
809
|
+
opts = pulumi.ResourceOptions(depends_on=[peering]))
|
|
810
|
+
```
|
|
811
|
+
|
|
761
812
|
### Example with Azure
|
|
762
813
|
|
|
763
814
|
```python
|
|
@@ -900,11 +951,62 @@ class NetworkPeering(pulumi.CustomResource):
|
|
|
900
951
|
aws_account_id="abc123abc123")
|
|
901
952
|
# the following assumes an AWS provider is configured
|
|
902
953
|
# Accept the peering connection request
|
|
903
|
-
peer = aws.
|
|
954
|
+
peer = aws.ec2.VpcPeeringConnectionAccepter("peer",
|
|
904
955
|
vpc_peering_connection_id=test_network_peering.connection_id,
|
|
905
956
|
auto_accept=True)
|
|
906
957
|
```
|
|
907
958
|
|
|
959
|
+
### Example with GCP
|
|
960
|
+
|
|
961
|
+
```python
|
|
962
|
+
import pulumi
|
|
963
|
+
import pulumi_gcp as gcp
|
|
964
|
+
import pulumi_mongodbatlas as mongodbatlas
|
|
965
|
+
|
|
966
|
+
# Container example provided but not always required,
|
|
967
|
+
# see network_container documentation for details.
|
|
968
|
+
test = mongodbatlas.NetworkContainer("test",
|
|
969
|
+
project_id=project_id,
|
|
970
|
+
atlas_cidr_block="10.8.0.0/21",
|
|
971
|
+
provider_name="GCP")
|
|
972
|
+
# Create the peering connection request
|
|
973
|
+
test_network_peering = mongodbatlas.NetworkPeering("test",
|
|
974
|
+
project_id=project_id,
|
|
975
|
+
container_id=test.container_id,
|
|
976
|
+
provider_name="GCP",
|
|
977
|
+
gcp_project_id=gc_p__projec_t__id,
|
|
978
|
+
network_name="default")
|
|
979
|
+
# the following assumes a GCP provider is configured
|
|
980
|
+
default = gcp.compute.get_network(name="default")
|
|
981
|
+
# Create the GCP peer
|
|
982
|
+
peering = gcp.compute.NetworkPeering("peering",
|
|
983
|
+
name="peering-gcp-terraform-test",
|
|
984
|
+
network=default.self_link,
|
|
985
|
+
peer_network=pulumi.Output.all(
|
|
986
|
+
atlas_gcp_project_id=test_network_peering.atlas_gcp_project_id,
|
|
987
|
+
atlas_vpc_name=test_network_peering.atlas_vpc_name
|
|
988
|
+
).apply(lambda resolved_outputs: f"https://www.googleapis.com/compute/v1/projects/{resolved_outputs['atlas_gcp_project_id']}/global/networks/{resolved_outputs['atlas_vpc_name']}")
|
|
989
|
+
)
|
|
990
|
+
# Create the cluster once the peering connection is completed
|
|
991
|
+
test_advanced_cluster = mongodbatlas.AdvancedCluster("test",
|
|
992
|
+
project_id=project_id,
|
|
993
|
+
name="terraform-manually-test",
|
|
994
|
+
cluster_type="REPLICASET",
|
|
995
|
+
backup_enabled=True,
|
|
996
|
+
replication_specs=[{
|
|
997
|
+
"region_configs": [{
|
|
998
|
+
"priority": 7,
|
|
999
|
+
"provider_name": "GCP",
|
|
1000
|
+
"region_name": "US_EAST_4",
|
|
1001
|
+
"electable_specs": {
|
|
1002
|
+
"instance_size": "M10",
|
|
1003
|
+
"node_count": 3,
|
|
1004
|
+
},
|
|
1005
|
+
}],
|
|
1006
|
+
}],
|
|
1007
|
+
opts = pulumi.ResourceOptions(depends_on=[peering]))
|
|
1008
|
+
```
|
|
1009
|
+
|
|
908
1010
|
### Example with Azure
|
|
909
1011
|
|
|
910
1012
|
```python
|
|
@@ -269,19 +269,19 @@ class PrivatelinkEndpointServiceDataFederationOnlineArchive(pulumi.CustomResourc
|
|
|
269
269
|
atlas_project = mongodbatlas.Project("atlas-project",
|
|
270
270
|
org_id=atlas_org_id,
|
|
271
271
|
name=atlas_project_name)
|
|
272
|
-
test = aws.
|
|
273
|
-
vpc_id=vpc-7fc0a543,
|
|
274
|
-
service_name
|
|
275
|
-
vpc_endpoint_type=Interface,
|
|
276
|
-
subnet_ids=[subnet-de0406d2],
|
|
277
|
-
security_group_ids=[sg-3f238186])
|
|
272
|
+
test = aws.ec2.VpcEndpoint("test",
|
|
273
|
+
vpc_id="vpc-7fc0a543",
|
|
274
|
+
service_name="<SERVICE-NAME>",
|
|
275
|
+
vpc_endpoint_type="Interface",
|
|
276
|
+
subnet_ids=["subnet-de0406d2"],
|
|
277
|
+
security_group_ids=["sg-3f238186"])
|
|
278
278
|
test_privatelink_endpoint_service_data_federation_online_archive = mongodbatlas.PrivatelinkEndpointServiceDataFederationOnlineArchive("test",
|
|
279
279
|
project_id=atlas_project.id,
|
|
280
|
-
endpoint_id=test
|
|
280
|
+
endpoint_id=test.id,
|
|
281
281
|
provider_name="AWS",
|
|
282
282
|
comment="Test",
|
|
283
283
|
region="US_EAST_1",
|
|
284
|
-
customer_endpoint_dns_name=test[
|
|
284
|
+
customer_endpoint_dns_name=test.dns_entries[0].dns_name)
|
|
285
285
|
```
|
|
286
286
|
|
|
287
287
|
The `service_name` value for the region in question can be found in the [MongoDB Atlas Administration](https://www.mongodb.com/docs/api/doc/atlas-admin-api-v2/operation/operation-createdatafederationprivateendpoint) documentation.
|
|
@@ -329,19 +329,19 @@ class PrivatelinkEndpointServiceDataFederationOnlineArchive(pulumi.CustomResourc
|
|
|
329
329
|
atlas_project = mongodbatlas.Project("atlas-project",
|
|
330
330
|
org_id=atlas_org_id,
|
|
331
331
|
name=atlas_project_name)
|
|
332
|
-
test = aws.
|
|
333
|
-
vpc_id=vpc-7fc0a543,
|
|
334
|
-
service_name
|
|
335
|
-
vpc_endpoint_type=Interface,
|
|
336
|
-
subnet_ids=[subnet-de0406d2],
|
|
337
|
-
security_group_ids=[sg-3f238186])
|
|
332
|
+
test = aws.ec2.VpcEndpoint("test",
|
|
333
|
+
vpc_id="vpc-7fc0a543",
|
|
334
|
+
service_name="<SERVICE-NAME>",
|
|
335
|
+
vpc_endpoint_type="Interface",
|
|
336
|
+
subnet_ids=["subnet-de0406d2"],
|
|
337
|
+
security_group_ids=["sg-3f238186"])
|
|
338
338
|
test_privatelink_endpoint_service_data_federation_online_archive = mongodbatlas.PrivatelinkEndpointServiceDataFederationOnlineArchive("test",
|
|
339
339
|
project_id=atlas_project.id,
|
|
340
|
-
endpoint_id=test
|
|
340
|
+
endpoint_id=test.id,
|
|
341
341
|
provider_name="AWS",
|
|
342
342
|
comment="Test",
|
|
343
343
|
region="US_EAST_1",
|
|
344
|
-
customer_endpoint_dns_name=test[
|
|
344
|
+
customer_endpoint_dns_name=test.dns_entries[0].dns_name)
|
|
345
345
|
```
|
|
346
346
|
|
|
347
347
|
The `service_name` value for the region in question can be found in the [MongoDB Atlas Administration](https://www.mongodb.com/docs/api/doc/atlas-admin-api-v2/operation/operation-createdatafederationprivateendpoint) documentation.
|
|
@@ -325,17 +325,17 @@ class PrivatelinkEndpointServiceServerless(pulumi.CustomResource):
|
|
|
325
325
|
project_id="<PROJECT_ID>",
|
|
326
326
|
instance_name=test_serverless_instance.name,
|
|
327
327
|
provider_name="AWS")
|
|
328
|
-
ptfe_service = aws.
|
|
329
|
-
vpc_id=vpc-7fc0a543,
|
|
328
|
+
ptfe_service = aws.ec2.VpcEndpoint("ptfe_service",
|
|
329
|
+
vpc_id="vpc-7fc0a543",
|
|
330
330
|
service_name=test.endpoint_service_name,
|
|
331
|
-
vpc_endpoint_type=Interface,
|
|
332
|
-
subnet_ids=[subnet-de0406d2],
|
|
333
|
-
security_group_ids=[sg-3f238186])
|
|
331
|
+
vpc_endpoint_type="Interface",
|
|
332
|
+
subnet_ids=["subnet-de0406d2"],
|
|
333
|
+
security_group_ids=["sg-3f238186"])
|
|
334
334
|
test_privatelink_endpoint_service_serverless = mongodbatlas.PrivatelinkEndpointServiceServerless("test",
|
|
335
335
|
project_id="<PROJECT_ID>",
|
|
336
336
|
instance_name=test_serverless_instance.name,
|
|
337
337
|
endpoint_id=test.endpoint_id,
|
|
338
|
-
cloud_provider_endpoint_id=ptfe_service
|
|
338
|
+
cloud_provider_endpoint_id=ptfe_service.id,
|
|
339
339
|
provider_name="AWS",
|
|
340
340
|
comment="New serverless endpoint")
|
|
341
341
|
```
|
|
@@ -344,23 +344,23 @@ class PrivatelinkEndpointServiceServerless(pulumi.CustomResource):
|
|
|
344
344
|
|
|
345
345
|
```python
|
|
346
346
|
import pulumi
|
|
347
|
-
import
|
|
347
|
+
import pulumi_azure as azure
|
|
348
348
|
import pulumi_mongodbatlas as mongodbatlas
|
|
349
349
|
|
|
350
350
|
test = mongodbatlas.PrivatelinkEndpointServerless("test",
|
|
351
351
|
project_id=project_id,
|
|
352
352
|
provider_name="AZURE")
|
|
353
|
-
|
|
354
|
-
name=endpoint-test,
|
|
355
|
-
location=test_azurerm_resource_group
|
|
353
|
+
test_endpoint = azure.privatelink.Endpoint("test",
|
|
354
|
+
name="endpoint-test",
|
|
355
|
+
location=test_azurerm_resource_group["location"],
|
|
356
356
|
resource_group_name=resource_group_name,
|
|
357
|
-
subnet_id=test_azurerm_subnet
|
|
358
|
-
private_service_connection=
|
|
359
|
-
name: test.private_link_service_name,
|
|
360
|
-
|
|
361
|
-
|
|
362
|
-
|
|
363
|
-
}
|
|
357
|
+
subnet_id=test_azurerm_subnet["id"],
|
|
358
|
+
private_service_connection={
|
|
359
|
+
"name": test.private_link_service_name,
|
|
360
|
+
"private_connection_resource_id": test.private_link_service_resource_id,
|
|
361
|
+
"is_manual_connection": True,
|
|
362
|
+
"request_message": "Azure Private Link test",
|
|
363
|
+
})
|
|
364
364
|
test_serverless_instance = mongodbatlas.ServerlessInstance("test",
|
|
365
365
|
project_id="<PROJECT_ID>",
|
|
366
366
|
name="test-db",
|
|
@@ -372,8 +372,8 @@ class PrivatelinkEndpointServiceServerless(pulumi.CustomResource):
|
|
|
372
372
|
project_id=test.project_id,
|
|
373
373
|
instance_name=test_serverless_instance.name,
|
|
374
374
|
endpoint_id=test.endpoint_id,
|
|
375
|
-
cloud_provider_endpoint_id=
|
|
376
|
-
private_endpoint_ip_address=
|
|
375
|
+
cloud_provider_endpoint_id=test_endpoint.id,
|
|
376
|
+
private_endpoint_ip_address=test_endpoint.private_service_connection.private_ip_address,
|
|
377
377
|
provider_name="AZURE",
|
|
378
378
|
comment="test")
|
|
379
379
|
```
|
|
@@ -433,17 +433,17 @@ class PrivatelinkEndpointServiceServerless(pulumi.CustomResource):
|
|
|
433
433
|
project_id="<PROJECT_ID>",
|
|
434
434
|
instance_name=test_serverless_instance.name,
|
|
435
435
|
provider_name="AWS")
|
|
436
|
-
ptfe_service = aws.
|
|
437
|
-
vpc_id=vpc-7fc0a543,
|
|
436
|
+
ptfe_service = aws.ec2.VpcEndpoint("ptfe_service",
|
|
437
|
+
vpc_id="vpc-7fc0a543",
|
|
438
438
|
service_name=test.endpoint_service_name,
|
|
439
|
-
vpc_endpoint_type=Interface,
|
|
440
|
-
subnet_ids=[subnet-de0406d2],
|
|
441
|
-
security_group_ids=[sg-3f238186])
|
|
439
|
+
vpc_endpoint_type="Interface",
|
|
440
|
+
subnet_ids=["subnet-de0406d2"],
|
|
441
|
+
security_group_ids=["sg-3f238186"])
|
|
442
442
|
test_privatelink_endpoint_service_serverless = mongodbatlas.PrivatelinkEndpointServiceServerless("test",
|
|
443
443
|
project_id="<PROJECT_ID>",
|
|
444
444
|
instance_name=test_serverless_instance.name,
|
|
445
445
|
endpoint_id=test.endpoint_id,
|
|
446
|
-
cloud_provider_endpoint_id=ptfe_service
|
|
446
|
+
cloud_provider_endpoint_id=ptfe_service.id,
|
|
447
447
|
provider_name="AWS",
|
|
448
448
|
comment="New serverless endpoint")
|
|
449
449
|
```
|
|
@@ -452,23 +452,23 @@ class PrivatelinkEndpointServiceServerless(pulumi.CustomResource):
|
|
|
452
452
|
|
|
453
453
|
```python
|
|
454
454
|
import pulumi
|
|
455
|
-
import
|
|
455
|
+
import pulumi_azure as azure
|
|
456
456
|
import pulumi_mongodbatlas as mongodbatlas
|
|
457
457
|
|
|
458
458
|
test = mongodbatlas.PrivatelinkEndpointServerless("test",
|
|
459
459
|
project_id=project_id,
|
|
460
460
|
provider_name="AZURE")
|
|
461
|
-
|
|
462
|
-
name=endpoint-test,
|
|
463
|
-
location=test_azurerm_resource_group
|
|
461
|
+
test_endpoint = azure.privatelink.Endpoint("test",
|
|
462
|
+
name="endpoint-test",
|
|
463
|
+
location=test_azurerm_resource_group["location"],
|
|
464
464
|
resource_group_name=resource_group_name,
|
|
465
|
-
subnet_id=test_azurerm_subnet
|
|
466
|
-
private_service_connection=
|
|
467
|
-
name: test.private_link_service_name,
|
|
468
|
-
|
|
469
|
-
|
|
470
|
-
|
|
471
|
-
}
|
|
465
|
+
subnet_id=test_azurerm_subnet["id"],
|
|
466
|
+
private_service_connection={
|
|
467
|
+
"name": test.private_link_service_name,
|
|
468
|
+
"private_connection_resource_id": test.private_link_service_resource_id,
|
|
469
|
+
"is_manual_connection": True,
|
|
470
|
+
"request_message": "Azure Private Link test",
|
|
471
|
+
})
|
|
472
472
|
test_serverless_instance = mongodbatlas.ServerlessInstance("test",
|
|
473
473
|
project_id="<PROJECT_ID>",
|
|
474
474
|
name="test-db",
|
|
@@ -480,8 +480,8 @@ class PrivatelinkEndpointServiceServerless(pulumi.CustomResource):
|
|
|
480
480
|
project_id=test.project_id,
|
|
481
481
|
instance_name=test_serverless_instance.name,
|
|
482
482
|
endpoint_id=test.endpoint_id,
|
|
483
|
-
cloud_provider_endpoint_id=
|
|
484
|
-
private_endpoint_ip_address=
|
|
483
|
+
cloud_provider_endpoint_id=test_endpoint.id,
|
|
484
|
+
private_endpoint_ip_address=test_endpoint.private_service_connection.private_ip_address,
|
|
485
485
|
provider_name="AZURE",
|
|
486
486
|
comment="test")
|
|
487
487
|
```
|
|
@@ -481,6 +481,101 @@ class StreamPrivatelinkEndpoint(pulumi.CustomResource):
|
|
|
481
481
|
pulumi.export("interfaceEndpointIds", [__item.interface_endpoint_id for __item in plural_datasource.results])
|
|
482
482
|
```
|
|
483
483
|
|
|
484
|
+
### AWS MSK Privatelink
|
|
485
|
+
```python
|
|
486
|
+
import pulumi
|
|
487
|
+
import json
|
|
488
|
+
import pulumi_aws as aws
|
|
489
|
+
import pulumi_mongodbatlas as mongodbatlas
|
|
490
|
+
|
|
491
|
+
vpc = aws.ec2.Vpc("vpc", cidr_block="192.168.0.0/22")
|
|
492
|
+
azs = aws.get_availability_zones(state="available")
|
|
493
|
+
subnet_az1 = aws.ec2.Subnet("subnet_az1",
|
|
494
|
+
availability_zone=azs.names[0],
|
|
495
|
+
cidr_block="192.168.0.0/24",
|
|
496
|
+
vpc_id=vpc.id)
|
|
497
|
+
subnet_az2 = aws.ec2.Subnet("subnet_az2",
|
|
498
|
+
availability_zone=azs.names[1],
|
|
499
|
+
cidr_block="192.168.1.0/24",
|
|
500
|
+
vpc_id=vpc.id)
|
|
501
|
+
sg = aws.ec2.SecurityGroup("sg", vpc_id=vpc.id)
|
|
502
|
+
example_configuration = aws.msk.Configuration("example",
|
|
503
|
+
name=f"{msk_cluster_name}-msk-configuration",
|
|
504
|
+
server_properties=\"\"\"auto.create.topics.enable=false
|
|
505
|
+
default.replication.factor=3
|
|
506
|
+
min.insync.replicas=2
|
|
507
|
+
num.io.threads=8
|
|
508
|
+
num.network.threads=5
|
|
509
|
+
num.partitions=1
|
|
510
|
+
num.replica.fetchers=2
|
|
511
|
+
replica.lag.time.max.ms=30000
|
|
512
|
+
socket.receive.buffer.bytes=102400
|
|
513
|
+
socket.request.max.bytes=104857600
|
|
514
|
+
socket.send.buffer.bytes=102400
|
|
515
|
+
unclean.leader.election.enable=true
|
|
516
|
+
allow.everyone.if.no.acl.found=false
|
|
517
|
+
\"\"\")
|
|
518
|
+
example = aws.msk.Cluster("example",
|
|
519
|
+
cluster_name=msk_cluster_name,
|
|
520
|
+
kafka_version="3.6.0",
|
|
521
|
+
number_of_broker_nodes=2,
|
|
522
|
+
broker_node_group_info={
|
|
523
|
+
"instance_type": "kafka.m5.large",
|
|
524
|
+
"client_subnets": [
|
|
525
|
+
subnet_az1.id,
|
|
526
|
+
subnet_az2.id,
|
|
527
|
+
],
|
|
528
|
+
"security_groups": [sg.id],
|
|
529
|
+
"connectivity_info": {
|
|
530
|
+
"vpc_connectivity": {
|
|
531
|
+
"client_authentication": {
|
|
532
|
+
"sasl": {
|
|
533
|
+
"scram": True,
|
|
534
|
+
},
|
|
535
|
+
},
|
|
536
|
+
},
|
|
537
|
+
},
|
|
538
|
+
},
|
|
539
|
+
client_authentication={
|
|
540
|
+
"sasl": {
|
|
541
|
+
"scram": True,
|
|
542
|
+
},
|
|
543
|
+
},
|
|
544
|
+
configuration_info={
|
|
545
|
+
"arn": example_configuration.arn,
|
|
546
|
+
"revision": example_configuration.latest_revision,
|
|
547
|
+
})
|
|
548
|
+
example_cluster_policy = aws.msk.ClusterPolicy("example",
|
|
549
|
+
cluster_arn=example.arn,
|
|
550
|
+
policy=pulumi.Output.json_dumps({
|
|
551
|
+
"Version": "2012-10-17",
|
|
552
|
+
"Statement": [{
|
|
553
|
+
"Effect": "Allow",
|
|
554
|
+
"Principal": {
|
|
555
|
+
"AWS": f"arn:aws:iam::{aws_account_id}:root",
|
|
556
|
+
},
|
|
557
|
+
"Action": [
|
|
558
|
+
"kafka:CreateVpcConnection",
|
|
559
|
+
"kafka:GetBootstrapBrokers",
|
|
560
|
+
"kafka:DescribeCluster",
|
|
561
|
+
"kafka:DescribeClusterV2",
|
|
562
|
+
],
|
|
563
|
+
"Resource": example.arn,
|
|
564
|
+
}],
|
|
565
|
+
}))
|
|
566
|
+
example_msk_single_scram_secret_association = aws.index.MskSingleScramSecretAssociation("example",
|
|
567
|
+
cluster_arn=example.arn,
|
|
568
|
+
secret_arn=aws_secret_arn)
|
|
569
|
+
test = mongodbatlas.StreamPrivatelinkEndpoint("test",
|
|
570
|
+
project_id=project_id,
|
|
571
|
+
provider_name="AWS",
|
|
572
|
+
vendor="MSK",
|
|
573
|
+
arn=example.arn)
|
|
574
|
+
singular_datasource = test.id.apply(lambda id: mongodbatlas.get_stream_privatelink_endpoint_output(project_id=project_id,
|
|
575
|
+
id=id))
|
|
576
|
+
pulumi.export("privatelinkEndpointId", singular_datasource.id)
|
|
577
|
+
```
|
|
578
|
+
|
|
484
579
|
### AWS S3 Privatelink
|
|
485
580
|
```python
|
|
486
581
|
import pulumi
|
|
@@ -488,20 +583,20 @@ class StreamPrivatelinkEndpoint(pulumi.CustomResource):
|
|
|
488
583
|
import pulumi_mongodbatlas as mongodbatlas
|
|
489
584
|
|
|
490
585
|
# S3 bucket for stream data
|
|
491
|
-
stream_bucket = aws.
|
|
586
|
+
stream_bucket = aws.s3.BucketV2("stream_bucket",
|
|
492
587
|
bucket=s3_bucket_name,
|
|
493
588
|
force_destroy=True)
|
|
494
|
-
stream_bucket_versioning = aws.
|
|
589
|
+
stream_bucket_versioning = aws.s3.BucketVersioningV2("stream_bucket_versioning",
|
|
495
590
|
bucket=stream_bucket.id,
|
|
496
|
-
versioning_configuration=
|
|
497
|
-
status: Enabled,
|
|
498
|
-
}
|
|
499
|
-
stream_bucket_encryption = aws.
|
|
591
|
+
versioning_configuration={
|
|
592
|
+
"status": "Enabled",
|
|
593
|
+
})
|
|
594
|
+
stream_bucket_encryption = aws.s3.BucketServerSideEncryptionConfigurationV2("stream_bucket_encryption",
|
|
500
595
|
bucket=stream_bucket.id,
|
|
501
|
-
|
|
502
|
-
|
|
503
|
-
|
|
504
|
-
}
|
|
596
|
+
rules=[{
|
|
597
|
+
"apply_server_side_encryption_by_default": {
|
|
598
|
+
"sse_algorithm": "AES256",
|
|
599
|
+
},
|
|
505
600
|
}])
|
|
506
601
|
# PrivateLink for S3
|
|
507
602
|
this = mongodbatlas.StreamPrivatelinkEndpoint("this",
|
|
@@ -607,6 +702,101 @@ class StreamPrivatelinkEndpoint(pulumi.CustomResource):
|
|
|
607
702
|
pulumi.export("interfaceEndpointIds", [__item.interface_endpoint_id for __item in plural_datasource.results])
|
|
608
703
|
```
|
|
609
704
|
|
|
705
|
+
### AWS MSK Privatelink
|
|
706
|
+
```python
|
|
707
|
+
import pulumi
|
|
708
|
+
import json
|
|
709
|
+
import pulumi_aws as aws
|
|
710
|
+
import pulumi_mongodbatlas as mongodbatlas
|
|
711
|
+
|
|
712
|
+
vpc = aws.ec2.Vpc("vpc", cidr_block="192.168.0.0/22")
|
|
713
|
+
azs = aws.get_availability_zones(state="available")
|
|
714
|
+
subnet_az1 = aws.ec2.Subnet("subnet_az1",
|
|
715
|
+
availability_zone=azs.names[0],
|
|
716
|
+
cidr_block="192.168.0.0/24",
|
|
717
|
+
vpc_id=vpc.id)
|
|
718
|
+
subnet_az2 = aws.ec2.Subnet("subnet_az2",
|
|
719
|
+
availability_zone=azs.names[1],
|
|
720
|
+
cidr_block="192.168.1.0/24",
|
|
721
|
+
vpc_id=vpc.id)
|
|
722
|
+
sg = aws.ec2.SecurityGroup("sg", vpc_id=vpc.id)
|
|
723
|
+
example_configuration = aws.msk.Configuration("example",
|
|
724
|
+
name=f"{msk_cluster_name}-msk-configuration",
|
|
725
|
+
server_properties=\"\"\"auto.create.topics.enable=false
|
|
726
|
+
default.replication.factor=3
|
|
727
|
+
min.insync.replicas=2
|
|
728
|
+
num.io.threads=8
|
|
729
|
+
num.network.threads=5
|
|
730
|
+
num.partitions=1
|
|
731
|
+
num.replica.fetchers=2
|
|
732
|
+
replica.lag.time.max.ms=30000
|
|
733
|
+
socket.receive.buffer.bytes=102400
|
|
734
|
+
socket.request.max.bytes=104857600
|
|
735
|
+
socket.send.buffer.bytes=102400
|
|
736
|
+
unclean.leader.election.enable=true
|
|
737
|
+
allow.everyone.if.no.acl.found=false
|
|
738
|
+
\"\"\")
|
|
739
|
+
example = aws.msk.Cluster("example",
|
|
740
|
+
cluster_name=msk_cluster_name,
|
|
741
|
+
kafka_version="3.6.0",
|
|
742
|
+
number_of_broker_nodes=2,
|
|
743
|
+
broker_node_group_info={
|
|
744
|
+
"instance_type": "kafka.m5.large",
|
|
745
|
+
"client_subnets": [
|
|
746
|
+
subnet_az1.id,
|
|
747
|
+
subnet_az2.id,
|
|
748
|
+
],
|
|
749
|
+
"security_groups": [sg.id],
|
|
750
|
+
"connectivity_info": {
|
|
751
|
+
"vpc_connectivity": {
|
|
752
|
+
"client_authentication": {
|
|
753
|
+
"sasl": {
|
|
754
|
+
"scram": True,
|
|
755
|
+
},
|
|
756
|
+
},
|
|
757
|
+
},
|
|
758
|
+
},
|
|
759
|
+
},
|
|
760
|
+
client_authentication={
|
|
761
|
+
"sasl": {
|
|
762
|
+
"scram": True,
|
|
763
|
+
},
|
|
764
|
+
},
|
|
765
|
+
configuration_info={
|
|
766
|
+
"arn": example_configuration.arn,
|
|
767
|
+
"revision": example_configuration.latest_revision,
|
|
768
|
+
})
|
|
769
|
+
example_cluster_policy = aws.msk.ClusterPolicy("example",
|
|
770
|
+
cluster_arn=example.arn,
|
|
771
|
+
policy=pulumi.Output.json_dumps({
|
|
772
|
+
"Version": "2012-10-17",
|
|
773
|
+
"Statement": [{
|
|
774
|
+
"Effect": "Allow",
|
|
775
|
+
"Principal": {
|
|
776
|
+
"AWS": f"arn:aws:iam::{aws_account_id}:root",
|
|
777
|
+
},
|
|
778
|
+
"Action": [
|
|
779
|
+
"kafka:CreateVpcConnection",
|
|
780
|
+
"kafka:GetBootstrapBrokers",
|
|
781
|
+
"kafka:DescribeCluster",
|
|
782
|
+
"kafka:DescribeClusterV2",
|
|
783
|
+
],
|
|
784
|
+
"Resource": example.arn,
|
|
785
|
+
}],
|
|
786
|
+
}))
|
|
787
|
+
example_msk_single_scram_secret_association = aws.index.MskSingleScramSecretAssociation("example",
|
|
788
|
+
cluster_arn=example.arn,
|
|
789
|
+
secret_arn=aws_secret_arn)
|
|
790
|
+
test = mongodbatlas.StreamPrivatelinkEndpoint("test",
|
|
791
|
+
project_id=project_id,
|
|
792
|
+
provider_name="AWS",
|
|
793
|
+
vendor="MSK",
|
|
794
|
+
arn=example.arn)
|
|
795
|
+
singular_datasource = test.id.apply(lambda id: mongodbatlas.get_stream_privatelink_endpoint_output(project_id=project_id,
|
|
796
|
+
id=id))
|
|
797
|
+
pulumi.export("privatelinkEndpointId", singular_datasource.id)
|
|
798
|
+
```
|
|
799
|
+
|
|
610
800
|
### AWS S3 Privatelink
|
|
611
801
|
```python
|
|
612
802
|
import pulumi
|
|
@@ -614,20 +804,20 @@ class StreamPrivatelinkEndpoint(pulumi.CustomResource):
|
|
|
614
804
|
import pulumi_mongodbatlas as mongodbatlas
|
|
615
805
|
|
|
616
806
|
# S3 bucket for stream data
|
|
617
|
-
stream_bucket = aws.
|
|
807
|
+
stream_bucket = aws.s3.BucketV2("stream_bucket",
|
|
618
808
|
bucket=s3_bucket_name,
|
|
619
809
|
force_destroy=True)
|
|
620
|
-
stream_bucket_versioning = aws.
|
|
810
|
+
stream_bucket_versioning = aws.s3.BucketVersioningV2("stream_bucket_versioning",
|
|
621
811
|
bucket=stream_bucket.id,
|
|
622
|
-
versioning_configuration=
|
|
623
|
-
status: Enabled,
|
|
624
|
-
}
|
|
625
|
-
stream_bucket_encryption = aws.
|
|
812
|
+
versioning_configuration={
|
|
813
|
+
"status": "Enabled",
|
|
814
|
+
})
|
|
815
|
+
stream_bucket_encryption = aws.s3.BucketServerSideEncryptionConfigurationV2("stream_bucket_encryption",
|
|
626
816
|
bucket=stream_bucket.id,
|
|
627
|
-
|
|
628
|
-
|
|
629
|
-
|
|
630
|
-
}
|
|
817
|
+
rules=[{
|
|
818
|
+
"apply_server_side_encryption_by_default": {
|
|
819
|
+
"sse_algorithm": "AES256",
|
|
820
|
+
},
|
|
631
821
|
}])
|
|
632
822
|
# PrivateLink for S3
|
|
633
823
|
this = mongodbatlas.StreamPrivatelinkEndpoint("this",
|
{pulumi_mongodbatlas-3.38.0.dist-info → pulumi_mongodbatlas-3.38.0a1764802483.dist-info}/RECORD
RENAMED
|
@@ -136,8 +136,8 @@ pulumi_mongodbatlas/get_stream_connection.py,sha256=-MQni5uGdVGU0rzj6j7fpn59FIZw
|
|
|
136
136
|
pulumi_mongodbatlas/get_stream_connections.py,sha256=jEDwPPAgHND4d7iNesp2K9TAMrL-vCYF9gVzWhNpVT8,8848
|
|
137
137
|
pulumi_mongodbatlas/get_stream_instance.py,sha256=ct9jxsbKqq3yWJO4EYdhEMPMh27CgXUCydNAWncJ2_Y,7078
|
|
138
138
|
pulumi_mongodbatlas/get_stream_instances.py,sha256=jgWexdwePtqxKM9gX385CRAl8W8qWoZJbJgAcGDB-P4,7555
|
|
139
|
-
pulumi_mongodbatlas/get_stream_privatelink_endpoint.py,sha256=
|
|
140
|
-
pulumi_mongodbatlas/get_stream_privatelink_endpoints.py,sha256=
|
|
139
|
+
pulumi_mongodbatlas/get_stream_privatelink_endpoint.py,sha256=h_xs9KwIoViAbgCdwA9xIbcoakYbGxt2cLOIZbaCjqM,23494
|
|
140
|
+
pulumi_mongodbatlas/get_stream_privatelink_endpoints.py,sha256=JF-XQNOP6nSuY2GBsXUblOW3DwJzaJBGrBxQGvakSB8,17386
|
|
141
141
|
pulumi_mongodbatlas/get_stream_processor.py,sha256=55MJ2Br8zPmxDvz5o0i537oQlluCazD801MFVY733CM,17790
|
|
142
142
|
pulumi_mongodbatlas/get_stream_processors.py,sha256=5nS5w9BX_8UNJzPBExA5SfpfkNdPzFIejFjr3UfP8YQ,15558
|
|
143
143
|
pulumi_mongodbatlas/get_team.py,sha256=lhBgSvPyHPn4HIp9CJ0gdNdTARoodkUCLkTcGMCfAc8,7492
|
|
@@ -151,7 +151,7 @@ pulumi_mongodbatlas/ldap_verify.py,sha256=CJYQnjH7EMbOF63RUD4P1T3O1FoBTM_LduEj38
|
|
|
151
151
|
pulumi_mongodbatlas/maintenance_window.py,sha256=rOmaAOrFdYeSh7fqZ2KVP1M3R97bw5-biwwKMB2iSFg,33085
|
|
152
152
|
pulumi_mongodbatlas/mongodb_employee_access_grant.py,sha256=Ti7xvQEhG0Yirl_XBfcBOhBQ7gwaexzqYFQvBrT0erQ,17160
|
|
153
153
|
pulumi_mongodbatlas/network_container.py,sha256=-6zkFr-UQvrhmwerB70vqtYSEZ8POHBJPO7eiN0UtRk,45192
|
|
154
|
-
pulumi_mongodbatlas/network_peering.py,sha256
|
|
154
|
+
pulumi_mongodbatlas/network_peering.py,sha256=-BQVksa1_njbYrhAGXuqzD0a8e_sHtmsYkq-Y3B2qyc,72822
|
|
155
155
|
pulumi_mongodbatlas/online_archive.py,sha256=Jbwh9x1FHsvaPvj4PogVgDLE8NaHySLxyx08jIwNbpQ,50684
|
|
156
156
|
pulumi_mongodbatlas/org_invitation.py,sha256=s6H1Yd6JaqERSGie-Wjowlrf5mVDgZAURTAXhR7fTpA,24066
|
|
157
157
|
pulumi_mongodbatlas/organization.py,sha256=SgMmZJKZSB3vqM_YFqt5Z68dujqLu7jvd5gifa4PduU,52333
|
|
@@ -160,14 +160,14 @@ pulumi_mongodbatlas/private_endpoint_regional_mode.py,sha256=cDHd_QIqDWmO67Rfs0y
|
|
|
160
160
|
pulumi_mongodbatlas/private_link_endpoint.py,sha256=SqRoxBDWJVFb9Qp1bszSX_vDykEch89L_cd2_ILPZkU,37761
|
|
161
161
|
pulumi_mongodbatlas/private_link_endpoint_service.py,sha256=HE4iVV4g2fC3fMUeXlSvgHkrsxtbYwSTkiFT7h3AnZk,44785
|
|
162
162
|
pulumi_mongodbatlas/privatelink_endpoint_serverless.py,sha256=B8OPnpA4K6xkPs13VmFIorOFdUaqlPxAFQni67bC-64,20957
|
|
163
|
-
pulumi_mongodbatlas/privatelink_endpoint_service_data_federation_online_archive.py,sha256=
|
|
164
|
-
pulumi_mongodbatlas/privatelink_endpoint_service_serverless.py,sha256=
|
|
163
|
+
pulumi_mongodbatlas/privatelink_endpoint_service_data_federation_online_archive.py,sha256=gWhLBYFCsWCJkw3YYrlpwdw_cQyiemXSsU7rCezZnH4,29960
|
|
164
|
+
pulumi_mongodbatlas/privatelink_endpoint_service_serverless.py,sha256=XS7Zr6eOP7d1Y8RzyG0i6TLXosoNb3CcI0PKPaZudbM,34646
|
|
165
165
|
pulumi_mongodbatlas/project.py,sha256=5Q8WR6gP_8HTTMWVn77826PugZ0OGx5Y4Hm3vuQOydE,76830
|
|
166
166
|
pulumi_mongodbatlas/project_api_key.py,sha256=DK0_gCnhsAOnP-0aISkT8BSsSFgG0THbnHs2WiTk8-Y,15282
|
|
167
167
|
pulumi_mongodbatlas/project_invitation.py,sha256=7_iWdwTTXQeNbMloPO_4OifRHgunxxBlIy65PxwUZiw,20655
|
|
168
168
|
pulumi_mongodbatlas/project_ip_access_list.py,sha256=iSOnD8xdkKqUf75P-YTsyuy0-6FT11U98WQv5beFyIA,26352
|
|
169
169
|
pulumi_mongodbatlas/provider.py,sha256=2bPNbOwObGh3Zvz3kmciDnJ_c11rVDsFD4g8PuWv714,19506
|
|
170
|
-
pulumi_mongodbatlas/pulumi-plugin.json,sha256=
|
|
170
|
+
pulumi_mongodbatlas/pulumi-plugin.json,sha256=fOcWhSyeSlUqLOLcRRf-13K3UTcBYI7HqiOf4lhmcnc,89
|
|
171
171
|
pulumi_mongodbatlas/push_based_log_export.py,sha256=-Gwi1wu_O3P1lW3mwWdlwuFIHLR8eFPJ5oyvuM2BV2o,21265
|
|
172
172
|
pulumi_mongodbatlas/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
|
|
173
173
|
pulumi_mongodbatlas/resource_policy.py,sha256=L5IqgiGKcewRH77wzRC61kL-cLaIg_tMVFrUAmqPE9c,22227
|
|
@@ -176,7 +176,7 @@ pulumi_mongodbatlas/search_index.py,sha256=L60T9pmRTnE4WAIZxm9w2QNBarNM46S4K2BLi
|
|
|
176
176
|
pulumi_mongodbatlas/serverless_instance.py,sha256=62jH6vKbeEMRnqFq1BlykYoMtdFCS3_Bs6VL89bmRuM,52975
|
|
177
177
|
pulumi_mongodbatlas/stream_connection.py,sha256=UFZdMYJ6E_hY8MTJlAQzxcIY1LPbK2Qt9SsHZv9YPw0,41052
|
|
178
178
|
pulumi_mongodbatlas/stream_instance.py,sha256=kk-IjX_aha2dnv-Ou5I9DmDsZC9-0v98lzv0TSSR8Po,18796
|
|
179
|
-
pulumi_mongodbatlas/stream_privatelink_endpoint.py,sha256=
|
|
179
|
+
pulumi_mongodbatlas/stream_privatelink_endpoint.py,sha256=jDBTX1dqXoOySzDznMLYAhaPO04R4-t2cGOaZ5RvGvA,53536
|
|
180
180
|
pulumi_mongodbatlas/stream_processor.py,sha256=teYaQFaszuiFIwMMGLWZ0Tc6Up0oGYclXE3Or1Pq1N8,39114
|
|
181
181
|
pulumi_mongodbatlas/team.py,sha256=qtHZmdJ9p6opBQIIG1M7-Plijhbif154FFvTf49IxVk,15265
|
|
182
182
|
pulumi_mongodbatlas/teams.py,sha256=EKdg6mJA2ArVW6lbKBqczWgdhgokRq9RYqIgkbombls,9338
|
|
@@ -186,7 +186,7 @@ pulumi_mongodbatlas/config/__init__.py,sha256=XWnQfVtc2oPapjSXXCdORFJvMpXt_SMJQA
|
|
|
186
186
|
pulumi_mongodbatlas/config/__init__.pyi,sha256=d057LRRJlAV6LJioFARJUijAcx3sLU1LESy-IGvTOtE,1434
|
|
187
187
|
pulumi_mongodbatlas/config/outputs.py,sha256=-84DLvuMUnmGTcyI_2-gn4oBKqAhwe_kkFmAbBrvM7o,5634
|
|
188
188
|
pulumi_mongodbatlas/config/vars.py,sha256=OU9iGc_l9zQhyfV2XFoTq_ehX7Et01tE5jST4YF7ysA,2862
|
|
189
|
-
pulumi_mongodbatlas-3.38.
|
|
190
|
-
pulumi_mongodbatlas-3.38.
|
|
191
|
-
pulumi_mongodbatlas-3.38.
|
|
192
|
-
pulumi_mongodbatlas-3.38.
|
|
189
|
+
pulumi_mongodbatlas-3.38.0a1764802483.dist-info/METADATA,sha256=2JxVD5w8vxWQvvPX8HbWCOuWmBGYyGlCsCmoDL3zDh8,3015
|
|
190
|
+
pulumi_mongodbatlas-3.38.0a1764802483.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
|
|
191
|
+
pulumi_mongodbatlas-3.38.0a1764802483.dist-info/top_level.txt,sha256=eFnUToWzr-Um7_ot_nth2jQFq6sOE4j3xJ2j_evNMco,20
|
|
192
|
+
pulumi_mongodbatlas-3.38.0a1764802483.dist-info/RECORD,,
|
{pulumi_mongodbatlas-3.38.0.dist-info → pulumi_mongodbatlas-3.38.0a1764802483.dist-info}/WHEEL
RENAMED
|
File without changes
|
|
File without changes
|