pulumi-gcp 8.7.0a1730183903__py3-none-any.whl → 8.7.0a1730196225__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_gcp/__init__.py +70 -0
- pulumi_gcp/accesscontextmanager/service_perimeter.py +2 -0
- pulumi_gcp/accesscontextmanager/service_perimeter_dry_run_egress_policy.py +4 -0
- pulumi_gcp/accesscontextmanager/service_perimeter_dry_run_ingress_policy.py +4 -0
- pulumi_gcp/accesscontextmanager/service_perimeter_egress_policy.py +4 -0
- pulumi_gcp/accesscontextmanager/service_perimeter_ingress_policy.py +4 -0
- pulumi_gcp/accesscontextmanager/service_perimeters.py +2 -0
- pulumi_gcp/apigee/__init__.py +2 -0
- pulumi_gcp/apigee/_inputs.py +108 -0
- pulumi_gcp/apigee/app_group.py +811 -0
- pulumi_gcp/apigee/developer.py +757 -0
- pulumi_gcp/apigee/outputs.py +64 -0
- pulumi_gcp/artifactregistry/get_docker_image.py +40 -0
- pulumi_gcp/bigquery/connection.py +12 -12
- pulumi_gcp/bigquery/job.py +6 -6
- pulumi_gcp/cloudrunv2/get_service.py +12 -1
- pulumi_gcp/cloudrunv2/service.py +92 -0
- pulumi_gcp/compute/_inputs.py +214 -116
- pulumi_gcp/compute/backend_service.py +76 -0
- pulumi_gcp/compute/get_backend_service.py +12 -1
- pulumi_gcp/compute/get_instance.py +29 -1
- pulumi_gcp/compute/get_instance_template.py +29 -1
- pulumi_gcp/compute/get_region_instance_group_manager.py +0 -18
- pulumi_gcp/compute/get_region_instance_template.py +29 -1
- pulumi_gcp/compute/instance.py +89 -0
- pulumi_gcp/compute/instance_from_machine_image.py +82 -0
- pulumi_gcp/compute/instance_from_template.py +82 -0
- pulumi_gcp/compute/instance_template.py +75 -0
- pulumi_gcp/compute/network_firewall_policy_association.py +76 -50
- pulumi_gcp/compute/network_firewall_policy_rule.py +149 -103
- pulumi_gcp/compute/outputs.py +170 -80
- pulumi_gcp/compute/region_backend_service.py +94 -0
- pulumi_gcp/compute/region_instance_template.py +75 -0
- pulumi_gcp/compute/region_network_endpoint_group.py +6 -4
- pulumi_gcp/compute/region_network_firewall_policy_association.py +104 -54
- pulumi_gcp/compute/region_network_firewall_policy_rule.py +160 -107
- pulumi_gcp/config/__init__.pyi +4 -0
- pulumi_gcp/config/vars.py +8 -0
- pulumi_gcp/container/attached_cluster.py +9 -6
- pulumi_gcp/container/outputs.py +2 -2
- pulumi_gcp/datastream/stream.py +2 -2
- pulumi_gcp/diagflow/_inputs.py +472 -2
- pulumi_gcp/diagflow/cx_agent.py +64 -4
- pulumi_gcp/diagflow/cx_flow.py +30 -0
- pulumi_gcp/diagflow/outputs.py +378 -2
- pulumi_gcp/gkehub/feature.py +2 -4
- pulumi_gcp/iam/workload_identity_pool_provider.py +56 -0
- pulumi_gcp/looker/instance.py +104 -2
- pulumi_gcp/monitoring/_inputs.py +23 -0
- pulumi_gcp/monitoring/get_secret_version.py +22 -3
- pulumi_gcp/monitoring/outputs.py +16 -0
- pulumi_gcp/networkconnectivity/__init__.py +1 -0
- pulumi_gcp/networkconnectivity/_inputs.py +148 -0
- pulumi_gcp/networkconnectivity/group.py +764 -0
- pulumi_gcp/networkconnectivity/outputs.py +125 -0
- pulumi_gcp/networkconnectivity/spoke.py +144 -0
- pulumi_gcp/networksecurity/server_tls_policy.py +2 -2
- pulumi_gcp/oracledatabase/__init__.py +20 -0
- pulumi_gcp/oracledatabase/_inputs.py +4745 -0
- pulumi_gcp/oracledatabase/autonomous_database.py +983 -0
- pulumi_gcp/oracledatabase/cloud_exadata_infrastructure.py +842 -0
- pulumi_gcp/oracledatabase/cloud_vm_cluster.py +1086 -0
- pulumi_gcp/oracledatabase/get_autonomous_database.py +290 -0
- pulumi_gcp/oracledatabase/get_autonomous_databases.py +150 -0
- pulumi_gcp/oracledatabase/get_cloud_exadata_infrastructure.py +257 -0
- pulumi_gcp/oracledatabase/get_cloud_exadata_infrastructures.py +150 -0
- pulumi_gcp/oracledatabase/get_cloud_vm_cluster.py +290 -0
- pulumi_gcp/oracledatabase/get_cloud_vm_clusters.py +150 -0
- pulumi_gcp/oracledatabase/get_db_nodes.py +245 -0
- pulumi_gcp/oracledatabase/get_db_servers.py +245 -0
- pulumi_gcp/oracledatabase/outputs.py +9304 -0
- pulumi_gcp/organizations/folder.py +7 -7
- pulumi_gcp/organizations/project.py +7 -7
- pulumi_gcp/orgpolicy/_inputs.py +3 -3
- pulumi_gcp/orgpolicy/outputs.py +2 -2
- pulumi_gcp/privilegedaccessmanager/get_entitlement.py +46 -2
- pulumi_gcp/provider.py +40 -0
- pulumi_gcp/pulumi-plugin.json +1 -1
- pulumi_gcp/secretmanager/get_regional_secret_version.py +24 -5
- pulumi_gcp/secretmanager/get_regional_secret_version_access.py +24 -5
- pulumi_gcp/secretmanager/get_secret_version.py +22 -3
- pulumi_gcp/secretmanager/get_secret_version_access.py +22 -3
- pulumi_gcp/secretmanager/regional_secret.py +2 -2
- pulumi_gcp/siteverification/get_token.py +0 -16
- pulumi_gcp/siteverification/owner.py +0 -16
- pulumi_gcp/spanner/_inputs.py +29 -5
- pulumi_gcp/spanner/outputs.py +20 -3
- pulumi_gcp/sql/_inputs.py +6 -6
- pulumi_gcp/sql/outputs.py +4 -4
- pulumi_gcp/sql/user.py +28 -21
- pulumi_gcp/storage/_inputs.py +36 -0
- pulumi_gcp/storage/bucket.py +47 -0
- pulumi_gcp/storage/get_bucket.py +12 -1
- pulumi_gcp/storage/outputs.py +40 -0
- pulumi_gcp/transcoder/__init__.py +11 -0
- pulumi_gcp/transcoder/_inputs.py +3991 -0
- pulumi_gcp/transcoder/job.py +2134 -0
- pulumi_gcp/transcoder/job_template.py +1524 -0
- pulumi_gcp/transcoder/outputs.py +2918 -0
- pulumi_gcp/vertex/ai_deployment_resource_pool.py +2 -2
- pulumi_gcp/vmwareengine/_inputs.py +440 -0
- pulumi_gcp/vmwareengine/cluster.py +100 -2
- pulumi_gcp/vmwareengine/get_cluster.py +12 -1
- pulumi_gcp/vmwareengine/outputs.py +615 -0
- pulumi_gcp/workstations/_inputs.py +54 -0
- pulumi_gcp/workstations/outputs.py +32 -0
- pulumi_gcp/workstations/workstation_config.py +205 -0
- {pulumi_gcp-8.7.0a1730183903.dist-info → pulumi_gcp-8.7.0a1730196225.dist-info}/METADATA +1 -1
- {pulumi_gcp-8.7.0a1730183903.dist-info → pulumi_gcp-8.7.0a1730196225.dist-info}/RECORD +111 -89
- {pulumi_gcp-8.7.0a1730183903.dist-info → pulumi_gcp-8.7.0a1730196225.dist-info}/WHEEL +1 -1
- {pulumi_gcp-8.7.0a1730183903.dist-info → pulumi_gcp-8.7.0a1730196225.dist-info}/top_level.txt +0 -0
|
@@ -0,0 +1,4745 @@
|
|
|
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
|
+
|
|
17
|
+
__all__ = [
|
|
18
|
+
'AutonomousDatabasePropertiesArgs',
|
|
19
|
+
'AutonomousDatabasePropertiesArgsDict',
|
|
20
|
+
'AutonomousDatabasePropertiesApexDetailArgs',
|
|
21
|
+
'AutonomousDatabasePropertiesApexDetailArgsDict',
|
|
22
|
+
'AutonomousDatabasePropertiesConnectionStringArgs',
|
|
23
|
+
'AutonomousDatabasePropertiesConnectionStringArgsDict',
|
|
24
|
+
'AutonomousDatabasePropertiesConnectionStringAllConnectionStringArgs',
|
|
25
|
+
'AutonomousDatabasePropertiesConnectionStringAllConnectionStringArgsDict',
|
|
26
|
+
'AutonomousDatabasePropertiesConnectionStringProfileArgs',
|
|
27
|
+
'AutonomousDatabasePropertiesConnectionStringProfileArgsDict',
|
|
28
|
+
'AutonomousDatabasePropertiesConnectionUrlArgs',
|
|
29
|
+
'AutonomousDatabasePropertiesConnectionUrlArgsDict',
|
|
30
|
+
'AutonomousDatabasePropertiesCustomerContactArgs',
|
|
31
|
+
'AutonomousDatabasePropertiesCustomerContactArgsDict',
|
|
32
|
+
'AutonomousDatabasePropertiesLocalStandbyDbArgs',
|
|
33
|
+
'AutonomousDatabasePropertiesLocalStandbyDbArgsDict',
|
|
34
|
+
'AutonomousDatabasePropertiesScheduledOperationDetailArgs',
|
|
35
|
+
'AutonomousDatabasePropertiesScheduledOperationDetailArgsDict',
|
|
36
|
+
'AutonomousDatabasePropertiesScheduledOperationDetailStartTimeArgs',
|
|
37
|
+
'AutonomousDatabasePropertiesScheduledOperationDetailStartTimeArgsDict',
|
|
38
|
+
'AutonomousDatabasePropertiesScheduledOperationDetailStopTimeArgs',
|
|
39
|
+
'AutonomousDatabasePropertiesScheduledOperationDetailStopTimeArgsDict',
|
|
40
|
+
'CloudExadataInfrastructurePropertiesArgs',
|
|
41
|
+
'CloudExadataInfrastructurePropertiesArgsDict',
|
|
42
|
+
'CloudExadataInfrastructurePropertiesCustomerContactArgs',
|
|
43
|
+
'CloudExadataInfrastructurePropertiesCustomerContactArgsDict',
|
|
44
|
+
'CloudExadataInfrastructurePropertiesMaintenanceWindowArgs',
|
|
45
|
+
'CloudExadataInfrastructurePropertiesMaintenanceWindowArgsDict',
|
|
46
|
+
'CloudVmClusterPropertiesArgs',
|
|
47
|
+
'CloudVmClusterPropertiesArgsDict',
|
|
48
|
+
'CloudVmClusterPropertiesDiagnosticsDataCollectionOptionsArgs',
|
|
49
|
+
'CloudVmClusterPropertiesDiagnosticsDataCollectionOptionsArgsDict',
|
|
50
|
+
'CloudVmClusterPropertiesTimeZoneArgs',
|
|
51
|
+
'CloudVmClusterPropertiesTimeZoneArgsDict',
|
|
52
|
+
]
|
|
53
|
+
|
|
54
|
+
MYPY = False
|
|
55
|
+
|
|
56
|
+
if not MYPY:
|
|
57
|
+
class AutonomousDatabasePropertiesArgsDict(TypedDict):
|
|
58
|
+
db_workload: pulumi.Input[str]
|
|
59
|
+
"""
|
|
60
|
+
Possible values:
|
|
61
|
+
DB_WORKLOAD_UNSPECIFIED
|
|
62
|
+
OLTP
|
|
63
|
+
DW
|
|
64
|
+
AJD
|
|
65
|
+
APEX
|
|
66
|
+
"""
|
|
67
|
+
license_type: pulumi.Input[str]
|
|
68
|
+
"""
|
|
69
|
+
The license type used for the Autonomous Database.
|
|
70
|
+
Possible values:
|
|
71
|
+
LICENSE_TYPE_UNSPECIFIED
|
|
72
|
+
LICENSE_INCLUDED
|
|
73
|
+
BRING_YOUR_OWN_LICENSE
|
|
74
|
+
"""
|
|
75
|
+
actual_used_data_storage_size_tb: NotRequired[pulumi.Input[float]]
|
|
76
|
+
"""
|
|
77
|
+
(Output)
|
|
78
|
+
The amount of storage currently being used for user and system data, in
|
|
79
|
+
terabytes.
|
|
80
|
+
"""
|
|
81
|
+
allocated_storage_size_tb: NotRequired[pulumi.Input[float]]
|
|
82
|
+
"""
|
|
83
|
+
(Output)
|
|
84
|
+
The amount of storage currently allocated for the database tables and
|
|
85
|
+
billed for, rounded up in terabytes.
|
|
86
|
+
"""
|
|
87
|
+
apex_details: NotRequired[pulumi.Input[Sequence[pulumi.Input['AutonomousDatabasePropertiesApexDetailArgsDict']]]]
|
|
88
|
+
"""
|
|
89
|
+
(Output)
|
|
90
|
+
Oracle APEX Application Development.
|
|
91
|
+
https://docs.oracle.com/en-us/iaas/api/#/en/database/20160918/datatypes/AutonomousDatabaseApex
|
|
92
|
+
Structure is documented below.
|
|
93
|
+
"""
|
|
94
|
+
are_primary_allowlisted_ips_used: NotRequired[pulumi.Input[bool]]
|
|
95
|
+
"""
|
|
96
|
+
(Output)
|
|
97
|
+
This field indicates the status of Data Guard and Access control for the
|
|
98
|
+
Autonomous Database. The field's value is null if Data Guard is disabled
|
|
99
|
+
or Access Control is disabled. The field's value is TRUE if both Data Guard
|
|
100
|
+
and Access Control are enabled, and the Autonomous Database is using
|
|
101
|
+
primary IP access control list (ACL) for standby. The field's value is
|
|
102
|
+
FALSE if both Data Guard and Access Control are enabled, and the Autonomous
|
|
103
|
+
Database is using a different IP access control list (ACL) for standby
|
|
104
|
+
compared to primary.
|
|
105
|
+
"""
|
|
106
|
+
autonomous_container_database_id: NotRequired[pulumi.Input[str]]
|
|
107
|
+
"""
|
|
108
|
+
(Output)
|
|
109
|
+
The Autonomous Container Database OCID.
|
|
110
|
+
"""
|
|
111
|
+
available_upgrade_versions: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
112
|
+
"""
|
|
113
|
+
(Output)
|
|
114
|
+
The list of available Oracle Database upgrade versions for an Autonomous
|
|
115
|
+
Database.
|
|
116
|
+
"""
|
|
117
|
+
backup_retention_period_days: NotRequired[pulumi.Input[int]]
|
|
118
|
+
"""
|
|
119
|
+
The retention period for the Autonomous Database. This field is specified
|
|
120
|
+
in days, can range from 1 day to 60 days, and has a default value of
|
|
121
|
+
60 days.
|
|
122
|
+
"""
|
|
123
|
+
character_set: NotRequired[pulumi.Input[str]]
|
|
124
|
+
"""
|
|
125
|
+
The character set for the Autonomous Database. The default is AL32UTF8.
|
|
126
|
+
"""
|
|
127
|
+
compute_count: NotRequired[pulumi.Input[float]]
|
|
128
|
+
"""
|
|
129
|
+
The number of compute servers for the Autonomous Database.
|
|
130
|
+
"""
|
|
131
|
+
connection_strings: NotRequired[pulumi.Input[Sequence[pulumi.Input['AutonomousDatabasePropertiesConnectionStringArgsDict']]]]
|
|
132
|
+
"""
|
|
133
|
+
(Output)
|
|
134
|
+
The connection string used to connect to the Autonomous Database.
|
|
135
|
+
https://docs.oracle.com/en-us/iaas/api/#/en/database/20160918/datatypes/AutonomousDatabaseConnectionStrings
|
|
136
|
+
Structure is documented below.
|
|
137
|
+
"""
|
|
138
|
+
connection_urls: NotRequired[pulumi.Input[Sequence[pulumi.Input['AutonomousDatabasePropertiesConnectionUrlArgsDict']]]]
|
|
139
|
+
"""
|
|
140
|
+
(Output)
|
|
141
|
+
The URLs for accessing Oracle Application Express (APEX) and SQL Developer
|
|
142
|
+
Web with a browser from a Compute instance.
|
|
143
|
+
https://docs.oracle.com/en-us/iaas/api/#/en/database/20160918/datatypes/AutonomousDatabaseConnectionUrls
|
|
144
|
+
Structure is documented below.
|
|
145
|
+
"""
|
|
146
|
+
customer_contacts: NotRequired[pulumi.Input[Sequence[pulumi.Input['AutonomousDatabasePropertiesCustomerContactArgsDict']]]]
|
|
147
|
+
"""
|
|
148
|
+
The list of customer contacts.
|
|
149
|
+
Structure is documented below.
|
|
150
|
+
"""
|
|
151
|
+
data_safe_state: NotRequired[pulumi.Input[str]]
|
|
152
|
+
"""
|
|
153
|
+
(Output)
|
|
154
|
+
The current state of the Data Safe registration for the
|
|
155
|
+
Autonomous Database.
|
|
156
|
+
Possible values:
|
|
157
|
+
DATA_SAFE_STATE_UNSPECIFIED
|
|
158
|
+
REGISTERING
|
|
159
|
+
REGISTERED
|
|
160
|
+
DEREGISTERING
|
|
161
|
+
NOT_REGISTERED
|
|
162
|
+
FAILED
|
|
163
|
+
"""
|
|
164
|
+
data_storage_size_gb: NotRequired[pulumi.Input[int]]
|
|
165
|
+
"""
|
|
166
|
+
The size of the data stored in the database, in gigabytes.
|
|
167
|
+
"""
|
|
168
|
+
data_storage_size_tb: NotRequired[pulumi.Input[int]]
|
|
169
|
+
"""
|
|
170
|
+
The size of the data stored in the database, in terabytes.
|
|
171
|
+
"""
|
|
172
|
+
database_management_state: NotRequired[pulumi.Input[str]]
|
|
173
|
+
"""
|
|
174
|
+
(Output)
|
|
175
|
+
The current state of database management for the Autonomous Database.
|
|
176
|
+
Possible values:
|
|
177
|
+
DATABASE_MANAGEMENT_STATE_UNSPECIFIED
|
|
178
|
+
ENABLING
|
|
179
|
+
ENABLED
|
|
180
|
+
DISABLING
|
|
181
|
+
NOT_ENABLED
|
|
182
|
+
FAILED_ENABLING
|
|
183
|
+
FAILED_DISABLING
|
|
184
|
+
"""
|
|
185
|
+
db_edition: NotRequired[pulumi.Input[str]]
|
|
186
|
+
"""
|
|
187
|
+
The edition of the Autonomous Databases.
|
|
188
|
+
Possible values:
|
|
189
|
+
DATABASE_EDITION_UNSPECIFIED
|
|
190
|
+
STANDARD_EDITION
|
|
191
|
+
ENTERPRISE_EDITION
|
|
192
|
+
"""
|
|
193
|
+
db_version: NotRequired[pulumi.Input[str]]
|
|
194
|
+
"""
|
|
195
|
+
The Oracle Database version for the Autonomous Database.
|
|
196
|
+
"""
|
|
197
|
+
failed_data_recovery_duration: NotRequired[pulumi.Input[str]]
|
|
198
|
+
"""
|
|
199
|
+
(Output)
|
|
200
|
+
This field indicates the number of seconds of data loss during a Data
|
|
201
|
+
Guard failover.
|
|
202
|
+
"""
|
|
203
|
+
is_auto_scaling_enabled: NotRequired[pulumi.Input[bool]]
|
|
204
|
+
"""
|
|
205
|
+
This field indicates if auto scaling is enabled for the Autonomous Database
|
|
206
|
+
CPU core count.
|
|
207
|
+
"""
|
|
208
|
+
is_local_data_guard_enabled: NotRequired[pulumi.Input[bool]]
|
|
209
|
+
"""
|
|
210
|
+
(Output)
|
|
211
|
+
This field indicates whether the Autonomous Database has local (in-region)
|
|
212
|
+
Data Guard enabled.
|
|
213
|
+
"""
|
|
214
|
+
is_storage_auto_scaling_enabled: NotRequired[pulumi.Input[bool]]
|
|
215
|
+
"""
|
|
216
|
+
This field indicates if auto scaling is enabled for the Autonomous Database
|
|
217
|
+
storage.
|
|
218
|
+
"""
|
|
219
|
+
lifecycle_details: NotRequired[pulumi.Input[str]]
|
|
220
|
+
"""
|
|
221
|
+
(Output)
|
|
222
|
+
The details of the current lifestyle state of the Autonomous Database.
|
|
223
|
+
"""
|
|
224
|
+
local_adg_auto_failover_max_data_loss_limit: NotRequired[pulumi.Input[int]]
|
|
225
|
+
"""
|
|
226
|
+
(Output)
|
|
227
|
+
This field indicates the maximum data loss limit for an Autonomous
|
|
228
|
+
Database, in seconds.
|
|
229
|
+
"""
|
|
230
|
+
local_disaster_recovery_type: NotRequired[pulumi.Input[str]]
|
|
231
|
+
"""
|
|
232
|
+
(Output)
|
|
233
|
+
This field indicates the local disaster recovery (DR) type of an
|
|
234
|
+
Autonomous Database.
|
|
235
|
+
Possible values:
|
|
236
|
+
LOCAL_DISASTER_RECOVERY_TYPE_UNSPECIFIED
|
|
237
|
+
ADG
|
|
238
|
+
BACKUP_BASED
|
|
239
|
+
"""
|
|
240
|
+
local_standby_dbs: NotRequired[pulumi.Input[Sequence[pulumi.Input['AutonomousDatabasePropertiesLocalStandbyDbArgsDict']]]]
|
|
241
|
+
"""
|
|
242
|
+
(Output)
|
|
243
|
+
Autonomous Data Guard standby database details.
|
|
244
|
+
https://docs.oracle.com/en-us/iaas/api/#/en/database/20160918/datatypes/AutonomousDatabaseStandbySummary
|
|
245
|
+
Structure is documented below.
|
|
246
|
+
"""
|
|
247
|
+
maintenance_begin_time: NotRequired[pulumi.Input[str]]
|
|
248
|
+
"""
|
|
249
|
+
(Output)
|
|
250
|
+
The date and time when maintenance will begin.
|
|
251
|
+
"""
|
|
252
|
+
maintenance_end_time: NotRequired[pulumi.Input[str]]
|
|
253
|
+
"""
|
|
254
|
+
(Output)
|
|
255
|
+
The date and time when maintenance will end.
|
|
256
|
+
"""
|
|
257
|
+
maintenance_schedule_type: NotRequired[pulumi.Input[str]]
|
|
258
|
+
"""
|
|
259
|
+
The maintenance schedule of the Autonomous Database.
|
|
260
|
+
Possible values:
|
|
261
|
+
MAINTENANCE_SCHEDULE_TYPE_UNSPECIFIED
|
|
262
|
+
EARLY
|
|
263
|
+
REGULAR
|
|
264
|
+
"""
|
|
265
|
+
memory_per_oracle_compute_unit_gbs: NotRequired[pulumi.Input[int]]
|
|
266
|
+
"""
|
|
267
|
+
(Output)
|
|
268
|
+
The amount of memory enabled per ECPU, in gigabytes.
|
|
269
|
+
"""
|
|
270
|
+
memory_table_gbs: NotRequired[pulumi.Input[int]]
|
|
271
|
+
"""
|
|
272
|
+
(Output)
|
|
273
|
+
The memory assigned to in-memory tables in an Autonomous Database.
|
|
274
|
+
"""
|
|
275
|
+
mtls_connection_required: NotRequired[pulumi.Input[bool]]
|
|
276
|
+
"""
|
|
277
|
+
This field specifies if the Autonomous Database requires mTLS connections.
|
|
278
|
+
"""
|
|
279
|
+
n_character_set: NotRequired[pulumi.Input[str]]
|
|
280
|
+
"""
|
|
281
|
+
The national character set for the Autonomous Database. The default is
|
|
282
|
+
AL16UTF16.
|
|
283
|
+
"""
|
|
284
|
+
next_long_term_backup_time: NotRequired[pulumi.Input[str]]
|
|
285
|
+
"""
|
|
286
|
+
(Output)
|
|
287
|
+
The long term backup schedule of the Autonomous Database.
|
|
288
|
+
"""
|
|
289
|
+
oci_url: NotRequired[pulumi.Input[str]]
|
|
290
|
+
"""
|
|
291
|
+
(Output)
|
|
292
|
+
The Oracle Cloud Infrastructure link for the Autonomous Database.
|
|
293
|
+
"""
|
|
294
|
+
ocid: NotRequired[pulumi.Input[str]]
|
|
295
|
+
"""
|
|
296
|
+
(Output)
|
|
297
|
+
OCID of the Autonomous Database.
|
|
298
|
+
https://docs.oracle.com/en-us/iaas/Content/General/Concepts/identifiers.htm#Oracle
|
|
299
|
+
"""
|
|
300
|
+
open_mode: NotRequired[pulumi.Input[str]]
|
|
301
|
+
"""
|
|
302
|
+
(Output)
|
|
303
|
+
This field indicates the current mode of the Autonomous Database.
|
|
304
|
+
Possible values:
|
|
305
|
+
OPEN_MODE_UNSPECIFIED
|
|
306
|
+
READ_ONLY
|
|
307
|
+
READ_WRITE
|
|
308
|
+
"""
|
|
309
|
+
operations_insights_state: NotRequired[pulumi.Input[str]]
|
|
310
|
+
"""
|
|
311
|
+
Possible values:
|
|
312
|
+
OPERATIONS_INSIGHTS_STATE_UNSPECIFIED
|
|
313
|
+
ENABLING
|
|
314
|
+
ENABLED
|
|
315
|
+
DISABLING
|
|
316
|
+
NOT_ENABLED
|
|
317
|
+
FAILED_ENABLING
|
|
318
|
+
FAILED_DISABLING
|
|
319
|
+
"""
|
|
320
|
+
peer_db_ids: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
321
|
+
"""
|
|
322
|
+
(Output)
|
|
323
|
+
The list of OCIDs of standby databases located in Autonomous Data Guard
|
|
324
|
+
remote regions that are associated with the source database.
|
|
325
|
+
"""
|
|
326
|
+
permission_level: NotRequired[pulumi.Input[str]]
|
|
327
|
+
"""
|
|
328
|
+
(Output)
|
|
329
|
+
The permission level of the Autonomous Database.
|
|
330
|
+
Possible values:
|
|
331
|
+
PERMISSION_LEVEL_UNSPECIFIED
|
|
332
|
+
RESTRICTED
|
|
333
|
+
UNRESTRICTED
|
|
334
|
+
"""
|
|
335
|
+
private_endpoint: NotRequired[pulumi.Input[str]]
|
|
336
|
+
"""
|
|
337
|
+
(Output)
|
|
338
|
+
The private endpoint for the Autonomous Database.
|
|
339
|
+
"""
|
|
340
|
+
private_endpoint_ip: NotRequired[pulumi.Input[str]]
|
|
341
|
+
"""
|
|
342
|
+
The private endpoint IP address for the Autonomous Database.
|
|
343
|
+
"""
|
|
344
|
+
private_endpoint_label: NotRequired[pulumi.Input[str]]
|
|
345
|
+
"""
|
|
346
|
+
The private endpoint label for the Autonomous Database.
|
|
347
|
+
"""
|
|
348
|
+
refreshable_mode: NotRequired[pulumi.Input[str]]
|
|
349
|
+
"""
|
|
350
|
+
(Output)
|
|
351
|
+
The refresh mode of the cloned Autonomous Database.
|
|
352
|
+
Possible values:
|
|
353
|
+
REFRESHABLE_MODE_UNSPECIFIED
|
|
354
|
+
AUTOMATIC
|
|
355
|
+
MANUAL
|
|
356
|
+
"""
|
|
357
|
+
refreshable_state: NotRequired[pulumi.Input[str]]
|
|
358
|
+
"""
|
|
359
|
+
(Output)
|
|
360
|
+
The refresh State of the clone.
|
|
361
|
+
Possible values:
|
|
362
|
+
REFRESHABLE_STATE_UNSPECIFIED
|
|
363
|
+
REFRESHING
|
|
364
|
+
NOT_REFRESHING
|
|
365
|
+
"""
|
|
366
|
+
role: NotRequired[pulumi.Input[str]]
|
|
367
|
+
"""
|
|
368
|
+
(Output)
|
|
369
|
+
The Data Guard role of the Autonomous Database.
|
|
370
|
+
Possible values:
|
|
371
|
+
ROLE_UNSPECIFIED
|
|
372
|
+
PRIMARY
|
|
373
|
+
STANDBY
|
|
374
|
+
DISABLED_STANDBY
|
|
375
|
+
BACKUP_COPY
|
|
376
|
+
SNAPSHOT_STANDBY
|
|
377
|
+
"""
|
|
378
|
+
scheduled_operation_details: NotRequired[pulumi.Input[Sequence[pulumi.Input['AutonomousDatabasePropertiesScheduledOperationDetailArgsDict']]]]
|
|
379
|
+
"""
|
|
380
|
+
(Output)
|
|
381
|
+
The list and details of the scheduled operations of the Autonomous
|
|
382
|
+
Database.
|
|
383
|
+
Structure is documented below.
|
|
384
|
+
"""
|
|
385
|
+
sql_web_developer_url: NotRequired[pulumi.Input[str]]
|
|
386
|
+
"""
|
|
387
|
+
(Output)
|
|
388
|
+
The SQL Web Developer URL for the Autonomous Database.
|
|
389
|
+
"""
|
|
390
|
+
state: NotRequired[pulumi.Input[str]]
|
|
391
|
+
"""
|
|
392
|
+
(Output)
|
|
393
|
+
Possible values:
|
|
394
|
+
STATE_UNSPECIFIED
|
|
395
|
+
PROVISIONING
|
|
396
|
+
AVAILABLE
|
|
397
|
+
STOPPING
|
|
398
|
+
STOPPED
|
|
399
|
+
STARTING
|
|
400
|
+
TERMINATING
|
|
401
|
+
TERMINATED
|
|
402
|
+
UNAVAILABLE
|
|
403
|
+
RESTORE_IN_PROGRESS
|
|
404
|
+
RESTORE_FAILED
|
|
405
|
+
BACKUP_IN_PROGRESS
|
|
406
|
+
SCALE_IN_PROGRESS
|
|
407
|
+
AVAILABLE_NEEDS_ATTENTION
|
|
408
|
+
UPDATING
|
|
409
|
+
MAINTENANCE_IN_PROGRESS
|
|
410
|
+
RESTARTING
|
|
411
|
+
RECREATING
|
|
412
|
+
ROLE_CHANGE_IN_PROGRESS
|
|
413
|
+
UPGRADING
|
|
414
|
+
INACCESSIBLE
|
|
415
|
+
STANDBY
|
|
416
|
+
"""
|
|
417
|
+
supported_clone_regions: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
418
|
+
"""
|
|
419
|
+
(Output)
|
|
420
|
+
The list of available regions that can be used to create a clone for the
|
|
421
|
+
Autonomous Database.
|
|
422
|
+
"""
|
|
423
|
+
total_auto_backup_storage_size_gbs: NotRequired[pulumi.Input[float]]
|
|
424
|
+
"""
|
|
425
|
+
(Output)
|
|
426
|
+
The storage space used by automatic backups of Autonomous Database, in
|
|
427
|
+
gigabytes.
|
|
428
|
+
"""
|
|
429
|
+
used_data_storage_size_tbs: NotRequired[pulumi.Input[int]]
|
|
430
|
+
"""
|
|
431
|
+
(Output)
|
|
432
|
+
The storage space used by Autonomous Database, in gigabytes.
|
|
433
|
+
"""
|
|
434
|
+
elif False:
|
|
435
|
+
AutonomousDatabasePropertiesArgsDict: TypeAlias = Mapping[str, Any]
|
|
436
|
+
|
|
437
|
+
@pulumi.input_type
|
|
438
|
+
class AutonomousDatabasePropertiesArgs:
|
|
439
|
+
def __init__(__self__, *,
|
|
440
|
+
db_workload: pulumi.Input[str],
|
|
441
|
+
license_type: pulumi.Input[str],
|
|
442
|
+
actual_used_data_storage_size_tb: Optional[pulumi.Input[float]] = None,
|
|
443
|
+
allocated_storage_size_tb: Optional[pulumi.Input[float]] = None,
|
|
444
|
+
apex_details: Optional[pulumi.Input[Sequence[pulumi.Input['AutonomousDatabasePropertiesApexDetailArgs']]]] = None,
|
|
445
|
+
are_primary_allowlisted_ips_used: Optional[pulumi.Input[bool]] = None,
|
|
446
|
+
autonomous_container_database_id: Optional[pulumi.Input[str]] = None,
|
|
447
|
+
available_upgrade_versions: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
448
|
+
backup_retention_period_days: Optional[pulumi.Input[int]] = None,
|
|
449
|
+
character_set: Optional[pulumi.Input[str]] = None,
|
|
450
|
+
compute_count: Optional[pulumi.Input[float]] = None,
|
|
451
|
+
connection_strings: Optional[pulumi.Input[Sequence[pulumi.Input['AutonomousDatabasePropertiesConnectionStringArgs']]]] = None,
|
|
452
|
+
connection_urls: Optional[pulumi.Input[Sequence[pulumi.Input['AutonomousDatabasePropertiesConnectionUrlArgs']]]] = None,
|
|
453
|
+
customer_contacts: Optional[pulumi.Input[Sequence[pulumi.Input['AutonomousDatabasePropertiesCustomerContactArgs']]]] = None,
|
|
454
|
+
data_safe_state: Optional[pulumi.Input[str]] = None,
|
|
455
|
+
data_storage_size_gb: Optional[pulumi.Input[int]] = None,
|
|
456
|
+
data_storage_size_tb: Optional[pulumi.Input[int]] = None,
|
|
457
|
+
database_management_state: Optional[pulumi.Input[str]] = None,
|
|
458
|
+
db_edition: Optional[pulumi.Input[str]] = None,
|
|
459
|
+
db_version: Optional[pulumi.Input[str]] = None,
|
|
460
|
+
failed_data_recovery_duration: Optional[pulumi.Input[str]] = None,
|
|
461
|
+
is_auto_scaling_enabled: Optional[pulumi.Input[bool]] = None,
|
|
462
|
+
is_local_data_guard_enabled: Optional[pulumi.Input[bool]] = None,
|
|
463
|
+
is_storage_auto_scaling_enabled: Optional[pulumi.Input[bool]] = None,
|
|
464
|
+
lifecycle_details: Optional[pulumi.Input[str]] = None,
|
|
465
|
+
local_adg_auto_failover_max_data_loss_limit: Optional[pulumi.Input[int]] = None,
|
|
466
|
+
local_disaster_recovery_type: Optional[pulumi.Input[str]] = None,
|
|
467
|
+
local_standby_dbs: Optional[pulumi.Input[Sequence[pulumi.Input['AutonomousDatabasePropertiesLocalStandbyDbArgs']]]] = None,
|
|
468
|
+
maintenance_begin_time: Optional[pulumi.Input[str]] = None,
|
|
469
|
+
maintenance_end_time: Optional[pulumi.Input[str]] = None,
|
|
470
|
+
maintenance_schedule_type: Optional[pulumi.Input[str]] = None,
|
|
471
|
+
memory_per_oracle_compute_unit_gbs: Optional[pulumi.Input[int]] = None,
|
|
472
|
+
memory_table_gbs: Optional[pulumi.Input[int]] = None,
|
|
473
|
+
mtls_connection_required: Optional[pulumi.Input[bool]] = None,
|
|
474
|
+
n_character_set: Optional[pulumi.Input[str]] = None,
|
|
475
|
+
next_long_term_backup_time: Optional[pulumi.Input[str]] = None,
|
|
476
|
+
oci_url: Optional[pulumi.Input[str]] = None,
|
|
477
|
+
ocid: Optional[pulumi.Input[str]] = None,
|
|
478
|
+
open_mode: Optional[pulumi.Input[str]] = None,
|
|
479
|
+
operations_insights_state: Optional[pulumi.Input[str]] = None,
|
|
480
|
+
peer_db_ids: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
481
|
+
permission_level: Optional[pulumi.Input[str]] = None,
|
|
482
|
+
private_endpoint: Optional[pulumi.Input[str]] = None,
|
|
483
|
+
private_endpoint_ip: Optional[pulumi.Input[str]] = None,
|
|
484
|
+
private_endpoint_label: Optional[pulumi.Input[str]] = None,
|
|
485
|
+
refreshable_mode: Optional[pulumi.Input[str]] = None,
|
|
486
|
+
refreshable_state: Optional[pulumi.Input[str]] = None,
|
|
487
|
+
role: Optional[pulumi.Input[str]] = None,
|
|
488
|
+
scheduled_operation_details: Optional[pulumi.Input[Sequence[pulumi.Input['AutonomousDatabasePropertiesScheduledOperationDetailArgs']]]] = None,
|
|
489
|
+
sql_web_developer_url: Optional[pulumi.Input[str]] = None,
|
|
490
|
+
state: Optional[pulumi.Input[str]] = None,
|
|
491
|
+
supported_clone_regions: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
492
|
+
total_auto_backup_storage_size_gbs: Optional[pulumi.Input[float]] = None,
|
|
493
|
+
used_data_storage_size_tbs: Optional[pulumi.Input[int]] = None):
|
|
494
|
+
"""
|
|
495
|
+
:param pulumi.Input[str] db_workload: Possible values:
|
|
496
|
+
DB_WORKLOAD_UNSPECIFIED
|
|
497
|
+
OLTP
|
|
498
|
+
DW
|
|
499
|
+
AJD
|
|
500
|
+
APEX
|
|
501
|
+
:param pulumi.Input[str] license_type: The license type used for the Autonomous Database.
|
|
502
|
+
Possible values:
|
|
503
|
+
LICENSE_TYPE_UNSPECIFIED
|
|
504
|
+
LICENSE_INCLUDED
|
|
505
|
+
BRING_YOUR_OWN_LICENSE
|
|
506
|
+
:param pulumi.Input[float] actual_used_data_storage_size_tb: (Output)
|
|
507
|
+
The amount of storage currently being used for user and system data, in
|
|
508
|
+
terabytes.
|
|
509
|
+
:param pulumi.Input[float] allocated_storage_size_tb: (Output)
|
|
510
|
+
The amount of storage currently allocated for the database tables and
|
|
511
|
+
billed for, rounded up in terabytes.
|
|
512
|
+
:param pulumi.Input[Sequence[pulumi.Input['AutonomousDatabasePropertiesApexDetailArgs']]] apex_details: (Output)
|
|
513
|
+
Oracle APEX Application Development.
|
|
514
|
+
https://docs.oracle.com/en-us/iaas/api/#/en/database/20160918/datatypes/AutonomousDatabaseApex
|
|
515
|
+
Structure is documented below.
|
|
516
|
+
:param pulumi.Input[bool] are_primary_allowlisted_ips_used: (Output)
|
|
517
|
+
This field indicates the status of Data Guard and Access control for the
|
|
518
|
+
Autonomous Database. The field's value is null if Data Guard is disabled
|
|
519
|
+
or Access Control is disabled. The field's value is TRUE if both Data Guard
|
|
520
|
+
and Access Control are enabled, and the Autonomous Database is using
|
|
521
|
+
primary IP access control list (ACL) for standby. The field's value is
|
|
522
|
+
FALSE if both Data Guard and Access Control are enabled, and the Autonomous
|
|
523
|
+
Database is using a different IP access control list (ACL) for standby
|
|
524
|
+
compared to primary.
|
|
525
|
+
:param pulumi.Input[str] autonomous_container_database_id: (Output)
|
|
526
|
+
The Autonomous Container Database OCID.
|
|
527
|
+
:param pulumi.Input[Sequence[pulumi.Input[str]]] available_upgrade_versions: (Output)
|
|
528
|
+
The list of available Oracle Database upgrade versions for an Autonomous
|
|
529
|
+
Database.
|
|
530
|
+
:param pulumi.Input[int] backup_retention_period_days: The retention period for the Autonomous Database. This field is specified
|
|
531
|
+
in days, can range from 1 day to 60 days, and has a default value of
|
|
532
|
+
60 days.
|
|
533
|
+
:param pulumi.Input[str] character_set: The character set for the Autonomous Database. The default is AL32UTF8.
|
|
534
|
+
:param pulumi.Input[float] compute_count: The number of compute servers for the Autonomous Database.
|
|
535
|
+
:param pulumi.Input[Sequence[pulumi.Input['AutonomousDatabasePropertiesConnectionStringArgs']]] connection_strings: (Output)
|
|
536
|
+
The connection string used to connect to the Autonomous Database.
|
|
537
|
+
https://docs.oracle.com/en-us/iaas/api/#/en/database/20160918/datatypes/AutonomousDatabaseConnectionStrings
|
|
538
|
+
Structure is documented below.
|
|
539
|
+
:param pulumi.Input[Sequence[pulumi.Input['AutonomousDatabasePropertiesConnectionUrlArgs']]] connection_urls: (Output)
|
|
540
|
+
The URLs for accessing Oracle Application Express (APEX) and SQL Developer
|
|
541
|
+
Web with a browser from a Compute instance.
|
|
542
|
+
https://docs.oracle.com/en-us/iaas/api/#/en/database/20160918/datatypes/AutonomousDatabaseConnectionUrls
|
|
543
|
+
Structure is documented below.
|
|
544
|
+
:param pulumi.Input[Sequence[pulumi.Input['AutonomousDatabasePropertiesCustomerContactArgs']]] customer_contacts: The list of customer contacts.
|
|
545
|
+
Structure is documented below.
|
|
546
|
+
:param pulumi.Input[str] data_safe_state: (Output)
|
|
547
|
+
The current state of the Data Safe registration for the
|
|
548
|
+
Autonomous Database.
|
|
549
|
+
Possible values:
|
|
550
|
+
DATA_SAFE_STATE_UNSPECIFIED
|
|
551
|
+
REGISTERING
|
|
552
|
+
REGISTERED
|
|
553
|
+
DEREGISTERING
|
|
554
|
+
NOT_REGISTERED
|
|
555
|
+
FAILED
|
|
556
|
+
:param pulumi.Input[int] data_storage_size_gb: The size of the data stored in the database, in gigabytes.
|
|
557
|
+
:param pulumi.Input[int] data_storage_size_tb: The size of the data stored in the database, in terabytes.
|
|
558
|
+
:param pulumi.Input[str] database_management_state: (Output)
|
|
559
|
+
The current state of database management for the Autonomous Database.
|
|
560
|
+
Possible values:
|
|
561
|
+
DATABASE_MANAGEMENT_STATE_UNSPECIFIED
|
|
562
|
+
ENABLING
|
|
563
|
+
ENABLED
|
|
564
|
+
DISABLING
|
|
565
|
+
NOT_ENABLED
|
|
566
|
+
FAILED_ENABLING
|
|
567
|
+
FAILED_DISABLING
|
|
568
|
+
:param pulumi.Input[str] db_edition: The edition of the Autonomous Databases.
|
|
569
|
+
Possible values:
|
|
570
|
+
DATABASE_EDITION_UNSPECIFIED
|
|
571
|
+
STANDARD_EDITION
|
|
572
|
+
ENTERPRISE_EDITION
|
|
573
|
+
:param pulumi.Input[str] db_version: The Oracle Database version for the Autonomous Database.
|
|
574
|
+
:param pulumi.Input[str] failed_data_recovery_duration: (Output)
|
|
575
|
+
This field indicates the number of seconds of data loss during a Data
|
|
576
|
+
Guard failover.
|
|
577
|
+
:param pulumi.Input[bool] is_auto_scaling_enabled: This field indicates if auto scaling is enabled for the Autonomous Database
|
|
578
|
+
CPU core count.
|
|
579
|
+
:param pulumi.Input[bool] is_local_data_guard_enabled: (Output)
|
|
580
|
+
This field indicates whether the Autonomous Database has local (in-region)
|
|
581
|
+
Data Guard enabled.
|
|
582
|
+
:param pulumi.Input[bool] is_storage_auto_scaling_enabled: This field indicates if auto scaling is enabled for the Autonomous Database
|
|
583
|
+
storage.
|
|
584
|
+
:param pulumi.Input[str] lifecycle_details: (Output)
|
|
585
|
+
The details of the current lifestyle state of the Autonomous Database.
|
|
586
|
+
:param pulumi.Input[int] local_adg_auto_failover_max_data_loss_limit: (Output)
|
|
587
|
+
This field indicates the maximum data loss limit for an Autonomous
|
|
588
|
+
Database, in seconds.
|
|
589
|
+
:param pulumi.Input[str] local_disaster_recovery_type: (Output)
|
|
590
|
+
This field indicates the local disaster recovery (DR) type of an
|
|
591
|
+
Autonomous Database.
|
|
592
|
+
Possible values:
|
|
593
|
+
LOCAL_DISASTER_RECOVERY_TYPE_UNSPECIFIED
|
|
594
|
+
ADG
|
|
595
|
+
BACKUP_BASED
|
|
596
|
+
:param pulumi.Input[Sequence[pulumi.Input['AutonomousDatabasePropertiesLocalStandbyDbArgs']]] local_standby_dbs: (Output)
|
|
597
|
+
Autonomous Data Guard standby database details.
|
|
598
|
+
https://docs.oracle.com/en-us/iaas/api/#/en/database/20160918/datatypes/AutonomousDatabaseStandbySummary
|
|
599
|
+
Structure is documented below.
|
|
600
|
+
:param pulumi.Input[str] maintenance_begin_time: (Output)
|
|
601
|
+
The date and time when maintenance will begin.
|
|
602
|
+
:param pulumi.Input[str] maintenance_end_time: (Output)
|
|
603
|
+
The date and time when maintenance will end.
|
|
604
|
+
:param pulumi.Input[str] maintenance_schedule_type: The maintenance schedule of the Autonomous Database.
|
|
605
|
+
Possible values:
|
|
606
|
+
MAINTENANCE_SCHEDULE_TYPE_UNSPECIFIED
|
|
607
|
+
EARLY
|
|
608
|
+
REGULAR
|
|
609
|
+
:param pulumi.Input[int] memory_per_oracle_compute_unit_gbs: (Output)
|
|
610
|
+
The amount of memory enabled per ECPU, in gigabytes.
|
|
611
|
+
:param pulumi.Input[int] memory_table_gbs: (Output)
|
|
612
|
+
The memory assigned to in-memory tables in an Autonomous Database.
|
|
613
|
+
:param pulumi.Input[bool] mtls_connection_required: This field specifies if the Autonomous Database requires mTLS connections.
|
|
614
|
+
:param pulumi.Input[str] n_character_set: The national character set for the Autonomous Database. The default is
|
|
615
|
+
AL16UTF16.
|
|
616
|
+
:param pulumi.Input[str] next_long_term_backup_time: (Output)
|
|
617
|
+
The long term backup schedule of the Autonomous Database.
|
|
618
|
+
:param pulumi.Input[str] oci_url: (Output)
|
|
619
|
+
The Oracle Cloud Infrastructure link for the Autonomous Database.
|
|
620
|
+
:param pulumi.Input[str] ocid: (Output)
|
|
621
|
+
OCID of the Autonomous Database.
|
|
622
|
+
https://docs.oracle.com/en-us/iaas/Content/General/Concepts/identifiers.htm#Oracle
|
|
623
|
+
:param pulumi.Input[str] open_mode: (Output)
|
|
624
|
+
This field indicates the current mode of the Autonomous Database.
|
|
625
|
+
Possible values:
|
|
626
|
+
OPEN_MODE_UNSPECIFIED
|
|
627
|
+
READ_ONLY
|
|
628
|
+
READ_WRITE
|
|
629
|
+
:param pulumi.Input[str] operations_insights_state: Possible values:
|
|
630
|
+
OPERATIONS_INSIGHTS_STATE_UNSPECIFIED
|
|
631
|
+
ENABLING
|
|
632
|
+
ENABLED
|
|
633
|
+
DISABLING
|
|
634
|
+
NOT_ENABLED
|
|
635
|
+
FAILED_ENABLING
|
|
636
|
+
FAILED_DISABLING
|
|
637
|
+
:param pulumi.Input[Sequence[pulumi.Input[str]]] peer_db_ids: (Output)
|
|
638
|
+
The list of OCIDs of standby databases located in Autonomous Data Guard
|
|
639
|
+
remote regions that are associated with the source database.
|
|
640
|
+
:param pulumi.Input[str] permission_level: (Output)
|
|
641
|
+
The permission level of the Autonomous Database.
|
|
642
|
+
Possible values:
|
|
643
|
+
PERMISSION_LEVEL_UNSPECIFIED
|
|
644
|
+
RESTRICTED
|
|
645
|
+
UNRESTRICTED
|
|
646
|
+
:param pulumi.Input[str] private_endpoint: (Output)
|
|
647
|
+
The private endpoint for the Autonomous Database.
|
|
648
|
+
:param pulumi.Input[str] private_endpoint_ip: The private endpoint IP address for the Autonomous Database.
|
|
649
|
+
:param pulumi.Input[str] private_endpoint_label: The private endpoint label for the Autonomous Database.
|
|
650
|
+
:param pulumi.Input[str] refreshable_mode: (Output)
|
|
651
|
+
The refresh mode of the cloned Autonomous Database.
|
|
652
|
+
Possible values:
|
|
653
|
+
REFRESHABLE_MODE_UNSPECIFIED
|
|
654
|
+
AUTOMATIC
|
|
655
|
+
MANUAL
|
|
656
|
+
:param pulumi.Input[str] refreshable_state: (Output)
|
|
657
|
+
The refresh State of the clone.
|
|
658
|
+
Possible values:
|
|
659
|
+
REFRESHABLE_STATE_UNSPECIFIED
|
|
660
|
+
REFRESHING
|
|
661
|
+
NOT_REFRESHING
|
|
662
|
+
:param pulumi.Input[str] role: (Output)
|
|
663
|
+
The Data Guard role of the Autonomous Database.
|
|
664
|
+
Possible values:
|
|
665
|
+
ROLE_UNSPECIFIED
|
|
666
|
+
PRIMARY
|
|
667
|
+
STANDBY
|
|
668
|
+
DISABLED_STANDBY
|
|
669
|
+
BACKUP_COPY
|
|
670
|
+
SNAPSHOT_STANDBY
|
|
671
|
+
:param pulumi.Input[Sequence[pulumi.Input['AutonomousDatabasePropertiesScheduledOperationDetailArgs']]] scheduled_operation_details: (Output)
|
|
672
|
+
The list and details of the scheduled operations of the Autonomous
|
|
673
|
+
Database.
|
|
674
|
+
Structure is documented below.
|
|
675
|
+
:param pulumi.Input[str] sql_web_developer_url: (Output)
|
|
676
|
+
The SQL Web Developer URL for the Autonomous Database.
|
|
677
|
+
:param pulumi.Input[str] state: (Output)
|
|
678
|
+
Possible values:
|
|
679
|
+
STATE_UNSPECIFIED
|
|
680
|
+
PROVISIONING
|
|
681
|
+
AVAILABLE
|
|
682
|
+
STOPPING
|
|
683
|
+
STOPPED
|
|
684
|
+
STARTING
|
|
685
|
+
TERMINATING
|
|
686
|
+
TERMINATED
|
|
687
|
+
UNAVAILABLE
|
|
688
|
+
RESTORE_IN_PROGRESS
|
|
689
|
+
RESTORE_FAILED
|
|
690
|
+
BACKUP_IN_PROGRESS
|
|
691
|
+
SCALE_IN_PROGRESS
|
|
692
|
+
AVAILABLE_NEEDS_ATTENTION
|
|
693
|
+
UPDATING
|
|
694
|
+
MAINTENANCE_IN_PROGRESS
|
|
695
|
+
RESTARTING
|
|
696
|
+
RECREATING
|
|
697
|
+
ROLE_CHANGE_IN_PROGRESS
|
|
698
|
+
UPGRADING
|
|
699
|
+
INACCESSIBLE
|
|
700
|
+
STANDBY
|
|
701
|
+
:param pulumi.Input[Sequence[pulumi.Input[str]]] supported_clone_regions: (Output)
|
|
702
|
+
The list of available regions that can be used to create a clone for the
|
|
703
|
+
Autonomous Database.
|
|
704
|
+
:param pulumi.Input[float] total_auto_backup_storage_size_gbs: (Output)
|
|
705
|
+
The storage space used by automatic backups of Autonomous Database, in
|
|
706
|
+
gigabytes.
|
|
707
|
+
:param pulumi.Input[int] used_data_storage_size_tbs: (Output)
|
|
708
|
+
The storage space used by Autonomous Database, in gigabytes.
|
|
709
|
+
"""
|
|
710
|
+
pulumi.set(__self__, "db_workload", db_workload)
|
|
711
|
+
pulumi.set(__self__, "license_type", license_type)
|
|
712
|
+
if actual_used_data_storage_size_tb is not None:
|
|
713
|
+
pulumi.set(__self__, "actual_used_data_storage_size_tb", actual_used_data_storage_size_tb)
|
|
714
|
+
if allocated_storage_size_tb is not None:
|
|
715
|
+
pulumi.set(__self__, "allocated_storage_size_tb", allocated_storage_size_tb)
|
|
716
|
+
if apex_details is not None:
|
|
717
|
+
pulumi.set(__self__, "apex_details", apex_details)
|
|
718
|
+
if are_primary_allowlisted_ips_used is not None:
|
|
719
|
+
pulumi.set(__self__, "are_primary_allowlisted_ips_used", are_primary_allowlisted_ips_used)
|
|
720
|
+
if autonomous_container_database_id is not None:
|
|
721
|
+
pulumi.set(__self__, "autonomous_container_database_id", autonomous_container_database_id)
|
|
722
|
+
if available_upgrade_versions is not None:
|
|
723
|
+
pulumi.set(__self__, "available_upgrade_versions", available_upgrade_versions)
|
|
724
|
+
if backup_retention_period_days is not None:
|
|
725
|
+
pulumi.set(__self__, "backup_retention_period_days", backup_retention_period_days)
|
|
726
|
+
if character_set is not None:
|
|
727
|
+
pulumi.set(__self__, "character_set", character_set)
|
|
728
|
+
if compute_count is not None:
|
|
729
|
+
pulumi.set(__self__, "compute_count", compute_count)
|
|
730
|
+
if connection_strings is not None:
|
|
731
|
+
pulumi.set(__self__, "connection_strings", connection_strings)
|
|
732
|
+
if connection_urls is not None:
|
|
733
|
+
pulumi.set(__self__, "connection_urls", connection_urls)
|
|
734
|
+
if customer_contacts is not None:
|
|
735
|
+
pulumi.set(__self__, "customer_contacts", customer_contacts)
|
|
736
|
+
if data_safe_state is not None:
|
|
737
|
+
pulumi.set(__self__, "data_safe_state", data_safe_state)
|
|
738
|
+
if data_storage_size_gb is not None:
|
|
739
|
+
pulumi.set(__self__, "data_storage_size_gb", data_storage_size_gb)
|
|
740
|
+
if data_storage_size_tb is not None:
|
|
741
|
+
pulumi.set(__self__, "data_storage_size_tb", data_storage_size_tb)
|
|
742
|
+
if database_management_state is not None:
|
|
743
|
+
pulumi.set(__self__, "database_management_state", database_management_state)
|
|
744
|
+
if db_edition is not None:
|
|
745
|
+
pulumi.set(__self__, "db_edition", db_edition)
|
|
746
|
+
if db_version is not None:
|
|
747
|
+
pulumi.set(__self__, "db_version", db_version)
|
|
748
|
+
if failed_data_recovery_duration is not None:
|
|
749
|
+
pulumi.set(__self__, "failed_data_recovery_duration", failed_data_recovery_duration)
|
|
750
|
+
if is_auto_scaling_enabled is not None:
|
|
751
|
+
pulumi.set(__self__, "is_auto_scaling_enabled", is_auto_scaling_enabled)
|
|
752
|
+
if is_local_data_guard_enabled is not None:
|
|
753
|
+
pulumi.set(__self__, "is_local_data_guard_enabled", is_local_data_guard_enabled)
|
|
754
|
+
if is_storage_auto_scaling_enabled is not None:
|
|
755
|
+
pulumi.set(__self__, "is_storage_auto_scaling_enabled", is_storage_auto_scaling_enabled)
|
|
756
|
+
if lifecycle_details is not None:
|
|
757
|
+
pulumi.set(__self__, "lifecycle_details", lifecycle_details)
|
|
758
|
+
if local_adg_auto_failover_max_data_loss_limit is not None:
|
|
759
|
+
pulumi.set(__self__, "local_adg_auto_failover_max_data_loss_limit", local_adg_auto_failover_max_data_loss_limit)
|
|
760
|
+
if local_disaster_recovery_type is not None:
|
|
761
|
+
pulumi.set(__self__, "local_disaster_recovery_type", local_disaster_recovery_type)
|
|
762
|
+
if local_standby_dbs is not None:
|
|
763
|
+
pulumi.set(__self__, "local_standby_dbs", local_standby_dbs)
|
|
764
|
+
if maintenance_begin_time is not None:
|
|
765
|
+
pulumi.set(__self__, "maintenance_begin_time", maintenance_begin_time)
|
|
766
|
+
if maintenance_end_time is not None:
|
|
767
|
+
pulumi.set(__self__, "maintenance_end_time", maintenance_end_time)
|
|
768
|
+
if maintenance_schedule_type is not None:
|
|
769
|
+
pulumi.set(__self__, "maintenance_schedule_type", maintenance_schedule_type)
|
|
770
|
+
if memory_per_oracle_compute_unit_gbs is not None:
|
|
771
|
+
pulumi.set(__self__, "memory_per_oracle_compute_unit_gbs", memory_per_oracle_compute_unit_gbs)
|
|
772
|
+
if memory_table_gbs is not None:
|
|
773
|
+
pulumi.set(__self__, "memory_table_gbs", memory_table_gbs)
|
|
774
|
+
if mtls_connection_required is not None:
|
|
775
|
+
pulumi.set(__self__, "mtls_connection_required", mtls_connection_required)
|
|
776
|
+
if n_character_set is not None:
|
|
777
|
+
pulumi.set(__self__, "n_character_set", n_character_set)
|
|
778
|
+
if next_long_term_backup_time is not None:
|
|
779
|
+
pulumi.set(__self__, "next_long_term_backup_time", next_long_term_backup_time)
|
|
780
|
+
if oci_url is not None:
|
|
781
|
+
pulumi.set(__self__, "oci_url", oci_url)
|
|
782
|
+
if ocid is not None:
|
|
783
|
+
pulumi.set(__self__, "ocid", ocid)
|
|
784
|
+
if open_mode is not None:
|
|
785
|
+
pulumi.set(__self__, "open_mode", open_mode)
|
|
786
|
+
if operations_insights_state is not None:
|
|
787
|
+
pulumi.set(__self__, "operations_insights_state", operations_insights_state)
|
|
788
|
+
if peer_db_ids is not None:
|
|
789
|
+
pulumi.set(__self__, "peer_db_ids", peer_db_ids)
|
|
790
|
+
if permission_level is not None:
|
|
791
|
+
pulumi.set(__self__, "permission_level", permission_level)
|
|
792
|
+
if private_endpoint is not None:
|
|
793
|
+
pulumi.set(__self__, "private_endpoint", private_endpoint)
|
|
794
|
+
if private_endpoint_ip is not None:
|
|
795
|
+
pulumi.set(__self__, "private_endpoint_ip", private_endpoint_ip)
|
|
796
|
+
if private_endpoint_label is not None:
|
|
797
|
+
pulumi.set(__self__, "private_endpoint_label", private_endpoint_label)
|
|
798
|
+
if refreshable_mode is not None:
|
|
799
|
+
pulumi.set(__self__, "refreshable_mode", refreshable_mode)
|
|
800
|
+
if refreshable_state is not None:
|
|
801
|
+
pulumi.set(__self__, "refreshable_state", refreshable_state)
|
|
802
|
+
if role is not None:
|
|
803
|
+
pulumi.set(__self__, "role", role)
|
|
804
|
+
if scheduled_operation_details is not None:
|
|
805
|
+
pulumi.set(__self__, "scheduled_operation_details", scheduled_operation_details)
|
|
806
|
+
if sql_web_developer_url is not None:
|
|
807
|
+
pulumi.set(__self__, "sql_web_developer_url", sql_web_developer_url)
|
|
808
|
+
if state is not None:
|
|
809
|
+
pulumi.set(__self__, "state", state)
|
|
810
|
+
if supported_clone_regions is not None:
|
|
811
|
+
pulumi.set(__self__, "supported_clone_regions", supported_clone_regions)
|
|
812
|
+
if total_auto_backup_storage_size_gbs is not None:
|
|
813
|
+
pulumi.set(__self__, "total_auto_backup_storage_size_gbs", total_auto_backup_storage_size_gbs)
|
|
814
|
+
if used_data_storage_size_tbs is not None:
|
|
815
|
+
pulumi.set(__self__, "used_data_storage_size_tbs", used_data_storage_size_tbs)
|
|
816
|
+
|
|
817
|
+
@property
|
|
818
|
+
@pulumi.getter(name="dbWorkload")
|
|
819
|
+
def db_workload(self) -> pulumi.Input[str]:
|
|
820
|
+
"""
|
|
821
|
+
Possible values:
|
|
822
|
+
DB_WORKLOAD_UNSPECIFIED
|
|
823
|
+
OLTP
|
|
824
|
+
DW
|
|
825
|
+
AJD
|
|
826
|
+
APEX
|
|
827
|
+
"""
|
|
828
|
+
return pulumi.get(self, "db_workload")
|
|
829
|
+
|
|
830
|
+
@db_workload.setter
|
|
831
|
+
def db_workload(self, value: pulumi.Input[str]):
|
|
832
|
+
pulumi.set(self, "db_workload", value)
|
|
833
|
+
|
|
834
|
+
@property
|
|
835
|
+
@pulumi.getter(name="licenseType")
|
|
836
|
+
def license_type(self) -> pulumi.Input[str]:
|
|
837
|
+
"""
|
|
838
|
+
The license type used for the Autonomous Database.
|
|
839
|
+
Possible values:
|
|
840
|
+
LICENSE_TYPE_UNSPECIFIED
|
|
841
|
+
LICENSE_INCLUDED
|
|
842
|
+
BRING_YOUR_OWN_LICENSE
|
|
843
|
+
"""
|
|
844
|
+
return pulumi.get(self, "license_type")
|
|
845
|
+
|
|
846
|
+
@license_type.setter
|
|
847
|
+
def license_type(self, value: pulumi.Input[str]):
|
|
848
|
+
pulumi.set(self, "license_type", value)
|
|
849
|
+
|
|
850
|
+
@property
|
|
851
|
+
@pulumi.getter(name="actualUsedDataStorageSizeTb")
|
|
852
|
+
def actual_used_data_storage_size_tb(self) -> Optional[pulumi.Input[float]]:
|
|
853
|
+
"""
|
|
854
|
+
(Output)
|
|
855
|
+
The amount of storage currently being used for user and system data, in
|
|
856
|
+
terabytes.
|
|
857
|
+
"""
|
|
858
|
+
return pulumi.get(self, "actual_used_data_storage_size_tb")
|
|
859
|
+
|
|
860
|
+
@actual_used_data_storage_size_tb.setter
|
|
861
|
+
def actual_used_data_storage_size_tb(self, value: Optional[pulumi.Input[float]]):
|
|
862
|
+
pulumi.set(self, "actual_used_data_storage_size_tb", value)
|
|
863
|
+
|
|
864
|
+
@property
|
|
865
|
+
@pulumi.getter(name="allocatedStorageSizeTb")
|
|
866
|
+
def allocated_storage_size_tb(self) -> Optional[pulumi.Input[float]]:
|
|
867
|
+
"""
|
|
868
|
+
(Output)
|
|
869
|
+
The amount of storage currently allocated for the database tables and
|
|
870
|
+
billed for, rounded up in terabytes.
|
|
871
|
+
"""
|
|
872
|
+
return pulumi.get(self, "allocated_storage_size_tb")
|
|
873
|
+
|
|
874
|
+
@allocated_storage_size_tb.setter
|
|
875
|
+
def allocated_storage_size_tb(self, value: Optional[pulumi.Input[float]]):
|
|
876
|
+
pulumi.set(self, "allocated_storage_size_tb", value)
|
|
877
|
+
|
|
878
|
+
@property
|
|
879
|
+
@pulumi.getter(name="apexDetails")
|
|
880
|
+
def apex_details(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['AutonomousDatabasePropertiesApexDetailArgs']]]]:
|
|
881
|
+
"""
|
|
882
|
+
(Output)
|
|
883
|
+
Oracle APEX Application Development.
|
|
884
|
+
https://docs.oracle.com/en-us/iaas/api/#/en/database/20160918/datatypes/AutonomousDatabaseApex
|
|
885
|
+
Structure is documented below.
|
|
886
|
+
"""
|
|
887
|
+
return pulumi.get(self, "apex_details")
|
|
888
|
+
|
|
889
|
+
@apex_details.setter
|
|
890
|
+
def apex_details(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['AutonomousDatabasePropertiesApexDetailArgs']]]]):
|
|
891
|
+
pulumi.set(self, "apex_details", value)
|
|
892
|
+
|
|
893
|
+
@property
|
|
894
|
+
@pulumi.getter(name="arePrimaryAllowlistedIpsUsed")
|
|
895
|
+
def are_primary_allowlisted_ips_used(self) -> Optional[pulumi.Input[bool]]:
|
|
896
|
+
"""
|
|
897
|
+
(Output)
|
|
898
|
+
This field indicates the status of Data Guard and Access control for the
|
|
899
|
+
Autonomous Database. The field's value is null if Data Guard is disabled
|
|
900
|
+
or Access Control is disabled. The field's value is TRUE if both Data Guard
|
|
901
|
+
and Access Control are enabled, and the Autonomous Database is using
|
|
902
|
+
primary IP access control list (ACL) for standby. The field's value is
|
|
903
|
+
FALSE if both Data Guard and Access Control are enabled, and the Autonomous
|
|
904
|
+
Database is using a different IP access control list (ACL) for standby
|
|
905
|
+
compared to primary.
|
|
906
|
+
"""
|
|
907
|
+
return pulumi.get(self, "are_primary_allowlisted_ips_used")
|
|
908
|
+
|
|
909
|
+
@are_primary_allowlisted_ips_used.setter
|
|
910
|
+
def are_primary_allowlisted_ips_used(self, value: Optional[pulumi.Input[bool]]):
|
|
911
|
+
pulumi.set(self, "are_primary_allowlisted_ips_used", value)
|
|
912
|
+
|
|
913
|
+
@property
|
|
914
|
+
@pulumi.getter(name="autonomousContainerDatabaseId")
|
|
915
|
+
def autonomous_container_database_id(self) -> Optional[pulumi.Input[str]]:
|
|
916
|
+
"""
|
|
917
|
+
(Output)
|
|
918
|
+
The Autonomous Container Database OCID.
|
|
919
|
+
"""
|
|
920
|
+
return pulumi.get(self, "autonomous_container_database_id")
|
|
921
|
+
|
|
922
|
+
@autonomous_container_database_id.setter
|
|
923
|
+
def autonomous_container_database_id(self, value: Optional[pulumi.Input[str]]):
|
|
924
|
+
pulumi.set(self, "autonomous_container_database_id", value)
|
|
925
|
+
|
|
926
|
+
@property
|
|
927
|
+
@pulumi.getter(name="availableUpgradeVersions")
|
|
928
|
+
def available_upgrade_versions(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
929
|
+
"""
|
|
930
|
+
(Output)
|
|
931
|
+
The list of available Oracle Database upgrade versions for an Autonomous
|
|
932
|
+
Database.
|
|
933
|
+
"""
|
|
934
|
+
return pulumi.get(self, "available_upgrade_versions")
|
|
935
|
+
|
|
936
|
+
@available_upgrade_versions.setter
|
|
937
|
+
def available_upgrade_versions(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
938
|
+
pulumi.set(self, "available_upgrade_versions", value)
|
|
939
|
+
|
|
940
|
+
@property
|
|
941
|
+
@pulumi.getter(name="backupRetentionPeriodDays")
|
|
942
|
+
def backup_retention_period_days(self) -> Optional[pulumi.Input[int]]:
|
|
943
|
+
"""
|
|
944
|
+
The retention period for the Autonomous Database. This field is specified
|
|
945
|
+
in days, can range from 1 day to 60 days, and has a default value of
|
|
946
|
+
60 days.
|
|
947
|
+
"""
|
|
948
|
+
return pulumi.get(self, "backup_retention_period_days")
|
|
949
|
+
|
|
950
|
+
@backup_retention_period_days.setter
|
|
951
|
+
def backup_retention_period_days(self, value: Optional[pulumi.Input[int]]):
|
|
952
|
+
pulumi.set(self, "backup_retention_period_days", value)
|
|
953
|
+
|
|
954
|
+
@property
|
|
955
|
+
@pulumi.getter(name="characterSet")
|
|
956
|
+
def character_set(self) -> Optional[pulumi.Input[str]]:
|
|
957
|
+
"""
|
|
958
|
+
The character set for the Autonomous Database. The default is AL32UTF8.
|
|
959
|
+
"""
|
|
960
|
+
return pulumi.get(self, "character_set")
|
|
961
|
+
|
|
962
|
+
@character_set.setter
|
|
963
|
+
def character_set(self, value: Optional[pulumi.Input[str]]):
|
|
964
|
+
pulumi.set(self, "character_set", value)
|
|
965
|
+
|
|
966
|
+
@property
|
|
967
|
+
@pulumi.getter(name="computeCount")
|
|
968
|
+
def compute_count(self) -> Optional[pulumi.Input[float]]:
|
|
969
|
+
"""
|
|
970
|
+
The number of compute servers for the Autonomous Database.
|
|
971
|
+
"""
|
|
972
|
+
return pulumi.get(self, "compute_count")
|
|
973
|
+
|
|
974
|
+
@compute_count.setter
|
|
975
|
+
def compute_count(self, value: Optional[pulumi.Input[float]]):
|
|
976
|
+
pulumi.set(self, "compute_count", value)
|
|
977
|
+
|
|
978
|
+
@property
|
|
979
|
+
@pulumi.getter(name="connectionStrings")
|
|
980
|
+
def connection_strings(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['AutonomousDatabasePropertiesConnectionStringArgs']]]]:
|
|
981
|
+
"""
|
|
982
|
+
(Output)
|
|
983
|
+
The connection string used to connect to the Autonomous Database.
|
|
984
|
+
https://docs.oracle.com/en-us/iaas/api/#/en/database/20160918/datatypes/AutonomousDatabaseConnectionStrings
|
|
985
|
+
Structure is documented below.
|
|
986
|
+
"""
|
|
987
|
+
return pulumi.get(self, "connection_strings")
|
|
988
|
+
|
|
989
|
+
@connection_strings.setter
|
|
990
|
+
def connection_strings(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['AutonomousDatabasePropertiesConnectionStringArgs']]]]):
|
|
991
|
+
pulumi.set(self, "connection_strings", value)
|
|
992
|
+
|
|
993
|
+
@property
|
|
994
|
+
@pulumi.getter(name="connectionUrls")
|
|
995
|
+
def connection_urls(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['AutonomousDatabasePropertiesConnectionUrlArgs']]]]:
|
|
996
|
+
"""
|
|
997
|
+
(Output)
|
|
998
|
+
The URLs for accessing Oracle Application Express (APEX) and SQL Developer
|
|
999
|
+
Web with a browser from a Compute instance.
|
|
1000
|
+
https://docs.oracle.com/en-us/iaas/api/#/en/database/20160918/datatypes/AutonomousDatabaseConnectionUrls
|
|
1001
|
+
Structure is documented below.
|
|
1002
|
+
"""
|
|
1003
|
+
return pulumi.get(self, "connection_urls")
|
|
1004
|
+
|
|
1005
|
+
@connection_urls.setter
|
|
1006
|
+
def connection_urls(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['AutonomousDatabasePropertiesConnectionUrlArgs']]]]):
|
|
1007
|
+
pulumi.set(self, "connection_urls", value)
|
|
1008
|
+
|
|
1009
|
+
@property
|
|
1010
|
+
@pulumi.getter(name="customerContacts")
|
|
1011
|
+
def customer_contacts(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['AutonomousDatabasePropertiesCustomerContactArgs']]]]:
|
|
1012
|
+
"""
|
|
1013
|
+
The list of customer contacts.
|
|
1014
|
+
Structure is documented below.
|
|
1015
|
+
"""
|
|
1016
|
+
return pulumi.get(self, "customer_contacts")
|
|
1017
|
+
|
|
1018
|
+
@customer_contacts.setter
|
|
1019
|
+
def customer_contacts(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['AutonomousDatabasePropertiesCustomerContactArgs']]]]):
|
|
1020
|
+
pulumi.set(self, "customer_contacts", value)
|
|
1021
|
+
|
|
1022
|
+
@property
|
|
1023
|
+
@pulumi.getter(name="dataSafeState")
|
|
1024
|
+
def data_safe_state(self) -> Optional[pulumi.Input[str]]:
|
|
1025
|
+
"""
|
|
1026
|
+
(Output)
|
|
1027
|
+
The current state of the Data Safe registration for the
|
|
1028
|
+
Autonomous Database.
|
|
1029
|
+
Possible values:
|
|
1030
|
+
DATA_SAFE_STATE_UNSPECIFIED
|
|
1031
|
+
REGISTERING
|
|
1032
|
+
REGISTERED
|
|
1033
|
+
DEREGISTERING
|
|
1034
|
+
NOT_REGISTERED
|
|
1035
|
+
FAILED
|
|
1036
|
+
"""
|
|
1037
|
+
return pulumi.get(self, "data_safe_state")
|
|
1038
|
+
|
|
1039
|
+
@data_safe_state.setter
|
|
1040
|
+
def data_safe_state(self, value: Optional[pulumi.Input[str]]):
|
|
1041
|
+
pulumi.set(self, "data_safe_state", value)
|
|
1042
|
+
|
|
1043
|
+
@property
|
|
1044
|
+
@pulumi.getter(name="dataStorageSizeGb")
|
|
1045
|
+
def data_storage_size_gb(self) -> Optional[pulumi.Input[int]]:
|
|
1046
|
+
"""
|
|
1047
|
+
The size of the data stored in the database, in gigabytes.
|
|
1048
|
+
"""
|
|
1049
|
+
return pulumi.get(self, "data_storage_size_gb")
|
|
1050
|
+
|
|
1051
|
+
@data_storage_size_gb.setter
|
|
1052
|
+
def data_storage_size_gb(self, value: Optional[pulumi.Input[int]]):
|
|
1053
|
+
pulumi.set(self, "data_storage_size_gb", value)
|
|
1054
|
+
|
|
1055
|
+
@property
|
|
1056
|
+
@pulumi.getter(name="dataStorageSizeTb")
|
|
1057
|
+
def data_storage_size_tb(self) -> Optional[pulumi.Input[int]]:
|
|
1058
|
+
"""
|
|
1059
|
+
The size of the data stored in the database, in terabytes.
|
|
1060
|
+
"""
|
|
1061
|
+
return pulumi.get(self, "data_storage_size_tb")
|
|
1062
|
+
|
|
1063
|
+
@data_storage_size_tb.setter
|
|
1064
|
+
def data_storage_size_tb(self, value: Optional[pulumi.Input[int]]):
|
|
1065
|
+
pulumi.set(self, "data_storage_size_tb", value)
|
|
1066
|
+
|
|
1067
|
+
@property
|
|
1068
|
+
@pulumi.getter(name="databaseManagementState")
|
|
1069
|
+
def database_management_state(self) -> Optional[pulumi.Input[str]]:
|
|
1070
|
+
"""
|
|
1071
|
+
(Output)
|
|
1072
|
+
The current state of database management for the Autonomous Database.
|
|
1073
|
+
Possible values:
|
|
1074
|
+
DATABASE_MANAGEMENT_STATE_UNSPECIFIED
|
|
1075
|
+
ENABLING
|
|
1076
|
+
ENABLED
|
|
1077
|
+
DISABLING
|
|
1078
|
+
NOT_ENABLED
|
|
1079
|
+
FAILED_ENABLING
|
|
1080
|
+
FAILED_DISABLING
|
|
1081
|
+
"""
|
|
1082
|
+
return pulumi.get(self, "database_management_state")
|
|
1083
|
+
|
|
1084
|
+
@database_management_state.setter
|
|
1085
|
+
def database_management_state(self, value: Optional[pulumi.Input[str]]):
|
|
1086
|
+
pulumi.set(self, "database_management_state", value)
|
|
1087
|
+
|
|
1088
|
+
@property
|
|
1089
|
+
@pulumi.getter(name="dbEdition")
|
|
1090
|
+
def db_edition(self) -> Optional[pulumi.Input[str]]:
|
|
1091
|
+
"""
|
|
1092
|
+
The edition of the Autonomous Databases.
|
|
1093
|
+
Possible values:
|
|
1094
|
+
DATABASE_EDITION_UNSPECIFIED
|
|
1095
|
+
STANDARD_EDITION
|
|
1096
|
+
ENTERPRISE_EDITION
|
|
1097
|
+
"""
|
|
1098
|
+
return pulumi.get(self, "db_edition")
|
|
1099
|
+
|
|
1100
|
+
@db_edition.setter
|
|
1101
|
+
def db_edition(self, value: Optional[pulumi.Input[str]]):
|
|
1102
|
+
pulumi.set(self, "db_edition", value)
|
|
1103
|
+
|
|
1104
|
+
@property
|
|
1105
|
+
@pulumi.getter(name="dbVersion")
|
|
1106
|
+
def db_version(self) -> Optional[pulumi.Input[str]]:
|
|
1107
|
+
"""
|
|
1108
|
+
The Oracle Database version for the Autonomous Database.
|
|
1109
|
+
"""
|
|
1110
|
+
return pulumi.get(self, "db_version")
|
|
1111
|
+
|
|
1112
|
+
@db_version.setter
|
|
1113
|
+
def db_version(self, value: Optional[pulumi.Input[str]]):
|
|
1114
|
+
pulumi.set(self, "db_version", value)
|
|
1115
|
+
|
|
1116
|
+
@property
|
|
1117
|
+
@pulumi.getter(name="failedDataRecoveryDuration")
|
|
1118
|
+
def failed_data_recovery_duration(self) -> Optional[pulumi.Input[str]]:
|
|
1119
|
+
"""
|
|
1120
|
+
(Output)
|
|
1121
|
+
This field indicates the number of seconds of data loss during a Data
|
|
1122
|
+
Guard failover.
|
|
1123
|
+
"""
|
|
1124
|
+
return pulumi.get(self, "failed_data_recovery_duration")
|
|
1125
|
+
|
|
1126
|
+
@failed_data_recovery_duration.setter
|
|
1127
|
+
def failed_data_recovery_duration(self, value: Optional[pulumi.Input[str]]):
|
|
1128
|
+
pulumi.set(self, "failed_data_recovery_duration", value)
|
|
1129
|
+
|
|
1130
|
+
@property
|
|
1131
|
+
@pulumi.getter(name="isAutoScalingEnabled")
|
|
1132
|
+
def is_auto_scaling_enabled(self) -> Optional[pulumi.Input[bool]]:
|
|
1133
|
+
"""
|
|
1134
|
+
This field indicates if auto scaling is enabled for the Autonomous Database
|
|
1135
|
+
CPU core count.
|
|
1136
|
+
"""
|
|
1137
|
+
return pulumi.get(self, "is_auto_scaling_enabled")
|
|
1138
|
+
|
|
1139
|
+
@is_auto_scaling_enabled.setter
|
|
1140
|
+
def is_auto_scaling_enabled(self, value: Optional[pulumi.Input[bool]]):
|
|
1141
|
+
pulumi.set(self, "is_auto_scaling_enabled", value)
|
|
1142
|
+
|
|
1143
|
+
@property
|
|
1144
|
+
@pulumi.getter(name="isLocalDataGuardEnabled")
|
|
1145
|
+
def is_local_data_guard_enabled(self) -> Optional[pulumi.Input[bool]]:
|
|
1146
|
+
"""
|
|
1147
|
+
(Output)
|
|
1148
|
+
This field indicates whether the Autonomous Database has local (in-region)
|
|
1149
|
+
Data Guard enabled.
|
|
1150
|
+
"""
|
|
1151
|
+
return pulumi.get(self, "is_local_data_guard_enabled")
|
|
1152
|
+
|
|
1153
|
+
@is_local_data_guard_enabled.setter
|
|
1154
|
+
def is_local_data_guard_enabled(self, value: Optional[pulumi.Input[bool]]):
|
|
1155
|
+
pulumi.set(self, "is_local_data_guard_enabled", value)
|
|
1156
|
+
|
|
1157
|
+
@property
|
|
1158
|
+
@pulumi.getter(name="isStorageAutoScalingEnabled")
|
|
1159
|
+
def is_storage_auto_scaling_enabled(self) -> Optional[pulumi.Input[bool]]:
|
|
1160
|
+
"""
|
|
1161
|
+
This field indicates if auto scaling is enabled for the Autonomous Database
|
|
1162
|
+
storage.
|
|
1163
|
+
"""
|
|
1164
|
+
return pulumi.get(self, "is_storage_auto_scaling_enabled")
|
|
1165
|
+
|
|
1166
|
+
@is_storage_auto_scaling_enabled.setter
|
|
1167
|
+
def is_storage_auto_scaling_enabled(self, value: Optional[pulumi.Input[bool]]):
|
|
1168
|
+
pulumi.set(self, "is_storage_auto_scaling_enabled", value)
|
|
1169
|
+
|
|
1170
|
+
@property
|
|
1171
|
+
@pulumi.getter(name="lifecycleDetails")
|
|
1172
|
+
def lifecycle_details(self) -> Optional[pulumi.Input[str]]:
|
|
1173
|
+
"""
|
|
1174
|
+
(Output)
|
|
1175
|
+
The details of the current lifestyle state of the Autonomous Database.
|
|
1176
|
+
"""
|
|
1177
|
+
return pulumi.get(self, "lifecycle_details")
|
|
1178
|
+
|
|
1179
|
+
@lifecycle_details.setter
|
|
1180
|
+
def lifecycle_details(self, value: Optional[pulumi.Input[str]]):
|
|
1181
|
+
pulumi.set(self, "lifecycle_details", value)
|
|
1182
|
+
|
|
1183
|
+
@property
|
|
1184
|
+
@pulumi.getter(name="localAdgAutoFailoverMaxDataLossLimit")
|
|
1185
|
+
def local_adg_auto_failover_max_data_loss_limit(self) -> Optional[pulumi.Input[int]]:
|
|
1186
|
+
"""
|
|
1187
|
+
(Output)
|
|
1188
|
+
This field indicates the maximum data loss limit for an Autonomous
|
|
1189
|
+
Database, in seconds.
|
|
1190
|
+
"""
|
|
1191
|
+
return pulumi.get(self, "local_adg_auto_failover_max_data_loss_limit")
|
|
1192
|
+
|
|
1193
|
+
@local_adg_auto_failover_max_data_loss_limit.setter
|
|
1194
|
+
def local_adg_auto_failover_max_data_loss_limit(self, value: Optional[pulumi.Input[int]]):
|
|
1195
|
+
pulumi.set(self, "local_adg_auto_failover_max_data_loss_limit", value)
|
|
1196
|
+
|
|
1197
|
+
@property
|
|
1198
|
+
@pulumi.getter(name="localDisasterRecoveryType")
|
|
1199
|
+
def local_disaster_recovery_type(self) -> Optional[pulumi.Input[str]]:
|
|
1200
|
+
"""
|
|
1201
|
+
(Output)
|
|
1202
|
+
This field indicates the local disaster recovery (DR) type of an
|
|
1203
|
+
Autonomous Database.
|
|
1204
|
+
Possible values:
|
|
1205
|
+
LOCAL_DISASTER_RECOVERY_TYPE_UNSPECIFIED
|
|
1206
|
+
ADG
|
|
1207
|
+
BACKUP_BASED
|
|
1208
|
+
"""
|
|
1209
|
+
return pulumi.get(self, "local_disaster_recovery_type")
|
|
1210
|
+
|
|
1211
|
+
@local_disaster_recovery_type.setter
|
|
1212
|
+
def local_disaster_recovery_type(self, value: Optional[pulumi.Input[str]]):
|
|
1213
|
+
pulumi.set(self, "local_disaster_recovery_type", value)
|
|
1214
|
+
|
|
1215
|
+
@property
|
|
1216
|
+
@pulumi.getter(name="localStandbyDbs")
|
|
1217
|
+
def local_standby_dbs(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['AutonomousDatabasePropertiesLocalStandbyDbArgs']]]]:
|
|
1218
|
+
"""
|
|
1219
|
+
(Output)
|
|
1220
|
+
Autonomous Data Guard standby database details.
|
|
1221
|
+
https://docs.oracle.com/en-us/iaas/api/#/en/database/20160918/datatypes/AutonomousDatabaseStandbySummary
|
|
1222
|
+
Structure is documented below.
|
|
1223
|
+
"""
|
|
1224
|
+
return pulumi.get(self, "local_standby_dbs")
|
|
1225
|
+
|
|
1226
|
+
@local_standby_dbs.setter
|
|
1227
|
+
def local_standby_dbs(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['AutonomousDatabasePropertiesLocalStandbyDbArgs']]]]):
|
|
1228
|
+
pulumi.set(self, "local_standby_dbs", value)
|
|
1229
|
+
|
|
1230
|
+
@property
|
|
1231
|
+
@pulumi.getter(name="maintenanceBeginTime")
|
|
1232
|
+
def maintenance_begin_time(self) -> Optional[pulumi.Input[str]]:
|
|
1233
|
+
"""
|
|
1234
|
+
(Output)
|
|
1235
|
+
The date and time when maintenance will begin.
|
|
1236
|
+
"""
|
|
1237
|
+
return pulumi.get(self, "maintenance_begin_time")
|
|
1238
|
+
|
|
1239
|
+
@maintenance_begin_time.setter
|
|
1240
|
+
def maintenance_begin_time(self, value: Optional[pulumi.Input[str]]):
|
|
1241
|
+
pulumi.set(self, "maintenance_begin_time", value)
|
|
1242
|
+
|
|
1243
|
+
@property
|
|
1244
|
+
@pulumi.getter(name="maintenanceEndTime")
|
|
1245
|
+
def maintenance_end_time(self) -> Optional[pulumi.Input[str]]:
|
|
1246
|
+
"""
|
|
1247
|
+
(Output)
|
|
1248
|
+
The date and time when maintenance will end.
|
|
1249
|
+
"""
|
|
1250
|
+
return pulumi.get(self, "maintenance_end_time")
|
|
1251
|
+
|
|
1252
|
+
@maintenance_end_time.setter
|
|
1253
|
+
def maintenance_end_time(self, value: Optional[pulumi.Input[str]]):
|
|
1254
|
+
pulumi.set(self, "maintenance_end_time", value)
|
|
1255
|
+
|
|
1256
|
+
@property
|
|
1257
|
+
@pulumi.getter(name="maintenanceScheduleType")
|
|
1258
|
+
def maintenance_schedule_type(self) -> Optional[pulumi.Input[str]]:
|
|
1259
|
+
"""
|
|
1260
|
+
The maintenance schedule of the Autonomous Database.
|
|
1261
|
+
Possible values:
|
|
1262
|
+
MAINTENANCE_SCHEDULE_TYPE_UNSPECIFIED
|
|
1263
|
+
EARLY
|
|
1264
|
+
REGULAR
|
|
1265
|
+
"""
|
|
1266
|
+
return pulumi.get(self, "maintenance_schedule_type")
|
|
1267
|
+
|
|
1268
|
+
@maintenance_schedule_type.setter
|
|
1269
|
+
def maintenance_schedule_type(self, value: Optional[pulumi.Input[str]]):
|
|
1270
|
+
pulumi.set(self, "maintenance_schedule_type", value)
|
|
1271
|
+
|
|
1272
|
+
@property
|
|
1273
|
+
@pulumi.getter(name="memoryPerOracleComputeUnitGbs")
|
|
1274
|
+
def memory_per_oracle_compute_unit_gbs(self) -> Optional[pulumi.Input[int]]:
|
|
1275
|
+
"""
|
|
1276
|
+
(Output)
|
|
1277
|
+
The amount of memory enabled per ECPU, in gigabytes.
|
|
1278
|
+
"""
|
|
1279
|
+
return pulumi.get(self, "memory_per_oracle_compute_unit_gbs")
|
|
1280
|
+
|
|
1281
|
+
@memory_per_oracle_compute_unit_gbs.setter
|
|
1282
|
+
def memory_per_oracle_compute_unit_gbs(self, value: Optional[pulumi.Input[int]]):
|
|
1283
|
+
pulumi.set(self, "memory_per_oracle_compute_unit_gbs", value)
|
|
1284
|
+
|
|
1285
|
+
@property
|
|
1286
|
+
@pulumi.getter(name="memoryTableGbs")
|
|
1287
|
+
def memory_table_gbs(self) -> Optional[pulumi.Input[int]]:
|
|
1288
|
+
"""
|
|
1289
|
+
(Output)
|
|
1290
|
+
The memory assigned to in-memory tables in an Autonomous Database.
|
|
1291
|
+
"""
|
|
1292
|
+
return pulumi.get(self, "memory_table_gbs")
|
|
1293
|
+
|
|
1294
|
+
@memory_table_gbs.setter
|
|
1295
|
+
def memory_table_gbs(self, value: Optional[pulumi.Input[int]]):
|
|
1296
|
+
pulumi.set(self, "memory_table_gbs", value)
|
|
1297
|
+
|
|
1298
|
+
@property
|
|
1299
|
+
@pulumi.getter(name="mtlsConnectionRequired")
|
|
1300
|
+
def mtls_connection_required(self) -> Optional[pulumi.Input[bool]]:
|
|
1301
|
+
"""
|
|
1302
|
+
This field specifies if the Autonomous Database requires mTLS connections.
|
|
1303
|
+
"""
|
|
1304
|
+
return pulumi.get(self, "mtls_connection_required")
|
|
1305
|
+
|
|
1306
|
+
@mtls_connection_required.setter
|
|
1307
|
+
def mtls_connection_required(self, value: Optional[pulumi.Input[bool]]):
|
|
1308
|
+
pulumi.set(self, "mtls_connection_required", value)
|
|
1309
|
+
|
|
1310
|
+
@property
|
|
1311
|
+
@pulumi.getter(name="nCharacterSet")
|
|
1312
|
+
def n_character_set(self) -> Optional[pulumi.Input[str]]:
|
|
1313
|
+
"""
|
|
1314
|
+
The national character set for the Autonomous Database. The default is
|
|
1315
|
+
AL16UTF16.
|
|
1316
|
+
"""
|
|
1317
|
+
return pulumi.get(self, "n_character_set")
|
|
1318
|
+
|
|
1319
|
+
@n_character_set.setter
|
|
1320
|
+
def n_character_set(self, value: Optional[pulumi.Input[str]]):
|
|
1321
|
+
pulumi.set(self, "n_character_set", value)
|
|
1322
|
+
|
|
1323
|
+
@property
|
|
1324
|
+
@pulumi.getter(name="nextLongTermBackupTime")
|
|
1325
|
+
def next_long_term_backup_time(self) -> Optional[pulumi.Input[str]]:
|
|
1326
|
+
"""
|
|
1327
|
+
(Output)
|
|
1328
|
+
The long term backup schedule of the Autonomous Database.
|
|
1329
|
+
"""
|
|
1330
|
+
return pulumi.get(self, "next_long_term_backup_time")
|
|
1331
|
+
|
|
1332
|
+
@next_long_term_backup_time.setter
|
|
1333
|
+
def next_long_term_backup_time(self, value: Optional[pulumi.Input[str]]):
|
|
1334
|
+
pulumi.set(self, "next_long_term_backup_time", value)
|
|
1335
|
+
|
|
1336
|
+
@property
|
|
1337
|
+
@pulumi.getter(name="ociUrl")
|
|
1338
|
+
def oci_url(self) -> Optional[pulumi.Input[str]]:
|
|
1339
|
+
"""
|
|
1340
|
+
(Output)
|
|
1341
|
+
The Oracle Cloud Infrastructure link for the Autonomous Database.
|
|
1342
|
+
"""
|
|
1343
|
+
return pulumi.get(self, "oci_url")
|
|
1344
|
+
|
|
1345
|
+
@oci_url.setter
|
|
1346
|
+
def oci_url(self, value: Optional[pulumi.Input[str]]):
|
|
1347
|
+
pulumi.set(self, "oci_url", value)
|
|
1348
|
+
|
|
1349
|
+
@property
|
|
1350
|
+
@pulumi.getter
|
|
1351
|
+
def ocid(self) -> Optional[pulumi.Input[str]]:
|
|
1352
|
+
"""
|
|
1353
|
+
(Output)
|
|
1354
|
+
OCID of the Autonomous Database.
|
|
1355
|
+
https://docs.oracle.com/en-us/iaas/Content/General/Concepts/identifiers.htm#Oracle
|
|
1356
|
+
"""
|
|
1357
|
+
return pulumi.get(self, "ocid")
|
|
1358
|
+
|
|
1359
|
+
@ocid.setter
|
|
1360
|
+
def ocid(self, value: Optional[pulumi.Input[str]]):
|
|
1361
|
+
pulumi.set(self, "ocid", value)
|
|
1362
|
+
|
|
1363
|
+
@property
|
|
1364
|
+
@pulumi.getter(name="openMode")
|
|
1365
|
+
def open_mode(self) -> Optional[pulumi.Input[str]]:
|
|
1366
|
+
"""
|
|
1367
|
+
(Output)
|
|
1368
|
+
This field indicates the current mode of the Autonomous Database.
|
|
1369
|
+
Possible values:
|
|
1370
|
+
OPEN_MODE_UNSPECIFIED
|
|
1371
|
+
READ_ONLY
|
|
1372
|
+
READ_WRITE
|
|
1373
|
+
"""
|
|
1374
|
+
return pulumi.get(self, "open_mode")
|
|
1375
|
+
|
|
1376
|
+
@open_mode.setter
|
|
1377
|
+
def open_mode(self, value: Optional[pulumi.Input[str]]):
|
|
1378
|
+
pulumi.set(self, "open_mode", value)
|
|
1379
|
+
|
|
1380
|
+
@property
|
|
1381
|
+
@pulumi.getter(name="operationsInsightsState")
|
|
1382
|
+
def operations_insights_state(self) -> Optional[pulumi.Input[str]]:
|
|
1383
|
+
"""
|
|
1384
|
+
Possible values:
|
|
1385
|
+
OPERATIONS_INSIGHTS_STATE_UNSPECIFIED
|
|
1386
|
+
ENABLING
|
|
1387
|
+
ENABLED
|
|
1388
|
+
DISABLING
|
|
1389
|
+
NOT_ENABLED
|
|
1390
|
+
FAILED_ENABLING
|
|
1391
|
+
FAILED_DISABLING
|
|
1392
|
+
"""
|
|
1393
|
+
return pulumi.get(self, "operations_insights_state")
|
|
1394
|
+
|
|
1395
|
+
@operations_insights_state.setter
|
|
1396
|
+
def operations_insights_state(self, value: Optional[pulumi.Input[str]]):
|
|
1397
|
+
pulumi.set(self, "operations_insights_state", value)
|
|
1398
|
+
|
|
1399
|
+
@property
|
|
1400
|
+
@pulumi.getter(name="peerDbIds")
|
|
1401
|
+
def peer_db_ids(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
1402
|
+
"""
|
|
1403
|
+
(Output)
|
|
1404
|
+
The list of OCIDs of standby databases located in Autonomous Data Guard
|
|
1405
|
+
remote regions that are associated with the source database.
|
|
1406
|
+
"""
|
|
1407
|
+
return pulumi.get(self, "peer_db_ids")
|
|
1408
|
+
|
|
1409
|
+
@peer_db_ids.setter
|
|
1410
|
+
def peer_db_ids(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
1411
|
+
pulumi.set(self, "peer_db_ids", value)
|
|
1412
|
+
|
|
1413
|
+
@property
|
|
1414
|
+
@pulumi.getter(name="permissionLevel")
|
|
1415
|
+
def permission_level(self) -> Optional[pulumi.Input[str]]:
|
|
1416
|
+
"""
|
|
1417
|
+
(Output)
|
|
1418
|
+
The permission level of the Autonomous Database.
|
|
1419
|
+
Possible values:
|
|
1420
|
+
PERMISSION_LEVEL_UNSPECIFIED
|
|
1421
|
+
RESTRICTED
|
|
1422
|
+
UNRESTRICTED
|
|
1423
|
+
"""
|
|
1424
|
+
return pulumi.get(self, "permission_level")
|
|
1425
|
+
|
|
1426
|
+
@permission_level.setter
|
|
1427
|
+
def permission_level(self, value: Optional[pulumi.Input[str]]):
|
|
1428
|
+
pulumi.set(self, "permission_level", value)
|
|
1429
|
+
|
|
1430
|
+
@property
|
|
1431
|
+
@pulumi.getter(name="privateEndpoint")
|
|
1432
|
+
def private_endpoint(self) -> Optional[pulumi.Input[str]]:
|
|
1433
|
+
"""
|
|
1434
|
+
(Output)
|
|
1435
|
+
The private endpoint for the Autonomous Database.
|
|
1436
|
+
"""
|
|
1437
|
+
return pulumi.get(self, "private_endpoint")
|
|
1438
|
+
|
|
1439
|
+
@private_endpoint.setter
|
|
1440
|
+
def private_endpoint(self, value: Optional[pulumi.Input[str]]):
|
|
1441
|
+
pulumi.set(self, "private_endpoint", value)
|
|
1442
|
+
|
|
1443
|
+
@property
|
|
1444
|
+
@pulumi.getter(name="privateEndpointIp")
|
|
1445
|
+
def private_endpoint_ip(self) -> Optional[pulumi.Input[str]]:
|
|
1446
|
+
"""
|
|
1447
|
+
The private endpoint IP address for the Autonomous Database.
|
|
1448
|
+
"""
|
|
1449
|
+
return pulumi.get(self, "private_endpoint_ip")
|
|
1450
|
+
|
|
1451
|
+
@private_endpoint_ip.setter
|
|
1452
|
+
def private_endpoint_ip(self, value: Optional[pulumi.Input[str]]):
|
|
1453
|
+
pulumi.set(self, "private_endpoint_ip", value)
|
|
1454
|
+
|
|
1455
|
+
@property
|
|
1456
|
+
@pulumi.getter(name="privateEndpointLabel")
|
|
1457
|
+
def private_endpoint_label(self) -> Optional[pulumi.Input[str]]:
|
|
1458
|
+
"""
|
|
1459
|
+
The private endpoint label for the Autonomous Database.
|
|
1460
|
+
"""
|
|
1461
|
+
return pulumi.get(self, "private_endpoint_label")
|
|
1462
|
+
|
|
1463
|
+
@private_endpoint_label.setter
|
|
1464
|
+
def private_endpoint_label(self, value: Optional[pulumi.Input[str]]):
|
|
1465
|
+
pulumi.set(self, "private_endpoint_label", value)
|
|
1466
|
+
|
|
1467
|
+
@property
|
|
1468
|
+
@pulumi.getter(name="refreshableMode")
|
|
1469
|
+
def refreshable_mode(self) -> Optional[pulumi.Input[str]]:
|
|
1470
|
+
"""
|
|
1471
|
+
(Output)
|
|
1472
|
+
The refresh mode of the cloned Autonomous Database.
|
|
1473
|
+
Possible values:
|
|
1474
|
+
REFRESHABLE_MODE_UNSPECIFIED
|
|
1475
|
+
AUTOMATIC
|
|
1476
|
+
MANUAL
|
|
1477
|
+
"""
|
|
1478
|
+
return pulumi.get(self, "refreshable_mode")
|
|
1479
|
+
|
|
1480
|
+
@refreshable_mode.setter
|
|
1481
|
+
def refreshable_mode(self, value: Optional[pulumi.Input[str]]):
|
|
1482
|
+
pulumi.set(self, "refreshable_mode", value)
|
|
1483
|
+
|
|
1484
|
+
@property
|
|
1485
|
+
@pulumi.getter(name="refreshableState")
|
|
1486
|
+
def refreshable_state(self) -> Optional[pulumi.Input[str]]:
|
|
1487
|
+
"""
|
|
1488
|
+
(Output)
|
|
1489
|
+
The refresh State of the clone.
|
|
1490
|
+
Possible values:
|
|
1491
|
+
REFRESHABLE_STATE_UNSPECIFIED
|
|
1492
|
+
REFRESHING
|
|
1493
|
+
NOT_REFRESHING
|
|
1494
|
+
"""
|
|
1495
|
+
return pulumi.get(self, "refreshable_state")
|
|
1496
|
+
|
|
1497
|
+
@refreshable_state.setter
|
|
1498
|
+
def refreshable_state(self, value: Optional[pulumi.Input[str]]):
|
|
1499
|
+
pulumi.set(self, "refreshable_state", value)
|
|
1500
|
+
|
|
1501
|
+
@property
|
|
1502
|
+
@pulumi.getter
|
|
1503
|
+
def role(self) -> Optional[pulumi.Input[str]]:
|
|
1504
|
+
"""
|
|
1505
|
+
(Output)
|
|
1506
|
+
The Data Guard role of the Autonomous Database.
|
|
1507
|
+
Possible values:
|
|
1508
|
+
ROLE_UNSPECIFIED
|
|
1509
|
+
PRIMARY
|
|
1510
|
+
STANDBY
|
|
1511
|
+
DISABLED_STANDBY
|
|
1512
|
+
BACKUP_COPY
|
|
1513
|
+
SNAPSHOT_STANDBY
|
|
1514
|
+
"""
|
|
1515
|
+
return pulumi.get(self, "role")
|
|
1516
|
+
|
|
1517
|
+
@role.setter
|
|
1518
|
+
def role(self, value: Optional[pulumi.Input[str]]):
|
|
1519
|
+
pulumi.set(self, "role", value)
|
|
1520
|
+
|
|
1521
|
+
@property
|
|
1522
|
+
@pulumi.getter(name="scheduledOperationDetails")
|
|
1523
|
+
def scheduled_operation_details(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['AutonomousDatabasePropertiesScheduledOperationDetailArgs']]]]:
|
|
1524
|
+
"""
|
|
1525
|
+
(Output)
|
|
1526
|
+
The list and details of the scheduled operations of the Autonomous
|
|
1527
|
+
Database.
|
|
1528
|
+
Structure is documented below.
|
|
1529
|
+
"""
|
|
1530
|
+
return pulumi.get(self, "scheduled_operation_details")
|
|
1531
|
+
|
|
1532
|
+
@scheduled_operation_details.setter
|
|
1533
|
+
def scheduled_operation_details(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['AutonomousDatabasePropertiesScheduledOperationDetailArgs']]]]):
|
|
1534
|
+
pulumi.set(self, "scheduled_operation_details", value)
|
|
1535
|
+
|
|
1536
|
+
@property
|
|
1537
|
+
@pulumi.getter(name="sqlWebDeveloperUrl")
|
|
1538
|
+
def sql_web_developer_url(self) -> Optional[pulumi.Input[str]]:
|
|
1539
|
+
"""
|
|
1540
|
+
(Output)
|
|
1541
|
+
The SQL Web Developer URL for the Autonomous Database.
|
|
1542
|
+
"""
|
|
1543
|
+
return pulumi.get(self, "sql_web_developer_url")
|
|
1544
|
+
|
|
1545
|
+
@sql_web_developer_url.setter
|
|
1546
|
+
def sql_web_developer_url(self, value: Optional[pulumi.Input[str]]):
|
|
1547
|
+
pulumi.set(self, "sql_web_developer_url", value)
|
|
1548
|
+
|
|
1549
|
+
@property
|
|
1550
|
+
@pulumi.getter
|
|
1551
|
+
def state(self) -> Optional[pulumi.Input[str]]:
|
|
1552
|
+
"""
|
|
1553
|
+
(Output)
|
|
1554
|
+
Possible values:
|
|
1555
|
+
STATE_UNSPECIFIED
|
|
1556
|
+
PROVISIONING
|
|
1557
|
+
AVAILABLE
|
|
1558
|
+
STOPPING
|
|
1559
|
+
STOPPED
|
|
1560
|
+
STARTING
|
|
1561
|
+
TERMINATING
|
|
1562
|
+
TERMINATED
|
|
1563
|
+
UNAVAILABLE
|
|
1564
|
+
RESTORE_IN_PROGRESS
|
|
1565
|
+
RESTORE_FAILED
|
|
1566
|
+
BACKUP_IN_PROGRESS
|
|
1567
|
+
SCALE_IN_PROGRESS
|
|
1568
|
+
AVAILABLE_NEEDS_ATTENTION
|
|
1569
|
+
UPDATING
|
|
1570
|
+
MAINTENANCE_IN_PROGRESS
|
|
1571
|
+
RESTARTING
|
|
1572
|
+
RECREATING
|
|
1573
|
+
ROLE_CHANGE_IN_PROGRESS
|
|
1574
|
+
UPGRADING
|
|
1575
|
+
INACCESSIBLE
|
|
1576
|
+
STANDBY
|
|
1577
|
+
"""
|
|
1578
|
+
return pulumi.get(self, "state")
|
|
1579
|
+
|
|
1580
|
+
@state.setter
|
|
1581
|
+
def state(self, value: Optional[pulumi.Input[str]]):
|
|
1582
|
+
pulumi.set(self, "state", value)
|
|
1583
|
+
|
|
1584
|
+
@property
|
|
1585
|
+
@pulumi.getter(name="supportedCloneRegions")
|
|
1586
|
+
def supported_clone_regions(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
1587
|
+
"""
|
|
1588
|
+
(Output)
|
|
1589
|
+
The list of available regions that can be used to create a clone for the
|
|
1590
|
+
Autonomous Database.
|
|
1591
|
+
"""
|
|
1592
|
+
return pulumi.get(self, "supported_clone_regions")
|
|
1593
|
+
|
|
1594
|
+
@supported_clone_regions.setter
|
|
1595
|
+
def supported_clone_regions(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
1596
|
+
pulumi.set(self, "supported_clone_regions", value)
|
|
1597
|
+
|
|
1598
|
+
@property
|
|
1599
|
+
@pulumi.getter(name="totalAutoBackupStorageSizeGbs")
|
|
1600
|
+
def total_auto_backup_storage_size_gbs(self) -> Optional[pulumi.Input[float]]:
|
|
1601
|
+
"""
|
|
1602
|
+
(Output)
|
|
1603
|
+
The storage space used by automatic backups of Autonomous Database, in
|
|
1604
|
+
gigabytes.
|
|
1605
|
+
"""
|
|
1606
|
+
return pulumi.get(self, "total_auto_backup_storage_size_gbs")
|
|
1607
|
+
|
|
1608
|
+
@total_auto_backup_storage_size_gbs.setter
|
|
1609
|
+
def total_auto_backup_storage_size_gbs(self, value: Optional[pulumi.Input[float]]):
|
|
1610
|
+
pulumi.set(self, "total_auto_backup_storage_size_gbs", value)
|
|
1611
|
+
|
|
1612
|
+
@property
|
|
1613
|
+
@pulumi.getter(name="usedDataStorageSizeTbs")
|
|
1614
|
+
def used_data_storage_size_tbs(self) -> Optional[pulumi.Input[int]]:
|
|
1615
|
+
"""
|
|
1616
|
+
(Output)
|
|
1617
|
+
The storage space used by Autonomous Database, in gigabytes.
|
|
1618
|
+
"""
|
|
1619
|
+
return pulumi.get(self, "used_data_storage_size_tbs")
|
|
1620
|
+
|
|
1621
|
+
@used_data_storage_size_tbs.setter
|
|
1622
|
+
def used_data_storage_size_tbs(self, value: Optional[pulumi.Input[int]]):
|
|
1623
|
+
pulumi.set(self, "used_data_storage_size_tbs", value)
|
|
1624
|
+
|
|
1625
|
+
|
|
1626
|
+
if not MYPY:
|
|
1627
|
+
class AutonomousDatabasePropertiesApexDetailArgsDict(TypedDict):
|
|
1628
|
+
apex_version: NotRequired[pulumi.Input[str]]
|
|
1629
|
+
"""
|
|
1630
|
+
The Oracle APEX Application Development version.
|
|
1631
|
+
"""
|
|
1632
|
+
ords_version: NotRequired[pulumi.Input[str]]
|
|
1633
|
+
"""
|
|
1634
|
+
The Oracle REST Data Services (ORDS) version.
|
|
1635
|
+
"""
|
|
1636
|
+
elif False:
|
|
1637
|
+
AutonomousDatabasePropertiesApexDetailArgsDict: TypeAlias = Mapping[str, Any]
|
|
1638
|
+
|
|
1639
|
+
@pulumi.input_type
|
|
1640
|
+
class AutonomousDatabasePropertiesApexDetailArgs:
|
|
1641
|
+
def __init__(__self__, *,
|
|
1642
|
+
apex_version: Optional[pulumi.Input[str]] = None,
|
|
1643
|
+
ords_version: Optional[pulumi.Input[str]] = None):
|
|
1644
|
+
"""
|
|
1645
|
+
:param pulumi.Input[str] apex_version: The Oracle APEX Application Development version.
|
|
1646
|
+
:param pulumi.Input[str] ords_version: The Oracle REST Data Services (ORDS) version.
|
|
1647
|
+
"""
|
|
1648
|
+
if apex_version is not None:
|
|
1649
|
+
pulumi.set(__self__, "apex_version", apex_version)
|
|
1650
|
+
if ords_version is not None:
|
|
1651
|
+
pulumi.set(__self__, "ords_version", ords_version)
|
|
1652
|
+
|
|
1653
|
+
@property
|
|
1654
|
+
@pulumi.getter(name="apexVersion")
|
|
1655
|
+
def apex_version(self) -> Optional[pulumi.Input[str]]:
|
|
1656
|
+
"""
|
|
1657
|
+
The Oracle APEX Application Development version.
|
|
1658
|
+
"""
|
|
1659
|
+
return pulumi.get(self, "apex_version")
|
|
1660
|
+
|
|
1661
|
+
@apex_version.setter
|
|
1662
|
+
def apex_version(self, value: Optional[pulumi.Input[str]]):
|
|
1663
|
+
pulumi.set(self, "apex_version", value)
|
|
1664
|
+
|
|
1665
|
+
@property
|
|
1666
|
+
@pulumi.getter(name="ordsVersion")
|
|
1667
|
+
def ords_version(self) -> Optional[pulumi.Input[str]]:
|
|
1668
|
+
"""
|
|
1669
|
+
The Oracle REST Data Services (ORDS) version.
|
|
1670
|
+
"""
|
|
1671
|
+
return pulumi.get(self, "ords_version")
|
|
1672
|
+
|
|
1673
|
+
@ords_version.setter
|
|
1674
|
+
def ords_version(self, value: Optional[pulumi.Input[str]]):
|
|
1675
|
+
pulumi.set(self, "ords_version", value)
|
|
1676
|
+
|
|
1677
|
+
|
|
1678
|
+
if not MYPY:
|
|
1679
|
+
class AutonomousDatabasePropertiesConnectionStringArgsDict(TypedDict):
|
|
1680
|
+
all_connection_strings: NotRequired[pulumi.Input[Sequence[pulumi.Input['AutonomousDatabasePropertiesConnectionStringAllConnectionStringArgsDict']]]]
|
|
1681
|
+
"""
|
|
1682
|
+
A list of all connection strings that can be used to connect to the
|
|
1683
|
+
Autonomous Database.
|
|
1684
|
+
"""
|
|
1685
|
+
dedicated: NotRequired[pulumi.Input[str]]
|
|
1686
|
+
"""
|
|
1687
|
+
The database service provides the least level of resources to each SQL
|
|
1688
|
+
statement, but supports the most number of concurrent SQL statements.
|
|
1689
|
+
"""
|
|
1690
|
+
high: NotRequired[pulumi.Input[str]]
|
|
1691
|
+
"""
|
|
1692
|
+
The database service provides the highest level of resources to each SQL
|
|
1693
|
+
statement.
|
|
1694
|
+
"""
|
|
1695
|
+
low: NotRequired[pulumi.Input[str]]
|
|
1696
|
+
"""
|
|
1697
|
+
The database service provides the least level of resources to each SQL
|
|
1698
|
+
statement.
|
|
1699
|
+
"""
|
|
1700
|
+
medium: NotRequired[pulumi.Input[str]]
|
|
1701
|
+
"""
|
|
1702
|
+
The database service provides a lower level of resources to each SQL
|
|
1703
|
+
statement.
|
|
1704
|
+
"""
|
|
1705
|
+
profiles: NotRequired[pulumi.Input[Sequence[pulumi.Input['AutonomousDatabasePropertiesConnectionStringProfileArgsDict']]]]
|
|
1706
|
+
"""
|
|
1707
|
+
A list of connection string profiles to allow clients to group, filter, and
|
|
1708
|
+
select values based on the structured metadata.
|
|
1709
|
+
"""
|
|
1710
|
+
elif False:
|
|
1711
|
+
AutonomousDatabasePropertiesConnectionStringArgsDict: TypeAlias = Mapping[str, Any]
|
|
1712
|
+
|
|
1713
|
+
@pulumi.input_type
|
|
1714
|
+
class AutonomousDatabasePropertiesConnectionStringArgs:
|
|
1715
|
+
def __init__(__self__, *,
|
|
1716
|
+
all_connection_strings: Optional[pulumi.Input[Sequence[pulumi.Input['AutonomousDatabasePropertiesConnectionStringAllConnectionStringArgs']]]] = None,
|
|
1717
|
+
dedicated: Optional[pulumi.Input[str]] = None,
|
|
1718
|
+
high: Optional[pulumi.Input[str]] = None,
|
|
1719
|
+
low: Optional[pulumi.Input[str]] = None,
|
|
1720
|
+
medium: Optional[pulumi.Input[str]] = None,
|
|
1721
|
+
profiles: Optional[pulumi.Input[Sequence[pulumi.Input['AutonomousDatabasePropertiesConnectionStringProfileArgs']]]] = None):
|
|
1722
|
+
"""
|
|
1723
|
+
:param pulumi.Input[Sequence[pulumi.Input['AutonomousDatabasePropertiesConnectionStringAllConnectionStringArgs']]] all_connection_strings: A list of all connection strings that can be used to connect to the
|
|
1724
|
+
Autonomous Database.
|
|
1725
|
+
:param pulumi.Input[str] dedicated: The database service provides the least level of resources to each SQL
|
|
1726
|
+
statement, but supports the most number of concurrent SQL statements.
|
|
1727
|
+
:param pulumi.Input[str] high: The database service provides the highest level of resources to each SQL
|
|
1728
|
+
statement.
|
|
1729
|
+
:param pulumi.Input[str] low: The database service provides the least level of resources to each SQL
|
|
1730
|
+
statement.
|
|
1731
|
+
:param pulumi.Input[str] medium: The database service provides a lower level of resources to each SQL
|
|
1732
|
+
statement.
|
|
1733
|
+
:param pulumi.Input[Sequence[pulumi.Input['AutonomousDatabasePropertiesConnectionStringProfileArgs']]] profiles: A list of connection string profiles to allow clients to group, filter, and
|
|
1734
|
+
select values based on the structured metadata.
|
|
1735
|
+
"""
|
|
1736
|
+
if all_connection_strings is not None:
|
|
1737
|
+
pulumi.set(__self__, "all_connection_strings", all_connection_strings)
|
|
1738
|
+
if dedicated is not None:
|
|
1739
|
+
pulumi.set(__self__, "dedicated", dedicated)
|
|
1740
|
+
if high is not None:
|
|
1741
|
+
pulumi.set(__self__, "high", high)
|
|
1742
|
+
if low is not None:
|
|
1743
|
+
pulumi.set(__self__, "low", low)
|
|
1744
|
+
if medium is not None:
|
|
1745
|
+
pulumi.set(__self__, "medium", medium)
|
|
1746
|
+
if profiles is not None:
|
|
1747
|
+
pulumi.set(__self__, "profiles", profiles)
|
|
1748
|
+
|
|
1749
|
+
@property
|
|
1750
|
+
@pulumi.getter(name="allConnectionStrings")
|
|
1751
|
+
def all_connection_strings(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['AutonomousDatabasePropertiesConnectionStringAllConnectionStringArgs']]]]:
|
|
1752
|
+
"""
|
|
1753
|
+
A list of all connection strings that can be used to connect to the
|
|
1754
|
+
Autonomous Database.
|
|
1755
|
+
"""
|
|
1756
|
+
return pulumi.get(self, "all_connection_strings")
|
|
1757
|
+
|
|
1758
|
+
@all_connection_strings.setter
|
|
1759
|
+
def all_connection_strings(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['AutonomousDatabasePropertiesConnectionStringAllConnectionStringArgs']]]]):
|
|
1760
|
+
pulumi.set(self, "all_connection_strings", value)
|
|
1761
|
+
|
|
1762
|
+
@property
|
|
1763
|
+
@pulumi.getter
|
|
1764
|
+
def dedicated(self) -> Optional[pulumi.Input[str]]:
|
|
1765
|
+
"""
|
|
1766
|
+
The database service provides the least level of resources to each SQL
|
|
1767
|
+
statement, but supports the most number of concurrent SQL statements.
|
|
1768
|
+
"""
|
|
1769
|
+
return pulumi.get(self, "dedicated")
|
|
1770
|
+
|
|
1771
|
+
@dedicated.setter
|
|
1772
|
+
def dedicated(self, value: Optional[pulumi.Input[str]]):
|
|
1773
|
+
pulumi.set(self, "dedicated", value)
|
|
1774
|
+
|
|
1775
|
+
@property
|
|
1776
|
+
@pulumi.getter
|
|
1777
|
+
def high(self) -> Optional[pulumi.Input[str]]:
|
|
1778
|
+
"""
|
|
1779
|
+
The database service provides the highest level of resources to each SQL
|
|
1780
|
+
statement.
|
|
1781
|
+
"""
|
|
1782
|
+
return pulumi.get(self, "high")
|
|
1783
|
+
|
|
1784
|
+
@high.setter
|
|
1785
|
+
def high(self, value: Optional[pulumi.Input[str]]):
|
|
1786
|
+
pulumi.set(self, "high", value)
|
|
1787
|
+
|
|
1788
|
+
@property
|
|
1789
|
+
@pulumi.getter
|
|
1790
|
+
def low(self) -> Optional[pulumi.Input[str]]:
|
|
1791
|
+
"""
|
|
1792
|
+
The database service provides the least level of resources to each SQL
|
|
1793
|
+
statement.
|
|
1794
|
+
"""
|
|
1795
|
+
return pulumi.get(self, "low")
|
|
1796
|
+
|
|
1797
|
+
@low.setter
|
|
1798
|
+
def low(self, value: Optional[pulumi.Input[str]]):
|
|
1799
|
+
pulumi.set(self, "low", value)
|
|
1800
|
+
|
|
1801
|
+
@property
|
|
1802
|
+
@pulumi.getter
|
|
1803
|
+
def medium(self) -> Optional[pulumi.Input[str]]:
|
|
1804
|
+
"""
|
|
1805
|
+
The database service provides a lower level of resources to each SQL
|
|
1806
|
+
statement.
|
|
1807
|
+
"""
|
|
1808
|
+
return pulumi.get(self, "medium")
|
|
1809
|
+
|
|
1810
|
+
@medium.setter
|
|
1811
|
+
def medium(self, value: Optional[pulumi.Input[str]]):
|
|
1812
|
+
pulumi.set(self, "medium", value)
|
|
1813
|
+
|
|
1814
|
+
@property
|
|
1815
|
+
@pulumi.getter
|
|
1816
|
+
def profiles(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['AutonomousDatabasePropertiesConnectionStringProfileArgs']]]]:
|
|
1817
|
+
"""
|
|
1818
|
+
A list of connection string profiles to allow clients to group, filter, and
|
|
1819
|
+
select values based on the structured metadata.
|
|
1820
|
+
"""
|
|
1821
|
+
return pulumi.get(self, "profiles")
|
|
1822
|
+
|
|
1823
|
+
@profiles.setter
|
|
1824
|
+
def profiles(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['AutonomousDatabasePropertiesConnectionStringProfileArgs']]]]):
|
|
1825
|
+
pulumi.set(self, "profiles", value)
|
|
1826
|
+
|
|
1827
|
+
|
|
1828
|
+
if not MYPY:
|
|
1829
|
+
class AutonomousDatabasePropertiesConnectionStringAllConnectionStringArgsDict(TypedDict):
|
|
1830
|
+
high: NotRequired[pulumi.Input[str]]
|
|
1831
|
+
"""
|
|
1832
|
+
The database service provides the highest level of resources to each SQL
|
|
1833
|
+
statement.
|
|
1834
|
+
"""
|
|
1835
|
+
low: NotRequired[pulumi.Input[str]]
|
|
1836
|
+
"""
|
|
1837
|
+
The database service provides the least level of resources to each SQL
|
|
1838
|
+
statement.
|
|
1839
|
+
"""
|
|
1840
|
+
medium: NotRequired[pulumi.Input[str]]
|
|
1841
|
+
"""
|
|
1842
|
+
The database service provides a lower level of resources to each SQL
|
|
1843
|
+
statement.
|
|
1844
|
+
"""
|
|
1845
|
+
elif False:
|
|
1846
|
+
AutonomousDatabasePropertiesConnectionStringAllConnectionStringArgsDict: TypeAlias = Mapping[str, Any]
|
|
1847
|
+
|
|
1848
|
+
@pulumi.input_type
|
|
1849
|
+
class AutonomousDatabasePropertiesConnectionStringAllConnectionStringArgs:
|
|
1850
|
+
def __init__(__self__, *,
|
|
1851
|
+
high: Optional[pulumi.Input[str]] = None,
|
|
1852
|
+
low: Optional[pulumi.Input[str]] = None,
|
|
1853
|
+
medium: Optional[pulumi.Input[str]] = None):
|
|
1854
|
+
"""
|
|
1855
|
+
:param pulumi.Input[str] high: The database service provides the highest level of resources to each SQL
|
|
1856
|
+
statement.
|
|
1857
|
+
:param pulumi.Input[str] low: The database service provides the least level of resources to each SQL
|
|
1858
|
+
statement.
|
|
1859
|
+
:param pulumi.Input[str] medium: The database service provides a lower level of resources to each SQL
|
|
1860
|
+
statement.
|
|
1861
|
+
"""
|
|
1862
|
+
if high is not None:
|
|
1863
|
+
pulumi.set(__self__, "high", high)
|
|
1864
|
+
if low is not None:
|
|
1865
|
+
pulumi.set(__self__, "low", low)
|
|
1866
|
+
if medium is not None:
|
|
1867
|
+
pulumi.set(__self__, "medium", medium)
|
|
1868
|
+
|
|
1869
|
+
@property
|
|
1870
|
+
@pulumi.getter
|
|
1871
|
+
def high(self) -> Optional[pulumi.Input[str]]:
|
|
1872
|
+
"""
|
|
1873
|
+
The database service provides the highest level of resources to each SQL
|
|
1874
|
+
statement.
|
|
1875
|
+
"""
|
|
1876
|
+
return pulumi.get(self, "high")
|
|
1877
|
+
|
|
1878
|
+
@high.setter
|
|
1879
|
+
def high(self, value: Optional[pulumi.Input[str]]):
|
|
1880
|
+
pulumi.set(self, "high", value)
|
|
1881
|
+
|
|
1882
|
+
@property
|
|
1883
|
+
@pulumi.getter
|
|
1884
|
+
def low(self) -> Optional[pulumi.Input[str]]:
|
|
1885
|
+
"""
|
|
1886
|
+
The database service provides the least level of resources to each SQL
|
|
1887
|
+
statement.
|
|
1888
|
+
"""
|
|
1889
|
+
return pulumi.get(self, "low")
|
|
1890
|
+
|
|
1891
|
+
@low.setter
|
|
1892
|
+
def low(self, value: Optional[pulumi.Input[str]]):
|
|
1893
|
+
pulumi.set(self, "low", value)
|
|
1894
|
+
|
|
1895
|
+
@property
|
|
1896
|
+
@pulumi.getter
|
|
1897
|
+
def medium(self) -> Optional[pulumi.Input[str]]:
|
|
1898
|
+
"""
|
|
1899
|
+
The database service provides a lower level of resources to each SQL
|
|
1900
|
+
statement.
|
|
1901
|
+
"""
|
|
1902
|
+
return pulumi.get(self, "medium")
|
|
1903
|
+
|
|
1904
|
+
@medium.setter
|
|
1905
|
+
def medium(self, value: Optional[pulumi.Input[str]]):
|
|
1906
|
+
pulumi.set(self, "medium", value)
|
|
1907
|
+
|
|
1908
|
+
|
|
1909
|
+
if not MYPY:
|
|
1910
|
+
class AutonomousDatabasePropertiesConnectionStringProfileArgsDict(TypedDict):
|
|
1911
|
+
consumer_group: NotRequired[pulumi.Input[str]]
|
|
1912
|
+
"""
|
|
1913
|
+
The current consumer group being used by the connection.
|
|
1914
|
+
Possible values:
|
|
1915
|
+
CONSUMER_GROUP_UNSPECIFIED
|
|
1916
|
+
HIGH
|
|
1917
|
+
MEDIUM
|
|
1918
|
+
LOW
|
|
1919
|
+
TP
|
|
1920
|
+
TPURGENT
|
|
1921
|
+
"""
|
|
1922
|
+
display_name: NotRequired[pulumi.Input[str]]
|
|
1923
|
+
"""
|
|
1924
|
+
The display name for the database connection.
|
|
1925
|
+
"""
|
|
1926
|
+
host_format: NotRequired[pulumi.Input[str]]
|
|
1927
|
+
"""
|
|
1928
|
+
The host name format being currently used in connection string.
|
|
1929
|
+
Possible values:
|
|
1930
|
+
HOST_FORMAT_UNSPECIFIED
|
|
1931
|
+
FQDN
|
|
1932
|
+
IP
|
|
1933
|
+
"""
|
|
1934
|
+
is_regional: NotRequired[pulumi.Input[bool]]
|
|
1935
|
+
"""
|
|
1936
|
+
This field indicates if the connection string is regional and is only
|
|
1937
|
+
applicable for cross-region Data Guard.
|
|
1938
|
+
"""
|
|
1939
|
+
protocol: NotRequired[pulumi.Input[str]]
|
|
1940
|
+
"""
|
|
1941
|
+
The protocol being used by the connection.
|
|
1942
|
+
Possible values:
|
|
1943
|
+
PROTOCOL_UNSPECIFIED
|
|
1944
|
+
TCP
|
|
1945
|
+
TCPS
|
|
1946
|
+
"""
|
|
1947
|
+
session_mode: NotRequired[pulumi.Input[str]]
|
|
1948
|
+
"""
|
|
1949
|
+
The current session mode of the connection.
|
|
1950
|
+
Possible values:
|
|
1951
|
+
SESSION_MODE_UNSPECIFIED
|
|
1952
|
+
DIRECT
|
|
1953
|
+
INDIRECT
|
|
1954
|
+
"""
|
|
1955
|
+
syntax_format: NotRequired[pulumi.Input[str]]
|
|
1956
|
+
"""
|
|
1957
|
+
The syntax of the connection string.
|
|
1958
|
+
Possible values:
|
|
1959
|
+
SYNTAX_FORMAT_UNSPECIFIED
|
|
1960
|
+
LONG
|
|
1961
|
+
EZCONNECT
|
|
1962
|
+
EZCONNECTPLUS
|
|
1963
|
+
"""
|
|
1964
|
+
tls_authentication: NotRequired[pulumi.Input[str]]
|
|
1965
|
+
"""
|
|
1966
|
+
This field indicates the TLS authentication type of the connection.
|
|
1967
|
+
Possible values:
|
|
1968
|
+
TLS_AUTHENTICATION_UNSPECIFIED
|
|
1969
|
+
SERVER
|
|
1970
|
+
MUTUAL
|
|
1971
|
+
"""
|
|
1972
|
+
value: NotRequired[pulumi.Input[str]]
|
|
1973
|
+
"""
|
|
1974
|
+
The value of the connection string.
|
|
1975
|
+
"""
|
|
1976
|
+
elif False:
|
|
1977
|
+
AutonomousDatabasePropertiesConnectionStringProfileArgsDict: TypeAlias = Mapping[str, Any]
|
|
1978
|
+
|
|
1979
|
+
@pulumi.input_type
|
|
1980
|
+
class AutonomousDatabasePropertiesConnectionStringProfileArgs:
|
|
1981
|
+
def __init__(__self__, *,
|
|
1982
|
+
consumer_group: Optional[pulumi.Input[str]] = None,
|
|
1983
|
+
display_name: Optional[pulumi.Input[str]] = None,
|
|
1984
|
+
host_format: Optional[pulumi.Input[str]] = None,
|
|
1985
|
+
is_regional: Optional[pulumi.Input[bool]] = None,
|
|
1986
|
+
protocol: Optional[pulumi.Input[str]] = None,
|
|
1987
|
+
session_mode: Optional[pulumi.Input[str]] = None,
|
|
1988
|
+
syntax_format: Optional[pulumi.Input[str]] = None,
|
|
1989
|
+
tls_authentication: Optional[pulumi.Input[str]] = None,
|
|
1990
|
+
value: Optional[pulumi.Input[str]] = None):
|
|
1991
|
+
"""
|
|
1992
|
+
:param pulumi.Input[str] consumer_group: The current consumer group being used by the connection.
|
|
1993
|
+
Possible values:
|
|
1994
|
+
CONSUMER_GROUP_UNSPECIFIED
|
|
1995
|
+
HIGH
|
|
1996
|
+
MEDIUM
|
|
1997
|
+
LOW
|
|
1998
|
+
TP
|
|
1999
|
+
TPURGENT
|
|
2000
|
+
:param pulumi.Input[str] display_name: The display name for the database connection.
|
|
2001
|
+
:param pulumi.Input[str] host_format: The host name format being currently used in connection string.
|
|
2002
|
+
Possible values:
|
|
2003
|
+
HOST_FORMAT_UNSPECIFIED
|
|
2004
|
+
FQDN
|
|
2005
|
+
IP
|
|
2006
|
+
:param pulumi.Input[bool] is_regional: This field indicates if the connection string is regional and is only
|
|
2007
|
+
applicable for cross-region Data Guard.
|
|
2008
|
+
:param pulumi.Input[str] protocol: The protocol being used by the connection.
|
|
2009
|
+
Possible values:
|
|
2010
|
+
PROTOCOL_UNSPECIFIED
|
|
2011
|
+
TCP
|
|
2012
|
+
TCPS
|
|
2013
|
+
:param pulumi.Input[str] session_mode: The current session mode of the connection.
|
|
2014
|
+
Possible values:
|
|
2015
|
+
SESSION_MODE_UNSPECIFIED
|
|
2016
|
+
DIRECT
|
|
2017
|
+
INDIRECT
|
|
2018
|
+
:param pulumi.Input[str] syntax_format: The syntax of the connection string.
|
|
2019
|
+
Possible values:
|
|
2020
|
+
SYNTAX_FORMAT_UNSPECIFIED
|
|
2021
|
+
LONG
|
|
2022
|
+
EZCONNECT
|
|
2023
|
+
EZCONNECTPLUS
|
|
2024
|
+
:param pulumi.Input[str] tls_authentication: This field indicates the TLS authentication type of the connection.
|
|
2025
|
+
Possible values:
|
|
2026
|
+
TLS_AUTHENTICATION_UNSPECIFIED
|
|
2027
|
+
SERVER
|
|
2028
|
+
MUTUAL
|
|
2029
|
+
:param pulumi.Input[str] value: The value of the connection string.
|
|
2030
|
+
"""
|
|
2031
|
+
if consumer_group is not None:
|
|
2032
|
+
pulumi.set(__self__, "consumer_group", consumer_group)
|
|
2033
|
+
if display_name is not None:
|
|
2034
|
+
pulumi.set(__self__, "display_name", display_name)
|
|
2035
|
+
if host_format is not None:
|
|
2036
|
+
pulumi.set(__self__, "host_format", host_format)
|
|
2037
|
+
if is_regional is not None:
|
|
2038
|
+
pulumi.set(__self__, "is_regional", is_regional)
|
|
2039
|
+
if protocol is not None:
|
|
2040
|
+
pulumi.set(__self__, "protocol", protocol)
|
|
2041
|
+
if session_mode is not None:
|
|
2042
|
+
pulumi.set(__self__, "session_mode", session_mode)
|
|
2043
|
+
if syntax_format is not None:
|
|
2044
|
+
pulumi.set(__self__, "syntax_format", syntax_format)
|
|
2045
|
+
if tls_authentication is not None:
|
|
2046
|
+
pulumi.set(__self__, "tls_authentication", tls_authentication)
|
|
2047
|
+
if value is not None:
|
|
2048
|
+
pulumi.set(__self__, "value", value)
|
|
2049
|
+
|
|
2050
|
+
@property
|
|
2051
|
+
@pulumi.getter(name="consumerGroup")
|
|
2052
|
+
def consumer_group(self) -> Optional[pulumi.Input[str]]:
|
|
2053
|
+
"""
|
|
2054
|
+
The current consumer group being used by the connection.
|
|
2055
|
+
Possible values:
|
|
2056
|
+
CONSUMER_GROUP_UNSPECIFIED
|
|
2057
|
+
HIGH
|
|
2058
|
+
MEDIUM
|
|
2059
|
+
LOW
|
|
2060
|
+
TP
|
|
2061
|
+
TPURGENT
|
|
2062
|
+
"""
|
|
2063
|
+
return pulumi.get(self, "consumer_group")
|
|
2064
|
+
|
|
2065
|
+
@consumer_group.setter
|
|
2066
|
+
def consumer_group(self, value: Optional[pulumi.Input[str]]):
|
|
2067
|
+
pulumi.set(self, "consumer_group", value)
|
|
2068
|
+
|
|
2069
|
+
@property
|
|
2070
|
+
@pulumi.getter(name="displayName")
|
|
2071
|
+
def display_name(self) -> Optional[pulumi.Input[str]]:
|
|
2072
|
+
"""
|
|
2073
|
+
The display name for the database connection.
|
|
2074
|
+
"""
|
|
2075
|
+
return pulumi.get(self, "display_name")
|
|
2076
|
+
|
|
2077
|
+
@display_name.setter
|
|
2078
|
+
def display_name(self, value: Optional[pulumi.Input[str]]):
|
|
2079
|
+
pulumi.set(self, "display_name", value)
|
|
2080
|
+
|
|
2081
|
+
@property
|
|
2082
|
+
@pulumi.getter(name="hostFormat")
|
|
2083
|
+
def host_format(self) -> Optional[pulumi.Input[str]]:
|
|
2084
|
+
"""
|
|
2085
|
+
The host name format being currently used in connection string.
|
|
2086
|
+
Possible values:
|
|
2087
|
+
HOST_FORMAT_UNSPECIFIED
|
|
2088
|
+
FQDN
|
|
2089
|
+
IP
|
|
2090
|
+
"""
|
|
2091
|
+
return pulumi.get(self, "host_format")
|
|
2092
|
+
|
|
2093
|
+
@host_format.setter
|
|
2094
|
+
def host_format(self, value: Optional[pulumi.Input[str]]):
|
|
2095
|
+
pulumi.set(self, "host_format", value)
|
|
2096
|
+
|
|
2097
|
+
@property
|
|
2098
|
+
@pulumi.getter(name="isRegional")
|
|
2099
|
+
def is_regional(self) -> Optional[pulumi.Input[bool]]:
|
|
2100
|
+
"""
|
|
2101
|
+
This field indicates if the connection string is regional and is only
|
|
2102
|
+
applicable for cross-region Data Guard.
|
|
2103
|
+
"""
|
|
2104
|
+
return pulumi.get(self, "is_regional")
|
|
2105
|
+
|
|
2106
|
+
@is_regional.setter
|
|
2107
|
+
def is_regional(self, value: Optional[pulumi.Input[bool]]):
|
|
2108
|
+
pulumi.set(self, "is_regional", value)
|
|
2109
|
+
|
|
2110
|
+
@property
|
|
2111
|
+
@pulumi.getter
|
|
2112
|
+
def protocol(self) -> Optional[pulumi.Input[str]]:
|
|
2113
|
+
"""
|
|
2114
|
+
The protocol being used by the connection.
|
|
2115
|
+
Possible values:
|
|
2116
|
+
PROTOCOL_UNSPECIFIED
|
|
2117
|
+
TCP
|
|
2118
|
+
TCPS
|
|
2119
|
+
"""
|
|
2120
|
+
return pulumi.get(self, "protocol")
|
|
2121
|
+
|
|
2122
|
+
@protocol.setter
|
|
2123
|
+
def protocol(self, value: Optional[pulumi.Input[str]]):
|
|
2124
|
+
pulumi.set(self, "protocol", value)
|
|
2125
|
+
|
|
2126
|
+
@property
|
|
2127
|
+
@pulumi.getter(name="sessionMode")
|
|
2128
|
+
def session_mode(self) -> Optional[pulumi.Input[str]]:
|
|
2129
|
+
"""
|
|
2130
|
+
The current session mode of the connection.
|
|
2131
|
+
Possible values:
|
|
2132
|
+
SESSION_MODE_UNSPECIFIED
|
|
2133
|
+
DIRECT
|
|
2134
|
+
INDIRECT
|
|
2135
|
+
"""
|
|
2136
|
+
return pulumi.get(self, "session_mode")
|
|
2137
|
+
|
|
2138
|
+
@session_mode.setter
|
|
2139
|
+
def session_mode(self, value: Optional[pulumi.Input[str]]):
|
|
2140
|
+
pulumi.set(self, "session_mode", value)
|
|
2141
|
+
|
|
2142
|
+
@property
|
|
2143
|
+
@pulumi.getter(name="syntaxFormat")
|
|
2144
|
+
def syntax_format(self) -> Optional[pulumi.Input[str]]:
|
|
2145
|
+
"""
|
|
2146
|
+
The syntax of the connection string.
|
|
2147
|
+
Possible values:
|
|
2148
|
+
SYNTAX_FORMAT_UNSPECIFIED
|
|
2149
|
+
LONG
|
|
2150
|
+
EZCONNECT
|
|
2151
|
+
EZCONNECTPLUS
|
|
2152
|
+
"""
|
|
2153
|
+
return pulumi.get(self, "syntax_format")
|
|
2154
|
+
|
|
2155
|
+
@syntax_format.setter
|
|
2156
|
+
def syntax_format(self, value: Optional[pulumi.Input[str]]):
|
|
2157
|
+
pulumi.set(self, "syntax_format", value)
|
|
2158
|
+
|
|
2159
|
+
@property
|
|
2160
|
+
@pulumi.getter(name="tlsAuthentication")
|
|
2161
|
+
def tls_authentication(self) -> Optional[pulumi.Input[str]]:
|
|
2162
|
+
"""
|
|
2163
|
+
This field indicates the TLS authentication type of the connection.
|
|
2164
|
+
Possible values:
|
|
2165
|
+
TLS_AUTHENTICATION_UNSPECIFIED
|
|
2166
|
+
SERVER
|
|
2167
|
+
MUTUAL
|
|
2168
|
+
"""
|
|
2169
|
+
return pulumi.get(self, "tls_authentication")
|
|
2170
|
+
|
|
2171
|
+
@tls_authentication.setter
|
|
2172
|
+
def tls_authentication(self, value: Optional[pulumi.Input[str]]):
|
|
2173
|
+
pulumi.set(self, "tls_authentication", value)
|
|
2174
|
+
|
|
2175
|
+
@property
|
|
2176
|
+
@pulumi.getter
|
|
2177
|
+
def value(self) -> Optional[pulumi.Input[str]]:
|
|
2178
|
+
"""
|
|
2179
|
+
The value of the connection string.
|
|
2180
|
+
"""
|
|
2181
|
+
return pulumi.get(self, "value")
|
|
2182
|
+
|
|
2183
|
+
@value.setter
|
|
2184
|
+
def value(self, value: Optional[pulumi.Input[str]]):
|
|
2185
|
+
pulumi.set(self, "value", value)
|
|
2186
|
+
|
|
2187
|
+
|
|
2188
|
+
if not MYPY:
|
|
2189
|
+
class AutonomousDatabasePropertiesConnectionUrlArgsDict(TypedDict):
|
|
2190
|
+
apex_uri: NotRequired[pulumi.Input[str]]
|
|
2191
|
+
"""
|
|
2192
|
+
Oracle Application Express (APEX) URL.
|
|
2193
|
+
"""
|
|
2194
|
+
database_transforms_uri: NotRequired[pulumi.Input[str]]
|
|
2195
|
+
"""
|
|
2196
|
+
The URL of the Database Transforms for the Autonomous Database.
|
|
2197
|
+
"""
|
|
2198
|
+
graph_studio_uri: NotRequired[pulumi.Input[str]]
|
|
2199
|
+
"""
|
|
2200
|
+
The URL of the Graph Studio for the Autonomous Database.
|
|
2201
|
+
"""
|
|
2202
|
+
machine_learning_notebook_uri: NotRequired[pulumi.Input[str]]
|
|
2203
|
+
"""
|
|
2204
|
+
The URL of the Oracle Machine Learning (OML) Notebook for the Autonomous
|
|
2205
|
+
Database.
|
|
2206
|
+
"""
|
|
2207
|
+
machine_learning_user_management_uri: NotRequired[pulumi.Input[str]]
|
|
2208
|
+
"""
|
|
2209
|
+
The URL of Machine Learning user management the Autonomous Database.
|
|
2210
|
+
"""
|
|
2211
|
+
mongo_db_uri: NotRequired[pulumi.Input[str]]
|
|
2212
|
+
"""
|
|
2213
|
+
The URL of the MongoDB API for the Autonomous Database.
|
|
2214
|
+
"""
|
|
2215
|
+
ords_uri: NotRequired[pulumi.Input[str]]
|
|
2216
|
+
"""
|
|
2217
|
+
The Oracle REST Data Services (ORDS) URL of the Web Access for the
|
|
2218
|
+
Autonomous Database.
|
|
2219
|
+
"""
|
|
2220
|
+
sql_dev_web_uri: NotRequired[pulumi.Input[str]]
|
|
2221
|
+
"""
|
|
2222
|
+
The URL of the Oracle SQL Developer Web for the Autonomous Database.
|
|
2223
|
+
"""
|
|
2224
|
+
elif False:
|
|
2225
|
+
AutonomousDatabasePropertiesConnectionUrlArgsDict: TypeAlias = Mapping[str, Any]
|
|
2226
|
+
|
|
2227
|
+
@pulumi.input_type
|
|
2228
|
+
class AutonomousDatabasePropertiesConnectionUrlArgs:
|
|
2229
|
+
def __init__(__self__, *,
|
|
2230
|
+
apex_uri: Optional[pulumi.Input[str]] = None,
|
|
2231
|
+
database_transforms_uri: Optional[pulumi.Input[str]] = None,
|
|
2232
|
+
graph_studio_uri: Optional[pulumi.Input[str]] = None,
|
|
2233
|
+
machine_learning_notebook_uri: Optional[pulumi.Input[str]] = None,
|
|
2234
|
+
machine_learning_user_management_uri: Optional[pulumi.Input[str]] = None,
|
|
2235
|
+
mongo_db_uri: Optional[pulumi.Input[str]] = None,
|
|
2236
|
+
ords_uri: Optional[pulumi.Input[str]] = None,
|
|
2237
|
+
sql_dev_web_uri: Optional[pulumi.Input[str]] = None):
|
|
2238
|
+
"""
|
|
2239
|
+
:param pulumi.Input[str] apex_uri: Oracle Application Express (APEX) URL.
|
|
2240
|
+
:param pulumi.Input[str] database_transforms_uri: The URL of the Database Transforms for the Autonomous Database.
|
|
2241
|
+
:param pulumi.Input[str] graph_studio_uri: The URL of the Graph Studio for the Autonomous Database.
|
|
2242
|
+
:param pulumi.Input[str] machine_learning_notebook_uri: The URL of the Oracle Machine Learning (OML) Notebook for the Autonomous
|
|
2243
|
+
Database.
|
|
2244
|
+
:param pulumi.Input[str] machine_learning_user_management_uri: The URL of Machine Learning user management the Autonomous Database.
|
|
2245
|
+
:param pulumi.Input[str] mongo_db_uri: The URL of the MongoDB API for the Autonomous Database.
|
|
2246
|
+
:param pulumi.Input[str] ords_uri: The Oracle REST Data Services (ORDS) URL of the Web Access for the
|
|
2247
|
+
Autonomous Database.
|
|
2248
|
+
:param pulumi.Input[str] sql_dev_web_uri: The URL of the Oracle SQL Developer Web for the Autonomous Database.
|
|
2249
|
+
"""
|
|
2250
|
+
if apex_uri is not None:
|
|
2251
|
+
pulumi.set(__self__, "apex_uri", apex_uri)
|
|
2252
|
+
if database_transforms_uri is not None:
|
|
2253
|
+
pulumi.set(__self__, "database_transforms_uri", database_transforms_uri)
|
|
2254
|
+
if graph_studio_uri is not None:
|
|
2255
|
+
pulumi.set(__self__, "graph_studio_uri", graph_studio_uri)
|
|
2256
|
+
if machine_learning_notebook_uri is not None:
|
|
2257
|
+
pulumi.set(__self__, "machine_learning_notebook_uri", machine_learning_notebook_uri)
|
|
2258
|
+
if machine_learning_user_management_uri is not None:
|
|
2259
|
+
pulumi.set(__self__, "machine_learning_user_management_uri", machine_learning_user_management_uri)
|
|
2260
|
+
if mongo_db_uri is not None:
|
|
2261
|
+
pulumi.set(__self__, "mongo_db_uri", mongo_db_uri)
|
|
2262
|
+
if ords_uri is not None:
|
|
2263
|
+
pulumi.set(__self__, "ords_uri", ords_uri)
|
|
2264
|
+
if sql_dev_web_uri is not None:
|
|
2265
|
+
pulumi.set(__self__, "sql_dev_web_uri", sql_dev_web_uri)
|
|
2266
|
+
|
|
2267
|
+
@property
|
|
2268
|
+
@pulumi.getter(name="apexUri")
|
|
2269
|
+
def apex_uri(self) -> Optional[pulumi.Input[str]]:
|
|
2270
|
+
"""
|
|
2271
|
+
Oracle Application Express (APEX) URL.
|
|
2272
|
+
"""
|
|
2273
|
+
return pulumi.get(self, "apex_uri")
|
|
2274
|
+
|
|
2275
|
+
@apex_uri.setter
|
|
2276
|
+
def apex_uri(self, value: Optional[pulumi.Input[str]]):
|
|
2277
|
+
pulumi.set(self, "apex_uri", value)
|
|
2278
|
+
|
|
2279
|
+
@property
|
|
2280
|
+
@pulumi.getter(name="databaseTransformsUri")
|
|
2281
|
+
def database_transforms_uri(self) -> Optional[pulumi.Input[str]]:
|
|
2282
|
+
"""
|
|
2283
|
+
The URL of the Database Transforms for the Autonomous Database.
|
|
2284
|
+
"""
|
|
2285
|
+
return pulumi.get(self, "database_transforms_uri")
|
|
2286
|
+
|
|
2287
|
+
@database_transforms_uri.setter
|
|
2288
|
+
def database_transforms_uri(self, value: Optional[pulumi.Input[str]]):
|
|
2289
|
+
pulumi.set(self, "database_transforms_uri", value)
|
|
2290
|
+
|
|
2291
|
+
@property
|
|
2292
|
+
@pulumi.getter(name="graphStudioUri")
|
|
2293
|
+
def graph_studio_uri(self) -> Optional[pulumi.Input[str]]:
|
|
2294
|
+
"""
|
|
2295
|
+
The URL of the Graph Studio for the Autonomous Database.
|
|
2296
|
+
"""
|
|
2297
|
+
return pulumi.get(self, "graph_studio_uri")
|
|
2298
|
+
|
|
2299
|
+
@graph_studio_uri.setter
|
|
2300
|
+
def graph_studio_uri(self, value: Optional[pulumi.Input[str]]):
|
|
2301
|
+
pulumi.set(self, "graph_studio_uri", value)
|
|
2302
|
+
|
|
2303
|
+
@property
|
|
2304
|
+
@pulumi.getter(name="machineLearningNotebookUri")
|
|
2305
|
+
def machine_learning_notebook_uri(self) -> Optional[pulumi.Input[str]]:
|
|
2306
|
+
"""
|
|
2307
|
+
The URL of the Oracle Machine Learning (OML) Notebook for the Autonomous
|
|
2308
|
+
Database.
|
|
2309
|
+
"""
|
|
2310
|
+
return pulumi.get(self, "machine_learning_notebook_uri")
|
|
2311
|
+
|
|
2312
|
+
@machine_learning_notebook_uri.setter
|
|
2313
|
+
def machine_learning_notebook_uri(self, value: Optional[pulumi.Input[str]]):
|
|
2314
|
+
pulumi.set(self, "machine_learning_notebook_uri", value)
|
|
2315
|
+
|
|
2316
|
+
@property
|
|
2317
|
+
@pulumi.getter(name="machineLearningUserManagementUri")
|
|
2318
|
+
def machine_learning_user_management_uri(self) -> Optional[pulumi.Input[str]]:
|
|
2319
|
+
"""
|
|
2320
|
+
The URL of Machine Learning user management the Autonomous Database.
|
|
2321
|
+
"""
|
|
2322
|
+
return pulumi.get(self, "machine_learning_user_management_uri")
|
|
2323
|
+
|
|
2324
|
+
@machine_learning_user_management_uri.setter
|
|
2325
|
+
def machine_learning_user_management_uri(self, value: Optional[pulumi.Input[str]]):
|
|
2326
|
+
pulumi.set(self, "machine_learning_user_management_uri", value)
|
|
2327
|
+
|
|
2328
|
+
@property
|
|
2329
|
+
@pulumi.getter(name="mongoDbUri")
|
|
2330
|
+
def mongo_db_uri(self) -> Optional[pulumi.Input[str]]:
|
|
2331
|
+
"""
|
|
2332
|
+
The URL of the MongoDB API for the Autonomous Database.
|
|
2333
|
+
"""
|
|
2334
|
+
return pulumi.get(self, "mongo_db_uri")
|
|
2335
|
+
|
|
2336
|
+
@mongo_db_uri.setter
|
|
2337
|
+
def mongo_db_uri(self, value: Optional[pulumi.Input[str]]):
|
|
2338
|
+
pulumi.set(self, "mongo_db_uri", value)
|
|
2339
|
+
|
|
2340
|
+
@property
|
|
2341
|
+
@pulumi.getter(name="ordsUri")
|
|
2342
|
+
def ords_uri(self) -> Optional[pulumi.Input[str]]:
|
|
2343
|
+
"""
|
|
2344
|
+
The Oracle REST Data Services (ORDS) URL of the Web Access for the
|
|
2345
|
+
Autonomous Database.
|
|
2346
|
+
"""
|
|
2347
|
+
return pulumi.get(self, "ords_uri")
|
|
2348
|
+
|
|
2349
|
+
@ords_uri.setter
|
|
2350
|
+
def ords_uri(self, value: Optional[pulumi.Input[str]]):
|
|
2351
|
+
pulumi.set(self, "ords_uri", value)
|
|
2352
|
+
|
|
2353
|
+
@property
|
|
2354
|
+
@pulumi.getter(name="sqlDevWebUri")
|
|
2355
|
+
def sql_dev_web_uri(self) -> Optional[pulumi.Input[str]]:
|
|
2356
|
+
"""
|
|
2357
|
+
The URL of the Oracle SQL Developer Web for the Autonomous Database.
|
|
2358
|
+
"""
|
|
2359
|
+
return pulumi.get(self, "sql_dev_web_uri")
|
|
2360
|
+
|
|
2361
|
+
@sql_dev_web_uri.setter
|
|
2362
|
+
def sql_dev_web_uri(self, value: Optional[pulumi.Input[str]]):
|
|
2363
|
+
pulumi.set(self, "sql_dev_web_uri", value)
|
|
2364
|
+
|
|
2365
|
+
|
|
2366
|
+
if not MYPY:
|
|
2367
|
+
class AutonomousDatabasePropertiesCustomerContactArgsDict(TypedDict):
|
|
2368
|
+
email: pulumi.Input[str]
|
|
2369
|
+
"""
|
|
2370
|
+
The email address used by Oracle to send notifications regarding databases
|
|
2371
|
+
and infrastructure.
|
|
2372
|
+
|
|
2373
|
+
<a name="nested_apex_details"></a>The `apex_details` block contains:
|
|
2374
|
+
"""
|
|
2375
|
+
elif False:
|
|
2376
|
+
AutonomousDatabasePropertiesCustomerContactArgsDict: TypeAlias = Mapping[str, Any]
|
|
2377
|
+
|
|
2378
|
+
@pulumi.input_type
|
|
2379
|
+
class AutonomousDatabasePropertiesCustomerContactArgs:
|
|
2380
|
+
def __init__(__self__, *,
|
|
2381
|
+
email: pulumi.Input[str]):
|
|
2382
|
+
"""
|
|
2383
|
+
:param pulumi.Input[str] email: The email address used by Oracle to send notifications regarding databases
|
|
2384
|
+
and infrastructure.
|
|
2385
|
+
|
|
2386
|
+
<a name="nested_apex_details"></a>The `apex_details` block contains:
|
|
2387
|
+
"""
|
|
2388
|
+
pulumi.set(__self__, "email", email)
|
|
2389
|
+
|
|
2390
|
+
@property
|
|
2391
|
+
@pulumi.getter
|
|
2392
|
+
def email(self) -> pulumi.Input[str]:
|
|
2393
|
+
"""
|
|
2394
|
+
The email address used by Oracle to send notifications regarding databases
|
|
2395
|
+
and infrastructure.
|
|
2396
|
+
|
|
2397
|
+
<a name="nested_apex_details"></a>The `apex_details` block contains:
|
|
2398
|
+
"""
|
|
2399
|
+
return pulumi.get(self, "email")
|
|
2400
|
+
|
|
2401
|
+
@email.setter
|
|
2402
|
+
def email(self, value: pulumi.Input[str]):
|
|
2403
|
+
pulumi.set(self, "email", value)
|
|
2404
|
+
|
|
2405
|
+
|
|
2406
|
+
if not MYPY:
|
|
2407
|
+
class AutonomousDatabasePropertiesLocalStandbyDbArgsDict(TypedDict):
|
|
2408
|
+
data_guard_role_changed_time: NotRequired[pulumi.Input[str]]
|
|
2409
|
+
"""
|
|
2410
|
+
The date and time the Autonomous Data Guard role was switched for the
|
|
2411
|
+
standby Autonomous Database.
|
|
2412
|
+
"""
|
|
2413
|
+
disaster_recovery_role_changed_time: NotRequired[pulumi.Input[str]]
|
|
2414
|
+
"""
|
|
2415
|
+
The date and time the Disaster Recovery role was switched for the standby
|
|
2416
|
+
Autonomous Database.
|
|
2417
|
+
"""
|
|
2418
|
+
lag_time_duration: NotRequired[pulumi.Input[str]]
|
|
2419
|
+
"""
|
|
2420
|
+
The amount of time, in seconds, that the data of the standby database lags
|
|
2421
|
+
in comparison to the data of the primary database.
|
|
2422
|
+
"""
|
|
2423
|
+
lifecycle_details: NotRequired[pulumi.Input[str]]
|
|
2424
|
+
"""
|
|
2425
|
+
The additional details about the current lifecycle state of the
|
|
2426
|
+
Autonomous Database.
|
|
2427
|
+
"""
|
|
2428
|
+
state: NotRequired[pulumi.Input[str]]
|
|
2429
|
+
"""
|
|
2430
|
+
Possible values:
|
|
2431
|
+
STATE_UNSPECIFIED
|
|
2432
|
+
PROVISIONING
|
|
2433
|
+
AVAILABLE
|
|
2434
|
+
STOPPING
|
|
2435
|
+
STOPPED
|
|
2436
|
+
STARTING
|
|
2437
|
+
TERMINATING
|
|
2438
|
+
TERMINATED
|
|
2439
|
+
UNAVAILABLE
|
|
2440
|
+
RESTORE_IN_PROGRESS
|
|
2441
|
+
RESTORE_FAILED
|
|
2442
|
+
BACKUP_IN_PROGRESS
|
|
2443
|
+
SCALE_IN_PROGRESS
|
|
2444
|
+
AVAILABLE_NEEDS_ATTENTION
|
|
2445
|
+
UPDATING
|
|
2446
|
+
MAINTENANCE_IN_PROGRESS
|
|
2447
|
+
RESTARTING
|
|
2448
|
+
RECREATING
|
|
2449
|
+
ROLE_CHANGE_IN_PROGRESS
|
|
2450
|
+
UPGRADING
|
|
2451
|
+
INACCESSIBLE
|
|
2452
|
+
STANDBY
|
|
2453
|
+
"""
|
|
2454
|
+
elif False:
|
|
2455
|
+
AutonomousDatabasePropertiesLocalStandbyDbArgsDict: TypeAlias = Mapping[str, Any]
|
|
2456
|
+
|
|
2457
|
+
@pulumi.input_type
|
|
2458
|
+
class AutonomousDatabasePropertiesLocalStandbyDbArgs:
|
|
2459
|
+
def __init__(__self__, *,
|
|
2460
|
+
data_guard_role_changed_time: Optional[pulumi.Input[str]] = None,
|
|
2461
|
+
disaster_recovery_role_changed_time: Optional[pulumi.Input[str]] = None,
|
|
2462
|
+
lag_time_duration: Optional[pulumi.Input[str]] = None,
|
|
2463
|
+
lifecycle_details: Optional[pulumi.Input[str]] = None,
|
|
2464
|
+
state: Optional[pulumi.Input[str]] = None):
|
|
2465
|
+
"""
|
|
2466
|
+
:param pulumi.Input[str] data_guard_role_changed_time: The date and time the Autonomous Data Guard role was switched for the
|
|
2467
|
+
standby Autonomous Database.
|
|
2468
|
+
:param pulumi.Input[str] disaster_recovery_role_changed_time: The date and time the Disaster Recovery role was switched for the standby
|
|
2469
|
+
Autonomous Database.
|
|
2470
|
+
:param pulumi.Input[str] lag_time_duration: The amount of time, in seconds, that the data of the standby database lags
|
|
2471
|
+
in comparison to the data of the primary database.
|
|
2472
|
+
:param pulumi.Input[str] lifecycle_details: The additional details about the current lifecycle state of the
|
|
2473
|
+
Autonomous Database.
|
|
2474
|
+
:param pulumi.Input[str] state: Possible values:
|
|
2475
|
+
STATE_UNSPECIFIED
|
|
2476
|
+
PROVISIONING
|
|
2477
|
+
AVAILABLE
|
|
2478
|
+
STOPPING
|
|
2479
|
+
STOPPED
|
|
2480
|
+
STARTING
|
|
2481
|
+
TERMINATING
|
|
2482
|
+
TERMINATED
|
|
2483
|
+
UNAVAILABLE
|
|
2484
|
+
RESTORE_IN_PROGRESS
|
|
2485
|
+
RESTORE_FAILED
|
|
2486
|
+
BACKUP_IN_PROGRESS
|
|
2487
|
+
SCALE_IN_PROGRESS
|
|
2488
|
+
AVAILABLE_NEEDS_ATTENTION
|
|
2489
|
+
UPDATING
|
|
2490
|
+
MAINTENANCE_IN_PROGRESS
|
|
2491
|
+
RESTARTING
|
|
2492
|
+
RECREATING
|
|
2493
|
+
ROLE_CHANGE_IN_PROGRESS
|
|
2494
|
+
UPGRADING
|
|
2495
|
+
INACCESSIBLE
|
|
2496
|
+
STANDBY
|
|
2497
|
+
"""
|
|
2498
|
+
if data_guard_role_changed_time is not None:
|
|
2499
|
+
pulumi.set(__self__, "data_guard_role_changed_time", data_guard_role_changed_time)
|
|
2500
|
+
if disaster_recovery_role_changed_time is not None:
|
|
2501
|
+
pulumi.set(__self__, "disaster_recovery_role_changed_time", disaster_recovery_role_changed_time)
|
|
2502
|
+
if lag_time_duration is not None:
|
|
2503
|
+
pulumi.set(__self__, "lag_time_duration", lag_time_duration)
|
|
2504
|
+
if lifecycle_details is not None:
|
|
2505
|
+
pulumi.set(__self__, "lifecycle_details", lifecycle_details)
|
|
2506
|
+
if state is not None:
|
|
2507
|
+
pulumi.set(__self__, "state", state)
|
|
2508
|
+
|
|
2509
|
+
@property
|
|
2510
|
+
@pulumi.getter(name="dataGuardRoleChangedTime")
|
|
2511
|
+
def data_guard_role_changed_time(self) -> Optional[pulumi.Input[str]]:
|
|
2512
|
+
"""
|
|
2513
|
+
The date and time the Autonomous Data Guard role was switched for the
|
|
2514
|
+
standby Autonomous Database.
|
|
2515
|
+
"""
|
|
2516
|
+
return pulumi.get(self, "data_guard_role_changed_time")
|
|
2517
|
+
|
|
2518
|
+
@data_guard_role_changed_time.setter
|
|
2519
|
+
def data_guard_role_changed_time(self, value: Optional[pulumi.Input[str]]):
|
|
2520
|
+
pulumi.set(self, "data_guard_role_changed_time", value)
|
|
2521
|
+
|
|
2522
|
+
@property
|
|
2523
|
+
@pulumi.getter(name="disasterRecoveryRoleChangedTime")
|
|
2524
|
+
def disaster_recovery_role_changed_time(self) -> Optional[pulumi.Input[str]]:
|
|
2525
|
+
"""
|
|
2526
|
+
The date and time the Disaster Recovery role was switched for the standby
|
|
2527
|
+
Autonomous Database.
|
|
2528
|
+
"""
|
|
2529
|
+
return pulumi.get(self, "disaster_recovery_role_changed_time")
|
|
2530
|
+
|
|
2531
|
+
@disaster_recovery_role_changed_time.setter
|
|
2532
|
+
def disaster_recovery_role_changed_time(self, value: Optional[pulumi.Input[str]]):
|
|
2533
|
+
pulumi.set(self, "disaster_recovery_role_changed_time", value)
|
|
2534
|
+
|
|
2535
|
+
@property
|
|
2536
|
+
@pulumi.getter(name="lagTimeDuration")
|
|
2537
|
+
def lag_time_duration(self) -> Optional[pulumi.Input[str]]:
|
|
2538
|
+
"""
|
|
2539
|
+
The amount of time, in seconds, that the data of the standby database lags
|
|
2540
|
+
in comparison to the data of the primary database.
|
|
2541
|
+
"""
|
|
2542
|
+
return pulumi.get(self, "lag_time_duration")
|
|
2543
|
+
|
|
2544
|
+
@lag_time_duration.setter
|
|
2545
|
+
def lag_time_duration(self, value: Optional[pulumi.Input[str]]):
|
|
2546
|
+
pulumi.set(self, "lag_time_duration", value)
|
|
2547
|
+
|
|
2548
|
+
@property
|
|
2549
|
+
@pulumi.getter(name="lifecycleDetails")
|
|
2550
|
+
def lifecycle_details(self) -> Optional[pulumi.Input[str]]:
|
|
2551
|
+
"""
|
|
2552
|
+
The additional details about the current lifecycle state of the
|
|
2553
|
+
Autonomous Database.
|
|
2554
|
+
"""
|
|
2555
|
+
return pulumi.get(self, "lifecycle_details")
|
|
2556
|
+
|
|
2557
|
+
@lifecycle_details.setter
|
|
2558
|
+
def lifecycle_details(self, value: Optional[pulumi.Input[str]]):
|
|
2559
|
+
pulumi.set(self, "lifecycle_details", value)
|
|
2560
|
+
|
|
2561
|
+
@property
|
|
2562
|
+
@pulumi.getter
|
|
2563
|
+
def state(self) -> Optional[pulumi.Input[str]]:
|
|
2564
|
+
"""
|
|
2565
|
+
Possible values:
|
|
2566
|
+
STATE_UNSPECIFIED
|
|
2567
|
+
PROVISIONING
|
|
2568
|
+
AVAILABLE
|
|
2569
|
+
STOPPING
|
|
2570
|
+
STOPPED
|
|
2571
|
+
STARTING
|
|
2572
|
+
TERMINATING
|
|
2573
|
+
TERMINATED
|
|
2574
|
+
UNAVAILABLE
|
|
2575
|
+
RESTORE_IN_PROGRESS
|
|
2576
|
+
RESTORE_FAILED
|
|
2577
|
+
BACKUP_IN_PROGRESS
|
|
2578
|
+
SCALE_IN_PROGRESS
|
|
2579
|
+
AVAILABLE_NEEDS_ATTENTION
|
|
2580
|
+
UPDATING
|
|
2581
|
+
MAINTENANCE_IN_PROGRESS
|
|
2582
|
+
RESTARTING
|
|
2583
|
+
RECREATING
|
|
2584
|
+
ROLE_CHANGE_IN_PROGRESS
|
|
2585
|
+
UPGRADING
|
|
2586
|
+
INACCESSIBLE
|
|
2587
|
+
STANDBY
|
|
2588
|
+
"""
|
|
2589
|
+
return pulumi.get(self, "state")
|
|
2590
|
+
|
|
2591
|
+
@state.setter
|
|
2592
|
+
def state(self, value: Optional[pulumi.Input[str]]):
|
|
2593
|
+
pulumi.set(self, "state", value)
|
|
2594
|
+
|
|
2595
|
+
|
|
2596
|
+
if not MYPY:
|
|
2597
|
+
class AutonomousDatabasePropertiesScheduledOperationDetailArgsDict(TypedDict):
|
|
2598
|
+
day_of_week: NotRequired[pulumi.Input[str]]
|
|
2599
|
+
"""
|
|
2600
|
+
Possible values:
|
|
2601
|
+
DAY_OF_WEEK_UNSPECIFIED
|
|
2602
|
+
MONDAY
|
|
2603
|
+
TUESDAY
|
|
2604
|
+
WEDNESDAY
|
|
2605
|
+
THURSDAY
|
|
2606
|
+
FRIDAY
|
|
2607
|
+
SATURDAY
|
|
2608
|
+
SUNDAY
|
|
2609
|
+
"""
|
|
2610
|
+
start_times: NotRequired[pulumi.Input[Sequence[pulumi.Input['AutonomousDatabasePropertiesScheduledOperationDetailStartTimeArgsDict']]]]
|
|
2611
|
+
"""
|
|
2612
|
+
Represents a time of day. The date and time zone are either not significant
|
|
2613
|
+
or are specified elsewhere. An API may choose to allow leap seconds. Related
|
|
2614
|
+
types are google.type.Date and 'google.protobuf.Timestamp'.
|
|
2615
|
+
"""
|
|
2616
|
+
stop_times: NotRequired[pulumi.Input[Sequence[pulumi.Input['AutonomousDatabasePropertiesScheduledOperationDetailStopTimeArgsDict']]]]
|
|
2617
|
+
"""
|
|
2618
|
+
Represents a time of day. The date and time zone are either not significant
|
|
2619
|
+
or are specified elsewhere. An API may choose to allow leap seconds. Related
|
|
2620
|
+
types are google.type.Date and 'google.protobuf.Timestamp'.
|
|
2621
|
+
"""
|
|
2622
|
+
elif False:
|
|
2623
|
+
AutonomousDatabasePropertiesScheduledOperationDetailArgsDict: TypeAlias = Mapping[str, Any]
|
|
2624
|
+
|
|
2625
|
+
@pulumi.input_type
|
|
2626
|
+
class AutonomousDatabasePropertiesScheduledOperationDetailArgs:
|
|
2627
|
+
def __init__(__self__, *,
|
|
2628
|
+
day_of_week: Optional[pulumi.Input[str]] = None,
|
|
2629
|
+
start_times: Optional[pulumi.Input[Sequence[pulumi.Input['AutonomousDatabasePropertiesScheduledOperationDetailStartTimeArgs']]]] = None,
|
|
2630
|
+
stop_times: Optional[pulumi.Input[Sequence[pulumi.Input['AutonomousDatabasePropertiesScheduledOperationDetailStopTimeArgs']]]] = None):
|
|
2631
|
+
"""
|
|
2632
|
+
:param pulumi.Input[str] day_of_week: Possible values:
|
|
2633
|
+
DAY_OF_WEEK_UNSPECIFIED
|
|
2634
|
+
MONDAY
|
|
2635
|
+
TUESDAY
|
|
2636
|
+
WEDNESDAY
|
|
2637
|
+
THURSDAY
|
|
2638
|
+
FRIDAY
|
|
2639
|
+
SATURDAY
|
|
2640
|
+
SUNDAY
|
|
2641
|
+
:param pulumi.Input[Sequence[pulumi.Input['AutonomousDatabasePropertiesScheduledOperationDetailStartTimeArgs']]] start_times: Represents a time of day. The date and time zone are either not significant
|
|
2642
|
+
or are specified elsewhere. An API may choose to allow leap seconds. Related
|
|
2643
|
+
types are google.type.Date and 'google.protobuf.Timestamp'.
|
|
2644
|
+
:param pulumi.Input[Sequence[pulumi.Input['AutonomousDatabasePropertiesScheduledOperationDetailStopTimeArgs']]] stop_times: Represents a time of day. The date and time zone are either not significant
|
|
2645
|
+
or are specified elsewhere. An API may choose to allow leap seconds. Related
|
|
2646
|
+
types are google.type.Date and 'google.protobuf.Timestamp'.
|
|
2647
|
+
"""
|
|
2648
|
+
if day_of_week is not None:
|
|
2649
|
+
pulumi.set(__self__, "day_of_week", day_of_week)
|
|
2650
|
+
if start_times is not None:
|
|
2651
|
+
pulumi.set(__self__, "start_times", start_times)
|
|
2652
|
+
if stop_times is not None:
|
|
2653
|
+
pulumi.set(__self__, "stop_times", stop_times)
|
|
2654
|
+
|
|
2655
|
+
@property
|
|
2656
|
+
@pulumi.getter(name="dayOfWeek")
|
|
2657
|
+
def day_of_week(self) -> Optional[pulumi.Input[str]]:
|
|
2658
|
+
"""
|
|
2659
|
+
Possible values:
|
|
2660
|
+
DAY_OF_WEEK_UNSPECIFIED
|
|
2661
|
+
MONDAY
|
|
2662
|
+
TUESDAY
|
|
2663
|
+
WEDNESDAY
|
|
2664
|
+
THURSDAY
|
|
2665
|
+
FRIDAY
|
|
2666
|
+
SATURDAY
|
|
2667
|
+
SUNDAY
|
|
2668
|
+
"""
|
|
2669
|
+
return pulumi.get(self, "day_of_week")
|
|
2670
|
+
|
|
2671
|
+
@day_of_week.setter
|
|
2672
|
+
def day_of_week(self, value: Optional[pulumi.Input[str]]):
|
|
2673
|
+
pulumi.set(self, "day_of_week", value)
|
|
2674
|
+
|
|
2675
|
+
@property
|
|
2676
|
+
@pulumi.getter(name="startTimes")
|
|
2677
|
+
def start_times(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['AutonomousDatabasePropertiesScheduledOperationDetailStartTimeArgs']]]]:
|
|
2678
|
+
"""
|
|
2679
|
+
Represents a time of day. The date and time zone are either not significant
|
|
2680
|
+
or are specified elsewhere. An API may choose to allow leap seconds. Related
|
|
2681
|
+
types are google.type.Date and 'google.protobuf.Timestamp'.
|
|
2682
|
+
"""
|
|
2683
|
+
return pulumi.get(self, "start_times")
|
|
2684
|
+
|
|
2685
|
+
@start_times.setter
|
|
2686
|
+
def start_times(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['AutonomousDatabasePropertiesScheduledOperationDetailStartTimeArgs']]]]):
|
|
2687
|
+
pulumi.set(self, "start_times", value)
|
|
2688
|
+
|
|
2689
|
+
@property
|
|
2690
|
+
@pulumi.getter(name="stopTimes")
|
|
2691
|
+
def stop_times(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['AutonomousDatabasePropertiesScheduledOperationDetailStopTimeArgs']]]]:
|
|
2692
|
+
"""
|
|
2693
|
+
Represents a time of day. The date and time zone are either not significant
|
|
2694
|
+
or are specified elsewhere. An API may choose to allow leap seconds. Related
|
|
2695
|
+
types are google.type.Date and 'google.protobuf.Timestamp'.
|
|
2696
|
+
"""
|
|
2697
|
+
return pulumi.get(self, "stop_times")
|
|
2698
|
+
|
|
2699
|
+
@stop_times.setter
|
|
2700
|
+
def stop_times(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['AutonomousDatabasePropertiesScheduledOperationDetailStopTimeArgs']]]]):
|
|
2701
|
+
pulumi.set(self, "stop_times", value)
|
|
2702
|
+
|
|
2703
|
+
|
|
2704
|
+
if not MYPY:
|
|
2705
|
+
class AutonomousDatabasePropertiesScheduledOperationDetailStartTimeArgsDict(TypedDict):
|
|
2706
|
+
hours: NotRequired[pulumi.Input[int]]
|
|
2707
|
+
"""
|
|
2708
|
+
Hours of day in 24 hour format. Should be from 0 to 23. An API may choose
|
|
2709
|
+
to allow the value "24:00:00" for scenarios like business closing time.
|
|
2710
|
+
"""
|
|
2711
|
+
minutes: NotRequired[pulumi.Input[int]]
|
|
2712
|
+
"""
|
|
2713
|
+
Minutes of hour of day. Must be from 0 to 59.
|
|
2714
|
+
"""
|
|
2715
|
+
nanos: NotRequired[pulumi.Input[int]]
|
|
2716
|
+
"""
|
|
2717
|
+
Fractions of seconds in nanoseconds. Must be from 0 to 999,999,999.
|
|
2718
|
+
"""
|
|
2719
|
+
seconds: NotRequired[pulumi.Input[int]]
|
|
2720
|
+
"""
|
|
2721
|
+
Seconds of minutes of the time. Must normally be from 0 to 59. An API may
|
|
2722
|
+
allow the value 60 if it allows leap-seconds.
|
|
2723
|
+
"""
|
|
2724
|
+
elif False:
|
|
2725
|
+
AutonomousDatabasePropertiesScheduledOperationDetailStartTimeArgsDict: TypeAlias = Mapping[str, Any]
|
|
2726
|
+
|
|
2727
|
+
@pulumi.input_type
|
|
2728
|
+
class AutonomousDatabasePropertiesScheduledOperationDetailStartTimeArgs:
|
|
2729
|
+
def __init__(__self__, *,
|
|
2730
|
+
hours: Optional[pulumi.Input[int]] = None,
|
|
2731
|
+
minutes: Optional[pulumi.Input[int]] = None,
|
|
2732
|
+
nanos: Optional[pulumi.Input[int]] = None,
|
|
2733
|
+
seconds: Optional[pulumi.Input[int]] = None):
|
|
2734
|
+
"""
|
|
2735
|
+
:param pulumi.Input[int] hours: Hours of day in 24 hour format. Should be from 0 to 23. An API may choose
|
|
2736
|
+
to allow the value "24:00:00" for scenarios like business closing time.
|
|
2737
|
+
:param pulumi.Input[int] minutes: Minutes of hour of day. Must be from 0 to 59.
|
|
2738
|
+
:param pulumi.Input[int] nanos: Fractions of seconds in nanoseconds. Must be from 0 to 999,999,999.
|
|
2739
|
+
:param pulumi.Input[int] seconds: Seconds of minutes of the time. Must normally be from 0 to 59. An API may
|
|
2740
|
+
allow the value 60 if it allows leap-seconds.
|
|
2741
|
+
"""
|
|
2742
|
+
if hours is not None:
|
|
2743
|
+
pulumi.set(__self__, "hours", hours)
|
|
2744
|
+
if minutes is not None:
|
|
2745
|
+
pulumi.set(__self__, "minutes", minutes)
|
|
2746
|
+
if nanos is not None:
|
|
2747
|
+
pulumi.set(__self__, "nanos", nanos)
|
|
2748
|
+
if seconds is not None:
|
|
2749
|
+
pulumi.set(__self__, "seconds", seconds)
|
|
2750
|
+
|
|
2751
|
+
@property
|
|
2752
|
+
@pulumi.getter
|
|
2753
|
+
def hours(self) -> Optional[pulumi.Input[int]]:
|
|
2754
|
+
"""
|
|
2755
|
+
Hours of day in 24 hour format. Should be from 0 to 23. An API may choose
|
|
2756
|
+
to allow the value "24:00:00" for scenarios like business closing time.
|
|
2757
|
+
"""
|
|
2758
|
+
return pulumi.get(self, "hours")
|
|
2759
|
+
|
|
2760
|
+
@hours.setter
|
|
2761
|
+
def hours(self, value: Optional[pulumi.Input[int]]):
|
|
2762
|
+
pulumi.set(self, "hours", value)
|
|
2763
|
+
|
|
2764
|
+
@property
|
|
2765
|
+
@pulumi.getter
|
|
2766
|
+
def minutes(self) -> Optional[pulumi.Input[int]]:
|
|
2767
|
+
"""
|
|
2768
|
+
Minutes of hour of day. Must be from 0 to 59.
|
|
2769
|
+
"""
|
|
2770
|
+
return pulumi.get(self, "minutes")
|
|
2771
|
+
|
|
2772
|
+
@minutes.setter
|
|
2773
|
+
def minutes(self, value: Optional[pulumi.Input[int]]):
|
|
2774
|
+
pulumi.set(self, "minutes", value)
|
|
2775
|
+
|
|
2776
|
+
@property
|
|
2777
|
+
@pulumi.getter
|
|
2778
|
+
def nanos(self) -> Optional[pulumi.Input[int]]:
|
|
2779
|
+
"""
|
|
2780
|
+
Fractions of seconds in nanoseconds. Must be from 0 to 999,999,999.
|
|
2781
|
+
"""
|
|
2782
|
+
return pulumi.get(self, "nanos")
|
|
2783
|
+
|
|
2784
|
+
@nanos.setter
|
|
2785
|
+
def nanos(self, value: Optional[pulumi.Input[int]]):
|
|
2786
|
+
pulumi.set(self, "nanos", value)
|
|
2787
|
+
|
|
2788
|
+
@property
|
|
2789
|
+
@pulumi.getter
|
|
2790
|
+
def seconds(self) -> Optional[pulumi.Input[int]]:
|
|
2791
|
+
"""
|
|
2792
|
+
Seconds of minutes of the time. Must normally be from 0 to 59. An API may
|
|
2793
|
+
allow the value 60 if it allows leap-seconds.
|
|
2794
|
+
"""
|
|
2795
|
+
return pulumi.get(self, "seconds")
|
|
2796
|
+
|
|
2797
|
+
@seconds.setter
|
|
2798
|
+
def seconds(self, value: Optional[pulumi.Input[int]]):
|
|
2799
|
+
pulumi.set(self, "seconds", value)
|
|
2800
|
+
|
|
2801
|
+
|
|
2802
|
+
if not MYPY:
|
|
2803
|
+
class AutonomousDatabasePropertiesScheduledOperationDetailStopTimeArgsDict(TypedDict):
|
|
2804
|
+
hours: NotRequired[pulumi.Input[int]]
|
|
2805
|
+
"""
|
|
2806
|
+
Hours of day in 24 hour format. Should be from 0 to 23. An API may choose
|
|
2807
|
+
to allow the value "24:00:00" for scenarios like business closing time.
|
|
2808
|
+
"""
|
|
2809
|
+
minutes: NotRequired[pulumi.Input[int]]
|
|
2810
|
+
"""
|
|
2811
|
+
Minutes of hour of day. Must be from 0 to 59.
|
|
2812
|
+
"""
|
|
2813
|
+
nanos: NotRequired[pulumi.Input[int]]
|
|
2814
|
+
"""
|
|
2815
|
+
Fractions of seconds in nanoseconds. Must be from 0 to 999,999,999.
|
|
2816
|
+
"""
|
|
2817
|
+
seconds: NotRequired[pulumi.Input[int]]
|
|
2818
|
+
"""
|
|
2819
|
+
Seconds of minutes of the time. Must normally be from 0 to 59. An API may
|
|
2820
|
+
allow the value 60 if it allows leap-seconds.
|
|
2821
|
+
"""
|
|
2822
|
+
elif False:
|
|
2823
|
+
AutonomousDatabasePropertiesScheduledOperationDetailStopTimeArgsDict: TypeAlias = Mapping[str, Any]
|
|
2824
|
+
|
|
2825
|
+
@pulumi.input_type
|
|
2826
|
+
class AutonomousDatabasePropertiesScheduledOperationDetailStopTimeArgs:
|
|
2827
|
+
def __init__(__self__, *,
|
|
2828
|
+
hours: Optional[pulumi.Input[int]] = None,
|
|
2829
|
+
minutes: Optional[pulumi.Input[int]] = None,
|
|
2830
|
+
nanos: Optional[pulumi.Input[int]] = None,
|
|
2831
|
+
seconds: Optional[pulumi.Input[int]] = None):
|
|
2832
|
+
"""
|
|
2833
|
+
:param pulumi.Input[int] hours: Hours of day in 24 hour format. Should be from 0 to 23. An API may choose
|
|
2834
|
+
to allow the value "24:00:00" for scenarios like business closing time.
|
|
2835
|
+
:param pulumi.Input[int] minutes: Minutes of hour of day. Must be from 0 to 59.
|
|
2836
|
+
:param pulumi.Input[int] nanos: Fractions of seconds in nanoseconds. Must be from 0 to 999,999,999.
|
|
2837
|
+
:param pulumi.Input[int] seconds: Seconds of minutes of the time. Must normally be from 0 to 59. An API may
|
|
2838
|
+
allow the value 60 if it allows leap-seconds.
|
|
2839
|
+
"""
|
|
2840
|
+
if hours is not None:
|
|
2841
|
+
pulumi.set(__self__, "hours", hours)
|
|
2842
|
+
if minutes is not None:
|
|
2843
|
+
pulumi.set(__self__, "minutes", minutes)
|
|
2844
|
+
if nanos is not None:
|
|
2845
|
+
pulumi.set(__self__, "nanos", nanos)
|
|
2846
|
+
if seconds is not None:
|
|
2847
|
+
pulumi.set(__self__, "seconds", seconds)
|
|
2848
|
+
|
|
2849
|
+
@property
|
|
2850
|
+
@pulumi.getter
|
|
2851
|
+
def hours(self) -> Optional[pulumi.Input[int]]:
|
|
2852
|
+
"""
|
|
2853
|
+
Hours of day in 24 hour format. Should be from 0 to 23. An API may choose
|
|
2854
|
+
to allow the value "24:00:00" for scenarios like business closing time.
|
|
2855
|
+
"""
|
|
2856
|
+
return pulumi.get(self, "hours")
|
|
2857
|
+
|
|
2858
|
+
@hours.setter
|
|
2859
|
+
def hours(self, value: Optional[pulumi.Input[int]]):
|
|
2860
|
+
pulumi.set(self, "hours", value)
|
|
2861
|
+
|
|
2862
|
+
@property
|
|
2863
|
+
@pulumi.getter
|
|
2864
|
+
def minutes(self) -> Optional[pulumi.Input[int]]:
|
|
2865
|
+
"""
|
|
2866
|
+
Minutes of hour of day. Must be from 0 to 59.
|
|
2867
|
+
"""
|
|
2868
|
+
return pulumi.get(self, "minutes")
|
|
2869
|
+
|
|
2870
|
+
@minutes.setter
|
|
2871
|
+
def minutes(self, value: Optional[pulumi.Input[int]]):
|
|
2872
|
+
pulumi.set(self, "minutes", value)
|
|
2873
|
+
|
|
2874
|
+
@property
|
|
2875
|
+
@pulumi.getter
|
|
2876
|
+
def nanos(self) -> Optional[pulumi.Input[int]]:
|
|
2877
|
+
"""
|
|
2878
|
+
Fractions of seconds in nanoseconds. Must be from 0 to 999,999,999.
|
|
2879
|
+
"""
|
|
2880
|
+
return pulumi.get(self, "nanos")
|
|
2881
|
+
|
|
2882
|
+
@nanos.setter
|
|
2883
|
+
def nanos(self, value: Optional[pulumi.Input[int]]):
|
|
2884
|
+
pulumi.set(self, "nanos", value)
|
|
2885
|
+
|
|
2886
|
+
@property
|
|
2887
|
+
@pulumi.getter
|
|
2888
|
+
def seconds(self) -> Optional[pulumi.Input[int]]:
|
|
2889
|
+
"""
|
|
2890
|
+
Seconds of minutes of the time. Must normally be from 0 to 59. An API may
|
|
2891
|
+
allow the value 60 if it allows leap-seconds.
|
|
2892
|
+
"""
|
|
2893
|
+
return pulumi.get(self, "seconds")
|
|
2894
|
+
|
|
2895
|
+
@seconds.setter
|
|
2896
|
+
def seconds(self, value: Optional[pulumi.Input[int]]):
|
|
2897
|
+
pulumi.set(self, "seconds", value)
|
|
2898
|
+
|
|
2899
|
+
|
|
2900
|
+
if not MYPY:
|
|
2901
|
+
class CloudExadataInfrastructurePropertiesArgsDict(TypedDict):
|
|
2902
|
+
shape: pulumi.Input[str]
|
|
2903
|
+
"""
|
|
2904
|
+
The shape of the Exadata Infrastructure. The shape determines the
|
|
2905
|
+
amount of CPU, storage, and memory resources allocated to the instance.
|
|
2906
|
+
"""
|
|
2907
|
+
activated_storage_count: NotRequired[pulumi.Input[int]]
|
|
2908
|
+
"""
|
|
2909
|
+
(Output)
|
|
2910
|
+
The requested number of additional storage servers activated for the
|
|
2911
|
+
Exadata Infrastructure.
|
|
2912
|
+
"""
|
|
2913
|
+
additional_storage_count: NotRequired[pulumi.Input[int]]
|
|
2914
|
+
"""
|
|
2915
|
+
(Output)
|
|
2916
|
+
The requested number of additional storage servers for the Exadata
|
|
2917
|
+
Infrastructure.
|
|
2918
|
+
"""
|
|
2919
|
+
available_storage_size_gb: NotRequired[pulumi.Input[int]]
|
|
2920
|
+
"""
|
|
2921
|
+
(Output)
|
|
2922
|
+
The available storage can be allocated to the Exadata Infrastructure
|
|
2923
|
+
resource, in gigabytes (GB).
|
|
2924
|
+
"""
|
|
2925
|
+
compute_count: NotRequired[pulumi.Input[int]]
|
|
2926
|
+
"""
|
|
2927
|
+
The number of compute servers for the Exadata Infrastructure.
|
|
2928
|
+
"""
|
|
2929
|
+
cpu_count: NotRequired[pulumi.Input[int]]
|
|
2930
|
+
"""
|
|
2931
|
+
(Output)
|
|
2932
|
+
The number of enabled CPU cores.
|
|
2933
|
+
"""
|
|
2934
|
+
customer_contacts: NotRequired[pulumi.Input[Sequence[pulumi.Input['CloudExadataInfrastructurePropertiesCustomerContactArgsDict']]]]
|
|
2935
|
+
"""
|
|
2936
|
+
The list of customer contacts.
|
|
2937
|
+
Structure is documented below.
|
|
2938
|
+
"""
|
|
2939
|
+
data_storage_size_tb: NotRequired[pulumi.Input[float]]
|
|
2940
|
+
"""
|
|
2941
|
+
(Output)
|
|
2942
|
+
Size, in terabytes, of the DATA disk group.
|
|
2943
|
+
"""
|
|
2944
|
+
db_node_storage_size_gb: NotRequired[pulumi.Input[int]]
|
|
2945
|
+
"""
|
|
2946
|
+
(Output)
|
|
2947
|
+
The local node storage allocated in GBs.
|
|
2948
|
+
"""
|
|
2949
|
+
db_server_version: NotRequired[pulumi.Input[str]]
|
|
2950
|
+
"""
|
|
2951
|
+
(Output)
|
|
2952
|
+
The software version of the database servers (dom0) in the Exadata
|
|
2953
|
+
Infrastructure.
|
|
2954
|
+
"""
|
|
2955
|
+
maintenance_window: NotRequired[pulumi.Input['CloudExadataInfrastructurePropertiesMaintenanceWindowArgsDict']]
|
|
2956
|
+
"""
|
|
2957
|
+
Maintenance window as defined by Oracle.
|
|
2958
|
+
https://docs.oracle.com/en-us/iaas/api/#/en/database/20160918/datatypes/MaintenanceWindow
|
|
2959
|
+
Structure is documented below.
|
|
2960
|
+
"""
|
|
2961
|
+
max_cpu_count: NotRequired[pulumi.Input[int]]
|
|
2962
|
+
"""
|
|
2963
|
+
(Output)
|
|
2964
|
+
The total number of CPU cores available.
|
|
2965
|
+
"""
|
|
2966
|
+
max_data_storage_tb: NotRequired[pulumi.Input[float]]
|
|
2967
|
+
"""
|
|
2968
|
+
(Output)
|
|
2969
|
+
The total available DATA disk group size.
|
|
2970
|
+
"""
|
|
2971
|
+
max_db_node_storage_size_gb: NotRequired[pulumi.Input[int]]
|
|
2972
|
+
"""
|
|
2973
|
+
(Output)
|
|
2974
|
+
The total local node storage available in GBs.
|
|
2975
|
+
"""
|
|
2976
|
+
max_memory_gb: NotRequired[pulumi.Input[int]]
|
|
2977
|
+
"""
|
|
2978
|
+
(Output)
|
|
2979
|
+
The total memory available in GBs.
|
|
2980
|
+
"""
|
|
2981
|
+
memory_size_gb: NotRequired[pulumi.Input[int]]
|
|
2982
|
+
"""
|
|
2983
|
+
(Output)
|
|
2984
|
+
The memory allocated in GBs.
|
|
2985
|
+
"""
|
|
2986
|
+
monthly_db_server_version: NotRequired[pulumi.Input[str]]
|
|
2987
|
+
"""
|
|
2988
|
+
(Output)
|
|
2989
|
+
The monthly software version of the database servers (dom0)
|
|
2990
|
+
in the Exadata Infrastructure. Example: 20.1.15
|
|
2991
|
+
"""
|
|
2992
|
+
monthly_storage_server_version: NotRequired[pulumi.Input[str]]
|
|
2993
|
+
"""
|
|
2994
|
+
(Output)
|
|
2995
|
+
The monthly software version of the storage servers (cells)
|
|
2996
|
+
in the Exadata Infrastructure. Example: 20.1.15
|
|
2997
|
+
"""
|
|
2998
|
+
next_maintenance_run_id: NotRequired[pulumi.Input[str]]
|
|
2999
|
+
"""
|
|
3000
|
+
(Output)
|
|
3001
|
+
The OCID of the next maintenance run.
|
|
3002
|
+
"""
|
|
3003
|
+
next_maintenance_run_time: NotRequired[pulumi.Input[str]]
|
|
3004
|
+
"""
|
|
3005
|
+
(Output)
|
|
3006
|
+
The time when the next maintenance run will occur.
|
|
3007
|
+
"""
|
|
3008
|
+
next_security_maintenance_run_time: NotRequired[pulumi.Input[str]]
|
|
3009
|
+
"""
|
|
3010
|
+
(Output)
|
|
3011
|
+
The time when the next security maintenance run will occur.
|
|
3012
|
+
"""
|
|
3013
|
+
oci_url: NotRequired[pulumi.Input[str]]
|
|
3014
|
+
"""
|
|
3015
|
+
(Output)
|
|
3016
|
+
Deep link to the OCI console to view this resource.
|
|
3017
|
+
"""
|
|
3018
|
+
ocid: NotRequired[pulumi.Input[str]]
|
|
3019
|
+
"""
|
|
3020
|
+
(Output)
|
|
3021
|
+
OCID of created infra.
|
|
3022
|
+
https://docs.oracle.com/en-us/iaas/Content/General/Concepts/identifiers.htm#Oracle
|
|
3023
|
+
"""
|
|
3024
|
+
state: NotRequired[pulumi.Input[str]]
|
|
3025
|
+
"""
|
|
3026
|
+
(Output)
|
|
3027
|
+
The current lifecycle state of the Exadata Infrastructure.
|
|
3028
|
+
Possible values:
|
|
3029
|
+
STATE_UNSPECIFIED
|
|
3030
|
+
PROVISIONING
|
|
3031
|
+
AVAILABLE
|
|
3032
|
+
UPDATING
|
|
3033
|
+
TERMINATING
|
|
3034
|
+
TERMINATED
|
|
3035
|
+
FAILED
|
|
3036
|
+
MAINTENANCE_IN_PROGRESS
|
|
3037
|
+
"""
|
|
3038
|
+
storage_count: NotRequired[pulumi.Input[int]]
|
|
3039
|
+
"""
|
|
3040
|
+
The number of Cloud Exadata storage servers for the Exadata Infrastructure.
|
|
3041
|
+
"""
|
|
3042
|
+
storage_server_version: NotRequired[pulumi.Input[str]]
|
|
3043
|
+
"""
|
|
3044
|
+
(Output)
|
|
3045
|
+
The software version of the storage servers (cells) in the Exadata
|
|
3046
|
+
Infrastructure.
|
|
3047
|
+
"""
|
|
3048
|
+
total_storage_size_gb: NotRequired[pulumi.Input[int]]
|
|
3049
|
+
"""
|
|
3050
|
+
The total storage allocated to the Exadata Infrastructure
|
|
3051
|
+
resource, in gigabytes (GB).
|
|
3052
|
+
"""
|
|
3053
|
+
elif False:
|
|
3054
|
+
CloudExadataInfrastructurePropertiesArgsDict: TypeAlias = Mapping[str, Any]
|
|
3055
|
+
|
|
3056
|
+
@pulumi.input_type
|
|
3057
|
+
class CloudExadataInfrastructurePropertiesArgs:
|
|
3058
|
+
def __init__(__self__, *,
|
|
3059
|
+
shape: pulumi.Input[str],
|
|
3060
|
+
activated_storage_count: Optional[pulumi.Input[int]] = None,
|
|
3061
|
+
additional_storage_count: Optional[pulumi.Input[int]] = None,
|
|
3062
|
+
available_storage_size_gb: Optional[pulumi.Input[int]] = None,
|
|
3063
|
+
compute_count: Optional[pulumi.Input[int]] = None,
|
|
3064
|
+
cpu_count: Optional[pulumi.Input[int]] = None,
|
|
3065
|
+
customer_contacts: Optional[pulumi.Input[Sequence[pulumi.Input['CloudExadataInfrastructurePropertiesCustomerContactArgs']]]] = None,
|
|
3066
|
+
data_storage_size_tb: Optional[pulumi.Input[float]] = None,
|
|
3067
|
+
db_node_storage_size_gb: Optional[pulumi.Input[int]] = None,
|
|
3068
|
+
db_server_version: Optional[pulumi.Input[str]] = None,
|
|
3069
|
+
maintenance_window: Optional[pulumi.Input['CloudExadataInfrastructurePropertiesMaintenanceWindowArgs']] = None,
|
|
3070
|
+
max_cpu_count: Optional[pulumi.Input[int]] = None,
|
|
3071
|
+
max_data_storage_tb: Optional[pulumi.Input[float]] = None,
|
|
3072
|
+
max_db_node_storage_size_gb: Optional[pulumi.Input[int]] = None,
|
|
3073
|
+
max_memory_gb: Optional[pulumi.Input[int]] = None,
|
|
3074
|
+
memory_size_gb: Optional[pulumi.Input[int]] = None,
|
|
3075
|
+
monthly_db_server_version: Optional[pulumi.Input[str]] = None,
|
|
3076
|
+
monthly_storage_server_version: Optional[pulumi.Input[str]] = None,
|
|
3077
|
+
next_maintenance_run_id: Optional[pulumi.Input[str]] = None,
|
|
3078
|
+
next_maintenance_run_time: Optional[pulumi.Input[str]] = None,
|
|
3079
|
+
next_security_maintenance_run_time: Optional[pulumi.Input[str]] = None,
|
|
3080
|
+
oci_url: Optional[pulumi.Input[str]] = None,
|
|
3081
|
+
ocid: Optional[pulumi.Input[str]] = None,
|
|
3082
|
+
state: Optional[pulumi.Input[str]] = None,
|
|
3083
|
+
storage_count: Optional[pulumi.Input[int]] = None,
|
|
3084
|
+
storage_server_version: Optional[pulumi.Input[str]] = None,
|
|
3085
|
+
total_storage_size_gb: Optional[pulumi.Input[int]] = None):
|
|
3086
|
+
"""
|
|
3087
|
+
:param pulumi.Input[str] shape: The shape of the Exadata Infrastructure. The shape determines the
|
|
3088
|
+
amount of CPU, storage, and memory resources allocated to the instance.
|
|
3089
|
+
:param pulumi.Input[int] activated_storage_count: (Output)
|
|
3090
|
+
The requested number of additional storage servers activated for the
|
|
3091
|
+
Exadata Infrastructure.
|
|
3092
|
+
:param pulumi.Input[int] additional_storage_count: (Output)
|
|
3093
|
+
The requested number of additional storage servers for the Exadata
|
|
3094
|
+
Infrastructure.
|
|
3095
|
+
:param pulumi.Input[int] available_storage_size_gb: (Output)
|
|
3096
|
+
The available storage can be allocated to the Exadata Infrastructure
|
|
3097
|
+
resource, in gigabytes (GB).
|
|
3098
|
+
:param pulumi.Input[int] compute_count: The number of compute servers for the Exadata Infrastructure.
|
|
3099
|
+
:param pulumi.Input[int] cpu_count: (Output)
|
|
3100
|
+
The number of enabled CPU cores.
|
|
3101
|
+
:param pulumi.Input[Sequence[pulumi.Input['CloudExadataInfrastructurePropertiesCustomerContactArgs']]] customer_contacts: The list of customer contacts.
|
|
3102
|
+
Structure is documented below.
|
|
3103
|
+
:param pulumi.Input[float] data_storage_size_tb: (Output)
|
|
3104
|
+
Size, in terabytes, of the DATA disk group.
|
|
3105
|
+
:param pulumi.Input[int] db_node_storage_size_gb: (Output)
|
|
3106
|
+
The local node storage allocated in GBs.
|
|
3107
|
+
:param pulumi.Input[str] db_server_version: (Output)
|
|
3108
|
+
The software version of the database servers (dom0) in the Exadata
|
|
3109
|
+
Infrastructure.
|
|
3110
|
+
:param pulumi.Input['CloudExadataInfrastructurePropertiesMaintenanceWindowArgs'] maintenance_window: Maintenance window as defined by Oracle.
|
|
3111
|
+
https://docs.oracle.com/en-us/iaas/api/#/en/database/20160918/datatypes/MaintenanceWindow
|
|
3112
|
+
Structure is documented below.
|
|
3113
|
+
:param pulumi.Input[int] max_cpu_count: (Output)
|
|
3114
|
+
The total number of CPU cores available.
|
|
3115
|
+
:param pulumi.Input[float] max_data_storage_tb: (Output)
|
|
3116
|
+
The total available DATA disk group size.
|
|
3117
|
+
:param pulumi.Input[int] max_db_node_storage_size_gb: (Output)
|
|
3118
|
+
The total local node storage available in GBs.
|
|
3119
|
+
:param pulumi.Input[int] max_memory_gb: (Output)
|
|
3120
|
+
The total memory available in GBs.
|
|
3121
|
+
:param pulumi.Input[int] memory_size_gb: (Output)
|
|
3122
|
+
The memory allocated in GBs.
|
|
3123
|
+
:param pulumi.Input[str] monthly_db_server_version: (Output)
|
|
3124
|
+
The monthly software version of the database servers (dom0)
|
|
3125
|
+
in the Exadata Infrastructure. Example: 20.1.15
|
|
3126
|
+
:param pulumi.Input[str] monthly_storage_server_version: (Output)
|
|
3127
|
+
The monthly software version of the storage servers (cells)
|
|
3128
|
+
in the Exadata Infrastructure. Example: 20.1.15
|
|
3129
|
+
:param pulumi.Input[str] next_maintenance_run_id: (Output)
|
|
3130
|
+
The OCID of the next maintenance run.
|
|
3131
|
+
:param pulumi.Input[str] next_maintenance_run_time: (Output)
|
|
3132
|
+
The time when the next maintenance run will occur.
|
|
3133
|
+
:param pulumi.Input[str] next_security_maintenance_run_time: (Output)
|
|
3134
|
+
The time when the next security maintenance run will occur.
|
|
3135
|
+
:param pulumi.Input[str] oci_url: (Output)
|
|
3136
|
+
Deep link to the OCI console to view this resource.
|
|
3137
|
+
:param pulumi.Input[str] ocid: (Output)
|
|
3138
|
+
OCID of created infra.
|
|
3139
|
+
https://docs.oracle.com/en-us/iaas/Content/General/Concepts/identifiers.htm#Oracle
|
|
3140
|
+
:param pulumi.Input[str] state: (Output)
|
|
3141
|
+
The current lifecycle state of the Exadata Infrastructure.
|
|
3142
|
+
Possible values:
|
|
3143
|
+
STATE_UNSPECIFIED
|
|
3144
|
+
PROVISIONING
|
|
3145
|
+
AVAILABLE
|
|
3146
|
+
UPDATING
|
|
3147
|
+
TERMINATING
|
|
3148
|
+
TERMINATED
|
|
3149
|
+
FAILED
|
|
3150
|
+
MAINTENANCE_IN_PROGRESS
|
|
3151
|
+
:param pulumi.Input[int] storage_count: The number of Cloud Exadata storage servers for the Exadata Infrastructure.
|
|
3152
|
+
:param pulumi.Input[str] storage_server_version: (Output)
|
|
3153
|
+
The software version of the storage servers (cells) in the Exadata
|
|
3154
|
+
Infrastructure.
|
|
3155
|
+
:param pulumi.Input[int] total_storage_size_gb: The total storage allocated to the Exadata Infrastructure
|
|
3156
|
+
resource, in gigabytes (GB).
|
|
3157
|
+
"""
|
|
3158
|
+
pulumi.set(__self__, "shape", shape)
|
|
3159
|
+
if activated_storage_count is not None:
|
|
3160
|
+
pulumi.set(__self__, "activated_storage_count", activated_storage_count)
|
|
3161
|
+
if additional_storage_count is not None:
|
|
3162
|
+
pulumi.set(__self__, "additional_storage_count", additional_storage_count)
|
|
3163
|
+
if available_storage_size_gb is not None:
|
|
3164
|
+
pulumi.set(__self__, "available_storage_size_gb", available_storage_size_gb)
|
|
3165
|
+
if compute_count is not None:
|
|
3166
|
+
pulumi.set(__self__, "compute_count", compute_count)
|
|
3167
|
+
if cpu_count is not None:
|
|
3168
|
+
pulumi.set(__self__, "cpu_count", cpu_count)
|
|
3169
|
+
if customer_contacts is not None:
|
|
3170
|
+
pulumi.set(__self__, "customer_contacts", customer_contacts)
|
|
3171
|
+
if data_storage_size_tb is not None:
|
|
3172
|
+
pulumi.set(__self__, "data_storage_size_tb", data_storage_size_tb)
|
|
3173
|
+
if db_node_storage_size_gb is not None:
|
|
3174
|
+
pulumi.set(__self__, "db_node_storage_size_gb", db_node_storage_size_gb)
|
|
3175
|
+
if db_server_version is not None:
|
|
3176
|
+
pulumi.set(__self__, "db_server_version", db_server_version)
|
|
3177
|
+
if maintenance_window is not None:
|
|
3178
|
+
pulumi.set(__self__, "maintenance_window", maintenance_window)
|
|
3179
|
+
if max_cpu_count is not None:
|
|
3180
|
+
pulumi.set(__self__, "max_cpu_count", max_cpu_count)
|
|
3181
|
+
if max_data_storage_tb is not None:
|
|
3182
|
+
pulumi.set(__self__, "max_data_storage_tb", max_data_storage_tb)
|
|
3183
|
+
if max_db_node_storage_size_gb is not None:
|
|
3184
|
+
pulumi.set(__self__, "max_db_node_storage_size_gb", max_db_node_storage_size_gb)
|
|
3185
|
+
if max_memory_gb is not None:
|
|
3186
|
+
pulumi.set(__self__, "max_memory_gb", max_memory_gb)
|
|
3187
|
+
if memory_size_gb is not None:
|
|
3188
|
+
pulumi.set(__self__, "memory_size_gb", memory_size_gb)
|
|
3189
|
+
if monthly_db_server_version is not None:
|
|
3190
|
+
pulumi.set(__self__, "monthly_db_server_version", monthly_db_server_version)
|
|
3191
|
+
if monthly_storage_server_version is not None:
|
|
3192
|
+
pulumi.set(__self__, "monthly_storage_server_version", monthly_storage_server_version)
|
|
3193
|
+
if next_maintenance_run_id is not None:
|
|
3194
|
+
pulumi.set(__self__, "next_maintenance_run_id", next_maintenance_run_id)
|
|
3195
|
+
if next_maintenance_run_time is not None:
|
|
3196
|
+
pulumi.set(__self__, "next_maintenance_run_time", next_maintenance_run_time)
|
|
3197
|
+
if next_security_maintenance_run_time is not None:
|
|
3198
|
+
pulumi.set(__self__, "next_security_maintenance_run_time", next_security_maintenance_run_time)
|
|
3199
|
+
if oci_url is not None:
|
|
3200
|
+
pulumi.set(__self__, "oci_url", oci_url)
|
|
3201
|
+
if ocid is not None:
|
|
3202
|
+
pulumi.set(__self__, "ocid", ocid)
|
|
3203
|
+
if state is not None:
|
|
3204
|
+
pulumi.set(__self__, "state", state)
|
|
3205
|
+
if storage_count is not None:
|
|
3206
|
+
pulumi.set(__self__, "storage_count", storage_count)
|
|
3207
|
+
if storage_server_version is not None:
|
|
3208
|
+
pulumi.set(__self__, "storage_server_version", storage_server_version)
|
|
3209
|
+
if total_storage_size_gb is not None:
|
|
3210
|
+
pulumi.set(__self__, "total_storage_size_gb", total_storage_size_gb)
|
|
3211
|
+
|
|
3212
|
+
@property
|
|
3213
|
+
@pulumi.getter
|
|
3214
|
+
def shape(self) -> pulumi.Input[str]:
|
|
3215
|
+
"""
|
|
3216
|
+
The shape of the Exadata Infrastructure. The shape determines the
|
|
3217
|
+
amount of CPU, storage, and memory resources allocated to the instance.
|
|
3218
|
+
"""
|
|
3219
|
+
return pulumi.get(self, "shape")
|
|
3220
|
+
|
|
3221
|
+
@shape.setter
|
|
3222
|
+
def shape(self, value: pulumi.Input[str]):
|
|
3223
|
+
pulumi.set(self, "shape", value)
|
|
3224
|
+
|
|
3225
|
+
@property
|
|
3226
|
+
@pulumi.getter(name="activatedStorageCount")
|
|
3227
|
+
def activated_storage_count(self) -> Optional[pulumi.Input[int]]:
|
|
3228
|
+
"""
|
|
3229
|
+
(Output)
|
|
3230
|
+
The requested number of additional storage servers activated for the
|
|
3231
|
+
Exadata Infrastructure.
|
|
3232
|
+
"""
|
|
3233
|
+
return pulumi.get(self, "activated_storage_count")
|
|
3234
|
+
|
|
3235
|
+
@activated_storage_count.setter
|
|
3236
|
+
def activated_storage_count(self, value: Optional[pulumi.Input[int]]):
|
|
3237
|
+
pulumi.set(self, "activated_storage_count", value)
|
|
3238
|
+
|
|
3239
|
+
@property
|
|
3240
|
+
@pulumi.getter(name="additionalStorageCount")
|
|
3241
|
+
def additional_storage_count(self) -> Optional[pulumi.Input[int]]:
|
|
3242
|
+
"""
|
|
3243
|
+
(Output)
|
|
3244
|
+
The requested number of additional storage servers for the Exadata
|
|
3245
|
+
Infrastructure.
|
|
3246
|
+
"""
|
|
3247
|
+
return pulumi.get(self, "additional_storage_count")
|
|
3248
|
+
|
|
3249
|
+
@additional_storage_count.setter
|
|
3250
|
+
def additional_storage_count(self, value: Optional[pulumi.Input[int]]):
|
|
3251
|
+
pulumi.set(self, "additional_storage_count", value)
|
|
3252
|
+
|
|
3253
|
+
@property
|
|
3254
|
+
@pulumi.getter(name="availableStorageSizeGb")
|
|
3255
|
+
def available_storage_size_gb(self) -> Optional[pulumi.Input[int]]:
|
|
3256
|
+
"""
|
|
3257
|
+
(Output)
|
|
3258
|
+
The available storage can be allocated to the Exadata Infrastructure
|
|
3259
|
+
resource, in gigabytes (GB).
|
|
3260
|
+
"""
|
|
3261
|
+
return pulumi.get(self, "available_storage_size_gb")
|
|
3262
|
+
|
|
3263
|
+
@available_storage_size_gb.setter
|
|
3264
|
+
def available_storage_size_gb(self, value: Optional[pulumi.Input[int]]):
|
|
3265
|
+
pulumi.set(self, "available_storage_size_gb", value)
|
|
3266
|
+
|
|
3267
|
+
@property
|
|
3268
|
+
@pulumi.getter(name="computeCount")
|
|
3269
|
+
def compute_count(self) -> Optional[pulumi.Input[int]]:
|
|
3270
|
+
"""
|
|
3271
|
+
The number of compute servers for the Exadata Infrastructure.
|
|
3272
|
+
"""
|
|
3273
|
+
return pulumi.get(self, "compute_count")
|
|
3274
|
+
|
|
3275
|
+
@compute_count.setter
|
|
3276
|
+
def compute_count(self, value: Optional[pulumi.Input[int]]):
|
|
3277
|
+
pulumi.set(self, "compute_count", value)
|
|
3278
|
+
|
|
3279
|
+
@property
|
|
3280
|
+
@pulumi.getter(name="cpuCount")
|
|
3281
|
+
def cpu_count(self) -> Optional[pulumi.Input[int]]:
|
|
3282
|
+
"""
|
|
3283
|
+
(Output)
|
|
3284
|
+
The number of enabled CPU cores.
|
|
3285
|
+
"""
|
|
3286
|
+
return pulumi.get(self, "cpu_count")
|
|
3287
|
+
|
|
3288
|
+
@cpu_count.setter
|
|
3289
|
+
def cpu_count(self, value: Optional[pulumi.Input[int]]):
|
|
3290
|
+
pulumi.set(self, "cpu_count", value)
|
|
3291
|
+
|
|
3292
|
+
@property
|
|
3293
|
+
@pulumi.getter(name="customerContacts")
|
|
3294
|
+
def customer_contacts(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['CloudExadataInfrastructurePropertiesCustomerContactArgs']]]]:
|
|
3295
|
+
"""
|
|
3296
|
+
The list of customer contacts.
|
|
3297
|
+
Structure is documented below.
|
|
3298
|
+
"""
|
|
3299
|
+
return pulumi.get(self, "customer_contacts")
|
|
3300
|
+
|
|
3301
|
+
@customer_contacts.setter
|
|
3302
|
+
def customer_contacts(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['CloudExadataInfrastructurePropertiesCustomerContactArgs']]]]):
|
|
3303
|
+
pulumi.set(self, "customer_contacts", value)
|
|
3304
|
+
|
|
3305
|
+
@property
|
|
3306
|
+
@pulumi.getter(name="dataStorageSizeTb")
|
|
3307
|
+
def data_storage_size_tb(self) -> Optional[pulumi.Input[float]]:
|
|
3308
|
+
"""
|
|
3309
|
+
(Output)
|
|
3310
|
+
Size, in terabytes, of the DATA disk group.
|
|
3311
|
+
"""
|
|
3312
|
+
return pulumi.get(self, "data_storage_size_tb")
|
|
3313
|
+
|
|
3314
|
+
@data_storage_size_tb.setter
|
|
3315
|
+
def data_storage_size_tb(self, value: Optional[pulumi.Input[float]]):
|
|
3316
|
+
pulumi.set(self, "data_storage_size_tb", value)
|
|
3317
|
+
|
|
3318
|
+
@property
|
|
3319
|
+
@pulumi.getter(name="dbNodeStorageSizeGb")
|
|
3320
|
+
def db_node_storage_size_gb(self) -> Optional[pulumi.Input[int]]:
|
|
3321
|
+
"""
|
|
3322
|
+
(Output)
|
|
3323
|
+
The local node storage allocated in GBs.
|
|
3324
|
+
"""
|
|
3325
|
+
return pulumi.get(self, "db_node_storage_size_gb")
|
|
3326
|
+
|
|
3327
|
+
@db_node_storage_size_gb.setter
|
|
3328
|
+
def db_node_storage_size_gb(self, value: Optional[pulumi.Input[int]]):
|
|
3329
|
+
pulumi.set(self, "db_node_storage_size_gb", value)
|
|
3330
|
+
|
|
3331
|
+
@property
|
|
3332
|
+
@pulumi.getter(name="dbServerVersion")
|
|
3333
|
+
def db_server_version(self) -> Optional[pulumi.Input[str]]:
|
|
3334
|
+
"""
|
|
3335
|
+
(Output)
|
|
3336
|
+
The software version of the database servers (dom0) in the Exadata
|
|
3337
|
+
Infrastructure.
|
|
3338
|
+
"""
|
|
3339
|
+
return pulumi.get(self, "db_server_version")
|
|
3340
|
+
|
|
3341
|
+
@db_server_version.setter
|
|
3342
|
+
def db_server_version(self, value: Optional[pulumi.Input[str]]):
|
|
3343
|
+
pulumi.set(self, "db_server_version", value)
|
|
3344
|
+
|
|
3345
|
+
@property
|
|
3346
|
+
@pulumi.getter(name="maintenanceWindow")
|
|
3347
|
+
def maintenance_window(self) -> Optional[pulumi.Input['CloudExadataInfrastructurePropertiesMaintenanceWindowArgs']]:
|
|
3348
|
+
"""
|
|
3349
|
+
Maintenance window as defined by Oracle.
|
|
3350
|
+
https://docs.oracle.com/en-us/iaas/api/#/en/database/20160918/datatypes/MaintenanceWindow
|
|
3351
|
+
Structure is documented below.
|
|
3352
|
+
"""
|
|
3353
|
+
return pulumi.get(self, "maintenance_window")
|
|
3354
|
+
|
|
3355
|
+
@maintenance_window.setter
|
|
3356
|
+
def maintenance_window(self, value: Optional[pulumi.Input['CloudExadataInfrastructurePropertiesMaintenanceWindowArgs']]):
|
|
3357
|
+
pulumi.set(self, "maintenance_window", value)
|
|
3358
|
+
|
|
3359
|
+
@property
|
|
3360
|
+
@pulumi.getter(name="maxCpuCount")
|
|
3361
|
+
def max_cpu_count(self) -> Optional[pulumi.Input[int]]:
|
|
3362
|
+
"""
|
|
3363
|
+
(Output)
|
|
3364
|
+
The total number of CPU cores available.
|
|
3365
|
+
"""
|
|
3366
|
+
return pulumi.get(self, "max_cpu_count")
|
|
3367
|
+
|
|
3368
|
+
@max_cpu_count.setter
|
|
3369
|
+
def max_cpu_count(self, value: Optional[pulumi.Input[int]]):
|
|
3370
|
+
pulumi.set(self, "max_cpu_count", value)
|
|
3371
|
+
|
|
3372
|
+
@property
|
|
3373
|
+
@pulumi.getter(name="maxDataStorageTb")
|
|
3374
|
+
def max_data_storage_tb(self) -> Optional[pulumi.Input[float]]:
|
|
3375
|
+
"""
|
|
3376
|
+
(Output)
|
|
3377
|
+
The total available DATA disk group size.
|
|
3378
|
+
"""
|
|
3379
|
+
return pulumi.get(self, "max_data_storage_tb")
|
|
3380
|
+
|
|
3381
|
+
@max_data_storage_tb.setter
|
|
3382
|
+
def max_data_storage_tb(self, value: Optional[pulumi.Input[float]]):
|
|
3383
|
+
pulumi.set(self, "max_data_storage_tb", value)
|
|
3384
|
+
|
|
3385
|
+
@property
|
|
3386
|
+
@pulumi.getter(name="maxDbNodeStorageSizeGb")
|
|
3387
|
+
def max_db_node_storage_size_gb(self) -> Optional[pulumi.Input[int]]:
|
|
3388
|
+
"""
|
|
3389
|
+
(Output)
|
|
3390
|
+
The total local node storage available in GBs.
|
|
3391
|
+
"""
|
|
3392
|
+
return pulumi.get(self, "max_db_node_storage_size_gb")
|
|
3393
|
+
|
|
3394
|
+
@max_db_node_storage_size_gb.setter
|
|
3395
|
+
def max_db_node_storage_size_gb(self, value: Optional[pulumi.Input[int]]):
|
|
3396
|
+
pulumi.set(self, "max_db_node_storage_size_gb", value)
|
|
3397
|
+
|
|
3398
|
+
@property
|
|
3399
|
+
@pulumi.getter(name="maxMemoryGb")
|
|
3400
|
+
def max_memory_gb(self) -> Optional[pulumi.Input[int]]:
|
|
3401
|
+
"""
|
|
3402
|
+
(Output)
|
|
3403
|
+
The total memory available in GBs.
|
|
3404
|
+
"""
|
|
3405
|
+
return pulumi.get(self, "max_memory_gb")
|
|
3406
|
+
|
|
3407
|
+
@max_memory_gb.setter
|
|
3408
|
+
def max_memory_gb(self, value: Optional[pulumi.Input[int]]):
|
|
3409
|
+
pulumi.set(self, "max_memory_gb", value)
|
|
3410
|
+
|
|
3411
|
+
@property
|
|
3412
|
+
@pulumi.getter(name="memorySizeGb")
|
|
3413
|
+
def memory_size_gb(self) -> Optional[pulumi.Input[int]]:
|
|
3414
|
+
"""
|
|
3415
|
+
(Output)
|
|
3416
|
+
The memory allocated in GBs.
|
|
3417
|
+
"""
|
|
3418
|
+
return pulumi.get(self, "memory_size_gb")
|
|
3419
|
+
|
|
3420
|
+
@memory_size_gb.setter
|
|
3421
|
+
def memory_size_gb(self, value: Optional[pulumi.Input[int]]):
|
|
3422
|
+
pulumi.set(self, "memory_size_gb", value)
|
|
3423
|
+
|
|
3424
|
+
@property
|
|
3425
|
+
@pulumi.getter(name="monthlyDbServerVersion")
|
|
3426
|
+
def monthly_db_server_version(self) -> Optional[pulumi.Input[str]]:
|
|
3427
|
+
"""
|
|
3428
|
+
(Output)
|
|
3429
|
+
The monthly software version of the database servers (dom0)
|
|
3430
|
+
in the Exadata Infrastructure. Example: 20.1.15
|
|
3431
|
+
"""
|
|
3432
|
+
return pulumi.get(self, "monthly_db_server_version")
|
|
3433
|
+
|
|
3434
|
+
@monthly_db_server_version.setter
|
|
3435
|
+
def monthly_db_server_version(self, value: Optional[pulumi.Input[str]]):
|
|
3436
|
+
pulumi.set(self, "monthly_db_server_version", value)
|
|
3437
|
+
|
|
3438
|
+
@property
|
|
3439
|
+
@pulumi.getter(name="monthlyStorageServerVersion")
|
|
3440
|
+
def monthly_storage_server_version(self) -> Optional[pulumi.Input[str]]:
|
|
3441
|
+
"""
|
|
3442
|
+
(Output)
|
|
3443
|
+
The monthly software version of the storage servers (cells)
|
|
3444
|
+
in the Exadata Infrastructure. Example: 20.1.15
|
|
3445
|
+
"""
|
|
3446
|
+
return pulumi.get(self, "monthly_storage_server_version")
|
|
3447
|
+
|
|
3448
|
+
@monthly_storage_server_version.setter
|
|
3449
|
+
def monthly_storage_server_version(self, value: Optional[pulumi.Input[str]]):
|
|
3450
|
+
pulumi.set(self, "monthly_storage_server_version", value)
|
|
3451
|
+
|
|
3452
|
+
@property
|
|
3453
|
+
@pulumi.getter(name="nextMaintenanceRunId")
|
|
3454
|
+
def next_maintenance_run_id(self) -> Optional[pulumi.Input[str]]:
|
|
3455
|
+
"""
|
|
3456
|
+
(Output)
|
|
3457
|
+
The OCID of the next maintenance run.
|
|
3458
|
+
"""
|
|
3459
|
+
return pulumi.get(self, "next_maintenance_run_id")
|
|
3460
|
+
|
|
3461
|
+
@next_maintenance_run_id.setter
|
|
3462
|
+
def next_maintenance_run_id(self, value: Optional[pulumi.Input[str]]):
|
|
3463
|
+
pulumi.set(self, "next_maintenance_run_id", value)
|
|
3464
|
+
|
|
3465
|
+
@property
|
|
3466
|
+
@pulumi.getter(name="nextMaintenanceRunTime")
|
|
3467
|
+
def next_maintenance_run_time(self) -> Optional[pulumi.Input[str]]:
|
|
3468
|
+
"""
|
|
3469
|
+
(Output)
|
|
3470
|
+
The time when the next maintenance run will occur.
|
|
3471
|
+
"""
|
|
3472
|
+
return pulumi.get(self, "next_maintenance_run_time")
|
|
3473
|
+
|
|
3474
|
+
@next_maintenance_run_time.setter
|
|
3475
|
+
def next_maintenance_run_time(self, value: Optional[pulumi.Input[str]]):
|
|
3476
|
+
pulumi.set(self, "next_maintenance_run_time", value)
|
|
3477
|
+
|
|
3478
|
+
@property
|
|
3479
|
+
@pulumi.getter(name="nextSecurityMaintenanceRunTime")
|
|
3480
|
+
def next_security_maintenance_run_time(self) -> Optional[pulumi.Input[str]]:
|
|
3481
|
+
"""
|
|
3482
|
+
(Output)
|
|
3483
|
+
The time when the next security maintenance run will occur.
|
|
3484
|
+
"""
|
|
3485
|
+
return pulumi.get(self, "next_security_maintenance_run_time")
|
|
3486
|
+
|
|
3487
|
+
@next_security_maintenance_run_time.setter
|
|
3488
|
+
def next_security_maintenance_run_time(self, value: Optional[pulumi.Input[str]]):
|
|
3489
|
+
pulumi.set(self, "next_security_maintenance_run_time", value)
|
|
3490
|
+
|
|
3491
|
+
@property
|
|
3492
|
+
@pulumi.getter(name="ociUrl")
|
|
3493
|
+
def oci_url(self) -> Optional[pulumi.Input[str]]:
|
|
3494
|
+
"""
|
|
3495
|
+
(Output)
|
|
3496
|
+
Deep link to the OCI console to view this resource.
|
|
3497
|
+
"""
|
|
3498
|
+
return pulumi.get(self, "oci_url")
|
|
3499
|
+
|
|
3500
|
+
@oci_url.setter
|
|
3501
|
+
def oci_url(self, value: Optional[pulumi.Input[str]]):
|
|
3502
|
+
pulumi.set(self, "oci_url", value)
|
|
3503
|
+
|
|
3504
|
+
@property
|
|
3505
|
+
@pulumi.getter
|
|
3506
|
+
def ocid(self) -> Optional[pulumi.Input[str]]:
|
|
3507
|
+
"""
|
|
3508
|
+
(Output)
|
|
3509
|
+
OCID of created infra.
|
|
3510
|
+
https://docs.oracle.com/en-us/iaas/Content/General/Concepts/identifiers.htm#Oracle
|
|
3511
|
+
"""
|
|
3512
|
+
return pulumi.get(self, "ocid")
|
|
3513
|
+
|
|
3514
|
+
@ocid.setter
|
|
3515
|
+
def ocid(self, value: Optional[pulumi.Input[str]]):
|
|
3516
|
+
pulumi.set(self, "ocid", value)
|
|
3517
|
+
|
|
3518
|
+
@property
|
|
3519
|
+
@pulumi.getter
|
|
3520
|
+
def state(self) -> Optional[pulumi.Input[str]]:
|
|
3521
|
+
"""
|
|
3522
|
+
(Output)
|
|
3523
|
+
The current lifecycle state of the Exadata Infrastructure.
|
|
3524
|
+
Possible values:
|
|
3525
|
+
STATE_UNSPECIFIED
|
|
3526
|
+
PROVISIONING
|
|
3527
|
+
AVAILABLE
|
|
3528
|
+
UPDATING
|
|
3529
|
+
TERMINATING
|
|
3530
|
+
TERMINATED
|
|
3531
|
+
FAILED
|
|
3532
|
+
MAINTENANCE_IN_PROGRESS
|
|
3533
|
+
"""
|
|
3534
|
+
return pulumi.get(self, "state")
|
|
3535
|
+
|
|
3536
|
+
@state.setter
|
|
3537
|
+
def state(self, value: Optional[pulumi.Input[str]]):
|
|
3538
|
+
pulumi.set(self, "state", value)
|
|
3539
|
+
|
|
3540
|
+
@property
|
|
3541
|
+
@pulumi.getter(name="storageCount")
|
|
3542
|
+
def storage_count(self) -> Optional[pulumi.Input[int]]:
|
|
3543
|
+
"""
|
|
3544
|
+
The number of Cloud Exadata storage servers for the Exadata Infrastructure.
|
|
3545
|
+
"""
|
|
3546
|
+
return pulumi.get(self, "storage_count")
|
|
3547
|
+
|
|
3548
|
+
@storage_count.setter
|
|
3549
|
+
def storage_count(self, value: Optional[pulumi.Input[int]]):
|
|
3550
|
+
pulumi.set(self, "storage_count", value)
|
|
3551
|
+
|
|
3552
|
+
@property
|
|
3553
|
+
@pulumi.getter(name="storageServerVersion")
|
|
3554
|
+
def storage_server_version(self) -> Optional[pulumi.Input[str]]:
|
|
3555
|
+
"""
|
|
3556
|
+
(Output)
|
|
3557
|
+
The software version of the storage servers (cells) in the Exadata
|
|
3558
|
+
Infrastructure.
|
|
3559
|
+
"""
|
|
3560
|
+
return pulumi.get(self, "storage_server_version")
|
|
3561
|
+
|
|
3562
|
+
@storage_server_version.setter
|
|
3563
|
+
def storage_server_version(self, value: Optional[pulumi.Input[str]]):
|
|
3564
|
+
pulumi.set(self, "storage_server_version", value)
|
|
3565
|
+
|
|
3566
|
+
@property
|
|
3567
|
+
@pulumi.getter(name="totalStorageSizeGb")
|
|
3568
|
+
def total_storage_size_gb(self) -> Optional[pulumi.Input[int]]:
|
|
3569
|
+
"""
|
|
3570
|
+
The total storage allocated to the Exadata Infrastructure
|
|
3571
|
+
resource, in gigabytes (GB).
|
|
3572
|
+
"""
|
|
3573
|
+
return pulumi.get(self, "total_storage_size_gb")
|
|
3574
|
+
|
|
3575
|
+
@total_storage_size_gb.setter
|
|
3576
|
+
def total_storage_size_gb(self, value: Optional[pulumi.Input[int]]):
|
|
3577
|
+
pulumi.set(self, "total_storage_size_gb", value)
|
|
3578
|
+
|
|
3579
|
+
|
|
3580
|
+
if not MYPY:
|
|
3581
|
+
class CloudExadataInfrastructurePropertiesCustomerContactArgsDict(TypedDict):
|
|
3582
|
+
email: pulumi.Input[str]
|
|
3583
|
+
"""
|
|
3584
|
+
The email address used by Oracle to send notifications regarding databases
|
|
3585
|
+
and infrastructure.
|
|
3586
|
+
"""
|
|
3587
|
+
elif False:
|
|
3588
|
+
CloudExadataInfrastructurePropertiesCustomerContactArgsDict: TypeAlias = Mapping[str, Any]
|
|
3589
|
+
|
|
3590
|
+
@pulumi.input_type
|
|
3591
|
+
class CloudExadataInfrastructurePropertiesCustomerContactArgs:
|
|
3592
|
+
def __init__(__self__, *,
|
|
3593
|
+
email: pulumi.Input[str]):
|
|
3594
|
+
"""
|
|
3595
|
+
:param pulumi.Input[str] email: The email address used by Oracle to send notifications regarding databases
|
|
3596
|
+
and infrastructure.
|
|
3597
|
+
"""
|
|
3598
|
+
pulumi.set(__self__, "email", email)
|
|
3599
|
+
|
|
3600
|
+
@property
|
|
3601
|
+
@pulumi.getter
|
|
3602
|
+
def email(self) -> pulumi.Input[str]:
|
|
3603
|
+
"""
|
|
3604
|
+
The email address used by Oracle to send notifications regarding databases
|
|
3605
|
+
and infrastructure.
|
|
3606
|
+
"""
|
|
3607
|
+
return pulumi.get(self, "email")
|
|
3608
|
+
|
|
3609
|
+
@email.setter
|
|
3610
|
+
def email(self, value: pulumi.Input[str]):
|
|
3611
|
+
pulumi.set(self, "email", value)
|
|
3612
|
+
|
|
3613
|
+
|
|
3614
|
+
if not MYPY:
|
|
3615
|
+
class CloudExadataInfrastructurePropertiesMaintenanceWindowArgsDict(TypedDict):
|
|
3616
|
+
custom_action_timeout_mins: NotRequired[pulumi.Input[int]]
|
|
3617
|
+
"""
|
|
3618
|
+
Determines the amount of time the system will wait before the start of each
|
|
3619
|
+
database server patching operation. Custom action timeout is in minutes and
|
|
3620
|
+
valid value is between 15 to 120 (inclusive).
|
|
3621
|
+
"""
|
|
3622
|
+
days_of_weeks: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
3623
|
+
"""
|
|
3624
|
+
Days during the week when maintenance should be performed.
|
|
3625
|
+
"""
|
|
3626
|
+
hours_of_days: NotRequired[pulumi.Input[Sequence[pulumi.Input[int]]]]
|
|
3627
|
+
"""
|
|
3628
|
+
The window of hours during the day when maintenance should be performed.
|
|
3629
|
+
The window is a 4 hour slot. Valid values are:
|
|
3630
|
+
0 - represents time slot 0:00 - 3:59 UTC
|
|
3631
|
+
4 - represents time slot 4:00 - 7:59 UTC
|
|
3632
|
+
8 - represents time slot 8:00 - 11:59 UTC
|
|
3633
|
+
12 - represents time slot 12:00 - 15:59 UTC
|
|
3634
|
+
16 - represents time slot 16:00 - 19:59 UTC
|
|
3635
|
+
20 - represents time slot 20:00 - 23:59 UTC
|
|
3636
|
+
"""
|
|
3637
|
+
is_custom_action_timeout_enabled: NotRequired[pulumi.Input[bool]]
|
|
3638
|
+
"""
|
|
3639
|
+
If true, enables the configuration of a custom action timeout (waiting
|
|
3640
|
+
period) between database server patching operations.
|
|
3641
|
+
"""
|
|
3642
|
+
lead_time_week: NotRequired[pulumi.Input[int]]
|
|
3643
|
+
"""
|
|
3644
|
+
Lead time window allows user to set a lead time to prepare for a down time.
|
|
3645
|
+
The lead time is in weeks and valid value is between 1 to 4.
|
|
3646
|
+
"""
|
|
3647
|
+
months: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
3648
|
+
"""
|
|
3649
|
+
Months during the year when maintenance should be performed.
|
|
3650
|
+
"""
|
|
3651
|
+
patching_mode: NotRequired[pulumi.Input[str]]
|
|
3652
|
+
"""
|
|
3653
|
+
Cloud CloudExadataInfrastructure node patching method, either "ROLLING"
|
|
3654
|
+
or "NONROLLING". Default value is ROLLING.
|
|
3655
|
+
Possible values:
|
|
3656
|
+
PATCHING_MODE_UNSPECIFIED
|
|
3657
|
+
ROLLING
|
|
3658
|
+
NON_ROLLING
|
|
3659
|
+
"""
|
|
3660
|
+
preference: NotRequired[pulumi.Input[str]]
|
|
3661
|
+
"""
|
|
3662
|
+
The maintenance window scheduling preference.
|
|
3663
|
+
Possible values:
|
|
3664
|
+
MAINTENANCE_WINDOW_PREFERENCE_UNSPECIFIED
|
|
3665
|
+
CUSTOM_PREFERENCE
|
|
3666
|
+
NO_PREFERENCE
|
|
3667
|
+
"""
|
|
3668
|
+
weeks_of_months: NotRequired[pulumi.Input[Sequence[pulumi.Input[int]]]]
|
|
3669
|
+
"""
|
|
3670
|
+
Weeks during the month when maintenance should be performed. Weeks start on
|
|
3671
|
+
the 1st, 8th, 15th, and 22nd days of the month, and have a duration of 7
|
|
3672
|
+
days. Weeks start and end based on calendar dates, not days of the week.
|
|
3673
|
+
"""
|
|
3674
|
+
elif False:
|
|
3675
|
+
CloudExadataInfrastructurePropertiesMaintenanceWindowArgsDict: TypeAlias = Mapping[str, Any]
|
|
3676
|
+
|
|
3677
|
+
@pulumi.input_type
|
|
3678
|
+
class CloudExadataInfrastructurePropertiesMaintenanceWindowArgs:
|
|
3679
|
+
def __init__(__self__, *,
|
|
3680
|
+
custom_action_timeout_mins: Optional[pulumi.Input[int]] = None,
|
|
3681
|
+
days_of_weeks: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
3682
|
+
hours_of_days: Optional[pulumi.Input[Sequence[pulumi.Input[int]]]] = None,
|
|
3683
|
+
is_custom_action_timeout_enabled: Optional[pulumi.Input[bool]] = None,
|
|
3684
|
+
lead_time_week: Optional[pulumi.Input[int]] = None,
|
|
3685
|
+
months: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
3686
|
+
patching_mode: Optional[pulumi.Input[str]] = None,
|
|
3687
|
+
preference: Optional[pulumi.Input[str]] = None,
|
|
3688
|
+
weeks_of_months: Optional[pulumi.Input[Sequence[pulumi.Input[int]]]] = None):
|
|
3689
|
+
"""
|
|
3690
|
+
:param pulumi.Input[int] custom_action_timeout_mins: Determines the amount of time the system will wait before the start of each
|
|
3691
|
+
database server patching operation. Custom action timeout is in minutes and
|
|
3692
|
+
valid value is between 15 to 120 (inclusive).
|
|
3693
|
+
:param pulumi.Input[Sequence[pulumi.Input[str]]] days_of_weeks: Days during the week when maintenance should be performed.
|
|
3694
|
+
:param pulumi.Input[Sequence[pulumi.Input[int]]] hours_of_days: The window of hours during the day when maintenance should be performed.
|
|
3695
|
+
The window is a 4 hour slot. Valid values are:
|
|
3696
|
+
0 - represents time slot 0:00 - 3:59 UTC
|
|
3697
|
+
4 - represents time slot 4:00 - 7:59 UTC
|
|
3698
|
+
8 - represents time slot 8:00 - 11:59 UTC
|
|
3699
|
+
12 - represents time slot 12:00 - 15:59 UTC
|
|
3700
|
+
16 - represents time slot 16:00 - 19:59 UTC
|
|
3701
|
+
20 - represents time slot 20:00 - 23:59 UTC
|
|
3702
|
+
:param pulumi.Input[bool] is_custom_action_timeout_enabled: If true, enables the configuration of a custom action timeout (waiting
|
|
3703
|
+
period) between database server patching operations.
|
|
3704
|
+
:param pulumi.Input[int] lead_time_week: Lead time window allows user to set a lead time to prepare for a down time.
|
|
3705
|
+
The lead time is in weeks and valid value is between 1 to 4.
|
|
3706
|
+
:param pulumi.Input[Sequence[pulumi.Input[str]]] months: Months during the year when maintenance should be performed.
|
|
3707
|
+
:param pulumi.Input[str] patching_mode: Cloud CloudExadataInfrastructure node patching method, either "ROLLING"
|
|
3708
|
+
or "NONROLLING". Default value is ROLLING.
|
|
3709
|
+
Possible values:
|
|
3710
|
+
PATCHING_MODE_UNSPECIFIED
|
|
3711
|
+
ROLLING
|
|
3712
|
+
NON_ROLLING
|
|
3713
|
+
:param pulumi.Input[str] preference: The maintenance window scheduling preference.
|
|
3714
|
+
Possible values:
|
|
3715
|
+
MAINTENANCE_WINDOW_PREFERENCE_UNSPECIFIED
|
|
3716
|
+
CUSTOM_PREFERENCE
|
|
3717
|
+
NO_PREFERENCE
|
|
3718
|
+
:param pulumi.Input[Sequence[pulumi.Input[int]]] weeks_of_months: Weeks during the month when maintenance should be performed. Weeks start on
|
|
3719
|
+
the 1st, 8th, 15th, and 22nd days of the month, and have a duration of 7
|
|
3720
|
+
days. Weeks start and end based on calendar dates, not days of the week.
|
|
3721
|
+
"""
|
|
3722
|
+
if custom_action_timeout_mins is not None:
|
|
3723
|
+
pulumi.set(__self__, "custom_action_timeout_mins", custom_action_timeout_mins)
|
|
3724
|
+
if days_of_weeks is not None:
|
|
3725
|
+
pulumi.set(__self__, "days_of_weeks", days_of_weeks)
|
|
3726
|
+
if hours_of_days is not None:
|
|
3727
|
+
pulumi.set(__self__, "hours_of_days", hours_of_days)
|
|
3728
|
+
if is_custom_action_timeout_enabled is not None:
|
|
3729
|
+
pulumi.set(__self__, "is_custom_action_timeout_enabled", is_custom_action_timeout_enabled)
|
|
3730
|
+
if lead_time_week is not None:
|
|
3731
|
+
pulumi.set(__self__, "lead_time_week", lead_time_week)
|
|
3732
|
+
if months is not None:
|
|
3733
|
+
pulumi.set(__self__, "months", months)
|
|
3734
|
+
if patching_mode is not None:
|
|
3735
|
+
pulumi.set(__self__, "patching_mode", patching_mode)
|
|
3736
|
+
if preference is not None:
|
|
3737
|
+
pulumi.set(__self__, "preference", preference)
|
|
3738
|
+
if weeks_of_months is not None:
|
|
3739
|
+
pulumi.set(__self__, "weeks_of_months", weeks_of_months)
|
|
3740
|
+
|
|
3741
|
+
@property
|
|
3742
|
+
@pulumi.getter(name="customActionTimeoutMins")
|
|
3743
|
+
def custom_action_timeout_mins(self) -> Optional[pulumi.Input[int]]:
|
|
3744
|
+
"""
|
|
3745
|
+
Determines the amount of time the system will wait before the start of each
|
|
3746
|
+
database server patching operation. Custom action timeout is in minutes and
|
|
3747
|
+
valid value is between 15 to 120 (inclusive).
|
|
3748
|
+
"""
|
|
3749
|
+
return pulumi.get(self, "custom_action_timeout_mins")
|
|
3750
|
+
|
|
3751
|
+
@custom_action_timeout_mins.setter
|
|
3752
|
+
def custom_action_timeout_mins(self, value: Optional[pulumi.Input[int]]):
|
|
3753
|
+
pulumi.set(self, "custom_action_timeout_mins", value)
|
|
3754
|
+
|
|
3755
|
+
@property
|
|
3756
|
+
@pulumi.getter(name="daysOfWeeks")
|
|
3757
|
+
def days_of_weeks(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
3758
|
+
"""
|
|
3759
|
+
Days during the week when maintenance should be performed.
|
|
3760
|
+
"""
|
|
3761
|
+
return pulumi.get(self, "days_of_weeks")
|
|
3762
|
+
|
|
3763
|
+
@days_of_weeks.setter
|
|
3764
|
+
def days_of_weeks(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
3765
|
+
pulumi.set(self, "days_of_weeks", value)
|
|
3766
|
+
|
|
3767
|
+
@property
|
|
3768
|
+
@pulumi.getter(name="hoursOfDays")
|
|
3769
|
+
def hours_of_days(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[int]]]]:
|
|
3770
|
+
"""
|
|
3771
|
+
The window of hours during the day when maintenance should be performed.
|
|
3772
|
+
The window is a 4 hour slot. Valid values are:
|
|
3773
|
+
0 - represents time slot 0:00 - 3:59 UTC
|
|
3774
|
+
4 - represents time slot 4:00 - 7:59 UTC
|
|
3775
|
+
8 - represents time slot 8:00 - 11:59 UTC
|
|
3776
|
+
12 - represents time slot 12:00 - 15:59 UTC
|
|
3777
|
+
16 - represents time slot 16:00 - 19:59 UTC
|
|
3778
|
+
20 - represents time slot 20:00 - 23:59 UTC
|
|
3779
|
+
"""
|
|
3780
|
+
return pulumi.get(self, "hours_of_days")
|
|
3781
|
+
|
|
3782
|
+
@hours_of_days.setter
|
|
3783
|
+
def hours_of_days(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[int]]]]):
|
|
3784
|
+
pulumi.set(self, "hours_of_days", value)
|
|
3785
|
+
|
|
3786
|
+
@property
|
|
3787
|
+
@pulumi.getter(name="isCustomActionTimeoutEnabled")
|
|
3788
|
+
def is_custom_action_timeout_enabled(self) -> Optional[pulumi.Input[bool]]:
|
|
3789
|
+
"""
|
|
3790
|
+
If true, enables the configuration of a custom action timeout (waiting
|
|
3791
|
+
period) between database server patching operations.
|
|
3792
|
+
"""
|
|
3793
|
+
return pulumi.get(self, "is_custom_action_timeout_enabled")
|
|
3794
|
+
|
|
3795
|
+
@is_custom_action_timeout_enabled.setter
|
|
3796
|
+
def is_custom_action_timeout_enabled(self, value: Optional[pulumi.Input[bool]]):
|
|
3797
|
+
pulumi.set(self, "is_custom_action_timeout_enabled", value)
|
|
3798
|
+
|
|
3799
|
+
@property
|
|
3800
|
+
@pulumi.getter(name="leadTimeWeek")
|
|
3801
|
+
def lead_time_week(self) -> Optional[pulumi.Input[int]]:
|
|
3802
|
+
"""
|
|
3803
|
+
Lead time window allows user to set a lead time to prepare for a down time.
|
|
3804
|
+
The lead time is in weeks and valid value is between 1 to 4.
|
|
3805
|
+
"""
|
|
3806
|
+
return pulumi.get(self, "lead_time_week")
|
|
3807
|
+
|
|
3808
|
+
@lead_time_week.setter
|
|
3809
|
+
def lead_time_week(self, value: Optional[pulumi.Input[int]]):
|
|
3810
|
+
pulumi.set(self, "lead_time_week", value)
|
|
3811
|
+
|
|
3812
|
+
@property
|
|
3813
|
+
@pulumi.getter
|
|
3814
|
+
def months(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
3815
|
+
"""
|
|
3816
|
+
Months during the year when maintenance should be performed.
|
|
3817
|
+
"""
|
|
3818
|
+
return pulumi.get(self, "months")
|
|
3819
|
+
|
|
3820
|
+
@months.setter
|
|
3821
|
+
def months(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
3822
|
+
pulumi.set(self, "months", value)
|
|
3823
|
+
|
|
3824
|
+
@property
|
|
3825
|
+
@pulumi.getter(name="patchingMode")
|
|
3826
|
+
def patching_mode(self) -> Optional[pulumi.Input[str]]:
|
|
3827
|
+
"""
|
|
3828
|
+
Cloud CloudExadataInfrastructure node patching method, either "ROLLING"
|
|
3829
|
+
or "NONROLLING". Default value is ROLLING.
|
|
3830
|
+
Possible values:
|
|
3831
|
+
PATCHING_MODE_UNSPECIFIED
|
|
3832
|
+
ROLLING
|
|
3833
|
+
NON_ROLLING
|
|
3834
|
+
"""
|
|
3835
|
+
return pulumi.get(self, "patching_mode")
|
|
3836
|
+
|
|
3837
|
+
@patching_mode.setter
|
|
3838
|
+
def patching_mode(self, value: Optional[pulumi.Input[str]]):
|
|
3839
|
+
pulumi.set(self, "patching_mode", value)
|
|
3840
|
+
|
|
3841
|
+
@property
|
|
3842
|
+
@pulumi.getter
|
|
3843
|
+
def preference(self) -> Optional[pulumi.Input[str]]:
|
|
3844
|
+
"""
|
|
3845
|
+
The maintenance window scheduling preference.
|
|
3846
|
+
Possible values:
|
|
3847
|
+
MAINTENANCE_WINDOW_PREFERENCE_UNSPECIFIED
|
|
3848
|
+
CUSTOM_PREFERENCE
|
|
3849
|
+
NO_PREFERENCE
|
|
3850
|
+
"""
|
|
3851
|
+
return pulumi.get(self, "preference")
|
|
3852
|
+
|
|
3853
|
+
@preference.setter
|
|
3854
|
+
def preference(self, value: Optional[pulumi.Input[str]]):
|
|
3855
|
+
pulumi.set(self, "preference", value)
|
|
3856
|
+
|
|
3857
|
+
@property
|
|
3858
|
+
@pulumi.getter(name="weeksOfMonths")
|
|
3859
|
+
def weeks_of_months(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[int]]]]:
|
|
3860
|
+
"""
|
|
3861
|
+
Weeks during the month when maintenance should be performed. Weeks start on
|
|
3862
|
+
the 1st, 8th, 15th, and 22nd days of the month, and have a duration of 7
|
|
3863
|
+
days. Weeks start and end based on calendar dates, not days of the week.
|
|
3864
|
+
"""
|
|
3865
|
+
return pulumi.get(self, "weeks_of_months")
|
|
3866
|
+
|
|
3867
|
+
@weeks_of_months.setter
|
|
3868
|
+
def weeks_of_months(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[int]]]]):
|
|
3869
|
+
pulumi.set(self, "weeks_of_months", value)
|
|
3870
|
+
|
|
3871
|
+
|
|
3872
|
+
if not MYPY:
|
|
3873
|
+
class CloudVmClusterPropertiesArgsDict(TypedDict):
|
|
3874
|
+
cpu_core_count: pulumi.Input[int]
|
|
3875
|
+
"""
|
|
3876
|
+
Number of enabled CPU cores.
|
|
3877
|
+
"""
|
|
3878
|
+
license_type: pulumi.Input[str]
|
|
3879
|
+
"""
|
|
3880
|
+
License type of VM Cluster.
|
|
3881
|
+
Possible values:
|
|
3882
|
+
LICENSE_TYPE_UNSPECIFIED
|
|
3883
|
+
LICENSE_INCLUDED
|
|
3884
|
+
BRING_YOUR_OWN_LICENSE
|
|
3885
|
+
"""
|
|
3886
|
+
cluster_name: NotRequired[pulumi.Input[str]]
|
|
3887
|
+
"""
|
|
3888
|
+
OCI Cluster name.
|
|
3889
|
+
"""
|
|
3890
|
+
compartment_id: NotRequired[pulumi.Input[str]]
|
|
3891
|
+
"""
|
|
3892
|
+
(Output)
|
|
3893
|
+
Compartment ID of cluster.
|
|
3894
|
+
"""
|
|
3895
|
+
data_storage_size_tb: NotRequired[pulumi.Input[float]]
|
|
3896
|
+
"""
|
|
3897
|
+
The data disk group size to be allocated in TBs.
|
|
3898
|
+
"""
|
|
3899
|
+
db_node_storage_size_gb: NotRequired[pulumi.Input[int]]
|
|
3900
|
+
"""
|
|
3901
|
+
Local storage per VM
|
|
3902
|
+
"""
|
|
3903
|
+
db_server_ocids: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
3904
|
+
"""
|
|
3905
|
+
OCID of database servers.
|
|
3906
|
+
"""
|
|
3907
|
+
diagnostics_data_collection_options: NotRequired[pulumi.Input['CloudVmClusterPropertiesDiagnosticsDataCollectionOptionsArgsDict']]
|
|
3908
|
+
"""
|
|
3909
|
+
Data collection options for diagnostics.
|
|
3910
|
+
Structure is documented below.
|
|
3911
|
+
"""
|
|
3912
|
+
disk_redundancy: NotRequired[pulumi.Input[str]]
|
|
3913
|
+
"""
|
|
3914
|
+
The type of redundancy.
|
|
3915
|
+
Possible values:
|
|
3916
|
+
DISK_REDUNDANCY_UNSPECIFIED
|
|
3917
|
+
HIGH
|
|
3918
|
+
NORMAL
|
|
3919
|
+
"""
|
|
3920
|
+
dns_listener_ip: NotRequired[pulumi.Input[str]]
|
|
3921
|
+
"""
|
|
3922
|
+
(Output)
|
|
3923
|
+
DNS listener IP.
|
|
3924
|
+
"""
|
|
3925
|
+
domain: NotRequired[pulumi.Input[str]]
|
|
3926
|
+
"""
|
|
3927
|
+
(Output)
|
|
3928
|
+
Parent DNS domain where SCAN DNS and hosts names are qualified.
|
|
3929
|
+
ex: ocispdelegated.ocisp10jvnet.oraclevcn.com
|
|
3930
|
+
"""
|
|
3931
|
+
gi_version: NotRequired[pulumi.Input[str]]
|
|
3932
|
+
"""
|
|
3933
|
+
Grid Infrastructure Version.
|
|
3934
|
+
"""
|
|
3935
|
+
hostname: NotRequired[pulumi.Input[str]]
|
|
3936
|
+
"""
|
|
3937
|
+
(Output)
|
|
3938
|
+
host name without domain.
|
|
3939
|
+
format: "-" with some suffix.
|
|
3940
|
+
ex: sp2-yi0xq where "sp2" is the hostname_prefix.
|
|
3941
|
+
"""
|
|
3942
|
+
hostname_prefix: NotRequired[pulumi.Input[str]]
|
|
3943
|
+
"""
|
|
3944
|
+
Prefix for VM cluster host names.
|
|
3945
|
+
"""
|
|
3946
|
+
local_backup_enabled: NotRequired[pulumi.Input[bool]]
|
|
3947
|
+
"""
|
|
3948
|
+
Use local backup.
|
|
3949
|
+
"""
|
|
3950
|
+
memory_size_gb: NotRequired[pulumi.Input[int]]
|
|
3951
|
+
"""
|
|
3952
|
+
Memory allocated in GBs.
|
|
3953
|
+
"""
|
|
3954
|
+
node_count: NotRequired[pulumi.Input[int]]
|
|
3955
|
+
"""
|
|
3956
|
+
Number of database servers.
|
|
3957
|
+
"""
|
|
3958
|
+
oci_url: NotRequired[pulumi.Input[str]]
|
|
3959
|
+
"""
|
|
3960
|
+
(Output)
|
|
3961
|
+
Deep link to the OCI console to view this resource.
|
|
3962
|
+
"""
|
|
3963
|
+
ocid: NotRequired[pulumi.Input[str]]
|
|
3964
|
+
"""
|
|
3965
|
+
(Output)
|
|
3966
|
+
Oracle Cloud Infrastructure ID of VM Cluster.
|
|
3967
|
+
"""
|
|
3968
|
+
ocpu_count: NotRequired[pulumi.Input[float]]
|
|
3969
|
+
"""
|
|
3970
|
+
OCPU count per VM. Minimum is 0.1.
|
|
3971
|
+
"""
|
|
3972
|
+
scan_dns: NotRequired[pulumi.Input[str]]
|
|
3973
|
+
"""
|
|
3974
|
+
(Output)
|
|
3975
|
+
SCAN DNS name.
|
|
3976
|
+
ex: sp2-yi0xq-scan.ocispdelegated.ocisp10jvnet.oraclevcn.com
|
|
3977
|
+
"""
|
|
3978
|
+
scan_dns_record_id: NotRequired[pulumi.Input[str]]
|
|
3979
|
+
"""
|
|
3980
|
+
(Output)
|
|
3981
|
+
OCID of scan DNS record.
|
|
3982
|
+
"""
|
|
3983
|
+
scan_ip_ids: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
3984
|
+
"""
|
|
3985
|
+
(Output)
|
|
3986
|
+
OCIDs of scan IPs.
|
|
3987
|
+
"""
|
|
3988
|
+
scan_listener_port_tcp: NotRequired[pulumi.Input[int]]
|
|
3989
|
+
"""
|
|
3990
|
+
(Output)
|
|
3991
|
+
SCAN listener port - TCP
|
|
3992
|
+
"""
|
|
3993
|
+
scan_listener_port_tcp_ssl: NotRequired[pulumi.Input[int]]
|
|
3994
|
+
"""
|
|
3995
|
+
(Output)
|
|
3996
|
+
SCAN listener port - TLS
|
|
3997
|
+
"""
|
|
3998
|
+
shape: NotRequired[pulumi.Input[str]]
|
|
3999
|
+
"""
|
|
4000
|
+
(Output)
|
|
4001
|
+
Shape of VM Cluster.
|
|
4002
|
+
"""
|
|
4003
|
+
sparse_diskgroup_enabled: NotRequired[pulumi.Input[bool]]
|
|
4004
|
+
"""
|
|
4005
|
+
Use exadata sparse snapshots.
|
|
4006
|
+
"""
|
|
4007
|
+
ssh_public_keys: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
4008
|
+
"""
|
|
4009
|
+
SSH public keys to be stored with cluster.
|
|
4010
|
+
"""
|
|
4011
|
+
state: NotRequired[pulumi.Input[str]]
|
|
4012
|
+
"""
|
|
4013
|
+
(Output)
|
|
4014
|
+
State of the cluster.
|
|
4015
|
+
Possible values:
|
|
4016
|
+
STATE_UNSPECIFIED
|
|
4017
|
+
PROVISIONING
|
|
4018
|
+
AVAILABLE
|
|
4019
|
+
UPDATING
|
|
4020
|
+
TERMINATING
|
|
4021
|
+
TERMINATED
|
|
4022
|
+
FAILED
|
|
4023
|
+
MAINTENANCE_IN_PROGRESS
|
|
4024
|
+
"""
|
|
4025
|
+
storage_size_gb: NotRequired[pulumi.Input[int]]
|
|
4026
|
+
"""
|
|
4027
|
+
(Output)
|
|
4028
|
+
The storage allocation for the disk group, in gigabytes (GB).
|
|
4029
|
+
"""
|
|
4030
|
+
system_version: NotRequired[pulumi.Input[str]]
|
|
4031
|
+
"""
|
|
4032
|
+
(Output)
|
|
4033
|
+
Operating system version of the image.
|
|
4034
|
+
"""
|
|
4035
|
+
time_zone: NotRequired[pulumi.Input['CloudVmClusterPropertiesTimeZoneArgsDict']]
|
|
4036
|
+
"""
|
|
4037
|
+
Represents a time zone from the
|
|
4038
|
+
[IANA Time Zone Database](https://www.iana.org/time-zones).
|
|
4039
|
+
Structure is documented below.
|
|
4040
|
+
"""
|
|
4041
|
+
elif False:
|
|
4042
|
+
CloudVmClusterPropertiesArgsDict: TypeAlias = Mapping[str, Any]
|
|
4043
|
+
|
|
4044
|
+
@pulumi.input_type
|
|
4045
|
+
class CloudVmClusterPropertiesArgs:
|
|
4046
|
+
def __init__(__self__, *,
|
|
4047
|
+
cpu_core_count: pulumi.Input[int],
|
|
4048
|
+
license_type: pulumi.Input[str],
|
|
4049
|
+
cluster_name: Optional[pulumi.Input[str]] = None,
|
|
4050
|
+
compartment_id: Optional[pulumi.Input[str]] = None,
|
|
4051
|
+
data_storage_size_tb: Optional[pulumi.Input[float]] = None,
|
|
4052
|
+
db_node_storage_size_gb: Optional[pulumi.Input[int]] = None,
|
|
4053
|
+
db_server_ocids: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
4054
|
+
diagnostics_data_collection_options: Optional[pulumi.Input['CloudVmClusterPropertiesDiagnosticsDataCollectionOptionsArgs']] = None,
|
|
4055
|
+
disk_redundancy: Optional[pulumi.Input[str]] = None,
|
|
4056
|
+
dns_listener_ip: Optional[pulumi.Input[str]] = None,
|
|
4057
|
+
domain: Optional[pulumi.Input[str]] = None,
|
|
4058
|
+
gi_version: Optional[pulumi.Input[str]] = None,
|
|
4059
|
+
hostname: Optional[pulumi.Input[str]] = None,
|
|
4060
|
+
hostname_prefix: Optional[pulumi.Input[str]] = None,
|
|
4061
|
+
local_backup_enabled: Optional[pulumi.Input[bool]] = None,
|
|
4062
|
+
memory_size_gb: Optional[pulumi.Input[int]] = None,
|
|
4063
|
+
node_count: Optional[pulumi.Input[int]] = None,
|
|
4064
|
+
oci_url: Optional[pulumi.Input[str]] = None,
|
|
4065
|
+
ocid: Optional[pulumi.Input[str]] = None,
|
|
4066
|
+
ocpu_count: Optional[pulumi.Input[float]] = None,
|
|
4067
|
+
scan_dns: Optional[pulumi.Input[str]] = None,
|
|
4068
|
+
scan_dns_record_id: Optional[pulumi.Input[str]] = None,
|
|
4069
|
+
scan_ip_ids: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
4070
|
+
scan_listener_port_tcp: Optional[pulumi.Input[int]] = None,
|
|
4071
|
+
scan_listener_port_tcp_ssl: Optional[pulumi.Input[int]] = None,
|
|
4072
|
+
shape: Optional[pulumi.Input[str]] = None,
|
|
4073
|
+
sparse_diskgroup_enabled: Optional[pulumi.Input[bool]] = None,
|
|
4074
|
+
ssh_public_keys: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
4075
|
+
state: Optional[pulumi.Input[str]] = None,
|
|
4076
|
+
storage_size_gb: Optional[pulumi.Input[int]] = None,
|
|
4077
|
+
system_version: Optional[pulumi.Input[str]] = None,
|
|
4078
|
+
time_zone: Optional[pulumi.Input['CloudVmClusterPropertiesTimeZoneArgs']] = None):
|
|
4079
|
+
"""
|
|
4080
|
+
:param pulumi.Input[int] cpu_core_count: Number of enabled CPU cores.
|
|
4081
|
+
:param pulumi.Input[str] license_type: License type of VM Cluster.
|
|
4082
|
+
Possible values:
|
|
4083
|
+
LICENSE_TYPE_UNSPECIFIED
|
|
4084
|
+
LICENSE_INCLUDED
|
|
4085
|
+
BRING_YOUR_OWN_LICENSE
|
|
4086
|
+
:param pulumi.Input[str] cluster_name: OCI Cluster name.
|
|
4087
|
+
:param pulumi.Input[str] compartment_id: (Output)
|
|
4088
|
+
Compartment ID of cluster.
|
|
4089
|
+
:param pulumi.Input[float] data_storage_size_tb: The data disk group size to be allocated in TBs.
|
|
4090
|
+
:param pulumi.Input[int] db_node_storage_size_gb: Local storage per VM
|
|
4091
|
+
:param pulumi.Input[Sequence[pulumi.Input[str]]] db_server_ocids: OCID of database servers.
|
|
4092
|
+
:param pulumi.Input['CloudVmClusterPropertiesDiagnosticsDataCollectionOptionsArgs'] diagnostics_data_collection_options: Data collection options for diagnostics.
|
|
4093
|
+
Structure is documented below.
|
|
4094
|
+
:param pulumi.Input[str] disk_redundancy: The type of redundancy.
|
|
4095
|
+
Possible values:
|
|
4096
|
+
DISK_REDUNDANCY_UNSPECIFIED
|
|
4097
|
+
HIGH
|
|
4098
|
+
NORMAL
|
|
4099
|
+
:param pulumi.Input[str] dns_listener_ip: (Output)
|
|
4100
|
+
DNS listener IP.
|
|
4101
|
+
:param pulumi.Input[str] domain: (Output)
|
|
4102
|
+
Parent DNS domain where SCAN DNS and hosts names are qualified.
|
|
4103
|
+
ex: ocispdelegated.ocisp10jvnet.oraclevcn.com
|
|
4104
|
+
:param pulumi.Input[str] gi_version: Grid Infrastructure Version.
|
|
4105
|
+
:param pulumi.Input[str] hostname: (Output)
|
|
4106
|
+
host name without domain.
|
|
4107
|
+
format: "-" with some suffix.
|
|
4108
|
+
ex: sp2-yi0xq where "sp2" is the hostname_prefix.
|
|
4109
|
+
:param pulumi.Input[str] hostname_prefix: Prefix for VM cluster host names.
|
|
4110
|
+
:param pulumi.Input[bool] local_backup_enabled: Use local backup.
|
|
4111
|
+
:param pulumi.Input[int] memory_size_gb: Memory allocated in GBs.
|
|
4112
|
+
:param pulumi.Input[int] node_count: Number of database servers.
|
|
4113
|
+
:param pulumi.Input[str] oci_url: (Output)
|
|
4114
|
+
Deep link to the OCI console to view this resource.
|
|
4115
|
+
:param pulumi.Input[str] ocid: (Output)
|
|
4116
|
+
Oracle Cloud Infrastructure ID of VM Cluster.
|
|
4117
|
+
:param pulumi.Input[float] ocpu_count: OCPU count per VM. Minimum is 0.1.
|
|
4118
|
+
:param pulumi.Input[str] scan_dns: (Output)
|
|
4119
|
+
SCAN DNS name.
|
|
4120
|
+
ex: sp2-yi0xq-scan.ocispdelegated.ocisp10jvnet.oraclevcn.com
|
|
4121
|
+
:param pulumi.Input[str] scan_dns_record_id: (Output)
|
|
4122
|
+
OCID of scan DNS record.
|
|
4123
|
+
:param pulumi.Input[Sequence[pulumi.Input[str]]] scan_ip_ids: (Output)
|
|
4124
|
+
OCIDs of scan IPs.
|
|
4125
|
+
:param pulumi.Input[int] scan_listener_port_tcp: (Output)
|
|
4126
|
+
SCAN listener port - TCP
|
|
4127
|
+
:param pulumi.Input[int] scan_listener_port_tcp_ssl: (Output)
|
|
4128
|
+
SCAN listener port - TLS
|
|
4129
|
+
:param pulumi.Input[str] shape: (Output)
|
|
4130
|
+
Shape of VM Cluster.
|
|
4131
|
+
:param pulumi.Input[bool] sparse_diskgroup_enabled: Use exadata sparse snapshots.
|
|
4132
|
+
:param pulumi.Input[Sequence[pulumi.Input[str]]] ssh_public_keys: SSH public keys to be stored with cluster.
|
|
4133
|
+
:param pulumi.Input[str] state: (Output)
|
|
4134
|
+
State of the cluster.
|
|
4135
|
+
Possible values:
|
|
4136
|
+
STATE_UNSPECIFIED
|
|
4137
|
+
PROVISIONING
|
|
4138
|
+
AVAILABLE
|
|
4139
|
+
UPDATING
|
|
4140
|
+
TERMINATING
|
|
4141
|
+
TERMINATED
|
|
4142
|
+
FAILED
|
|
4143
|
+
MAINTENANCE_IN_PROGRESS
|
|
4144
|
+
:param pulumi.Input[int] storage_size_gb: (Output)
|
|
4145
|
+
The storage allocation for the disk group, in gigabytes (GB).
|
|
4146
|
+
:param pulumi.Input[str] system_version: (Output)
|
|
4147
|
+
Operating system version of the image.
|
|
4148
|
+
:param pulumi.Input['CloudVmClusterPropertiesTimeZoneArgs'] time_zone: Represents a time zone from the
|
|
4149
|
+
[IANA Time Zone Database](https://www.iana.org/time-zones).
|
|
4150
|
+
Structure is documented below.
|
|
4151
|
+
"""
|
|
4152
|
+
pulumi.set(__self__, "cpu_core_count", cpu_core_count)
|
|
4153
|
+
pulumi.set(__self__, "license_type", license_type)
|
|
4154
|
+
if cluster_name is not None:
|
|
4155
|
+
pulumi.set(__self__, "cluster_name", cluster_name)
|
|
4156
|
+
if compartment_id is not None:
|
|
4157
|
+
pulumi.set(__self__, "compartment_id", compartment_id)
|
|
4158
|
+
if data_storage_size_tb is not None:
|
|
4159
|
+
pulumi.set(__self__, "data_storage_size_tb", data_storage_size_tb)
|
|
4160
|
+
if db_node_storage_size_gb is not None:
|
|
4161
|
+
pulumi.set(__self__, "db_node_storage_size_gb", db_node_storage_size_gb)
|
|
4162
|
+
if db_server_ocids is not None:
|
|
4163
|
+
pulumi.set(__self__, "db_server_ocids", db_server_ocids)
|
|
4164
|
+
if diagnostics_data_collection_options is not None:
|
|
4165
|
+
pulumi.set(__self__, "diagnostics_data_collection_options", diagnostics_data_collection_options)
|
|
4166
|
+
if disk_redundancy is not None:
|
|
4167
|
+
pulumi.set(__self__, "disk_redundancy", disk_redundancy)
|
|
4168
|
+
if dns_listener_ip is not None:
|
|
4169
|
+
pulumi.set(__self__, "dns_listener_ip", dns_listener_ip)
|
|
4170
|
+
if domain is not None:
|
|
4171
|
+
pulumi.set(__self__, "domain", domain)
|
|
4172
|
+
if gi_version is not None:
|
|
4173
|
+
pulumi.set(__self__, "gi_version", gi_version)
|
|
4174
|
+
if hostname is not None:
|
|
4175
|
+
pulumi.set(__self__, "hostname", hostname)
|
|
4176
|
+
if hostname_prefix is not None:
|
|
4177
|
+
pulumi.set(__self__, "hostname_prefix", hostname_prefix)
|
|
4178
|
+
if local_backup_enabled is not None:
|
|
4179
|
+
pulumi.set(__self__, "local_backup_enabled", local_backup_enabled)
|
|
4180
|
+
if memory_size_gb is not None:
|
|
4181
|
+
pulumi.set(__self__, "memory_size_gb", memory_size_gb)
|
|
4182
|
+
if node_count is not None:
|
|
4183
|
+
pulumi.set(__self__, "node_count", node_count)
|
|
4184
|
+
if oci_url is not None:
|
|
4185
|
+
pulumi.set(__self__, "oci_url", oci_url)
|
|
4186
|
+
if ocid is not None:
|
|
4187
|
+
pulumi.set(__self__, "ocid", ocid)
|
|
4188
|
+
if ocpu_count is not None:
|
|
4189
|
+
pulumi.set(__self__, "ocpu_count", ocpu_count)
|
|
4190
|
+
if scan_dns is not None:
|
|
4191
|
+
pulumi.set(__self__, "scan_dns", scan_dns)
|
|
4192
|
+
if scan_dns_record_id is not None:
|
|
4193
|
+
pulumi.set(__self__, "scan_dns_record_id", scan_dns_record_id)
|
|
4194
|
+
if scan_ip_ids is not None:
|
|
4195
|
+
pulumi.set(__self__, "scan_ip_ids", scan_ip_ids)
|
|
4196
|
+
if scan_listener_port_tcp is not None:
|
|
4197
|
+
pulumi.set(__self__, "scan_listener_port_tcp", scan_listener_port_tcp)
|
|
4198
|
+
if scan_listener_port_tcp_ssl is not None:
|
|
4199
|
+
pulumi.set(__self__, "scan_listener_port_tcp_ssl", scan_listener_port_tcp_ssl)
|
|
4200
|
+
if shape is not None:
|
|
4201
|
+
pulumi.set(__self__, "shape", shape)
|
|
4202
|
+
if sparse_diskgroup_enabled is not None:
|
|
4203
|
+
pulumi.set(__self__, "sparse_diskgroup_enabled", sparse_diskgroup_enabled)
|
|
4204
|
+
if ssh_public_keys is not None:
|
|
4205
|
+
pulumi.set(__self__, "ssh_public_keys", ssh_public_keys)
|
|
4206
|
+
if state is not None:
|
|
4207
|
+
pulumi.set(__self__, "state", state)
|
|
4208
|
+
if storage_size_gb is not None:
|
|
4209
|
+
pulumi.set(__self__, "storage_size_gb", storage_size_gb)
|
|
4210
|
+
if system_version is not None:
|
|
4211
|
+
pulumi.set(__self__, "system_version", system_version)
|
|
4212
|
+
if time_zone is not None:
|
|
4213
|
+
pulumi.set(__self__, "time_zone", time_zone)
|
|
4214
|
+
|
|
4215
|
+
@property
|
|
4216
|
+
@pulumi.getter(name="cpuCoreCount")
|
|
4217
|
+
def cpu_core_count(self) -> pulumi.Input[int]:
|
|
4218
|
+
"""
|
|
4219
|
+
Number of enabled CPU cores.
|
|
4220
|
+
"""
|
|
4221
|
+
return pulumi.get(self, "cpu_core_count")
|
|
4222
|
+
|
|
4223
|
+
@cpu_core_count.setter
|
|
4224
|
+
def cpu_core_count(self, value: pulumi.Input[int]):
|
|
4225
|
+
pulumi.set(self, "cpu_core_count", value)
|
|
4226
|
+
|
|
4227
|
+
@property
|
|
4228
|
+
@pulumi.getter(name="licenseType")
|
|
4229
|
+
def license_type(self) -> pulumi.Input[str]:
|
|
4230
|
+
"""
|
|
4231
|
+
License type of VM Cluster.
|
|
4232
|
+
Possible values:
|
|
4233
|
+
LICENSE_TYPE_UNSPECIFIED
|
|
4234
|
+
LICENSE_INCLUDED
|
|
4235
|
+
BRING_YOUR_OWN_LICENSE
|
|
4236
|
+
"""
|
|
4237
|
+
return pulumi.get(self, "license_type")
|
|
4238
|
+
|
|
4239
|
+
@license_type.setter
|
|
4240
|
+
def license_type(self, value: pulumi.Input[str]):
|
|
4241
|
+
pulumi.set(self, "license_type", value)
|
|
4242
|
+
|
|
4243
|
+
@property
|
|
4244
|
+
@pulumi.getter(name="clusterName")
|
|
4245
|
+
def cluster_name(self) -> Optional[pulumi.Input[str]]:
|
|
4246
|
+
"""
|
|
4247
|
+
OCI Cluster name.
|
|
4248
|
+
"""
|
|
4249
|
+
return pulumi.get(self, "cluster_name")
|
|
4250
|
+
|
|
4251
|
+
@cluster_name.setter
|
|
4252
|
+
def cluster_name(self, value: Optional[pulumi.Input[str]]):
|
|
4253
|
+
pulumi.set(self, "cluster_name", value)
|
|
4254
|
+
|
|
4255
|
+
@property
|
|
4256
|
+
@pulumi.getter(name="compartmentId")
|
|
4257
|
+
def compartment_id(self) -> Optional[pulumi.Input[str]]:
|
|
4258
|
+
"""
|
|
4259
|
+
(Output)
|
|
4260
|
+
Compartment ID of cluster.
|
|
4261
|
+
"""
|
|
4262
|
+
return pulumi.get(self, "compartment_id")
|
|
4263
|
+
|
|
4264
|
+
@compartment_id.setter
|
|
4265
|
+
def compartment_id(self, value: Optional[pulumi.Input[str]]):
|
|
4266
|
+
pulumi.set(self, "compartment_id", value)
|
|
4267
|
+
|
|
4268
|
+
@property
|
|
4269
|
+
@pulumi.getter(name="dataStorageSizeTb")
|
|
4270
|
+
def data_storage_size_tb(self) -> Optional[pulumi.Input[float]]:
|
|
4271
|
+
"""
|
|
4272
|
+
The data disk group size to be allocated in TBs.
|
|
4273
|
+
"""
|
|
4274
|
+
return pulumi.get(self, "data_storage_size_tb")
|
|
4275
|
+
|
|
4276
|
+
@data_storage_size_tb.setter
|
|
4277
|
+
def data_storage_size_tb(self, value: Optional[pulumi.Input[float]]):
|
|
4278
|
+
pulumi.set(self, "data_storage_size_tb", value)
|
|
4279
|
+
|
|
4280
|
+
@property
|
|
4281
|
+
@pulumi.getter(name="dbNodeStorageSizeGb")
|
|
4282
|
+
def db_node_storage_size_gb(self) -> Optional[pulumi.Input[int]]:
|
|
4283
|
+
"""
|
|
4284
|
+
Local storage per VM
|
|
4285
|
+
"""
|
|
4286
|
+
return pulumi.get(self, "db_node_storage_size_gb")
|
|
4287
|
+
|
|
4288
|
+
@db_node_storage_size_gb.setter
|
|
4289
|
+
def db_node_storage_size_gb(self, value: Optional[pulumi.Input[int]]):
|
|
4290
|
+
pulumi.set(self, "db_node_storage_size_gb", value)
|
|
4291
|
+
|
|
4292
|
+
@property
|
|
4293
|
+
@pulumi.getter(name="dbServerOcids")
|
|
4294
|
+
def db_server_ocids(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
4295
|
+
"""
|
|
4296
|
+
OCID of database servers.
|
|
4297
|
+
"""
|
|
4298
|
+
return pulumi.get(self, "db_server_ocids")
|
|
4299
|
+
|
|
4300
|
+
@db_server_ocids.setter
|
|
4301
|
+
def db_server_ocids(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
4302
|
+
pulumi.set(self, "db_server_ocids", value)
|
|
4303
|
+
|
|
4304
|
+
@property
|
|
4305
|
+
@pulumi.getter(name="diagnosticsDataCollectionOptions")
|
|
4306
|
+
def diagnostics_data_collection_options(self) -> Optional[pulumi.Input['CloudVmClusterPropertiesDiagnosticsDataCollectionOptionsArgs']]:
|
|
4307
|
+
"""
|
|
4308
|
+
Data collection options for diagnostics.
|
|
4309
|
+
Structure is documented below.
|
|
4310
|
+
"""
|
|
4311
|
+
return pulumi.get(self, "diagnostics_data_collection_options")
|
|
4312
|
+
|
|
4313
|
+
@diagnostics_data_collection_options.setter
|
|
4314
|
+
def diagnostics_data_collection_options(self, value: Optional[pulumi.Input['CloudVmClusterPropertiesDiagnosticsDataCollectionOptionsArgs']]):
|
|
4315
|
+
pulumi.set(self, "diagnostics_data_collection_options", value)
|
|
4316
|
+
|
|
4317
|
+
@property
|
|
4318
|
+
@pulumi.getter(name="diskRedundancy")
|
|
4319
|
+
def disk_redundancy(self) -> Optional[pulumi.Input[str]]:
|
|
4320
|
+
"""
|
|
4321
|
+
The type of redundancy.
|
|
4322
|
+
Possible values:
|
|
4323
|
+
DISK_REDUNDANCY_UNSPECIFIED
|
|
4324
|
+
HIGH
|
|
4325
|
+
NORMAL
|
|
4326
|
+
"""
|
|
4327
|
+
return pulumi.get(self, "disk_redundancy")
|
|
4328
|
+
|
|
4329
|
+
@disk_redundancy.setter
|
|
4330
|
+
def disk_redundancy(self, value: Optional[pulumi.Input[str]]):
|
|
4331
|
+
pulumi.set(self, "disk_redundancy", value)
|
|
4332
|
+
|
|
4333
|
+
@property
|
|
4334
|
+
@pulumi.getter(name="dnsListenerIp")
|
|
4335
|
+
def dns_listener_ip(self) -> Optional[pulumi.Input[str]]:
|
|
4336
|
+
"""
|
|
4337
|
+
(Output)
|
|
4338
|
+
DNS listener IP.
|
|
4339
|
+
"""
|
|
4340
|
+
return pulumi.get(self, "dns_listener_ip")
|
|
4341
|
+
|
|
4342
|
+
@dns_listener_ip.setter
|
|
4343
|
+
def dns_listener_ip(self, value: Optional[pulumi.Input[str]]):
|
|
4344
|
+
pulumi.set(self, "dns_listener_ip", value)
|
|
4345
|
+
|
|
4346
|
+
@property
|
|
4347
|
+
@pulumi.getter
|
|
4348
|
+
def domain(self) -> Optional[pulumi.Input[str]]:
|
|
4349
|
+
"""
|
|
4350
|
+
(Output)
|
|
4351
|
+
Parent DNS domain where SCAN DNS and hosts names are qualified.
|
|
4352
|
+
ex: ocispdelegated.ocisp10jvnet.oraclevcn.com
|
|
4353
|
+
"""
|
|
4354
|
+
return pulumi.get(self, "domain")
|
|
4355
|
+
|
|
4356
|
+
@domain.setter
|
|
4357
|
+
def domain(self, value: Optional[pulumi.Input[str]]):
|
|
4358
|
+
pulumi.set(self, "domain", value)
|
|
4359
|
+
|
|
4360
|
+
@property
|
|
4361
|
+
@pulumi.getter(name="giVersion")
|
|
4362
|
+
def gi_version(self) -> Optional[pulumi.Input[str]]:
|
|
4363
|
+
"""
|
|
4364
|
+
Grid Infrastructure Version.
|
|
4365
|
+
"""
|
|
4366
|
+
return pulumi.get(self, "gi_version")
|
|
4367
|
+
|
|
4368
|
+
@gi_version.setter
|
|
4369
|
+
def gi_version(self, value: Optional[pulumi.Input[str]]):
|
|
4370
|
+
pulumi.set(self, "gi_version", value)
|
|
4371
|
+
|
|
4372
|
+
@property
|
|
4373
|
+
@pulumi.getter
|
|
4374
|
+
def hostname(self) -> Optional[pulumi.Input[str]]:
|
|
4375
|
+
"""
|
|
4376
|
+
(Output)
|
|
4377
|
+
host name without domain.
|
|
4378
|
+
format: "-" with some suffix.
|
|
4379
|
+
ex: sp2-yi0xq where "sp2" is the hostname_prefix.
|
|
4380
|
+
"""
|
|
4381
|
+
return pulumi.get(self, "hostname")
|
|
4382
|
+
|
|
4383
|
+
@hostname.setter
|
|
4384
|
+
def hostname(self, value: Optional[pulumi.Input[str]]):
|
|
4385
|
+
pulumi.set(self, "hostname", value)
|
|
4386
|
+
|
|
4387
|
+
@property
|
|
4388
|
+
@pulumi.getter(name="hostnamePrefix")
|
|
4389
|
+
def hostname_prefix(self) -> Optional[pulumi.Input[str]]:
|
|
4390
|
+
"""
|
|
4391
|
+
Prefix for VM cluster host names.
|
|
4392
|
+
"""
|
|
4393
|
+
return pulumi.get(self, "hostname_prefix")
|
|
4394
|
+
|
|
4395
|
+
@hostname_prefix.setter
|
|
4396
|
+
def hostname_prefix(self, value: Optional[pulumi.Input[str]]):
|
|
4397
|
+
pulumi.set(self, "hostname_prefix", value)
|
|
4398
|
+
|
|
4399
|
+
@property
|
|
4400
|
+
@pulumi.getter(name="localBackupEnabled")
|
|
4401
|
+
def local_backup_enabled(self) -> Optional[pulumi.Input[bool]]:
|
|
4402
|
+
"""
|
|
4403
|
+
Use local backup.
|
|
4404
|
+
"""
|
|
4405
|
+
return pulumi.get(self, "local_backup_enabled")
|
|
4406
|
+
|
|
4407
|
+
@local_backup_enabled.setter
|
|
4408
|
+
def local_backup_enabled(self, value: Optional[pulumi.Input[bool]]):
|
|
4409
|
+
pulumi.set(self, "local_backup_enabled", value)
|
|
4410
|
+
|
|
4411
|
+
@property
|
|
4412
|
+
@pulumi.getter(name="memorySizeGb")
|
|
4413
|
+
def memory_size_gb(self) -> Optional[pulumi.Input[int]]:
|
|
4414
|
+
"""
|
|
4415
|
+
Memory allocated in GBs.
|
|
4416
|
+
"""
|
|
4417
|
+
return pulumi.get(self, "memory_size_gb")
|
|
4418
|
+
|
|
4419
|
+
@memory_size_gb.setter
|
|
4420
|
+
def memory_size_gb(self, value: Optional[pulumi.Input[int]]):
|
|
4421
|
+
pulumi.set(self, "memory_size_gb", value)
|
|
4422
|
+
|
|
4423
|
+
@property
|
|
4424
|
+
@pulumi.getter(name="nodeCount")
|
|
4425
|
+
def node_count(self) -> Optional[pulumi.Input[int]]:
|
|
4426
|
+
"""
|
|
4427
|
+
Number of database servers.
|
|
4428
|
+
"""
|
|
4429
|
+
return pulumi.get(self, "node_count")
|
|
4430
|
+
|
|
4431
|
+
@node_count.setter
|
|
4432
|
+
def node_count(self, value: Optional[pulumi.Input[int]]):
|
|
4433
|
+
pulumi.set(self, "node_count", value)
|
|
4434
|
+
|
|
4435
|
+
@property
|
|
4436
|
+
@pulumi.getter(name="ociUrl")
|
|
4437
|
+
def oci_url(self) -> Optional[pulumi.Input[str]]:
|
|
4438
|
+
"""
|
|
4439
|
+
(Output)
|
|
4440
|
+
Deep link to the OCI console to view this resource.
|
|
4441
|
+
"""
|
|
4442
|
+
return pulumi.get(self, "oci_url")
|
|
4443
|
+
|
|
4444
|
+
@oci_url.setter
|
|
4445
|
+
def oci_url(self, value: Optional[pulumi.Input[str]]):
|
|
4446
|
+
pulumi.set(self, "oci_url", value)
|
|
4447
|
+
|
|
4448
|
+
@property
|
|
4449
|
+
@pulumi.getter
|
|
4450
|
+
def ocid(self) -> Optional[pulumi.Input[str]]:
|
|
4451
|
+
"""
|
|
4452
|
+
(Output)
|
|
4453
|
+
Oracle Cloud Infrastructure ID of VM Cluster.
|
|
4454
|
+
"""
|
|
4455
|
+
return pulumi.get(self, "ocid")
|
|
4456
|
+
|
|
4457
|
+
@ocid.setter
|
|
4458
|
+
def ocid(self, value: Optional[pulumi.Input[str]]):
|
|
4459
|
+
pulumi.set(self, "ocid", value)
|
|
4460
|
+
|
|
4461
|
+
@property
|
|
4462
|
+
@pulumi.getter(name="ocpuCount")
|
|
4463
|
+
def ocpu_count(self) -> Optional[pulumi.Input[float]]:
|
|
4464
|
+
"""
|
|
4465
|
+
OCPU count per VM. Minimum is 0.1.
|
|
4466
|
+
"""
|
|
4467
|
+
return pulumi.get(self, "ocpu_count")
|
|
4468
|
+
|
|
4469
|
+
@ocpu_count.setter
|
|
4470
|
+
def ocpu_count(self, value: Optional[pulumi.Input[float]]):
|
|
4471
|
+
pulumi.set(self, "ocpu_count", value)
|
|
4472
|
+
|
|
4473
|
+
@property
|
|
4474
|
+
@pulumi.getter(name="scanDns")
|
|
4475
|
+
def scan_dns(self) -> Optional[pulumi.Input[str]]:
|
|
4476
|
+
"""
|
|
4477
|
+
(Output)
|
|
4478
|
+
SCAN DNS name.
|
|
4479
|
+
ex: sp2-yi0xq-scan.ocispdelegated.ocisp10jvnet.oraclevcn.com
|
|
4480
|
+
"""
|
|
4481
|
+
return pulumi.get(self, "scan_dns")
|
|
4482
|
+
|
|
4483
|
+
@scan_dns.setter
|
|
4484
|
+
def scan_dns(self, value: Optional[pulumi.Input[str]]):
|
|
4485
|
+
pulumi.set(self, "scan_dns", value)
|
|
4486
|
+
|
|
4487
|
+
@property
|
|
4488
|
+
@pulumi.getter(name="scanDnsRecordId")
|
|
4489
|
+
def scan_dns_record_id(self) -> Optional[pulumi.Input[str]]:
|
|
4490
|
+
"""
|
|
4491
|
+
(Output)
|
|
4492
|
+
OCID of scan DNS record.
|
|
4493
|
+
"""
|
|
4494
|
+
return pulumi.get(self, "scan_dns_record_id")
|
|
4495
|
+
|
|
4496
|
+
@scan_dns_record_id.setter
|
|
4497
|
+
def scan_dns_record_id(self, value: Optional[pulumi.Input[str]]):
|
|
4498
|
+
pulumi.set(self, "scan_dns_record_id", value)
|
|
4499
|
+
|
|
4500
|
+
@property
|
|
4501
|
+
@pulumi.getter(name="scanIpIds")
|
|
4502
|
+
def scan_ip_ids(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
4503
|
+
"""
|
|
4504
|
+
(Output)
|
|
4505
|
+
OCIDs of scan IPs.
|
|
4506
|
+
"""
|
|
4507
|
+
return pulumi.get(self, "scan_ip_ids")
|
|
4508
|
+
|
|
4509
|
+
@scan_ip_ids.setter
|
|
4510
|
+
def scan_ip_ids(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
4511
|
+
pulumi.set(self, "scan_ip_ids", value)
|
|
4512
|
+
|
|
4513
|
+
@property
|
|
4514
|
+
@pulumi.getter(name="scanListenerPortTcp")
|
|
4515
|
+
def scan_listener_port_tcp(self) -> Optional[pulumi.Input[int]]:
|
|
4516
|
+
"""
|
|
4517
|
+
(Output)
|
|
4518
|
+
SCAN listener port - TCP
|
|
4519
|
+
"""
|
|
4520
|
+
return pulumi.get(self, "scan_listener_port_tcp")
|
|
4521
|
+
|
|
4522
|
+
@scan_listener_port_tcp.setter
|
|
4523
|
+
def scan_listener_port_tcp(self, value: Optional[pulumi.Input[int]]):
|
|
4524
|
+
pulumi.set(self, "scan_listener_port_tcp", value)
|
|
4525
|
+
|
|
4526
|
+
@property
|
|
4527
|
+
@pulumi.getter(name="scanListenerPortTcpSsl")
|
|
4528
|
+
def scan_listener_port_tcp_ssl(self) -> Optional[pulumi.Input[int]]:
|
|
4529
|
+
"""
|
|
4530
|
+
(Output)
|
|
4531
|
+
SCAN listener port - TLS
|
|
4532
|
+
"""
|
|
4533
|
+
return pulumi.get(self, "scan_listener_port_tcp_ssl")
|
|
4534
|
+
|
|
4535
|
+
@scan_listener_port_tcp_ssl.setter
|
|
4536
|
+
def scan_listener_port_tcp_ssl(self, value: Optional[pulumi.Input[int]]):
|
|
4537
|
+
pulumi.set(self, "scan_listener_port_tcp_ssl", value)
|
|
4538
|
+
|
|
4539
|
+
@property
|
|
4540
|
+
@pulumi.getter
|
|
4541
|
+
def shape(self) -> Optional[pulumi.Input[str]]:
|
|
4542
|
+
"""
|
|
4543
|
+
(Output)
|
|
4544
|
+
Shape of VM Cluster.
|
|
4545
|
+
"""
|
|
4546
|
+
return pulumi.get(self, "shape")
|
|
4547
|
+
|
|
4548
|
+
@shape.setter
|
|
4549
|
+
def shape(self, value: Optional[pulumi.Input[str]]):
|
|
4550
|
+
pulumi.set(self, "shape", value)
|
|
4551
|
+
|
|
4552
|
+
@property
|
|
4553
|
+
@pulumi.getter(name="sparseDiskgroupEnabled")
|
|
4554
|
+
def sparse_diskgroup_enabled(self) -> Optional[pulumi.Input[bool]]:
|
|
4555
|
+
"""
|
|
4556
|
+
Use exadata sparse snapshots.
|
|
4557
|
+
"""
|
|
4558
|
+
return pulumi.get(self, "sparse_diskgroup_enabled")
|
|
4559
|
+
|
|
4560
|
+
@sparse_diskgroup_enabled.setter
|
|
4561
|
+
def sparse_diskgroup_enabled(self, value: Optional[pulumi.Input[bool]]):
|
|
4562
|
+
pulumi.set(self, "sparse_diskgroup_enabled", value)
|
|
4563
|
+
|
|
4564
|
+
@property
|
|
4565
|
+
@pulumi.getter(name="sshPublicKeys")
|
|
4566
|
+
def ssh_public_keys(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
4567
|
+
"""
|
|
4568
|
+
SSH public keys to be stored with cluster.
|
|
4569
|
+
"""
|
|
4570
|
+
return pulumi.get(self, "ssh_public_keys")
|
|
4571
|
+
|
|
4572
|
+
@ssh_public_keys.setter
|
|
4573
|
+
def ssh_public_keys(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
4574
|
+
pulumi.set(self, "ssh_public_keys", value)
|
|
4575
|
+
|
|
4576
|
+
@property
|
|
4577
|
+
@pulumi.getter
|
|
4578
|
+
def state(self) -> Optional[pulumi.Input[str]]:
|
|
4579
|
+
"""
|
|
4580
|
+
(Output)
|
|
4581
|
+
State of the cluster.
|
|
4582
|
+
Possible values:
|
|
4583
|
+
STATE_UNSPECIFIED
|
|
4584
|
+
PROVISIONING
|
|
4585
|
+
AVAILABLE
|
|
4586
|
+
UPDATING
|
|
4587
|
+
TERMINATING
|
|
4588
|
+
TERMINATED
|
|
4589
|
+
FAILED
|
|
4590
|
+
MAINTENANCE_IN_PROGRESS
|
|
4591
|
+
"""
|
|
4592
|
+
return pulumi.get(self, "state")
|
|
4593
|
+
|
|
4594
|
+
@state.setter
|
|
4595
|
+
def state(self, value: Optional[pulumi.Input[str]]):
|
|
4596
|
+
pulumi.set(self, "state", value)
|
|
4597
|
+
|
|
4598
|
+
@property
|
|
4599
|
+
@pulumi.getter(name="storageSizeGb")
|
|
4600
|
+
def storage_size_gb(self) -> Optional[pulumi.Input[int]]:
|
|
4601
|
+
"""
|
|
4602
|
+
(Output)
|
|
4603
|
+
The storage allocation for the disk group, in gigabytes (GB).
|
|
4604
|
+
"""
|
|
4605
|
+
return pulumi.get(self, "storage_size_gb")
|
|
4606
|
+
|
|
4607
|
+
@storage_size_gb.setter
|
|
4608
|
+
def storage_size_gb(self, value: Optional[pulumi.Input[int]]):
|
|
4609
|
+
pulumi.set(self, "storage_size_gb", value)
|
|
4610
|
+
|
|
4611
|
+
@property
|
|
4612
|
+
@pulumi.getter(name="systemVersion")
|
|
4613
|
+
def system_version(self) -> Optional[pulumi.Input[str]]:
|
|
4614
|
+
"""
|
|
4615
|
+
(Output)
|
|
4616
|
+
Operating system version of the image.
|
|
4617
|
+
"""
|
|
4618
|
+
return pulumi.get(self, "system_version")
|
|
4619
|
+
|
|
4620
|
+
@system_version.setter
|
|
4621
|
+
def system_version(self, value: Optional[pulumi.Input[str]]):
|
|
4622
|
+
pulumi.set(self, "system_version", value)
|
|
4623
|
+
|
|
4624
|
+
@property
|
|
4625
|
+
@pulumi.getter(name="timeZone")
|
|
4626
|
+
def time_zone(self) -> Optional[pulumi.Input['CloudVmClusterPropertiesTimeZoneArgs']]:
|
|
4627
|
+
"""
|
|
4628
|
+
Represents a time zone from the
|
|
4629
|
+
[IANA Time Zone Database](https://www.iana.org/time-zones).
|
|
4630
|
+
Structure is documented below.
|
|
4631
|
+
"""
|
|
4632
|
+
return pulumi.get(self, "time_zone")
|
|
4633
|
+
|
|
4634
|
+
@time_zone.setter
|
|
4635
|
+
def time_zone(self, value: Optional[pulumi.Input['CloudVmClusterPropertiesTimeZoneArgs']]):
|
|
4636
|
+
pulumi.set(self, "time_zone", value)
|
|
4637
|
+
|
|
4638
|
+
|
|
4639
|
+
if not MYPY:
|
|
4640
|
+
class CloudVmClusterPropertiesDiagnosticsDataCollectionOptionsArgsDict(TypedDict):
|
|
4641
|
+
diagnostics_events_enabled: NotRequired[pulumi.Input[bool]]
|
|
4642
|
+
"""
|
|
4643
|
+
Indicates whether diagnostic collection is enabled for the VM cluster
|
|
4644
|
+
"""
|
|
4645
|
+
health_monitoring_enabled: NotRequired[pulumi.Input[bool]]
|
|
4646
|
+
"""
|
|
4647
|
+
Indicates whether health monitoring is enabled for the VM cluster
|
|
4648
|
+
"""
|
|
4649
|
+
incident_logs_enabled: NotRequired[pulumi.Input[bool]]
|
|
4650
|
+
"""
|
|
4651
|
+
Indicates whether incident logs and trace collection are enabled for the VM
|
|
4652
|
+
cluster
|
|
4653
|
+
"""
|
|
4654
|
+
elif False:
|
|
4655
|
+
CloudVmClusterPropertiesDiagnosticsDataCollectionOptionsArgsDict: TypeAlias = Mapping[str, Any]
|
|
4656
|
+
|
|
4657
|
+
@pulumi.input_type
|
|
4658
|
+
class CloudVmClusterPropertiesDiagnosticsDataCollectionOptionsArgs:
|
|
4659
|
+
def __init__(__self__, *,
|
|
4660
|
+
diagnostics_events_enabled: Optional[pulumi.Input[bool]] = None,
|
|
4661
|
+
health_monitoring_enabled: Optional[pulumi.Input[bool]] = None,
|
|
4662
|
+
incident_logs_enabled: Optional[pulumi.Input[bool]] = None):
|
|
4663
|
+
"""
|
|
4664
|
+
:param pulumi.Input[bool] diagnostics_events_enabled: Indicates whether diagnostic collection is enabled for the VM cluster
|
|
4665
|
+
:param pulumi.Input[bool] health_monitoring_enabled: Indicates whether health monitoring is enabled for the VM cluster
|
|
4666
|
+
:param pulumi.Input[bool] incident_logs_enabled: Indicates whether incident logs and trace collection are enabled for the VM
|
|
4667
|
+
cluster
|
|
4668
|
+
"""
|
|
4669
|
+
if diagnostics_events_enabled is not None:
|
|
4670
|
+
pulumi.set(__self__, "diagnostics_events_enabled", diagnostics_events_enabled)
|
|
4671
|
+
if health_monitoring_enabled is not None:
|
|
4672
|
+
pulumi.set(__self__, "health_monitoring_enabled", health_monitoring_enabled)
|
|
4673
|
+
if incident_logs_enabled is not None:
|
|
4674
|
+
pulumi.set(__self__, "incident_logs_enabled", incident_logs_enabled)
|
|
4675
|
+
|
|
4676
|
+
@property
|
|
4677
|
+
@pulumi.getter(name="diagnosticsEventsEnabled")
|
|
4678
|
+
def diagnostics_events_enabled(self) -> Optional[pulumi.Input[bool]]:
|
|
4679
|
+
"""
|
|
4680
|
+
Indicates whether diagnostic collection is enabled for the VM cluster
|
|
4681
|
+
"""
|
|
4682
|
+
return pulumi.get(self, "diagnostics_events_enabled")
|
|
4683
|
+
|
|
4684
|
+
@diagnostics_events_enabled.setter
|
|
4685
|
+
def diagnostics_events_enabled(self, value: Optional[pulumi.Input[bool]]):
|
|
4686
|
+
pulumi.set(self, "diagnostics_events_enabled", value)
|
|
4687
|
+
|
|
4688
|
+
@property
|
|
4689
|
+
@pulumi.getter(name="healthMonitoringEnabled")
|
|
4690
|
+
def health_monitoring_enabled(self) -> Optional[pulumi.Input[bool]]:
|
|
4691
|
+
"""
|
|
4692
|
+
Indicates whether health monitoring is enabled for the VM cluster
|
|
4693
|
+
"""
|
|
4694
|
+
return pulumi.get(self, "health_monitoring_enabled")
|
|
4695
|
+
|
|
4696
|
+
@health_monitoring_enabled.setter
|
|
4697
|
+
def health_monitoring_enabled(self, value: Optional[pulumi.Input[bool]]):
|
|
4698
|
+
pulumi.set(self, "health_monitoring_enabled", value)
|
|
4699
|
+
|
|
4700
|
+
@property
|
|
4701
|
+
@pulumi.getter(name="incidentLogsEnabled")
|
|
4702
|
+
def incident_logs_enabled(self) -> Optional[pulumi.Input[bool]]:
|
|
4703
|
+
"""
|
|
4704
|
+
Indicates whether incident logs and trace collection are enabled for the VM
|
|
4705
|
+
cluster
|
|
4706
|
+
"""
|
|
4707
|
+
return pulumi.get(self, "incident_logs_enabled")
|
|
4708
|
+
|
|
4709
|
+
@incident_logs_enabled.setter
|
|
4710
|
+
def incident_logs_enabled(self, value: Optional[pulumi.Input[bool]]):
|
|
4711
|
+
pulumi.set(self, "incident_logs_enabled", value)
|
|
4712
|
+
|
|
4713
|
+
|
|
4714
|
+
if not MYPY:
|
|
4715
|
+
class CloudVmClusterPropertiesTimeZoneArgsDict(TypedDict):
|
|
4716
|
+
id: NotRequired[pulumi.Input[str]]
|
|
4717
|
+
"""
|
|
4718
|
+
IANA Time Zone Database time zone, e.g. "America/New_York".
|
|
4719
|
+
"""
|
|
4720
|
+
elif False:
|
|
4721
|
+
CloudVmClusterPropertiesTimeZoneArgsDict: TypeAlias = Mapping[str, Any]
|
|
4722
|
+
|
|
4723
|
+
@pulumi.input_type
|
|
4724
|
+
class CloudVmClusterPropertiesTimeZoneArgs:
|
|
4725
|
+
def __init__(__self__, *,
|
|
4726
|
+
id: Optional[pulumi.Input[str]] = None):
|
|
4727
|
+
"""
|
|
4728
|
+
:param pulumi.Input[str] id: IANA Time Zone Database time zone, e.g. "America/New_York".
|
|
4729
|
+
"""
|
|
4730
|
+
if id is not None:
|
|
4731
|
+
pulumi.set(__self__, "id", id)
|
|
4732
|
+
|
|
4733
|
+
@property
|
|
4734
|
+
@pulumi.getter
|
|
4735
|
+
def id(self) -> Optional[pulumi.Input[str]]:
|
|
4736
|
+
"""
|
|
4737
|
+
IANA Time Zone Database time zone, e.g. "America/New_York".
|
|
4738
|
+
"""
|
|
4739
|
+
return pulumi.get(self, "id")
|
|
4740
|
+
|
|
4741
|
+
@id.setter
|
|
4742
|
+
def id(self, value: Optional[pulumi.Input[str]]):
|
|
4743
|
+
pulumi.set(self, "id", value)
|
|
4744
|
+
|
|
4745
|
+
|