pulumi-mongodbatlas 4.3.0a1770157031__tar.gz → 4.3.0a1770264059__tar.gz

{pulumi_mongodbatlas-4.3.0a1770157031 → pulumi_mongodbatlas-4.3.0a1770264059}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pulumi_mongodbatlas
-Version: 4.3.0a1770157031
+Version: 4.3.0a1770264059
 Summary: A Pulumi package for creating and managing mongodbatlas cloud resources.
 License: Apache-2.0
 Project-URL: Homepage, https://pulumi.io

{pulumi_mongodbatlas-4.3.0a1770157031 → pulumi_mongodbatlas-4.3.0a1770264059}/pulumi_mongodbatlas/__init__.py

@@ -98,6 +98,8 @@ from .get_flex_snapshots import *
 from .get_global_cluster_config import *
 from .get_ldap_configuration import *
 from .get_ldap_verify import *
+from .get_log_integration import *
+from .get_log_integrations import *
 from .get_maintenance_window import *
 from .get_mongodb_employee_access_grant import *
 from .get_network_container import *
@@ -119,6 +121,7 @@ from .get_project_api_key import *
 from .get_project_api_keys import *
 from .get_project_invitation import *
 from .get_project_ip_access_list import *
+from .get_project_ip_access_lists import *
 from .get_project_ip_addresses import *
 from .get_project_service_account import *
 from .get_project_service_account_access_list_entries import *
@@ -165,6 +168,7 @@ from .get_x509_authentication_database_user import *
 from .global_cluster_config import *
 from .ldap_configuration import *
 from .ldap_verify import *
+from .log_integration import *
 from .maintenance_window import *
 from .mongodb_employee_access_grant import *
 from .network_container import *
@@ -487,6 +491,14 @@ _utilities.register(
    "mongodbatlas:index/ldapVerify:LdapVerify": "LdapVerify"
   }
  },
+ {
+  "pkg": "mongodbatlas",
+  "mod": "index/logIntegration",
+  "fqn": "pulumi_mongodbatlas",
+  "classes": {
+   "mongodbatlas:index/logIntegration:LogIntegration": "LogIntegration"
+  }
+ },
  {
   "pkg": "mongodbatlas",
   "mod": "index/maintenanceWindow",

{pulumi_mongodbatlas-4.3.0a1770157031 → pulumi_mongodbatlas-4.3.0a1770264059}/pulumi_mongodbatlas/_inputs.py

@@ -9729,10 +9729,6 @@ if not MYPY:
         """
         A string that can be [parsed as a duration](https://pkg.go.dev/time#ParseDuration) consisting of numbers and unit suffixes, such as "30s" or "2h45m". Valid time units are "s" (seconds), "m" (minutes), "h" (hours). Read operations occur during any refresh or planning operation when refresh is enabled.
         """
-        update: NotRequired[pulumi.Input[_builtins.str]]
-        """
-        A string that can be [parsed as a duration](https://pkg.go.dev/time#ParseDuration) consisting of numbers and unit suffixes, such as "30s" or "2h45m". Valid time units are "s" (seconds), "m" (minutes), "h" (hours).
-        """
 elif False:
     ProjectIpAccessListTimeoutsArgsDict: TypeAlias = Mapping[str, Any]
 
@@ -9740,19 +9736,15 @@ elif False:
 class ProjectIpAccessListTimeoutsArgs:
     def __init__(__self__, *,
                  delete: Optional[pulumi.Input[_builtins.str]] = None,
-                 read: Optional[pulumi.Input[_builtins.str]] = None,
-                 update: Optional[pulumi.Input[_builtins.str]] = None):
+                 read: Optional[pulumi.Input[_builtins.str]] = None):
         """
         :param pulumi.Input[_builtins.str] delete: A string that can be [parsed as a duration](https://pkg.go.dev/time#ParseDuration) consisting of numbers and unit suffixes, such as "30s" or "2h45m". Valid time units are "s" (seconds), "m" (minutes), "h" (hours). Setting a timeout for a Delete operation is only applicable if changes are saved into state before the destroy operation occurs.
         :param pulumi.Input[_builtins.str] read: A string that can be [parsed as a duration](https://pkg.go.dev/time#ParseDuration) consisting of numbers and unit suffixes, such as "30s" or "2h45m". Valid time units are "s" (seconds), "m" (minutes), "h" (hours). Read operations occur during any refresh or planning operation when refresh is enabled.
-        :param pulumi.Input[_builtins.str] update: A string that can be [parsed as a duration](https://pkg.go.dev/time#ParseDuration) consisting of numbers and unit suffixes, such as "30s" or "2h45m". Valid time units are "s" (seconds), "m" (minutes), "h" (hours).
         """
         if delete is not None:
             pulumi.set(__self__, "delete", delete)
         if read is not None:
             pulumi.set(__self__, "read", read)
-        if update is not None:
-            pulumi.set(__self__, "update", update)
 
     @_builtins.property
     @pulumi.getter
@@ -9778,18 +9770,6 @@ class ProjectIpAccessListTimeoutsArgs:
     def read(self, value: Optional[pulumi.Input[_builtins.str]]):
         pulumi.set(self, "read", value)
 
-    @_builtins.property
-    @pulumi.getter
-    def update(self) -> Optional[pulumi.Input[_builtins.str]]:
-        """
-        A string that can be [parsed as a duration](https://pkg.go.dev/time#ParseDuration) consisting of numbers and unit suffixes, such as "30s" or "2h45m". Valid time units are "s" (seconds), "m" (minutes), "h" (hours).
-        """
-        return pulumi.get(self, "update")
-
-    @update.setter
-    def update(self, value: Optional[pulumi.Input[_builtins.str]]):
-        pulumi.set(self, "update", value)
-
 
 if not MYPY:
     class ProjectIpAddressesArgsDict(TypedDict):

pulumi_mongodbatlas-4.3.0a1770264059/pulumi_mongodbatlas/get_log_integration.py

@@ -0,0 +1,270 @@
+# coding=utf-8
+# *** WARNING: this file was generated by pulumi-language-python. ***
+# *** Do not edit by hand unless you're certain you know what you are doing! ***
+
+import builtins as _builtins
+import warnings
+import sys
+import pulumi
+import pulumi.runtime
+from typing import Any, Mapping, Optional, Sequence, Union, overload
+if sys.version_info >= (3, 11):
+    from typing import NotRequired, TypedDict, TypeAlias
+else:
+    from typing_extensions import NotRequired, TypedDict, TypeAlias
+from . import _utilities
+
+__all__ = [
+    'GetLogIntegrationResult',
+    'AwaitableGetLogIntegrationResult',
+    'get_log_integration',
+    'get_log_integration_output',
+]
+
+@pulumi.output_type
+class GetLogIntegrationResult:
+    """
+    A collection of values returned by getLogIntegration.
+    """
+    def __init__(__self__, bucket_name=None, iam_role_id=None, id=None, integration_id=None, kms_key=None, log_types=None, prefix_path=None, project_id=None, type=None):
+        if bucket_name and not isinstance(bucket_name, str):
+            raise TypeError("Expected argument 'bucket_name' to be a str")
+        pulumi.set(__self__, "bucket_name", bucket_name)
+        if iam_role_id and not isinstance(iam_role_id, str):
+            raise TypeError("Expected argument 'iam_role_id' to be a str")
+        pulumi.set(__self__, "iam_role_id", iam_role_id)
+        if id and not isinstance(id, str):
+            raise TypeError("Expected argument 'id' to be a str")
+        pulumi.set(__self__, "id", id)
+        if integration_id and not isinstance(integration_id, str):
+            raise TypeError("Expected argument 'integration_id' to be a str")
+        pulumi.set(__self__, "integration_id", integration_id)
+        if kms_key and not isinstance(kms_key, str):
+            raise TypeError("Expected argument 'kms_key' to be a str")
+        pulumi.set(__self__, "kms_key", kms_key)
+        if log_types and not isinstance(log_types, list):
+            raise TypeError("Expected argument 'log_types' to be a list")
+        pulumi.set(__self__, "log_types", log_types)
+        if prefix_path and not isinstance(prefix_path, str):
+            raise TypeError("Expected argument 'prefix_path' to be a str")
+        pulumi.set(__self__, "prefix_path", prefix_path)
+        if project_id and not isinstance(project_id, str):
+            raise TypeError("Expected argument 'project_id' to be a str")
+        pulumi.set(__self__, "project_id", project_id)
+        if type and not isinstance(type, str):
+            raise TypeError("Expected argument 'type' to be a str")
+        pulumi.set(__self__, "type", type)
+
+    @_builtins.property
+    @pulumi.getter(name="bucketName")
+    def bucket_name(self) -> _builtins.str:
+        """
+        Human-readable label that identifies the S3 bucket name for storing log files.
+        """
+        return pulumi.get(self, "bucket_name")
+
+    @_builtins.property
+    @pulumi.getter(name="iamRoleId")
+    def iam_role_id(self) -> _builtins.str:
+        """
+        Unique 24-hexadecimal digit string that identifies the AWS IAM role that MongoDB Cloud uses to access your S3 bucket.
+        """
+        return pulumi.get(self, "iam_role_id")
+
+    @_builtins.property
+    @pulumi.getter
+    def id(self) -> _builtins.str:
+        """
+        The provider-assigned unique ID for this managed resource.
+        """
+        return pulumi.get(self, "id")
+
+    @_builtins.property
+    @pulumi.getter(name="integrationId")
+    def integration_id(self) -> _builtins.str:
+        """
+        Unique identifier of the log integration configuration.
+        """
+        return pulumi.get(self, "integration_id")
+
+    @_builtins.property
+    @pulumi.getter(name="kmsKey")
+    def kms_key(self) -> _builtins.str:
+        """
+        AWS KMS key ID or ARN for server-side encryption (optional). If not provided, uses bucket default encryption settings.
+        """
+        return pulumi.get(self, "kms_key")
+
+    @_builtins.property
+    @pulumi.getter(name="logTypes")
+    def log_types(self) -> Sequence[_builtins.str]:
+        """
+        Array of log types to export to S3. Valid values: MONGOD, MONGOS, MONGOD*AUDIT, MONGOS*AUDIT.
+        """
+        return pulumi.get(self, "log_types")
+
+    @_builtins.property
+    @pulumi.getter(name="prefixPath")
+    def prefix_path(self) -> _builtins.str:
+        """
+        S3 directory path prefix where the log files will be stored. MongoDB Cloud will add further sub-directories based on the log type.
+        """
+        return pulumi.get(self, "prefix_path")
+
+    @_builtins.property
+    @pulumi.getter(name="projectId")
+    def project_id(self) -> _builtins.str:
+        """
+        Unique 24-hexadecimal digit string that identifies your project.
+        """
+        return pulumi.get(self, "project_id")
+
+    @_builtins.property
+    @pulumi.getter
+    def type(self) -> _builtins.str:
+        """
+        Human-readable label that identifies the service to which you want to integrate with MongoDB Cloud. The value must match the log integration type.
+        """
+        return pulumi.get(self, "type")
+
+
+class AwaitableGetLogIntegrationResult(GetLogIntegrationResult):
+    # pylint: disable=using-constant-test
+    def __await__(self):
+        if False:
+            yield self
+        return GetLogIntegrationResult(
+            bucket_name=self.bucket_name,
+            iam_role_id=self.iam_role_id,
+            id=self.id,
+            integration_id=self.integration_id,
+            kms_key=self.kms_key,
+            log_types=self.log_types,
+            prefix_path=self.prefix_path,
+            project_id=self.project_id,
+            type=self.type)
+
+
+def get_log_integration(integration_id: Optional[_builtins.str] = None,
+                        project_id: Optional[_builtins.str] = None,
+                        opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetLogIntegrationResult:
+    """
+    `LogIntegration` describes the configuration for a log integration identified by its unique ID. Log integrations are managed at the project level and allow you to continually export `mongod`, `mongos`, and audit logs to an AWS S3 bucket with 1-minute log export intervals.
+
+    To use this data source, the requesting Service Account or API Key must have the Organization Owner or Project Owner role.
+
+    ## Example Usage
+
+    ```python
+    import pulumi
+    import pulumi_mongodbatlas as mongodbatlas
+
+    project = mongodbatlas.Project("project",
+        name=atlas_project_name,
+        org_id=atlas_org_id)
+    # Set up cloud provider access in Atlas using the created IAM role
+    setup_only = mongodbatlas.CloudProviderAccessSetup("setup_only",
+        project_id=project.id,
+        provider_name="AWS")
+    auth_role = mongodbatlas.CloudProviderAccessAuthorization("auth_role",
+        project_id=project.id,
+        role_id=setup_only.role_id,
+        aws={
+            "iam_assumed_role_arn": atlas_role["arn"],
+        })
+    # Set up log integration with authorized IAM role
+    example_log_integration = mongodbatlas.LogIntegration("example",
+        project_id=project.id,
+        bucket_name=log_bucket["bucket"],
+        iam_role_id=auth_role.role_id,
+        prefix_path="atlas-logs",
+        type="S3_LOG_EXPORT",
+        log_types=["MONGOD_AUDIT"])
+    example = mongodbatlas.get_log_integration_output(project_id=example_log_integration.project_id,
+        integration_id=example_log_integration.integration_id)
+    example_get_log_integrations = mongodbatlas.get_log_integrations_output(project_id=example_log_integration.project_id)
+    pulumi.export("logIntegrationBucketName", example.bucket_name)
+    pulumi.export("logIntegrationsResults", example_get_log_integrations.results)
+    ```
+
+
+    :param _builtins.str integration_id: Unique identifier of the log integration configuration.
+    :param _builtins.str project_id: Unique 24-hexadecimal digit string that identifies your project.
+    """
+    __args__ = dict()
+    __args__['integrationId'] = integration_id
+    __args__['projectId'] = project_id
+    opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
+    __ret__ = pulumi.runtime.invoke('mongodbatlas:index/getLogIntegration:getLogIntegration', __args__, opts=opts, typ=GetLogIntegrationResult).value
+
+    return AwaitableGetLogIntegrationResult(
+        bucket_name=pulumi.get(__ret__, 'bucket_name'),
+        iam_role_id=pulumi.get(__ret__, 'iam_role_id'),
+        id=pulumi.get(__ret__, 'id'),
+        integration_id=pulumi.get(__ret__, 'integration_id'),
+        kms_key=pulumi.get(__ret__, 'kms_key'),
+        log_types=pulumi.get(__ret__, 'log_types'),
+        prefix_path=pulumi.get(__ret__, 'prefix_path'),
+        project_id=pulumi.get(__ret__, 'project_id'),
+        type=pulumi.get(__ret__, 'type'))
+def get_log_integration_output(integration_id: Optional[pulumi.Input[_builtins.str]] = None,
+                               project_id: Optional[pulumi.Input[_builtins.str]] = None,
+                               opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[GetLogIntegrationResult]:
+    """
+    `LogIntegration` describes the configuration for a log integration identified by its unique ID. Log integrations are managed at the project level and allow you to continually export `mongod`, `mongos`, and audit logs to an AWS S3 bucket with 1-minute log export intervals.
+
+    To use this data source, the requesting Service Account or API Key must have the Organization Owner or Project Owner role.
+
+    ## Example Usage
+
+    ```python
+    import pulumi
+    import pulumi_mongodbatlas as mongodbatlas
+
+    project = mongodbatlas.Project("project",
+        name=atlas_project_name,
+        org_id=atlas_org_id)
+    # Set up cloud provider access in Atlas using the created IAM role
+    setup_only = mongodbatlas.CloudProviderAccessSetup("setup_only",
+        project_id=project.id,
+        provider_name="AWS")
+    auth_role = mongodbatlas.CloudProviderAccessAuthorization("auth_role",
+        project_id=project.id,
+        role_id=setup_only.role_id,
+        aws={
+            "iam_assumed_role_arn": atlas_role["arn"],
+        })
+    # Set up log integration with authorized IAM role
+    example_log_integration = mongodbatlas.LogIntegration("example",
+        project_id=project.id,
+        bucket_name=log_bucket["bucket"],
+        iam_role_id=auth_role.role_id,
+        prefix_path="atlas-logs",
+        type="S3_LOG_EXPORT",
+        log_types=["MONGOD_AUDIT"])
+    example = mongodbatlas.get_log_integration_output(project_id=example_log_integration.project_id,
+        integration_id=example_log_integration.integration_id)
+    example_get_log_integrations = mongodbatlas.get_log_integrations_output(project_id=example_log_integration.project_id)
+    pulumi.export("logIntegrationBucketName", example.bucket_name)
+    pulumi.export("logIntegrationsResults", example_get_log_integrations.results)
+    ```
+
+
+    :param _builtins.str integration_id: Unique identifier of the log integration configuration.
+    :param _builtins.str project_id: Unique 24-hexadecimal digit string that identifies your project.
+    """
+    __args__ = dict()
+    __args__['integrationId'] = integration_id
+    __args__['projectId'] = project_id
+    opts = pulumi.InvokeOutputOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
+    __ret__ = pulumi.runtime.invoke_output('mongodbatlas:index/getLogIntegration:getLogIntegration', __args__, opts=opts, typ=GetLogIntegrationResult)
+    return __ret__.apply(lambda __response__: GetLogIntegrationResult(
+        bucket_name=pulumi.get(__response__, 'bucket_name'),
+        iam_role_id=pulumi.get(__response__, 'iam_role_id'),
+        id=pulumi.get(__response__, 'id'),
+        integration_id=pulumi.get(__response__, 'integration_id'),
+        kms_key=pulumi.get(__response__, 'kms_key'),
+        log_types=pulumi.get(__response__, 'log_types'),
+        prefix_path=pulumi.get(__response__, 'prefix_path'),
+        project_id=pulumi.get(__response__, 'project_id'),
+        type=pulumi.get(__response__, 'type')))

pulumi_mongodbatlas-4.3.0a1770264059/pulumi_mongodbatlas/get_log_integrations.py

@@ -0,0 +1,203 @@
+# coding=utf-8
+# *** WARNING: this file was generated by pulumi-language-python. ***
+# *** Do not edit by hand unless you're certain you know what you are doing! ***
+
+import builtins as _builtins
+import warnings
+import sys
+import pulumi
+import pulumi.runtime
+from typing import Any, Mapping, Optional, Sequence, Union, overload
+if sys.version_info >= (3, 11):
+    from typing import NotRequired, TypedDict, TypeAlias
+else:
+    from typing_extensions import NotRequired, TypedDict, TypeAlias
+from . import _utilities
+from . import outputs
+
+__all__ = [
+    'GetLogIntegrationsResult',
+    'AwaitableGetLogIntegrationsResult',
+    'get_log_integrations',
+    'get_log_integrations_output',
+]
+
+@pulumi.output_type
+class GetLogIntegrationsResult:
+    """
+    A collection of values returned by getLogIntegrations.
+    """
+    def __init__(__self__, id=None, integration_type=None, project_id=None, results=None):
+        if id and not isinstance(id, str):
+            raise TypeError("Expected argument 'id' to be a str")
+        pulumi.set(__self__, "id", id)
+        if integration_type and not isinstance(integration_type, str):
+            raise TypeError("Expected argument 'integration_type' to be a str")
+        pulumi.set(__self__, "integration_type", integration_type)
+        if project_id and not isinstance(project_id, str):
+            raise TypeError("Expected argument 'project_id' to be a str")
+        pulumi.set(__self__, "project_id", project_id)
+        if results and not isinstance(results, list):
+            raise TypeError("Expected argument 'results' to be a list")
+        pulumi.set(__self__, "results", results)
+
+    @_builtins.property
+    @pulumi.getter
+    def id(self) -> _builtins.str:
+        """
+        The provider-assigned unique ID for this managed resource.
+        """
+        return pulumi.get(self, "id")
+
+    @_builtins.property
+    @pulumi.getter(name="integrationType")
+    def integration_type(self) -> Optional[_builtins.str]:
+        """
+        Optional filter by integration type (e.g., 'S3*LOG*EXPORT').
+        """
+        return pulumi.get(self, "integration_type")
+
+    @_builtins.property
+    @pulumi.getter(name="projectId")
+    def project_id(self) -> _builtins.str:
+        """
+        Unique 24-hexadecimal digit string that identifies your project.
+        """
+        return pulumi.get(self, "project_id")
+
+    @_builtins.property
+    @pulumi.getter
+    def results(self) -> Sequence['outputs.GetLogIntegrationsResultResult']:
+        """
+        List of returned documents that MongoDB Cloud provides when completing this request.
+        """
+        return pulumi.get(self, "results")
+
+
+class AwaitableGetLogIntegrationsResult(GetLogIntegrationsResult):
+    # pylint: disable=using-constant-test
+    def __await__(self):
+        if False:
+            yield self
+        return GetLogIntegrationsResult(
+            id=self.id,
+            integration_type=self.integration_type,
+            project_id=self.project_id,
+            results=self.results)
+
+
+def get_log_integrations(integration_type: Optional[_builtins.str] = None,
+                         project_id: Optional[_builtins.str] = None,
+                         opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetLogIntegrationsResult:
+    """
+    `get_log_integrations` returns all log integrations in a project. Log integrations allow you to continually export `mongod`, `mongos`, and audit logs to an AWS S3 bucket with 1-minute log export intervals.
+
+    To use this data source, the requesting Service Account or API Key must have the Organization Owner or Project Owner role.
+
+    ## Example Usage
+
+    ### S
+    ```python
+    import pulumi
+    import pulumi_mongodbatlas as mongodbatlas
+
+    project = mongodbatlas.Project("project",
+        name=atlas_project_name,
+        org_id=atlas_org_id)
+    # Set up cloud provider access in Atlas using the created IAM role
+    setup_only = mongodbatlas.CloudProviderAccessSetup("setup_only",
+        project_id=project.id,
+        provider_name="AWS")
+    auth_role = mongodbatlas.CloudProviderAccessAuthorization("auth_role",
+        project_id=project.id,
+        role_id=setup_only.role_id,
+        aws={
+            "iam_assumed_role_arn": atlas_role["arn"],
+        })
+    # Set up log integration with authorized IAM role
+    example_log_integration = mongodbatlas.LogIntegration("example",
+        project_id=project.id,
+        bucket_name=log_bucket["bucket"],
+        iam_role_id=auth_role.role_id,
+        prefix_path="atlas-logs",
+        type="S3_LOG_EXPORT",
+        log_types=["MONGOD_AUDIT"])
+    example = mongodbatlas.get_log_integration_output(project_id=example_log_integration.project_id,
+        integration_id=example_log_integration.integration_id)
+    example_get_log_integrations = mongodbatlas.get_log_integrations_output(project_id=example_log_integration.project_id)
+    pulumi.export("logIntegrationBucketName", example.bucket_name)
+    pulumi.export("logIntegrationsResults", example_get_log_integrations.results)
+    ```
+
+
+    :param _builtins.str integration_type: Optional filter by integration type (e.g., 'S3*LOG*EXPORT').
+    :param _builtins.str project_id: Unique 24-hexadecimal digit string that identifies your project.
+    """
+    __args__ = dict()
+    __args__['integrationType'] = integration_type
+    __args__['projectId'] = project_id
+    opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
+    __ret__ = pulumi.runtime.invoke('mongodbatlas:index/getLogIntegrations:getLogIntegrations', __args__, opts=opts, typ=GetLogIntegrationsResult).value
+
+    return AwaitableGetLogIntegrationsResult(
+        id=pulumi.get(__ret__, 'id'),
+        integration_type=pulumi.get(__ret__, 'integration_type'),
+        project_id=pulumi.get(__ret__, 'project_id'),
+        results=pulumi.get(__ret__, 'results'))
+def get_log_integrations_output(integration_type: Optional[pulumi.Input[Optional[_builtins.str]]] = None,
+                                project_id: Optional[pulumi.Input[_builtins.str]] = None,
+                                opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[GetLogIntegrationsResult]:
+    """
+    `get_log_integrations` returns all log integrations in a project. Log integrations allow you to continually export `mongod`, `mongos`, and audit logs to an AWS S3 bucket with 1-minute log export intervals.
+
+    To use this data source, the requesting Service Account or API Key must have the Organization Owner or Project Owner role.
+
+    ## Example Usage
+
+    ### S
+    ```python
+    import pulumi
+    import pulumi_mongodbatlas as mongodbatlas
+
+    project = mongodbatlas.Project("project",
+        name=atlas_project_name,
+        org_id=atlas_org_id)
+    # Set up cloud provider access in Atlas using the created IAM role
+    setup_only = mongodbatlas.CloudProviderAccessSetup("setup_only",
+        project_id=project.id,
+        provider_name="AWS")
+    auth_role = mongodbatlas.CloudProviderAccessAuthorization("auth_role",
+        project_id=project.id,
+        role_id=setup_only.role_id,
+        aws={
+            "iam_assumed_role_arn": atlas_role["arn"],
+        })
+    # Set up log integration with authorized IAM role
+    example_log_integration = mongodbatlas.LogIntegration("example",
+        project_id=project.id,
+        bucket_name=log_bucket["bucket"],
+        iam_role_id=auth_role.role_id,
+        prefix_path="atlas-logs",
+        type="S3_LOG_EXPORT",
+        log_types=["MONGOD_AUDIT"])
+    example = mongodbatlas.get_log_integration_output(project_id=example_log_integration.project_id,
+        integration_id=example_log_integration.integration_id)
+    example_get_log_integrations = mongodbatlas.get_log_integrations_output(project_id=example_log_integration.project_id)
+    pulumi.export("logIntegrationBucketName", example.bucket_name)
+    pulumi.export("logIntegrationsResults", example_get_log_integrations.results)
+    ```
+
+
+    :param _builtins.str integration_type: Optional filter by integration type (e.g., 'S3*LOG*EXPORT').
+    :param _builtins.str project_id: Unique 24-hexadecimal digit string that identifies your project.
+    """
+    __args__ = dict()
+    __args__['integrationType'] = integration_type
+    __args__['projectId'] = project_id
+    opts = pulumi.InvokeOutputOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
+    __ret__ = pulumi.runtime.invoke_output('mongodbatlas:index/getLogIntegrations:getLogIntegrations', __args__, opts=opts, typ=GetLogIntegrationsResult)
+    return __ret__.apply(lambda __response__: GetLogIntegrationsResult(
+        id=pulumi.get(__response__, 'id'),
+        integration_type=pulumi.get(__response__, 'integration_type'),
+        project_id=pulumi.get(__response__, 'project_id'),
+        results=pulumi.get(__response__, 'results')))