pulumi-mongodbatlas 4.2.0a1769139905__tar.gz → 4.3.0__tar.gz

{pulumi_mongodbatlas-4.2.0a1769139905 → pulumi_mongodbatlas-4.3.0}/PKG-INFO

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

{pulumi_mongodbatlas-4.2.0a1769139905 → pulumi_mongodbatlas-4.3.0}/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.2.0a1769139905 → pulumi_mongodbatlas-4.3.0}/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.2.0a1769139905 → pulumi_mongodbatlas-4.3.0}/pulumi_mongodbatlas/alert_configuration.py

@@ -22,11 +22,11 @@ __all__ = ['AlertConfigurationArgs', 'AlertConfiguration']
 class AlertConfigurationArgs:
     def __init__(__self__, *,
                  event_type: pulumi.Input[_builtins.str],
+                 notifications: pulumi.Input[Sequence[pulumi.Input['AlertConfigurationNotificationArgs']]],
                  project_id: pulumi.Input[_builtins.str],
                  enabled: Optional[pulumi.Input[_builtins.bool]] = None,
                  matchers: Optional[pulumi.Input[Sequence[pulumi.Input['AlertConfigurationMatcherArgs']]]] = None,
                  metric_threshold_config: Optional[pulumi.Input['AlertConfigurationMetricThresholdConfigArgs']] = None,
-                 notifications: Optional[pulumi.Input[Sequence[pulumi.Input['AlertConfigurationNotificationArgs']]]] = None,
                  severity_override: Optional[pulumi.Input[_builtins.str]] = None,
                  threshold_config: Optional[pulumi.Input['AlertConfigurationThresholdConfigArgs']] = None):
         """
@@ -42,6 +42,7 @@ class AlertConfigurationArgs:
         :param pulumi.Input[_builtins.str] severity_override: Severity of the event. For the list of accepted values please read the [Create One Alert Configuration in One Project](https://www.mongodb.com/docs/api/doc/atlas-admin-api-v2/operation/operation-creategroupalertconfig) API documentation.
         """
         pulumi.set(__self__, "event_type", event_type)
+        pulumi.set(__self__, "notifications", notifications)
         pulumi.set(__self__, "project_id", project_id)
         if enabled is not None:
             pulumi.set(__self__, "enabled", enabled)
@@ -49,8 +50,6 @@ class AlertConfigurationArgs:
             pulumi.set(__self__, "matchers", matchers)
         if metric_threshold_config is not None:
             pulumi.set(__self__, "metric_threshold_config", metric_threshold_config)
-        if notifications is not None:
-            pulumi.set(__self__, "notifications", notifications)
         if severity_override is not None:
             pulumi.set(__self__, "severity_override", severity_override)
         if threshold_config is not None:
@@ -73,6 +72,15 @@ class AlertConfigurationArgs:
     def event_type(self, value: pulumi.Input[_builtins.str]):
         pulumi.set(self, "event_type", value)
 
+    @_builtins.property
+    @pulumi.getter
+    def notifications(self) -> pulumi.Input[Sequence[pulumi.Input['AlertConfigurationNotificationArgs']]]:
+        return pulumi.get(self, "notifications")
+
+    @notifications.setter
+    def notifications(self, value: pulumi.Input[Sequence[pulumi.Input['AlertConfigurationNotificationArgs']]]):
+        pulumi.set(self, "notifications", value)
+
     @_builtins.property
     @pulumi.getter(name="projectId")
     def project_id(self) -> pulumi.Input[_builtins.str]:
@@ -115,15 +123,6 @@ class AlertConfigurationArgs:
     def metric_threshold_config(self, value: Optional[pulumi.Input['AlertConfigurationMetricThresholdConfigArgs']]):
         pulumi.set(self, "metric_threshold_config", value)
 
-    @_builtins.property
-    @pulumi.getter
-    def notifications(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['AlertConfigurationNotificationArgs']]]]:
-        return pulumi.get(self, "notifications")
-
-    @notifications.setter
-    def notifications(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['AlertConfigurationNotificationArgs']]]]):
-        pulumi.set(self, "notifications", value)
-
     @_builtins.property
     @pulumi.getter(name="severityOverride")
     def severity_override(self) -> Optional[pulumi.Input[_builtins.str]]:
@@ -685,6 +684,8 @@ class AlertConfiguration(pulumi.CustomResource):
             __props__.__dict__["event_type"] = event_type
             __props__.__dict__["matchers"] = matchers
             __props__.__dict__["metric_threshold_config"] = metric_threshold_config
+            if notifications is None and not opts.urn:
+                raise TypeError("Missing required property 'notifications'")
             __props__.__dict__["notifications"] = notifications
             if project_id is None and not opts.urn:
                 raise TypeError("Missing required property 'project_id'")
@@ -801,7 +802,7 @@ class AlertConfiguration(pulumi.CustomResource):
 
     @_builtins.property
     @pulumi.getter
-    def notifications(self) -> pulumi.Output[Optional[Sequence['outputs.AlertConfigurationNotification']]]:
+    def notifications(self) -> pulumi.Output[Sequence['outputs.AlertConfigurationNotification']]:
         return pulumi.get(self, "notifications")
 
     @_builtins.property

{pulumi_mongodbatlas-4.2.0a1769139905 → pulumi_mongodbatlas-4.3.0}/pulumi_mongodbatlas/database_user.py

@@ -23,6 +23,7 @@ class DatabaseUserArgs:
     def __init__(__self__, *,
                  auth_database_name: pulumi.Input[_builtins.str],
                  project_id: pulumi.Input[_builtins.str],
+                 roles: pulumi.Input[Sequence[pulumi.Input['DatabaseUserRoleArgs']]],
                  username: pulumi.Input[_builtins.str],
                  aws_iam_type: Optional[pulumi.Input[_builtins.str]] = None,
                  description: Optional[pulumi.Input[_builtins.str]] = None,
@@ -30,7 +31,6 @@ class DatabaseUserArgs:
                  ldap_auth_type: Optional[pulumi.Input[_builtins.str]] = None,
                  oidc_auth_type: Optional[pulumi.Input[_builtins.str]] = None,
                  password: Optional[pulumi.Input[_builtins.str]] = None,
-                 roles: Optional[pulumi.Input[Sequence[pulumi.Input['DatabaseUserRoleArgs']]]] = None,
                  scopes: Optional[pulumi.Input[Sequence[pulumi.Input['DatabaseUserScopeArgs']]]] = None,
                  x509_type: Optional[pulumi.Input[_builtins.str]] = None):
         """
@@ -38,6 +38,7 @@ class DatabaseUserArgs:
         :param pulumi.Input[_builtins.str] auth_database_name: Database against which Atlas authenticates the user. A user must provide both a username and authentication database to log into MongoDB.
                Accepted values include:
         :param pulumi.Input[_builtins.str] project_id: The unique ID for the project to create the database user.
+        :param pulumi.Input[Sequence[pulumi.Input['DatabaseUserRoleArgs']]] roles: List of user’s roles and the databases / collections on which the roles apply. A role allows the user to perform particular actions on the specified database. A role on the admin database can include privileges that apply to the other databases as well. See Roles below for more details.
         :param pulumi.Input[_builtins.str] username: Username for authenticating to MongoDB. USER_ARN or ROLE_ARN if `aws_iam_type` is USER or ROLE.
         :param pulumi.Input[_builtins.str] aws_iam_type: If this value is set, the new database user authenticates with AWS IAM credentials. If no value is given, Atlas uses the default value of `NONE`. The accepted types are:
                * `NONE` -	The user does not use AWS IAM credentials.
@@ -52,7 +53,6 @@ class DatabaseUserArgs:
                * `NONE` -	The user does not use OIDC federated authentication.
                * `IDP_GROUP` - OIDC Workforce federated authentication group. To learn more about OIDC federated authentication, see [Set up Workforce Identity Federation with OIDC](https://www.mongodb.com/docs/atlas/security-oidc/).
                * `USER` - OIDC Workload federated authentication user. To learn more about OIDC federated authentication, see [Set up Workload Identity Federation with OIDC](https://www.mongodb.com/docs/atlas/security-oidc/).
-        :param pulumi.Input[Sequence[pulumi.Input['DatabaseUserRoleArgs']]] roles: List of user’s roles and the databases / collections on which the roles apply. A role allows the user to perform particular actions on the specified database. A role on the admin database can include privileges that apply to the other databases as well. See Roles below for more details.
         :param pulumi.Input[_builtins.str] x509_type: X.509 method by which the provided username is authenticated. If no value is given, Atlas uses the default value of NONE. The accepted types are:
                * `NONE` -	The user does not use X.509 authentication.
                * `MANAGED` - The user is being created for use with Atlas-managed X.509.Externally authenticated users can only be created on the `$external` database.
@@ -60,6 +60,7 @@ class DatabaseUserArgs:
         """
         pulumi.set(__self__, "auth_database_name", auth_database_name)
         pulumi.set(__self__, "project_id", project_id)
+        pulumi.set(__self__, "roles", roles)
         pulumi.set(__self__, "username", username)
         if aws_iam_type is not None:
             pulumi.set(__self__, "aws_iam_type", aws_iam_type)
@@ -73,8 +74,6 @@ class DatabaseUserArgs:
             pulumi.set(__self__, "oidc_auth_type", oidc_auth_type)
         if password is not None:
             pulumi.set(__self__, "password", password)
-        if roles is not None:
-            pulumi.set(__self__, "roles", roles)
         if scopes is not None:
             pulumi.set(__self__, "scopes", scopes)
         if x509_type is not None:
@@ -105,6 +104,18 @@ class DatabaseUserArgs:
     def project_id(self, value: pulumi.Input[_builtins.str]):
         pulumi.set(self, "project_id", value)
 
+    @_builtins.property
+    @pulumi.getter
+    def roles(self) -> pulumi.Input[Sequence[pulumi.Input['DatabaseUserRoleArgs']]]:
+        """
+        List of user’s roles and the databases / collections on which the roles apply. A role allows the user to perform particular actions on the specified database. A role on the admin database can include privileges that apply to the other databases as well. See Roles below for more details.
+        """
+        return pulumi.get(self, "roles")
+
+    @roles.setter
+    def roles(self, value: pulumi.Input[Sequence[pulumi.Input['DatabaseUserRoleArgs']]]):
+        pulumi.set(self, "roles", value)
+
     @_builtins.property
     @pulumi.getter
     def username(self) -> pulumi.Input[_builtins.str]:
@@ -192,18 +203,6 @@ class DatabaseUserArgs:
     def password(self, value: Optional[pulumi.Input[_builtins.str]]):
         pulumi.set(self, "password", value)
 
-    @_builtins.property
-    @pulumi.getter
-    def roles(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['DatabaseUserRoleArgs']]]]:
-        """
-        List of user’s roles and the databases / collections on which the roles apply. A role allows the user to perform particular actions on the specified database. A role on the admin database can include privileges that apply to the other databases as well. See Roles below for more details.
-        """
-        return pulumi.get(self, "roles")
-
-    @roles.setter
-    def roles(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['DatabaseUserRoleArgs']]]]):
-        pulumi.set(self, "roles", value)
-
     @_builtins.property
     @pulumi.getter
     def scopes(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['DatabaseUserScopeArgs']]]]:
@@ -811,6 +810,8 @@ class DatabaseUser(pulumi.CustomResource):
             if project_id is None and not opts.urn:
                 raise TypeError("Missing required property 'project_id'")
             __props__.__dict__["project_id"] = project_id
+            if roles is None and not opts.urn:
+                raise TypeError("Missing required property 'roles'")
             __props__.__dict__["roles"] = roles
             __props__.__dict__["scopes"] = scopes
             if username is None and not opts.urn:
@@ -959,7 +960,7 @@ class DatabaseUser(pulumi.CustomResource):
 
     @_builtins.property
     @pulumi.getter
-    def roles(self) -> pulumi.Output[Optional[Sequence['outputs.DatabaseUserRole']]]:
+    def roles(self) -> pulumi.Output[Sequence['outputs.DatabaseUserRole']]:
         """
         List of user’s roles and the databases / collections on which the roles apply. A role allows the user to perform particular actions on the specified database. A role on the admin database can include privileges that apply to the other databases as well. See Roles below for more details.
         """

{pulumi_mongodbatlas-4.2.0a1769139905 → pulumi_mongodbatlas-4.3.0}/pulumi_mongodbatlas/get_alert_configurations.py

@@ -111,6 +111,28 @@ def get_alert_configurations(list_options: Optional[Sequence[Union['GetAlertConf
 
     > **NOTE:** Groups and projects are synonymous terms. You may find group_id in the official documentation.
 
+    ## Example Usage
+
+    ```python
+    import pulumi
+    import pulumi_mongodbatlas as mongodbatlas
+    import pulumi_std as std
+
+    import_ = mongodbatlas.get_alert_configurations(project_id=project_id,
+        output_types=[
+            "resource_hcl",
+            "resource_import",
+        ])
+    alerts = import_.results
+    outputs = std.index.flatten(input=[[] if alert.output == None else alert.output for i, alert in alerts])["result"]
+    output_values = std.index.compact(input=[o["value"] for i, o in outputs])["result"]
+    pulumi.export("alertOutput", std.index.join(separator="\\n",
+        input=output_values)["result"])
+    ```
+
+    Refer to the following for a full example on using this data_source as a tool to import all resources:
+    * atlas-alert-configurations
+
 
     :param Sequence[Union['GetAlertConfigurationsListOptionArgs', 'GetAlertConfigurationsListOptionArgsDict']] list_options: Arguments that dictate how many and which results are returned by the data source
            * `list_options.page_num` - Which page of results to retrieve (default to first page)
@@ -142,6 +164,28 @@ def get_alert_configurations_output(list_options: Optional[pulumi.Input[Optional
 
     > **NOTE:** Groups and projects are synonymous terms. You may find group_id in the official documentation.
 
+    ## Example Usage
+
+    ```python
+    import pulumi
+    import pulumi_mongodbatlas as mongodbatlas
+    import pulumi_std as std
+
+    import_ = mongodbatlas.get_alert_configurations(project_id=project_id,
+        output_types=[
+            "resource_hcl",
+            "resource_import",
+        ])
+    alerts = import_.results
+    outputs = std.index.flatten(input=[[] if alert.output == None else alert.output for i, alert in alerts])["result"]
+    output_values = std.index.compact(input=[o["value"] for i, o in outputs])["result"]
+    pulumi.export("alertOutput", std.index.join(separator="\\n",
+        input=output_values)["result"])
+    ```
+
+    Refer to the following for a full example on using this data_source as a tool to import all resources:
+    * atlas-alert-configurations
+
 
     :param Sequence[Union['GetAlertConfigurationsListOptionArgs', 'GetAlertConfigurationsListOptionArgsDict']] list_options: Arguments that dictate how many and which results are returned by the data source
            * `list_options.page_num` - Which page of results to retrieve (default to first page)

pulumi_mongodbatlas-4.3.0/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')))