pulumi-oci 2.23.0a1738332002__py3-none-any.whl → 2.24.0__py3-none-any.whl

pulumi_oci/mysql/_inputs.py

@@ -41,6 +41,8 @@ __all__ = [
     'MysqlBackupDbSystemSnapshotEndpointArgsDict',
     'MysqlBackupDbSystemSnapshotMaintenanceArgs',
     'MysqlBackupDbSystemSnapshotMaintenanceArgsDict',
+    'MysqlBackupDbSystemSnapshotReadEndpointArgs',
+    'MysqlBackupDbSystemSnapshotReadEndpointArgsDict',
     'MysqlBackupDbSystemSnapshotSecureConnectionArgs',
     'MysqlBackupDbSystemSnapshotSecureConnectionArgsDict',
     'MysqlBackupDbSystemSnapshotSummaryArgs',
@@ -83,6 +85,8 @@ __all__ = [
     'MysqlDbSystemMaintenanceArgsDict',
     'MysqlDbSystemPointInTimeRecoveryDetailArgs',
     'MysqlDbSystemPointInTimeRecoveryDetailArgsDict',
+    'MysqlDbSystemReadEndpointArgs',
+    'MysqlDbSystemReadEndpointArgsDict',
     'MysqlDbSystemSecureConnectionsArgs',
     'MysqlDbSystemSecureConnectionsArgsDict',
     'MysqlDbSystemSourceArgs',
@@ -834,6 +838,10 @@ if not MYPY:
         """
         The network port on which X Plugin listens for TCP/IP connections. This is the X Plugin equivalent of port.
         """
+        read_endpoints: NotRequired[pulumi.Input[Sequence[pulumi.Input['MysqlBackupDbSystemSnapshotReadEndpointArgsDict']]]]
+        """
+        The read endpoint of a DB System.
+        """
         region: NotRequired[pulumi.Input[str]]
         """
         The region identifier of the region where the DB system exists. For more information, please see [Regions and Availability Domains](https://docs.oracle.com/en-us/iaas/Content/General/Concepts/regions.htm).
@@ -880,6 +888,7 @@ class MysqlBackupDbSystemSnapshotArgs:
                  mysql_version: Optional[pulumi.Input[str]] = None,
                  port: Optional[pulumi.Input[int]] = None,
                  port_x: Optional[pulumi.Input[int]] = None,
+                 read_endpoints: Optional[pulumi.Input[Sequence[pulumi.Input['MysqlBackupDbSystemSnapshotReadEndpointArgs']]]] = None,
                  region: Optional[pulumi.Input[str]] = None,
                  secure_connections: Optional[pulumi.Input[Sequence[pulumi.Input['MysqlBackupDbSystemSnapshotSecureConnectionArgs']]]] = None,
                  shape_name: Optional[pulumi.Input[str]] = None,
@@ -909,6 +918,7 @@ class MysqlBackupDbSystemSnapshotArgs:
         :param pulumi.Input[str] mysql_version: The MySQL server version of the DB System used for backup.
         :param pulumi.Input[int] port: The port for primary endpoint of the DB System to listen on.
         :param pulumi.Input[int] port_x: The network port on which X Plugin listens for TCP/IP connections. This is the X Plugin equivalent of port.
+        :param pulumi.Input[Sequence[pulumi.Input['MysqlBackupDbSystemSnapshotReadEndpointArgs']]] read_endpoints: The read endpoint of a DB System.
         :param pulumi.Input[str] region: The region identifier of the region where the DB system exists. For more information, please see [Regions and Availability Domains](https://docs.oracle.com/en-us/iaas/Content/General/Concepts/regions.htm).
         :param pulumi.Input[Sequence[pulumi.Input['MysqlBackupDbSystemSnapshotSecureConnectionArgs']]] secure_connections: Secure connection configuration details.
         :param pulumi.Input[str] shape_name: The shape of the DB System instance used for backup.
@@ -962,6 +972,8 @@ class MysqlBackupDbSystemSnapshotArgs:
             pulumi.set(__self__, "port", port)
         if port_x is not None:
             pulumi.set(__self__, "port_x", port_x)
+        if read_endpoints is not None:
+            pulumi.set(__self__, "read_endpoints", read_endpoints)
         if region is not None:
             pulumi.set(__self__, "region", region)
         if secure_connections is not None:
@@ -1259,6 +1271,18 @@ class MysqlBackupDbSystemSnapshotArgs:
     def port_x(self, value: Optional[pulumi.Input[int]]):
         pulumi.set(self, "port_x", value)
 
+    @property
+    @pulumi.getter(name="readEndpoints")
+    def read_endpoints(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['MysqlBackupDbSystemSnapshotReadEndpointArgs']]]]:
+        """
+        The read endpoint of a DB System.
+        """
+        return pulumi.get(self, "read_endpoints")
+
+    @read_endpoints.setter
+    def read_endpoints(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['MysqlBackupDbSystemSnapshotReadEndpointArgs']]]]):
+        pulumi.set(self, "read_endpoints", value)
+
     @property
     @pulumi.getter
     def region(self) -> Optional[pulumi.Input[str]]:
@@ -1320,7 +1344,7 @@ if not MYPY:
         """
         is_enabled: NotRequired[pulumi.Input[bool]]
         """
-        Specifies if PITR is enabled or disabled.
+        Specifies if the DB System read endpoint is enabled or not.
         """
         pitr_policies: NotRequired[pulumi.Input[Sequence[pulumi.Input['MysqlBackupDbSystemSnapshotBackupPolicyPitrPolicyArgsDict']]]]
         """
@@ -1349,7 +1373,7 @@ class MysqlBackupDbSystemSnapshotBackupPolicyArgs:
         """
         :param pulumi.Input[Mapping[str, pulumi.Input[str]]] defined_tags: (Updatable) Defined tags for this resource. Each key is predefined and scoped to a namespace. Example: `{"foo-namespace.bar-key": "value"}`
         :param pulumi.Input[Mapping[str, pulumi.Input[str]]] freeform_tags: (Updatable) Simple key-value pair that is applied without any predefined name, type or scope. Exists for cross-compatibility only. Example: `{"bar-key": "value"}`
-        :param pulumi.Input[bool] is_enabled: Specifies if PITR is enabled or disabled.
+        :param pulumi.Input[bool] is_enabled: Specifies if the DB System read endpoint is enabled or not.
         :param pulumi.Input[Sequence[pulumi.Input['MysqlBackupDbSystemSnapshotBackupPolicyPitrPolicyArgs']]] pitr_policies: The PITR policy for the DB System.
         :param pulumi.Input[int] retention_in_days: (Updatable) Number of days to retain this backup.
         :param pulumi.Input[str] window_start_time: The start time of the maintenance window.
@@ -1395,7 +1419,7 @@ class MysqlBackupDbSystemSnapshotBackupPolicyArgs:
     @pulumi.getter(name="isEnabled")
     def is_enabled(self) -> Optional[pulumi.Input[bool]]:
         """
-        Specifies if PITR is enabled or disabled.
+        Specifies if the DB System read endpoint is enabled or not.
         """
         return pulumi.get(self, "is_enabled")
 
@@ -1444,7 +1468,7 @@ if not MYPY:
     class MysqlBackupDbSystemSnapshotBackupPolicyPitrPolicyArgsDict(TypedDict):
         is_enabled: NotRequired[pulumi.Input[bool]]
         """
-        Specifies if PITR is enabled or disabled.
+        Specifies if the DB System read endpoint is enabled or not.
         """
 elif False:
     MysqlBackupDbSystemSnapshotBackupPolicyPitrPolicyArgsDict: TypeAlias = Mapping[str, Any]
@@ -1454,7 +1478,7 @@ class MysqlBackupDbSystemSnapshotBackupPolicyPitrPolicyArgs:
     def __init__(__self__, *,
                  is_enabled: Optional[pulumi.Input[bool]] = None):
         """
-        :param pulumi.Input[bool] is_enabled: Specifies if PITR is enabled or disabled.
+        :param pulumi.Input[bool] is_enabled: Specifies if the DB System read endpoint is enabled or not.
         """
         if is_enabled is not None:
             pulumi.set(__self__, "is_enabled", is_enabled)
@@ -1463,7 +1487,7 @@ class MysqlBackupDbSystemSnapshotBackupPolicyPitrPolicyArgs:
     @pulumi.getter(name="isEnabled")
     def is_enabled(self) -> Optional[pulumi.Input[bool]]:
         """
-        Specifies if PITR is enabled or disabled.
+        Specifies if the DB System read endpoint is enabled or not.
         """
         return pulumi.get(self, "is_enabled")
 
@@ -1880,6 +1904,98 @@ class MysqlBackupDbSystemSnapshotMaintenanceArgs:
         pulumi.set(self, "window_start_time", value)
 
 
+if not MYPY:
+    class MysqlBackupDbSystemSnapshotReadEndpointArgsDict(TypedDict):
+        exclude_ips: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
+        """
+        A list of IP addresses of read replicas that are excluded from serving read requests.
+        """
+        is_enabled: NotRequired[pulumi.Input[bool]]
+        """
+        Specifies if the DB System read endpoint is enabled or not.
+        """
+        read_endpoint_hostname_label: NotRequired[pulumi.Input[str]]
+        """
+        The hostname for the read endpoint of the DB System. Used for DNS.
+        """
+        read_endpoint_ip_address: NotRequired[pulumi.Input[str]]
+        """
+        The IP address the DB System read endpoint is configured to listen on. A private IP address of your choice to assign to the read endpoint of the DB System. Must be an available IP address within the subnet's CIDR. If you don't specify a value, Oracle automatically assigns a private IP address from the subnet. This should be a "dotted-quad" style IPv4 address.
+        """
+elif False:
+    MysqlBackupDbSystemSnapshotReadEndpointArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class MysqlBackupDbSystemSnapshotReadEndpointArgs:
+    def __init__(__self__, *,
+                 exclude_ips: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
+                 is_enabled: Optional[pulumi.Input[bool]] = None,
+                 read_endpoint_hostname_label: Optional[pulumi.Input[str]] = None,
+                 read_endpoint_ip_address: Optional[pulumi.Input[str]] = None):
+        """
+        :param pulumi.Input[Sequence[pulumi.Input[str]]] exclude_ips: A list of IP addresses of read replicas that are excluded from serving read requests.
+        :param pulumi.Input[bool] is_enabled: Specifies if the DB System read endpoint is enabled or not.
+        :param pulumi.Input[str] read_endpoint_hostname_label: The hostname for the read endpoint of the DB System. Used for DNS.
+        :param pulumi.Input[str] read_endpoint_ip_address: The IP address the DB System read endpoint is configured to listen on. A private IP address of your choice to assign to the read endpoint of the DB System. Must be an available IP address within the subnet's CIDR. If you don't specify a value, Oracle automatically assigns a private IP address from the subnet. This should be a "dotted-quad" style IPv4 address.
+        """
+        if exclude_ips is not None:
+            pulumi.set(__self__, "exclude_ips", exclude_ips)
+        if is_enabled is not None:
+            pulumi.set(__self__, "is_enabled", is_enabled)
+        if read_endpoint_hostname_label is not None:
+            pulumi.set(__self__, "read_endpoint_hostname_label", read_endpoint_hostname_label)
+        if read_endpoint_ip_address is not None:
+            pulumi.set(__self__, "read_endpoint_ip_address", read_endpoint_ip_address)
+
+    @property
+    @pulumi.getter(name="excludeIps")
+    def exclude_ips(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
+        """
+        A list of IP addresses of read replicas that are excluded from serving read requests.
+        """
+        return pulumi.get(self, "exclude_ips")
+
+    @exclude_ips.setter
+    def exclude_ips(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
+        pulumi.set(self, "exclude_ips", value)
+
+    @property
+    @pulumi.getter(name="isEnabled")
+    def is_enabled(self) -> Optional[pulumi.Input[bool]]:
+        """
+        Specifies if the DB System read endpoint is enabled or not.
+        """
+        return pulumi.get(self, "is_enabled")
+
+    @is_enabled.setter
+    def is_enabled(self, value: Optional[pulumi.Input[bool]]):
+        pulumi.set(self, "is_enabled", value)
+
+    @property
+    @pulumi.getter(name="readEndpointHostnameLabel")
+    def read_endpoint_hostname_label(self) -> Optional[pulumi.Input[str]]:
+        """
+        The hostname for the read endpoint of the DB System. Used for DNS.
+        """
+        return pulumi.get(self, "read_endpoint_hostname_label")
+
+    @read_endpoint_hostname_label.setter
+    def read_endpoint_hostname_label(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "read_endpoint_hostname_label", value)
+
+    @property
+    @pulumi.getter(name="readEndpointIpAddress")
+    def read_endpoint_ip_address(self) -> Optional[pulumi.Input[str]]:
+        """
+        The IP address the DB System read endpoint is configured to listen on. A private IP address of your choice to assign to the read endpoint of the DB System. Must be an available IP address within the subnet's CIDR. If you don't specify a value, Oracle automatically assigns a private IP address from the subnet. This should be a "dotted-quad" style IPv4 address.
+        """
+        return pulumi.get(self, "read_endpoint_ip_address")
+
+    @read_endpoint_ip_address.setter
+    def read_endpoint_ip_address(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "read_endpoint_ip_address", value)
+
+
 if not MYPY:
     class MysqlBackupDbSystemSnapshotSecureConnectionArgsDict(TypedDict):
         certificate_generation_type: NotRequired[pulumi.Input[str]]
@@ -4243,7 +4359,7 @@ if not MYPY:
         """
         is_enabled: NotRequired[pulumi.Input[bool]]
         """
-        Whether the Channel has been enabled by the user.
+        Specifies if the DB System read endpoint is enabled or not.
         """
         lifecycle_details: NotRequired[pulumi.Input[str]]
         """
@@ -4293,7 +4409,7 @@ class MysqlDbSystemChannelArgs:
         :param pulumi.Input[str] display_name: (Updatable) The user-friendly name for the DB System. It does not have to be unique.
         :param pulumi.Input[Mapping[str, pulumi.Input[str]]] freeform_tags: (Updatable) Simple key-value pair applied without any predefined name, type or scope. Exists for cross-compatibility only. Example: `{"bar-key": "value"}`
         :param pulumi.Input[str] id: The OCID of the DB System.
-        :param pulumi.Input[bool] is_enabled: Whether the Channel has been enabled by the user.
+        :param pulumi.Input[bool] is_enabled: Specifies if the DB System read endpoint is enabled or not.
         :param pulumi.Input[str] lifecycle_details: Additional information about the current lifecycleState.
         :param pulumi.Input[Sequence[pulumi.Input['MysqlDbSystemChannelSourceArgs']]] sources: Parameters detailing how to provision the initial data of the system.
         :param pulumi.Input[str] state: (Updatable) The target state for the DB System. Could be set to `ACTIVE` or `INACTIVE`.
@@ -4390,7 +4506,7 @@ class MysqlDbSystemChannelArgs:
     @pulumi.getter(name="isEnabled")
     def is_enabled(self) -> Optional[pulumi.Input[bool]]:
         """
-        Whether the Channel has been enabled by the user.
+        Specifies if the DB System read endpoint is enabled or not.
         """
         return pulumi.get(self, "is_enabled")
 
@@ -5708,6 +5824,110 @@ class MysqlDbSystemPointInTimeRecoveryDetailArgs:
         pulumi.set(self, "time_latest_recovery_point", value)
 
 
+if not MYPY:
+    class MysqlDbSystemReadEndpointArgsDict(TypedDict):
+        exclude_ips: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
+        """
+        (Updatable) A list of IP addresses of read replicas that are excluded from serving read requests.
+        """
+        is_enabled: NotRequired[pulumi.Input[bool]]
+        """
+        (Updatable) Specifies if the DB System read endpoint is enabled or not.
+        """
+        read_endpoint_hostname_label: NotRequired[pulumi.Input[str]]
+        """
+        (Updatable) The hostname for the read endpoint of the DB System. Used for DNS.
+
+        The value is the hostname portion of the primary private IP's fully qualified domain name (FQDN)  (for example, "dbsystem-1" in FQDN "dbsystem-1.subnet123.vcn1.oraclevcn.com").
+
+        Must be unique across all VNICs in the subnet and comply with RFC 952 and RFC 1123.
+        """
+        read_endpoint_ip_address: NotRequired[pulumi.Input[str]]
+        """
+        (Updatable) The IP address the DB System read endpoint is configured to listen on. A private IP address of your choice to assign to the read endpoint of the DB System. Must be an available IP address within the subnet's CIDR. If you don't specify a value, Oracle automatically assigns a private IP address from the subnet. This should be a "dotted-quad" style IPv4 address.
+        """
+elif False:
+    MysqlDbSystemReadEndpointArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class MysqlDbSystemReadEndpointArgs:
+    def __init__(__self__, *,
+                 exclude_ips: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
+                 is_enabled: Optional[pulumi.Input[bool]] = None,
+                 read_endpoint_hostname_label: Optional[pulumi.Input[str]] = None,
+                 read_endpoint_ip_address: Optional[pulumi.Input[str]] = None):
+        """
+        :param pulumi.Input[Sequence[pulumi.Input[str]]] exclude_ips: (Updatable) A list of IP addresses of read replicas that are excluded from serving read requests.
+        :param pulumi.Input[bool] is_enabled: (Updatable) Specifies if the DB System read endpoint is enabled or not.
+        :param pulumi.Input[str] read_endpoint_hostname_label: (Updatable) The hostname for the read endpoint of the DB System. Used for DNS.
+               
+               The value is the hostname portion of the primary private IP's fully qualified domain name (FQDN)  (for example, "dbsystem-1" in FQDN "dbsystem-1.subnet123.vcn1.oraclevcn.com").
+               
+               Must be unique across all VNICs in the subnet and comply with RFC 952 and RFC 1123.
+        :param pulumi.Input[str] read_endpoint_ip_address: (Updatable) The IP address the DB System read endpoint is configured to listen on. A private IP address of your choice to assign to the read endpoint of the DB System. Must be an available IP address within the subnet's CIDR. If you don't specify a value, Oracle automatically assigns a private IP address from the subnet. This should be a "dotted-quad" style IPv4 address.
+        """
+        if exclude_ips is not None:
+            pulumi.set(__self__, "exclude_ips", exclude_ips)
+        if is_enabled is not None:
+            pulumi.set(__self__, "is_enabled", is_enabled)
+        if read_endpoint_hostname_label is not None:
+            pulumi.set(__self__, "read_endpoint_hostname_label", read_endpoint_hostname_label)
+        if read_endpoint_ip_address is not None:
+            pulumi.set(__self__, "read_endpoint_ip_address", read_endpoint_ip_address)
+
+    @property
+    @pulumi.getter(name="excludeIps")
+    def exclude_ips(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
+        """
+        (Updatable) A list of IP addresses of read replicas that are excluded from serving read requests.
+        """
+        return pulumi.get(self, "exclude_ips")
+
+    @exclude_ips.setter
+    def exclude_ips(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
+        pulumi.set(self, "exclude_ips", value)
+
+    @property
+    @pulumi.getter(name="isEnabled")
+    def is_enabled(self) -> Optional[pulumi.Input[bool]]:
+        """
+        (Updatable) Specifies if the DB System read endpoint is enabled or not.
+        """
+        return pulumi.get(self, "is_enabled")
+
+    @is_enabled.setter
+    def is_enabled(self, value: Optional[pulumi.Input[bool]]):
+        pulumi.set(self, "is_enabled", value)
+
+    @property
+    @pulumi.getter(name="readEndpointHostnameLabel")
+    def read_endpoint_hostname_label(self) -> Optional[pulumi.Input[str]]:
+        """
+        (Updatable) The hostname for the read endpoint of the DB System. Used for DNS.
+
+        The value is the hostname portion of the primary private IP's fully qualified domain name (FQDN)  (for example, "dbsystem-1" in FQDN "dbsystem-1.subnet123.vcn1.oraclevcn.com").
+
+        Must be unique across all VNICs in the subnet and comply with RFC 952 and RFC 1123.
+        """
+        return pulumi.get(self, "read_endpoint_hostname_label")
+
+    @read_endpoint_hostname_label.setter
+    def read_endpoint_hostname_label(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "read_endpoint_hostname_label", value)
+
+    @property
+    @pulumi.getter(name="readEndpointIpAddress")
+    def read_endpoint_ip_address(self) -> Optional[pulumi.Input[str]]:
+        """
+        (Updatable) The IP address the DB System read endpoint is configured to listen on. A private IP address of your choice to assign to the read endpoint of the DB System. Must be an available IP address within the subnet's CIDR. If you don't specify a value, Oracle automatically assigns a private IP address from the subnet. This should be a "dotted-quad" style IPv4 address.
+        """
+        return pulumi.get(self, "read_endpoint_ip_address")
+
+    @read_endpoint_ip_address.setter
+    def read_endpoint_ip_address(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "read_endpoint_ip_address", value)
+
+
 if not MYPY:
     class MysqlDbSystemSecureConnectionsArgsDict(TypedDict):
         certificate_generation_type: pulumi.Input[str]

pulumi_oci/mysql/get_mysql_db_system.py

@@ -27,7 +27,10 @@ class GetMysqlDbSystemResult:
     """
     A collection of values returned by getMysqlDbSystem.
     """
-    def __init__(__self__, admin_password=None, admin_username=None, availability_domain=None, backup_policies=None, channels=None, compartment_id=None, configuration_id=None, crash_recovery=None, current_placements=None, customer_contacts=None, data_storage_size_in_gb=None, data_storages=None, database_management=None, db_system_id=None, defined_tags=None, deletion_policies=None, description=None, display_name=None, endpoints=None, fault_domain=None, freeform_tags=None, heat_wave_clusters=None, hostname_label=None, id=None, ip_address=None, is_heat_wave_cluster_attached=None, is_highly_available=None, lifecycle_details=None, maintenances=None, mysql_version=None, point_in_time_recovery_details=None, port=None, port_x=None, secure_connections=None, shape_name=None, shutdown_type=None, sources=None, state=None, subnet_id=None, time_created=None, time_updated=None):
+    def __init__(__self__, access_mode=None, admin_password=None, admin_username=None, availability_domain=None, backup_policies=None, channels=None, compartment_id=None, configuration_id=None, crash_recovery=None, current_placements=None, customer_contacts=None, data_storage_size_in_gb=None, data_storages=None, database_management=None, database_mode=None, db_system_id=None, defined_tags=None, deletion_policies=None, description=None, display_name=None, endpoints=None, fault_domain=None, freeform_tags=None, heat_wave_clusters=None, hostname_label=None, id=None, ip_address=None, is_heat_wave_cluster_attached=None, is_highly_available=None, lifecycle_details=None, maintenances=None, mysql_version=None, point_in_time_recovery_details=None, port=None, port_x=None, read_endpoints=None, secure_connections=None, shape_name=None, shutdown_type=None, sources=None, state=None, subnet_id=None, time_created=None, time_updated=None):
+        if access_mode and not isinstance(access_mode, str):
+            raise TypeError("Expected argument 'access_mode' to be a str")
+        pulumi.set(__self__, "access_mode", access_mode)
         if admin_password and not isinstance(admin_password, str):
             raise TypeError("Expected argument 'admin_password' to be a str")
         pulumi.set(__self__, "admin_password", admin_password)
@@ -67,6 +70,9 @@ class GetMysqlDbSystemResult:
         if database_management and not isinstance(database_management, str):
             raise TypeError("Expected argument 'database_management' to be a str")
         pulumi.set(__self__, "database_management", database_management)
+        if database_mode and not isinstance(database_mode, str):
+            raise TypeError("Expected argument 'database_mode' to be a str")
+        pulumi.set(__self__, "database_mode", database_mode)
         if db_system_id and not isinstance(db_system_id, str):
             raise TypeError("Expected argument 'db_system_id' to be a str")
         pulumi.set(__self__, "db_system_id", db_system_id)
@@ -127,6 +133,9 @@ class GetMysqlDbSystemResult:
         if port_x and not isinstance(port_x, int):
             raise TypeError("Expected argument 'port_x' to be a int")
         pulumi.set(__self__, "port_x", port_x)
+        if read_endpoints and not isinstance(read_endpoints, list):
+            raise TypeError("Expected argument 'read_endpoints' to be a list")
+        pulumi.set(__self__, "read_endpoints", read_endpoints)
         if secure_connections and not isinstance(secure_connections, list):
             raise TypeError("Expected argument 'secure_connections' to be a list")
         pulumi.set(__self__, "secure_connections", secure_connections)
@@ -152,6 +161,16 @@ class GetMysqlDbSystemResult:
             raise TypeError("Expected argument 'time_updated' to be a str")
         pulumi.set(__self__, "time_updated", time_updated)
 
+    @property
+    @pulumi.getter(name="accessMode")
+    def access_mode(self) -> str:
+        """
+        The access mode indicating if the database access is unrestricted (to all MySQL user accounts),  or restricted (to only certain users with specific privileges):
+        * UNRESTRICTED: the access to the database is not restricted;
+        * RESTRICTED: the access is allowed only to users with specific privileges;  RESTRICTED will correspond to setting the MySQL system variable  [offline_mode](https://dev.mysql.com/doc/en/server-system-variables.html#sysvar_offline_mode) to ON.
+        """
+        return pulumi.get(self, "access_mode")
+
     @property
     @pulumi.getter(name="adminPassword")
     def admin_password(self) -> str:
@@ -250,6 +269,16 @@ class GetMysqlDbSystemResult:
         """
         return pulumi.get(self, "database_management")
 
+    @property
+    @pulumi.getter(name="databaseMode")
+    def database_mode(self) -> str:
+        """
+        The database mode indicating the types of statements that are allowed to run in the the DB system. This mode applies only to statements run by user connections. Replicated write statements continue  to be allowed regardless of the DatabaseMode.
+        * READ_WRITE: allow running read and write statements on the DB system;
+        * READ_ONLY: only allow running read statements on the DB system.
+        """
+        return pulumi.get(self, "database_mode")
+
     @property
     @pulumi.getter(name="dbSystemId")
     def db_system_id(self) -> str:
@@ -410,6 +439,14 @@ class GetMysqlDbSystemResult:
         """
         return pulumi.get(self, "port_x")
 
+    @property
+    @pulumi.getter(name="readEndpoints")
+    def read_endpoints(self) -> Sequence['outputs.GetMysqlDbSystemReadEndpointResult']:
+        """
+        The read endpoint of a DB System.
+        """
+        return pulumi.get(self, "read_endpoints")
+
     @property
     @pulumi.getter(name="secureConnections")
     def secure_connections(self) -> Sequence['outputs.GetMysqlDbSystemSecureConnectionResult']:
@@ -478,6 +515,7 @@ class AwaitableGetMysqlDbSystemResult(GetMysqlDbSystemResult):
         if False:
             yield self
         return GetMysqlDbSystemResult(
+            access_mode=self.access_mode,
             admin_password=self.admin_password,
             admin_username=self.admin_username,
             availability_domain=self.availability_domain,
@@ -491,6 +529,7 @@ class AwaitableGetMysqlDbSystemResult(GetMysqlDbSystemResult):
             data_storage_size_in_gb=self.data_storage_size_in_gb,
             data_storages=self.data_storages,
             database_management=self.database_management,
+            database_mode=self.database_mode,
             db_system_id=self.db_system_id,
             defined_tags=self.defined_tags,
             deletion_policies=self.deletion_policies,
@@ -511,6 +550,7 @@ class AwaitableGetMysqlDbSystemResult(GetMysqlDbSystemResult):
             point_in_time_recovery_details=self.point_in_time_recovery_details,
             port=self.port,
             port_x=self.port_x,
+            read_endpoints=self.read_endpoints,
             secure_connections=self.secure_connections,
             shape_name=self.shape_name,
             shutdown_type=self.shutdown_type,
@@ -546,6 +586,7 @@ def get_mysql_db_system(db_system_id: Optional[str] = None,
     __ret__ = pulumi.runtime.invoke('oci:Mysql/getMysqlDbSystem:getMysqlDbSystem', __args__, opts=opts, typ=GetMysqlDbSystemResult).value
 
     return AwaitableGetMysqlDbSystemResult(
+        access_mode=pulumi.get(__ret__, 'access_mode'),
         admin_password=pulumi.get(__ret__, 'admin_password'),
         admin_username=pulumi.get(__ret__, 'admin_username'),
         availability_domain=pulumi.get(__ret__, 'availability_domain'),
@@ -559,6 +600,7 @@ def get_mysql_db_system(db_system_id: Optional[str] = None,
         data_storage_size_in_gb=pulumi.get(__ret__, 'data_storage_size_in_gb'),
         data_storages=pulumi.get(__ret__, 'data_storages'),
         database_management=pulumi.get(__ret__, 'database_management'),
+        database_mode=pulumi.get(__ret__, 'database_mode'),
         db_system_id=pulumi.get(__ret__, 'db_system_id'),
         defined_tags=pulumi.get(__ret__, 'defined_tags'),
         deletion_policies=pulumi.get(__ret__, 'deletion_policies'),
@@ -579,6 +621,7 @@ def get_mysql_db_system(db_system_id: Optional[str] = None,
         point_in_time_recovery_details=pulumi.get(__ret__, 'point_in_time_recovery_details'),
         port=pulumi.get(__ret__, 'port'),
         port_x=pulumi.get(__ret__, 'port_x'),
+        read_endpoints=pulumi.get(__ret__, 'read_endpoints'),
         secure_connections=pulumi.get(__ret__, 'secure_connections'),
         shape_name=pulumi.get(__ret__, 'shape_name'),
         shutdown_type=pulumi.get(__ret__, 'shutdown_type'),
@@ -611,6 +654,7 @@ def get_mysql_db_system_output(db_system_id: Optional[pulumi.Input[str]] = None,
     opts = pulumi.InvokeOutputOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
     __ret__ = pulumi.runtime.invoke_output('oci:Mysql/getMysqlDbSystem:getMysqlDbSystem', __args__, opts=opts, typ=GetMysqlDbSystemResult)
     return __ret__.apply(lambda __response__: GetMysqlDbSystemResult(
+        access_mode=pulumi.get(__response__, 'access_mode'),
         admin_password=pulumi.get(__response__, 'admin_password'),
         admin_username=pulumi.get(__response__, 'admin_username'),
         availability_domain=pulumi.get(__response__, 'availability_domain'),
@@ -624,6 +668,7 @@ def get_mysql_db_system_output(db_system_id: Optional[pulumi.Input[str]] = None,
         data_storage_size_in_gb=pulumi.get(__response__, 'data_storage_size_in_gb'),
         data_storages=pulumi.get(__response__, 'data_storages'),
         database_management=pulumi.get(__response__, 'database_management'),
+        database_mode=pulumi.get(__response__, 'database_mode'),
         db_system_id=pulumi.get(__response__, 'db_system_id'),
         defined_tags=pulumi.get(__response__, 'defined_tags'),
         deletion_policies=pulumi.get(__response__, 'deletion_policies'),
@@ -644,6 +689,7 @@ def get_mysql_db_system_output(db_system_id: Optional[pulumi.Input[str]] = None,
         point_in_time_recovery_details=pulumi.get(__response__, 'point_in_time_recovery_details'),
         port=pulumi.get(__response__, 'port'),
         port_x=pulumi.get(__response__, 'port_x'),
+        read_endpoints=pulumi.get(__response__, 'read_endpoints'),
         secure_connections=pulumi.get(__response__, 'secure_connections'),
         shape_name=pulumi.get(__response__, 'shape_name'),
         shutdown_type=pulumi.get(__response__, 'shutdown_type'),