pulumi-oci 2.26.0a1741943394__py3-none-any.whl → 2.27.0__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_oci/__init__.py +144 -0
- pulumi_oci/containerengine/_inputs.py +9 -9
- pulumi_oci/containerengine/outputs.py +18 -22
- pulumi_oci/core/__init__.py +7 -0
- pulumi_oci/core/_inputs.py +147 -0
- pulumi_oci/core/compute_gpu_memory_cluster.py +706 -0
- pulumi_oci/core/compute_gpu_memory_fabric.py +667 -0
- pulumi_oci/core/get_compute_gpu_memory_cluster.py +281 -0
- pulumi_oci/core/get_compute_gpu_memory_cluster_instances.py +144 -0
- pulumi_oci/core/get_compute_gpu_memory_clusters.py +232 -0
- pulumi_oci/core/get_compute_gpu_memory_fabric.py +309 -0
- pulumi_oci/core/get_compute_gpu_memory_fabrics.py +289 -0
- pulumi_oci/core/outputs.py +582 -0
- pulumi_oci/database/__init__.py +2 -0
- pulumi_oci/database/_inputs.py +2211 -24
- pulumi_oci/database/autonomous_container_database.py +305 -52
- pulumi_oci/database/autonomous_container_database_add_standby.py +2183 -0
- pulumi_oci/database/autonomous_container_database_dataguard_association.py +80 -40
- pulumi_oci/database/autonomous_container_database_snapshot_standby.py +322 -0
- pulumi_oci/database/get_autonomous_container_database.py +103 -2
- pulumi_oci/database/get_autonomous_container_database_dataguard_association.py +12 -1
- pulumi_oci/database/get_autonomous_container_databases.py +1 -1
- pulumi_oci/database/get_maintenance_run.py +15 -1
- pulumi_oci/database/maintenance_run.py +28 -0
- pulumi_oci/database/outputs.py +2747 -225
- pulumi_oci/goldengate/_inputs.py +128 -0
- pulumi_oci/goldengate/deployment.py +103 -0
- pulumi_oci/goldengate/deployment_backup.py +28 -0
- pulumi_oci/goldengate/get_deployment.py +43 -1
- pulumi_oci/goldengate/get_deployment_backup.py +15 -1
- pulumi_oci/goldengate/outputs.py +289 -0
- pulumi_oci/osmanagementhub/__init__.py +18 -0
- pulumi_oci/osmanagementhub/_inputs.py +677 -12
- pulumi_oci/osmanagementhub/event.py +8 -0
- pulumi_oci/osmanagementhub/get_entitlements.py +2 -2
- pulumi_oci/osmanagementhub/get_event.py +2 -0
- pulumi_oci/osmanagementhub/get_events.py +2 -0
- pulumi_oci/osmanagementhub/get_managed_instance.py +30 -2
- pulumi_oci/osmanagementhub/get_managed_instances.py +75 -63
- pulumi_oci/osmanagementhub/get_management_station.py +116 -4
- pulumi_oci/osmanagementhub/get_management_station_mirrors.py +1 -1
- pulumi_oci/osmanagementhub/get_management_stations.py +47 -4
- pulumi_oci/osmanagementhub/get_profile.py +32 -4
- pulumi_oci/osmanagementhub/get_profile_available_software_sources.py +207 -0
- pulumi_oci/osmanagementhub/get_profile_version.py +388 -0
- pulumi_oci/osmanagementhub/get_profiles.py +63 -3
- pulumi_oci/osmanagementhub/get_scheduled_job.py +15 -1
- pulumi_oci/osmanagementhub/get_software_package.py +2 -2
- pulumi_oci/osmanagementhub/get_software_package_software_source.py +7 -7
- pulumi_oci/osmanagementhub/get_software_source.py +89 -5
- pulumi_oci/osmanagementhub/get_software_source_available_software_packages.py +209 -0
- pulumi_oci/osmanagementhub/get_software_source_manifest.py +127 -0
- pulumi_oci/osmanagementhub/get_software_sources.py +30 -8
- pulumi_oci/osmanagementhub/lifecycle_stage_attach_managed_instances_management.py +6 -39
- pulumi_oci/osmanagementhub/lifecycle_stage_detach_managed_instances_management.py +6 -39
- pulumi_oci/osmanagementhub/lifecycle_stage_reboot_management.py +297 -0
- pulumi_oci/osmanagementhub/managed_instance.py +56 -0
- pulumi_oci/osmanagementhub/managed_instance_group_install_packages_management.py +49 -0
- pulumi_oci/osmanagementhub/managed_instance_group_reboot_management.py +297 -0
- pulumi_oci/osmanagementhub/managed_instance_reboot_management.py +299 -0
- pulumi_oci/osmanagementhub/management_station.py +251 -4
- pulumi_oci/osmanagementhub/management_station_associate_managed_instances_management.py +298 -0
- pulumi_oci/osmanagementhub/management_station_refresh_management.py +2 -2
- pulumi_oci/osmanagementhub/management_station_synchronize_mirrors_management.py +9 -9
- pulumi_oci/osmanagementhub/outputs.py +1349 -50
- pulumi_oci/osmanagementhub/profile.py +70 -14
- pulumi_oci/osmanagementhub/profile_attach_lifecycle_stage_management.py +269 -0
- pulumi_oci/osmanagementhub/profile_attach_managed_instance_group_management.py +269 -0
- pulumi_oci/osmanagementhub/profile_attach_management_station_management.py +269 -0
- pulumi_oci/osmanagementhub/profile_attach_software_sources_management.py +269 -0
- pulumi_oci/osmanagementhub/profile_detach_software_sources_management.py +269 -0
- pulumi_oci/osmanagementhub/scheduled_job.py +72 -21
- pulumi_oci/osmanagementhub/software_source.py +365 -26
- pulumi_oci/osmanagementhub/software_source_add_packages_management.py +67 -10
- pulumi_oci/osmanagementhub/software_source_generate_metadata_management.py +217 -0
- pulumi_oci/osmanagementhub/software_source_manifest.py +268 -0
- pulumi_oci/osmanagementhub/software_source_remove_packages_management.py +277 -0
- pulumi_oci/osmanagementhub/software_source_replace_packages_management.py +277 -0
- pulumi_oci/osmanagementhub/work_request_rerun_management.py +325 -0
- pulumi_oci/pulumi-plugin.json +1 -1
- {pulumi_oci-2.26.0a1741943394.dist-info → pulumi_oci-2.27.0.dist-info}/METADATA +2 -2
- {pulumi_oci-2.26.0a1741943394.dist-info → pulumi_oci-2.27.0.dist-info}/RECORD +84 -57
- {pulumi_oci-2.26.0a1741943394.dist-info → pulumi_oci-2.27.0.dist-info}/WHEEL +1 -1
- {pulumi_oci-2.26.0a1741943394.dist-info → pulumi_oci-2.27.0.dist-info}/top_level.txt +0 -0
|
@@ -0,0 +1,2183 @@
|
|
|
1
|
+
# coding=utf-8
|
|
2
|
+
# *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. ***
|
|
3
|
+
# *** Do not edit by hand unless you're certain you know what you are doing! ***
|
|
4
|
+
|
|
5
|
+
import copy
|
|
6
|
+
import warnings
|
|
7
|
+
import sys
|
|
8
|
+
import pulumi
|
|
9
|
+
import pulumi.runtime
|
|
10
|
+
from typing import Any, Mapping, Optional, Sequence, Union, overload
|
|
11
|
+
if sys.version_info >= (3, 11):
|
|
12
|
+
from typing import NotRequired, TypedDict, TypeAlias
|
|
13
|
+
else:
|
|
14
|
+
from typing_extensions import NotRequired, TypedDict, TypeAlias
|
|
15
|
+
from .. import _utilities
|
|
16
|
+
from . import outputs
|
|
17
|
+
from ._inputs import *
|
|
18
|
+
|
|
19
|
+
__all__ = ['AutonomousContainerDatabaseAddStandbyArgs', 'AutonomousContainerDatabaseAddStandby']
|
|
20
|
+
|
|
21
|
+
@pulumi.input_type
|
|
22
|
+
class AutonomousContainerDatabaseAddStandbyArgs:
|
|
23
|
+
def __init__(__self__, *,
|
|
24
|
+
autonomous_container_database_id: pulumi.Input[str],
|
|
25
|
+
fast_start_fail_over_lag_limit_in_seconds: Optional[pulumi.Input[int]] = None,
|
|
26
|
+
is_automatic_failover_enabled: Optional[pulumi.Input[bool]] = None,
|
|
27
|
+
peer_autonomous_container_database_backup_config: Optional[pulumi.Input['AutonomousContainerDatabaseAddStandbyPeerAutonomousContainerDatabaseBackupConfigArgs']] = None,
|
|
28
|
+
peer_autonomous_container_database_compartment_id: Optional[pulumi.Input[str]] = None,
|
|
29
|
+
peer_autonomous_container_database_display_name: Optional[pulumi.Input[str]] = None,
|
|
30
|
+
peer_autonomous_vm_cluster_id: Optional[pulumi.Input[str]] = None,
|
|
31
|
+
peer_cloud_autonomous_vm_cluster_id: Optional[pulumi.Input[str]] = None,
|
|
32
|
+
peer_db_unique_name: Optional[pulumi.Input[str]] = None,
|
|
33
|
+
protection_mode: Optional[pulumi.Input[str]] = None,
|
|
34
|
+
standby_maintenance_buffer_in_days: Optional[pulumi.Input[int]] = None):
|
|
35
|
+
"""
|
|
36
|
+
The set of arguments for constructing a AutonomousContainerDatabaseAddStandby resource.
|
|
37
|
+
:param pulumi.Input[str] autonomous_container_database_id: The Autonomous Container Database [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm).
|
|
38
|
+
:param pulumi.Input[int] fast_start_fail_over_lag_limit_in_seconds: The lag time for my preference based on data loss tolerance in seconds.
|
|
39
|
+
:param pulumi.Input[bool] is_automatic_failover_enabled: Indicates whether Automatic Failover is enabled for Autonomous Container Database Dataguard Association
|
|
40
|
+
:param pulumi.Input['AutonomousContainerDatabaseAddStandbyPeerAutonomousContainerDatabaseBackupConfigArgs'] peer_autonomous_container_database_backup_config: Backup options for the standby Autonomous Container Database.
|
|
41
|
+
:param pulumi.Input[str] peer_autonomous_container_database_compartment_id: The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the compartment where the standby Autonomous Container Database will be created.
|
|
42
|
+
:param pulumi.Input[str] peer_autonomous_container_database_display_name: The display name for the peer Autonomous Container Database.
|
|
43
|
+
:param pulumi.Input[str] peer_autonomous_vm_cluster_id: The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the peer Autonomous Exadata VM Cluster.
|
|
44
|
+
:param pulumi.Input[str] peer_cloud_autonomous_vm_cluster_id: The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the peer cloud Autonomous Exadata VM Cluster.
|
|
45
|
+
:param pulumi.Input[str] peer_db_unique_name: Specifies the `DB_UNIQUE_NAME` of the peer database to be created.
|
|
46
|
+
:param pulumi.Input[str] protection_mode: The protection mode of this Autonomous Data Guard association. For more information, see [Oracle Data Guard Protection Modes](http://docs.oracle.com/database/122/SBYDB/oracle-data-guard-protection-modes.htm#SBYDB02000) in the Oracle Data Guard documentation.
|
|
47
|
+
:param pulumi.Input[int] standby_maintenance_buffer_in_days: The scheduling detail for the quarterly maintenance window of the standby Autonomous Container Database. This value represents the number of days before scheduled maintenance of the primary database.
|
|
48
|
+
|
|
49
|
+
|
|
50
|
+
** IMPORTANT **
|
|
51
|
+
Any change to a property that does not support update will force the destruction and recreation of the resource with the new property values
|
|
52
|
+
"""
|
|
53
|
+
pulumi.set(__self__, "autonomous_container_database_id", autonomous_container_database_id)
|
|
54
|
+
if fast_start_fail_over_lag_limit_in_seconds is not None:
|
|
55
|
+
pulumi.set(__self__, "fast_start_fail_over_lag_limit_in_seconds", fast_start_fail_over_lag_limit_in_seconds)
|
|
56
|
+
if is_automatic_failover_enabled is not None:
|
|
57
|
+
pulumi.set(__self__, "is_automatic_failover_enabled", is_automatic_failover_enabled)
|
|
58
|
+
if peer_autonomous_container_database_backup_config is not None:
|
|
59
|
+
pulumi.set(__self__, "peer_autonomous_container_database_backup_config", peer_autonomous_container_database_backup_config)
|
|
60
|
+
if peer_autonomous_container_database_compartment_id is not None:
|
|
61
|
+
pulumi.set(__self__, "peer_autonomous_container_database_compartment_id", peer_autonomous_container_database_compartment_id)
|
|
62
|
+
if peer_autonomous_container_database_display_name is not None:
|
|
63
|
+
pulumi.set(__self__, "peer_autonomous_container_database_display_name", peer_autonomous_container_database_display_name)
|
|
64
|
+
if peer_autonomous_vm_cluster_id is not None:
|
|
65
|
+
pulumi.set(__self__, "peer_autonomous_vm_cluster_id", peer_autonomous_vm_cluster_id)
|
|
66
|
+
if peer_cloud_autonomous_vm_cluster_id is not None:
|
|
67
|
+
pulumi.set(__self__, "peer_cloud_autonomous_vm_cluster_id", peer_cloud_autonomous_vm_cluster_id)
|
|
68
|
+
if peer_db_unique_name is not None:
|
|
69
|
+
pulumi.set(__self__, "peer_db_unique_name", peer_db_unique_name)
|
|
70
|
+
if protection_mode is not None:
|
|
71
|
+
pulumi.set(__self__, "protection_mode", protection_mode)
|
|
72
|
+
if standby_maintenance_buffer_in_days is not None:
|
|
73
|
+
pulumi.set(__self__, "standby_maintenance_buffer_in_days", standby_maintenance_buffer_in_days)
|
|
74
|
+
|
|
75
|
+
@property
|
|
76
|
+
@pulumi.getter(name="autonomousContainerDatabaseId")
|
|
77
|
+
def autonomous_container_database_id(self) -> pulumi.Input[str]:
|
|
78
|
+
"""
|
|
79
|
+
The Autonomous Container Database [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm).
|
|
80
|
+
"""
|
|
81
|
+
return pulumi.get(self, "autonomous_container_database_id")
|
|
82
|
+
|
|
83
|
+
@autonomous_container_database_id.setter
|
|
84
|
+
def autonomous_container_database_id(self, value: pulumi.Input[str]):
|
|
85
|
+
pulumi.set(self, "autonomous_container_database_id", value)
|
|
86
|
+
|
|
87
|
+
@property
|
|
88
|
+
@pulumi.getter(name="fastStartFailOverLagLimitInSeconds")
|
|
89
|
+
def fast_start_fail_over_lag_limit_in_seconds(self) -> Optional[pulumi.Input[int]]:
|
|
90
|
+
"""
|
|
91
|
+
The lag time for my preference based on data loss tolerance in seconds.
|
|
92
|
+
"""
|
|
93
|
+
return pulumi.get(self, "fast_start_fail_over_lag_limit_in_seconds")
|
|
94
|
+
|
|
95
|
+
@fast_start_fail_over_lag_limit_in_seconds.setter
|
|
96
|
+
def fast_start_fail_over_lag_limit_in_seconds(self, value: Optional[pulumi.Input[int]]):
|
|
97
|
+
pulumi.set(self, "fast_start_fail_over_lag_limit_in_seconds", value)
|
|
98
|
+
|
|
99
|
+
@property
|
|
100
|
+
@pulumi.getter(name="isAutomaticFailoverEnabled")
|
|
101
|
+
def is_automatic_failover_enabled(self) -> Optional[pulumi.Input[bool]]:
|
|
102
|
+
"""
|
|
103
|
+
Indicates whether Automatic Failover is enabled for Autonomous Container Database Dataguard Association
|
|
104
|
+
"""
|
|
105
|
+
return pulumi.get(self, "is_automatic_failover_enabled")
|
|
106
|
+
|
|
107
|
+
@is_automatic_failover_enabled.setter
|
|
108
|
+
def is_automatic_failover_enabled(self, value: Optional[pulumi.Input[bool]]):
|
|
109
|
+
pulumi.set(self, "is_automatic_failover_enabled", value)
|
|
110
|
+
|
|
111
|
+
@property
|
|
112
|
+
@pulumi.getter(name="peerAutonomousContainerDatabaseBackupConfig")
|
|
113
|
+
def peer_autonomous_container_database_backup_config(self) -> Optional[pulumi.Input['AutonomousContainerDatabaseAddStandbyPeerAutonomousContainerDatabaseBackupConfigArgs']]:
|
|
114
|
+
"""
|
|
115
|
+
Backup options for the standby Autonomous Container Database.
|
|
116
|
+
"""
|
|
117
|
+
return pulumi.get(self, "peer_autonomous_container_database_backup_config")
|
|
118
|
+
|
|
119
|
+
@peer_autonomous_container_database_backup_config.setter
|
|
120
|
+
def peer_autonomous_container_database_backup_config(self, value: Optional[pulumi.Input['AutonomousContainerDatabaseAddStandbyPeerAutonomousContainerDatabaseBackupConfigArgs']]):
|
|
121
|
+
pulumi.set(self, "peer_autonomous_container_database_backup_config", value)
|
|
122
|
+
|
|
123
|
+
@property
|
|
124
|
+
@pulumi.getter(name="peerAutonomousContainerDatabaseCompartmentId")
|
|
125
|
+
def peer_autonomous_container_database_compartment_id(self) -> Optional[pulumi.Input[str]]:
|
|
126
|
+
"""
|
|
127
|
+
The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the compartment where the standby Autonomous Container Database will be created.
|
|
128
|
+
"""
|
|
129
|
+
return pulumi.get(self, "peer_autonomous_container_database_compartment_id")
|
|
130
|
+
|
|
131
|
+
@peer_autonomous_container_database_compartment_id.setter
|
|
132
|
+
def peer_autonomous_container_database_compartment_id(self, value: Optional[pulumi.Input[str]]):
|
|
133
|
+
pulumi.set(self, "peer_autonomous_container_database_compartment_id", value)
|
|
134
|
+
|
|
135
|
+
@property
|
|
136
|
+
@pulumi.getter(name="peerAutonomousContainerDatabaseDisplayName")
|
|
137
|
+
def peer_autonomous_container_database_display_name(self) -> Optional[pulumi.Input[str]]:
|
|
138
|
+
"""
|
|
139
|
+
The display name for the peer Autonomous Container Database.
|
|
140
|
+
"""
|
|
141
|
+
return pulumi.get(self, "peer_autonomous_container_database_display_name")
|
|
142
|
+
|
|
143
|
+
@peer_autonomous_container_database_display_name.setter
|
|
144
|
+
def peer_autonomous_container_database_display_name(self, value: Optional[pulumi.Input[str]]):
|
|
145
|
+
pulumi.set(self, "peer_autonomous_container_database_display_name", value)
|
|
146
|
+
|
|
147
|
+
@property
|
|
148
|
+
@pulumi.getter(name="peerAutonomousVmClusterId")
|
|
149
|
+
def peer_autonomous_vm_cluster_id(self) -> Optional[pulumi.Input[str]]:
|
|
150
|
+
"""
|
|
151
|
+
The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the peer Autonomous Exadata VM Cluster.
|
|
152
|
+
"""
|
|
153
|
+
return pulumi.get(self, "peer_autonomous_vm_cluster_id")
|
|
154
|
+
|
|
155
|
+
@peer_autonomous_vm_cluster_id.setter
|
|
156
|
+
def peer_autonomous_vm_cluster_id(self, value: Optional[pulumi.Input[str]]):
|
|
157
|
+
pulumi.set(self, "peer_autonomous_vm_cluster_id", value)
|
|
158
|
+
|
|
159
|
+
@property
|
|
160
|
+
@pulumi.getter(name="peerCloudAutonomousVmClusterId")
|
|
161
|
+
def peer_cloud_autonomous_vm_cluster_id(self) -> Optional[pulumi.Input[str]]:
|
|
162
|
+
"""
|
|
163
|
+
The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the peer cloud Autonomous Exadata VM Cluster.
|
|
164
|
+
"""
|
|
165
|
+
return pulumi.get(self, "peer_cloud_autonomous_vm_cluster_id")
|
|
166
|
+
|
|
167
|
+
@peer_cloud_autonomous_vm_cluster_id.setter
|
|
168
|
+
def peer_cloud_autonomous_vm_cluster_id(self, value: Optional[pulumi.Input[str]]):
|
|
169
|
+
pulumi.set(self, "peer_cloud_autonomous_vm_cluster_id", value)
|
|
170
|
+
|
|
171
|
+
@property
|
|
172
|
+
@pulumi.getter(name="peerDbUniqueName")
|
|
173
|
+
def peer_db_unique_name(self) -> Optional[pulumi.Input[str]]:
|
|
174
|
+
"""
|
|
175
|
+
Specifies the `DB_UNIQUE_NAME` of the peer database to be created.
|
|
176
|
+
"""
|
|
177
|
+
return pulumi.get(self, "peer_db_unique_name")
|
|
178
|
+
|
|
179
|
+
@peer_db_unique_name.setter
|
|
180
|
+
def peer_db_unique_name(self, value: Optional[pulumi.Input[str]]):
|
|
181
|
+
pulumi.set(self, "peer_db_unique_name", value)
|
|
182
|
+
|
|
183
|
+
@property
|
|
184
|
+
@pulumi.getter(name="protectionMode")
|
|
185
|
+
def protection_mode(self) -> Optional[pulumi.Input[str]]:
|
|
186
|
+
"""
|
|
187
|
+
The protection mode of this Autonomous Data Guard association. For more information, see [Oracle Data Guard Protection Modes](http://docs.oracle.com/database/122/SBYDB/oracle-data-guard-protection-modes.htm#SBYDB02000) in the Oracle Data Guard documentation.
|
|
188
|
+
"""
|
|
189
|
+
return pulumi.get(self, "protection_mode")
|
|
190
|
+
|
|
191
|
+
@protection_mode.setter
|
|
192
|
+
def protection_mode(self, value: Optional[pulumi.Input[str]]):
|
|
193
|
+
pulumi.set(self, "protection_mode", value)
|
|
194
|
+
|
|
195
|
+
@property
|
|
196
|
+
@pulumi.getter(name="standbyMaintenanceBufferInDays")
|
|
197
|
+
def standby_maintenance_buffer_in_days(self) -> Optional[pulumi.Input[int]]:
|
|
198
|
+
"""
|
|
199
|
+
The scheduling detail for the quarterly maintenance window of the standby Autonomous Container Database. This value represents the number of days before scheduled maintenance of the primary database.
|
|
200
|
+
|
|
201
|
+
|
|
202
|
+
** IMPORTANT **
|
|
203
|
+
Any change to a property that does not support update will force the destruction and recreation of the resource with the new property values
|
|
204
|
+
"""
|
|
205
|
+
return pulumi.get(self, "standby_maintenance_buffer_in_days")
|
|
206
|
+
|
|
207
|
+
@standby_maintenance_buffer_in_days.setter
|
|
208
|
+
def standby_maintenance_buffer_in_days(self, value: Optional[pulumi.Input[int]]):
|
|
209
|
+
pulumi.set(self, "standby_maintenance_buffer_in_days", value)
|
|
210
|
+
|
|
211
|
+
|
|
212
|
+
@pulumi.input_type
|
|
213
|
+
class _AutonomousContainerDatabaseAddStandbyState:
|
|
214
|
+
def __init__(__self__, *,
|
|
215
|
+
autonomous_container_database_id: Optional[pulumi.Input[str]] = None,
|
|
216
|
+
autonomous_exadata_infrastructure_id: Optional[pulumi.Input[str]] = None,
|
|
217
|
+
autonomous_vm_cluster_id: Optional[pulumi.Input[str]] = None,
|
|
218
|
+
availability_domain: Optional[pulumi.Input[str]] = None,
|
|
219
|
+
available_cpus: Optional[pulumi.Input[float]] = None,
|
|
220
|
+
backup_configs: Optional[pulumi.Input[Sequence[pulumi.Input['AutonomousContainerDatabaseAddStandbyBackupConfigArgs']]]] = None,
|
|
221
|
+
cloud_autonomous_vm_cluster_id: Optional[pulumi.Input[str]] = None,
|
|
222
|
+
compartment_id: Optional[pulumi.Input[str]] = None,
|
|
223
|
+
compute_model: Optional[pulumi.Input[str]] = None,
|
|
224
|
+
dataguard_group_members: Optional[pulumi.Input[Sequence[pulumi.Input['AutonomousContainerDatabaseAddStandbyDataguardGroupMemberArgs']]]] = None,
|
|
225
|
+
dataguards: Optional[pulumi.Input[Sequence[pulumi.Input['AutonomousContainerDatabaseAddStandbyDataguardArgs']]]] = None,
|
|
226
|
+
db_name: Optional[pulumi.Input[str]] = None,
|
|
227
|
+
db_split_threshold: Optional[pulumi.Input[int]] = None,
|
|
228
|
+
db_unique_name: Optional[pulumi.Input[str]] = None,
|
|
229
|
+
db_version: Optional[pulumi.Input[str]] = None,
|
|
230
|
+
defined_tags: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
|
|
231
|
+
display_name: Optional[pulumi.Input[str]] = None,
|
|
232
|
+
distribution_affinity: Optional[pulumi.Input[str]] = None,
|
|
233
|
+
dst_file_version: Optional[pulumi.Input[str]] = None,
|
|
234
|
+
fast_start_fail_over_lag_limit_in_seconds: Optional[pulumi.Input[int]] = None,
|
|
235
|
+
freeform_tags: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
|
|
236
|
+
infrastructure_type: Optional[pulumi.Input[str]] = None,
|
|
237
|
+
is_automatic_failover_enabled: Optional[pulumi.Input[bool]] = None,
|
|
238
|
+
is_data_guard_enabled: Optional[pulumi.Input[bool]] = None,
|
|
239
|
+
is_dst_file_update_enabled: Optional[pulumi.Input[bool]] = None,
|
|
240
|
+
is_multiple_standby: Optional[pulumi.Input[bool]] = None,
|
|
241
|
+
key_history_entries: Optional[pulumi.Input[Sequence[pulumi.Input['AutonomousContainerDatabaseAddStandbyKeyHistoryEntryArgs']]]] = None,
|
|
242
|
+
key_store_id: Optional[pulumi.Input[str]] = None,
|
|
243
|
+
key_store_wallet_name: Optional[pulumi.Input[str]] = None,
|
|
244
|
+
kms_key_id: Optional[pulumi.Input[str]] = None,
|
|
245
|
+
kms_key_version_id: Optional[pulumi.Input[str]] = None,
|
|
246
|
+
largest_provisionable_autonomous_database_in_cpus: Optional[pulumi.Input[float]] = None,
|
|
247
|
+
last_maintenance_run_id: Optional[pulumi.Input[str]] = None,
|
|
248
|
+
lifecycle_details: Optional[pulumi.Input[str]] = None,
|
|
249
|
+
list_one_off_patches: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
250
|
+
maintenance_windows: Optional[pulumi.Input[Sequence[pulumi.Input['AutonomousContainerDatabaseAddStandbyMaintenanceWindowArgs']]]] = None,
|
|
251
|
+
memory_per_oracle_compute_unit_in_gbs: Optional[pulumi.Input[int]] = None,
|
|
252
|
+
net_services_architecture: Optional[pulumi.Input[str]] = None,
|
|
253
|
+
next_maintenance_run_id: Optional[pulumi.Input[str]] = None,
|
|
254
|
+
patch_id: Optional[pulumi.Input[str]] = None,
|
|
255
|
+
patch_model: Optional[pulumi.Input[str]] = None,
|
|
256
|
+
peer_autonomous_container_database_backup_config: Optional[pulumi.Input['AutonomousContainerDatabaseAddStandbyPeerAutonomousContainerDatabaseBackupConfigArgs']] = None,
|
|
257
|
+
peer_autonomous_container_database_compartment_id: Optional[pulumi.Input[str]] = None,
|
|
258
|
+
peer_autonomous_container_database_display_name: Optional[pulumi.Input[str]] = None,
|
|
259
|
+
peer_autonomous_vm_cluster_id: Optional[pulumi.Input[str]] = None,
|
|
260
|
+
peer_cloud_autonomous_vm_cluster_id: Optional[pulumi.Input[str]] = None,
|
|
261
|
+
peer_db_unique_name: Optional[pulumi.Input[str]] = None,
|
|
262
|
+
protection_mode: Optional[pulumi.Input[str]] = None,
|
|
263
|
+
provisionable_cpuses: Optional[pulumi.Input[Sequence[pulumi.Input[float]]]] = None,
|
|
264
|
+
provisioned_cpus: Optional[pulumi.Input[float]] = None,
|
|
265
|
+
reclaimable_cpus: Optional[pulumi.Input[float]] = None,
|
|
266
|
+
reserved_cpus: Optional[pulumi.Input[float]] = None,
|
|
267
|
+
role: Optional[pulumi.Input[str]] = None,
|
|
268
|
+
service_level_agreement_type: Optional[pulumi.Input[str]] = None,
|
|
269
|
+
standby_maintenance_buffer_in_days: Optional[pulumi.Input[int]] = None,
|
|
270
|
+
state: Optional[pulumi.Input[str]] = None,
|
|
271
|
+
time_created: Optional[pulumi.Input[str]] = None,
|
|
272
|
+
time_of_last_backup: Optional[pulumi.Input[str]] = None,
|
|
273
|
+
time_snapshot_standby_revert: Optional[pulumi.Input[str]] = None,
|
|
274
|
+
total_cpus: Optional[pulumi.Input[int]] = None,
|
|
275
|
+
vault_id: Optional[pulumi.Input[str]] = None,
|
|
276
|
+
version_preference: Optional[pulumi.Input[str]] = None,
|
|
277
|
+
vm_failover_reservation: Optional[pulumi.Input[int]] = None):
|
|
278
|
+
"""
|
|
279
|
+
Input properties used for looking up and filtering AutonomousContainerDatabaseAddStandby resources.
|
|
280
|
+
:param pulumi.Input[str] autonomous_container_database_id: The Autonomous Container Database [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm).
|
|
281
|
+
:param pulumi.Input[str] autonomous_exadata_infrastructure_id: **No longer used.** For Autonomous Database on dedicated Exadata infrastructure, the container database is created within a specified `cloudAutonomousVmCluster`.
|
|
282
|
+
:param pulumi.Input[str] autonomous_vm_cluster_id: The OCID of the Autonomous VM Cluster.
|
|
283
|
+
:param pulumi.Input[str] availability_domain: The domain of the Autonomous Container Database
|
|
284
|
+
:param pulumi.Input[float] available_cpus: Sum of CPUs available on the Autonomous VM Cluster + Sum of reclaimable CPUs available in the Autonomous Container Database.
|
|
285
|
+
:param pulumi.Input[Sequence[pulumi.Input['AutonomousContainerDatabaseAddStandbyBackupConfigArgs']]] backup_configs: Backup options for the Autonomous Container Database.
|
|
286
|
+
:param pulumi.Input[str] cloud_autonomous_vm_cluster_id: The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the cloud Autonomous Exadata VM Cluster.
|
|
287
|
+
:param pulumi.Input[str] compartment_id: The OCID of the compartment.
|
|
288
|
+
:param pulumi.Input[str] compute_model: The compute model of the Autonomous Container Database. For Autonomous Database on Dedicated Exadata Infrastructure, the CPU type (ECPUs or OCPUs) is determined by the parent Autonomous Exadata VM Cluster's compute model. ECPU compute model is the recommended model and OCPU compute model is legacy. See [Compute Models in Autonomous Database on Dedicated Exadata Infrastructure](https://docs.oracle.com/en/cloud/paas/autonomous-database/dedicated/adbak) for more details.
|
|
289
|
+
:param pulumi.Input[Sequence[pulumi.Input['AutonomousContainerDatabaseAddStandbyDataguardGroupMemberArgs']]] dataguard_group_members: Array of Dg associations.
|
|
290
|
+
:param pulumi.Input[Sequence[pulumi.Input['AutonomousContainerDatabaseAddStandbyDataguardArgs']]] dataguards: The properties that define Autonomous Container Databases Dataguard.
|
|
291
|
+
:param pulumi.Input[str] db_name: The Database name for the Autonomous Container Database. The name must be unique within the Cloud Autonomous VM Cluster, starting with an alphabetic character, followed by 1 to 7 alphanumeric characters.
|
|
292
|
+
:param pulumi.Input[int] db_split_threshold: The CPU value beyond which an Autonomous Database will be opened across multiple nodes. The default value of this attribute is 16 for OCPUs and 64 for ECPUs.
|
|
293
|
+
:param pulumi.Input[str] db_version: Oracle Database version of the Autonomous Container Database.
|
|
294
|
+
:param pulumi.Input[Mapping[str, pulumi.Input[str]]] defined_tags: Defined tags for this resource. Each key is predefined and scoped to a namespace. For more information, see [Resource Tags](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/resourcetags.htm).
|
|
295
|
+
:param pulumi.Input[str] display_name: The user-provided name for the Autonomous Container Database.
|
|
296
|
+
:param pulumi.Input[str] distribution_affinity: Determines whether an Autonomous Database must be opened across the maximum number of nodes or the least number of nodes. By default, Minimum nodes is selected.
|
|
297
|
+
:param pulumi.Input[str] dst_file_version: DST Time-Zone File version of the Autonomous Container Database.
|
|
298
|
+
:param pulumi.Input[int] fast_start_fail_over_lag_limit_in_seconds: The lag time for my preference based on data loss tolerance in seconds.
|
|
299
|
+
:param pulumi.Input[Mapping[str, pulumi.Input[str]]] freeform_tags: Free-form tags for this resource. Each tag is a simple key-value pair with no predefined name, type, or namespace. For more information, see [Resource Tags](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/resourcetags.htm). Example: `{"Department": "Finance"}`
|
|
300
|
+
:param pulumi.Input[str] infrastructure_type: The infrastructure type this resource belongs to.
|
|
301
|
+
:param pulumi.Input[bool] is_automatic_failover_enabled: Indicates whether Automatic Failover is enabled for Autonomous Container Database Dataguard Association
|
|
302
|
+
:param pulumi.Input[bool] is_data_guard_enabled: **Deprecated.** Indicates whether the Autonomous Database has local (in-region) Data Guard enabled. Not applicable to cross-region Autonomous Data Guard associations, or to Autonomous Databases using dedicated Exadata infrastructure or Exadata Cloud@Customer infrastructure.
|
|
303
|
+
:param pulumi.Input[bool] is_dst_file_update_enabled: Indicates if an automatic DST Time Zone file update is enabled for the Autonomous Container Database. If enabled along with Release Update, patching will be done in a Non-Rolling manner.
|
|
304
|
+
:param pulumi.Input[bool] is_multiple_standby: Whether it is multiple standby Autonomous Dataguard
|
|
305
|
+
:param pulumi.Input[Sequence[pulumi.Input['AutonomousContainerDatabaseAddStandbyKeyHistoryEntryArgs']]] key_history_entries: Key History Entry.
|
|
306
|
+
:param pulumi.Input[str] key_store_id: The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the key store of Oracle Vault.
|
|
307
|
+
:param pulumi.Input[str] key_store_wallet_name: The wallet name for Oracle Key Vault.
|
|
308
|
+
:param pulumi.Input[str] kms_key_id: The OCID of the key container that is used as the master encryption key in database transparent data encryption (TDE) operations.
|
|
309
|
+
:param pulumi.Input[str] kms_key_version_id: The OCID of the key container version that is used in database transparent data encryption (TDE) operations KMS Key can have multiple key versions. If none is specified, the current key version (latest) of the Key Id is used for the operation. Autonomous Database Serverless does not use key versions, hence is not applicable for Autonomous Database Serverless instances.
|
|
310
|
+
:param pulumi.Input[float] largest_provisionable_autonomous_database_in_cpus: The largest Autonomous Database (CPU) that can be created in a new Autonomous Container Database.
|
|
311
|
+
:param pulumi.Input[str] last_maintenance_run_id: The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the last maintenance run.
|
|
312
|
+
:param pulumi.Input[str] lifecycle_details: Additional information about the current lifecycle state.
|
|
313
|
+
:param pulumi.Input[Sequence[pulumi.Input[str]]] list_one_off_patches: List of One-Off patches that has been successfully applied to Autonomous Container Database
|
|
314
|
+
:param pulumi.Input[Sequence[pulumi.Input['AutonomousContainerDatabaseAddStandbyMaintenanceWindowArgs']]] maintenance_windows: The scheduling details for the quarterly maintenance window. Patching and system updates take place during the maintenance window.
|
|
315
|
+
:param pulumi.Input[int] memory_per_oracle_compute_unit_in_gbs: The amount of memory (in GBs) enabled per ECPU or OCPU in the Autonomous VM Cluster.
|
|
316
|
+
:param pulumi.Input[str] net_services_architecture: Enabling SHARED server architecture enables a database server to allow many client processes to share very few server processes, thereby increasing the number of supported users.
|
|
317
|
+
:param pulumi.Input[str] next_maintenance_run_id: The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the next maintenance run.
|
|
318
|
+
:param pulumi.Input[str] patch_id: The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the last patch applied on the system.
|
|
319
|
+
:param pulumi.Input[str] patch_model: Database patch model preference.
|
|
320
|
+
:param pulumi.Input['AutonomousContainerDatabaseAddStandbyPeerAutonomousContainerDatabaseBackupConfigArgs'] peer_autonomous_container_database_backup_config: Backup options for the standby Autonomous Container Database.
|
|
321
|
+
:param pulumi.Input[str] peer_autonomous_container_database_compartment_id: The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the compartment where the standby Autonomous Container Database will be created.
|
|
322
|
+
:param pulumi.Input[str] peer_autonomous_container_database_display_name: The display name for the peer Autonomous Container Database.
|
|
323
|
+
:param pulumi.Input[str] peer_autonomous_vm_cluster_id: The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the peer Autonomous Exadata VM Cluster.
|
|
324
|
+
:param pulumi.Input[str] peer_cloud_autonomous_vm_cluster_id: The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the peer cloud Autonomous Exadata VM Cluster.
|
|
325
|
+
:param pulumi.Input[str] peer_db_unique_name: Specifies the `DB_UNIQUE_NAME` of the peer database to be created.
|
|
326
|
+
:param pulumi.Input[str] protection_mode: The protection mode of this Autonomous Data Guard association. For more information, see [Oracle Data Guard Protection Modes](http://docs.oracle.com/database/122/SBYDB/oracle-data-guard-protection-modes.htm#SBYDB02000) in the Oracle Data Guard documentation.
|
|
327
|
+
:param pulumi.Input[Sequence[pulumi.Input[float]]] provisionable_cpuses: An array of CPU values that can be used to successfully provision a single Autonomous Database.
|
|
328
|
+
:param pulumi.Input[float] provisioned_cpus: The number of CPUs provisioned in an Autonomous Container Database.
|
|
329
|
+
:param pulumi.Input[float] reclaimable_cpus: CPUs that continue to be included in the count of CPUs available to the Autonomous Container Database even after one of its Autonomous Database is terminated or scaled down. You can release them to the available CPUs at its parent Autonomous VM Cluster level by restarting the Autonomous Container Database.
|
|
330
|
+
:param pulumi.Input[float] reserved_cpus: The number of CPUs reserved in an Autonomous Container Database.
|
|
331
|
+
:param pulumi.Input[str] role: The Data Guard role of the Autonomous Container Database or Autonomous Database, if Autonomous Data Guard is enabled.
|
|
332
|
+
:param pulumi.Input[str] service_level_agreement_type: The service level agreement type of the container database. The default is STANDARD.
|
|
333
|
+
:param pulumi.Input[int] standby_maintenance_buffer_in_days: The scheduling detail for the quarterly maintenance window of the standby Autonomous Container Database. This value represents the number of days before scheduled maintenance of the primary database.
|
|
334
|
+
|
|
335
|
+
|
|
336
|
+
** IMPORTANT **
|
|
337
|
+
Any change to a property that does not support update will force the destruction and recreation of the resource with the new property values
|
|
338
|
+
:param pulumi.Input[str] state: The current state of the Autonomous Container Database.
|
|
339
|
+
:param pulumi.Input[str] time_created: The date and time the Autonomous Container Database was created.
|
|
340
|
+
:param pulumi.Input[str] time_of_last_backup: The timestamp of last successful backup. Here NULL value represents either there are no successful backups or backups are not configured for this Autonomous Container Database.
|
|
341
|
+
:param pulumi.Input[str] time_snapshot_standby_revert: The date and time the Autonomous Container Database will be reverted to Standby from Snapshot Standby.
|
|
342
|
+
:param pulumi.Input[int] total_cpus: The number of CPUs allocated to the Autonomous VM cluster.
|
|
343
|
+
:param pulumi.Input[str] vault_id: The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the Oracle Cloud Infrastructure [vault](https://docs.cloud.oracle.com/iaas/Content/KeyManagement/Concepts/keyoverview.htm#concepts). This parameter and `secretId` are required for Customer Managed Keys.
|
|
344
|
+
:param pulumi.Input[str] version_preference: The next maintenance version preference.
|
|
345
|
+
:param pulumi.Input[int] vm_failover_reservation: The percentage of CPUs reserved across nodes to support node failover. Allowed values are 0%, 25%, and 50%, with 50% being the default option.
|
|
346
|
+
"""
|
|
347
|
+
if autonomous_container_database_id is not None:
|
|
348
|
+
pulumi.set(__self__, "autonomous_container_database_id", autonomous_container_database_id)
|
|
349
|
+
if autonomous_exadata_infrastructure_id is not None:
|
|
350
|
+
pulumi.set(__self__, "autonomous_exadata_infrastructure_id", autonomous_exadata_infrastructure_id)
|
|
351
|
+
if autonomous_vm_cluster_id is not None:
|
|
352
|
+
pulumi.set(__self__, "autonomous_vm_cluster_id", autonomous_vm_cluster_id)
|
|
353
|
+
if availability_domain is not None:
|
|
354
|
+
pulumi.set(__self__, "availability_domain", availability_domain)
|
|
355
|
+
if available_cpus is not None:
|
|
356
|
+
pulumi.set(__self__, "available_cpus", available_cpus)
|
|
357
|
+
if backup_configs is not None:
|
|
358
|
+
pulumi.set(__self__, "backup_configs", backup_configs)
|
|
359
|
+
if cloud_autonomous_vm_cluster_id is not None:
|
|
360
|
+
pulumi.set(__self__, "cloud_autonomous_vm_cluster_id", cloud_autonomous_vm_cluster_id)
|
|
361
|
+
if compartment_id is not None:
|
|
362
|
+
pulumi.set(__self__, "compartment_id", compartment_id)
|
|
363
|
+
if compute_model is not None:
|
|
364
|
+
pulumi.set(__self__, "compute_model", compute_model)
|
|
365
|
+
if dataguard_group_members is not None:
|
|
366
|
+
pulumi.set(__self__, "dataguard_group_members", dataguard_group_members)
|
|
367
|
+
if dataguards is not None:
|
|
368
|
+
pulumi.set(__self__, "dataguards", dataguards)
|
|
369
|
+
if db_name is not None:
|
|
370
|
+
pulumi.set(__self__, "db_name", db_name)
|
|
371
|
+
if db_split_threshold is not None:
|
|
372
|
+
pulumi.set(__self__, "db_split_threshold", db_split_threshold)
|
|
373
|
+
if db_unique_name is not None:
|
|
374
|
+
pulumi.set(__self__, "db_unique_name", db_unique_name)
|
|
375
|
+
if db_version is not None:
|
|
376
|
+
pulumi.set(__self__, "db_version", db_version)
|
|
377
|
+
if defined_tags is not None:
|
|
378
|
+
pulumi.set(__self__, "defined_tags", defined_tags)
|
|
379
|
+
if display_name is not None:
|
|
380
|
+
pulumi.set(__self__, "display_name", display_name)
|
|
381
|
+
if distribution_affinity is not None:
|
|
382
|
+
pulumi.set(__self__, "distribution_affinity", distribution_affinity)
|
|
383
|
+
if dst_file_version is not None:
|
|
384
|
+
pulumi.set(__self__, "dst_file_version", dst_file_version)
|
|
385
|
+
if fast_start_fail_over_lag_limit_in_seconds is not None:
|
|
386
|
+
pulumi.set(__self__, "fast_start_fail_over_lag_limit_in_seconds", fast_start_fail_over_lag_limit_in_seconds)
|
|
387
|
+
if freeform_tags is not None:
|
|
388
|
+
pulumi.set(__self__, "freeform_tags", freeform_tags)
|
|
389
|
+
if infrastructure_type is not None:
|
|
390
|
+
pulumi.set(__self__, "infrastructure_type", infrastructure_type)
|
|
391
|
+
if is_automatic_failover_enabled is not None:
|
|
392
|
+
pulumi.set(__self__, "is_automatic_failover_enabled", is_automatic_failover_enabled)
|
|
393
|
+
if is_data_guard_enabled is not None:
|
|
394
|
+
pulumi.set(__self__, "is_data_guard_enabled", is_data_guard_enabled)
|
|
395
|
+
if is_dst_file_update_enabled is not None:
|
|
396
|
+
pulumi.set(__self__, "is_dst_file_update_enabled", is_dst_file_update_enabled)
|
|
397
|
+
if is_multiple_standby is not None:
|
|
398
|
+
pulumi.set(__self__, "is_multiple_standby", is_multiple_standby)
|
|
399
|
+
if key_history_entries is not None:
|
|
400
|
+
pulumi.set(__self__, "key_history_entries", key_history_entries)
|
|
401
|
+
if key_store_id is not None:
|
|
402
|
+
pulumi.set(__self__, "key_store_id", key_store_id)
|
|
403
|
+
if key_store_wallet_name is not None:
|
|
404
|
+
pulumi.set(__self__, "key_store_wallet_name", key_store_wallet_name)
|
|
405
|
+
if kms_key_id is not None:
|
|
406
|
+
pulumi.set(__self__, "kms_key_id", kms_key_id)
|
|
407
|
+
if kms_key_version_id is not None:
|
|
408
|
+
pulumi.set(__self__, "kms_key_version_id", kms_key_version_id)
|
|
409
|
+
if largest_provisionable_autonomous_database_in_cpus is not None:
|
|
410
|
+
pulumi.set(__self__, "largest_provisionable_autonomous_database_in_cpus", largest_provisionable_autonomous_database_in_cpus)
|
|
411
|
+
if last_maintenance_run_id is not None:
|
|
412
|
+
pulumi.set(__self__, "last_maintenance_run_id", last_maintenance_run_id)
|
|
413
|
+
if lifecycle_details is not None:
|
|
414
|
+
pulumi.set(__self__, "lifecycle_details", lifecycle_details)
|
|
415
|
+
if list_one_off_patches is not None:
|
|
416
|
+
pulumi.set(__self__, "list_one_off_patches", list_one_off_patches)
|
|
417
|
+
if maintenance_windows is not None:
|
|
418
|
+
pulumi.set(__self__, "maintenance_windows", maintenance_windows)
|
|
419
|
+
if memory_per_oracle_compute_unit_in_gbs is not None:
|
|
420
|
+
pulumi.set(__self__, "memory_per_oracle_compute_unit_in_gbs", memory_per_oracle_compute_unit_in_gbs)
|
|
421
|
+
if net_services_architecture is not None:
|
|
422
|
+
pulumi.set(__self__, "net_services_architecture", net_services_architecture)
|
|
423
|
+
if next_maintenance_run_id is not None:
|
|
424
|
+
pulumi.set(__self__, "next_maintenance_run_id", next_maintenance_run_id)
|
|
425
|
+
if patch_id is not None:
|
|
426
|
+
pulumi.set(__self__, "patch_id", patch_id)
|
|
427
|
+
if patch_model is not None:
|
|
428
|
+
pulumi.set(__self__, "patch_model", patch_model)
|
|
429
|
+
if peer_autonomous_container_database_backup_config is not None:
|
|
430
|
+
pulumi.set(__self__, "peer_autonomous_container_database_backup_config", peer_autonomous_container_database_backup_config)
|
|
431
|
+
if peer_autonomous_container_database_compartment_id is not None:
|
|
432
|
+
pulumi.set(__self__, "peer_autonomous_container_database_compartment_id", peer_autonomous_container_database_compartment_id)
|
|
433
|
+
if peer_autonomous_container_database_display_name is not None:
|
|
434
|
+
pulumi.set(__self__, "peer_autonomous_container_database_display_name", peer_autonomous_container_database_display_name)
|
|
435
|
+
if peer_autonomous_vm_cluster_id is not None:
|
|
436
|
+
pulumi.set(__self__, "peer_autonomous_vm_cluster_id", peer_autonomous_vm_cluster_id)
|
|
437
|
+
if peer_cloud_autonomous_vm_cluster_id is not None:
|
|
438
|
+
pulumi.set(__self__, "peer_cloud_autonomous_vm_cluster_id", peer_cloud_autonomous_vm_cluster_id)
|
|
439
|
+
if peer_db_unique_name is not None:
|
|
440
|
+
pulumi.set(__self__, "peer_db_unique_name", peer_db_unique_name)
|
|
441
|
+
if protection_mode is not None:
|
|
442
|
+
pulumi.set(__self__, "protection_mode", protection_mode)
|
|
443
|
+
if provisionable_cpuses is not None:
|
|
444
|
+
pulumi.set(__self__, "provisionable_cpuses", provisionable_cpuses)
|
|
445
|
+
if provisioned_cpus is not None:
|
|
446
|
+
pulumi.set(__self__, "provisioned_cpus", provisioned_cpus)
|
|
447
|
+
if reclaimable_cpus is not None:
|
|
448
|
+
pulumi.set(__self__, "reclaimable_cpus", reclaimable_cpus)
|
|
449
|
+
if reserved_cpus is not None:
|
|
450
|
+
pulumi.set(__self__, "reserved_cpus", reserved_cpus)
|
|
451
|
+
if role is not None:
|
|
452
|
+
pulumi.set(__self__, "role", role)
|
|
453
|
+
if service_level_agreement_type is not None:
|
|
454
|
+
pulumi.set(__self__, "service_level_agreement_type", service_level_agreement_type)
|
|
455
|
+
if standby_maintenance_buffer_in_days is not None:
|
|
456
|
+
pulumi.set(__self__, "standby_maintenance_buffer_in_days", standby_maintenance_buffer_in_days)
|
|
457
|
+
if state is not None:
|
|
458
|
+
pulumi.set(__self__, "state", state)
|
|
459
|
+
if time_created is not None:
|
|
460
|
+
pulumi.set(__self__, "time_created", time_created)
|
|
461
|
+
if time_of_last_backup is not None:
|
|
462
|
+
pulumi.set(__self__, "time_of_last_backup", time_of_last_backup)
|
|
463
|
+
if time_snapshot_standby_revert is not None:
|
|
464
|
+
pulumi.set(__self__, "time_snapshot_standby_revert", time_snapshot_standby_revert)
|
|
465
|
+
if total_cpus is not None:
|
|
466
|
+
pulumi.set(__self__, "total_cpus", total_cpus)
|
|
467
|
+
if vault_id is not None:
|
|
468
|
+
pulumi.set(__self__, "vault_id", vault_id)
|
|
469
|
+
if version_preference is not None:
|
|
470
|
+
pulumi.set(__self__, "version_preference", version_preference)
|
|
471
|
+
if vm_failover_reservation is not None:
|
|
472
|
+
pulumi.set(__self__, "vm_failover_reservation", vm_failover_reservation)
|
|
473
|
+
|
|
474
|
+
@property
|
|
475
|
+
@pulumi.getter(name="autonomousContainerDatabaseId")
|
|
476
|
+
def autonomous_container_database_id(self) -> Optional[pulumi.Input[str]]:
|
|
477
|
+
"""
|
|
478
|
+
The Autonomous Container Database [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm).
|
|
479
|
+
"""
|
|
480
|
+
return pulumi.get(self, "autonomous_container_database_id")
|
|
481
|
+
|
|
482
|
+
@autonomous_container_database_id.setter
|
|
483
|
+
def autonomous_container_database_id(self, value: Optional[pulumi.Input[str]]):
|
|
484
|
+
pulumi.set(self, "autonomous_container_database_id", value)
|
|
485
|
+
|
|
486
|
+
@property
|
|
487
|
+
@pulumi.getter(name="autonomousExadataInfrastructureId")
|
|
488
|
+
def autonomous_exadata_infrastructure_id(self) -> Optional[pulumi.Input[str]]:
|
|
489
|
+
"""
|
|
490
|
+
**No longer used.** For Autonomous Database on dedicated Exadata infrastructure, the container database is created within a specified `cloudAutonomousVmCluster`.
|
|
491
|
+
"""
|
|
492
|
+
return pulumi.get(self, "autonomous_exadata_infrastructure_id")
|
|
493
|
+
|
|
494
|
+
@autonomous_exadata_infrastructure_id.setter
|
|
495
|
+
def autonomous_exadata_infrastructure_id(self, value: Optional[pulumi.Input[str]]):
|
|
496
|
+
pulumi.set(self, "autonomous_exadata_infrastructure_id", value)
|
|
497
|
+
|
|
498
|
+
@property
|
|
499
|
+
@pulumi.getter(name="autonomousVmClusterId")
|
|
500
|
+
def autonomous_vm_cluster_id(self) -> Optional[pulumi.Input[str]]:
|
|
501
|
+
"""
|
|
502
|
+
The OCID of the Autonomous VM Cluster.
|
|
503
|
+
"""
|
|
504
|
+
return pulumi.get(self, "autonomous_vm_cluster_id")
|
|
505
|
+
|
|
506
|
+
@autonomous_vm_cluster_id.setter
|
|
507
|
+
def autonomous_vm_cluster_id(self, value: Optional[pulumi.Input[str]]):
|
|
508
|
+
pulumi.set(self, "autonomous_vm_cluster_id", value)
|
|
509
|
+
|
|
510
|
+
@property
|
|
511
|
+
@pulumi.getter(name="availabilityDomain")
|
|
512
|
+
def availability_domain(self) -> Optional[pulumi.Input[str]]:
|
|
513
|
+
"""
|
|
514
|
+
The domain of the Autonomous Container Database
|
|
515
|
+
"""
|
|
516
|
+
return pulumi.get(self, "availability_domain")
|
|
517
|
+
|
|
518
|
+
@availability_domain.setter
|
|
519
|
+
def availability_domain(self, value: Optional[pulumi.Input[str]]):
|
|
520
|
+
pulumi.set(self, "availability_domain", value)
|
|
521
|
+
|
|
522
|
+
@property
|
|
523
|
+
@pulumi.getter(name="availableCpus")
|
|
524
|
+
def available_cpus(self) -> Optional[pulumi.Input[float]]:
|
|
525
|
+
"""
|
|
526
|
+
Sum of CPUs available on the Autonomous VM Cluster + Sum of reclaimable CPUs available in the Autonomous Container Database.
|
|
527
|
+
"""
|
|
528
|
+
return pulumi.get(self, "available_cpus")
|
|
529
|
+
|
|
530
|
+
@available_cpus.setter
|
|
531
|
+
def available_cpus(self, value: Optional[pulumi.Input[float]]):
|
|
532
|
+
pulumi.set(self, "available_cpus", value)
|
|
533
|
+
|
|
534
|
+
@property
|
|
535
|
+
@pulumi.getter(name="backupConfigs")
|
|
536
|
+
def backup_configs(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['AutonomousContainerDatabaseAddStandbyBackupConfigArgs']]]]:
|
|
537
|
+
"""
|
|
538
|
+
Backup options for the Autonomous Container Database.
|
|
539
|
+
"""
|
|
540
|
+
return pulumi.get(self, "backup_configs")
|
|
541
|
+
|
|
542
|
+
@backup_configs.setter
|
|
543
|
+
def backup_configs(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['AutonomousContainerDatabaseAddStandbyBackupConfigArgs']]]]):
|
|
544
|
+
pulumi.set(self, "backup_configs", value)
|
|
545
|
+
|
|
546
|
+
@property
|
|
547
|
+
@pulumi.getter(name="cloudAutonomousVmClusterId")
|
|
548
|
+
def cloud_autonomous_vm_cluster_id(self) -> Optional[pulumi.Input[str]]:
|
|
549
|
+
"""
|
|
550
|
+
The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the cloud Autonomous Exadata VM Cluster.
|
|
551
|
+
"""
|
|
552
|
+
return pulumi.get(self, "cloud_autonomous_vm_cluster_id")
|
|
553
|
+
|
|
554
|
+
@cloud_autonomous_vm_cluster_id.setter
|
|
555
|
+
def cloud_autonomous_vm_cluster_id(self, value: Optional[pulumi.Input[str]]):
|
|
556
|
+
pulumi.set(self, "cloud_autonomous_vm_cluster_id", value)
|
|
557
|
+
|
|
558
|
+
@property
|
|
559
|
+
@pulumi.getter(name="compartmentId")
|
|
560
|
+
def compartment_id(self) -> Optional[pulumi.Input[str]]:
|
|
561
|
+
"""
|
|
562
|
+
The OCID of the compartment.
|
|
563
|
+
"""
|
|
564
|
+
return pulumi.get(self, "compartment_id")
|
|
565
|
+
|
|
566
|
+
@compartment_id.setter
|
|
567
|
+
def compartment_id(self, value: Optional[pulumi.Input[str]]):
|
|
568
|
+
pulumi.set(self, "compartment_id", value)
|
|
569
|
+
|
|
570
|
+
@property
|
|
571
|
+
@pulumi.getter(name="computeModel")
|
|
572
|
+
def compute_model(self) -> Optional[pulumi.Input[str]]:
|
|
573
|
+
"""
|
|
574
|
+
The compute model of the Autonomous Container Database. For Autonomous Database on Dedicated Exadata Infrastructure, the CPU type (ECPUs or OCPUs) is determined by the parent Autonomous Exadata VM Cluster's compute model. ECPU compute model is the recommended model and OCPU compute model is legacy. See [Compute Models in Autonomous Database on Dedicated Exadata Infrastructure](https://docs.oracle.com/en/cloud/paas/autonomous-database/dedicated/adbak) for more details.
|
|
575
|
+
"""
|
|
576
|
+
return pulumi.get(self, "compute_model")
|
|
577
|
+
|
|
578
|
+
@compute_model.setter
|
|
579
|
+
def compute_model(self, value: Optional[pulumi.Input[str]]):
|
|
580
|
+
pulumi.set(self, "compute_model", value)
|
|
581
|
+
|
|
582
|
+
@property
|
|
583
|
+
@pulumi.getter(name="dataguardGroupMembers")
|
|
584
|
+
def dataguard_group_members(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['AutonomousContainerDatabaseAddStandbyDataguardGroupMemberArgs']]]]:
|
|
585
|
+
"""
|
|
586
|
+
Array of Dg associations.
|
|
587
|
+
"""
|
|
588
|
+
return pulumi.get(self, "dataguard_group_members")
|
|
589
|
+
|
|
590
|
+
@dataguard_group_members.setter
|
|
591
|
+
def dataguard_group_members(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['AutonomousContainerDatabaseAddStandbyDataguardGroupMemberArgs']]]]):
|
|
592
|
+
pulumi.set(self, "dataguard_group_members", value)
|
|
593
|
+
|
|
594
|
+
@property
|
|
595
|
+
@pulumi.getter
|
|
596
|
+
def dataguards(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['AutonomousContainerDatabaseAddStandbyDataguardArgs']]]]:
|
|
597
|
+
"""
|
|
598
|
+
The properties that define Autonomous Container Databases Dataguard.
|
|
599
|
+
"""
|
|
600
|
+
return pulumi.get(self, "dataguards")
|
|
601
|
+
|
|
602
|
+
@dataguards.setter
|
|
603
|
+
def dataguards(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['AutonomousContainerDatabaseAddStandbyDataguardArgs']]]]):
|
|
604
|
+
pulumi.set(self, "dataguards", value)
|
|
605
|
+
|
|
606
|
+
@property
|
|
607
|
+
@pulumi.getter(name="dbName")
|
|
608
|
+
def db_name(self) -> Optional[pulumi.Input[str]]:
|
|
609
|
+
"""
|
|
610
|
+
The Database name for the Autonomous Container Database. The name must be unique within the Cloud Autonomous VM Cluster, starting with an alphabetic character, followed by 1 to 7 alphanumeric characters.
|
|
611
|
+
"""
|
|
612
|
+
return pulumi.get(self, "db_name")
|
|
613
|
+
|
|
614
|
+
@db_name.setter
|
|
615
|
+
def db_name(self, value: Optional[pulumi.Input[str]]):
|
|
616
|
+
pulumi.set(self, "db_name", value)
|
|
617
|
+
|
|
618
|
+
@property
|
|
619
|
+
@pulumi.getter(name="dbSplitThreshold")
|
|
620
|
+
def db_split_threshold(self) -> Optional[pulumi.Input[int]]:
|
|
621
|
+
"""
|
|
622
|
+
The CPU value beyond which an Autonomous Database will be opened across multiple nodes. The default value of this attribute is 16 for OCPUs and 64 for ECPUs.
|
|
623
|
+
"""
|
|
624
|
+
return pulumi.get(self, "db_split_threshold")
|
|
625
|
+
|
|
626
|
+
@db_split_threshold.setter
|
|
627
|
+
def db_split_threshold(self, value: Optional[pulumi.Input[int]]):
|
|
628
|
+
pulumi.set(self, "db_split_threshold", value)
|
|
629
|
+
|
|
630
|
+
@property
|
|
631
|
+
@pulumi.getter(name="dbUniqueName")
|
|
632
|
+
def db_unique_name(self) -> Optional[pulumi.Input[str]]:
|
|
633
|
+
return pulumi.get(self, "db_unique_name")
|
|
634
|
+
|
|
635
|
+
@db_unique_name.setter
|
|
636
|
+
def db_unique_name(self, value: Optional[pulumi.Input[str]]):
|
|
637
|
+
pulumi.set(self, "db_unique_name", value)
|
|
638
|
+
|
|
639
|
+
@property
|
|
640
|
+
@pulumi.getter(name="dbVersion")
|
|
641
|
+
def db_version(self) -> Optional[pulumi.Input[str]]:
|
|
642
|
+
"""
|
|
643
|
+
Oracle Database version of the Autonomous Container Database.
|
|
644
|
+
"""
|
|
645
|
+
return pulumi.get(self, "db_version")
|
|
646
|
+
|
|
647
|
+
@db_version.setter
|
|
648
|
+
def db_version(self, value: Optional[pulumi.Input[str]]):
|
|
649
|
+
pulumi.set(self, "db_version", value)
|
|
650
|
+
|
|
651
|
+
@property
|
|
652
|
+
@pulumi.getter(name="definedTags")
|
|
653
|
+
def defined_tags(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
|
|
654
|
+
"""
|
|
655
|
+
Defined tags for this resource. Each key is predefined and scoped to a namespace. For more information, see [Resource Tags](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/resourcetags.htm).
|
|
656
|
+
"""
|
|
657
|
+
return pulumi.get(self, "defined_tags")
|
|
658
|
+
|
|
659
|
+
@defined_tags.setter
|
|
660
|
+
def defined_tags(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]):
|
|
661
|
+
pulumi.set(self, "defined_tags", value)
|
|
662
|
+
|
|
663
|
+
@property
|
|
664
|
+
@pulumi.getter(name="displayName")
|
|
665
|
+
def display_name(self) -> Optional[pulumi.Input[str]]:
|
|
666
|
+
"""
|
|
667
|
+
The user-provided name for the Autonomous Container Database.
|
|
668
|
+
"""
|
|
669
|
+
return pulumi.get(self, "display_name")
|
|
670
|
+
|
|
671
|
+
@display_name.setter
|
|
672
|
+
def display_name(self, value: Optional[pulumi.Input[str]]):
|
|
673
|
+
pulumi.set(self, "display_name", value)
|
|
674
|
+
|
|
675
|
+
@property
|
|
676
|
+
@pulumi.getter(name="distributionAffinity")
|
|
677
|
+
def distribution_affinity(self) -> Optional[pulumi.Input[str]]:
|
|
678
|
+
"""
|
|
679
|
+
Determines whether an Autonomous Database must be opened across the maximum number of nodes or the least number of nodes. By default, Minimum nodes is selected.
|
|
680
|
+
"""
|
|
681
|
+
return pulumi.get(self, "distribution_affinity")
|
|
682
|
+
|
|
683
|
+
@distribution_affinity.setter
|
|
684
|
+
def distribution_affinity(self, value: Optional[pulumi.Input[str]]):
|
|
685
|
+
pulumi.set(self, "distribution_affinity", value)
|
|
686
|
+
|
|
687
|
+
@property
|
|
688
|
+
@pulumi.getter(name="dstFileVersion")
|
|
689
|
+
def dst_file_version(self) -> Optional[pulumi.Input[str]]:
|
|
690
|
+
"""
|
|
691
|
+
DST Time-Zone File version of the Autonomous Container Database.
|
|
692
|
+
"""
|
|
693
|
+
return pulumi.get(self, "dst_file_version")
|
|
694
|
+
|
|
695
|
+
@dst_file_version.setter
|
|
696
|
+
def dst_file_version(self, value: Optional[pulumi.Input[str]]):
|
|
697
|
+
pulumi.set(self, "dst_file_version", value)
|
|
698
|
+
|
|
699
|
+
@property
|
|
700
|
+
@pulumi.getter(name="fastStartFailOverLagLimitInSeconds")
|
|
701
|
+
def fast_start_fail_over_lag_limit_in_seconds(self) -> Optional[pulumi.Input[int]]:
|
|
702
|
+
"""
|
|
703
|
+
The lag time for my preference based on data loss tolerance in seconds.
|
|
704
|
+
"""
|
|
705
|
+
return pulumi.get(self, "fast_start_fail_over_lag_limit_in_seconds")
|
|
706
|
+
|
|
707
|
+
@fast_start_fail_over_lag_limit_in_seconds.setter
|
|
708
|
+
def fast_start_fail_over_lag_limit_in_seconds(self, value: Optional[pulumi.Input[int]]):
|
|
709
|
+
pulumi.set(self, "fast_start_fail_over_lag_limit_in_seconds", value)
|
|
710
|
+
|
|
711
|
+
@property
|
|
712
|
+
@pulumi.getter(name="freeformTags")
|
|
713
|
+
def freeform_tags(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
|
|
714
|
+
"""
|
|
715
|
+
Free-form tags for this resource. Each tag is a simple key-value pair with no predefined name, type, or namespace. For more information, see [Resource Tags](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/resourcetags.htm). Example: `{"Department": "Finance"}`
|
|
716
|
+
"""
|
|
717
|
+
return pulumi.get(self, "freeform_tags")
|
|
718
|
+
|
|
719
|
+
@freeform_tags.setter
|
|
720
|
+
def freeform_tags(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]):
|
|
721
|
+
pulumi.set(self, "freeform_tags", value)
|
|
722
|
+
|
|
723
|
+
@property
|
|
724
|
+
@pulumi.getter(name="infrastructureType")
|
|
725
|
+
def infrastructure_type(self) -> Optional[pulumi.Input[str]]:
|
|
726
|
+
"""
|
|
727
|
+
The infrastructure type this resource belongs to.
|
|
728
|
+
"""
|
|
729
|
+
return pulumi.get(self, "infrastructure_type")
|
|
730
|
+
|
|
731
|
+
@infrastructure_type.setter
|
|
732
|
+
def infrastructure_type(self, value: Optional[pulumi.Input[str]]):
|
|
733
|
+
pulumi.set(self, "infrastructure_type", value)
|
|
734
|
+
|
|
735
|
+
@property
|
|
736
|
+
@pulumi.getter(name="isAutomaticFailoverEnabled")
|
|
737
|
+
def is_automatic_failover_enabled(self) -> Optional[pulumi.Input[bool]]:
|
|
738
|
+
"""
|
|
739
|
+
Indicates whether Automatic Failover is enabled for Autonomous Container Database Dataguard Association
|
|
740
|
+
"""
|
|
741
|
+
return pulumi.get(self, "is_automatic_failover_enabled")
|
|
742
|
+
|
|
743
|
+
@is_automatic_failover_enabled.setter
|
|
744
|
+
def is_automatic_failover_enabled(self, value: Optional[pulumi.Input[bool]]):
|
|
745
|
+
pulumi.set(self, "is_automatic_failover_enabled", value)
|
|
746
|
+
|
|
747
|
+
@property
|
|
748
|
+
@pulumi.getter(name="isDataGuardEnabled")
|
|
749
|
+
def is_data_guard_enabled(self) -> Optional[pulumi.Input[bool]]:
|
|
750
|
+
"""
|
|
751
|
+
**Deprecated.** Indicates whether the Autonomous Database has local (in-region) Data Guard enabled. Not applicable to cross-region Autonomous Data Guard associations, or to Autonomous Databases using dedicated Exadata infrastructure or Exadata Cloud@Customer infrastructure.
|
|
752
|
+
"""
|
|
753
|
+
return pulumi.get(self, "is_data_guard_enabled")
|
|
754
|
+
|
|
755
|
+
@is_data_guard_enabled.setter
|
|
756
|
+
def is_data_guard_enabled(self, value: Optional[pulumi.Input[bool]]):
|
|
757
|
+
pulumi.set(self, "is_data_guard_enabled", value)
|
|
758
|
+
|
|
759
|
+
@property
|
|
760
|
+
@pulumi.getter(name="isDstFileUpdateEnabled")
|
|
761
|
+
def is_dst_file_update_enabled(self) -> Optional[pulumi.Input[bool]]:
|
|
762
|
+
"""
|
|
763
|
+
Indicates if an automatic DST Time Zone file update is enabled for the Autonomous Container Database. If enabled along with Release Update, patching will be done in a Non-Rolling manner.
|
|
764
|
+
"""
|
|
765
|
+
return pulumi.get(self, "is_dst_file_update_enabled")
|
|
766
|
+
|
|
767
|
+
@is_dst_file_update_enabled.setter
|
|
768
|
+
def is_dst_file_update_enabled(self, value: Optional[pulumi.Input[bool]]):
|
|
769
|
+
pulumi.set(self, "is_dst_file_update_enabled", value)
|
|
770
|
+
|
|
771
|
+
@property
|
|
772
|
+
@pulumi.getter(name="isMultipleStandby")
|
|
773
|
+
def is_multiple_standby(self) -> Optional[pulumi.Input[bool]]:
|
|
774
|
+
"""
|
|
775
|
+
Whether it is multiple standby Autonomous Dataguard
|
|
776
|
+
"""
|
|
777
|
+
return pulumi.get(self, "is_multiple_standby")
|
|
778
|
+
|
|
779
|
+
@is_multiple_standby.setter
|
|
780
|
+
def is_multiple_standby(self, value: Optional[pulumi.Input[bool]]):
|
|
781
|
+
pulumi.set(self, "is_multiple_standby", value)
|
|
782
|
+
|
|
783
|
+
@property
|
|
784
|
+
@pulumi.getter(name="keyHistoryEntries")
|
|
785
|
+
def key_history_entries(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['AutonomousContainerDatabaseAddStandbyKeyHistoryEntryArgs']]]]:
|
|
786
|
+
"""
|
|
787
|
+
Key History Entry.
|
|
788
|
+
"""
|
|
789
|
+
return pulumi.get(self, "key_history_entries")
|
|
790
|
+
|
|
791
|
+
@key_history_entries.setter
|
|
792
|
+
def key_history_entries(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['AutonomousContainerDatabaseAddStandbyKeyHistoryEntryArgs']]]]):
|
|
793
|
+
pulumi.set(self, "key_history_entries", value)
|
|
794
|
+
|
|
795
|
+
@property
|
|
796
|
+
@pulumi.getter(name="keyStoreId")
|
|
797
|
+
def key_store_id(self) -> Optional[pulumi.Input[str]]:
|
|
798
|
+
"""
|
|
799
|
+
The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the key store of Oracle Vault.
|
|
800
|
+
"""
|
|
801
|
+
return pulumi.get(self, "key_store_id")
|
|
802
|
+
|
|
803
|
+
@key_store_id.setter
|
|
804
|
+
def key_store_id(self, value: Optional[pulumi.Input[str]]):
|
|
805
|
+
pulumi.set(self, "key_store_id", value)
|
|
806
|
+
|
|
807
|
+
@property
|
|
808
|
+
@pulumi.getter(name="keyStoreWalletName")
|
|
809
|
+
def key_store_wallet_name(self) -> Optional[pulumi.Input[str]]:
|
|
810
|
+
"""
|
|
811
|
+
The wallet name for Oracle Key Vault.
|
|
812
|
+
"""
|
|
813
|
+
return pulumi.get(self, "key_store_wallet_name")
|
|
814
|
+
|
|
815
|
+
@key_store_wallet_name.setter
|
|
816
|
+
def key_store_wallet_name(self, value: Optional[pulumi.Input[str]]):
|
|
817
|
+
pulumi.set(self, "key_store_wallet_name", value)
|
|
818
|
+
|
|
819
|
+
@property
|
|
820
|
+
@pulumi.getter(name="kmsKeyId")
|
|
821
|
+
def kms_key_id(self) -> Optional[pulumi.Input[str]]:
|
|
822
|
+
"""
|
|
823
|
+
The OCID of the key container that is used as the master encryption key in database transparent data encryption (TDE) operations.
|
|
824
|
+
"""
|
|
825
|
+
return pulumi.get(self, "kms_key_id")
|
|
826
|
+
|
|
827
|
+
@kms_key_id.setter
|
|
828
|
+
def kms_key_id(self, value: Optional[pulumi.Input[str]]):
|
|
829
|
+
pulumi.set(self, "kms_key_id", value)
|
|
830
|
+
|
|
831
|
+
@property
|
|
832
|
+
@pulumi.getter(name="kmsKeyVersionId")
|
|
833
|
+
def kms_key_version_id(self) -> Optional[pulumi.Input[str]]:
|
|
834
|
+
"""
|
|
835
|
+
The OCID of the key container version that is used in database transparent data encryption (TDE) operations KMS Key can have multiple key versions. If none is specified, the current key version (latest) of the Key Id is used for the operation. Autonomous Database Serverless does not use key versions, hence is not applicable for Autonomous Database Serverless instances.
|
|
836
|
+
"""
|
|
837
|
+
return pulumi.get(self, "kms_key_version_id")
|
|
838
|
+
|
|
839
|
+
@kms_key_version_id.setter
|
|
840
|
+
def kms_key_version_id(self, value: Optional[pulumi.Input[str]]):
|
|
841
|
+
pulumi.set(self, "kms_key_version_id", value)
|
|
842
|
+
|
|
843
|
+
@property
|
|
844
|
+
@pulumi.getter(name="largestProvisionableAutonomousDatabaseInCpus")
|
|
845
|
+
def largest_provisionable_autonomous_database_in_cpus(self) -> Optional[pulumi.Input[float]]:
|
|
846
|
+
"""
|
|
847
|
+
The largest Autonomous Database (CPU) that can be created in a new Autonomous Container Database.
|
|
848
|
+
"""
|
|
849
|
+
return pulumi.get(self, "largest_provisionable_autonomous_database_in_cpus")
|
|
850
|
+
|
|
851
|
+
@largest_provisionable_autonomous_database_in_cpus.setter
|
|
852
|
+
def largest_provisionable_autonomous_database_in_cpus(self, value: Optional[pulumi.Input[float]]):
|
|
853
|
+
pulumi.set(self, "largest_provisionable_autonomous_database_in_cpus", value)
|
|
854
|
+
|
|
855
|
+
@property
|
|
856
|
+
@pulumi.getter(name="lastMaintenanceRunId")
|
|
857
|
+
def last_maintenance_run_id(self) -> Optional[pulumi.Input[str]]:
|
|
858
|
+
"""
|
|
859
|
+
The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the last maintenance run.
|
|
860
|
+
"""
|
|
861
|
+
return pulumi.get(self, "last_maintenance_run_id")
|
|
862
|
+
|
|
863
|
+
@last_maintenance_run_id.setter
|
|
864
|
+
def last_maintenance_run_id(self, value: Optional[pulumi.Input[str]]):
|
|
865
|
+
pulumi.set(self, "last_maintenance_run_id", value)
|
|
866
|
+
|
|
867
|
+
@property
|
|
868
|
+
@pulumi.getter(name="lifecycleDetails")
|
|
869
|
+
def lifecycle_details(self) -> Optional[pulumi.Input[str]]:
|
|
870
|
+
"""
|
|
871
|
+
Additional information about the current lifecycle state.
|
|
872
|
+
"""
|
|
873
|
+
return pulumi.get(self, "lifecycle_details")
|
|
874
|
+
|
|
875
|
+
@lifecycle_details.setter
|
|
876
|
+
def lifecycle_details(self, value: Optional[pulumi.Input[str]]):
|
|
877
|
+
pulumi.set(self, "lifecycle_details", value)
|
|
878
|
+
|
|
879
|
+
@property
|
|
880
|
+
@pulumi.getter(name="listOneOffPatches")
|
|
881
|
+
def list_one_off_patches(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
882
|
+
"""
|
|
883
|
+
List of One-Off patches that has been successfully applied to Autonomous Container Database
|
|
884
|
+
"""
|
|
885
|
+
return pulumi.get(self, "list_one_off_patches")
|
|
886
|
+
|
|
887
|
+
@list_one_off_patches.setter
|
|
888
|
+
def list_one_off_patches(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
889
|
+
pulumi.set(self, "list_one_off_patches", value)
|
|
890
|
+
|
|
891
|
+
@property
|
|
892
|
+
@pulumi.getter(name="maintenanceWindows")
|
|
893
|
+
def maintenance_windows(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['AutonomousContainerDatabaseAddStandbyMaintenanceWindowArgs']]]]:
|
|
894
|
+
"""
|
|
895
|
+
The scheduling details for the quarterly maintenance window. Patching and system updates take place during the maintenance window.
|
|
896
|
+
"""
|
|
897
|
+
return pulumi.get(self, "maintenance_windows")
|
|
898
|
+
|
|
899
|
+
@maintenance_windows.setter
|
|
900
|
+
def maintenance_windows(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['AutonomousContainerDatabaseAddStandbyMaintenanceWindowArgs']]]]):
|
|
901
|
+
pulumi.set(self, "maintenance_windows", value)
|
|
902
|
+
|
|
903
|
+
@property
|
|
904
|
+
@pulumi.getter(name="memoryPerOracleComputeUnitInGbs")
|
|
905
|
+
def memory_per_oracle_compute_unit_in_gbs(self) -> Optional[pulumi.Input[int]]:
|
|
906
|
+
"""
|
|
907
|
+
The amount of memory (in GBs) enabled per ECPU or OCPU in the Autonomous VM Cluster.
|
|
908
|
+
"""
|
|
909
|
+
return pulumi.get(self, "memory_per_oracle_compute_unit_in_gbs")
|
|
910
|
+
|
|
911
|
+
@memory_per_oracle_compute_unit_in_gbs.setter
|
|
912
|
+
def memory_per_oracle_compute_unit_in_gbs(self, value: Optional[pulumi.Input[int]]):
|
|
913
|
+
pulumi.set(self, "memory_per_oracle_compute_unit_in_gbs", value)
|
|
914
|
+
|
|
915
|
+
@property
|
|
916
|
+
@pulumi.getter(name="netServicesArchitecture")
|
|
917
|
+
def net_services_architecture(self) -> Optional[pulumi.Input[str]]:
|
|
918
|
+
"""
|
|
919
|
+
Enabling SHARED server architecture enables a database server to allow many client processes to share very few server processes, thereby increasing the number of supported users.
|
|
920
|
+
"""
|
|
921
|
+
return pulumi.get(self, "net_services_architecture")
|
|
922
|
+
|
|
923
|
+
@net_services_architecture.setter
|
|
924
|
+
def net_services_architecture(self, value: Optional[pulumi.Input[str]]):
|
|
925
|
+
pulumi.set(self, "net_services_architecture", value)
|
|
926
|
+
|
|
927
|
+
@property
|
|
928
|
+
@pulumi.getter(name="nextMaintenanceRunId")
|
|
929
|
+
def next_maintenance_run_id(self) -> Optional[pulumi.Input[str]]:
|
|
930
|
+
"""
|
|
931
|
+
The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the next maintenance run.
|
|
932
|
+
"""
|
|
933
|
+
return pulumi.get(self, "next_maintenance_run_id")
|
|
934
|
+
|
|
935
|
+
@next_maintenance_run_id.setter
|
|
936
|
+
def next_maintenance_run_id(self, value: Optional[pulumi.Input[str]]):
|
|
937
|
+
pulumi.set(self, "next_maintenance_run_id", value)
|
|
938
|
+
|
|
939
|
+
@property
|
|
940
|
+
@pulumi.getter(name="patchId")
|
|
941
|
+
def patch_id(self) -> Optional[pulumi.Input[str]]:
|
|
942
|
+
"""
|
|
943
|
+
The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the last patch applied on the system.
|
|
944
|
+
"""
|
|
945
|
+
return pulumi.get(self, "patch_id")
|
|
946
|
+
|
|
947
|
+
@patch_id.setter
|
|
948
|
+
def patch_id(self, value: Optional[pulumi.Input[str]]):
|
|
949
|
+
pulumi.set(self, "patch_id", value)
|
|
950
|
+
|
|
951
|
+
@property
|
|
952
|
+
@pulumi.getter(name="patchModel")
|
|
953
|
+
def patch_model(self) -> Optional[pulumi.Input[str]]:
|
|
954
|
+
"""
|
|
955
|
+
Database patch model preference.
|
|
956
|
+
"""
|
|
957
|
+
return pulumi.get(self, "patch_model")
|
|
958
|
+
|
|
959
|
+
@patch_model.setter
|
|
960
|
+
def patch_model(self, value: Optional[pulumi.Input[str]]):
|
|
961
|
+
pulumi.set(self, "patch_model", value)
|
|
962
|
+
|
|
963
|
+
@property
|
|
964
|
+
@pulumi.getter(name="peerAutonomousContainerDatabaseBackupConfig")
|
|
965
|
+
def peer_autonomous_container_database_backup_config(self) -> Optional[pulumi.Input['AutonomousContainerDatabaseAddStandbyPeerAutonomousContainerDatabaseBackupConfigArgs']]:
|
|
966
|
+
"""
|
|
967
|
+
Backup options for the standby Autonomous Container Database.
|
|
968
|
+
"""
|
|
969
|
+
return pulumi.get(self, "peer_autonomous_container_database_backup_config")
|
|
970
|
+
|
|
971
|
+
@peer_autonomous_container_database_backup_config.setter
|
|
972
|
+
def peer_autonomous_container_database_backup_config(self, value: Optional[pulumi.Input['AutonomousContainerDatabaseAddStandbyPeerAutonomousContainerDatabaseBackupConfigArgs']]):
|
|
973
|
+
pulumi.set(self, "peer_autonomous_container_database_backup_config", value)
|
|
974
|
+
|
|
975
|
+
@property
|
|
976
|
+
@pulumi.getter(name="peerAutonomousContainerDatabaseCompartmentId")
|
|
977
|
+
def peer_autonomous_container_database_compartment_id(self) -> Optional[pulumi.Input[str]]:
|
|
978
|
+
"""
|
|
979
|
+
The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the compartment where the standby Autonomous Container Database will be created.
|
|
980
|
+
"""
|
|
981
|
+
return pulumi.get(self, "peer_autonomous_container_database_compartment_id")
|
|
982
|
+
|
|
983
|
+
@peer_autonomous_container_database_compartment_id.setter
|
|
984
|
+
def peer_autonomous_container_database_compartment_id(self, value: Optional[pulumi.Input[str]]):
|
|
985
|
+
pulumi.set(self, "peer_autonomous_container_database_compartment_id", value)
|
|
986
|
+
|
|
987
|
+
@property
|
|
988
|
+
@pulumi.getter(name="peerAutonomousContainerDatabaseDisplayName")
|
|
989
|
+
def peer_autonomous_container_database_display_name(self) -> Optional[pulumi.Input[str]]:
|
|
990
|
+
"""
|
|
991
|
+
The display name for the peer Autonomous Container Database.
|
|
992
|
+
"""
|
|
993
|
+
return pulumi.get(self, "peer_autonomous_container_database_display_name")
|
|
994
|
+
|
|
995
|
+
@peer_autonomous_container_database_display_name.setter
|
|
996
|
+
def peer_autonomous_container_database_display_name(self, value: Optional[pulumi.Input[str]]):
|
|
997
|
+
pulumi.set(self, "peer_autonomous_container_database_display_name", value)
|
|
998
|
+
|
|
999
|
+
@property
|
|
1000
|
+
@pulumi.getter(name="peerAutonomousVmClusterId")
|
|
1001
|
+
def peer_autonomous_vm_cluster_id(self) -> Optional[pulumi.Input[str]]:
|
|
1002
|
+
"""
|
|
1003
|
+
The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the peer Autonomous Exadata VM Cluster.
|
|
1004
|
+
"""
|
|
1005
|
+
return pulumi.get(self, "peer_autonomous_vm_cluster_id")
|
|
1006
|
+
|
|
1007
|
+
@peer_autonomous_vm_cluster_id.setter
|
|
1008
|
+
def peer_autonomous_vm_cluster_id(self, value: Optional[pulumi.Input[str]]):
|
|
1009
|
+
pulumi.set(self, "peer_autonomous_vm_cluster_id", value)
|
|
1010
|
+
|
|
1011
|
+
@property
|
|
1012
|
+
@pulumi.getter(name="peerCloudAutonomousVmClusterId")
|
|
1013
|
+
def peer_cloud_autonomous_vm_cluster_id(self) -> Optional[pulumi.Input[str]]:
|
|
1014
|
+
"""
|
|
1015
|
+
The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the peer cloud Autonomous Exadata VM Cluster.
|
|
1016
|
+
"""
|
|
1017
|
+
return pulumi.get(self, "peer_cloud_autonomous_vm_cluster_id")
|
|
1018
|
+
|
|
1019
|
+
@peer_cloud_autonomous_vm_cluster_id.setter
|
|
1020
|
+
def peer_cloud_autonomous_vm_cluster_id(self, value: Optional[pulumi.Input[str]]):
|
|
1021
|
+
pulumi.set(self, "peer_cloud_autonomous_vm_cluster_id", value)
|
|
1022
|
+
|
|
1023
|
+
@property
|
|
1024
|
+
@pulumi.getter(name="peerDbUniqueName")
|
|
1025
|
+
def peer_db_unique_name(self) -> Optional[pulumi.Input[str]]:
|
|
1026
|
+
"""
|
|
1027
|
+
Specifies the `DB_UNIQUE_NAME` of the peer database to be created.
|
|
1028
|
+
"""
|
|
1029
|
+
return pulumi.get(self, "peer_db_unique_name")
|
|
1030
|
+
|
|
1031
|
+
@peer_db_unique_name.setter
|
|
1032
|
+
def peer_db_unique_name(self, value: Optional[pulumi.Input[str]]):
|
|
1033
|
+
pulumi.set(self, "peer_db_unique_name", value)
|
|
1034
|
+
|
|
1035
|
+
@property
|
|
1036
|
+
@pulumi.getter(name="protectionMode")
|
|
1037
|
+
def protection_mode(self) -> Optional[pulumi.Input[str]]:
|
|
1038
|
+
"""
|
|
1039
|
+
The protection mode of this Autonomous Data Guard association. For more information, see [Oracle Data Guard Protection Modes](http://docs.oracle.com/database/122/SBYDB/oracle-data-guard-protection-modes.htm#SBYDB02000) in the Oracle Data Guard documentation.
|
|
1040
|
+
"""
|
|
1041
|
+
return pulumi.get(self, "protection_mode")
|
|
1042
|
+
|
|
1043
|
+
@protection_mode.setter
|
|
1044
|
+
def protection_mode(self, value: Optional[pulumi.Input[str]]):
|
|
1045
|
+
pulumi.set(self, "protection_mode", value)
|
|
1046
|
+
|
|
1047
|
+
@property
|
|
1048
|
+
@pulumi.getter(name="provisionableCpuses")
|
|
1049
|
+
def provisionable_cpuses(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[float]]]]:
|
|
1050
|
+
"""
|
|
1051
|
+
An array of CPU values that can be used to successfully provision a single Autonomous Database.
|
|
1052
|
+
"""
|
|
1053
|
+
return pulumi.get(self, "provisionable_cpuses")
|
|
1054
|
+
|
|
1055
|
+
@provisionable_cpuses.setter
|
|
1056
|
+
def provisionable_cpuses(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[float]]]]):
|
|
1057
|
+
pulumi.set(self, "provisionable_cpuses", value)
|
|
1058
|
+
|
|
1059
|
+
@property
|
|
1060
|
+
@pulumi.getter(name="provisionedCpus")
|
|
1061
|
+
def provisioned_cpus(self) -> Optional[pulumi.Input[float]]:
|
|
1062
|
+
"""
|
|
1063
|
+
The number of CPUs provisioned in an Autonomous Container Database.
|
|
1064
|
+
"""
|
|
1065
|
+
return pulumi.get(self, "provisioned_cpus")
|
|
1066
|
+
|
|
1067
|
+
@provisioned_cpus.setter
|
|
1068
|
+
def provisioned_cpus(self, value: Optional[pulumi.Input[float]]):
|
|
1069
|
+
pulumi.set(self, "provisioned_cpus", value)
|
|
1070
|
+
|
|
1071
|
+
@property
|
|
1072
|
+
@pulumi.getter(name="reclaimableCpus")
|
|
1073
|
+
def reclaimable_cpus(self) -> Optional[pulumi.Input[float]]:
|
|
1074
|
+
"""
|
|
1075
|
+
CPUs that continue to be included in the count of CPUs available to the Autonomous Container Database even after one of its Autonomous Database is terminated or scaled down. You can release them to the available CPUs at its parent Autonomous VM Cluster level by restarting the Autonomous Container Database.
|
|
1076
|
+
"""
|
|
1077
|
+
return pulumi.get(self, "reclaimable_cpus")
|
|
1078
|
+
|
|
1079
|
+
@reclaimable_cpus.setter
|
|
1080
|
+
def reclaimable_cpus(self, value: Optional[pulumi.Input[float]]):
|
|
1081
|
+
pulumi.set(self, "reclaimable_cpus", value)
|
|
1082
|
+
|
|
1083
|
+
@property
|
|
1084
|
+
@pulumi.getter(name="reservedCpus")
|
|
1085
|
+
def reserved_cpus(self) -> Optional[pulumi.Input[float]]:
|
|
1086
|
+
"""
|
|
1087
|
+
The number of CPUs reserved in an Autonomous Container Database.
|
|
1088
|
+
"""
|
|
1089
|
+
return pulumi.get(self, "reserved_cpus")
|
|
1090
|
+
|
|
1091
|
+
@reserved_cpus.setter
|
|
1092
|
+
def reserved_cpus(self, value: Optional[pulumi.Input[float]]):
|
|
1093
|
+
pulumi.set(self, "reserved_cpus", value)
|
|
1094
|
+
|
|
1095
|
+
@property
|
|
1096
|
+
@pulumi.getter
|
|
1097
|
+
def role(self) -> Optional[pulumi.Input[str]]:
|
|
1098
|
+
"""
|
|
1099
|
+
The Data Guard role of the Autonomous Container Database or Autonomous Database, if Autonomous Data Guard is enabled.
|
|
1100
|
+
"""
|
|
1101
|
+
return pulumi.get(self, "role")
|
|
1102
|
+
|
|
1103
|
+
@role.setter
|
|
1104
|
+
def role(self, value: Optional[pulumi.Input[str]]):
|
|
1105
|
+
pulumi.set(self, "role", value)
|
|
1106
|
+
|
|
1107
|
+
@property
|
|
1108
|
+
@pulumi.getter(name="serviceLevelAgreementType")
|
|
1109
|
+
def service_level_agreement_type(self) -> Optional[pulumi.Input[str]]:
|
|
1110
|
+
"""
|
|
1111
|
+
The service level agreement type of the container database. The default is STANDARD.
|
|
1112
|
+
"""
|
|
1113
|
+
return pulumi.get(self, "service_level_agreement_type")
|
|
1114
|
+
|
|
1115
|
+
@service_level_agreement_type.setter
|
|
1116
|
+
def service_level_agreement_type(self, value: Optional[pulumi.Input[str]]):
|
|
1117
|
+
pulumi.set(self, "service_level_agreement_type", value)
|
|
1118
|
+
|
|
1119
|
+
@property
|
|
1120
|
+
@pulumi.getter(name="standbyMaintenanceBufferInDays")
|
|
1121
|
+
def standby_maintenance_buffer_in_days(self) -> Optional[pulumi.Input[int]]:
|
|
1122
|
+
"""
|
|
1123
|
+
The scheduling detail for the quarterly maintenance window of the standby Autonomous Container Database. This value represents the number of days before scheduled maintenance of the primary database.
|
|
1124
|
+
|
|
1125
|
+
|
|
1126
|
+
** IMPORTANT **
|
|
1127
|
+
Any change to a property that does not support update will force the destruction and recreation of the resource with the new property values
|
|
1128
|
+
"""
|
|
1129
|
+
return pulumi.get(self, "standby_maintenance_buffer_in_days")
|
|
1130
|
+
|
|
1131
|
+
@standby_maintenance_buffer_in_days.setter
|
|
1132
|
+
def standby_maintenance_buffer_in_days(self, value: Optional[pulumi.Input[int]]):
|
|
1133
|
+
pulumi.set(self, "standby_maintenance_buffer_in_days", value)
|
|
1134
|
+
|
|
1135
|
+
@property
|
|
1136
|
+
@pulumi.getter
|
|
1137
|
+
def state(self) -> Optional[pulumi.Input[str]]:
|
|
1138
|
+
"""
|
|
1139
|
+
The current state of the Autonomous Container Database.
|
|
1140
|
+
"""
|
|
1141
|
+
return pulumi.get(self, "state")
|
|
1142
|
+
|
|
1143
|
+
@state.setter
|
|
1144
|
+
def state(self, value: Optional[pulumi.Input[str]]):
|
|
1145
|
+
pulumi.set(self, "state", value)
|
|
1146
|
+
|
|
1147
|
+
@property
|
|
1148
|
+
@pulumi.getter(name="timeCreated")
|
|
1149
|
+
def time_created(self) -> Optional[pulumi.Input[str]]:
|
|
1150
|
+
"""
|
|
1151
|
+
The date and time the Autonomous Container Database was created.
|
|
1152
|
+
"""
|
|
1153
|
+
return pulumi.get(self, "time_created")
|
|
1154
|
+
|
|
1155
|
+
@time_created.setter
|
|
1156
|
+
def time_created(self, value: Optional[pulumi.Input[str]]):
|
|
1157
|
+
pulumi.set(self, "time_created", value)
|
|
1158
|
+
|
|
1159
|
+
@property
|
|
1160
|
+
@pulumi.getter(name="timeOfLastBackup")
|
|
1161
|
+
def time_of_last_backup(self) -> Optional[pulumi.Input[str]]:
|
|
1162
|
+
"""
|
|
1163
|
+
The timestamp of last successful backup. Here NULL value represents either there are no successful backups or backups are not configured for this Autonomous Container Database.
|
|
1164
|
+
"""
|
|
1165
|
+
return pulumi.get(self, "time_of_last_backup")
|
|
1166
|
+
|
|
1167
|
+
@time_of_last_backup.setter
|
|
1168
|
+
def time_of_last_backup(self, value: Optional[pulumi.Input[str]]):
|
|
1169
|
+
pulumi.set(self, "time_of_last_backup", value)
|
|
1170
|
+
|
|
1171
|
+
@property
|
|
1172
|
+
@pulumi.getter(name="timeSnapshotStandbyRevert")
|
|
1173
|
+
def time_snapshot_standby_revert(self) -> Optional[pulumi.Input[str]]:
|
|
1174
|
+
"""
|
|
1175
|
+
The date and time the Autonomous Container Database will be reverted to Standby from Snapshot Standby.
|
|
1176
|
+
"""
|
|
1177
|
+
return pulumi.get(self, "time_snapshot_standby_revert")
|
|
1178
|
+
|
|
1179
|
+
@time_snapshot_standby_revert.setter
|
|
1180
|
+
def time_snapshot_standby_revert(self, value: Optional[pulumi.Input[str]]):
|
|
1181
|
+
pulumi.set(self, "time_snapshot_standby_revert", value)
|
|
1182
|
+
|
|
1183
|
+
@property
|
|
1184
|
+
@pulumi.getter(name="totalCpus")
|
|
1185
|
+
def total_cpus(self) -> Optional[pulumi.Input[int]]:
|
|
1186
|
+
"""
|
|
1187
|
+
The number of CPUs allocated to the Autonomous VM cluster.
|
|
1188
|
+
"""
|
|
1189
|
+
return pulumi.get(self, "total_cpus")
|
|
1190
|
+
|
|
1191
|
+
@total_cpus.setter
|
|
1192
|
+
def total_cpus(self, value: Optional[pulumi.Input[int]]):
|
|
1193
|
+
pulumi.set(self, "total_cpus", value)
|
|
1194
|
+
|
|
1195
|
+
@property
|
|
1196
|
+
@pulumi.getter(name="vaultId")
|
|
1197
|
+
def vault_id(self) -> Optional[pulumi.Input[str]]:
|
|
1198
|
+
"""
|
|
1199
|
+
The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the Oracle Cloud Infrastructure [vault](https://docs.cloud.oracle.com/iaas/Content/KeyManagement/Concepts/keyoverview.htm#concepts). This parameter and `secretId` are required for Customer Managed Keys.
|
|
1200
|
+
"""
|
|
1201
|
+
return pulumi.get(self, "vault_id")
|
|
1202
|
+
|
|
1203
|
+
@vault_id.setter
|
|
1204
|
+
def vault_id(self, value: Optional[pulumi.Input[str]]):
|
|
1205
|
+
pulumi.set(self, "vault_id", value)
|
|
1206
|
+
|
|
1207
|
+
@property
|
|
1208
|
+
@pulumi.getter(name="versionPreference")
|
|
1209
|
+
def version_preference(self) -> Optional[pulumi.Input[str]]:
|
|
1210
|
+
"""
|
|
1211
|
+
The next maintenance version preference.
|
|
1212
|
+
"""
|
|
1213
|
+
return pulumi.get(self, "version_preference")
|
|
1214
|
+
|
|
1215
|
+
@version_preference.setter
|
|
1216
|
+
def version_preference(self, value: Optional[pulumi.Input[str]]):
|
|
1217
|
+
pulumi.set(self, "version_preference", value)
|
|
1218
|
+
|
|
1219
|
+
@property
|
|
1220
|
+
@pulumi.getter(name="vmFailoverReservation")
|
|
1221
|
+
def vm_failover_reservation(self) -> Optional[pulumi.Input[int]]:
|
|
1222
|
+
"""
|
|
1223
|
+
The percentage of CPUs reserved across nodes to support node failover. Allowed values are 0%, 25%, and 50%, with 50% being the default option.
|
|
1224
|
+
"""
|
|
1225
|
+
return pulumi.get(self, "vm_failover_reservation")
|
|
1226
|
+
|
|
1227
|
+
@vm_failover_reservation.setter
|
|
1228
|
+
def vm_failover_reservation(self, value: Optional[pulumi.Input[int]]):
|
|
1229
|
+
pulumi.set(self, "vm_failover_reservation", value)
|
|
1230
|
+
|
|
1231
|
+
|
|
1232
|
+
class AutonomousContainerDatabaseAddStandby(pulumi.CustomResource):
|
|
1233
|
+
@overload
|
|
1234
|
+
def __init__(__self__,
|
|
1235
|
+
resource_name: str,
|
|
1236
|
+
opts: Optional[pulumi.ResourceOptions] = None,
|
|
1237
|
+
autonomous_container_database_id: Optional[pulumi.Input[str]] = None,
|
|
1238
|
+
fast_start_fail_over_lag_limit_in_seconds: Optional[pulumi.Input[int]] = None,
|
|
1239
|
+
is_automatic_failover_enabled: Optional[pulumi.Input[bool]] = None,
|
|
1240
|
+
peer_autonomous_container_database_backup_config: Optional[pulumi.Input[Union['AutonomousContainerDatabaseAddStandbyPeerAutonomousContainerDatabaseBackupConfigArgs', 'AutonomousContainerDatabaseAddStandbyPeerAutonomousContainerDatabaseBackupConfigArgsDict']]] = None,
|
|
1241
|
+
peer_autonomous_container_database_compartment_id: Optional[pulumi.Input[str]] = None,
|
|
1242
|
+
peer_autonomous_container_database_display_name: Optional[pulumi.Input[str]] = None,
|
|
1243
|
+
peer_autonomous_vm_cluster_id: Optional[pulumi.Input[str]] = None,
|
|
1244
|
+
peer_cloud_autonomous_vm_cluster_id: Optional[pulumi.Input[str]] = None,
|
|
1245
|
+
peer_db_unique_name: Optional[pulumi.Input[str]] = None,
|
|
1246
|
+
protection_mode: Optional[pulumi.Input[str]] = None,
|
|
1247
|
+
standby_maintenance_buffer_in_days: Optional[pulumi.Input[int]] = None,
|
|
1248
|
+
__props__=None):
|
|
1249
|
+
"""
|
|
1250
|
+
This resource provides the Autonomous Container Database Add Standby resource in Oracle Cloud Infrastructure Database service.
|
|
1251
|
+
|
|
1252
|
+
Create Standby Autonomous Container Database.
|
|
1253
|
+
For more information about changing Autonomous Container Databases Add Standby, see
|
|
1254
|
+
[Create Standby Autonomous Container Database](https://docs.oracle.com/en/cloud/paas/autonomous-database/dedicated/adbcl/index.html#ADBCL-GUID-D3B503F1-0032-4B0D-9F00-ACAE8151AB80) and [Convert Snapshot Standby to Physical Standby](https://docs.oracle.com/en/cloud/paas/autonomous-database/dedicated/adbcl/index.html#ADBCL-GUID-E8D7E0EE-8244-467D-B33A-1BC6F969A0A4).
|
|
1255
|
+
|
|
1256
|
+
## Example Usage
|
|
1257
|
+
|
|
1258
|
+
```python
|
|
1259
|
+
import pulumi
|
|
1260
|
+
import pulumi_oci as oci
|
|
1261
|
+
|
|
1262
|
+
test_autonomous_container_database_add_standby = oci.database.AutonomousContainerDatabaseAddStandby("test_autonomous_container_database_add_standby",
|
|
1263
|
+
autonomous_container_database_id=test_autonomous_container_database["id"],
|
|
1264
|
+
fast_start_fail_over_lag_limit_in_seconds=autonomous_container_database_add_standby_fast_start_fail_over_lag_limit_in_seconds,
|
|
1265
|
+
is_automatic_failover_enabled=autonomous_container_database_add_standby_is_automatic_failover_enabled,
|
|
1266
|
+
peer_autonomous_container_database_backup_config={
|
|
1267
|
+
"backup_destination_details": [{
|
|
1268
|
+
"type": autonomous_container_database_add_standby_peer_autonomous_container_database_backup_config_backup_destination_details_type,
|
|
1269
|
+
"dbrs_policy_id": test_policy["id"],
|
|
1270
|
+
"id": autonomous_container_database_add_standby_peer_autonomous_container_database_backup_config_backup_destination_details_id,
|
|
1271
|
+
"internet_proxy": autonomous_container_database_add_standby_peer_autonomous_container_database_backup_config_backup_destination_details_internet_proxy,
|
|
1272
|
+
"vpc_password": autonomous_container_database_add_standby_peer_autonomous_container_database_backup_config_backup_destination_details_vpc_password,
|
|
1273
|
+
"vpc_user": autonomous_container_database_add_standby_peer_autonomous_container_database_backup_config_backup_destination_details_vpc_user,
|
|
1274
|
+
}],
|
|
1275
|
+
"recovery_window_in_days": autonomous_container_database_add_standby_peer_autonomous_container_database_backup_config_recovery_window_in_days,
|
|
1276
|
+
},
|
|
1277
|
+
peer_autonomous_container_database_compartment_id=test_compartment["id"],
|
|
1278
|
+
peer_autonomous_container_database_display_name=autonomous_container_database_add_standby_peer_autonomous_container_database_display_name,
|
|
1279
|
+
peer_autonomous_vm_cluster_id=test_autonomous_vm_cluster["id"],
|
|
1280
|
+
peer_cloud_autonomous_vm_cluster_id=test_cloud_autonomous_vm_cluster["id"],
|
|
1281
|
+
peer_db_unique_name=autonomous_container_database_add_standby_peer_db_unique_name,
|
|
1282
|
+
protection_mode=autonomous_container_database_add_standby_protection_mode,
|
|
1283
|
+
standby_maintenance_buffer_in_days=autonomous_container_database_add_standby_standby_maintenance_buffer_in_days)
|
|
1284
|
+
```
|
|
1285
|
+
|
|
1286
|
+
## Import
|
|
1287
|
+
|
|
1288
|
+
AutonomousContainerDatabaseAddStandby can be imported using the `id`, e.g.
|
|
1289
|
+
|
|
1290
|
+
```sh
|
|
1291
|
+
$ pulumi import oci:Database/autonomousContainerDatabaseAddStandby:AutonomousContainerDatabaseAddStandby test_autonomous_container_database_add_standby "id"
|
|
1292
|
+
```
|
|
1293
|
+
|
|
1294
|
+
:param str resource_name: The name of the resource.
|
|
1295
|
+
:param pulumi.ResourceOptions opts: Options for the resource.
|
|
1296
|
+
:param pulumi.Input[str] autonomous_container_database_id: The Autonomous Container Database [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm).
|
|
1297
|
+
:param pulumi.Input[int] fast_start_fail_over_lag_limit_in_seconds: The lag time for my preference based on data loss tolerance in seconds.
|
|
1298
|
+
:param pulumi.Input[bool] is_automatic_failover_enabled: Indicates whether Automatic Failover is enabled for Autonomous Container Database Dataguard Association
|
|
1299
|
+
:param pulumi.Input[Union['AutonomousContainerDatabaseAddStandbyPeerAutonomousContainerDatabaseBackupConfigArgs', 'AutonomousContainerDatabaseAddStandbyPeerAutonomousContainerDatabaseBackupConfigArgsDict']] peer_autonomous_container_database_backup_config: Backup options for the standby Autonomous Container Database.
|
|
1300
|
+
:param pulumi.Input[str] peer_autonomous_container_database_compartment_id: The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the compartment where the standby Autonomous Container Database will be created.
|
|
1301
|
+
:param pulumi.Input[str] peer_autonomous_container_database_display_name: The display name for the peer Autonomous Container Database.
|
|
1302
|
+
:param pulumi.Input[str] peer_autonomous_vm_cluster_id: The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the peer Autonomous Exadata VM Cluster.
|
|
1303
|
+
:param pulumi.Input[str] peer_cloud_autonomous_vm_cluster_id: The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the peer cloud Autonomous Exadata VM Cluster.
|
|
1304
|
+
:param pulumi.Input[str] peer_db_unique_name: Specifies the `DB_UNIQUE_NAME` of the peer database to be created.
|
|
1305
|
+
:param pulumi.Input[str] protection_mode: The protection mode of this Autonomous Data Guard association. For more information, see [Oracle Data Guard Protection Modes](http://docs.oracle.com/database/122/SBYDB/oracle-data-guard-protection-modes.htm#SBYDB02000) in the Oracle Data Guard documentation.
|
|
1306
|
+
:param pulumi.Input[int] standby_maintenance_buffer_in_days: The scheduling detail for the quarterly maintenance window of the standby Autonomous Container Database. This value represents the number of days before scheduled maintenance of the primary database.
|
|
1307
|
+
|
|
1308
|
+
|
|
1309
|
+
** IMPORTANT **
|
|
1310
|
+
Any change to a property that does not support update will force the destruction and recreation of the resource with the new property values
|
|
1311
|
+
"""
|
|
1312
|
+
...
|
|
1313
|
+
@overload
|
|
1314
|
+
def __init__(__self__,
|
|
1315
|
+
resource_name: str,
|
|
1316
|
+
args: AutonomousContainerDatabaseAddStandbyArgs,
|
|
1317
|
+
opts: Optional[pulumi.ResourceOptions] = None):
|
|
1318
|
+
"""
|
|
1319
|
+
This resource provides the Autonomous Container Database Add Standby resource in Oracle Cloud Infrastructure Database service.
|
|
1320
|
+
|
|
1321
|
+
Create Standby Autonomous Container Database.
|
|
1322
|
+
For more information about changing Autonomous Container Databases Add Standby, see
|
|
1323
|
+
[Create Standby Autonomous Container Database](https://docs.oracle.com/en/cloud/paas/autonomous-database/dedicated/adbcl/index.html#ADBCL-GUID-D3B503F1-0032-4B0D-9F00-ACAE8151AB80) and [Convert Snapshot Standby to Physical Standby](https://docs.oracle.com/en/cloud/paas/autonomous-database/dedicated/adbcl/index.html#ADBCL-GUID-E8D7E0EE-8244-467D-B33A-1BC6F969A0A4).
|
|
1324
|
+
|
|
1325
|
+
## Example Usage
|
|
1326
|
+
|
|
1327
|
+
```python
|
|
1328
|
+
import pulumi
|
|
1329
|
+
import pulumi_oci as oci
|
|
1330
|
+
|
|
1331
|
+
test_autonomous_container_database_add_standby = oci.database.AutonomousContainerDatabaseAddStandby("test_autonomous_container_database_add_standby",
|
|
1332
|
+
autonomous_container_database_id=test_autonomous_container_database["id"],
|
|
1333
|
+
fast_start_fail_over_lag_limit_in_seconds=autonomous_container_database_add_standby_fast_start_fail_over_lag_limit_in_seconds,
|
|
1334
|
+
is_automatic_failover_enabled=autonomous_container_database_add_standby_is_automatic_failover_enabled,
|
|
1335
|
+
peer_autonomous_container_database_backup_config={
|
|
1336
|
+
"backup_destination_details": [{
|
|
1337
|
+
"type": autonomous_container_database_add_standby_peer_autonomous_container_database_backup_config_backup_destination_details_type,
|
|
1338
|
+
"dbrs_policy_id": test_policy["id"],
|
|
1339
|
+
"id": autonomous_container_database_add_standby_peer_autonomous_container_database_backup_config_backup_destination_details_id,
|
|
1340
|
+
"internet_proxy": autonomous_container_database_add_standby_peer_autonomous_container_database_backup_config_backup_destination_details_internet_proxy,
|
|
1341
|
+
"vpc_password": autonomous_container_database_add_standby_peer_autonomous_container_database_backup_config_backup_destination_details_vpc_password,
|
|
1342
|
+
"vpc_user": autonomous_container_database_add_standby_peer_autonomous_container_database_backup_config_backup_destination_details_vpc_user,
|
|
1343
|
+
}],
|
|
1344
|
+
"recovery_window_in_days": autonomous_container_database_add_standby_peer_autonomous_container_database_backup_config_recovery_window_in_days,
|
|
1345
|
+
},
|
|
1346
|
+
peer_autonomous_container_database_compartment_id=test_compartment["id"],
|
|
1347
|
+
peer_autonomous_container_database_display_name=autonomous_container_database_add_standby_peer_autonomous_container_database_display_name,
|
|
1348
|
+
peer_autonomous_vm_cluster_id=test_autonomous_vm_cluster["id"],
|
|
1349
|
+
peer_cloud_autonomous_vm_cluster_id=test_cloud_autonomous_vm_cluster["id"],
|
|
1350
|
+
peer_db_unique_name=autonomous_container_database_add_standby_peer_db_unique_name,
|
|
1351
|
+
protection_mode=autonomous_container_database_add_standby_protection_mode,
|
|
1352
|
+
standby_maintenance_buffer_in_days=autonomous_container_database_add_standby_standby_maintenance_buffer_in_days)
|
|
1353
|
+
```
|
|
1354
|
+
|
|
1355
|
+
## Import
|
|
1356
|
+
|
|
1357
|
+
AutonomousContainerDatabaseAddStandby can be imported using the `id`, e.g.
|
|
1358
|
+
|
|
1359
|
+
```sh
|
|
1360
|
+
$ pulumi import oci:Database/autonomousContainerDatabaseAddStandby:AutonomousContainerDatabaseAddStandby test_autonomous_container_database_add_standby "id"
|
|
1361
|
+
```
|
|
1362
|
+
|
|
1363
|
+
:param str resource_name: The name of the resource.
|
|
1364
|
+
:param AutonomousContainerDatabaseAddStandbyArgs args: The arguments to use to populate this resource's properties.
|
|
1365
|
+
:param pulumi.ResourceOptions opts: Options for the resource.
|
|
1366
|
+
"""
|
|
1367
|
+
...
|
|
1368
|
+
def __init__(__self__, resource_name: str, *args, **kwargs):
|
|
1369
|
+
resource_args, opts = _utilities.get_resource_args_opts(AutonomousContainerDatabaseAddStandbyArgs, pulumi.ResourceOptions, *args, **kwargs)
|
|
1370
|
+
if resource_args is not None:
|
|
1371
|
+
__self__._internal_init(resource_name, opts, **resource_args.__dict__)
|
|
1372
|
+
else:
|
|
1373
|
+
__self__._internal_init(resource_name, *args, **kwargs)
|
|
1374
|
+
|
|
1375
|
+
def _internal_init(__self__,
|
|
1376
|
+
resource_name: str,
|
|
1377
|
+
opts: Optional[pulumi.ResourceOptions] = None,
|
|
1378
|
+
autonomous_container_database_id: Optional[pulumi.Input[str]] = None,
|
|
1379
|
+
fast_start_fail_over_lag_limit_in_seconds: Optional[pulumi.Input[int]] = None,
|
|
1380
|
+
is_automatic_failover_enabled: Optional[pulumi.Input[bool]] = None,
|
|
1381
|
+
peer_autonomous_container_database_backup_config: Optional[pulumi.Input[Union['AutonomousContainerDatabaseAddStandbyPeerAutonomousContainerDatabaseBackupConfigArgs', 'AutonomousContainerDatabaseAddStandbyPeerAutonomousContainerDatabaseBackupConfigArgsDict']]] = None,
|
|
1382
|
+
peer_autonomous_container_database_compartment_id: Optional[pulumi.Input[str]] = None,
|
|
1383
|
+
peer_autonomous_container_database_display_name: Optional[pulumi.Input[str]] = None,
|
|
1384
|
+
peer_autonomous_vm_cluster_id: Optional[pulumi.Input[str]] = None,
|
|
1385
|
+
peer_cloud_autonomous_vm_cluster_id: Optional[pulumi.Input[str]] = None,
|
|
1386
|
+
peer_db_unique_name: Optional[pulumi.Input[str]] = None,
|
|
1387
|
+
protection_mode: Optional[pulumi.Input[str]] = None,
|
|
1388
|
+
standby_maintenance_buffer_in_days: Optional[pulumi.Input[int]] = None,
|
|
1389
|
+
__props__=None):
|
|
1390
|
+
opts = pulumi.ResourceOptions.merge(_utilities.get_resource_opts_defaults(), opts)
|
|
1391
|
+
if not isinstance(opts, pulumi.ResourceOptions):
|
|
1392
|
+
raise TypeError('Expected resource options to be a ResourceOptions instance')
|
|
1393
|
+
if opts.id is None:
|
|
1394
|
+
if __props__ is not None:
|
|
1395
|
+
raise TypeError('__props__ is only valid when passed in combination with a valid opts.id to get an existing resource')
|
|
1396
|
+
__props__ = AutonomousContainerDatabaseAddStandbyArgs.__new__(AutonomousContainerDatabaseAddStandbyArgs)
|
|
1397
|
+
|
|
1398
|
+
if autonomous_container_database_id is None and not opts.urn:
|
|
1399
|
+
raise TypeError("Missing required property 'autonomous_container_database_id'")
|
|
1400
|
+
__props__.__dict__["autonomous_container_database_id"] = autonomous_container_database_id
|
|
1401
|
+
__props__.__dict__["fast_start_fail_over_lag_limit_in_seconds"] = fast_start_fail_over_lag_limit_in_seconds
|
|
1402
|
+
__props__.__dict__["is_automatic_failover_enabled"] = is_automatic_failover_enabled
|
|
1403
|
+
__props__.__dict__["peer_autonomous_container_database_backup_config"] = peer_autonomous_container_database_backup_config
|
|
1404
|
+
__props__.__dict__["peer_autonomous_container_database_compartment_id"] = peer_autonomous_container_database_compartment_id
|
|
1405
|
+
__props__.__dict__["peer_autonomous_container_database_display_name"] = peer_autonomous_container_database_display_name
|
|
1406
|
+
__props__.__dict__["peer_autonomous_vm_cluster_id"] = peer_autonomous_vm_cluster_id
|
|
1407
|
+
__props__.__dict__["peer_cloud_autonomous_vm_cluster_id"] = peer_cloud_autonomous_vm_cluster_id
|
|
1408
|
+
__props__.__dict__["peer_db_unique_name"] = peer_db_unique_name
|
|
1409
|
+
__props__.__dict__["protection_mode"] = protection_mode
|
|
1410
|
+
__props__.__dict__["standby_maintenance_buffer_in_days"] = standby_maintenance_buffer_in_days
|
|
1411
|
+
__props__.__dict__["autonomous_exadata_infrastructure_id"] = None
|
|
1412
|
+
__props__.__dict__["autonomous_vm_cluster_id"] = None
|
|
1413
|
+
__props__.__dict__["availability_domain"] = None
|
|
1414
|
+
__props__.__dict__["available_cpus"] = None
|
|
1415
|
+
__props__.__dict__["backup_configs"] = None
|
|
1416
|
+
__props__.__dict__["cloud_autonomous_vm_cluster_id"] = None
|
|
1417
|
+
__props__.__dict__["compartment_id"] = None
|
|
1418
|
+
__props__.__dict__["compute_model"] = None
|
|
1419
|
+
__props__.__dict__["dataguard_group_members"] = None
|
|
1420
|
+
__props__.__dict__["dataguards"] = None
|
|
1421
|
+
__props__.__dict__["db_name"] = None
|
|
1422
|
+
__props__.__dict__["db_split_threshold"] = None
|
|
1423
|
+
__props__.__dict__["db_unique_name"] = None
|
|
1424
|
+
__props__.__dict__["db_version"] = None
|
|
1425
|
+
__props__.__dict__["defined_tags"] = None
|
|
1426
|
+
__props__.__dict__["display_name"] = None
|
|
1427
|
+
__props__.__dict__["distribution_affinity"] = None
|
|
1428
|
+
__props__.__dict__["dst_file_version"] = None
|
|
1429
|
+
__props__.__dict__["freeform_tags"] = None
|
|
1430
|
+
__props__.__dict__["infrastructure_type"] = None
|
|
1431
|
+
__props__.__dict__["is_data_guard_enabled"] = None
|
|
1432
|
+
__props__.__dict__["is_dst_file_update_enabled"] = None
|
|
1433
|
+
__props__.__dict__["is_multiple_standby"] = None
|
|
1434
|
+
__props__.__dict__["key_history_entries"] = None
|
|
1435
|
+
__props__.__dict__["key_store_id"] = None
|
|
1436
|
+
__props__.__dict__["key_store_wallet_name"] = None
|
|
1437
|
+
__props__.__dict__["kms_key_id"] = None
|
|
1438
|
+
__props__.__dict__["kms_key_version_id"] = None
|
|
1439
|
+
__props__.__dict__["largest_provisionable_autonomous_database_in_cpus"] = None
|
|
1440
|
+
__props__.__dict__["last_maintenance_run_id"] = None
|
|
1441
|
+
__props__.__dict__["lifecycle_details"] = None
|
|
1442
|
+
__props__.__dict__["list_one_off_patches"] = None
|
|
1443
|
+
__props__.__dict__["maintenance_windows"] = None
|
|
1444
|
+
__props__.__dict__["memory_per_oracle_compute_unit_in_gbs"] = None
|
|
1445
|
+
__props__.__dict__["net_services_architecture"] = None
|
|
1446
|
+
__props__.__dict__["next_maintenance_run_id"] = None
|
|
1447
|
+
__props__.__dict__["patch_id"] = None
|
|
1448
|
+
__props__.__dict__["patch_model"] = None
|
|
1449
|
+
__props__.__dict__["provisionable_cpuses"] = None
|
|
1450
|
+
__props__.__dict__["provisioned_cpus"] = None
|
|
1451
|
+
__props__.__dict__["reclaimable_cpus"] = None
|
|
1452
|
+
__props__.__dict__["reserved_cpus"] = None
|
|
1453
|
+
__props__.__dict__["role"] = None
|
|
1454
|
+
__props__.__dict__["service_level_agreement_type"] = None
|
|
1455
|
+
__props__.__dict__["state"] = None
|
|
1456
|
+
__props__.__dict__["time_created"] = None
|
|
1457
|
+
__props__.__dict__["time_of_last_backup"] = None
|
|
1458
|
+
__props__.__dict__["time_snapshot_standby_revert"] = None
|
|
1459
|
+
__props__.__dict__["total_cpus"] = None
|
|
1460
|
+
__props__.__dict__["vault_id"] = None
|
|
1461
|
+
__props__.__dict__["version_preference"] = None
|
|
1462
|
+
__props__.__dict__["vm_failover_reservation"] = None
|
|
1463
|
+
super(AutonomousContainerDatabaseAddStandby, __self__).__init__(
|
|
1464
|
+
'oci:Database/autonomousContainerDatabaseAddStandby:AutonomousContainerDatabaseAddStandby',
|
|
1465
|
+
resource_name,
|
|
1466
|
+
__props__,
|
|
1467
|
+
opts)
|
|
1468
|
+
|
|
1469
|
+
@staticmethod
|
|
1470
|
+
def get(resource_name: str,
|
|
1471
|
+
id: pulumi.Input[str],
|
|
1472
|
+
opts: Optional[pulumi.ResourceOptions] = None,
|
|
1473
|
+
autonomous_container_database_id: Optional[pulumi.Input[str]] = None,
|
|
1474
|
+
autonomous_exadata_infrastructure_id: Optional[pulumi.Input[str]] = None,
|
|
1475
|
+
autonomous_vm_cluster_id: Optional[pulumi.Input[str]] = None,
|
|
1476
|
+
availability_domain: Optional[pulumi.Input[str]] = None,
|
|
1477
|
+
available_cpus: Optional[pulumi.Input[float]] = None,
|
|
1478
|
+
backup_configs: Optional[pulumi.Input[Sequence[pulumi.Input[Union['AutonomousContainerDatabaseAddStandbyBackupConfigArgs', 'AutonomousContainerDatabaseAddStandbyBackupConfigArgsDict']]]]] = None,
|
|
1479
|
+
cloud_autonomous_vm_cluster_id: Optional[pulumi.Input[str]] = None,
|
|
1480
|
+
compartment_id: Optional[pulumi.Input[str]] = None,
|
|
1481
|
+
compute_model: Optional[pulumi.Input[str]] = None,
|
|
1482
|
+
dataguard_group_members: Optional[pulumi.Input[Sequence[pulumi.Input[Union['AutonomousContainerDatabaseAddStandbyDataguardGroupMemberArgs', 'AutonomousContainerDatabaseAddStandbyDataguardGroupMemberArgsDict']]]]] = None,
|
|
1483
|
+
dataguards: Optional[pulumi.Input[Sequence[pulumi.Input[Union['AutonomousContainerDatabaseAddStandbyDataguardArgs', 'AutonomousContainerDatabaseAddStandbyDataguardArgsDict']]]]] = None,
|
|
1484
|
+
db_name: Optional[pulumi.Input[str]] = None,
|
|
1485
|
+
db_split_threshold: Optional[pulumi.Input[int]] = None,
|
|
1486
|
+
db_unique_name: Optional[pulumi.Input[str]] = None,
|
|
1487
|
+
db_version: Optional[pulumi.Input[str]] = None,
|
|
1488
|
+
defined_tags: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
|
|
1489
|
+
display_name: Optional[pulumi.Input[str]] = None,
|
|
1490
|
+
distribution_affinity: Optional[pulumi.Input[str]] = None,
|
|
1491
|
+
dst_file_version: Optional[pulumi.Input[str]] = None,
|
|
1492
|
+
fast_start_fail_over_lag_limit_in_seconds: Optional[pulumi.Input[int]] = None,
|
|
1493
|
+
freeform_tags: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
|
|
1494
|
+
infrastructure_type: Optional[pulumi.Input[str]] = None,
|
|
1495
|
+
is_automatic_failover_enabled: Optional[pulumi.Input[bool]] = None,
|
|
1496
|
+
is_data_guard_enabled: Optional[pulumi.Input[bool]] = None,
|
|
1497
|
+
is_dst_file_update_enabled: Optional[pulumi.Input[bool]] = None,
|
|
1498
|
+
is_multiple_standby: Optional[pulumi.Input[bool]] = None,
|
|
1499
|
+
key_history_entries: Optional[pulumi.Input[Sequence[pulumi.Input[Union['AutonomousContainerDatabaseAddStandbyKeyHistoryEntryArgs', 'AutonomousContainerDatabaseAddStandbyKeyHistoryEntryArgsDict']]]]] = None,
|
|
1500
|
+
key_store_id: Optional[pulumi.Input[str]] = None,
|
|
1501
|
+
key_store_wallet_name: Optional[pulumi.Input[str]] = None,
|
|
1502
|
+
kms_key_id: Optional[pulumi.Input[str]] = None,
|
|
1503
|
+
kms_key_version_id: Optional[pulumi.Input[str]] = None,
|
|
1504
|
+
largest_provisionable_autonomous_database_in_cpus: Optional[pulumi.Input[float]] = None,
|
|
1505
|
+
last_maintenance_run_id: Optional[pulumi.Input[str]] = None,
|
|
1506
|
+
lifecycle_details: Optional[pulumi.Input[str]] = None,
|
|
1507
|
+
list_one_off_patches: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
1508
|
+
maintenance_windows: Optional[pulumi.Input[Sequence[pulumi.Input[Union['AutonomousContainerDatabaseAddStandbyMaintenanceWindowArgs', 'AutonomousContainerDatabaseAddStandbyMaintenanceWindowArgsDict']]]]] = None,
|
|
1509
|
+
memory_per_oracle_compute_unit_in_gbs: Optional[pulumi.Input[int]] = None,
|
|
1510
|
+
net_services_architecture: Optional[pulumi.Input[str]] = None,
|
|
1511
|
+
next_maintenance_run_id: Optional[pulumi.Input[str]] = None,
|
|
1512
|
+
patch_id: Optional[pulumi.Input[str]] = None,
|
|
1513
|
+
patch_model: Optional[pulumi.Input[str]] = None,
|
|
1514
|
+
peer_autonomous_container_database_backup_config: Optional[pulumi.Input[Union['AutonomousContainerDatabaseAddStandbyPeerAutonomousContainerDatabaseBackupConfigArgs', 'AutonomousContainerDatabaseAddStandbyPeerAutonomousContainerDatabaseBackupConfigArgsDict']]] = None,
|
|
1515
|
+
peer_autonomous_container_database_compartment_id: Optional[pulumi.Input[str]] = None,
|
|
1516
|
+
peer_autonomous_container_database_display_name: Optional[pulumi.Input[str]] = None,
|
|
1517
|
+
peer_autonomous_vm_cluster_id: Optional[pulumi.Input[str]] = None,
|
|
1518
|
+
peer_cloud_autonomous_vm_cluster_id: Optional[pulumi.Input[str]] = None,
|
|
1519
|
+
peer_db_unique_name: Optional[pulumi.Input[str]] = None,
|
|
1520
|
+
protection_mode: Optional[pulumi.Input[str]] = None,
|
|
1521
|
+
provisionable_cpuses: Optional[pulumi.Input[Sequence[pulumi.Input[float]]]] = None,
|
|
1522
|
+
provisioned_cpus: Optional[pulumi.Input[float]] = None,
|
|
1523
|
+
reclaimable_cpus: Optional[pulumi.Input[float]] = None,
|
|
1524
|
+
reserved_cpus: Optional[pulumi.Input[float]] = None,
|
|
1525
|
+
role: Optional[pulumi.Input[str]] = None,
|
|
1526
|
+
service_level_agreement_type: Optional[pulumi.Input[str]] = None,
|
|
1527
|
+
standby_maintenance_buffer_in_days: Optional[pulumi.Input[int]] = None,
|
|
1528
|
+
state: Optional[pulumi.Input[str]] = None,
|
|
1529
|
+
time_created: Optional[pulumi.Input[str]] = None,
|
|
1530
|
+
time_of_last_backup: Optional[pulumi.Input[str]] = None,
|
|
1531
|
+
time_snapshot_standby_revert: Optional[pulumi.Input[str]] = None,
|
|
1532
|
+
total_cpus: Optional[pulumi.Input[int]] = None,
|
|
1533
|
+
vault_id: Optional[pulumi.Input[str]] = None,
|
|
1534
|
+
version_preference: Optional[pulumi.Input[str]] = None,
|
|
1535
|
+
vm_failover_reservation: Optional[pulumi.Input[int]] = None) -> 'AutonomousContainerDatabaseAddStandby':
|
|
1536
|
+
"""
|
|
1537
|
+
Get an existing AutonomousContainerDatabaseAddStandby resource's state with the given name, id, and optional extra
|
|
1538
|
+
properties used to qualify the lookup.
|
|
1539
|
+
|
|
1540
|
+
:param str resource_name: The unique name of the resulting resource.
|
|
1541
|
+
:param pulumi.Input[str] id: The unique provider ID of the resource to lookup.
|
|
1542
|
+
:param pulumi.ResourceOptions opts: Options for the resource.
|
|
1543
|
+
:param pulumi.Input[str] autonomous_container_database_id: The Autonomous Container Database [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm).
|
|
1544
|
+
:param pulumi.Input[str] autonomous_exadata_infrastructure_id: **No longer used.** For Autonomous Database on dedicated Exadata infrastructure, the container database is created within a specified `cloudAutonomousVmCluster`.
|
|
1545
|
+
:param pulumi.Input[str] autonomous_vm_cluster_id: The OCID of the Autonomous VM Cluster.
|
|
1546
|
+
:param pulumi.Input[str] availability_domain: The domain of the Autonomous Container Database
|
|
1547
|
+
:param pulumi.Input[float] available_cpus: Sum of CPUs available on the Autonomous VM Cluster + Sum of reclaimable CPUs available in the Autonomous Container Database.
|
|
1548
|
+
:param pulumi.Input[Sequence[pulumi.Input[Union['AutonomousContainerDatabaseAddStandbyBackupConfigArgs', 'AutonomousContainerDatabaseAddStandbyBackupConfigArgsDict']]]] backup_configs: Backup options for the Autonomous Container Database.
|
|
1549
|
+
:param pulumi.Input[str] cloud_autonomous_vm_cluster_id: The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the cloud Autonomous Exadata VM Cluster.
|
|
1550
|
+
:param pulumi.Input[str] compartment_id: The OCID of the compartment.
|
|
1551
|
+
:param pulumi.Input[str] compute_model: The compute model of the Autonomous Container Database. For Autonomous Database on Dedicated Exadata Infrastructure, the CPU type (ECPUs or OCPUs) is determined by the parent Autonomous Exadata VM Cluster's compute model. ECPU compute model is the recommended model and OCPU compute model is legacy. See [Compute Models in Autonomous Database on Dedicated Exadata Infrastructure](https://docs.oracle.com/en/cloud/paas/autonomous-database/dedicated/adbak) for more details.
|
|
1552
|
+
:param pulumi.Input[Sequence[pulumi.Input[Union['AutonomousContainerDatabaseAddStandbyDataguardGroupMemberArgs', 'AutonomousContainerDatabaseAddStandbyDataguardGroupMemberArgsDict']]]] dataguard_group_members: Array of Dg associations.
|
|
1553
|
+
:param pulumi.Input[Sequence[pulumi.Input[Union['AutonomousContainerDatabaseAddStandbyDataguardArgs', 'AutonomousContainerDatabaseAddStandbyDataguardArgsDict']]]] dataguards: The properties that define Autonomous Container Databases Dataguard.
|
|
1554
|
+
:param pulumi.Input[str] db_name: The Database name for the Autonomous Container Database. The name must be unique within the Cloud Autonomous VM Cluster, starting with an alphabetic character, followed by 1 to 7 alphanumeric characters.
|
|
1555
|
+
:param pulumi.Input[int] db_split_threshold: The CPU value beyond which an Autonomous Database will be opened across multiple nodes. The default value of this attribute is 16 for OCPUs and 64 for ECPUs.
|
|
1556
|
+
:param pulumi.Input[str] db_version: Oracle Database version of the Autonomous Container Database.
|
|
1557
|
+
:param pulumi.Input[Mapping[str, pulumi.Input[str]]] defined_tags: Defined tags for this resource. Each key is predefined and scoped to a namespace. For more information, see [Resource Tags](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/resourcetags.htm).
|
|
1558
|
+
:param pulumi.Input[str] display_name: The user-provided name for the Autonomous Container Database.
|
|
1559
|
+
:param pulumi.Input[str] distribution_affinity: Determines whether an Autonomous Database must be opened across the maximum number of nodes or the least number of nodes. By default, Minimum nodes is selected.
|
|
1560
|
+
:param pulumi.Input[str] dst_file_version: DST Time-Zone File version of the Autonomous Container Database.
|
|
1561
|
+
:param pulumi.Input[int] fast_start_fail_over_lag_limit_in_seconds: The lag time for my preference based on data loss tolerance in seconds.
|
|
1562
|
+
:param pulumi.Input[Mapping[str, pulumi.Input[str]]] freeform_tags: Free-form tags for this resource. Each tag is a simple key-value pair with no predefined name, type, or namespace. For more information, see [Resource Tags](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/resourcetags.htm). Example: `{"Department": "Finance"}`
|
|
1563
|
+
:param pulumi.Input[str] infrastructure_type: The infrastructure type this resource belongs to.
|
|
1564
|
+
:param pulumi.Input[bool] is_automatic_failover_enabled: Indicates whether Automatic Failover is enabled for Autonomous Container Database Dataguard Association
|
|
1565
|
+
:param pulumi.Input[bool] is_data_guard_enabled: **Deprecated.** Indicates whether the Autonomous Database has local (in-region) Data Guard enabled. Not applicable to cross-region Autonomous Data Guard associations, or to Autonomous Databases using dedicated Exadata infrastructure or Exadata Cloud@Customer infrastructure.
|
|
1566
|
+
:param pulumi.Input[bool] is_dst_file_update_enabled: Indicates if an automatic DST Time Zone file update is enabled for the Autonomous Container Database. If enabled along with Release Update, patching will be done in a Non-Rolling manner.
|
|
1567
|
+
:param pulumi.Input[bool] is_multiple_standby: Whether it is multiple standby Autonomous Dataguard
|
|
1568
|
+
:param pulumi.Input[Sequence[pulumi.Input[Union['AutonomousContainerDatabaseAddStandbyKeyHistoryEntryArgs', 'AutonomousContainerDatabaseAddStandbyKeyHistoryEntryArgsDict']]]] key_history_entries: Key History Entry.
|
|
1569
|
+
:param pulumi.Input[str] key_store_id: The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the key store of Oracle Vault.
|
|
1570
|
+
:param pulumi.Input[str] key_store_wallet_name: The wallet name for Oracle Key Vault.
|
|
1571
|
+
:param pulumi.Input[str] kms_key_id: The OCID of the key container that is used as the master encryption key in database transparent data encryption (TDE) operations.
|
|
1572
|
+
:param pulumi.Input[str] kms_key_version_id: The OCID of the key container version that is used in database transparent data encryption (TDE) operations KMS Key can have multiple key versions. If none is specified, the current key version (latest) of the Key Id is used for the operation. Autonomous Database Serverless does not use key versions, hence is not applicable for Autonomous Database Serverless instances.
|
|
1573
|
+
:param pulumi.Input[float] largest_provisionable_autonomous_database_in_cpus: The largest Autonomous Database (CPU) that can be created in a new Autonomous Container Database.
|
|
1574
|
+
:param pulumi.Input[str] last_maintenance_run_id: The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the last maintenance run.
|
|
1575
|
+
:param pulumi.Input[str] lifecycle_details: Additional information about the current lifecycle state.
|
|
1576
|
+
:param pulumi.Input[Sequence[pulumi.Input[str]]] list_one_off_patches: List of One-Off patches that has been successfully applied to Autonomous Container Database
|
|
1577
|
+
:param pulumi.Input[Sequence[pulumi.Input[Union['AutonomousContainerDatabaseAddStandbyMaintenanceWindowArgs', 'AutonomousContainerDatabaseAddStandbyMaintenanceWindowArgsDict']]]] maintenance_windows: The scheduling details for the quarterly maintenance window. Patching and system updates take place during the maintenance window.
|
|
1578
|
+
:param pulumi.Input[int] memory_per_oracle_compute_unit_in_gbs: The amount of memory (in GBs) enabled per ECPU or OCPU in the Autonomous VM Cluster.
|
|
1579
|
+
:param pulumi.Input[str] net_services_architecture: Enabling SHARED server architecture enables a database server to allow many client processes to share very few server processes, thereby increasing the number of supported users.
|
|
1580
|
+
:param pulumi.Input[str] next_maintenance_run_id: The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the next maintenance run.
|
|
1581
|
+
:param pulumi.Input[str] patch_id: The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the last patch applied on the system.
|
|
1582
|
+
:param pulumi.Input[str] patch_model: Database patch model preference.
|
|
1583
|
+
:param pulumi.Input[Union['AutonomousContainerDatabaseAddStandbyPeerAutonomousContainerDatabaseBackupConfigArgs', 'AutonomousContainerDatabaseAddStandbyPeerAutonomousContainerDatabaseBackupConfigArgsDict']] peer_autonomous_container_database_backup_config: Backup options for the standby Autonomous Container Database.
|
|
1584
|
+
:param pulumi.Input[str] peer_autonomous_container_database_compartment_id: The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the compartment where the standby Autonomous Container Database will be created.
|
|
1585
|
+
:param pulumi.Input[str] peer_autonomous_container_database_display_name: The display name for the peer Autonomous Container Database.
|
|
1586
|
+
:param pulumi.Input[str] peer_autonomous_vm_cluster_id: The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the peer Autonomous Exadata VM Cluster.
|
|
1587
|
+
:param pulumi.Input[str] peer_cloud_autonomous_vm_cluster_id: The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the peer cloud Autonomous Exadata VM Cluster.
|
|
1588
|
+
:param pulumi.Input[str] peer_db_unique_name: Specifies the `DB_UNIQUE_NAME` of the peer database to be created.
|
|
1589
|
+
:param pulumi.Input[str] protection_mode: The protection mode of this Autonomous Data Guard association. For more information, see [Oracle Data Guard Protection Modes](http://docs.oracle.com/database/122/SBYDB/oracle-data-guard-protection-modes.htm#SBYDB02000) in the Oracle Data Guard documentation.
|
|
1590
|
+
:param pulumi.Input[Sequence[pulumi.Input[float]]] provisionable_cpuses: An array of CPU values that can be used to successfully provision a single Autonomous Database.
|
|
1591
|
+
:param pulumi.Input[float] provisioned_cpus: The number of CPUs provisioned in an Autonomous Container Database.
|
|
1592
|
+
:param pulumi.Input[float] reclaimable_cpus: CPUs that continue to be included in the count of CPUs available to the Autonomous Container Database even after one of its Autonomous Database is terminated or scaled down. You can release them to the available CPUs at its parent Autonomous VM Cluster level by restarting the Autonomous Container Database.
|
|
1593
|
+
:param pulumi.Input[float] reserved_cpus: The number of CPUs reserved in an Autonomous Container Database.
|
|
1594
|
+
:param pulumi.Input[str] role: The Data Guard role of the Autonomous Container Database or Autonomous Database, if Autonomous Data Guard is enabled.
|
|
1595
|
+
:param pulumi.Input[str] service_level_agreement_type: The service level agreement type of the container database. The default is STANDARD.
|
|
1596
|
+
:param pulumi.Input[int] standby_maintenance_buffer_in_days: The scheduling detail for the quarterly maintenance window of the standby Autonomous Container Database. This value represents the number of days before scheduled maintenance of the primary database.
|
|
1597
|
+
|
|
1598
|
+
|
|
1599
|
+
** IMPORTANT **
|
|
1600
|
+
Any change to a property that does not support update will force the destruction and recreation of the resource with the new property values
|
|
1601
|
+
:param pulumi.Input[str] state: The current state of the Autonomous Container Database.
|
|
1602
|
+
:param pulumi.Input[str] time_created: The date and time the Autonomous Container Database was created.
|
|
1603
|
+
:param pulumi.Input[str] time_of_last_backup: The timestamp of last successful backup. Here NULL value represents either there are no successful backups or backups are not configured for this Autonomous Container Database.
|
|
1604
|
+
:param pulumi.Input[str] time_snapshot_standby_revert: The date and time the Autonomous Container Database will be reverted to Standby from Snapshot Standby.
|
|
1605
|
+
:param pulumi.Input[int] total_cpus: The number of CPUs allocated to the Autonomous VM cluster.
|
|
1606
|
+
:param pulumi.Input[str] vault_id: The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the Oracle Cloud Infrastructure [vault](https://docs.cloud.oracle.com/iaas/Content/KeyManagement/Concepts/keyoverview.htm#concepts). This parameter and `secretId` are required for Customer Managed Keys.
|
|
1607
|
+
:param pulumi.Input[str] version_preference: The next maintenance version preference.
|
|
1608
|
+
:param pulumi.Input[int] vm_failover_reservation: The percentage of CPUs reserved across nodes to support node failover. Allowed values are 0%, 25%, and 50%, with 50% being the default option.
|
|
1609
|
+
"""
|
|
1610
|
+
opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id))
|
|
1611
|
+
|
|
1612
|
+
__props__ = _AutonomousContainerDatabaseAddStandbyState.__new__(_AutonomousContainerDatabaseAddStandbyState)
|
|
1613
|
+
|
|
1614
|
+
__props__.__dict__["autonomous_container_database_id"] = autonomous_container_database_id
|
|
1615
|
+
__props__.__dict__["autonomous_exadata_infrastructure_id"] = autonomous_exadata_infrastructure_id
|
|
1616
|
+
__props__.__dict__["autonomous_vm_cluster_id"] = autonomous_vm_cluster_id
|
|
1617
|
+
__props__.__dict__["availability_domain"] = availability_domain
|
|
1618
|
+
__props__.__dict__["available_cpus"] = available_cpus
|
|
1619
|
+
__props__.__dict__["backup_configs"] = backup_configs
|
|
1620
|
+
__props__.__dict__["cloud_autonomous_vm_cluster_id"] = cloud_autonomous_vm_cluster_id
|
|
1621
|
+
__props__.__dict__["compartment_id"] = compartment_id
|
|
1622
|
+
__props__.__dict__["compute_model"] = compute_model
|
|
1623
|
+
__props__.__dict__["dataguard_group_members"] = dataguard_group_members
|
|
1624
|
+
__props__.__dict__["dataguards"] = dataguards
|
|
1625
|
+
__props__.__dict__["db_name"] = db_name
|
|
1626
|
+
__props__.__dict__["db_split_threshold"] = db_split_threshold
|
|
1627
|
+
__props__.__dict__["db_unique_name"] = db_unique_name
|
|
1628
|
+
__props__.__dict__["db_version"] = db_version
|
|
1629
|
+
__props__.__dict__["defined_tags"] = defined_tags
|
|
1630
|
+
__props__.__dict__["display_name"] = display_name
|
|
1631
|
+
__props__.__dict__["distribution_affinity"] = distribution_affinity
|
|
1632
|
+
__props__.__dict__["dst_file_version"] = dst_file_version
|
|
1633
|
+
__props__.__dict__["fast_start_fail_over_lag_limit_in_seconds"] = fast_start_fail_over_lag_limit_in_seconds
|
|
1634
|
+
__props__.__dict__["freeform_tags"] = freeform_tags
|
|
1635
|
+
__props__.__dict__["infrastructure_type"] = infrastructure_type
|
|
1636
|
+
__props__.__dict__["is_automatic_failover_enabled"] = is_automatic_failover_enabled
|
|
1637
|
+
__props__.__dict__["is_data_guard_enabled"] = is_data_guard_enabled
|
|
1638
|
+
__props__.__dict__["is_dst_file_update_enabled"] = is_dst_file_update_enabled
|
|
1639
|
+
__props__.__dict__["is_multiple_standby"] = is_multiple_standby
|
|
1640
|
+
__props__.__dict__["key_history_entries"] = key_history_entries
|
|
1641
|
+
__props__.__dict__["key_store_id"] = key_store_id
|
|
1642
|
+
__props__.__dict__["key_store_wallet_name"] = key_store_wallet_name
|
|
1643
|
+
__props__.__dict__["kms_key_id"] = kms_key_id
|
|
1644
|
+
__props__.__dict__["kms_key_version_id"] = kms_key_version_id
|
|
1645
|
+
__props__.__dict__["largest_provisionable_autonomous_database_in_cpus"] = largest_provisionable_autonomous_database_in_cpus
|
|
1646
|
+
__props__.__dict__["last_maintenance_run_id"] = last_maintenance_run_id
|
|
1647
|
+
__props__.__dict__["lifecycle_details"] = lifecycle_details
|
|
1648
|
+
__props__.__dict__["list_one_off_patches"] = list_one_off_patches
|
|
1649
|
+
__props__.__dict__["maintenance_windows"] = maintenance_windows
|
|
1650
|
+
__props__.__dict__["memory_per_oracle_compute_unit_in_gbs"] = memory_per_oracle_compute_unit_in_gbs
|
|
1651
|
+
__props__.__dict__["net_services_architecture"] = net_services_architecture
|
|
1652
|
+
__props__.__dict__["next_maintenance_run_id"] = next_maintenance_run_id
|
|
1653
|
+
__props__.__dict__["patch_id"] = patch_id
|
|
1654
|
+
__props__.__dict__["patch_model"] = patch_model
|
|
1655
|
+
__props__.__dict__["peer_autonomous_container_database_backup_config"] = peer_autonomous_container_database_backup_config
|
|
1656
|
+
__props__.__dict__["peer_autonomous_container_database_compartment_id"] = peer_autonomous_container_database_compartment_id
|
|
1657
|
+
__props__.__dict__["peer_autonomous_container_database_display_name"] = peer_autonomous_container_database_display_name
|
|
1658
|
+
__props__.__dict__["peer_autonomous_vm_cluster_id"] = peer_autonomous_vm_cluster_id
|
|
1659
|
+
__props__.__dict__["peer_cloud_autonomous_vm_cluster_id"] = peer_cloud_autonomous_vm_cluster_id
|
|
1660
|
+
__props__.__dict__["peer_db_unique_name"] = peer_db_unique_name
|
|
1661
|
+
__props__.__dict__["protection_mode"] = protection_mode
|
|
1662
|
+
__props__.__dict__["provisionable_cpuses"] = provisionable_cpuses
|
|
1663
|
+
__props__.__dict__["provisioned_cpus"] = provisioned_cpus
|
|
1664
|
+
__props__.__dict__["reclaimable_cpus"] = reclaimable_cpus
|
|
1665
|
+
__props__.__dict__["reserved_cpus"] = reserved_cpus
|
|
1666
|
+
__props__.__dict__["role"] = role
|
|
1667
|
+
__props__.__dict__["service_level_agreement_type"] = service_level_agreement_type
|
|
1668
|
+
__props__.__dict__["standby_maintenance_buffer_in_days"] = standby_maintenance_buffer_in_days
|
|
1669
|
+
__props__.__dict__["state"] = state
|
|
1670
|
+
__props__.__dict__["time_created"] = time_created
|
|
1671
|
+
__props__.__dict__["time_of_last_backup"] = time_of_last_backup
|
|
1672
|
+
__props__.__dict__["time_snapshot_standby_revert"] = time_snapshot_standby_revert
|
|
1673
|
+
__props__.__dict__["total_cpus"] = total_cpus
|
|
1674
|
+
__props__.__dict__["vault_id"] = vault_id
|
|
1675
|
+
__props__.__dict__["version_preference"] = version_preference
|
|
1676
|
+
__props__.__dict__["vm_failover_reservation"] = vm_failover_reservation
|
|
1677
|
+
return AutonomousContainerDatabaseAddStandby(resource_name, opts=opts, __props__=__props__)
|
|
1678
|
+
|
|
1679
|
+
@property
|
|
1680
|
+
@pulumi.getter(name="autonomousContainerDatabaseId")
|
|
1681
|
+
def autonomous_container_database_id(self) -> pulumi.Output[str]:
|
|
1682
|
+
"""
|
|
1683
|
+
The Autonomous Container Database [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm).
|
|
1684
|
+
"""
|
|
1685
|
+
return pulumi.get(self, "autonomous_container_database_id")
|
|
1686
|
+
|
|
1687
|
+
@property
|
|
1688
|
+
@pulumi.getter(name="autonomousExadataInfrastructureId")
|
|
1689
|
+
def autonomous_exadata_infrastructure_id(self) -> pulumi.Output[str]:
|
|
1690
|
+
"""
|
|
1691
|
+
**No longer used.** For Autonomous Database on dedicated Exadata infrastructure, the container database is created within a specified `cloudAutonomousVmCluster`.
|
|
1692
|
+
"""
|
|
1693
|
+
return pulumi.get(self, "autonomous_exadata_infrastructure_id")
|
|
1694
|
+
|
|
1695
|
+
@property
|
|
1696
|
+
@pulumi.getter(name="autonomousVmClusterId")
|
|
1697
|
+
def autonomous_vm_cluster_id(self) -> pulumi.Output[str]:
|
|
1698
|
+
"""
|
|
1699
|
+
The OCID of the Autonomous VM Cluster.
|
|
1700
|
+
"""
|
|
1701
|
+
return pulumi.get(self, "autonomous_vm_cluster_id")
|
|
1702
|
+
|
|
1703
|
+
@property
|
|
1704
|
+
@pulumi.getter(name="availabilityDomain")
|
|
1705
|
+
def availability_domain(self) -> pulumi.Output[str]:
|
|
1706
|
+
"""
|
|
1707
|
+
The domain of the Autonomous Container Database
|
|
1708
|
+
"""
|
|
1709
|
+
return pulumi.get(self, "availability_domain")
|
|
1710
|
+
|
|
1711
|
+
@property
|
|
1712
|
+
@pulumi.getter(name="availableCpus")
|
|
1713
|
+
def available_cpus(self) -> pulumi.Output[float]:
|
|
1714
|
+
"""
|
|
1715
|
+
Sum of CPUs available on the Autonomous VM Cluster + Sum of reclaimable CPUs available in the Autonomous Container Database.
|
|
1716
|
+
"""
|
|
1717
|
+
return pulumi.get(self, "available_cpus")
|
|
1718
|
+
|
|
1719
|
+
@property
|
|
1720
|
+
@pulumi.getter(name="backupConfigs")
|
|
1721
|
+
def backup_configs(self) -> pulumi.Output[Sequence['outputs.AutonomousContainerDatabaseAddStandbyBackupConfig']]:
|
|
1722
|
+
"""
|
|
1723
|
+
Backup options for the Autonomous Container Database.
|
|
1724
|
+
"""
|
|
1725
|
+
return pulumi.get(self, "backup_configs")
|
|
1726
|
+
|
|
1727
|
+
@property
|
|
1728
|
+
@pulumi.getter(name="cloudAutonomousVmClusterId")
|
|
1729
|
+
def cloud_autonomous_vm_cluster_id(self) -> pulumi.Output[str]:
|
|
1730
|
+
"""
|
|
1731
|
+
The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the cloud Autonomous Exadata VM Cluster.
|
|
1732
|
+
"""
|
|
1733
|
+
return pulumi.get(self, "cloud_autonomous_vm_cluster_id")
|
|
1734
|
+
|
|
1735
|
+
@property
|
|
1736
|
+
@pulumi.getter(name="compartmentId")
|
|
1737
|
+
def compartment_id(self) -> pulumi.Output[str]:
|
|
1738
|
+
"""
|
|
1739
|
+
The OCID of the compartment.
|
|
1740
|
+
"""
|
|
1741
|
+
return pulumi.get(self, "compartment_id")
|
|
1742
|
+
|
|
1743
|
+
@property
|
|
1744
|
+
@pulumi.getter(name="computeModel")
|
|
1745
|
+
def compute_model(self) -> pulumi.Output[str]:
|
|
1746
|
+
"""
|
|
1747
|
+
The compute model of the Autonomous Container Database. For Autonomous Database on Dedicated Exadata Infrastructure, the CPU type (ECPUs or OCPUs) is determined by the parent Autonomous Exadata VM Cluster's compute model. ECPU compute model is the recommended model and OCPU compute model is legacy. See [Compute Models in Autonomous Database on Dedicated Exadata Infrastructure](https://docs.oracle.com/en/cloud/paas/autonomous-database/dedicated/adbak) for more details.
|
|
1748
|
+
"""
|
|
1749
|
+
return pulumi.get(self, "compute_model")
|
|
1750
|
+
|
|
1751
|
+
@property
|
|
1752
|
+
@pulumi.getter(name="dataguardGroupMembers")
|
|
1753
|
+
def dataguard_group_members(self) -> pulumi.Output[Sequence['outputs.AutonomousContainerDatabaseAddStandbyDataguardGroupMember']]:
|
|
1754
|
+
"""
|
|
1755
|
+
Array of Dg associations.
|
|
1756
|
+
"""
|
|
1757
|
+
return pulumi.get(self, "dataguard_group_members")
|
|
1758
|
+
|
|
1759
|
+
@property
|
|
1760
|
+
@pulumi.getter
|
|
1761
|
+
def dataguards(self) -> pulumi.Output[Sequence['outputs.AutonomousContainerDatabaseAddStandbyDataguard']]:
|
|
1762
|
+
"""
|
|
1763
|
+
The properties that define Autonomous Container Databases Dataguard.
|
|
1764
|
+
"""
|
|
1765
|
+
return pulumi.get(self, "dataguards")
|
|
1766
|
+
|
|
1767
|
+
@property
|
|
1768
|
+
@pulumi.getter(name="dbName")
|
|
1769
|
+
def db_name(self) -> pulumi.Output[str]:
|
|
1770
|
+
"""
|
|
1771
|
+
The Database name for the Autonomous Container Database. The name must be unique within the Cloud Autonomous VM Cluster, starting with an alphabetic character, followed by 1 to 7 alphanumeric characters.
|
|
1772
|
+
"""
|
|
1773
|
+
return pulumi.get(self, "db_name")
|
|
1774
|
+
|
|
1775
|
+
@property
|
|
1776
|
+
@pulumi.getter(name="dbSplitThreshold")
|
|
1777
|
+
def db_split_threshold(self) -> pulumi.Output[int]:
|
|
1778
|
+
"""
|
|
1779
|
+
The CPU value beyond which an Autonomous Database will be opened across multiple nodes. The default value of this attribute is 16 for OCPUs and 64 for ECPUs.
|
|
1780
|
+
"""
|
|
1781
|
+
return pulumi.get(self, "db_split_threshold")
|
|
1782
|
+
|
|
1783
|
+
@property
|
|
1784
|
+
@pulumi.getter(name="dbUniqueName")
|
|
1785
|
+
def db_unique_name(self) -> pulumi.Output[str]:
|
|
1786
|
+
return pulumi.get(self, "db_unique_name")
|
|
1787
|
+
|
|
1788
|
+
@property
|
|
1789
|
+
@pulumi.getter(name="dbVersion")
|
|
1790
|
+
def db_version(self) -> pulumi.Output[str]:
|
|
1791
|
+
"""
|
|
1792
|
+
Oracle Database version of the Autonomous Container Database.
|
|
1793
|
+
"""
|
|
1794
|
+
return pulumi.get(self, "db_version")
|
|
1795
|
+
|
|
1796
|
+
@property
|
|
1797
|
+
@pulumi.getter(name="definedTags")
|
|
1798
|
+
def defined_tags(self) -> pulumi.Output[Mapping[str, str]]:
|
|
1799
|
+
"""
|
|
1800
|
+
Defined tags for this resource. Each key is predefined and scoped to a namespace. For more information, see [Resource Tags](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/resourcetags.htm).
|
|
1801
|
+
"""
|
|
1802
|
+
return pulumi.get(self, "defined_tags")
|
|
1803
|
+
|
|
1804
|
+
@property
|
|
1805
|
+
@pulumi.getter(name="displayName")
|
|
1806
|
+
def display_name(self) -> pulumi.Output[str]:
|
|
1807
|
+
"""
|
|
1808
|
+
The user-provided name for the Autonomous Container Database.
|
|
1809
|
+
"""
|
|
1810
|
+
return pulumi.get(self, "display_name")
|
|
1811
|
+
|
|
1812
|
+
@property
|
|
1813
|
+
@pulumi.getter(name="distributionAffinity")
|
|
1814
|
+
def distribution_affinity(self) -> pulumi.Output[str]:
|
|
1815
|
+
"""
|
|
1816
|
+
Determines whether an Autonomous Database must be opened across the maximum number of nodes or the least number of nodes. By default, Minimum nodes is selected.
|
|
1817
|
+
"""
|
|
1818
|
+
return pulumi.get(self, "distribution_affinity")
|
|
1819
|
+
|
|
1820
|
+
@property
|
|
1821
|
+
@pulumi.getter(name="dstFileVersion")
|
|
1822
|
+
def dst_file_version(self) -> pulumi.Output[str]:
|
|
1823
|
+
"""
|
|
1824
|
+
DST Time-Zone File version of the Autonomous Container Database.
|
|
1825
|
+
"""
|
|
1826
|
+
return pulumi.get(self, "dst_file_version")
|
|
1827
|
+
|
|
1828
|
+
@property
|
|
1829
|
+
@pulumi.getter(name="fastStartFailOverLagLimitInSeconds")
|
|
1830
|
+
def fast_start_fail_over_lag_limit_in_seconds(self) -> pulumi.Output[int]:
|
|
1831
|
+
"""
|
|
1832
|
+
The lag time for my preference based on data loss tolerance in seconds.
|
|
1833
|
+
"""
|
|
1834
|
+
return pulumi.get(self, "fast_start_fail_over_lag_limit_in_seconds")
|
|
1835
|
+
|
|
1836
|
+
@property
|
|
1837
|
+
@pulumi.getter(name="freeformTags")
|
|
1838
|
+
def freeform_tags(self) -> pulumi.Output[Mapping[str, str]]:
|
|
1839
|
+
"""
|
|
1840
|
+
Free-form tags for this resource. Each tag is a simple key-value pair with no predefined name, type, or namespace. For more information, see [Resource Tags](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/resourcetags.htm). Example: `{"Department": "Finance"}`
|
|
1841
|
+
"""
|
|
1842
|
+
return pulumi.get(self, "freeform_tags")
|
|
1843
|
+
|
|
1844
|
+
@property
|
|
1845
|
+
@pulumi.getter(name="infrastructureType")
|
|
1846
|
+
def infrastructure_type(self) -> pulumi.Output[str]:
|
|
1847
|
+
"""
|
|
1848
|
+
The infrastructure type this resource belongs to.
|
|
1849
|
+
"""
|
|
1850
|
+
return pulumi.get(self, "infrastructure_type")
|
|
1851
|
+
|
|
1852
|
+
@property
|
|
1853
|
+
@pulumi.getter(name="isAutomaticFailoverEnabled")
|
|
1854
|
+
def is_automatic_failover_enabled(self) -> pulumi.Output[bool]:
|
|
1855
|
+
"""
|
|
1856
|
+
Indicates whether Automatic Failover is enabled for Autonomous Container Database Dataguard Association
|
|
1857
|
+
"""
|
|
1858
|
+
return pulumi.get(self, "is_automatic_failover_enabled")
|
|
1859
|
+
|
|
1860
|
+
@property
|
|
1861
|
+
@pulumi.getter(name="isDataGuardEnabled")
|
|
1862
|
+
def is_data_guard_enabled(self) -> pulumi.Output[bool]:
|
|
1863
|
+
"""
|
|
1864
|
+
**Deprecated.** Indicates whether the Autonomous Database has local (in-region) Data Guard enabled. Not applicable to cross-region Autonomous Data Guard associations, or to Autonomous Databases using dedicated Exadata infrastructure or Exadata Cloud@Customer infrastructure.
|
|
1865
|
+
"""
|
|
1866
|
+
return pulumi.get(self, "is_data_guard_enabled")
|
|
1867
|
+
|
|
1868
|
+
@property
|
|
1869
|
+
@pulumi.getter(name="isDstFileUpdateEnabled")
|
|
1870
|
+
def is_dst_file_update_enabled(self) -> pulumi.Output[bool]:
|
|
1871
|
+
"""
|
|
1872
|
+
Indicates if an automatic DST Time Zone file update is enabled for the Autonomous Container Database. If enabled along with Release Update, patching will be done in a Non-Rolling manner.
|
|
1873
|
+
"""
|
|
1874
|
+
return pulumi.get(self, "is_dst_file_update_enabled")
|
|
1875
|
+
|
|
1876
|
+
@property
|
|
1877
|
+
@pulumi.getter(name="isMultipleStandby")
|
|
1878
|
+
def is_multiple_standby(self) -> pulumi.Output[bool]:
|
|
1879
|
+
"""
|
|
1880
|
+
Whether it is multiple standby Autonomous Dataguard
|
|
1881
|
+
"""
|
|
1882
|
+
return pulumi.get(self, "is_multiple_standby")
|
|
1883
|
+
|
|
1884
|
+
@property
|
|
1885
|
+
@pulumi.getter(name="keyHistoryEntries")
|
|
1886
|
+
def key_history_entries(self) -> pulumi.Output[Sequence['outputs.AutonomousContainerDatabaseAddStandbyKeyHistoryEntry']]:
|
|
1887
|
+
"""
|
|
1888
|
+
Key History Entry.
|
|
1889
|
+
"""
|
|
1890
|
+
return pulumi.get(self, "key_history_entries")
|
|
1891
|
+
|
|
1892
|
+
@property
|
|
1893
|
+
@pulumi.getter(name="keyStoreId")
|
|
1894
|
+
def key_store_id(self) -> pulumi.Output[str]:
|
|
1895
|
+
"""
|
|
1896
|
+
The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the key store of Oracle Vault.
|
|
1897
|
+
"""
|
|
1898
|
+
return pulumi.get(self, "key_store_id")
|
|
1899
|
+
|
|
1900
|
+
@property
|
|
1901
|
+
@pulumi.getter(name="keyStoreWalletName")
|
|
1902
|
+
def key_store_wallet_name(self) -> pulumi.Output[str]:
|
|
1903
|
+
"""
|
|
1904
|
+
The wallet name for Oracle Key Vault.
|
|
1905
|
+
"""
|
|
1906
|
+
return pulumi.get(self, "key_store_wallet_name")
|
|
1907
|
+
|
|
1908
|
+
@property
|
|
1909
|
+
@pulumi.getter(name="kmsKeyId")
|
|
1910
|
+
def kms_key_id(self) -> pulumi.Output[str]:
|
|
1911
|
+
"""
|
|
1912
|
+
The OCID of the key container that is used as the master encryption key in database transparent data encryption (TDE) operations.
|
|
1913
|
+
"""
|
|
1914
|
+
return pulumi.get(self, "kms_key_id")
|
|
1915
|
+
|
|
1916
|
+
@property
|
|
1917
|
+
@pulumi.getter(name="kmsKeyVersionId")
|
|
1918
|
+
def kms_key_version_id(self) -> pulumi.Output[str]:
|
|
1919
|
+
"""
|
|
1920
|
+
The OCID of the key container version that is used in database transparent data encryption (TDE) operations KMS Key can have multiple key versions. If none is specified, the current key version (latest) of the Key Id is used for the operation. Autonomous Database Serverless does not use key versions, hence is not applicable for Autonomous Database Serverless instances.
|
|
1921
|
+
"""
|
|
1922
|
+
return pulumi.get(self, "kms_key_version_id")
|
|
1923
|
+
|
|
1924
|
+
@property
|
|
1925
|
+
@pulumi.getter(name="largestProvisionableAutonomousDatabaseInCpus")
|
|
1926
|
+
def largest_provisionable_autonomous_database_in_cpus(self) -> pulumi.Output[float]:
|
|
1927
|
+
"""
|
|
1928
|
+
The largest Autonomous Database (CPU) that can be created in a new Autonomous Container Database.
|
|
1929
|
+
"""
|
|
1930
|
+
return pulumi.get(self, "largest_provisionable_autonomous_database_in_cpus")
|
|
1931
|
+
|
|
1932
|
+
@property
|
|
1933
|
+
@pulumi.getter(name="lastMaintenanceRunId")
|
|
1934
|
+
def last_maintenance_run_id(self) -> pulumi.Output[str]:
|
|
1935
|
+
"""
|
|
1936
|
+
The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the last maintenance run.
|
|
1937
|
+
"""
|
|
1938
|
+
return pulumi.get(self, "last_maintenance_run_id")
|
|
1939
|
+
|
|
1940
|
+
@property
|
|
1941
|
+
@pulumi.getter(name="lifecycleDetails")
|
|
1942
|
+
def lifecycle_details(self) -> pulumi.Output[str]:
|
|
1943
|
+
"""
|
|
1944
|
+
Additional information about the current lifecycle state.
|
|
1945
|
+
"""
|
|
1946
|
+
return pulumi.get(self, "lifecycle_details")
|
|
1947
|
+
|
|
1948
|
+
@property
|
|
1949
|
+
@pulumi.getter(name="listOneOffPatches")
|
|
1950
|
+
def list_one_off_patches(self) -> pulumi.Output[Sequence[str]]:
|
|
1951
|
+
"""
|
|
1952
|
+
List of One-Off patches that has been successfully applied to Autonomous Container Database
|
|
1953
|
+
"""
|
|
1954
|
+
return pulumi.get(self, "list_one_off_patches")
|
|
1955
|
+
|
|
1956
|
+
@property
|
|
1957
|
+
@pulumi.getter(name="maintenanceWindows")
|
|
1958
|
+
def maintenance_windows(self) -> pulumi.Output[Sequence['outputs.AutonomousContainerDatabaseAddStandbyMaintenanceWindow']]:
|
|
1959
|
+
"""
|
|
1960
|
+
The scheduling details for the quarterly maintenance window. Patching and system updates take place during the maintenance window.
|
|
1961
|
+
"""
|
|
1962
|
+
return pulumi.get(self, "maintenance_windows")
|
|
1963
|
+
|
|
1964
|
+
@property
|
|
1965
|
+
@pulumi.getter(name="memoryPerOracleComputeUnitInGbs")
|
|
1966
|
+
def memory_per_oracle_compute_unit_in_gbs(self) -> pulumi.Output[int]:
|
|
1967
|
+
"""
|
|
1968
|
+
The amount of memory (in GBs) enabled per ECPU or OCPU in the Autonomous VM Cluster.
|
|
1969
|
+
"""
|
|
1970
|
+
return pulumi.get(self, "memory_per_oracle_compute_unit_in_gbs")
|
|
1971
|
+
|
|
1972
|
+
@property
|
|
1973
|
+
@pulumi.getter(name="netServicesArchitecture")
|
|
1974
|
+
def net_services_architecture(self) -> pulumi.Output[str]:
|
|
1975
|
+
"""
|
|
1976
|
+
Enabling SHARED server architecture enables a database server to allow many client processes to share very few server processes, thereby increasing the number of supported users.
|
|
1977
|
+
"""
|
|
1978
|
+
return pulumi.get(self, "net_services_architecture")
|
|
1979
|
+
|
|
1980
|
+
@property
|
|
1981
|
+
@pulumi.getter(name="nextMaintenanceRunId")
|
|
1982
|
+
def next_maintenance_run_id(self) -> pulumi.Output[str]:
|
|
1983
|
+
"""
|
|
1984
|
+
The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the next maintenance run.
|
|
1985
|
+
"""
|
|
1986
|
+
return pulumi.get(self, "next_maintenance_run_id")
|
|
1987
|
+
|
|
1988
|
+
@property
|
|
1989
|
+
@pulumi.getter(name="patchId")
|
|
1990
|
+
def patch_id(self) -> pulumi.Output[str]:
|
|
1991
|
+
"""
|
|
1992
|
+
The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the last patch applied on the system.
|
|
1993
|
+
"""
|
|
1994
|
+
return pulumi.get(self, "patch_id")
|
|
1995
|
+
|
|
1996
|
+
@property
|
|
1997
|
+
@pulumi.getter(name="patchModel")
|
|
1998
|
+
def patch_model(self) -> pulumi.Output[str]:
|
|
1999
|
+
"""
|
|
2000
|
+
Database patch model preference.
|
|
2001
|
+
"""
|
|
2002
|
+
return pulumi.get(self, "patch_model")
|
|
2003
|
+
|
|
2004
|
+
@property
|
|
2005
|
+
@pulumi.getter(name="peerAutonomousContainerDatabaseBackupConfig")
|
|
2006
|
+
def peer_autonomous_container_database_backup_config(self) -> pulumi.Output['outputs.AutonomousContainerDatabaseAddStandbyPeerAutonomousContainerDatabaseBackupConfig']:
|
|
2007
|
+
"""
|
|
2008
|
+
Backup options for the standby Autonomous Container Database.
|
|
2009
|
+
"""
|
|
2010
|
+
return pulumi.get(self, "peer_autonomous_container_database_backup_config")
|
|
2011
|
+
|
|
2012
|
+
@property
|
|
2013
|
+
@pulumi.getter(name="peerAutonomousContainerDatabaseCompartmentId")
|
|
2014
|
+
def peer_autonomous_container_database_compartment_id(self) -> pulumi.Output[str]:
|
|
2015
|
+
"""
|
|
2016
|
+
The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the compartment where the standby Autonomous Container Database will be created.
|
|
2017
|
+
"""
|
|
2018
|
+
return pulumi.get(self, "peer_autonomous_container_database_compartment_id")
|
|
2019
|
+
|
|
2020
|
+
@property
|
|
2021
|
+
@pulumi.getter(name="peerAutonomousContainerDatabaseDisplayName")
|
|
2022
|
+
def peer_autonomous_container_database_display_name(self) -> pulumi.Output[str]:
|
|
2023
|
+
"""
|
|
2024
|
+
The display name for the peer Autonomous Container Database.
|
|
2025
|
+
"""
|
|
2026
|
+
return pulumi.get(self, "peer_autonomous_container_database_display_name")
|
|
2027
|
+
|
|
2028
|
+
@property
|
|
2029
|
+
@pulumi.getter(name="peerAutonomousVmClusterId")
|
|
2030
|
+
def peer_autonomous_vm_cluster_id(self) -> pulumi.Output[str]:
|
|
2031
|
+
"""
|
|
2032
|
+
The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the peer Autonomous Exadata VM Cluster.
|
|
2033
|
+
"""
|
|
2034
|
+
return pulumi.get(self, "peer_autonomous_vm_cluster_id")
|
|
2035
|
+
|
|
2036
|
+
@property
|
|
2037
|
+
@pulumi.getter(name="peerCloudAutonomousVmClusterId")
|
|
2038
|
+
def peer_cloud_autonomous_vm_cluster_id(self) -> pulumi.Output[str]:
|
|
2039
|
+
"""
|
|
2040
|
+
The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the peer cloud Autonomous Exadata VM Cluster.
|
|
2041
|
+
"""
|
|
2042
|
+
return pulumi.get(self, "peer_cloud_autonomous_vm_cluster_id")
|
|
2043
|
+
|
|
2044
|
+
@property
|
|
2045
|
+
@pulumi.getter(name="peerDbUniqueName")
|
|
2046
|
+
def peer_db_unique_name(self) -> pulumi.Output[str]:
|
|
2047
|
+
"""
|
|
2048
|
+
Specifies the `DB_UNIQUE_NAME` of the peer database to be created.
|
|
2049
|
+
"""
|
|
2050
|
+
return pulumi.get(self, "peer_db_unique_name")
|
|
2051
|
+
|
|
2052
|
+
@property
|
|
2053
|
+
@pulumi.getter(name="protectionMode")
|
|
2054
|
+
def protection_mode(self) -> pulumi.Output[str]:
|
|
2055
|
+
"""
|
|
2056
|
+
The protection mode of this Autonomous Data Guard association. For more information, see [Oracle Data Guard Protection Modes](http://docs.oracle.com/database/122/SBYDB/oracle-data-guard-protection-modes.htm#SBYDB02000) in the Oracle Data Guard documentation.
|
|
2057
|
+
"""
|
|
2058
|
+
return pulumi.get(self, "protection_mode")
|
|
2059
|
+
|
|
2060
|
+
@property
|
|
2061
|
+
@pulumi.getter(name="provisionableCpuses")
|
|
2062
|
+
def provisionable_cpuses(self) -> pulumi.Output[Sequence[float]]:
|
|
2063
|
+
"""
|
|
2064
|
+
An array of CPU values that can be used to successfully provision a single Autonomous Database.
|
|
2065
|
+
"""
|
|
2066
|
+
return pulumi.get(self, "provisionable_cpuses")
|
|
2067
|
+
|
|
2068
|
+
@property
|
|
2069
|
+
@pulumi.getter(name="provisionedCpus")
|
|
2070
|
+
def provisioned_cpus(self) -> pulumi.Output[float]:
|
|
2071
|
+
"""
|
|
2072
|
+
The number of CPUs provisioned in an Autonomous Container Database.
|
|
2073
|
+
"""
|
|
2074
|
+
return pulumi.get(self, "provisioned_cpus")
|
|
2075
|
+
|
|
2076
|
+
@property
|
|
2077
|
+
@pulumi.getter(name="reclaimableCpus")
|
|
2078
|
+
def reclaimable_cpus(self) -> pulumi.Output[float]:
|
|
2079
|
+
"""
|
|
2080
|
+
CPUs that continue to be included in the count of CPUs available to the Autonomous Container Database even after one of its Autonomous Database is terminated or scaled down. You can release them to the available CPUs at its parent Autonomous VM Cluster level by restarting the Autonomous Container Database.
|
|
2081
|
+
"""
|
|
2082
|
+
return pulumi.get(self, "reclaimable_cpus")
|
|
2083
|
+
|
|
2084
|
+
@property
|
|
2085
|
+
@pulumi.getter(name="reservedCpus")
|
|
2086
|
+
def reserved_cpus(self) -> pulumi.Output[float]:
|
|
2087
|
+
"""
|
|
2088
|
+
The number of CPUs reserved in an Autonomous Container Database.
|
|
2089
|
+
"""
|
|
2090
|
+
return pulumi.get(self, "reserved_cpus")
|
|
2091
|
+
|
|
2092
|
+
@property
|
|
2093
|
+
@pulumi.getter
|
|
2094
|
+
def role(self) -> pulumi.Output[str]:
|
|
2095
|
+
"""
|
|
2096
|
+
The Data Guard role of the Autonomous Container Database or Autonomous Database, if Autonomous Data Guard is enabled.
|
|
2097
|
+
"""
|
|
2098
|
+
return pulumi.get(self, "role")
|
|
2099
|
+
|
|
2100
|
+
@property
|
|
2101
|
+
@pulumi.getter(name="serviceLevelAgreementType")
|
|
2102
|
+
def service_level_agreement_type(self) -> pulumi.Output[str]:
|
|
2103
|
+
"""
|
|
2104
|
+
The service level agreement type of the container database. The default is STANDARD.
|
|
2105
|
+
"""
|
|
2106
|
+
return pulumi.get(self, "service_level_agreement_type")
|
|
2107
|
+
|
|
2108
|
+
@property
|
|
2109
|
+
@pulumi.getter(name="standbyMaintenanceBufferInDays")
|
|
2110
|
+
def standby_maintenance_buffer_in_days(self) -> pulumi.Output[int]:
|
|
2111
|
+
"""
|
|
2112
|
+
The scheduling detail for the quarterly maintenance window of the standby Autonomous Container Database. This value represents the number of days before scheduled maintenance of the primary database.
|
|
2113
|
+
|
|
2114
|
+
|
|
2115
|
+
** IMPORTANT **
|
|
2116
|
+
Any change to a property that does not support update will force the destruction and recreation of the resource with the new property values
|
|
2117
|
+
"""
|
|
2118
|
+
return pulumi.get(self, "standby_maintenance_buffer_in_days")
|
|
2119
|
+
|
|
2120
|
+
@property
|
|
2121
|
+
@pulumi.getter
|
|
2122
|
+
def state(self) -> pulumi.Output[str]:
|
|
2123
|
+
"""
|
|
2124
|
+
The current state of the Autonomous Container Database.
|
|
2125
|
+
"""
|
|
2126
|
+
return pulumi.get(self, "state")
|
|
2127
|
+
|
|
2128
|
+
@property
|
|
2129
|
+
@pulumi.getter(name="timeCreated")
|
|
2130
|
+
def time_created(self) -> pulumi.Output[str]:
|
|
2131
|
+
"""
|
|
2132
|
+
The date and time the Autonomous Container Database was created.
|
|
2133
|
+
"""
|
|
2134
|
+
return pulumi.get(self, "time_created")
|
|
2135
|
+
|
|
2136
|
+
@property
|
|
2137
|
+
@pulumi.getter(name="timeOfLastBackup")
|
|
2138
|
+
def time_of_last_backup(self) -> pulumi.Output[str]:
|
|
2139
|
+
"""
|
|
2140
|
+
The timestamp of last successful backup. Here NULL value represents either there are no successful backups or backups are not configured for this Autonomous Container Database.
|
|
2141
|
+
"""
|
|
2142
|
+
return pulumi.get(self, "time_of_last_backup")
|
|
2143
|
+
|
|
2144
|
+
@property
|
|
2145
|
+
@pulumi.getter(name="timeSnapshotStandbyRevert")
|
|
2146
|
+
def time_snapshot_standby_revert(self) -> pulumi.Output[str]:
|
|
2147
|
+
"""
|
|
2148
|
+
The date and time the Autonomous Container Database will be reverted to Standby from Snapshot Standby.
|
|
2149
|
+
"""
|
|
2150
|
+
return pulumi.get(self, "time_snapshot_standby_revert")
|
|
2151
|
+
|
|
2152
|
+
@property
|
|
2153
|
+
@pulumi.getter(name="totalCpus")
|
|
2154
|
+
def total_cpus(self) -> pulumi.Output[int]:
|
|
2155
|
+
"""
|
|
2156
|
+
The number of CPUs allocated to the Autonomous VM cluster.
|
|
2157
|
+
"""
|
|
2158
|
+
return pulumi.get(self, "total_cpus")
|
|
2159
|
+
|
|
2160
|
+
@property
|
|
2161
|
+
@pulumi.getter(name="vaultId")
|
|
2162
|
+
def vault_id(self) -> pulumi.Output[str]:
|
|
2163
|
+
"""
|
|
2164
|
+
The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the Oracle Cloud Infrastructure [vault](https://docs.cloud.oracle.com/iaas/Content/KeyManagement/Concepts/keyoverview.htm#concepts). This parameter and `secretId` are required for Customer Managed Keys.
|
|
2165
|
+
"""
|
|
2166
|
+
return pulumi.get(self, "vault_id")
|
|
2167
|
+
|
|
2168
|
+
@property
|
|
2169
|
+
@pulumi.getter(name="versionPreference")
|
|
2170
|
+
def version_preference(self) -> pulumi.Output[str]:
|
|
2171
|
+
"""
|
|
2172
|
+
The next maintenance version preference.
|
|
2173
|
+
"""
|
|
2174
|
+
return pulumi.get(self, "version_preference")
|
|
2175
|
+
|
|
2176
|
+
@property
|
|
2177
|
+
@pulumi.getter(name="vmFailoverReservation")
|
|
2178
|
+
def vm_failover_reservation(self) -> pulumi.Output[int]:
|
|
2179
|
+
"""
|
|
2180
|
+
The percentage of CPUs reserved across nodes to support node failover. Allowed values are 0%, 25%, and 50%, with 50% being the default option.
|
|
2181
|
+
"""
|
|
2182
|
+
return pulumi.get(self, "vm_failover_reservation")
|
|
2183
|
+
|