pulumi-digitalocean 4.50.0a1753335988__py3-none-any.whl → 4.50.0a1753508712__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.
Potentially problematic release.
This version of pulumi-digitalocean might be problematic. Click here for more details.
- pulumi_digitalocean/__init__.py +1 -1
- pulumi_digitalocean/_enums.py +9 -9
- pulumi_digitalocean/_inputs.py +5705 -5706
- pulumi_digitalocean/app.py +87 -88
- pulumi_digitalocean/cdn.py +104 -105
- pulumi_digitalocean/certificate.py +137 -138
- pulumi_digitalocean/config/__init__.py +1 -1
- pulumi_digitalocean/config/__init__.pyi +1 -2
- pulumi_digitalocean/config/vars.py +10 -11
- pulumi_digitalocean/container_registry.py +88 -89
- pulumi_digitalocean/container_registry_docker_credentials.py +70 -71
- pulumi_digitalocean/custom_image.py +175 -176
- pulumi_digitalocean/database_cluster.py +346 -347
- pulumi_digitalocean/database_connection_pool.py +157 -158
- pulumi_digitalocean/database_db.py +35 -36
- pulumi_digitalocean/database_firewall.py +21 -22
- pulumi_digitalocean/database_kafka_config.py +307 -308
- pulumi_digitalocean/database_kafka_topic.py +81 -82
- pulumi_digitalocean/database_mongodb_config.py +103 -104
- pulumi_digitalocean/database_mysql_config.py +477 -478
- pulumi_digitalocean/database_opensearch_config.py +664 -665
- pulumi_digitalocean/database_postgresql_config.py +857 -858
- pulumi_digitalocean/database_redis_config.py +205 -206
- pulumi_digitalocean/database_replica.py +197 -198
- pulumi_digitalocean/database_user.py +91 -92
- pulumi_digitalocean/dns_record.py +180 -181
- pulumi_digitalocean/domain.py +53 -54
- pulumi_digitalocean/droplet.py +388 -389
- pulumi_digitalocean/droplet_autoscale.py +53 -54
- pulumi_digitalocean/droplet_snapshot.py +71 -72
- pulumi_digitalocean/firewall.py +78 -79
- pulumi_digitalocean/floating_ip.py +61 -62
- pulumi_digitalocean/floating_ip_assignment.py +35 -36
- pulumi_digitalocean/genai_agent.py +452 -453
- pulumi_digitalocean/get_account.py +17 -18
- pulumi_digitalocean/get_app.py +27 -28
- pulumi_digitalocean/get_certificate.py +21 -22
- pulumi_digitalocean/get_container_registry.py +21 -22
- pulumi_digitalocean/get_database_ca.py +11 -12
- pulumi_digitalocean/get_database_cluster.py +60 -61
- pulumi_digitalocean/get_database_connection_pool.py +35 -36
- pulumi_digitalocean/get_database_replica.py +45 -46
- pulumi_digitalocean/get_database_user.py +26 -27
- pulumi_digitalocean/get_domain.py +15 -16
- pulumi_digitalocean/get_domains.py +6 -7
- pulumi_digitalocean/get_droplet.py +71 -72
- pulumi_digitalocean/get_droplet_autoscale.py +22 -23
- pulumi_digitalocean/get_droplet_snapshot.py +37 -38
- pulumi_digitalocean/get_droplets.py +12 -13
- pulumi_digitalocean/get_firewall.py +30 -31
- pulumi_digitalocean/get_floating_ip.py +15 -16
- pulumi_digitalocean/get_genai_agent.py +89 -90
- pulumi_digitalocean/get_genai_agents.py +10 -11
- pulumi_digitalocean/get_image.py +49 -50
- pulumi_digitalocean/get_images.py +6 -7
- pulumi_digitalocean/get_kubernetes_cluster.py +53 -54
- pulumi_digitalocean/get_kubernetes_versions.py +13 -14
- pulumi_digitalocean/get_load_balancer.py +59 -60
- pulumi_digitalocean/get_partner_attachment.py +30 -31
- pulumi_digitalocean/get_partner_attachment_service_key.py +13 -14
- pulumi_digitalocean/get_project.py +31 -32
- pulumi_digitalocean/get_projects.py +6 -7
- pulumi_digitalocean/get_record.py +31 -32
- pulumi_digitalocean/get_records.py +12 -13
- pulumi_digitalocean/get_region.py +17 -18
- pulumi_digitalocean/get_regions.py +6 -7
- pulumi_digitalocean/get_reserved_ip.py +15 -16
- pulumi_digitalocean/get_reserved_ipv6.py +15 -16
- pulumi_digitalocean/get_sizes.py +6 -7
- pulumi_digitalocean/get_spaces_bucket.py +21 -22
- pulumi_digitalocean/get_spaces_bucket_object.py +57 -58
- pulumi_digitalocean/get_spaces_bucket_objects.py +45 -46
- pulumi_digitalocean/get_spaces_buckets.py +6 -7
- pulumi_digitalocean/get_spaces_key.py +14 -15
- pulumi_digitalocean/get_ssh_key.py +13 -14
- pulumi_digitalocean/get_ssh_keys.py +6 -7
- pulumi_digitalocean/get_tag.py +21 -22
- pulumi_digitalocean/get_tags.py +6 -7
- pulumi_digitalocean/get_volume.py +33 -34
- pulumi_digitalocean/get_volume_snapshot.py +39 -40
- pulumi_digitalocean/get_vpc.py +29 -30
- pulumi_digitalocean/get_vpc_nat_gateway.py +33 -34
- pulumi_digitalocean/get_vpc_peering.py +23 -24
- pulumi_digitalocean/kubernetes_cluster.py +293 -294
- pulumi_digitalocean/kubernetes_node_pool.py +168 -169
- pulumi_digitalocean/load_balancer.py +374 -375
- pulumi_digitalocean/monitor_alert.py +149 -150
- pulumi_digitalocean/outputs.py +7064 -7065
- pulumi_digitalocean/partner_attachment.py +150 -151
- pulumi_digitalocean/project.py +139 -140
- pulumi_digitalocean/project_resources.py +35 -36
- pulumi_digitalocean/provider.py +84 -85
- pulumi_digitalocean/pulumi-plugin.json +1 -1
- pulumi_digitalocean/reserved_ip.py +61 -62
- pulumi_digitalocean/reserved_ip_assignment.py +35 -36
- pulumi_digitalocean/reserved_ipv6.py +53 -54
- pulumi_digitalocean/reserved_ipv6_assignment.py +35 -36
- pulumi_digitalocean/spaces_bucket.py +105 -106
- pulumi_digitalocean/spaces_bucket_cors_configuration.py +38 -39
- pulumi_digitalocean/spaces_bucket_logging.py +69 -70
- pulumi_digitalocean/spaces_bucket_object.py +282 -283
- pulumi_digitalocean/spaces_bucket_policy.py +52 -53
- pulumi_digitalocean/spaces_key.py +48 -49
- pulumi_digitalocean/ssh_key.py +44 -45
- pulumi_digitalocean/tag.py +72 -73
- pulumi_digitalocean/uptime_alert.py +106 -107
- pulumi_digitalocean/uptime_check.py +86 -87
- pulumi_digitalocean/volume.py +181 -182
- pulumi_digitalocean/volume_attachment.py +35 -36
- pulumi_digitalocean/volume_snapshot.py +88 -89
- pulumi_digitalocean/vpc.py +96 -97
- pulumi_digitalocean/vpc_nat_gateway.py +152 -153
- pulumi_digitalocean/vpc_peering.py +53 -54
- {pulumi_digitalocean-4.50.0a1753335988.dist-info → pulumi_digitalocean-4.50.0a1753508712.dist-info}/METADATA +1 -1
- pulumi_digitalocean-4.50.0a1753508712.dist-info/RECORD +119 -0
- pulumi_digitalocean-4.50.0a1753335988.dist-info/RECORD +0 -119
- {pulumi_digitalocean-4.50.0a1753335988.dist-info → pulumi_digitalocean-4.50.0a1753508712.dist-info}/WHEEL +0 -0
- {pulumi_digitalocean-4.50.0a1753335988.dist-info → pulumi_digitalocean-4.50.0a1753508712.dist-info}/top_level.txt +0 -0
|
@@ -2,8 +2,7 @@
|
|
|
2
2
|
# *** WARNING: this file was generated by pulumi-language-python. ***
|
|
3
3
|
# *** Do not edit by hand unless you're certain you know what you are doing! ***
|
|
4
4
|
|
|
5
|
-
import builtins
|
|
6
|
-
import copy
|
|
5
|
+
import builtins as _builtins
|
|
7
6
|
import warnings
|
|
8
7
|
import sys
|
|
9
8
|
import pulumi
|
|
@@ -22,112 +21,112 @@ __all__ = ['DatabasePostgresqlConfigArgs', 'DatabasePostgresqlConfig']
|
|
|
22
21
|
@pulumi.input_type
|
|
23
22
|
class DatabasePostgresqlConfigArgs:
|
|
24
23
|
def __init__(__self__, *,
|
|
25
|
-
cluster_id: pulumi.Input[
|
|
26
|
-
autovacuum_analyze_scale_factor: Optional[pulumi.Input[
|
|
27
|
-
autovacuum_analyze_threshold: Optional[pulumi.Input[
|
|
28
|
-
autovacuum_freeze_max_age: Optional[pulumi.Input[
|
|
29
|
-
autovacuum_max_workers: Optional[pulumi.Input[
|
|
30
|
-
autovacuum_naptime: Optional[pulumi.Input[
|
|
31
|
-
autovacuum_vacuum_cost_delay: Optional[pulumi.Input[
|
|
32
|
-
autovacuum_vacuum_cost_limit: Optional[pulumi.Input[
|
|
33
|
-
autovacuum_vacuum_scale_factor: Optional[pulumi.Input[
|
|
34
|
-
autovacuum_vacuum_threshold: Optional[pulumi.Input[
|
|
35
|
-
backup_hour: Optional[pulumi.Input[
|
|
36
|
-
backup_minute: Optional[pulumi.Input[
|
|
37
|
-
bgwriter_delay: Optional[pulumi.Input[
|
|
38
|
-
bgwriter_flush_after: Optional[pulumi.Input[
|
|
39
|
-
bgwriter_lru_maxpages: Optional[pulumi.Input[
|
|
40
|
-
bgwriter_lru_multiplier: Optional[pulumi.Input[
|
|
41
|
-
deadlock_timeout: Optional[pulumi.Input[
|
|
42
|
-
default_toast_compression: Optional[pulumi.Input[
|
|
43
|
-
idle_in_transaction_session_timeout: Optional[pulumi.Input[
|
|
44
|
-
jit: Optional[pulumi.Input[
|
|
45
|
-
log_autovacuum_min_duration: Optional[pulumi.Input[
|
|
46
|
-
log_error_verbosity: Optional[pulumi.Input[
|
|
47
|
-
log_line_prefix: Optional[pulumi.Input[
|
|
48
|
-
log_min_duration_statement: Optional[pulumi.Input[
|
|
49
|
-
max_files_per_process: Optional[pulumi.Input[
|
|
50
|
-
max_locks_per_transaction: Optional[pulumi.Input[
|
|
51
|
-
max_logical_replication_workers: Optional[pulumi.Input[
|
|
52
|
-
max_parallel_workers: Optional[pulumi.Input[
|
|
53
|
-
max_parallel_workers_per_gather: Optional[pulumi.Input[
|
|
54
|
-
max_pred_locks_per_transaction: Optional[pulumi.Input[
|
|
55
|
-
max_prepared_transactions: Optional[pulumi.Input[
|
|
56
|
-
max_replication_slots: Optional[pulumi.Input[
|
|
57
|
-
max_stack_depth: Optional[pulumi.Input[
|
|
58
|
-
max_standby_archive_delay: Optional[pulumi.Input[
|
|
59
|
-
max_standby_streaming_delay: Optional[pulumi.Input[
|
|
60
|
-
max_wal_senders: Optional[pulumi.Input[
|
|
61
|
-
max_worker_processes: Optional[pulumi.Input[
|
|
62
|
-
pg_partman_bgw_interval: Optional[pulumi.Input[
|
|
63
|
-
pg_partman_bgw_role: Optional[pulumi.Input[
|
|
64
|
-
pg_stat_statements_track: Optional[pulumi.Input[
|
|
24
|
+
cluster_id: pulumi.Input[_builtins.str],
|
|
25
|
+
autovacuum_analyze_scale_factor: Optional[pulumi.Input[_builtins.float]] = None,
|
|
26
|
+
autovacuum_analyze_threshold: Optional[pulumi.Input[_builtins.int]] = None,
|
|
27
|
+
autovacuum_freeze_max_age: Optional[pulumi.Input[_builtins.int]] = None,
|
|
28
|
+
autovacuum_max_workers: Optional[pulumi.Input[_builtins.int]] = None,
|
|
29
|
+
autovacuum_naptime: Optional[pulumi.Input[_builtins.int]] = None,
|
|
30
|
+
autovacuum_vacuum_cost_delay: Optional[pulumi.Input[_builtins.int]] = None,
|
|
31
|
+
autovacuum_vacuum_cost_limit: Optional[pulumi.Input[_builtins.int]] = None,
|
|
32
|
+
autovacuum_vacuum_scale_factor: Optional[pulumi.Input[_builtins.float]] = None,
|
|
33
|
+
autovacuum_vacuum_threshold: Optional[pulumi.Input[_builtins.int]] = None,
|
|
34
|
+
backup_hour: Optional[pulumi.Input[_builtins.int]] = None,
|
|
35
|
+
backup_minute: Optional[pulumi.Input[_builtins.int]] = None,
|
|
36
|
+
bgwriter_delay: Optional[pulumi.Input[_builtins.int]] = None,
|
|
37
|
+
bgwriter_flush_after: Optional[pulumi.Input[_builtins.int]] = None,
|
|
38
|
+
bgwriter_lru_maxpages: Optional[pulumi.Input[_builtins.int]] = None,
|
|
39
|
+
bgwriter_lru_multiplier: Optional[pulumi.Input[_builtins.float]] = None,
|
|
40
|
+
deadlock_timeout: Optional[pulumi.Input[_builtins.int]] = None,
|
|
41
|
+
default_toast_compression: Optional[pulumi.Input[_builtins.str]] = None,
|
|
42
|
+
idle_in_transaction_session_timeout: Optional[pulumi.Input[_builtins.int]] = None,
|
|
43
|
+
jit: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
44
|
+
log_autovacuum_min_duration: Optional[pulumi.Input[_builtins.int]] = None,
|
|
45
|
+
log_error_verbosity: Optional[pulumi.Input[_builtins.str]] = None,
|
|
46
|
+
log_line_prefix: Optional[pulumi.Input[_builtins.str]] = None,
|
|
47
|
+
log_min_duration_statement: Optional[pulumi.Input[_builtins.int]] = None,
|
|
48
|
+
max_files_per_process: Optional[pulumi.Input[_builtins.int]] = None,
|
|
49
|
+
max_locks_per_transaction: Optional[pulumi.Input[_builtins.int]] = None,
|
|
50
|
+
max_logical_replication_workers: Optional[pulumi.Input[_builtins.int]] = None,
|
|
51
|
+
max_parallel_workers: Optional[pulumi.Input[_builtins.int]] = None,
|
|
52
|
+
max_parallel_workers_per_gather: Optional[pulumi.Input[_builtins.int]] = None,
|
|
53
|
+
max_pred_locks_per_transaction: Optional[pulumi.Input[_builtins.int]] = None,
|
|
54
|
+
max_prepared_transactions: Optional[pulumi.Input[_builtins.int]] = None,
|
|
55
|
+
max_replication_slots: Optional[pulumi.Input[_builtins.int]] = None,
|
|
56
|
+
max_stack_depth: Optional[pulumi.Input[_builtins.int]] = None,
|
|
57
|
+
max_standby_archive_delay: Optional[pulumi.Input[_builtins.int]] = None,
|
|
58
|
+
max_standby_streaming_delay: Optional[pulumi.Input[_builtins.int]] = None,
|
|
59
|
+
max_wal_senders: Optional[pulumi.Input[_builtins.int]] = None,
|
|
60
|
+
max_worker_processes: Optional[pulumi.Input[_builtins.int]] = None,
|
|
61
|
+
pg_partman_bgw_interval: Optional[pulumi.Input[_builtins.int]] = None,
|
|
62
|
+
pg_partman_bgw_role: Optional[pulumi.Input[_builtins.str]] = None,
|
|
63
|
+
pg_stat_statements_track: Optional[pulumi.Input[_builtins.str]] = None,
|
|
65
64
|
pgbouncers: Optional[pulumi.Input[Sequence[pulumi.Input['DatabasePostgresqlConfigPgbouncerArgs']]]] = None,
|
|
66
|
-
shared_buffers_percentage: Optional[pulumi.Input[
|
|
67
|
-
temp_file_limit: Optional[pulumi.Input[
|
|
65
|
+
shared_buffers_percentage: Optional[pulumi.Input[_builtins.float]] = None,
|
|
66
|
+
temp_file_limit: Optional[pulumi.Input[_builtins.int]] = None,
|
|
68
67
|
timescaledbs: Optional[pulumi.Input[Sequence[pulumi.Input['DatabasePostgresqlConfigTimescaledbArgs']]]] = None,
|
|
69
|
-
timezone: Optional[pulumi.Input[
|
|
70
|
-
track_activity_query_size: Optional[pulumi.Input[
|
|
71
|
-
track_commit_timestamp: Optional[pulumi.Input[
|
|
72
|
-
track_functions: Optional[pulumi.Input[
|
|
73
|
-
track_io_timing: Optional[pulumi.Input[
|
|
74
|
-
wal_sender_timeout: Optional[pulumi.Input[
|
|
75
|
-
wal_writer_delay: Optional[pulumi.Input[
|
|
76
|
-
work_mem: Optional[pulumi.Input[
|
|
68
|
+
timezone: Optional[pulumi.Input[_builtins.str]] = None,
|
|
69
|
+
track_activity_query_size: Optional[pulumi.Input[_builtins.int]] = None,
|
|
70
|
+
track_commit_timestamp: Optional[pulumi.Input[_builtins.str]] = None,
|
|
71
|
+
track_functions: Optional[pulumi.Input[_builtins.str]] = None,
|
|
72
|
+
track_io_timing: Optional[pulumi.Input[_builtins.str]] = None,
|
|
73
|
+
wal_sender_timeout: Optional[pulumi.Input[_builtins.int]] = None,
|
|
74
|
+
wal_writer_delay: Optional[pulumi.Input[_builtins.int]] = None,
|
|
75
|
+
work_mem: Optional[pulumi.Input[_builtins.int]] = None):
|
|
77
76
|
"""
|
|
78
77
|
The set of arguments for constructing a DatabasePostgresqlConfig resource.
|
|
79
|
-
:param pulumi.Input[
|
|
80
|
-
:param pulumi.Input[
|
|
81
|
-
:param pulumi.Input[
|
|
82
|
-
:param pulumi.Input[
|
|
83
|
-
:param pulumi.Input[
|
|
84
|
-
:param pulumi.Input[
|
|
85
|
-
:param pulumi.Input[
|
|
86
|
-
:param pulumi.Input[
|
|
87
|
-
:param pulumi.Input[
|
|
88
|
-
:param pulumi.Input[
|
|
89
|
-
:param pulumi.Input[
|
|
90
|
-
:param pulumi.Input[
|
|
91
|
-
:param pulumi.Input[
|
|
92
|
-
:param pulumi.Input[
|
|
93
|
-
:param pulumi.Input[
|
|
94
|
-
:param pulumi.Input[
|
|
95
|
-
:param pulumi.Input[
|
|
96
|
-
:param pulumi.Input[
|
|
97
|
-
:param pulumi.Input[
|
|
98
|
-
:param pulumi.Input[
|
|
99
|
-
:param pulumi.Input[
|
|
100
|
-
:param pulumi.Input[
|
|
101
|
-
:param pulumi.Input[
|
|
102
|
-
:param pulumi.Input[
|
|
103
|
-
:param pulumi.Input[
|
|
104
|
-
:param pulumi.Input[
|
|
105
|
-
:param pulumi.Input[
|
|
106
|
-
:param pulumi.Input[
|
|
107
|
-
:param pulumi.Input[
|
|
108
|
-
:param pulumi.Input[
|
|
109
|
-
:param pulumi.Input[
|
|
110
|
-
:param pulumi.Input[
|
|
111
|
-
:param pulumi.Input[
|
|
112
|
-
:param pulumi.Input[
|
|
113
|
-
:param pulumi.Input[
|
|
114
|
-
:param pulumi.Input[
|
|
115
|
-
:param pulumi.Input[
|
|
116
|
-
:param pulumi.Input[
|
|
117
|
-
:param pulumi.Input[
|
|
118
|
-
:param pulumi.Input[
|
|
78
|
+
:param pulumi.Input[_builtins.str] cluster_id: The ID of the target PostgreSQL cluster.
|
|
79
|
+
:param pulumi.Input[_builtins.float] autovacuum_analyze_scale_factor: Specifies a fraction, in a decimal value, of the table size to add to autovacuum_analyze_threshold when deciding whether to trigger an ANALYZE. The default is 0.2 (20% of table size).
|
|
80
|
+
:param pulumi.Input[_builtins.int] autovacuum_analyze_threshold: Specifies the minimum number of inserted, updated, or deleted tuples needed to trigger an ANALYZE in any one table. The default is 50 tuples.
|
|
81
|
+
:param pulumi.Input[_builtins.int] autovacuum_freeze_max_age: Specifies the maximum age (in transactions) that a table's pg_class.relfrozenxid field can attain before a VACUUM operation is forced to prevent transaction ID wraparound within the table. Note that the system will launch autovacuum processes to prevent wraparound even when autovacuum is otherwise disabled. This parameter will cause the server to be restarted.
|
|
82
|
+
:param pulumi.Input[_builtins.int] autovacuum_max_workers: Specifies the maximum number of autovacuum processes (other than the autovacuum launcher) that may be running at any one time. The default is three. This parameter can only be set at server start.
|
|
83
|
+
:param pulumi.Input[_builtins.int] autovacuum_naptime: Specifies the minimum delay, in seconds, between autovacuum runs on any given database. The default is one minute.
|
|
84
|
+
:param pulumi.Input[_builtins.int] autovacuum_vacuum_cost_delay: Specifies the cost delay value, in milliseconds, that will be used in automatic VACUUM operations. If -1, uses the regular vacuum_cost_delay value, which is 20 milliseconds.
|
|
85
|
+
:param pulumi.Input[_builtins.int] autovacuum_vacuum_cost_limit: Specifies the cost limit value that will be used in automatic VACUUM operations. If -1 is specified (which is the default), the regular vacuum_cost_limit value will be used.
|
|
86
|
+
:param pulumi.Input[_builtins.float] autovacuum_vacuum_scale_factor: Specifies a fraction, in a decimal value, of the table size to add to autovacuum_vacuum_threshold when deciding whether to trigger a VACUUM. The default is 0.2 (20% of table size).
|
|
87
|
+
:param pulumi.Input[_builtins.int] autovacuum_vacuum_threshold: Specifies the minimum number of updated or deleted tuples needed to trigger a VACUUM in any one table. The default is 50 tuples.
|
|
88
|
+
:param pulumi.Input[_builtins.int] backup_hour: The hour of day (in UTC) when backup for the service starts. New backup only starts if previous backup has already completed.
|
|
89
|
+
:param pulumi.Input[_builtins.int] backup_minute: The minute of the backup hour when backup for the service starts. New backup is only started if previous backup has already completed.
|
|
90
|
+
:param pulumi.Input[_builtins.int] bgwriter_delay: Specifies the delay, in milliseconds, between activity rounds for the background writer. Default is 200 ms.
|
|
91
|
+
:param pulumi.Input[_builtins.int] bgwriter_flush_after: The amount of kilobytes that need to be written by the background writer before attempting to force the OS to issue these writes to underlying storage. Specified in kilobytes, default is 512. Setting of 0 disables forced writeback.
|
|
92
|
+
:param pulumi.Input[_builtins.int] bgwriter_lru_maxpages: The maximum number of buffers that the background writer can write. Setting this to zero disables background writing. Default is 100.
|
|
93
|
+
:param pulumi.Input[_builtins.float] bgwriter_lru_multiplier: The average recent need for new buffers is multiplied by bgwriter_lru_multiplier to arrive at an estimate of the number that will be needed during the next round, (up to bgwriter_lru_maxpages). 1.0 represents a “just in time” policy of writing exactly the number of buffers predicted to be needed. Larger values provide some cushion against spikes in demand, while smaller values intentionally leave writes to be done by server processes. The default is 2.0.
|
|
94
|
+
:param pulumi.Input[_builtins.int] deadlock_timeout: The amount of time, in milliseconds, to wait on a lock before checking to see if there is a deadlock condition.
|
|
95
|
+
:param pulumi.Input[_builtins.str] default_toast_compression: Specifies the default TOAST compression method for values of compressible columns (the default is lz4). Supported values are: `lz4`, `pglz`.
|
|
96
|
+
:param pulumi.Input[_builtins.int] idle_in_transaction_session_timeout: Time out sessions with open transactions after this number of milliseconds
|
|
97
|
+
:param pulumi.Input[_builtins.bool] jit: Activates, in a boolean, the system-wide use of Just-in-Time Compilation (JIT).
|
|
98
|
+
:param pulumi.Input[_builtins.int] log_autovacuum_min_duration: Causes each action executed by autovacuum to be logged if it ran for at least the specified number of milliseconds. Setting this to zero logs all autovacuum actions. Minus-one (the default) disables logging autovacuum actions.
|
|
99
|
+
:param pulumi.Input[_builtins.str] log_error_verbosity: Controls the amount of detail written in the server log for each message that is logged. Supported values are: `TERSE`, `DEFAULT`, `VERBOSE`.
|
|
100
|
+
:param pulumi.Input[_builtins.str] log_line_prefix: Selects one of the available log-formats. These can support popular log analyzers like pgbadger, pganalyze, etc. Supported values are: `pid=%p,user=%u,db=%d,app=%a,client=%h`, `%m [%p] %q[user=%u,db=%d,app=%a]`, `%t [%p]: [%l-1] user=%u,db=%d,app=%a,client=%h`.
|
|
101
|
+
:param pulumi.Input[_builtins.int] log_min_duration_statement: Log statements that take more than this number of milliseconds to run. If -1, disables.
|
|
102
|
+
:param pulumi.Input[_builtins.int] max_files_per_process: PostgreSQL maximum number of files that can be open per process.
|
|
103
|
+
:param pulumi.Input[_builtins.int] max_locks_per_transaction: PostgreSQL maximum locks per transaction. Once increased, this parameter cannot be lowered from its set value.
|
|
104
|
+
:param pulumi.Input[_builtins.int] max_logical_replication_workers: PostgreSQL maximum logical replication workers (taken from the pool of max_parallel_workers).
|
|
105
|
+
:param pulumi.Input[_builtins.int] max_parallel_workers: Sets the maximum number of workers that the system can support for parallel queries.
|
|
106
|
+
:param pulumi.Input[_builtins.int] max_parallel_workers_per_gather: Sets the maximum number of workers that can be started by a single Gather or Gather Merge node.
|
|
107
|
+
:param pulumi.Input[_builtins.int] max_pred_locks_per_transaction: PostgreSQL maximum predicate locks per transaction.
|
|
108
|
+
:param pulumi.Input[_builtins.int] max_prepared_transactions: PostgreSQL maximum prepared transactions. Once increased, this parameter cannot be lowered from its set value.
|
|
109
|
+
:param pulumi.Input[_builtins.int] max_replication_slots: PostgreSQL maximum replication slots.
|
|
110
|
+
:param pulumi.Input[_builtins.int] max_stack_depth: Maximum depth of the stack in bytes.
|
|
111
|
+
:param pulumi.Input[_builtins.int] max_standby_archive_delay: Max standby archive delay in milliseconds.
|
|
112
|
+
:param pulumi.Input[_builtins.int] max_standby_streaming_delay: Max standby streaming delay in milliseconds.
|
|
113
|
+
:param pulumi.Input[_builtins.int] max_wal_senders: PostgreSQL maximum WAL senders. Once increased, this parameter cannot be lowered from its set value.
|
|
114
|
+
:param pulumi.Input[_builtins.int] max_worker_processes: Sets the maximum number of background processes that the system can support. Once increased, this parameter cannot be lowered from its set value.
|
|
115
|
+
:param pulumi.Input[_builtins.int] pg_partman_bgw_interval: Sets the time interval to run pg_partman's scheduled tasks.
|
|
116
|
+
:param pulumi.Input[_builtins.str] pg_partman_bgw_role: Controls which role to use for pg_partman's scheduled background tasks. Must consist of alpha-numeric characters, dots, underscores, or dashes. May not start with dash or dot. Maximum of 64 characters.
|
|
117
|
+
:param pulumi.Input[_builtins.str] pg_stat_statements_track: Controls which statements are counted. Specify 'top' to track top-level statements (those issued directly by clients), 'all' to also track nested statements (such as statements invoked within functions), or 'none' to disable statement statistics collection. The default value is top. Supported values are: `all`, `top`, `none`.
|
|
119
118
|
:param pulumi.Input[Sequence[pulumi.Input['DatabasePostgresqlConfigPgbouncerArgs']]] pgbouncers: PGBouncer connection pooling settings
|
|
120
|
-
:param pulumi.Input[
|
|
121
|
-
:param pulumi.Input[
|
|
119
|
+
:param pulumi.Input[_builtins.float] shared_buffers_percentage: Percentage of total RAM that the database server uses for shared memory buffers. Valid range is 20-60 (float), which corresponds to 20% - 60%. This setting adjusts the shared_buffers configuration value.
|
|
120
|
+
:param pulumi.Input[_builtins.int] temp_file_limit: PostgreSQL temporary file limit in KiB. If -1, sets to unlimited.
|
|
122
121
|
:param pulumi.Input[Sequence[pulumi.Input['DatabasePostgresqlConfigTimescaledbArgs']]] timescaledbs: TimescaleDB extension configuration values
|
|
123
|
-
:param pulumi.Input[
|
|
124
|
-
:param pulumi.Input[
|
|
125
|
-
:param pulumi.Input[
|
|
126
|
-
:param pulumi.Input[
|
|
127
|
-
:param pulumi.Input[
|
|
128
|
-
:param pulumi.Input[
|
|
129
|
-
:param pulumi.Input[
|
|
130
|
-
:param pulumi.Input[
|
|
122
|
+
:param pulumi.Input[_builtins.str] timezone: PostgreSQL service timezone
|
|
123
|
+
:param pulumi.Input[_builtins.int] track_activity_query_size: Specifies the number of bytes reserved to track the currently executing command for each active session.
|
|
124
|
+
:param pulumi.Input[_builtins.str] track_commit_timestamp: Record commit time of transactions. The default value is top. Supported values are: `off`, `on`.
|
|
125
|
+
:param pulumi.Input[_builtins.str] track_functions: Enables tracking of function call counts and time used. The default value is top. Supported values are: `all`, `pl`, `none`.
|
|
126
|
+
:param pulumi.Input[_builtins.str] track_io_timing: Enables timing of database I/O calls. This parameter is off by default, because it will repeatedly query the operating system for the current time, which may cause significant overhead on some platforms. The default value is top. Supported values are: `off`, `on`.
|
|
127
|
+
:param pulumi.Input[_builtins.int] wal_sender_timeout: Terminate replication connections that are inactive for longer than this amount of time, in milliseconds. Setting this value to zero disables the timeout. Must be either 0 or between 5000 and 10800000.
|
|
128
|
+
:param pulumi.Input[_builtins.int] wal_writer_delay: WAL flush interval in milliseconds. Note that setting this value to lower than the default 200ms may negatively impact performance
|
|
129
|
+
:param pulumi.Input[_builtins.int] work_mem: The maximum amount of memory, in MB, used by a query operation (such as a sort or hash table) before writing to temporary disk files. Default is 1MB + 0.075% of total RAM (up to 32MB).
|
|
131
130
|
"""
|
|
132
131
|
pulumi.set(__self__, "cluster_id", cluster_id)
|
|
133
132
|
if autovacuum_analyze_scale_factor is not None:
|
|
@@ -233,487 +232,487 @@ class DatabasePostgresqlConfigArgs:
|
|
|
233
232
|
if work_mem is not None:
|
|
234
233
|
pulumi.set(__self__, "work_mem", work_mem)
|
|
235
234
|
|
|
236
|
-
@property
|
|
235
|
+
@_builtins.property
|
|
237
236
|
@pulumi.getter(name="clusterId")
|
|
238
|
-
def cluster_id(self) -> pulumi.Input[
|
|
237
|
+
def cluster_id(self) -> pulumi.Input[_builtins.str]:
|
|
239
238
|
"""
|
|
240
239
|
The ID of the target PostgreSQL cluster.
|
|
241
240
|
"""
|
|
242
241
|
return pulumi.get(self, "cluster_id")
|
|
243
242
|
|
|
244
243
|
@cluster_id.setter
|
|
245
|
-
def cluster_id(self, value: pulumi.Input[
|
|
244
|
+
def cluster_id(self, value: pulumi.Input[_builtins.str]):
|
|
246
245
|
pulumi.set(self, "cluster_id", value)
|
|
247
246
|
|
|
248
|
-
@property
|
|
247
|
+
@_builtins.property
|
|
249
248
|
@pulumi.getter(name="autovacuumAnalyzeScaleFactor")
|
|
250
|
-
def autovacuum_analyze_scale_factor(self) -> Optional[pulumi.Input[
|
|
249
|
+
def autovacuum_analyze_scale_factor(self) -> Optional[pulumi.Input[_builtins.float]]:
|
|
251
250
|
"""
|
|
252
251
|
Specifies a fraction, in a decimal value, of the table size to add to autovacuum_analyze_threshold when deciding whether to trigger an ANALYZE. The default is 0.2 (20% of table size).
|
|
253
252
|
"""
|
|
254
253
|
return pulumi.get(self, "autovacuum_analyze_scale_factor")
|
|
255
254
|
|
|
256
255
|
@autovacuum_analyze_scale_factor.setter
|
|
257
|
-
def autovacuum_analyze_scale_factor(self, value: Optional[pulumi.Input[
|
|
256
|
+
def autovacuum_analyze_scale_factor(self, value: Optional[pulumi.Input[_builtins.float]]):
|
|
258
257
|
pulumi.set(self, "autovacuum_analyze_scale_factor", value)
|
|
259
258
|
|
|
260
|
-
@property
|
|
259
|
+
@_builtins.property
|
|
261
260
|
@pulumi.getter(name="autovacuumAnalyzeThreshold")
|
|
262
|
-
def autovacuum_analyze_threshold(self) -> Optional[pulumi.Input[
|
|
261
|
+
def autovacuum_analyze_threshold(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
263
262
|
"""
|
|
264
263
|
Specifies the minimum number of inserted, updated, or deleted tuples needed to trigger an ANALYZE in any one table. The default is 50 tuples.
|
|
265
264
|
"""
|
|
266
265
|
return pulumi.get(self, "autovacuum_analyze_threshold")
|
|
267
266
|
|
|
268
267
|
@autovacuum_analyze_threshold.setter
|
|
269
|
-
def autovacuum_analyze_threshold(self, value: Optional[pulumi.Input[
|
|
268
|
+
def autovacuum_analyze_threshold(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
270
269
|
pulumi.set(self, "autovacuum_analyze_threshold", value)
|
|
271
270
|
|
|
272
|
-
@property
|
|
271
|
+
@_builtins.property
|
|
273
272
|
@pulumi.getter(name="autovacuumFreezeMaxAge")
|
|
274
|
-
def autovacuum_freeze_max_age(self) -> Optional[pulumi.Input[
|
|
273
|
+
def autovacuum_freeze_max_age(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
275
274
|
"""
|
|
276
275
|
Specifies the maximum age (in transactions) that a table's pg_class.relfrozenxid field can attain before a VACUUM operation is forced to prevent transaction ID wraparound within the table. Note that the system will launch autovacuum processes to prevent wraparound even when autovacuum is otherwise disabled. This parameter will cause the server to be restarted.
|
|
277
276
|
"""
|
|
278
277
|
return pulumi.get(self, "autovacuum_freeze_max_age")
|
|
279
278
|
|
|
280
279
|
@autovacuum_freeze_max_age.setter
|
|
281
|
-
def autovacuum_freeze_max_age(self, value: Optional[pulumi.Input[
|
|
280
|
+
def autovacuum_freeze_max_age(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
282
281
|
pulumi.set(self, "autovacuum_freeze_max_age", value)
|
|
283
282
|
|
|
284
|
-
@property
|
|
283
|
+
@_builtins.property
|
|
285
284
|
@pulumi.getter(name="autovacuumMaxWorkers")
|
|
286
|
-
def autovacuum_max_workers(self) -> Optional[pulumi.Input[
|
|
285
|
+
def autovacuum_max_workers(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
287
286
|
"""
|
|
288
287
|
Specifies the maximum number of autovacuum processes (other than the autovacuum launcher) that may be running at any one time. The default is three. This parameter can only be set at server start.
|
|
289
288
|
"""
|
|
290
289
|
return pulumi.get(self, "autovacuum_max_workers")
|
|
291
290
|
|
|
292
291
|
@autovacuum_max_workers.setter
|
|
293
|
-
def autovacuum_max_workers(self, value: Optional[pulumi.Input[
|
|
292
|
+
def autovacuum_max_workers(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
294
293
|
pulumi.set(self, "autovacuum_max_workers", value)
|
|
295
294
|
|
|
296
|
-
@property
|
|
295
|
+
@_builtins.property
|
|
297
296
|
@pulumi.getter(name="autovacuumNaptime")
|
|
298
|
-
def autovacuum_naptime(self) -> Optional[pulumi.Input[
|
|
297
|
+
def autovacuum_naptime(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
299
298
|
"""
|
|
300
299
|
Specifies the minimum delay, in seconds, between autovacuum runs on any given database. The default is one minute.
|
|
301
300
|
"""
|
|
302
301
|
return pulumi.get(self, "autovacuum_naptime")
|
|
303
302
|
|
|
304
303
|
@autovacuum_naptime.setter
|
|
305
|
-
def autovacuum_naptime(self, value: Optional[pulumi.Input[
|
|
304
|
+
def autovacuum_naptime(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
306
305
|
pulumi.set(self, "autovacuum_naptime", value)
|
|
307
306
|
|
|
308
|
-
@property
|
|
307
|
+
@_builtins.property
|
|
309
308
|
@pulumi.getter(name="autovacuumVacuumCostDelay")
|
|
310
|
-
def autovacuum_vacuum_cost_delay(self) -> Optional[pulumi.Input[
|
|
309
|
+
def autovacuum_vacuum_cost_delay(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
311
310
|
"""
|
|
312
311
|
Specifies the cost delay value, in milliseconds, that will be used in automatic VACUUM operations. If -1, uses the regular vacuum_cost_delay value, which is 20 milliseconds.
|
|
313
312
|
"""
|
|
314
313
|
return pulumi.get(self, "autovacuum_vacuum_cost_delay")
|
|
315
314
|
|
|
316
315
|
@autovacuum_vacuum_cost_delay.setter
|
|
317
|
-
def autovacuum_vacuum_cost_delay(self, value: Optional[pulumi.Input[
|
|
316
|
+
def autovacuum_vacuum_cost_delay(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
318
317
|
pulumi.set(self, "autovacuum_vacuum_cost_delay", value)
|
|
319
318
|
|
|
320
|
-
@property
|
|
319
|
+
@_builtins.property
|
|
321
320
|
@pulumi.getter(name="autovacuumVacuumCostLimit")
|
|
322
|
-
def autovacuum_vacuum_cost_limit(self) -> Optional[pulumi.Input[
|
|
321
|
+
def autovacuum_vacuum_cost_limit(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
323
322
|
"""
|
|
324
323
|
Specifies the cost limit value that will be used in automatic VACUUM operations. If -1 is specified (which is the default), the regular vacuum_cost_limit value will be used.
|
|
325
324
|
"""
|
|
326
325
|
return pulumi.get(self, "autovacuum_vacuum_cost_limit")
|
|
327
326
|
|
|
328
327
|
@autovacuum_vacuum_cost_limit.setter
|
|
329
|
-
def autovacuum_vacuum_cost_limit(self, value: Optional[pulumi.Input[
|
|
328
|
+
def autovacuum_vacuum_cost_limit(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
330
329
|
pulumi.set(self, "autovacuum_vacuum_cost_limit", value)
|
|
331
330
|
|
|
332
|
-
@property
|
|
331
|
+
@_builtins.property
|
|
333
332
|
@pulumi.getter(name="autovacuumVacuumScaleFactor")
|
|
334
|
-
def autovacuum_vacuum_scale_factor(self) -> Optional[pulumi.Input[
|
|
333
|
+
def autovacuum_vacuum_scale_factor(self) -> Optional[pulumi.Input[_builtins.float]]:
|
|
335
334
|
"""
|
|
336
335
|
Specifies a fraction, in a decimal value, of the table size to add to autovacuum_vacuum_threshold when deciding whether to trigger a VACUUM. The default is 0.2 (20% of table size).
|
|
337
336
|
"""
|
|
338
337
|
return pulumi.get(self, "autovacuum_vacuum_scale_factor")
|
|
339
338
|
|
|
340
339
|
@autovacuum_vacuum_scale_factor.setter
|
|
341
|
-
def autovacuum_vacuum_scale_factor(self, value: Optional[pulumi.Input[
|
|
340
|
+
def autovacuum_vacuum_scale_factor(self, value: Optional[pulumi.Input[_builtins.float]]):
|
|
342
341
|
pulumi.set(self, "autovacuum_vacuum_scale_factor", value)
|
|
343
342
|
|
|
344
|
-
@property
|
|
343
|
+
@_builtins.property
|
|
345
344
|
@pulumi.getter(name="autovacuumVacuumThreshold")
|
|
346
|
-
def autovacuum_vacuum_threshold(self) -> Optional[pulumi.Input[
|
|
345
|
+
def autovacuum_vacuum_threshold(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
347
346
|
"""
|
|
348
347
|
Specifies the minimum number of updated or deleted tuples needed to trigger a VACUUM in any one table. The default is 50 tuples.
|
|
349
348
|
"""
|
|
350
349
|
return pulumi.get(self, "autovacuum_vacuum_threshold")
|
|
351
350
|
|
|
352
351
|
@autovacuum_vacuum_threshold.setter
|
|
353
|
-
def autovacuum_vacuum_threshold(self, value: Optional[pulumi.Input[
|
|
352
|
+
def autovacuum_vacuum_threshold(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
354
353
|
pulumi.set(self, "autovacuum_vacuum_threshold", value)
|
|
355
354
|
|
|
356
|
-
@property
|
|
355
|
+
@_builtins.property
|
|
357
356
|
@pulumi.getter(name="backupHour")
|
|
358
|
-
def backup_hour(self) -> Optional[pulumi.Input[
|
|
357
|
+
def backup_hour(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
359
358
|
"""
|
|
360
359
|
The hour of day (in UTC) when backup for the service starts. New backup only starts if previous backup has already completed.
|
|
361
360
|
"""
|
|
362
361
|
return pulumi.get(self, "backup_hour")
|
|
363
362
|
|
|
364
363
|
@backup_hour.setter
|
|
365
|
-
def backup_hour(self, value: Optional[pulumi.Input[
|
|
364
|
+
def backup_hour(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
366
365
|
pulumi.set(self, "backup_hour", value)
|
|
367
366
|
|
|
368
|
-
@property
|
|
367
|
+
@_builtins.property
|
|
369
368
|
@pulumi.getter(name="backupMinute")
|
|
370
|
-
def backup_minute(self) -> Optional[pulumi.Input[
|
|
369
|
+
def backup_minute(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
371
370
|
"""
|
|
372
371
|
The minute of the backup hour when backup for the service starts. New backup is only started if previous backup has already completed.
|
|
373
372
|
"""
|
|
374
373
|
return pulumi.get(self, "backup_minute")
|
|
375
374
|
|
|
376
375
|
@backup_minute.setter
|
|
377
|
-
def backup_minute(self, value: Optional[pulumi.Input[
|
|
376
|
+
def backup_minute(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
378
377
|
pulumi.set(self, "backup_minute", value)
|
|
379
378
|
|
|
380
|
-
@property
|
|
379
|
+
@_builtins.property
|
|
381
380
|
@pulumi.getter(name="bgwriterDelay")
|
|
382
|
-
def bgwriter_delay(self) -> Optional[pulumi.Input[
|
|
381
|
+
def bgwriter_delay(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
383
382
|
"""
|
|
384
383
|
Specifies the delay, in milliseconds, between activity rounds for the background writer. Default is 200 ms.
|
|
385
384
|
"""
|
|
386
385
|
return pulumi.get(self, "bgwriter_delay")
|
|
387
386
|
|
|
388
387
|
@bgwriter_delay.setter
|
|
389
|
-
def bgwriter_delay(self, value: Optional[pulumi.Input[
|
|
388
|
+
def bgwriter_delay(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
390
389
|
pulumi.set(self, "bgwriter_delay", value)
|
|
391
390
|
|
|
392
|
-
@property
|
|
391
|
+
@_builtins.property
|
|
393
392
|
@pulumi.getter(name="bgwriterFlushAfter")
|
|
394
|
-
def bgwriter_flush_after(self) -> Optional[pulumi.Input[
|
|
393
|
+
def bgwriter_flush_after(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
395
394
|
"""
|
|
396
395
|
The amount of kilobytes that need to be written by the background writer before attempting to force the OS to issue these writes to underlying storage. Specified in kilobytes, default is 512. Setting of 0 disables forced writeback.
|
|
397
396
|
"""
|
|
398
397
|
return pulumi.get(self, "bgwriter_flush_after")
|
|
399
398
|
|
|
400
399
|
@bgwriter_flush_after.setter
|
|
401
|
-
def bgwriter_flush_after(self, value: Optional[pulumi.Input[
|
|
400
|
+
def bgwriter_flush_after(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
402
401
|
pulumi.set(self, "bgwriter_flush_after", value)
|
|
403
402
|
|
|
404
|
-
@property
|
|
403
|
+
@_builtins.property
|
|
405
404
|
@pulumi.getter(name="bgwriterLruMaxpages")
|
|
406
|
-
def bgwriter_lru_maxpages(self) -> Optional[pulumi.Input[
|
|
405
|
+
def bgwriter_lru_maxpages(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
407
406
|
"""
|
|
408
407
|
The maximum number of buffers that the background writer can write. Setting this to zero disables background writing. Default is 100.
|
|
409
408
|
"""
|
|
410
409
|
return pulumi.get(self, "bgwriter_lru_maxpages")
|
|
411
410
|
|
|
412
411
|
@bgwriter_lru_maxpages.setter
|
|
413
|
-
def bgwriter_lru_maxpages(self, value: Optional[pulumi.Input[
|
|
412
|
+
def bgwriter_lru_maxpages(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
414
413
|
pulumi.set(self, "bgwriter_lru_maxpages", value)
|
|
415
414
|
|
|
416
|
-
@property
|
|
415
|
+
@_builtins.property
|
|
417
416
|
@pulumi.getter(name="bgwriterLruMultiplier")
|
|
418
|
-
def bgwriter_lru_multiplier(self) -> Optional[pulumi.Input[
|
|
417
|
+
def bgwriter_lru_multiplier(self) -> Optional[pulumi.Input[_builtins.float]]:
|
|
419
418
|
"""
|
|
420
419
|
The average recent need for new buffers is multiplied by bgwriter_lru_multiplier to arrive at an estimate of the number that will be needed during the next round, (up to bgwriter_lru_maxpages). 1.0 represents a “just in time” policy of writing exactly the number of buffers predicted to be needed. Larger values provide some cushion against spikes in demand, while smaller values intentionally leave writes to be done by server processes. The default is 2.0.
|
|
421
420
|
"""
|
|
422
421
|
return pulumi.get(self, "bgwriter_lru_multiplier")
|
|
423
422
|
|
|
424
423
|
@bgwriter_lru_multiplier.setter
|
|
425
|
-
def bgwriter_lru_multiplier(self, value: Optional[pulumi.Input[
|
|
424
|
+
def bgwriter_lru_multiplier(self, value: Optional[pulumi.Input[_builtins.float]]):
|
|
426
425
|
pulumi.set(self, "bgwriter_lru_multiplier", value)
|
|
427
426
|
|
|
428
|
-
@property
|
|
427
|
+
@_builtins.property
|
|
429
428
|
@pulumi.getter(name="deadlockTimeout")
|
|
430
|
-
def deadlock_timeout(self) -> Optional[pulumi.Input[
|
|
429
|
+
def deadlock_timeout(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
431
430
|
"""
|
|
432
431
|
The amount of time, in milliseconds, to wait on a lock before checking to see if there is a deadlock condition.
|
|
433
432
|
"""
|
|
434
433
|
return pulumi.get(self, "deadlock_timeout")
|
|
435
434
|
|
|
436
435
|
@deadlock_timeout.setter
|
|
437
|
-
def deadlock_timeout(self, value: Optional[pulumi.Input[
|
|
436
|
+
def deadlock_timeout(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
438
437
|
pulumi.set(self, "deadlock_timeout", value)
|
|
439
438
|
|
|
440
|
-
@property
|
|
439
|
+
@_builtins.property
|
|
441
440
|
@pulumi.getter(name="defaultToastCompression")
|
|
442
|
-
def default_toast_compression(self) -> Optional[pulumi.Input[
|
|
441
|
+
def default_toast_compression(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
443
442
|
"""
|
|
444
443
|
Specifies the default TOAST compression method for values of compressible columns (the default is lz4). Supported values are: `lz4`, `pglz`.
|
|
445
444
|
"""
|
|
446
445
|
return pulumi.get(self, "default_toast_compression")
|
|
447
446
|
|
|
448
447
|
@default_toast_compression.setter
|
|
449
|
-
def default_toast_compression(self, value: Optional[pulumi.Input[
|
|
448
|
+
def default_toast_compression(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
450
449
|
pulumi.set(self, "default_toast_compression", value)
|
|
451
450
|
|
|
452
|
-
@property
|
|
451
|
+
@_builtins.property
|
|
453
452
|
@pulumi.getter(name="idleInTransactionSessionTimeout")
|
|
454
|
-
def idle_in_transaction_session_timeout(self) -> Optional[pulumi.Input[
|
|
453
|
+
def idle_in_transaction_session_timeout(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
455
454
|
"""
|
|
456
455
|
Time out sessions with open transactions after this number of milliseconds
|
|
457
456
|
"""
|
|
458
457
|
return pulumi.get(self, "idle_in_transaction_session_timeout")
|
|
459
458
|
|
|
460
459
|
@idle_in_transaction_session_timeout.setter
|
|
461
|
-
def idle_in_transaction_session_timeout(self, value: Optional[pulumi.Input[
|
|
460
|
+
def idle_in_transaction_session_timeout(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
462
461
|
pulumi.set(self, "idle_in_transaction_session_timeout", value)
|
|
463
462
|
|
|
464
|
-
@property
|
|
463
|
+
@_builtins.property
|
|
465
464
|
@pulumi.getter
|
|
466
|
-
def jit(self) -> Optional[pulumi.Input[
|
|
465
|
+
def jit(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
467
466
|
"""
|
|
468
467
|
Activates, in a boolean, the system-wide use of Just-in-Time Compilation (JIT).
|
|
469
468
|
"""
|
|
470
469
|
return pulumi.get(self, "jit")
|
|
471
470
|
|
|
472
471
|
@jit.setter
|
|
473
|
-
def jit(self, value: Optional[pulumi.Input[
|
|
472
|
+
def jit(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
474
473
|
pulumi.set(self, "jit", value)
|
|
475
474
|
|
|
476
|
-
@property
|
|
475
|
+
@_builtins.property
|
|
477
476
|
@pulumi.getter(name="logAutovacuumMinDuration")
|
|
478
|
-
def log_autovacuum_min_duration(self) -> Optional[pulumi.Input[
|
|
477
|
+
def log_autovacuum_min_duration(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
479
478
|
"""
|
|
480
479
|
Causes each action executed by autovacuum to be logged if it ran for at least the specified number of milliseconds. Setting this to zero logs all autovacuum actions. Minus-one (the default) disables logging autovacuum actions.
|
|
481
480
|
"""
|
|
482
481
|
return pulumi.get(self, "log_autovacuum_min_duration")
|
|
483
482
|
|
|
484
483
|
@log_autovacuum_min_duration.setter
|
|
485
|
-
def log_autovacuum_min_duration(self, value: Optional[pulumi.Input[
|
|
484
|
+
def log_autovacuum_min_duration(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
486
485
|
pulumi.set(self, "log_autovacuum_min_duration", value)
|
|
487
486
|
|
|
488
|
-
@property
|
|
487
|
+
@_builtins.property
|
|
489
488
|
@pulumi.getter(name="logErrorVerbosity")
|
|
490
|
-
def log_error_verbosity(self) -> Optional[pulumi.Input[
|
|
489
|
+
def log_error_verbosity(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
491
490
|
"""
|
|
492
491
|
Controls the amount of detail written in the server log for each message that is logged. Supported values are: `TERSE`, `DEFAULT`, `VERBOSE`.
|
|
493
492
|
"""
|
|
494
493
|
return pulumi.get(self, "log_error_verbosity")
|
|
495
494
|
|
|
496
495
|
@log_error_verbosity.setter
|
|
497
|
-
def log_error_verbosity(self, value: Optional[pulumi.Input[
|
|
496
|
+
def log_error_verbosity(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
498
497
|
pulumi.set(self, "log_error_verbosity", value)
|
|
499
498
|
|
|
500
|
-
@property
|
|
499
|
+
@_builtins.property
|
|
501
500
|
@pulumi.getter(name="logLinePrefix")
|
|
502
|
-
def log_line_prefix(self) -> Optional[pulumi.Input[
|
|
501
|
+
def log_line_prefix(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
503
502
|
"""
|
|
504
503
|
Selects one of the available log-formats. These can support popular log analyzers like pgbadger, pganalyze, etc. Supported values are: `pid=%p,user=%u,db=%d,app=%a,client=%h`, `%m [%p] %q[user=%u,db=%d,app=%a]`, `%t [%p]: [%l-1] user=%u,db=%d,app=%a,client=%h`.
|
|
505
504
|
"""
|
|
506
505
|
return pulumi.get(self, "log_line_prefix")
|
|
507
506
|
|
|
508
507
|
@log_line_prefix.setter
|
|
509
|
-
def log_line_prefix(self, value: Optional[pulumi.Input[
|
|
508
|
+
def log_line_prefix(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
510
509
|
pulumi.set(self, "log_line_prefix", value)
|
|
511
510
|
|
|
512
|
-
@property
|
|
511
|
+
@_builtins.property
|
|
513
512
|
@pulumi.getter(name="logMinDurationStatement")
|
|
514
|
-
def log_min_duration_statement(self) -> Optional[pulumi.Input[
|
|
513
|
+
def log_min_duration_statement(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
515
514
|
"""
|
|
516
515
|
Log statements that take more than this number of milliseconds to run. If -1, disables.
|
|
517
516
|
"""
|
|
518
517
|
return pulumi.get(self, "log_min_duration_statement")
|
|
519
518
|
|
|
520
519
|
@log_min_duration_statement.setter
|
|
521
|
-
def log_min_duration_statement(self, value: Optional[pulumi.Input[
|
|
520
|
+
def log_min_duration_statement(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
522
521
|
pulumi.set(self, "log_min_duration_statement", value)
|
|
523
522
|
|
|
524
|
-
@property
|
|
523
|
+
@_builtins.property
|
|
525
524
|
@pulumi.getter(name="maxFilesPerProcess")
|
|
526
|
-
def max_files_per_process(self) -> Optional[pulumi.Input[
|
|
525
|
+
def max_files_per_process(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
527
526
|
"""
|
|
528
527
|
PostgreSQL maximum number of files that can be open per process.
|
|
529
528
|
"""
|
|
530
529
|
return pulumi.get(self, "max_files_per_process")
|
|
531
530
|
|
|
532
531
|
@max_files_per_process.setter
|
|
533
|
-
def max_files_per_process(self, value: Optional[pulumi.Input[
|
|
532
|
+
def max_files_per_process(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
534
533
|
pulumi.set(self, "max_files_per_process", value)
|
|
535
534
|
|
|
536
|
-
@property
|
|
535
|
+
@_builtins.property
|
|
537
536
|
@pulumi.getter(name="maxLocksPerTransaction")
|
|
538
|
-
def max_locks_per_transaction(self) -> Optional[pulumi.Input[
|
|
537
|
+
def max_locks_per_transaction(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
539
538
|
"""
|
|
540
539
|
PostgreSQL maximum locks per transaction. Once increased, this parameter cannot be lowered from its set value.
|
|
541
540
|
"""
|
|
542
541
|
return pulumi.get(self, "max_locks_per_transaction")
|
|
543
542
|
|
|
544
543
|
@max_locks_per_transaction.setter
|
|
545
|
-
def max_locks_per_transaction(self, value: Optional[pulumi.Input[
|
|
544
|
+
def max_locks_per_transaction(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
546
545
|
pulumi.set(self, "max_locks_per_transaction", value)
|
|
547
546
|
|
|
548
|
-
@property
|
|
547
|
+
@_builtins.property
|
|
549
548
|
@pulumi.getter(name="maxLogicalReplicationWorkers")
|
|
550
|
-
def max_logical_replication_workers(self) -> Optional[pulumi.Input[
|
|
549
|
+
def max_logical_replication_workers(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
551
550
|
"""
|
|
552
551
|
PostgreSQL maximum logical replication workers (taken from the pool of max_parallel_workers).
|
|
553
552
|
"""
|
|
554
553
|
return pulumi.get(self, "max_logical_replication_workers")
|
|
555
554
|
|
|
556
555
|
@max_logical_replication_workers.setter
|
|
557
|
-
def max_logical_replication_workers(self, value: Optional[pulumi.Input[
|
|
556
|
+
def max_logical_replication_workers(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
558
557
|
pulumi.set(self, "max_logical_replication_workers", value)
|
|
559
558
|
|
|
560
|
-
@property
|
|
559
|
+
@_builtins.property
|
|
561
560
|
@pulumi.getter(name="maxParallelWorkers")
|
|
562
|
-
def max_parallel_workers(self) -> Optional[pulumi.Input[
|
|
561
|
+
def max_parallel_workers(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
563
562
|
"""
|
|
564
563
|
Sets the maximum number of workers that the system can support for parallel queries.
|
|
565
564
|
"""
|
|
566
565
|
return pulumi.get(self, "max_parallel_workers")
|
|
567
566
|
|
|
568
567
|
@max_parallel_workers.setter
|
|
569
|
-
def max_parallel_workers(self, value: Optional[pulumi.Input[
|
|
568
|
+
def max_parallel_workers(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
570
569
|
pulumi.set(self, "max_parallel_workers", value)
|
|
571
570
|
|
|
572
|
-
@property
|
|
571
|
+
@_builtins.property
|
|
573
572
|
@pulumi.getter(name="maxParallelWorkersPerGather")
|
|
574
|
-
def max_parallel_workers_per_gather(self) -> Optional[pulumi.Input[
|
|
573
|
+
def max_parallel_workers_per_gather(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
575
574
|
"""
|
|
576
575
|
Sets the maximum number of workers that can be started by a single Gather or Gather Merge node.
|
|
577
576
|
"""
|
|
578
577
|
return pulumi.get(self, "max_parallel_workers_per_gather")
|
|
579
578
|
|
|
580
579
|
@max_parallel_workers_per_gather.setter
|
|
581
|
-
def max_parallel_workers_per_gather(self, value: Optional[pulumi.Input[
|
|
580
|
+
def max_parallel_workers_per_gather(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
582
581
|
pulumi.set(self, "max_parallel_workers_per_gather", value)
|
|
583
582
|
|
|
584
|
-
@property
|
|
583
|
+
@_builtins.property
|
|
585
584
|
@pulumi.getter(name="maxPredLocksPerTransaction")
|
|
586
|
-
def max_pred_locks_per_transaction(self) -> Optional[pulumi.Input[
|
|
585
|
+
def max_pred_locks_per_transaction(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
587
586
|
"""
|
|
588
587
|
PostgreSQL maximum predicate locks per transaction.
|
|
589
588
|
"""
|
|
590
589
|
return pulumi.get(self, "max_pred_locks_per_transaction")
|
|
591
590
|
|
|
592
591
|
@max_pred_locks_per_transaction.setter
|
|
593
|
-
def max_pred_locks_per_transaction(self, value: Optional[pulumi.Input[
|
|
592
|
+
def max_pred_locks_per_transaction(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
594
593
|
pulumi.set(self, "max_pred_locks_per_transaction", value)
|
|
595
594
|
|
|
596
|
-
@property
|
|
595
|
+
@_builtins.property
|
|
597
596
|
@pulumi.getter(name="maxPreparedTransactions")
|
|
598
|
-
def max_prepared_transactions(self) -> Optional[pulumi.Input[
|
|
597
|
+
def max_prepared_transactions(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
599
598
|
"""
|
|
600
599
|
PostgreSQL maximum prepared transactions. Once increased, this parameter cannot be lowered from its set value.
|
|
601
600
|
"""
|
|
602
601
|
return pulumi.get(self, "max_prepared_transactions")
|
|
603
602
|
|
|
604
603
|
@max_prepared_transactions.setter
|
|
605
|
-
def max_prepared_transactions(self, value: Optional[pulumi.Input[
|
|
604
|
+
def max_prepared_transactions(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
606
605
|
pulumi.set(self, "max_prepared_transactions", value)
|
|
607
606
|
|
|
608
|
-
@property
|
|
607
|
+
@_builtins.property
|
|
609
608
|
@pulumi.getter(name="maxReplicationSlots")
|
|
610
|
-
def max_replication_slots(self) -> Optional[pulumi.Input[
|
|
609
|
+
def max_replication_slots(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
611
610
|
"""
|
|
612
611
|
PostgreSQL maximum replication slots.
|
|
613
612
|
"""
|
|
614
613
|
return pulumi.get(self, "max_replication_slots")
|
|
615
614
|
|
|
616
615
|
@max_replication_slots.setter
|
|
617
|
-
def max_replication_slots(self, value: Optional[pulumi.Input[
|
|
616
|
+
def max_replication_slots(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
618
617
|
pulumi.set(self, "max_replication_slots", value)
|
|
619
618
|
|
|
620
|
-
@property
|
|
619
|
+
@_builtins.property
|
|
621
620
|
@pulumi.getter(name="maxStackDepth")
|
|
622
|
-
def max_stack_depth(self) -> Optional[pulumi.Input[
|
|
621
|
+
def max_stack_depth(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
623
622
|
"""
|
|
624
623
|
Maximum depth of the stack in bytes.
|
|
625
624
|
"""
|
|
626
625
|
return pulumi.get(self, "max_stack_depth")
|
|
627
626
|
|
|
628
627
|
@max_stack_depth.setter
|
|
629
|
-
def max_stack_depth(self, value: Optional[pulumi.Input[
|
|
628
|
+
def max_stack_depth(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
630
629
|
pulumi.set(self, "max_stack_depth", value)
|
|
631
630
|
|
|
632
|
-
@property
|
|
631
|
+
@_builtins.property
|
|
633
632
|
@pulumi.getter(name="maxStandbyArchiveDelay")
|
|
634
|
-
def max_standby_archive_delay(self) -> Optional[pulumi.Input[
|
|
633
|
+
def max_standby_archive_delay(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
635
634
|
"""
|
|
636
635
|
Max standby archive delay in milliseconds.
|
|
637
636
|
"""
|
|
638
637
|
return pulumi.get(self, "max_standby_archive_delay")
|
|
639
638
|
|
|
640
639
|
@max_standby_archive_delay.setter
|
|
641
|
-
def max_standby_archive_delay(self, value: Optional[pulumi.Input[
|
|
640
|
+
def max_standby_archive_delay(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
642
641
|
pulumi.set(self, "max_standby_archive_delay", value)
|
|
643
642
|
|
|
644
|
-
@property
|
|
643
|
+
@_builtins.property
|
|
645
644
|
@pulumi.getter(name="maxStandbyStreamingDelay")
|
|
646
|
-
def max_standby_streaming_delay(self) -> Optional[pulumi.Input[
|
|
645
|
+
def max_standby_streaming_delay(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
647
646
|
"""
|
|
648
647
|
Max standby streaming delay in milliseconds.
|
|
649
648
|
"""
|
|
650
649
|
return pulumi.get(self, "max_standby_streaming_delay")
|
|
651
650
|
|
|
652
651
|
@max_standby_streaming_delay.setter
|
|
653
|
-
def max_standby_streaming_delay(self, value: Optional[pulumi.Input[
|
|
652
|
+
def max_standby_streaming_delay(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
654
653
|
pulumi.set(self, "max_standby_streaming_delay", value)
|
|
655
654
|
|
|
656
|
-
@property
|
|
655
|
+
@_builtins.property
|
|
657
656
|
@pulumi.getter(name="maxWalSenders")
|
|
658
|
-
def max_wal_senders(self) -> Optional[pulumi.Input[
|
|
657
|
+
def max_wal_senders(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
659
658
|
"""
|
|
660
659
|
PostgreSQL maximum WAL senders. Once increased, this parameter cannot be lowered from its set value.
|
|
661
660
|
"""
|
|
662
661
|
return pulumi.get(self, "max_wal_senders")
|
|
663
662
|
|
|
664
663
|
@max_wal_senders.setter
|
|
665
|
-
def max_wal_senders(self, value: Optional[pulumi.Input[
|
|
664
|
+
def max_wal_senders(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
666
665
|
pulumi.set(self, "max_wal_senders", value)
|
|
667
666
|
|
|
668
|
-
@property
|
|
667
|
+
@_builtins.property
|
|
669
668
|
@pulumi.getter(name="maxWorkerProcesses")
|
|
670
|
-
def max_worker_processes(self) -> Optional[pulumi.Input[
|
|
669
|
+
def max_worker_processes(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
671
670
|
"""
|
|
672
671
|
Sets the maximum number of background processes that the system can support. Once increased, this parameter cannot be lowered from its set value.
|
|
673
672
|
"""
|
|
674
673
|
return pulumi.get(self, "max_worker_processes")
|
|
675
674
|
|
|
676
675
|
@max_worker_processes.setter
|
|
677
|
-
def max_worker_processes(self, value: Optional[pulumi.Input[
|
|
676
|
+
def max_worker_processes(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
678
677
|
pulumi.set(self, "max_worker_processes", value)
|
|
679
678
|
|
|
680
|
-
@property
|
|
679
|
+
@_builtins.property
|
|
681
680
|
@pulumi.getter(name="pgPartmanBgwInterval")
|
|
682
|
-
def pg_partman_bgw_interval(self) -> Optional[pulumi.Input[
|
|
681
|
+
def pg_partman_bgw_interval(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
683
682
|
"""
|
|
684
683
|
Sets the time interval to run pg_partman's scheduled tasks.
|
|
685
684
|
"""
|
|
686
685
|
return pulumi.get(self, "pg_partman_bgw_interval")
|
|
687
686
|
|
|
688
687
|
@pg_partman_bgw_interval.setter
|
|
689
|
-
def pg_partman_bgw_interval(self, value: Optional[pulumi.Input[
|
|
688
|
+
def pg_partman_bgw_interval(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
690
689
|
pulumi.set(self, "pg_partman_bgw_interval", value)
|
|
691
690
|
|
|
692
|
-
@property
|
|
691
|
+
@_builtins.property
|
|
693
692
|
@pulumi.getter(name="pgPartmanBgwRole")
|
|
694
|
-
def pg_partman_bgw_role(self) -> Optional[pulumi.Input[
|
|
693
|
+
def pg_partman_bgw_role(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
695
694
|
"""
|
|
696
695
|
Controls which role to use for pg_partman's scheduled background tasks. Must consist of alpha-numeric characters, dots, underscores, or dashes. May not start with dash or dot. Maximum of 64 characters.
|
|
697
696
|
"""
|
|
698
697
|
return pulumi.get(self, "pg_partman_bgw_role")
|
|
699
698
|
|
|
700
699
|
@pg_partman_bgw_role.setter
|
|
701
|
-
def pg_partman_bgw_role(self, value: Optional[pulumi.Input[
|
|
700
|
+
def pg_partman_bgw_role(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
702
701
|
pulumi.set(self, "pg_partman_bgw_role", value)
|
|
703
702
|
|
|
704
|
-
@property
|
|
703
|
+
@_builtins.property
|
|
705
704
|
@pulumi.getter(name="pgStatStatementsTrack")
|
|
706
|
-
def pg_stat_statements_track(self) -> Optional[pulumi.Input[
|
|
705
|
+
def pg_stat_statements_track(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
707
706
|
"""
|
|
708
707
|
Controls which statements are counted. Specify 'top' to track top-level statements (those issued directly by clients), 'all' to also track nested statements (such as statements invoked within functions), or 'none' to disable statement statistics collection. The default value is top. Supported values are: `all`, `top`, `none`.
|
|
709
708
|
"""
|
|
710
709
|
return pulumi.get(self, "pg_stat_statements_track")
|
|
711
710
|
|
|
712
711
|
@pg_stat_statements_track.setter
|
|
713
|
-
def pg_stat_statements_track(self, value: Optional[pulumi.Input[
|
|
712
|
+
def pg_stat_statements_track(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
714
713
|
pulumi.set(self, "pg_stat_statements_track", value)
|
|
715
714
|
|
|
716
|
-
@property
|
|
715
|
+
@_builtins.property
|
|
717
716
|
@pulumi.getter
|
|
718
717
|
def pgbouncers(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['DatabasePostgresqlConfigPgbouncerArgs']]]]:
|
|
719
718
|
"""
|
|
@@ -725,31 +724,31 @@ class DatabasePostgresqlConfigArgs:
|
|
|
725
724
|
def pgbouncers(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['DatabasePostgresqlConfigPgbouncerArgs']]]]):
|
|
726
725
|
pulumi.set(self, "pgbouncers", value)
|
|
727
726
|
|
|
728
|
-
@property
|
|
727
|
+
@_builtins.property
|
|
729
728
|
@pulumi.getter(name="sharedBuffersPercentage")
|
|
730
|
-
def shared_buffers_percentage(self) -> Optional[pulumi.Input[
|
|
729
|
+
def shared_buffers_percentage(self) -> Optional[pulumi.Input[_builtins.float]]:
|
|
731
730
|
"""
|
|
732
731
|
Percentage of total RAM that the database server uses for shared memory buffers. Valid range is 20-60 (float), which corresponds to 20% - 60%. This setting adjusts the shared_buffers configuration value.
|
|
733
732
|
"""
|
|
734
733
|
return pulumi.get(self, "shared_buffers_percentage")
|
|
735
734
|
|
|
736
735
|
@shared_buffers_percentage.setter
|
|
737
|
-
def shared_buffers_percentage(self, value: Optional[pulumi.Input[
|
|
736
|
+
def shared_buffers_percentage(self, value: Optional[pulumi.Input[_builtins.float]]):
|
|
738
737
|
pulumi.set(self, "shared_buffers_percentage", value)
|
|
739
738
|
|
|
740
|
-
@property
|
|
739
|
+
@_builtins.property
|
|
741
740
|
@pulumi.getter(name="tempFileLimit")
|
|
742
|
-
def temp_file_limit(self) -> Optional[pulumi.Input[
|
|
741
|
+
def temp_file_limit(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
743
742
|
"""
|
|
744
743
|
PostgreSQL temporary file limit in KiB. If -1, sets to unlimited.
|
|
745
744
|
"""
|
|
746
745
|
return pulumi.get(self, "temp_file_limit")
|
|
747
746
|
|
|
748
747
|
@temp_file_limit.setter
|
|
749
|
-
def temp_file_limit(self, value: Optional[pulumi.Input[
|
|
748
|
+
def temp_file_limit(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
750
749
|
pulumi.set(self, "temp_file_limit", value)
|
|
751
750
|
|
|
752
|
-
@property
|
|
751
|
+
@_builtins.property
|
|
753
752
|
@pulumi.getter
|
|
754
753
|
def timescaledbs(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['DatabasePostgresqlConfigTimescaledbArgs']]]]:
|
|
755
754
|
"""
|
|
@@ -761,212 +760,212 @@ class DatabasePostgresqlConfigArgs:
|
|
|
761
760
|
def timescaledbs(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['DatabasePostgresqlConfigTimescaledbArgs']]]]):
|
|
762
761
|
pulumi.set(self, "timescaledbs", value)
|
|
763
762
|
|
|
764
|
-
@property
|
|
763
|
+
@_builtins.property
|
|
765
764
|
@pulumi.getter
|
|
766
|
-
def timezone(self) -> Optional[pulumi.Input[
|
|
765
|
+
def timezone(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
767
766
|
"""
|
|
768
767
|
PostgreSQL service timezone
|
|
769
768
|
"""
|
|
770
769
|
return pulumi.get(self, "timezone")
|
|
771
770
|
|
|
772
771
|
@timezone.setter
|
|
773
|
-
def timezone(self, value: Optional[pulumi.Input[
|
|
772
|
+
def timezone(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
774
773
|
pulumi.set(self, "timezone", value)
|
|
775
774
|
|
|
776
|
-
@property
|
|
775
|
+
@_builtins.property
|
|
777
776
|
@pulumi.getter(name="trackActivityQuerySize")
|
|
778
|
-
def track_activity_query_size(self) -> Optional[pulumi.Input[
|
|
777
|
+
def track_activity_query_size(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
779
778
|
"""
|
|
780
779
|
Specifies the number of bytes reserved to track the currently executing command for each active session.
|
|
781
780
|
"""
|
|
782
781
|
return pulumi.get(self, "track_activity_query_size")
|
|
783
782
|
|
|
784
783
|
@track_activity_query_size.setter
|
|
785
|
-
def track_activity_query_size(self, value: Optional[pulumi.Input[
|
|
784
|
+
def track_activity_query_size(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
786
785
|
pulumi.set(self, "track_activity_query_size", value)
|
|
787
786
|
|
|
788
|
-
@property
|
|
787
|
+
@_builtins.property
|
|
789
788
|
@pulumi.getter(name="trackCommitTimestamp")
|
|
790
|
-
def track_commit_timestamp(self) -> Optional[pulumi.Input[
|
|
789
|
+
def track_commit_timestamp(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
791
790
|
"""
|
|
792
791
|
Record commit time of transactions. The default value is top. Supported values are: `off`, `on`.
|
|
793
792
|
"""
|
|
794
793
|
return pulumi.get(self, "track_commit_timestamp")
|
|
795
794
|
|
|
796
795
|
@track_commit_timestamp.setter
|
|
797
|
-
def track_commit_timestamp(self, value: Optional[pulumi.Input[
|
|
796
|
+
def track_commit_timestamp(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
798
797
|
pulumi.set(self, "track_commit_timestamp", value)
|
|
799
798
|
|
|
800
|
-
@property
|
|
799
|
+
@_builtins.property
|
|
801
800
|
@pulumi.getter(name="trackFunctions")
|
|
802
|
-
def track_functions(self) -> Optional[pulumi.Input[
|
|
801
|
+
def track_functions(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
803
802
|
"""
|
|
804
803
|
Enables tracking of function call counts and time used. The default value is top. Supported values are: `all`, `pl`, `none`.
|
|
805
804
|
"""
|
|
806
805
|
return pulumi.get(self, "track_functions")
|
|
807
806
|
|
|
808
807
|
@track_functions.setter
|
|
809
|
-
def track_functions(self, value: Optional[pulumi.Input[
|
|
808
|
+
def track_functions(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
810
809
|
pulumi.set(self, "track_functions", value)
|
|
811
810
|
|
|
812
|
-
@property
|
|
811
|
+
@_builtins.property
|
|
813
812
|
@pulumi.getter(name="trackIoTiming")
|
|
814
|
-
def track_io_timing(self) -> Optional[pulumi.Input[
|
|
813
|
+
def track_io_timing(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
815
814
|
"""
|
|
816
815
|
Enables timing of database I/O calls. This parameter is off by default, because it will repeatedly query the operating system for the current time, which may cause significant overhead on some platforms. The default value is top. Supported values are: `off`, `on`.
|
|
817
816
|
"""
|
|
818
817
|
return pulumi.get(self, "track_io_timing")
|
|
819
818
|
|
|
820
819
|
@track_io_timing.setter
|
|
821
|
-
def track_io_timing(self, value: Optional[pulumi.Input[
|
|
820
|
+
def track_io_timing(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
822
821
|
pulumi.set(self, "track_io_timing", value)
|
|
823
822
|
|
|
824
|
-
@property
|
|
823
|
+
@_builtins.property
|
|
825
824
|
@pulumi.getter(name="walSenderTimeout")
|
|
826
|
-
def wal_sender_timeout(self) -> Optional[pulumi.Input[
|
|
825
|
+
def wal_sender_timeout(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
827
826
|
"""
|
|
828
827
|
Terminate replication connections that are inactive for longer than this amount of time, in milliseconds. Setting this value to zero disables the timeout. Must be either 0 or between 5000 and 10800000.
|
|
829
828
|
"""
|
|
830
829
|
return pulumi.get(self, "wal_sender_timeout")
|
|
831
830
|
|
|
832
831
|
@wal_sender_timeout.setter
|
|
833
|
-
def wal_sender_timeout(self, value: Optional[pulumi.Input[
|
|
832
|
+
def wal_sender_timeout(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
834
833
|
pulumi.set(self, "wal_sender_timeout", value)
|
|
835
834
|
|
|
836
|
-
@property
|
|
835
|
+
@_builtins.property
|
|
837
836
|
@pulumi.getter(name="walWriterDelay")
|
|
838
|
-
def wal_writer_delay(self) -> Optional[pulumi.Input[
|
|
837
|
+
def wal_writer_delay(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
839
838
|
"""
|
|
840
839
|
WAL flush interval in milliseconds. Note that setting this value to lower than the default 200ms may negatively impact performance
|
|
841
840
|
"""
|
|
842
841
|
return pulumi.get(self, "wal_writer_delay")
|
|
843
842
|
|
|
844
843
|
@wal_writer_delay.setter
|
|
845
|
-
def wal_writer_delay(self, value: Optional[pulumi.Input[
|
|
844
|
+
def wal_writer_delay(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
846
845
|
pulumi.set(self, "wal_writer_delay", value)
|
|
847
846
|
|
|
848
|
-
@property
|
|
847
|
+
@_builtins.property
|
|
849
848
|
@pulumi.getter(name="workMem")
|
|
850
|
-
def work_mem(self) -> Optional[pulumi.Input[
|
|
849
|
+
def work_mem(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
851
850
|
"""
|
|
852
851
|
The maximum amount of memory, in MB, used by a query operation (such as a sort or hash table) before writing to temporary disk files. Default is 1MB + 0.075% of total RAM (up to 32MB).
|
|
853
852
|
"""
|
|
854
853
|
return pulumi.get(self, "work_mem")
|
|
855
854
|
|
|
856
855
|
@work_mem.setter
|
|
857
|
-
def work_mem(self, value: Optional[pulumi.Input[
|
|
856
|
+
def work_mem(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
858
857
|
pulumi.set(self, "work_mem", value)
|
|
859
858
|
|
|
860
859
|
|
|
861
860
|
@pulumi.input_type
|
|
862
861
|
class _DatabasePostgresqlConfigState:
|
|
863
862
|
def __init__(__self__, *,
|
|
864
|
-
autovacuum_analyze_scale_factor: Optional[pulumi.Input[
|
|
865
|
-
autovacuum_analyze_threshold: Optional[pulumi.Input[
|
|
866
|
-
autovacuum_freeze_max_age: Optional[pulumi.Input[
|
|
867
|
-
autovacuum_max_workers: Optional[pulumi.Input[
|
|
868
|
-
autovacuum_naptime: Optional[pulumi.Input[
|
|
869
|
-
autovacuum_vacuum_cost_delay: Optional[pulumi.Input[
|
|
870
|
-
autovacuum_vacuum_cost_limit: Optional[pulumi.Input[
|
|
871
|
-
autovacuum_vacuum_scale_factor: Optional[pulumi.Input[
|
|
872
|
-
autovacuum_vacuum_threshold: Optional[pulumi.Input[
|
|
873
|
-
backup_hour: Optional[pulumi.Input[
|
|
874
|
-
backup_minute: Optional[pulumi.Input[
|
|
875
|
-
bgwriter_delay: Optional[pulumi.Input[
|
|
876
|
-
bgwriter_flush_after: Optional[pulumi.Input[
|
|
877
|
-
bgwriter_lru_maxpages: Optional[pulumi.Input[
|
|
878
|
-
bgwriter_lru_multiplier: Optional[pulumi.Input[
|
|
879
|
-
cluster_id: Optional[pulumi.Input[
|
|
880
|
-
deadlock_timeout: Optional[pulumi.Input[
|
|
881
|
-
default_toast_compression: Optional[pulumi.Input[
|
|
882
|
-
idle_in_transaction_session_timeout: Optional[pulumi.Input[
|
|
883
|
-
jit: Optional[pulumi.Input[
|
|
884
|
-
log_autovacuum_min_duration: Optional[pulumi.Input[
|
|
885
|
-
log_error_verbosity: Optional[pulumi.Input[
|
|
886
|
-
log_line_prefix: Optional[pulumi.Input[
|
|
887
|
-
log_min_duration_statement: Optional[pulumi.Input[
|
|
888
|
-
max_files_per_process: Optional[pulumi.Input[
|
|
889
|
-
max_locks_per_transaction: Optional[pulumi.Input[
|
|
890
|
-
max_logical_replication_workers: Optional[pulumi.Input[
|
|
891
|
-
max_parallel_workers: Optional[pulumi.Input[
|
|
892
|
-
max_parallel_workers_per_gather: Optional[pulumi.Input[
|
|
893
|
-
max_pred_locks_per_transaction: Optional[pulumi.Input[
|
|
894
|
-
max_prepared_transactions: Optional[pulumi.Input[
|
|
895
|
-
max_replication_slots: Optional[pulumi.Input[
|
|
896
|
-
max_stack_depth: Optional[pulumi.Input[
|
|
897
|
-
max_standby_archive_delay: Optional[pulumi.Input[
|
|
898
|
-
max_standby_streaming_delay: Optional[pulumi.Input[
|
|
899
|
-
max_wal_senders: Optional[pulumi.Input[
|
|
900
|
-
max_worker_processes: Optional[pulumi.Input[
|
|
901
|
-
pg_partman_bgw_interval: Optional[pulumi.Input[
|
|
902
|
-
pg_partman_bgw_role: Optional[pulumi.Input[
|
|
903
|
-
pg_stat_statements_track: Optional[pulumi.Input[
|
|
863
|
+
autovacuum_analyze_scale_factor: Optional[pulumi.Input[_builtins.float]] = None,
|
|
864
|
+
autovacuum_analyze_threshold: Optional[pulumi.Input[_builtins.int]] = None,
|
|
865
|
+
autovacuum_freeze_max_age: Optional[pulumi.Input[_builtins.int]] = None,
|
|
866
|
+
autovacuum_max_workers: Optional[pulumi.Input[_builtins.int]] = None,
|
|
867
|
+
autovacuum_naptime: Optional[pulumi.Input[_builtins.int]] = None,
|
|
868
|
+
autovacuum_vacuum_cost_delay: Optional[pulumi.Input[_builtins.int]] = None,
|
|
869
|
+
autovacuum_vacuum_cost_limit: Optional[pulumi.Input[_builtins.int]] = None,
|
|
870
|
+
autovacuum_vacuum_scale_factor: Optional[pulumi.Input[_builtins.float]] = None,
|
|
871
|
+
autovacuum_vacuum_threshold: Optional[pulumi.Input[_builtins.int]] = None,
|
|
872
|
+
backup_hour: Optional[pulumi.Input[_builtins.int]] = None,
|
|
873
|
+
backup_minute: Optional[pulumi.Input[_builtins.int]] = None,
|
|
874
|
+
bgwriter_delay: Optional[pulumi.Input[_builtins.int]] = None,
|
|
875
|
+
bgwriter_flush_after: Optional[pulumi.Input[_builtins.int]] = None,
|
|
876
|
+
bgwriter_lru_maxpages: Optional[pulumi.Input[_builtins.int]] = None,
|
|
877
|
+
bgwriter_lru_multiplier: Optional[pulumi.Input[_builtins.float]] = None,
|
|
878
|
+
cluster_id: Optional[pulumi.Input[_builtins.str]] = None,
|
|
879
|
+
deadlock_timeout: Optional[pulumi.Input[_builtins.int]] = None,
|
|
880
|
+
default_toast_compression: Optional[pulumi.Input[_builtins.str]] = None,
|
|
881
|
+
idle_in_transaction_session_timeout: Optional[pulumi.Input[_builtins.int]] = None,
|
|
882
|
+
jit: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
883
|
+
log_autovacuum_min_duration: Optional[pulumi.Input[_builtins.int]] = None,
|
|
884
|
+
log_error_verbosity: Optional[pulumi.Input[_builtins.str]] = None,
|
|
885
|
+
log_line_prefix: Optional[pulumi.Input[_builtins.str]] = None,
|
|
886
|
+
log_min_duration_statement: Optional[pulumi.Input[_builtins.int]] = None,
|
|
887
|
+
max_files_per_process: Optional[pulumi.Input[_builtins.int]] = None,
|
|
888
|
+
max_locks_per_transaction: Optional[pulumi.Input[_builtins.int]] = None,
|
|
889
|
+
max_logical_replication_workers: Optional[pulumi.Input[_builtins.int]] = None,
|
|
890
|
+
max_parallel_workers: Optional[pulumi.Input[_builtins.int]] = None,
|
|
891
|
+
max_parallel_workers_per_gather: Optional[pulumi.Input[_builtins.int]] = None,
|
|
892
|
+
max_pred_locks_per_transaction: Optional[pulumi.Input[_builtins.int]] = None,
|
|
893
|
+
max_prepared_transactions: Optional[pulumi.Input[_builtins.int]] = None,
|
|
894
|
+
max_replication_slots: Optional[pulumi.Input[_builtins.int]] = None,
|
|
895
|
+
max_stack_depth: Optional[pulumi.Input[_builtins.int]] = None,
|
|
896
|
+
max_standby_archive_delay: Optional[pulumi.Input[_builtins.int]] = None,
|
|
897
|
+
max_standby_streaming_delay: Optional[pulumi.Input[_builtins.int]] = None,
|
|
898
|
+
max_wal_senders: Optional[pulumi.Input[_builtins.int]] = None,
|
|
899
|
+
max_worker_processes: Optional[pulumi.Input[_builtins.int]] = None,
|
|
900
|
+
pg_partman_bgw_interval: Optional[pulumi.Input[_builtins.int]] = None,
|
|
901
|
+
pg_partman_bgw_role: Optional[pulumi.Input[_builtins.str]] = None,
|
|
902
|
+
pg_stat_statements_track: Optional[pulumi.Input[_builtins.str]] = None,
|
|
904
903
|
pgbouncers: Optional[pulumi.Input[Sequence[pulumi.Input['DatabasePostgresqlConfigPgbouncerArgs']]]] = None,
|
|
905
|
-
shared_buffers_percentage: Optional[pulumi.Input[
|
|
906
|
-
temp_file_limit: Optional[pulumi.Input[
|
|
904
|
+
shared_buffers_percentage: Optional[pulumi.Input[_builtins.float]] = None,
|
|
905
|
+
temp_file_limit: Optional[pulumi.Input[_builtins.int]] = None,
|
|
907
906
|
timescaledbs: Optional[pulumi.Input[Sequence[pulumi.Input['DatabasePostgresqlConfigTimescaledbArgs']]]] = None,
|
|
908
|
-
timezone: Optional[pulumi.Input[
|
|
909
|
-
track_activity_query_size: Optional[pulumi.Input[
|
|
910
|
-
track_commit_timestamp: Optional[pulumi.Input[
|
|
911
|
-
track_functions: Optional[pulumi.Input[
|
|
912
|
-
track_io_timing: Optional[pulumi.Input[
|
|
913
|
-
wal_sender_timeout: Optional[pulumi.Input[
|
|
914
|
-
wal_writer_delay: Optional[pulumi.Input[
|
|
915
|
-
work_mem: Optional[pulumi.Input[
|
|
907
|
+
timezone: Optional[pulumi.Input[_builtins.str]] = None,
|
|
908
|
+
track_activity_query_size: Optional[pulumi.Input[_builtins.int]] = None,
|
|
909
|
+
track_commit_timestamp: Optional[pulumi.Input[_builtins.str]] = None,
|
|
910
|
+
track_functions: Optional[pulumi.Input[_builtins.str]] = None,
|
|
911
|
+
track_io_timing: Optional[pulumi.Input[_builtins.str]] = None,
|
|
912
|
+
wal_sender_timeout: Optional[pulumi.Input[_builtins.int]] = None,
|
|
913
|
+
wal_writer_delay: Optional[pulumi.Input[_builtins.int]] = None,
|
|
914
|
+
work_mem: Optional[pulumi.Input[_builtins.int]] = None):
|
|
916
915
|
"""
|
|
917
916
|
Input properties used for looking up and filtering DatabasePostgresqlConfig resources.
|
|
918
|
-
:param pulumi.Input[
|
|
919
|
-
:param pulumi.Input[
|
|
920
|
-
:param pulumi.Input[
|
|
921
|
-
:param pulumi.Input[
|
|
922
|
-
:param pulumi.Input[
|
|
923
|
-
:param pulumi.Input[
|
|
924
|
-
:param pulumi.Input[
|
|
925
|
-
:param pulumi.Input[
|
|
926
|
-
:param pulumi.Input[
|
|
927
|
-
:param pulumi.Input[
|
|
928
|
-
:param pulumi.Input[
|
|
929
|
-
:param pulumi.Input[
|
|
930
|
-
:param pulumi.Input[
|
|
931
|
-
:param pulumi.Input[
|
|
932
|
-
:param pulumi.Input[
|
|
933
|
-
:param pulumi.Input[
|
|
934
|
-
:param pulumi.Input[
|
|
935
|
-
:param pulumi.Input[
|
|
936
|
-
:param pulumi.Input[
|
|
937
|
-
:param pulumi.Input[
|
|
938
|
-
:param pulumi.Input[
|
|
939
|
-
:param pulumi.Input[
|
|
940
|
-
:param pulumi.Input[
|
|
941
|
-
:param pulumi.Input[
|
|
942
|
-
:param pulumi.Input[
|
|
943
|
-
:param pulumi.Input[
|
|
944
|
-
:param pulumi.Input[
|
|
945
|
-
:param pulumi.Input[
|
|
946
|
-
:param pulumi.Input[
|
|
947
|
-
:param pulumi.Input[
|
|
948
|
-
:param pulumi.Input[
|
|
949
|
-
:param pulumi.Input[
|
|
950
|
-
:param pulumi.Input[
|
|
951
|
-
:param pulumi.Input[
|
|
952
|
-
:param pulumi.Input[
|
|
953
|
-
:param pulumi.Input[
|
|
954
|
-
:param pulumi.Input[
|
|
955
|
-
:param pulumi.Input[
|
|
956
|
-
:param pulumi.Input[
|
|
957
|
-
:param pulumi.Input[
|
|
917
|
+
:param pulumi.Input[_builtins.float] autovacuum_analyze_scale_factor: Specifies a fraction, in a decimal value, of the table size to add to autovacuum_analyze_threshold when deciding whether to trigger an ANALYZE. The default is 0.2 (20% of table size).
|
|
918
|
+
:param pulumi.Input[_builtins.int] autovacuum_analyze_threshold: Specifies the minimum number of inserted, updated, or deleted tuples needed to trigger an ANALYZE in any one table. The default is 50 tuples.
|
|
919
|
+
:param pulumi.Input[_builtins.int] autovacuum_freeze_max_age: Specifies the maximum age (in transactions) that a table's pg_class.relfrozenxid field can attain before a VACUUM operation is forced to prevent transaction ID wraparound within the table. Note that the system will launch autovacuum processes to prevent wraparound even when autovacuum is otherwise disabled. This parameter will cause the server to be restarted.
|
|
920
|
+
:param pulumi.Input[_builtins.int] autovacuum_max_workers: Specifies the maximum number of autovacuum processes (other than the autovacuum launcher) that may be running at any one time. The default is three. This parameter can only be set at server start.
|
|
921
|
+
:param pulumi.Input[_builtins.int] autovacuum_naptime: Specifies the minimum delay, in seconds, between autovacuum runs on any given database. The default is one minute.
|
|
922
|
+
:param pulumi.Input[_builtins.int] autovacuum_vacuum_cost_delay: Specifies the cost delay value, in milliseconds, that will be used in automatic VACUUM operations. If -1, uses the regular vacuum_cost_delay value, which is 20 milliseconds.
|
|
923
|
+
:param pulumi.Input[_builtins.int] autovacuum_vacuum_cost_limit: Specifies the cost limit value that will be used in automatic VACUUM operations. If -1 is specified (which is the default), the regular vacuum_cost_limit value will be used.
|
|
924
|
+
:param pulumi.Input[_builtins.float] autovacuum_vacuum_scale_factor: Specifies a fraction, in a decimal value, of the table size to add to autovacuum_vacuum_threshold when deciding whether to trigger a VACUUM. The default is 0.2 (20% of table size).
|
|
925
|
+
:param pulumi.Input[_builtins.int] autovacuum_vacuum_threshold: Specifies the minimum number of updated or deleted tuples needed to trigger a VACUUM in any one table. The default is 50 tuples.
|
|
926
|
+
:param pulumi.Input[_builtins.int] backup_hour: The hour of day (in UTC) when backup for the service starts. New backup only starts if previous backup has already completed.
|
|
927
|
+
:param pulumi.Input[_builtins.int] backup_minute: The minute of the backup hour when backup for the service starts. New backup is only started if previous backup has already completed.
|
|
928
|
+
:param pulumi.Input[_builtins.int] bgwriter_delay: Specifies the delay, in milliseconds, between activity rounds for the background writer. Default is 200 ms.
|
|
929
|
+
:param pulumi.Input[_builtins.int] bgwriter_flush_after: The amount of kilobytes that need to be written by the background writer before attempting to force the OS to issue these writes to underlying storage. Specified in kilobytes, default is 512. Setting of 0 disables forced writeback.
|
|
930
|
+
:param pulumi.Input[_builtins.int] bgwriter_lru_maxpages: The maximum number of buffers that the background writer can write. Setting this to zero disables background writing. Default is 100.
|
|
931
|
+
:param pulumi.Input[_builtins.float] bgwriter_lru_multiplier: The average recent need for new buffers is multiplied by bgwriter_lru_multiplier to arrive at an estimate of the number that will be needed during the next round, (up to bgwriter_lru_maxpages). 1.0 represents a “just in time” policy of writing exactly the number of buffers predicted to be needed. Larger values provide some cushion against spikes in demand, while smaller values intentionally leave writes to be done by server processes. The default is 2.0.
|
|
932
|
+
:param pulumi.Input[_builtins.str] cluster_id: The ID of the target PostgreSQL cluster.
|
|
933
|
+
:param pulumi.Input[_builtins.int] deadlock_timeout: The amount of time, in milliseconds, to wait on a lock before checking to see if there is a deadlock condition.
|
|
934
|
+
:param pulumi.Input[_builtins.str] default_toast_compression: Specifies the default TOAST compression method for values of compressible columns (the default is lz4). Supported values are: `lz4`, `pglz`.
|
|
935
|
+
:param pulumi.Input[_builtins.int] idle_in_transaction_session_timeout: Time out sessions with open transactions after this number of milliseconds
|
|
936
|
+
:param pulumi.Input[_builtins.bool] jit: Activates, in a boolean, the system-wide use of Just-in-Time Compilation (JIT).
|
|
937
|
+
:param pulumi.Input[_builtins.int] log_autovacuum_min_duration: Causes each action executed by autovacuum to be logged if it ran for at least the specified number of milliseconds. Setting this to zero logs all autovacuum actions. Minus-one (the default) disables logging autovacuum actions.
|
|
938
|
+
:param pulumi.Input[_builtins.str] log_error_verbosity: Controls the amount of detail written in the server log for each message that is logged. Supported values are: `TERSE`, `DEFAULT`, `VERBOSE`.
|
|
939
|
+
:param pulumi.Input[_builtins.str] log_line_prefix: Selects one of the available log-formats. These can support popular log analyzers like pgbadger, pganalyze, etc. Supported values are: `pid=%p,user=%u,db=%d,app=%a,client=%h`, `%m [%p] %q[user=%u,db=%d,app=%a]`, `%t [%p]: [%l-1] user=%u,db=%d,app=%a,client=%h`.
|
|
940
|
+
:param pulumi.Input[_builtins.int] log_min_duration_statement: Log statements that take more than this number of milliseconds to run. If -1, disables.
|
|
941
|
+
:param pulumi.Input[_builtins.int] max_files_per_process: PostgreSQL maximum number of files that can be open per process.
|
|
942
|
+
:param pulumi.Input[_builtins.int] max_locks_per_transaction: PostgreSQL maximum locks per transaction. Once increased, this parameter cannot be lowered from its set value.
|
|
943
|
+
:param pulumi.Input[_builtins.int] max_logical_replication_workers: PostgreSQL maximum logical replication workers (taken from the pool of max_parallel_workers).
|
|
944
|
+
:param pulumi.Input[_builtins.int] max_parallel_workers: Sets the maximum number of workers that the system can support for parallel queries.
|
|
945
|
+
:param pulumi.Input[_builtins.int] max_parallel_workers_per_gather: Sets the maximum number of workers that can be started by a single Gather or Gather Merge node.
|
|
946
|
+
:param pulumi.Input[_builtins.int] max_pred_locks_per_transaction: PostgreSQL maximum predicate locks per transaction.
|
|
947
|
+
:param pulumi.Input[_builtins.int] max_prepared_transactions: PostgreSQL maximum prepared transactions. Once increased, this parameter cannot be lowered from its set value.
|
|
948
|
+
:param pulumi.Input[_builtins.int] max_replication_slots: PostgreSQL maximum replication slots.
|
|
949
|
+
:param pulumi.Input[_builtins.int] max_stack_depth: Maximum depth of the stack in bytes.
|
|
950
|
+
:param pulumi.Input[_builtins.int] max_standby_archive_delay: Max standby archive delay in milliseconds.
|
|
951
|
+
:param pulumi.Input[_builtins.int] max_standby_streaming_delay: Max standby streaming delay in milliseconds.
|
|
952
|
+
:param pulumi.Input[_builtins.int] max_wal_senders: PostgreSQL maximum WAL senders. Once increased, this parameter cannot be lowered from its set value.
|
|
953
|
+
:param pulumi.Input[_builtins.int] max_worker_processes: Sets the maximum number of background processes that the system can support. Once increased, this parameter cannot be lowered from its set value.
|
|
954
|
+
:param pulumi.Input[_builtins.int] pg_partman_bgw_interval: Sets the time interval to run pg_partman's scheduled tasks.
|
|
955
|
+
:param pulumi.Input[_builtins.str] pg_partman_bgw_role: Controls which role to use for pg_partman's scheduled background tasks. Must consist of alpha-numeric characters, dots, underscores, or dashes. May not start with dash or dot. Maximum of 64 characters.
|
|
956
|
+
:param pulumi.Input[_builtins.str] pg_stat_statements_track: Controls which statements are counted. Specify 'top' to track top-level statements (those issued directly by clients), 'all' to also track nested statements (such as statements invoked within functions), or 'none' to disable statement statistics collection. The default value is top. Supported values are: `all`, `top`, `none`.
|
|
958
957
|
:param pulumi.Input[Sequence[pulumi.Input['DatabasePostgresqlConfigPgbouncerArgs']]] pgbouncers: PGBouncer connection pooling settings
|
|
959
|
-
:param pulumi.Input[
|
|
960
|
-
:param pulumi.Input[
|
|
958
|
+
:param pulumi.Input[_builtins.float] shared_buffers_percentage: Percentage of total RAM that the database server uses for shared memory buffers. Valid range is 20-60 (float), which corresponds to 20% - 60%. This setting adjusts the shared_buffers configuration value.
|
|
959
|
+
:param pulumi.Input[_builtins.int] temp_file_limit: PostgreSQL temporary file limit in KiB. If -1, sets to unlimited.
|
|
961
960
|
:param pulumi.Input[Sequence[pulumi.Input['DatabasePostgresqlConfigTimescaledbArgs']]] timescaledbs: TimescaleDB extension configuration values
|
|
962
|
-
:param pulumi.Input[
|
|
963
|
-
:param pulumi.Input[
|
|
964
|
-
:param pulumi.Input[
|
|
965
|
-
:param pulumi.Input[
|
|
966
|
-
:param pulumi.Input[
|
|
967
|
-
:param pulumi.Input[
|
|
968
|
-
:param pulumi.Input[
|
|
969
|
-
:param pulumi.Input[
|
|
961
|
+
:param pulumi.Input[_builtins.str] timezone: PostgreSQL service timezone
|
|
962
|
+
:param pulumi.Input[_builtins.int] track_activity_query_size: Specifies the number of bytes reserved to track the currently executing command for each active session.
|
|
963
|
+
:param pulumi.Input[_builtins.str] track_commit_timestamp: Record commit time of transactions. The default value is top. Supported values are: `off`, `on`.
|
|
964
|
+
:param pulumi.Input[_builtins.str] track_functions: Enables tracking of function call counts and time used. The default value is top. Supported values are: `all`, `pl`, `none`.
|
|
965
|
+
:param pulumi.Input[_builtins.str] track_io_timing: Enables timing of database I/O calls. This parameter is off by default, because it will repeatedly query the operating system for the current time, which may cause significant overhead on some platforms. The default value is top. Supported values are: `off`, `on`.
|
|
966
|
+
:param pulumi.Input[_builtins.int] wal_sender_timeout: Terminate replication connections that are inactive for longer than this amount of time, in milliseconds. Setting this value to zero disables the timeout. Must be either 0 or between 5000 and 10800000.
|
|
967
|
+
:param pulumi.Input[_builtins.int] wal_writer_delay: WAL flush interval in milliseconds. Note that setting this value to lower than the default 200ms may negatively impact performance
|
|
968
|
+
:param pulumi.Input[_builtins.int] work_mem: The maximum amount of memory, in MB, used by a query operation (such as a sort or hash table) before writing to temporary disk files. Default is 1MB + 0.075% of total RAM (up to 32MB).
|
|
970
969
|
"""
|
|
971
970
|
if autovacuum_analyze_scale_factor is not None:
|
|
972
971
|
pulumi.set(__self__, "autovacuum_analyze_scale_factor", autovacuum_analyze_scale_factor)
|
|
@@ -1073,487 +1072,487 @@ class _DatabasePostgresqlConfigState:
|
|
|
1073
1072
|
if work_mem is not None:
|
|
1074
1073
|
pulumi.set(__self__, "work_mem", work_mem)
|
|
1075
1074
|
|
|
1076
|
-
@property
|
|
1075
|
+
@_builtins.property
|
|
1077
1076
|
@pulumi.getter(name="autovacuumAnalyzeScaleFactor")
|
|
1078
|
-
def autovacuum_analyze_scale_factor(self) -> Optional[pulumi.Input[
|
|
1077
|
+
def autovacuum_analyze_scale_factor(self) -> Optional[pulumi.Input[_builtins.float]]:
|
|
1079
1078
|
"""
|
|
1080
1079
|
Specifies a fraction, in a decimal value, of the table size to add to autovacuum_analyze_threshold when deciding whether to trigger an ANALYZE. The default is 0.2 (20% of table size).
|
|
1081
1080
|
"""
|
|
1082
1081
|
return pulumi.get(self, "autovacuum_analyze_scale_factor")
|
|
1083
1082
|
|
|
1084
1083
|
@autovacuum_analyze_scale_factor.setter
|
|
1085
|
-
def autovacuum_analyze_scale_factor(self, value: Optional[pulumi.Input[
|
|
1084
|
+
def autovacuum_analyze_scale_factor(self, value: Optional[pulumi.Input[_builtins.float]]):
|
|
1086
1085
|
pulumi.set(self, "autovacuum_analyze_scale_factor", value)
|
|
1087
1086
|
|
|
1088
|
-
@property
|
|
1087
|
+
@_builtins.property
|
|
1089
1088
|
@pulumi.getter(name="autovacuumAnalyzeThreshold")
|
|
1090
|
-
def autovacuum_analyze_threshold(self) -> Optional[pulumi.Input[
|
|
1089
|
+
def autovacuum_analyze_threshold(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
1091
1090
|
"""
|
|
1092
1091
|
Specifies the minimum number of inserted, updated, or deleted tuples needed to trigger an ANALYZE in any one table. The default is 50 tuples.
|
|
1093
1092
|
"""
|
|
1094
1093
|
return pulumi.get(self, "autovacuum_analyze_threshold")
|
|
1095
1094
|
|
|
1096
1095
|
@autovacuum_analyze_threshold.setter
|
|
1097
|
-
def autovacuum_analyze_threshold(self, value: Optional[pulumi.Input[
|
|
1096
|
+
def autovacuum_analyze_threshold(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
1098
1097
|
pulumi.set(self, "autovacuum_analyze_threshold", value)
|
|
1099
1098
|
|
|
1100
|
-
@property
|
|
1099
|
+
@_builtins.property
|
|
1101
1100
|
@pulumi.getter(name="autovacuumFreezeMaxAge")
|
|
1102
|
-
def autovacuum_freeze_max_age(self) -> Optional[pulumi.Input[
|
|
1101
|
+
def autovacuum_freeze_max_age(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
1103
1102
|
"""
|
|
1104
1103
|
Specifies the maximum age (in transactions) that a table's pg_class.relfrozenxid field can attain before a VACUUM operation is forced to prevent transaction ID wraparound within the table. Note that the system will launch autovacuum processes to prevent wraparound even when autovacuum is otherwise disabled. This parameter will cause the server to be restarted.
|
|
1105
1104
|
"""
|
|
1106
1105
|
return pulumi.get(self, "autovacuum_freeze_max_age")
|
|
1107
1106
|
|
|
1108
1107
|
@autovacuum_freeze_max_age.setter
|
|
1109
|
-
def autovacuum_freeze_max_age(self, value: Optional[pulumi.Input[
|
|
1108
|
+
def autovacuum_freeze_max_age(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
1110
1109
|
pulumi.set(self, "autovacuum_freeze_max_age", value)
|
|
1111
1110
|
|
|
1112
|
-
@property
|
|
1111
|
+
@_builtins.property
|
|
1113
1112
|
@pulumi.getter(name="autovacuumMaxWorkers")
|
|
1114
|
-
def autovacuum_max_workers(self) -> Optional[pulumi.Input[
|
|
1113
|
+
def autovacuum_max_workers(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
1115
1114
|
"""
|
|
1116
1115
|
Specifies the maximum number of autovacuum processes (other than the autovacuum launcher) that may be running at any one time. The default is three. This parameter can only be set at server start.
|
|
1117
1116
|
"""
|
|
1118
1117
|
return pulumi.get(self, "autovacuum_max_workers")
|
|
1119
1118
|
|
|
1120
1119
|
@autovacuum_max_workers.setter
|
|
1121
|
-
def autovacuum_max_workers(self, value: Optional[pulumi.Input[
|
|
1120
|
+
def autovacuum_max_workers(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
1122
1121
|
pulumi.set(self, "autovacuum_max_workers", value)
|
|
1123
1122
|
|
|
1124
|
-
@property
|
|
1123
|
+
@_builtins.property
|
|
1125
1124
|
@pulumi.getter(name="autovacuumNaptime")
|
|
1126
|
-
def autovacuum_naptime(self) -> Optional[pulumi.Input[
|
|
1125
|
+
def autovacuum_naptime(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
1127
1126
|
"""
|
|
1128
1127
|
Specifies the minimum delay, in seconds, between autovacuum runs on any given database. The default is one minute.
|
|
1129
1128
|
"""
|
|
1130
1129
|
return pulumi.get(self, "autovacuum_naptime")
|
|
1131
1130
|
|
|
1132
1131
|
@autovacuum_naptime.setter
|
|
1133
|
-
def autovacuum_naptime(self, value: Optional[pulumi.Input[
|
|
1132
|
+
def autovacuum_naptime(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
1134
1133
|
pulumi.set(self, "autovacuum_naptime", value)
|
|
1135
1134
|
|
|
1136
|
-
@property
|
|
1135
|
+
@_builtins.property
|
|
1137
1136
|
@pulumi.getter(name="autovacuumVacuumCostDelay")
|
|
1138
|
-
def autovacuum_vacuum_cost_delay(self) -> Optional[pulumi.Input[
|
|
1137
|
+
def autovacuum_vacuum_cost_delay(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
1139
1138
|
"""
|
|
1140
1139
|
Specifies the cost delay value, in milliseconds, that will be used in automatic VACUUM operations. If -1, uses the regular vacuum_cost_delay value, which is 20 milliseconds.
|
|
1141
1140
|
"""
|
|
1142
1141
|
return pulumi.get(self, "autovacuum_vacuum_cost_delay")
|
|
1143
1142
|
|
|
1144
1143
|
@autovacuum_vacuum_cost_delay.setter
|
|
1145
|
-
def autovacuum_vacuum_cost_delay(self, value: Optional[pulumi.Input[
|
|
1144
|
+
def autovacuum_vacuum_cost_delay(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
1146
1145
|
pulumi.set(self, "autovacuum_vacuum_cost_delay", value)
|
|
1147
1146
|
|
|
1148
|
-
@property
|
|
1147
|
+
@_builtins.property
|
|
1149
1148
|
@pulumi.getter(name="autovacuumVacuumCostLimit")
|
|
1150
|
-
def autovacuum_vacuum_cost_limit(self) -> Optional[pulumi.Input[
|
|
1149
|
+
def autovacuum_vacuum_cost_limit(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
1151
1150
|
"""
|
|
1152
1151
|
Specifies the cost limit value that will be used in automatic VACUUM operations. If -1 is specified (which is the default), the regular vacuum_cost_limit value will be used.
|
|
1153
1152
|
"""
|
|
1154
1153
|
return pulumi.get(self, "autovacuum_vacuum_cost_limit")
|
|
1155
1154
|
|
|
1156
1155
|
@autovacuum_vacuum_cost_limit.setter
|
|
1157
|
-
def autovacuum_vacuum_cost_limit(self, value: Optional[pulumi.Input[
|
|
1156
|
+
def autovacuum_vacuum_cost_limit(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
1158
1157
|
pulumi.set(self, "autovacuum_vacuum_cost_limit", value)
|
|
1159
1158
|
|
|
1160
|
-
@property
|
|
1159
|
+
@_builtins.property
|
|
1161
1160
|
@pulumi.getter(name="autovacuumVacuumScaleFactor")
|
|
1162
|
-
def autovacuum_vacuum_scale_factor(self) -> Optional[pulumi.Input[
|
|
1161
|
+
def autovacuum_vacuum_scale_factor(self) -> Optional[pulumi.Input[_builtins.float]]:
|
|
1163
1162
|
"""
|
|
1164
1163
|
Specifies a fraction, in a decimal value, of the table size to add to autovacuum_vacuum_threshold when deciding whether to trigger a VACUUM. The default is 0.2 (20% of table size).
|
|
1165
1164
|
"""
|
|
1166
1165
|
return pulumi.get(self, "autovacuum_vacuum_scale_factor")
|
|
1167
1166
|
|
|
1168
1167
|
@autovacuum_vacuum_scale_factor.setter
|
|
1169
|
-
def autovacuum_vacuum_scale_factor(self, value: Optional[pulumi.Input[
|
|
1168
|
+
def autovacuum_vacuum_scale_factor(self, value: Optional[pulumi.Input[_builtins.float]]):
|
|
1170
1169
|
pulumi.set(self, "autovacuum_vacuum_scale_factor", value)
|
|
1171
1170
|
|
|
1172
|
-
@property
|
|
1171
|
+
@_builtins.property
|
|
1173
1172
|
@pulumi.getter(name="autovacuumVacuumThreshold")
|
|
1174
|
-
def autovacuum_vacuum_threshold(self) -> Optional[pulumi.Input[
|
|
1173
|
+
def autovacuum_vacuum_threshold(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
1175
1174
|
"""
|
|
1176
1175
|
Specifies the minimum number of updated or deleted tuples needed to trigger a VACUUM in any one table. The default is 50 tuples.
|
|
1177
1176
|
"""
|
|
1178
1177
|
return pulumi.get(self, "autovacuum_vacuum_threshold")
|
|
1179
1178
|
|
|
1180
1179
|
@autovacuum_vacuum_threshold.setter
|
|
1181
|
-
def autovacuum_vacuum_threshold(self, value: Optional[pulumi.Input[
|
|
1180
|
+
def autovacuum_vacuum_threshold(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
1182
1181
|
pulumi.set(self, "autovacuum_vacuum_threshold", value)
|
|
1183
1182
|
|
|
1184
|
-
@property
|
|
1183
|
+
@_builtins.property
|
|
1185
1184
|
@pulumi.getter(name="backupHour")
|
|
1186
|
-
def backup_hour(self) -> Optional[pulumi.Input[
|
|
1185
|
+
def backup_hour(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
1187
1186
|
"""
|
|
1188
1187
|
The hour of day (in UTC) when backup for the service starts. New backup only starts if previous backup has already completed.
|
|
1189
1188
|
"""
|
|
1190
1189
|
return pulumi.get(self, "backup_hour")
|
|
1191
1190
|
|
|
1192
1191
|
@backup_hour.setter
|
|
1193
|
-
def backup_hour(self, value: Optional[pulumi.Input[
|
|
1192
|
+
def backup_hour(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
1194
1193
|
pulumi.set(self, "backup_hour", value)
|
|
1195
1194
|
|
|
1196
|
-
@property
|
|
1195
|
+
@_builtins.property
|
|
1197
1196
|
@pulumi.getter(name="backupMinute")
|
|
1198
|
-
def backup_minute(self) -> Optional[pulumi.Input[
|
|
1197
|
+
def backup_minute(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
1199
1198
|
"""
|
|
1200
1199
|
The minute of the backup hour when backup for the service starts. New backup is only started if previous backup has already completed.
|
|
1201
1200
|
"""
|
|
1202
1201
|
return pulumi.get(self, "backup_minute")
|
|
1203
1202
|
|
|
1204
1203
|
@backup_minute.setter
|
|
1205
|
-
def backup_minute(self, value: Optional[pulumi.Input[
|
|
1204
|
+
def backup_minute(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
1206
1205
|
pulumi.set(self, "backup_minute", value)
|
|
1207
1206
|
|
|
1208
|
-
@property
|
|
1207
|
+
@_builtins.property
|
|
1209
1208
|
@pulumi.getter(name="bgwriterDelay")
|
|
1210
|
-
def bgwriter_delay(self) -> Optional[pulumi.Input[
|
|
1209
|
+
def bgwriter_delay(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
1211
1210
|
"""
|
|
1212
1211
|
Specifies the delay, in milliseconds, between activity rounds for the background writer. Default is 200 ms.
|
|
1213
1212
|
"""
|
|
1214
1213
|
return pulumi.get(self, "bgwriter_delay")
|
|
1215
1214
|
|
|
1216
1215
|
@bgwriter_delay.setter
|
|
1217
|
-
def bgwriter_delay(self, value: Optional[pulumi.Input[
|
|
1216
|
+
def bgwriter_delay(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
1218
1217
|
pulumi.set(self, "bgwriter_delay", value)
|
|
1219
1218
|
|
|
1220
|
-
@property
|
|
1219
|
+
@_builtins.property
|
|
1221
1220
|
@pulumi.getter(name="bgwriterFlushAfter")
|
|
1222
|
-
def bgwriter_flush_after(self) -> Optional[pulumi.Input[
|
|
1221
|
+
def bgwriter_flush_after(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
1223
1222
|
"""
|
|
1224
1223
|
The amount of kilobytes that need to be written by the background writer before attempting to force the OS to issue these writes to underlying storage. Specified in kilobytes, default is 512. Setting of 0 disables forced writeback.
|
|
1225
1224
|
"""
|
|
1226
1225
|
return pulumi.get(self, "bgwriter_flush_after")
|
|
1227
1226
|
|
|
1228
1227
|
@bgwriter_flush_after.setter
|
|
1229
|
-
def bgwriter_flush_after(self, value: Optional[pulumi.Input[
|
|
1228
|
+
def bgwriter_flush_after(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
1230
1229
|
pulumi.set(self, "bgwriter_flush_after", value)
|
|
1231
1230
|
|
|
1232
|
-
@property
|
|
1231
|
+
@_builtins.property
|
|
1233
1232
|
@pulumi.getter(name="bgwriterLruMaxpages")
|
|
1234
|
-
def bgwriter_lru_maxpages(self) -> Optional[pulumi.Input[
|
|
1233
|
+
def bgwriter_lru_maxpages(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
1235
1234
|
"""
|
|
1236
1235
|
The maximum number of buffers that the background writer can write. Setting this to zero disables background writing. Default is 100.
|
|
1237
1236
|
"""
|
|
1238
1237
|
return pulumi.get(self, "bgwriter_lru_maxpages")
|
|
1239
1238
|
|
|
1240
1239
|
@bgwriter_lru_maxpages.setter
|
|
1241
|
-
def bgwriter_lru_maxpages(self, value: Optional[pulumi.Input[
|
|
1240
|
+
def bgwriter_lru_maxpages(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
1242
1241
|
pulumi.set(self, "bgwriter_lru_maxpages", value)
|
|
1243
1242
|
|
|
1244
|
-
@property
|
|
1243
|
+
@_builtins.property
|
|
1245
1244
|
@pulumi.getter(name="bgwriterLruMultiplier")
|
|
1246
|
-
def bgwriter_lru_multiplier(self) -> Optional[pulumi.Input[
|
|
1245
|
+
def bgwriter_lru_multiplier(self) -> Optional[pulumi.Input[_builtins.float]]:
|
|
1247
1246
|
"""
|
|
1248
1247
|
The average recent need for new buffers is multiplied by bgwriter_lru_multiplier to arrive at an estimate of the number that will be needed during the next round, (up to bgwriter_lru_maxpages). 1.0 represents a “just in time” policy of writing exactly the number of buffers predicted to be needed. Larger values provide some cushion against spikes in demand, while smaller values intentionally leave writes to be done by server processes. The default is 2.0.
|
|
1249
1248
|
"""
|
|
1250
1249
|
return pulumi.get(self, "bgwriter_lru_multiplier")
|
|
1251
1250
|
|
|
1252
1251
|
@bgwriter_lru_multiplier.setter
|
|
1253
|
-
def bgwriter_lru_multiplier(self, value: Optional[pulumi.Input[
|
|
1252
|
+
def bgwriter_lru_multiplier(self, value: Optional[pulumi.Input[_builtins.float]]):
|
|
1254
1253
|
pulumi.set(self, "bgwriter_lru_multiplier", value)
|
|
1255
1254
|
|
|
1256
|
-
@property
|
|
1255
|
+
@_builtins.property
|
|
1257
1256
|
@pulumi.getter(name="clusterId")
|
|
1258
|
-
def cluster_id(self) -> Optional[pulumi.Input[
|
|
1257
|
+
def cluster_id(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
1259
1258
|
"""
|
|
1260
1259
|
The ID of the target PostgreSQL cluster.
|
|
1261
1260
|
"""
|
|
1262
1261
|
return pulumi.get(self, "cluster_id")
|
|
1263
1262
|
|
|
1264
1263
|
@cluster_id.setter
|
|
1265
|
-
def cluster_id(self, value: Optional[pulumi.Input[
|
|
1264
|
+
def cluster_id(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
1266
1265
|
pulumi.set(self, "cluster_id", value)
|
|
1267
1266
|
|
|
1268
|
-
@property
|
|
1267
|
+
@_builtins.property
|
|
1269
1268
|
@pulumi.getter(name="deadlockTimeout")
|
|
1270
|
-
def deadlock_timeout(self) -> Optional[pulumi.Input[
|
|
1269
|
+
def deadlock_timeout(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
1271
1270
|
"""
|
|
1272
1271
|
The amount of time, in milliseconds, to wait on a lock before checking to see if there is a deadlock condition.
|
|
1273
1272
|
"""
|
|
1274
1273
|
return pulumi.get(self, "deadlock_timeout")
|
|
1275
1274
|
|
|
1276
1275
|
@deadlock_timeout.setter
|
|
1277
|
-
def deadlock_timeout(self, value: Optional[pulumi.Input[
|
|
1276
|
+
def deadlock_timeout(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
1278
1277
|
pulumi.set(self, "deadlock_timeout", value)
|
|
1279
1278
|
|
|
1280
|
-
@property
|
|
1279
|
+
@_builtins.property
|
|
1281
1280
|
@pulumi.getter(name="defaultToastCompression")
|
|
1282
|
-
def default_toast_compression(self) -> Optional[pulumi.Input[
|
|
1281
|
+
def default_toast_compression(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
1283
1282
|
"""
|
|
1284
1283
|
Specifies the default TOAST compression method for values of compressible columns (the default is lz4). Supported values are: `lz4`, `pglz`.
|
|
1285
1284
|
"""
|
|
1286
1285
|
return pulumi.get(self, "default_toast_compression")
|
|
1287
1286
|
|
|
1288
1287
|
@default_toast_compression.setter
|
|
1289
|
-
def default_toast_compression(self, value: Optional[pulumi.Input[
|
|
1288
|
+
def default_toast_compression(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
1290
1289
|
pulumi.set(self, "default_toast_compression", value)
|
|
1291
1290
|
|
|
1292
|
-
@property
|
|
1291
|
+
@_builtins.property
|
|
1293
1292
|
@pulumi.getter(name="idleInTransactionSessionTimeout")
|
|
1294
|
-
def idle_in_transaction_session_timeout(self) -> Optional[pulumi.Input[
|
|
1293
|
+
def idle_in_transaction_session_timeout(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
1295
1294
|
"""
|
|
1296
1295
|
Time out sessions with open transactions after this number of milliseconds
|
|
1297
1296
|
"""
|
|
1298
1297
|
return pulumi.get(self, "idle_in_transaction_session_timeout")
|
|
1299
1298
|
|
|
1300
1299
|
@idle_in_transaction_session_timeout.setter
|
|
1301
|
-
def idle_in_transaction_session_timeout(self, value: Optional[pulumi.Input[
|
|
1300
|
+
def idle_in_transaction_session_timeout(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
1302
1301
|
pulumi.set(self, "idle_in_transaction_session_timeout", value)
|
|
1303
1302
|
|
|
1304
|
-
@property
|
|
1303
|
+
@_builtins.property
|
|
1305
1304
|
@pulumi.getter
|
|
1306
|
-
def jit(self) -> Optional[pulumi.Input[
|
|
1305
|
+
def jit(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
1307
1306
|
"""
|
|
1308
1307
|
Activates, in a boolean, the system-wide use of Just-in-Time Compilation (JIT).
|
|
1309
1308
|
"""
|
|
1310
1309
|
return pulumi.get(self, "jit")
|
|
1311
1310
|
|
|
1312
1311
|
@jit.setter
|
|
1313
|
-
def jit(self, value: Optional[pulumi.Input[
|
|
1312
|
+
def jit(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
1314
1313
|
pulumi.set(self, "jit", value)
|
|
1315
1314
|
|
|
1316
|
-
@property
|
|
1315
|
+
@_builtins.property
|
|
1317
1316
|
@pulumi.getter(name="logAutovacuumMinDuration")
|
|
1318
|
-
def log_autovacuum_min_duration(self) -> Optional[pulumi.Input[
|
|
1317
|
+
def log_autovacuum_min_duration(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
1319
1318
|
"""
|
|
1320
1319
|
Causes each action executed by autovacuum to be logged if it ran for at least the specified number of milliseconds. Setting this to zero logs all autovacuum actions. Minus-one (the default) disables logging autovacuum actions.
|
|
1321
1320
|
"""
|
|
1322
1321
|
return pulumi.get(self, "log_autovacuum_min_duration")
|
|
1323
1322
|
|
|
1324
1323
|
@log_autovacuum_min_duration.setter
|
|
1325
|
-
def log_autovacuum_min_duration(self, value: Optional[pulumi.Input[
|
|
1324
|
+
def log_autovacuum_min_duration(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
1326
1325
|
pulumi.set(self, "log_autovacuum_min_duration", value)
|
|
1327
1326
|
|
|
1328
|
-
@property
|
|
1327
|
+
@_builtins.property
|
|
1329
1328
|
@pulumi.getter(name="logErrorVerbosity")
|
|
1330
|
-
def log_error_verbosity(self) -> Optional[pulumi.Input[
|
|
1329
|
+
def log_error_verbosity(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
1331
1330
|
"""
|
|
1332
1331
|
Controls the amount of detail written in the server log for each message that is logged. Supported values are: `TERSE`, `DEFAULT`, `VERBOSE`.
|
|
1333
1332
|
"""
|
|
1334
1333
|
return pulumi.get(self, "log_error_verbosity")
|
|
1335
1334
|
|
|
1336
1335
|
@log_error_verbosity.setter
|
|
1337
|
-
def log_error_verbosity(self, value: Optional[pulumi.Input[
|
|
1336
|
+
def log_error_verbosity(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
1338
1337
|
pulumi.set(self, "log_error_verbosity", value)
|
|
1339
1338
|
|
|
1340
|
-
@property
|
|
1339
|
+
@_builtins.property
|
|
1341
1340
|
@pulumi.getter(name="logLinePrefix")
|
|
1342
|
-
def log_line_prefix(self) -> Optional[pulumi.Input[
|
|
1341
|
+
def log_line_prefix(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
1343
1342
|
"""
|
|
1344
1343
|
Selects one of the available log-formats. These can support popular log analyzers like pgbadger, pganalyze, etc. Supported values are: `pid=%p,user=%u,db=%d,app=%a,client=%h`, `%m [%p] %q[user=%u,db=%d,app=%a]`, `%t [%p]: [%l-1] user=%u,db=%d,app=%a,client=%h`.
|
|
1345
1344
|
"""
|
|
1346
1345
|
return pulumi.get(self, "log_line_prefix")
|
|
1347
1346
|
|
|
1348
1347
|
@log_line_prefix.setter
|
|
1349
|
-
def log_line_prefix(self, value: Optional[pulumi.Input[
|
|
1348
|
+
def log_line_prefix(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
1350
1349
|
pulumi.set(self, "log_line_prefix", value)
|
|
1351
1350
|
|
|
1352
|
-
@property
|
|
1351
|
+
@_builtins.property
|
|
1353
1352
|
@pulumi.getter(name="logMinDurationStatement")
|
|
1354
|
-
def log_min_duration_statement(self) -> Optional[pulumi.Input[
|
|
1353
|
+
def log_min_duration_statement(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
1355
1354
|
"""
|
|
1356
1355
|
Log statements that take more than this number of milliseconds to run. If -1, disables.
|
|
1357
1356
|
"""
|
|
1358
1357
|
return pulumi.get(self, "log_min_duration_statement")
|
|
1359
1358
|
|
|
1360
1359
|
@log_min_duration_statement.setter
|
|
1361
|
-
def log_min_duration_statement(self, value: Optional[pulumi.Input[
|
|
1360
|
+
def log_min_duration_statement(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
1362
1361
|
pulumi.set(self, "log_min_duration_statement", value)
|
|
1363
1362
|
|
|
1364
|
-
@property
|
|
1363
|
+
@_builtins.property
|
|
1365
1364
|
@pulumi.getter(name="maxFilesPerProcess")
|
|
1366
|
-
def max_files_per_process(self) -> Optional[pulumi.Input[
|
|
1365
|
+
def max_files_per_process(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
1367
1366
|
"""
|
|
1368
1367
|
PostgreSQL maximum number of files that can be open per process.
|
|
1369
1368
|
"""
|
|
1370
1369
|
return pulumi.get(self, "max_files_per_process")
|
|
1371
1370
|
|
|
1372
1371
|
@max_files_per_process.setter
|
|
1373
|
-
def max_files_per_process(self, value: Optional[pulumi.Input[
|
|
1372
|
+
def max_files_per_process(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
1374
1373
|
pulumi.set(self, "max_files_per_process", value)
|
|
1375
1374
|
|
|
1376
|
-
@property
|
|
1375
|
+
@_builtins.property
|
|
1377
1376
|
@pulumi.getter(name="maxLocksPerTransaction")
|
|
1378
|
-
def max_locks_per_transaction(self) -> Optional[pulumi.Input[
|
|
1377
|
+
def max_locks_per_transaction(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
1379
1378
|
"""
|
|
1380
1379
|
PostgreSQL maximum locks per transaction. Once increased, this parameter cannot be lowered from its set value.
|
|
1381
1380
|
"""
|
|
1382
1381
|
return pulumi.get(self, "max_locks_per_transaction")
|
|
1383
1382
|
|
|
1384
1383
|
@max_locks_per_transaction.setter
|
|
1385
|
-
def max_locks_per_transaction(self, value: Optional[pulumi.Input[
|
|
1384
|
+
def max_locks_per_transaction(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
1386
1385
|
pulumi.set(self, "max_locks_per_transaction", value)
|
|
1387
1386
|
|
|
1388
|
-
@property
|
|
1387
|
+
@_builtins.property
|
|
1389
1388
|
@pulumi.getter(name="maxLogicalReplicationWorkers")
|
|
1390
|
-
def max_logical_replication_workers(self) -> Optional[pulumi.Input[
|
|
1389
|
+
def max_logical_replication_workers(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
1391
1390
|
"""
|
|
1392
1391
|
PostgreSQL maximum logical replication workers (taken from the pool of max_parallel_workers).
|
|
1393
1392
|
"""
|
|
1394
1393
|
return pulumi.get(self, "max_logical_replication_workers")
|
|
1395
1394
|
|
|
1396
1395
|
@max_logical_replication_workers.setter
|
|
1397
|
-
def max_logical_replication_workers(self, value: Optional[pulumi.Input[
|
|
1396
|
+
def max_logical_replication_workers(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
1398
1397
|
pulumi.set(self, "max_logical_replication_workers", value)
|
|
1399
1398
|
|
|
1400
|
-
@property
|
|
1399
|
+
@_builtins.property
|
|
1401
1400
|
@pulumi.getter(name="maxParallelWorkers")
|
|
1402
|
-
def max_parallel_workers(self) -> Optional[pulumi.Input[
|
|
1401
|
+
def max_parallel_workers(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
1403
1402
|
"""
|
|
1404
1403
|
Sets the maximum number of workers that the system can support for parallel queries.
|
|
1405
1404
|
"""
|
|
1406
1405
|
return pulumi.get(self, "max_parallel_workers")
|
|
1407
1406
|
|
|
1408
1407
|
@max_parallel_workers.setter
|
|
1409
|
-
def max_parallel_workers(self, value: Optional[pulumi.Input[
|
|
1408
|
+
def max_parallel_workers(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
1410
1409
|
pulumi.set(self, "max_parallel_workers", value)
|
|
1411
1410
|
|
|
1412
|
-
@property
|
|
1411
|
+
@_builtins.property
|
|
1413
1412
|
@pulumi.getter(name="maxParallelWorkersPerGather")
|
|
1414
|
-
def max_parallel_workers_per_gather(self) -> Optional[pulumi.Input[
|
|
1413
|
+
def max_parallel_workers_per_gather(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
1415
1414
|
"""
|
|
1416
1415
|
Sets the maximum number of workers that can be started by a single Gather or Gather Merge node.
|
|
1417
1416
|
"""
|
|
1418
1417
|
return pulumi.get(self, "max_parallel_workers_per_gather")
|
|
1419
1418
|
|
|
1420
1419
|
@max_parallel_workers_per_gather.setter
|
|
1421
|
-
def max_parallel_workers_per_gather(self, value: Optional[pulumi.Input[
|
|
1420
|
+
def max_parallel_workers_per_gather(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
1422
1421
|
pulumi.set(self, "max_parallel_workers_per_gather", value)
|
|
1423
1422
|
|
|
1424
|
-
@property
|
|
1423
|
+
@_builtins.property
|
|
1425
1424
|
@pulumi.getter(name="maxPredLocksPerTransaction")
|
|
1426
|
-
def max_pred_locks_per_transaction(self) -> Optional[pulumi.Input[
|
|
1425
|
+
def max_pred_locks_per_transaction(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
1427
1426
|
"""
|
|
1428
1427
|
PostgreSQL maximum predicate locks per transaction.
|
|
1429
1428
|
"""
|
|
1430
1429
|
return pulumi.get(self, "max_pred_locks_per_transaction")
|
|
1431
1430
|
|
|
1432
1431
|
@max_pred_locks_per_transaction.setter
|
|
1433
|
-
def max_pred_locks_per_transaction(self, value: Optional[pulumi.Input[
|
|
1432
|
+
def max_pred_locks_per_transaction(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
1434
1433
|
pulumi.set(self, "max_pred_locks_per_transaction", value)
|
|
1435
1434
|
|
|
1436
|
-
@property
|
|
1435
|
+
@_builtins.property
|
|
1437
1436
|
@pulumi.getter(name="maxPreparedTransactions")
|
|
1438
|
-
def max_prepared_transactions(self) -> Optional[pulumi.Input[
|
|
1437
|
+
def max_prepared_transactions(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
1439
1438
|
"""
|
|
1440
1439
|
PostgreSQL maximum prepared transactions. Once increased, this parameter cannot be lowered from its set value.
|
|
1441
1440
|
"""
|
|
1442
1441
|
return pulumi.get(self, "max_prepared_transactions")
|
|
1443
1442
|
|
|
1444
1443
|
@max_prepared_transactions.setter
|
|
1445
|
-
def max_prepared_transactions(self, value: Optional[pulumi.Input[
|
|
1444
|
+
def max_prepared_transactions(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
1446
1445
|
pulumi.set(self, "max_prepared_transactions", value)
|
|
1447
1446
|
|
|
1448
|
-
@property
|
|
1447
|
+
@_builtins.property
|
|
1449
1448
|
@pulumi.getter(name="maxReplicationSlots")
|
|
1450
|
-
def max_replication_slots(self) -> Optional[pulumi.Input[
|
|
1449
|
+
def max_replication_slots(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
1451
1450
|
"""
|
|
1452
1451
|
PostgreSQL maximum replication slots.
|
|
1453
1452
|
"""
|
|
1454
1453
|
return pulumi.get(self, "max_replication_slots")
|
|
1455
1454
|
|
|
1456
1455
|
@max_replication_slots.setter
|
|
1457
|
-
def max_replication_slots(self, value: Optional[pulumi.Input[
|
|
1456
|
+
def max_replication_slots(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
1458
1457
|
pulumi.set(self, "max_replication_slots", value)
|
|
1459
1458
|
|
|
1460
|
-
@property
|
|
1459
|
+
@_builtins.property
|
|
1461
1460
|
@pulumi.getter(name="maxStackDepth")
|
|
1462
|
-
def max_stack_depth(self) -> Optional[pulumi.Input[
|
|
1461
|
+
def max_stack_depth(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
1463
1462
|
"""
|
|
1464
1463
|
Maximum depth of the stack in bytes.
|
|
1465
1464
|
"""
|
|
1466
1465
|
return pulumi.get(self, "max_stack_depth")
|
|
1467
1466
|
|
|
1468
1467
|
@max_stack_depth.setter
|
|
1469
|
-
def max_stack_depth(self, value: Optional[pulumi.Input[
|
|
1468
|
+
def max_stack_depth(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
1470
1469
|
pulumi.set(self, "max_stack_depth", value)
|
|
1471
1470
|
|
|
1472
|
-
@property
|
|
1471
|
+
@_builtins.property
|
|
1473
1472
|
@pulumi.getter(name="maxStandbyArchiveDelay")
|
|
1474
|
-
def max_standby_archive_delay(self) -> Optional[pulumi.Input[
|
|
1473
|
+
def max_standby_archive_delay(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
1475
1474
|
"""
|
|
1476
1475
|
Max standby archive delay in milliseconds.
|
|
1477
1476
|
"""
|
|
1478
1477
|
return pulumi.get(self, "max_standby_archive_delay")
|
|
1479
1478
|
|
|
1480
1479
|
@max_standby_archive_delay.setter
|
|
1481
|
-
def max_standby_archive_delay(self, value: Optional[pulumi.Input[
|
|
1480
|
+
def max_standby_archive_delay(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
1482
1481
|
pulumi.set(self, "max_standby_archive_delay", value)
|
|
1483
1482
|
|
|
1484
|
-
@property
|
|
1483
|
+
@_builtins.property
|
|
1485
1484
|
@pulumi.getter(name="maxStandbyStreamingDelay")
|
|
1486
|
-
def max_standby_streaming_delay(self) -> Optional[pulumi.Input[
|
|
1485
|
+
def max_standby_streaming_delay(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
1487
1486
|
"""
|
|
1488
1487
|
Max standby streaming delay in milliseconds.
|
|
1489
1488
|
"""
|
|
1490
1489
|
return pulumi.get(self, "max_standby_streaming_delay")
|
|
1491
1490
|
|
|
1492
1491
|
@max_standby_streaming_delay.setter
|
|
1493
|
-
def max_standby_streaming_delay(self, value: Optional[pulumi.Input[
|
|
1492
|
+
def max_standby_streaming_delay(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
1494
1493
|
pulumi.set(self, "max_standby_streaming_delay", value)
|
|
1495
1494
|
|
|
1496
|
-
@property
|
|
1495
|
+
@_builtins.property
|
|
1497
1496
|
@pulumi.getter(name="maxWalSenders")
|
|
1498
|
-
def max_wal_senders(self) -> Optional[pulumi.Input[
|
|
1497
|
+
def max_wal_senders(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
1499
1498
|
"""
|
|
1500
1499
|
PostgreSQL maximum WAL senders. Once increased, this parameter cannot be lowered from its set value.
|
|
1501
1500
|
"""
|
|
1502
1501
|
return pulumi.get(self, "max_wal_senders")
|
|
1503
1502
|
|
|
1504
1503
|
@max_wal_senders.setter
|
|
1505
|
-
def max_wal_senders(self, value: Optional[pulumi.Input[
|
|
1504
|
+
def max_wal_senders(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
1506
1505
|
pulumi.set(self, "max_wal_senders", value)
|
|
1507
1506
|
|
|
1508
|
-
@property
|
|
1507
|
+
@_builtins.property
|
|
1509
1508
|
@pulumi.getter(name="maxWorkerProcesses")
|
|
1510
|
-
def max_worker_processes(self) -> Optional[pulumi.Input[
|
|
1509
|
+
def max_worker_processes(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
1511
1510
|
"""
|
|
1512
1511
|
Sets the maximum number of background processes that the system can support. Once increased, this parameter cannot be lowered from its set value.
|
|
1513
1512
|
"""
|
|
1514
1513
|
return pulumi.get(self, "max_worker_processes")
|
|
1515
1514
|
|
|
1516
1515
|
@max_worker_processes.setter
|
|
1517
|
-
def max_worker_processes(self, value: Optional[pulumi.Input[
|
|
1516
|
+
def max_worker_processes(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
1518
1517
|
pulumi.set(self, "max_worker_processes", value)
|
|
1519
1518
|
|
|
1520
|
-
@property
|
|
1519
|
+
@_builtins.property
|
|
1521
1520
|
@pulumi.getter(name="pgPartmanBgwInterval")
|
|
1522
|
-
def pg_partman_bgw_interval(self) -> Optional[pulumi.Input[
|
|
1521
|
+
def pg_partman_bgw_interval(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
1523
1522
|
"""
|
|
1524
1523
|
Sets the time interval to run pg_partman's scheduled tasks.
|
|
1525
1524
|
"""
|
|
1526
1525
|
return pulumi.get(self, "pg_partman_bgw_interval")
|
|
1527
1526
|
|
|
1528
1527
|
@pg_partman_bgw_interval.setter
|
|
1529
|
-
def pg_partman_bgw_interval(self, value: Optional[pulumi.Input[
|
|
1528
|
+
def pg_partman_bgw_interval(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
1530
1529
|
pulumi.set(self, "pg_partman_bgw_interval", value)
|
|
1531
1530
|
|
|
1532
|
-
@property
|
|
1531
|
+
@_builtins.property
|
|
1533
1532
|
@pulumi.getter(name="pgPartmanBgwRole")
|
|
1534
|
-
def pg_partman_bgw_role(self) -> Optional[pulumi.Input[
|
|
1533
|
+
def pg_partman_bgw_role(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
1535
1534
|
"""
|
|
1536
1535
|
Controls which role to use for pg_partman's scheduled background tasks. Must consist of alpha-numeric characters, dots, underscores, or dashes. May not start with dash or dot. Maximum of 64 characters.
|
|
1537
1536
|
"""
|
|
1538
1537
|
return pulumi.get(self, "pg_partman_bgw_role")
|
|
1539
1538
|
|
|
1540
1539
|
@pg_partman_bgw_role.setter
|
|
1541
|
-
def pg_partman_bgw_role(self, value: Optional[pulumi.Input[
|
|
1540
|
+
def pg_partman_bgw_role(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
1542
1541
|
pulumi.set(self, "pg_partman_bgw_role", value)
|
|
1543
1542
|
|
|
1544
|
-
@property
|
|
1543
|
+
@_builtins.property
|
|
1545
1544
|
@pulumi.getter(name="pgStatStatementsTrack")
|
|
1546
|
-
def pg_stat_statements_track(self) -> Optional[pulumi.Input[
|
|
1545
|
+
def pg_stat_statements_track(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
1547
1546
|
"""
|
|
1548
1547
|
Controls which statements are counted. Specify 'top' to track top-level statements (those issued directly by clients), 'all' to also track nested statements (such as statements invoked within functions), or 'none' to disable statement statistics collection. The default value is top. Supported values are: `all`, `top`, `none`.
|
|
1549
1548
|
"""
|
|
1550
1549
|
return pulumi.get(self, "pg_stat_statements_track")
|
|
1551
1550
|
|
|
1552
1551
|
@pg_stat_statements_track.setter
|
|
1553
|
-
def pg_stat_statements_track(self, value: Optional[pulumi.Input[
|
|
1552
|
+
def pg_stat_statements_track(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
1554
1553
|
pulumi.set(self, "pg_stat_statements_track", value)
|
|
1555
1554
|
|
|
1556
|
-
@property
|
|
1555
|
+
@_builtins.property
|
|
1557
1556
|
@pulumi.getter
|
|
1558
1557
|
def pgbouncers(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['DatabasePostgresqlConfigPgbouncerArgs']]]]:
|
|
1559
1558
|
"""
|
|
@@ -1565,31 +1564,31 @@ class _DatabasePostgresqlConfigState:
|
|
|
1565
1564
|
def pgbouncers(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['DatabasePostgresqlConfigPgbouncerArgs']]]]):
|
|
1566
1565
|
pulumi.set(self, "pgbouncers", value)
|
|
1567
1566
|
|
|
1568
|
-
@property
|
|
1567
|
+
@_builtins.property
|
|
1569
1568
|
@pulumi.getter(name="sharedBuffersPercentage")
|
|
1570
|
-
def shared_buffers_percentage(self) -> Optional[pulumi.Input[
|
|
1569
|
+
def shared_buffers_percentage(self) -> Optional[pulumi.Input[_builtins.float]]:
|
|
1571
1570
|
"""
|
|
1572
1571
|
Percentage of total RAM that the database server uses for shared memory buffers. Valid range is 20-60 (float), which corresponds to 20% - 60%. This setting adjusts the shared_buffers configuration value.
|
|
1573
1572
|
"""
|
|
1574
1573
|
return pulumi.get(self, "shared_buffers_percentage")
|
|
1575
1574
|
|
|
1576
1575
|
@shared_buffers_percentage.setter
|
|
1577
|
-
def shared_buffers_percentage(self, value: Optional[pulumi.Input[
|
|
1576
|
+
def shared_buffers_percentage(self, value: Optional[pulumi.Input[_builtins.float]]):
|
|
1578
1577
|
pulumi.set(self, "shared_buffers_percentage", value)
|
|
1579
1578
|
|
|
1580
|
-
@property
|
|
1579
|
+
@_builtins.property
|
|
1581
1580
|
@pulumi.getter(name="tempFileLimit")
|
|
1582
|
-
def temp_file_limit(self) -> Optional[pulumi.Input[
|
|
1581
|
+
def temp_file_limit(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
1583
1582
|
"""
|
|
1584
1583
|
PostgreSQL temporary file limit in KiB. If -1, sets to unlimited.
|
|
1585
1584
|
"""
|
|
1586
1585
|
return pulumi.get(self, "temp_file_limit")
|
|
1587
1586
|
|
|
1588
1587
|
@temp_file_limit.setter
|
|
1589
|
-
def temp_file_limit(self, value: Optional[pulumi.Input[
|
|
1588
|
+
def temp_file_limit(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
1590
1589
|
pulumi.set(self, "temp_file_limit", value)
|
|
1591
1590
|
|
|
1592
|
-
@property
|
|
1591
|
+
@_builtins.property
|
|
1593
1592
|
@pulumi.getter
|
|
1594
1593
|
def timescaledbs(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['DatabasePostgresqlConfigTimescaledbArgs']]]]:
|
|
1595
1594
|
"""
|
|
@@ -1601,100 +1600,100 @@ class _DatabasePostgresqlConfigState:
|
|
|
1601
1600
|
def timescaledbs(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['DatabasePostgresqlConfigTimescaledbArgs']]]]):
|
|
1602
1601
|
pulumi.set(self, "timescaledbs", value)
|
|
1603
1602
|
|
|
1604
|
-
@property
|
|
1603
|
+
@_builtins.property
|
|
1605
1604
|
@pulumi.getter
|
|
1606
|
-
def timezone(self) -> Optional[pulumi.Input[
|
|
1605
|
+
def timezone(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
1607
1606
|
"""
|
|
1608
1607
|
PostgreSQL service timezone
|
|
1609
1608
|
"""
|
|
1610
1609
|
return pulumi.get(self, "timezone")
|
|
1611
1610
|
|
|
1612
1611
|
@timezone.setter
|
|
1613
|
-
def timezone(self, value: Optional[pulumi.Input[
|
|
1612
|
+
def timezone(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
1614
1613
|
pulumi.set(self, "timezone", value)
|
|
1615
1614
|
|
|
1616
|
-
@property
|
|
1615
|
+
@_builtins.property
|
|
1617
1616
|
@pulumi.getter(name="trackActivityQuerySize")
|
|
1618
|
-
def track_activity_query_size(self) -> Optional[pulumi.Input[
|
|
1617
|
+
def track_activity_query_size(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
1619
1618
|
"""
|
|
1620
1619
|
Specifies the number of bytes reserved to track the currently executing command for each active session.
|
|
1621
1620
|
"""
|
|
1622
1621
|
return pulumi.get(self, "track_activity_query_size")
|
|
1623
1622
|
|
|
1624
1623
|
@track_activity_query_size.setter
|
|
1625
|
-
def track_activity_query_size(self, value: Optional[pulumi.Input[
|
|
1624
|
+
def track_activity_query_size(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
1626
1625
|
pulumi.set(self, "track_activity_query_size", value)
|
|
1627
1626
|
|
|
1628
|
-
@property
|
|
1627
|
+
@_builtins.property
|
|
1629
1628
|
@pulumi.getter(name="trackCommitTimestamp")
|
|
1630
|
-
def track_commit_timestamp(self) -> Optional[pulumi.Input[
|
|
1629
|
+
def track_commit_timestamp(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
1631
1630
|
"""
|
|
1632
1631
|
Record commit time of transactions. The default value is top. Supported values are: `off`, `on`.
|
|
1633
1632
|
"""
|
|
1634
1633
|
return pulumi.get(self, "track_commit_timestamp")
|
|
1635
1634
|
|
|
1636
1635
|
@track_commit_timestamp.setter
|
|
1637
|
-
def track_commit_timestamp(self, value: Optional[pulumi.Input[
|
|
1636
|
+
def track_commit_timestamp(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
1638
1637
|
pulumi.set(self, "track_commit_timestamp", value)
|
|
1639
1638
|
|
|
1640
|
-
@property
|
|
1639
|
+
@_builtins.property
|
|
1641
1640
|
@pulumi.getter(name="trackFunctions")
|
|
1642
|
-
def track_functions(self) -> Optional[pulumi.Input[
|
|
1641
|
+
def track_functions(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
1643
1642
|
"""
|
|
1644
1643
|
Enables tracking of function call counts and time used. The default value is top. Supported values are: `all`, `pl`, `none`.
|
|
1645
1644
|
"""
|
|
1646
1645
|
return pulumi.get(self, "track_functions")
|
|
1647
1646
|
|
|
1648
1647
|
@track_functions.setter
|
|
1649
|
-
def track_functions(self, value: Optional[pulumi.Input[
|
|
1648
|
+
def track_functions(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
1650
1649
|
pulumi.set(self, "track_functions", value)
|
|
1651
1650
|
|
|
1652
|
-
@property
|
|
1651
|
+
@_builtins.property
|
|
1653
1652
|
@pulumi.getter(name="trackIoTiming")
|
|
1654
|
-
def track_io_timing(self) -> Optional[pulumi.Input[
|
|
1653
|
+
def track_io_timing(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
1655
1654
|
"""
|
|
1656
1655
|
Enables timing of database I/O calls. This parameter is off by default, because it will repeatedly query the operating system for the current time, which may cause significant overhead on some platforms. The default value is top. Supported values are: `off`, `on`.
|
|
1657
1656
|
"""
|
|
1658
1657
|
return pulumi.get(self, "track_io_timing")
|
|
1659
1658
|
|
|
1660
1659
|
@track_io_timing.setter
|
|
1661
|
-
def track_io_timing(self, value: Optional[pulumi.Input[
|
|
1660
|
+
def track_io_timing(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
1662
1661
|
pulumi.set(self, "track_io_timing", value)
|
|
1663
1662
|
|
|
1664
|
-
@property
|
|
1663
|
+
@_builtins.property
|
|
1665
1664
|
@pulumi.getter(name="walSenderTimeout")
|
|
1666
|
-
def wal_sender_timeout(self) -> Optional[pulumi.Input[
|
|
1665
|
+
def wal_sender_timeout(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
1667
1666
|
"""
|
|
1668
1667
|
Terminate replication connections that are inactive for longer than this amount of time, in milliseconds. Setting this value to zero disables the timeout. Must be either 0 or between 5000 and 10800000.
|
|
1669
1668
|
"""
|
|
1670
1669
|
return pulumi.get(self, "wal_sender_timeout")
|
|
1671
1670
|
|
|
1672
1671
|
@wal_sender_timeout.setter
|
|
1673
|
-
def wal_sender_timeout(self, value: Optional[pulumi.Input[
|
|
1672
|
+
def wal_sender_timeout(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
1674
1673
|
pulumi.set(self, "wal_sender_timeout", value)
|
|
1675
1674
|
|
|
1676
|
-
@property
|
|
1675
|
+
@_builtins.property
|
|
1677
1676
|
@pulumi.getter(name="walWriterDelay")
|
|
1678
|
-
def wal_writer_delay(self) -> Optional[pulumi.Input[
|
|
1677
|
+
def wal_writer_delay(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
1679
1678
|
"""
|
|
1680
1679
|
WAL flush interval in milliseconds. Note that setting this value to lower than the default 200ms may negatively impact performance
|
|
1681
1680
|
"""
|
|
1682
1681
|
return pulumi.get(self, "wal_writer_delay")
|
|
1683
1682
|
|
|
1684
1683
|
@wal_writer_delay.setter
|
|
1685
|
-
def wal_writer_delay(self, value: Optional[pulumi.Input[
|
|
1684
|
+
def wal_writer_delay(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
1686
1685
|
pulumi.set(self, "wal_writer_delay", value)
|
|
1687
1686
|
|
|
1688
|
-
@property
|
|
1687
|
+
@_builtins.property
|
|
1689
1688
|
@pulumi.getter(name="workMem")
|
|
1690
|
-
def work_mem(self) -> Optional[pulumi.Input[
|
|
1689
|
+
def work_mem(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
1691
1690
|
"""
|
|
1692
1691
|
The maximum amount of memory, in MB, used by a query operation (such as a sort or hash table) before writing to temporary disk files. Default is 1MB + 0.075% of total RAM (up to 32MB).
|
|
1693
1692
|
"""
|
|
1694
1693
|
return pulumi.get(self, "work_mem")
|
|
1695
1694
|
|
|
1696
1695
|
@work_mem.setter
|
|
1697
|
-
def work_mem(self, value: Optional[pulumi.Input[
|
|
1696
|
+
def work_mem(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
1698
1697
|
pulumi.set(self, "work_mem", value)
|
|
1699
1698
|
|
|
1700
1699
|
|
|
@@ -1704,58 +1703,58 @@ class DatabasePostgresqlConfig(pulumi.CustomResource):
|
|
|
1704
1703
|
def __init__(__self__,
|
|
1705
1704
|
resource_name: str,
|
|
1706
1705
|
opts: Optional[pulumi.ResourceOptions] = None,
|
|
1707
|
-
autovacuum_analyze_scale_factor: Optional[pulumi.Input[
|
|
1708
|
-
autovacuum_analyze_threshold: Optional[pulumi.Input[
|
|
1709
|
-
autovacuum_freeze_max_age: Optional[pulumi.Input[
|
|
1710
|
-
autovacuum_max_workers: Optional[pulumi.Input[
|
|
1711
|
-
autovacuum_naptime: Optional[pulumi.Input[
|
|
1712
|
-
autovacuum_vacuum_cost_delay: Optional[pulumi.Input[
|
|
1713
|
-
autovacuum_vacuum_cost_limit: Optional[pulumi.Input[
|
|
1714
|
-
autovacuum_vacuum_scale_factor: Optional[pulumi.Input[
|
|
1715
|
-
autovacuum_vacuum_threshold: Optional[pulumi.Input[
|
|
1716
|
-
backup_hour: Optional[pulumi.Input[
|
|
1717
|
-
backup_minute: Optional[pulumi.Input[
|
|
1718
|
-
bgwriter_delay: Optional[pulumi.Input[
|
|
1719
|
-
bgwriter_flush_after: Optional[pulumi.Input[
|
|
1720
|
-
bgwriter_lru_maxpages: Optional[pulumi.Input[
|
|
1721
|
-
bgwriter_lru_multiplier: Optional[pulumi.Input[
|
|
1722
|
-
cluster_id: Optional[pulumi.Input[
|
|
1723
|
-
deadlock_timeout: Optional[pulumi.Input[
|
|
1724
|
-
default_toast_compression: Optional[pulumi.Input[
|
|
1725
|
-
idle_in_transaction_session_timeout: Optional[pulumi.Input[
|
|
1726
|
-
jit: Optional[pulumi.Input[
|
|
1727
|
-
log_autovacuum_min_duration: Optional[pulumi.Input[
|
|
1728
|
-
log_error_verbosity: Optional[pulumi.Input[
|
|
1729
|
-
log_line_prefix: Optional[pulumi.Input[
|
|
1730
|
-
log_min_duration_statement: Optional[pulumi.Input[
|
|
1731
|
-
max_files_per_process: Optional[pulumi.Input[
|
|
1732
|
-
max_locks_per_transaction: Optional[pulumi.Input[
|
|
1733
|
-
max_logical_replication_workers: Optional[pulumi.Input[
|
|
1734
|
-
max_parallel_workers: Optional[pulumi.Input[
|
|
1735
|
-
max_parallel_workers_per_gather: Optional[pulumi.Input[
|
|
1736
|
-
max_pred_locks_per_transaction: Optional[pulumi.Input[
|
|
1737
|
-
max_prepared_transactions: Optional[pulumi.Input[
|
|
1738
|
-
max_replication_slots: Optional[pulumi.Input[
|
|
1739
|
-
max_stack_depth: Optional[pulumi.Input[
|
|
1740
|
-
max_standby_archive_delay: Optional[pulumi.Input[
|
|
1741
|
-
max_standby_streaming_delay: Optional[pulumi.Input[
|
|
1742
|
-
max_wal_senders: Optional[pulumi.Input[
|
|
1743
|
-
max_worker_processes: Optional[pulumi.Input[
|
|
1744
|
-
pg_partman_bgw_interval: Optional[pulumi.Input[
|
|
1745
|
-
pg_partman_bgw_role: Optional[pulumi.Input[
|
|
1746
|
-
pg_stat_statements_track: Optional[pulumi.Input[
|
|
1706
|
+
autovacuum_analyze_scale_factor: Optional[pulumi.Input[_builtins.float]] = None,
|
|
1707
|
+
autovacuum_analyze_threshold: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1708
|
+
autovacuum_freeze_max_age: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1709
|
+
autovacuum_max_workers: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1710
|
+
autovacuum_naptime: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1711
|
+
autovacuum_vacuum_cost_delay: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1712
|
+
autovacuum_vacuum_cost_limit: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1713
|
+
autovacuum_vacuum_scale_factor: Optional[pulumi.Input[_builtins.float]] = None,
|
|
1714
|
+
autovacuum_vacuum_threshold: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1715
|
+
backup_hour: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1716
|
+
backup_minute: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1717
|
+
bgwriter_delay: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1718
|
+
bgwriter_flush_after: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1719
|
+
bgwriter_lru_maxpages: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1720
|
+
bgwriter_lru_multiplier: Optional[pulumi.Input[_builtins.float]] = None,
|
|
1721
|
+
cluster_id: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1722
|
+
deadlock_timeout: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1723
|
+
default_toast_compression: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1724
|
+
idle_in_transaction_session_timeout: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1725
|
+
jit: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1726
|
+
log_autovacuum_min_duration: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1727
|
+
log_error_verbosity: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1728
|
+
log_line_prefix: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1729
|
+
log_min_duration_statement: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1730
|
+
max_files_per_process: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1731
|
+
max_locks_per_transaction: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1732
|
+
max_logical_replication_workers: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1733
|
+
max_parallel_workers: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1734
|
+
max_parallel_workers_per_gather: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1735
|
+
max_pred_locks_per_transaction: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1736
|
+
max_prepared_transactions: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1737
|
+
max_replication_slots: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1738
|
+
max_stack_depth: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1739
|
+
max_standby_archive_delay: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1740
|
+
max_standby_streaming_delay: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1741
|
+
max_wal_senders: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1742
|
+
max_worker_processes: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1743
|
+
pg_partman_bgw_interval: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1744
|
+
pg_partman_bgw_role: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1745
|
+
pg_stat_statements_track: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1747
1746
|
pgbouncers: Optional[pulumi.Input[Sequence[pulumi.Input[Union['DatabasePostgresqlConfigPgbouncerArgs', 'DatabasePostgresqlConfigPgbouncerArgsDict']]]]] = None,
|
|
1748
|
-
shared_buffers_percentage: Optional[pulumi.Input[
|
|
1749
|
-
temp_file_limit: Optional[pulumi.Input[
|
|
1747
|
+
shared_buffers_percentage: Optional[pulumi.Input[_builtins.float]] = None,
|
|
1748
|
+
temp_file_limit: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1750
1749
|
timescaledbs: Optional[pulumi.Input[Sequence[pulumi.Input[Union['DatabasePostgresqlConfigTimescaledbArgs', 'DatabasePostgresqlConfigTimescaledbArgsDict']]]]] = None,
|
|
1751
|
-
timezone: Optional[pulumi.Input[
|
|
1752
|
-
track_activity_query_size: Optional[pulumi.Input[
|
|
1753
|
-
track_commit_timestamp: Optional[pulumi.Input[
|
|
1754
|
-
track_functions: Optional[pulumi.Input[
|
|
1755
|
-
track_io_timing: Optional[pulumi.Input[
|
|
1756
|
-
wal_sender_timeout: Optional[pulumi.Input[
|
|
1757
|
-
wal_writer_delay: Optional[pulumi.Input[
|
|
1758
|
-
work_mem: Optional[pulumi.Input[
|
|
1750
|
+
timezone: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1751
|
+
track_activity_query_size: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1752
|
+
track_commit_timestamp: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1753
|
+
track_functions: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1754
|
+
track_io_timing: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1755
|
+
wal_sender_timeout: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1756
|
+
wal_writer_delay: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1757
|
+
work_mem: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1759
1758
|
__props__=None):
|
|
1760
1759
|
"""
|
|
1761
1760
|
Provides a virtual resource that can be used to change advanced configuration
|
|
@@ -1794,58 +1793,58 @@ class DatabasePostgresqlConfig(pulumi.CustomResource):
|
|
|
1794
1793
|
|
|
1795
1794
|
:param str resource_name: The name of the resource.
|
|
1796
1795
|
:param pulumi.ResourceOptions opts: Options for the resource.
|
|
1797
|
-
:param pulumi.Input[
|
|
1798
|
-
:param pulumi.Input[
|
|
1799
|
-
:param pulumi.Input[
|
|
1800
|
-
:param pulumi.Input[
|
|
1801
|
-
:param pulumi.Input[
|
|
1802
|
-
:param pulumi.Input[
|
|
1803
|
-
:param pulumi.Input[
|
|
1804
|
-
:param pulumi.Input[
|
|
1805
|
-
:param pulumi.Input[
|
|
1806
|
-
:param pulumi.Input[
|
|
1807
|
-
:param pulumi.Input[
|
|
1808
|
-
:param pulumi.Input[
|
|
1809
|
-
:param pulumi.Input[
|
|
1810
|
-
:param pulumi.Input[
|
|
1811
|
-
:param pulumi.Input[
|
|
1812
|
-
:param pulumi.Input[
|
|
1813
|
-
:param pulumi.Input[
|
|
1814
|
-
:param pulumi.Input[
|
|
1815
|
-
:param pulumi.Input[
|
|
1816
|
-
:param pulumi.Input[
|
|
1817
|
-
:param pulumi.Input[
|
|
1818
|
-
:param pulumi.Input[
|
|
1819
|
-
:param pulumi.Input[
|
|
1820
|
-
:param pulumi.Input[
|
|
1821
|
-
:param pulumi.Input[
|
|
1822
|
-
:param pulumi.Input[
|
|
1823
|
-
:param pulumi.Input[
|
|
1824
|
-
:param pulumi.Input[
|
|
1825
|
-
:param pulumi.Input[
|
|
1826
|
-
:param pulumi.Input[
|
|
1827
|
-
:param pulumi.Input[
|
|
1828
|
-
:param pulumi.Input[
|
|
1829
|
-
:param pulumi.Input[
|
|
1830
|
-
:param pulumi.Input[
|
|
1831
|
-
:param pulumi.Input[
|
|
1832
|
-
:param pulumi.Input[
|
|
1833
|
-
:param pulumi.Input[
|
|
1834
|
-
:param pulumi.Input[
|
|
1835
|
-
:param pulumi.Input[
|
|
1836
|
-
:param pulumi.Input[
|
|
1796
|
+
:param pulumi.Input[_builtins.float] autovacuum_analyze_scale_factor: Specifies a fraction, in a decimal value, of the table size to add to autovacuum_analyze_threshold when deciding whether to trigger an ANALYZE. The default is 0.2 (20% of table size).
|
|
1797
|
+
:param pulumi.Input[_builtins.int] autovacuum_analyze_threshold: Specifies the minimum number of inserted, updated, or deleted tuples needed to trigger an ANALYZE in any one table. The default is 50 tuples.
|
|
1798
|
+
:param pulumi.Input[_builtins.int] autovacuum_freeze_max_age: Specifies the maximum age (in transactions) that a table's pg_class.relfrozenxid field can attain before a VACUUM operation is forced to prevent transaction ID wraparound within the table. Note that the system will launch autovacuum processes to prevent wraparound even when autovacuum is otherwise disabled. This parameter will cause the server to be restarted.
|
|
1799
|
+
:param pulumi.Input[_builtins.int] autovacuum_max_workers: Specifies the maximum number of autovacuum processes (other than the autovacuum launcher) that may be running at any one time. The default is three. This parameter can only be set at server start.
|
|
1800
|
+
:param pulumi.Input[_builtins.int] autovacuum_naptime: Specifies the minimum delay, in seconds, between autovacuum runs on any given database. The default is one minute.
|
|
1801
|
+
:param pulumi.Input[_builtins.int] autovacuum_vacuum_cost_delay: Specifies the cost delay value, in milliseconds, that will be used in automatic VACUUM operations. If -1, uses the regular vacuum_cost_delay value, which is 20 milliseconds.
|
|
1802
|
+
:param pulumi.Input[_builtins.int] autovacuum_vacuum_cost_limit: Specifies the cost limit value that will be used in automatic VACUUM operations. If -1 is specified (which is the default), the regular vacuum_cost_limit value will be used.
|
|
1803
|
+
:param pulumi.Input[_builtins.float] autovacuum_vacuum_scale_factor: Specifies a fraction, in a decimal value, of the table size to add to autovacuum_vacuum_threshold when deciding whether to trigger a VACUUM. The default is 0.2 (20% of table size).
|
|
1804
|
+
:param pulumi.Input[_builtins.int] autovacuum_vacuum_threshold: Specifies the minimum number of updated or deleted tuples needed to trigger a VACUUM in any one table. The default is 50 tuples.
|
|
1805
|
+
:param pulumi.Input[_builtins.int] backup_hour: The hour of day (in UTC) when backup for the service starts. New backup only starts if previous backup has already completed.
|
|
1806
|
+
:param pulumi.Input[_builtins.int] backup_minute: The minute of the backup hour when backup for the service starts. New backup is only started if previous backup has already completed.
|
|
1807
|
+
:param pulumi.Input[_builtins.int] bgwriter_delay: Specifies the delay, in milliseconds, between activity rounds for the background writer. Default is 200 ms.
|
|
1808
|
+
:param pulumi.Input[_builtins.int] bgwriter_flush_after: The amount of kilobytes that need to be written by the background writer before attempting to force the OS to issue these writes to underlying storage. Specified in kilobytes, default is 512. Setting of 0 disables forced writeback.
|
|
1809
|
+
:param pulumi.Input[_builtins.int] bgwriter_lru_maxpages: The maximum number of buffers that the background writer can write. Setting this to zero disables background writing. Default is 100.
|
|
1810
|
+
:param pulumi.Input[_builtins.float] bgwriter_lru_multiplier: The average recent need for new buffers is multiplied by bgwriter_lru_multiplier to arrive at an estimate of the number that will be needed during the next round, (up to bgwriter_lru_maxpages). 1.0 represents a “just in time” policy of writing exactly the number of buffers predicted to be needed. Larger values provide some cushion against spikes in demand, while smaller values intentionally leave writes to be done by server processes. The default is 2.0.
|
|
1811
|
+
:param pulumi.Input[_builtins.str] cluster_id: The ID of the target PostgreSQL cluster.
|
|
1812
|
+
:param pulumi.Input[_builtins.int] deadlock_timeout: The amount of time, in milliseconds, to wait on a lock before checking to see if there is a deadlock condition.
|
|
1813
|
+
:param pulumi.Input[_builtins.str] default_toast_compression: Specifies the default TOAST compression method for values of compressible columns (the default is lz4). Supported values are: `lz4`, `pglz`.
|
|
1814
|
+
:param pulumi.Input[_builtins.int] idle_in_transaction_session_timeout: Time out sessions with open transactions after this number of milliseconds
|
|
1815
|
+
:param pulumi.Input[_builtins.bool] jit: Activates, in a boolean, the system-wide use of Just-in-Time Compilation (JIT).
|
|
1816
|
+
:param pulumi.Input[_builtins.int] log_autovacuum_min_duration: Causes each action executed by autovacuum to be logged if it ran for at least the specified number of milliseconds. Setting this to zero logs all autovacuum actions. Minus-one (the default) disables logging autovacuum actions.
|
|
1817
|
+
:param pulumi.Input[_builtins.str] log_error_verbosity: Controls the amount of detail written in the server log for each message that is logged. Supported values are: `TERSE`, `DEFAULT`, `VERBOSE`.
|
|
1818
|
+
:param pulumi.Input[_builtins.str] log_line_prefix: Selects one of the available log-formats. These can support popular log analyzers like pgbadger, pganalyze, etc. Supported values are: `pid=%p,user=%u,db=%d,app=%a,client=%h`, `%m [%p] %q[user=%u,db=%d,app=%a]`, `%t [%p]: [%l-1] user=%u,db=%d,app=%a,client=%h`.
|
|
1819
|
+
:param pulumi.Input[_builtins.int] log_min_duration_statement: Log statements that take more than this number of milliseconds to run. If -1, disables.
|
|
1820
|
+
:param pulumi.Input[_builtins.int] max_files_per_process: PostgreSQL maximum number of files that can be open per process.
|
|
1821
|
+
:param pulumi.Input[_builtins.int] max_locks_per_transaction: PostgreSQL maximum locks per transaction. Once increased, this parameter cannot be lowered from its set value.
|
|
1822
|
+
:param pulumi.Input[_builtins.int] max_logical_replication_workers: PostgreSQL maximum logical replication workers (taken from the pool of max_parallel_workers).
|
|
1823
|
+
:param pulumi.Input[_builtins.int] max_parallel_workers: Sets the maximum number of workers that the system can support for parallel queries.
|
|
1824
|
+
:param pulumi.Input[_builtins.int] max_parallel_workers_per_gather: Sets the maximum number of workers that can be started by a single Gather or Gather Merge node.
|
|
1825
|
+
:param pulumi.Input[_builtins.int] max_pred_locks_per_transaction: PostgreSQL maximum predicate locks per transaction.
|
|
1826
|
+
:param pulumi.Input[_builtins.int] max_prepared_transactions: PostgreSQL maximum prepared transactions. Once increased, this parameter cannot be lowered from its set value.
|
|
1827
|
+
:param pulumi.Input[_builtins.int] max_replication_slots: PostgreSQL maximum replication slots.
|
|
1828
|
+
:param pulumi.Input[_builtins.int] max_stack_depth: Maximum depth of the stack in bytes.
|
|
1829
|
+
:param pulumi.Input[_builtins.int] max_standby_archive_delay: Max standby archive delay in milliseconds.
|
|
1830
|
+
:param pulumi.Input[_builtins.int] max_standby_streaming_delay: Max standby streaming delay in milliseconds.
|
|
1831
|
+
:param pulumi.Input[_builtins.int] max_wal_senders: PostgreSQL maximum WAL senders. Once increased, this parameter cannot be lowered from its set value.
|
|
1832
|
+
:param pulumi.Input[_builtins.int] max_worker_processes: Sets the maximum number of background processes that the system can support. Once increased, this parameter cannot be lowered from its set value.
|
|
1833
|
+
:param pulumi.Input[_builtins.int] pg_partman_bgw_interval: Sets the time interval to run pg_partman's scheduled tasks.
|
|
1834
|
+
:param pulumi.Input[_builtins.str] pg_partman_bgw_role: Controls which role to use for pg_partman's scheduled background tasks. Must consist of alpha-numeric characters, dots, underscores, or dashes. May not start with dash or dot. Maximum of 64 characters.
|
|
1835
|
+
:param pulumi.Input[_builtins.str] pg_stat_statements_track: Controls which statements are counted. Specify 'top' to track top-level statements (those issued directly by clients), 'all' to also track nested statements (such as statements invoked within functions), or 'none' to disable statement statistics collection. The default value is top. Supported values are: `all`, `top`, `none`.
|
|
1837
1836
|
:param pulumi.Input[Sequence[pulumi.Input[Union['DatabasePostgresqlConfigPgbouncerArgs', 'DatabasePostgresqlConfigPgbouncerArgsDict']]]] pgbouncers: PGBouncer connection pooling settings
|
|
1838
|
-
:param pulumi.Input[
|
|
1839
|
-
:param pulumi.Input[
|
|
1837
|
+
:param pulumi.Input[_builtins.float] shared_buffers_percentage: Percentage of total RAM that the database server uses for shared memory buffers. Valid range is 20-60 (float), which corresponds to 20% - 60%. This setting adjusts the shared_buffers configuration value.
|
|
1838
|
+
:param pulumi.Input[_builtins.int] temp_file_limit: PostgreSQL temporary file limit in KiB. If -1, sets to unlimited.
|
|
1840
1839
|
:param pulumi.Input[Sequence[pulumi.Input[Union['DatabasePostgresqlConfigTimescaledbArgs', 'DatabasePostgresqlConfigTimescaledbArgsDict']]]] timescaledbs: TimescaleDB extension configuration values
|
|
1841
|
-
:param pulumi.Input[
|
|
1842
|
-
:param pulumi.Input[
|
|
1843
|
-
:param pulumi.Input[
|
|
1844
|
-
:param pulumi.Input[
|
|
1845
|
-
:param pulumi.Input[
|
|
1846
|
-
:param pulumi.Input[
|
|
1847
|
-
:param pulumi.Input[
|
|
1848
|
-
:param pulumi.Input[
|
|
1840
|
+
:param pulumi.Input[_builtins.str] timezone: PostgreSQL service timezone
|
|
1841
|
+
:param pulumi.Input[_builtins.int] track_activity_query_size: Specifies the number of bytes reserved to track the currently executing command for each active session.
|
|
1842
|
+
:param pulumi.Input[_builtins.str] track_commit_timestamp: Record commit time of transactions. The default value is top. Supported values are: `off`, `on`.
|
|
1843
|
+
:param pulumi.Input[_builtins.str] track_functions: Enables tracking of function call counts and time used. The default value is top. Supported values are: `all`, `pl`, `none`.
|
|
1844
|
+
:param pulumi.Input[_builtins.str] track_io_timing: Enables timing of database I/O calls. This parameter is off by default, because it will repeatedly query the operating system for the current time, which may cause significant overhead on some platforms. The default value is top. Supported values are: `off`, `on`.
|
|
1845
|
+
:param pulumi.Input[_builtins.int] wal_sender_timeout: Terminate replication connections that are inactive for longer than this amount of time, in milliseconds. Setting this value to zero disables the timeout. Must be either 0 or between 5000 and 10800000.
|
|
1846
|
+
:param pulumi.Input[_builtins.int] wal_writer_delay: WAL flush interval in milliseconds. Note that setting this value to lower than the default 200ms may negatively impact performance
|
|
1847
|
+
:param pulumi.Input[_builtins.int] work_mem: The maximum amount of memory, in MB, used by a query operation (such as a sort or hash table) before writing to temporary disk files. Default is 1MB + 0.075% of total RAM (up to 32MB).
|
|
1849
1848
|
"""
|
|
1850
1849
|
...
|
|
1851
1850
|
@overload
|
|
@@ -1903,58 +1902,58 @@ class DatabasePostgresqlConfig(pulumi.CustomResource):
|
|
|
1903
1902
|
def _internal_init(__self__,
|
|
1904
1903
|
resource_name: str,
|
|
1905
1904
|
opts: Optional[pulumi.ResourceOptions] = None,
|
|
1906
|
-
autovacuum_analyze_scale_factor: Optional[pulumi.Input[
|
|
1907
|
-
autovacuum_analyze_threshold: Optional[pulumi.Input[
|
|
1908
|
-
autovacuum_freeze_max_age: Optional[pulumi.Input[
|
|
1909
|
-
autovacuum_max_workers: Optional[pulumi.Input[
|
|
1910
|
-
autovacuum_naptime: Optional[pulumi.Input[
|
|
1911
|
-
autovacuum_vacuum_cost_delay: Optional[pulumi.Input[
|
|
1912
|
-
autovacuum_vacuum_cost_limit: Optional[pulumi.Input[
|
|
1913
|
-
autovacuum_vacuum_scale_factor: Optional[pulumi.Input[
|
|
1914
|
-
autovacuum_vacuum_threshold: Optional[pulumi.Input[
|
|
1915
|
-
backup_hour: Optional[pulumi.Input[
|
|
1916
|
-
backup_minute: Optional[pulumi.Input[
|
|
1917
|
-
bgwriter_delay: Optional[pulumi.Input[
|
|
1918
|
-
bgwriter_flush_after: Optional[pulumi.Input[
|
|
1919
|
-
bgwriter_lru_maxpages: Optional[pulumi.Input[
|
|
1920
|
-
bgwriter_lru_multiplier: Optional[pulumi.Input[
|
|
1921
|
-
cluster_id: Optional[pulumi.Input[
|
|
1922
|
-
deadlock_timeout: Optional[pulumi.Input[
|
|
1923
|
-
default_toast_compression: Optional[pulumi.Input[
|
|
1924
|
-
idle_in_transaction_session_timeout: Optional[pulumi.Input[
|
|
1925
|
-
jit: Optional[pulumi.Input[
|
|
1926
|
-
log_autovacuum_min_duration: Optional[pulumi.Input[
|
|
1927
|
-
log_error_verbosity: Optional[pulumi.Input[
|
|
1928
|
-
log_line_prefix: Optional[pulumi.Input[
|
|
1929
|
-
log_min_duration_statement: Optional[pulumi.Input[
|
|
1930
|
-
max_files_per_process: Optional[pulumi.Input[
|
|
1931
|
-
max_locks_per_transaction: Optional[pulumi.Input[
|
|
1932
|
-
max_logical_replication_workers: Optional[pulumi.Input[
|
|
1933
|
-
max_parallel_workers: Optional[pulumi.Input[
|
|
1934
|
-
max_parallel_workers_per_gather: Optional[pulumi.Input[
|
|
1935
|
-
max_pred_locks_per_transaction: Optional[pulumi.Input[
|
|
1936
|
-
max_prepared_transactions: Optional[pulumi.Input[
|
|
1937
|
-
max_replication_slots: Optional[pulumi.Input[
|
|
1938
|
-
max_stack_depth: Optional[pulumi.Input[
|
|
1939
|
-
max_standby_archive_delay: Optional[pulumi.Input[
|
|
1940
|
-
max_standby_streaming_delay: Optional[pulumi.Input[
|
|
1941
|
-
max_wal_senders: Optional[pulumi.Input[
|
|
1942
|
-
max_worker_processes: Optional[pulumi.Input[
|
|
1943
|
-
pg_partman_bgw_interval: Optional[pulumi.Input[
|
|
1944
|
-
pg_partman_bgw_role: Optional[pulumi.Input[
|
|
1945
|
-
pg_stat_statements_track: Optional[pulumi.Input[
|
|
1905
|
+
autovacuum_analyze_scale_factor: Optional[pulumi.Input[_builtins.float]] = None,
|
|
1906
|
+
autovacuum_analyze_threshold: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1907
|
+
autovacuum_freeze_max_age: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1908
|
+
autovacuum_max_workers: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1909
|
+
autovacuum_naptime: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1910
|
+
autovacuum_vacuum_cost_delay: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1911
|
+
autovacuum_vacuum_cost_limit: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1912
|
+
autovacuum_vacuum_scale_factor: Optional[pulumi.Input[_builtins.float]] = None,
|
|
1913
|
+
autovacuum_vacuum_threshold: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1914
|
+
backup_hour: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1915
|
+
backup_minute: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1916
|
+
bgwriter_delay: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1917
|
+
bgwriter_flush_after: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1918
|
+
bgwriter_lru_maxpages: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1919
|
+
bgwriter_lru_multiplier: Optional[pulumi.Input[_builtins.float]] = None,
|
|
1920
|
+
cluster_id: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1921
|
+
deadlock_timeout: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1922
|
+
default_toast_compression: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1923
|
+
idle_in_transaction_session_timeout: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1924
|
+
jit: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1925
|
+
log_autovacuum_min_duration: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1926
|
+
log_error_verbosity: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1927
|
+
log_line_prefix: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1928
|
+
log_min_duration_statement: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1929
|
+
max_files_per_process: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1930
|
+
max_locks_per_transaction: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1931
|
+
max_logical_replication_workers: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1932
|
+
max_parallel_workers: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1933
|
+
max_parallel_workers_per_gather: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1934
|
+
max_pred_locks_per_transaction: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1935
|
+
max_prepared_transactions: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1936
|
+
max_replication_slots: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1937
|
+
max_stack_depth: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1938
|
+
max_standby_archive_delay: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1939
|
+
max_standby_streaming_delay: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1940
|
+
max_wal_senders: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1941
|
+
max_worker_processes: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1942
|
+
pg_partman_bgw_interval: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1943
|
+
pg_partman_bgw_role: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1944
|
+
pg_stat_statements_track: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1946
1945
|
pgbouncers: Optional[pulumi.Input[Sequence[pulumi.Input[Union['DatabasePostgresqlConfigPgbouncerArgs', 'DatabasePostgresqlConfigPgbouncerArgsDict']]]]] = None,
|
|
1947
|
-
shared_buffers_percentage: Optional[pulumi.Input[
|
|
1948
|
-
temp_file_limit: Optional[pulumi.Input[
|
|
1946
|
+
shared_buffers_percentage: Optional[pulumi.Input[_builtins.float]] = None,
|
|
1947
|
+
temp_file_limit: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1949
1948
|
timescaledbs: Optional[pulumi.Input[Sequence[pulumi.Input[Union['DatabasePostgresqlConfigTimescaledbArgs', 'DatabasePostgresqlConfigTimescaledbArgsDict']]]]] = None,
|
|
1950
|
-
timezone: Optional[pulumi.Input[
|
|
1951
|
-
track_activity_query_size: Optional[pulumi.Input[
|
|
1952
|
-
track_commit_timestamp: Optional[pulumi.Input[
|
|
1953
|
-
track_functions: Optional[pulumi.Input[
|
|
1954
|
-
track_io_timing: Optional[pulumi.Input[
|
|
1955
|
-
wal_sender_timeout: Optional[pulumi.Input[
|
|
1956
|
-
wal_writer_delay: Optional[pulumi.Input[
|
|
1957
|
-
work_mem: Optional[pulumi.Input[
|
|
1949
|
+
timezone: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1950
|
+
track_activity_query_size: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1951
|
+
track_commit_timestamp: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1952
|
+
track_functions: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1953
|
+
track_io_timing: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1954
|
+
wal_sender_timeout: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1955
|
+
wal_writer_delay: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1956
|
+
work_mem: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1958
1957
|
__props__=None):
|
|
1959
1958
|
opts = pulumi.ResourceOptions.merge(_utilities.get_resource_opts_defaults(), opts)
|
|
1960
1959
|
if not isinstance(opts, pulumi.ResourceOptions):
|
|
@@ -2028,58 +2027,58 @@ class DatabasePostgresqlConfig(pulumi.CustomResource):
|
|
|
2028
2027
|
def get(resource_name: str,
|
|
2029
2028
|
id: pulumi.Input[str],
|
|
2030
2029
|
opts: Optional[pulumi.ResourceOptions] = None,
|
|
2031
|
-
autovacuum_analyze_scale_factor: Optional[pulumi.Input[
|
|
2032
|
-
autovacuum_analyze_threshold: Optional[pulumi.Input[
|
|
2033
|
-
autovacuum_freeze_max_age: Optional[pulumi.Input[
|
|
2034
|
-
autovacuum_max_workers: Optional[pulumi.Input[
|
|
2035
|
-
autovacuum_naptime: Optional[pulumi.Input[
|
|
2036
|
-
autovacuum_vacuum_cost_delay: Optional[pulumi.Input[
|
|
2037
|
-
autovacuum_vacuum_cost_limit: Optional[pulumi.Input[
|
|
2038
|
-
autovacuum_vacuum_scale_factor: Optional[pulumi.Input[
|
|
2039
|
-
autovacuum_vacuum_threshold: Optional[pulumi.Input[
|
|
2040
|
-
backup_hour: Optional[pulumi.Input[
|
|
2041
|
-
backup_minute: Optional[pulumi.Input[
|
|
2042
|
-
bgwriter_delay: Optional[pulumi.Input[
|
|
2043
|
-
bgwriter_flush_after: Optional[pulumi.Input[
|
|
2044
|
-
bgwriter_lru_maxpages: Optional[pulumi.Input[
|
|
2045
|
-
bgwriter_lru_multiplier: Optional[pulumi.Input[
|
|
2046
|
-
cluster_id: Optional[pulumi.Input[
|
|
2047
|
-
deadlock_timeout: Optional[pulumi.Input[
|
|
2048
|
-
default_toast_compression: Optional[pulumi.Input[
|
|
2049
|
-
idle_in_transaction_session_timeout: Optional[pulumi.Input[
|
|
2050
|
-
jit: Optional[pulumi.Input[
|
|
2051
|
-
log_autovacuum_min_duration: Optional[pulumi.Input[
|
|
2052
|
-
log_error_verbosity: Optional[pulumi.Input[
|
|
2053
|
-
log_line_prefix: Optional[pulumi.Input[
|
|
2054
|
-
log_min_duration_statement: Optional[pulumi.Input[
|
|
2055
|
-
max_files_per_process: Optional[pulumi.Input[
|
|
2056
|
-
max_locks_per_transaction: Optional[pulumi.Input[
|
|
2057
|
-
max_logical_replication_workers: Optional[pulumi.Input[
|
|
2058
|
-
max_parallel_workers: Optional[pulumi.Input[
|
|
2059
|
-
max_parallel_workers_per_gather: Optional[pulumi.Input[
|
|
2060
|
-
max_pred_locks_per_transaction: Optional[pulumi.Input[
|
|
2061
|
-
max_prepared_transactions: Optional[pulumi.Input[
|
|
2062
|
-
max_replication_slots: Optional[pulumi.Input[
|
|
2063
|
-
max_stack_depth: Optional[pulumi.Input[
|
|
2064
|
-
max_standby_archive_delay: Optional[pulumi.Input[
|
|
2065
|
-
max_standby_streaming_delay: Optional[pulumi.Input[
|
|
2066
|
-
max_wal_senders: Optional[pulumi.Input[
|
|
2067
|
-
max_worker_processes: Optional[pulumi.Input[
|
|
2068
|
-
pg_partman_bgw_interval: Optional[pulumi.Input[
|
|
2069
|
-
pg_partman_bgw_role: Optional[pulumi.Input[
|
|
2070
|
-
pg_stat_statements_track: Optional[pulumi.Input[
|
|
2030
|
+
autovacuum_analyze_scale_factor: Optional[pulumi.Input[_builtins.float]] = None,
|
|
2031
|
+
autovacuum_analyze_threshold: Optional[pulumi.Input[_builtins.int]] = None,
|
|
2032
|
+
autovacuum_freeze_max_age: Optional[pulumi.Input[_builtins.int]] = None,
|
|
2033
|
+
autovacuum_max_workers: Optional[pulumi.Input[_builtins.int]] = None,
|
|
2034
|
+
autovacuum_naptime: Optional[pulumi.Input[_builtins.int]] = None,
|
|
2035
|
+
autovacuum_vacuum_cost_delay: Optional[pulumi.Input[_builtins.int]] = None,
|
|
2036
|
+
autovacuum_vacuum_cost_limit: Optional[pulumi.Input[_builtins.int]] = None,
|
|
2037
|
+
autovacuum_vacuum_scale_factor: Optional[pulumi.Input[_builtins.float]] = None,
|
|
2038
|
+
autovacuum_vacuum_threshold: Optional[pulumi.Input[_builtins.int]] = None,
|
|
2039
|
+
backup_hour: Optional[pulumi.Input[_builtins.int]] = None,
|
|
2040
|
+
backup_minute: Optional[pulumi.Input[_builtins.int]] = None,
|
|
2041
|
+
bgwriter_delay: Optional[pulumi.Input[_builtins.int]] = None,
|
|
2042
|
+
bgwriter_flush_after: Optional[pulumi.Input[_builtins.int]] = None,
|
|
2043
|
+
bgwriter_lru_maxpages: Optional[pulumi.Input[_builtins.int]] = None,
|
|
2044
|
+
bgwriter_lru_multiplier: Optional[pulumi.Input[_builtins.float]] = None,
|
|
2045
|
+
cluster_id: Optional[pulumi.Input[_builtins.str]] = None,
|
|
2046
|
+
deadlock_timeout: Optional[pulumi.Input[_builtins.int]] = None,
|
|
2047
|
+
default_toast_compression: Optional[pulumi.Input[_builtins.str]] = None,
|
|
2048
|
+
idle_in_transaction_session_timeout: Optional[pulumi.Input[_builtins.int]] = None,
|
|
2049
|
+
jit: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
2050
|
+
log_autovacuum_min_duration: Optional[pulumi.Input[_builtins.int]] = None,
|
|
2051
|
+
log_error_verbosity: Optional[pulumi.Input[_builtins.str]] = None,
|
|
2052
|
+
log_line_prefix: Optional[pulumi.Input[_builtins.str]] = None,
|
|
2053
|
+
log_min_duration_statement: Optional[pulumi.Input[_builtins.int]] = None,
|
|
2054
|
+
max_files_per_process: Optional[pulumi.Input[_builtins.int]] = None,
|
|
2055
|
+
max_locks_per_transaction: Optional[pulumi.Input[_builtins.int]] = None,
|
|
2056
|
+
max_logical_replication_workers: Optional[pulumi.Input[_builtins.int]] = None,
|
|
2057
|
+
max_parallel_workers: Optional[pulumi.Input[_builtins.int]] = None,
|
|
2058
|
+
max_parallel_workers_per_gather: Optional[pulumi.Input[_builtins.int]] = None,
|
|
2059
|
+
max_pred_locks_per_transaction: Optional[pulumi.Input[_builtins.int]] = None,
|
|
2060
|
+
max_prepared_transactions: Optional[pulumi.Input[_builtins.int]] = None,
|
|
2061
|
+
max_replication_slots: Optional[pulumi.Input[_builtins.int]] = None,
|
|
2062
|
+
max_stack_depth: Optional[pulumi.Input[_builtins.int]] = None,
|
|
2063
|
+
max_standby_archive_delay: Optional[pulumi.Input[_builtins.int]] = None,
|
|
2064
|
+
max_standby_streaming_delay: Optional[pulumi.Input[_builtins.int]] = None,
|
|
2065
|
+
max_wal_senders: Optional[pulumi.Input[_builtins.int]] = None,
|
|
2066
|
+
max_worker_processes: Optional[pulumi.Input[_builtins.int]] = None,
|
|
2067
|
+
pg_partman_bgw_interval: Optional[pulumi.Input[_builtins.int]] = None,
|
|
2068
|
+
pg_partman_bgw_role: Optional[pulumi.Input[_builtins.str]] = None,
|
|
2069
|
+
pg_stat_statements_track: Optional[pulumi.Input[_builtins.str]] = None,
|
|
2071
2070
|
pgbouncers: Optional[pulumi.Input[Sequence[pulumi.Input[Union['DatabasePostgresqlConfigPgbouncerArgs', 'DatabasePostgresqlConfigPgbouncerArgsDict']]]]] = None,
|
|
2072
|
-
shared_buffers_percentage: Optional[pulumi.Input[
|
|
2073
|
-
temp_file_limit: Optional[pulumi.Input[
|
|
2071
|
+
shared_buffers_percentage: Optional[pulumi.Input[_builtins.float]] = None,
|
|
2072
|
+
temp_file_limit: Optional[pulumi.Input[_builtins.int]] = None,
|
|
2074
2073
|
timescaledbs: Optional[pulumi.Input[Sequence[pulumi.Input[Union['DatabasePostgresqlConfigTimescaledbArgs', 'DatabasePostgresqlConfigTimescaledbArgsDict']]]]] = None,
|
|
2075
|
-
timezone: Optional[pulumi.Input[
|
|
2076
|
-
track_activity_query_size: Optional[pulumi.Input[
|
|
2077
|
-
track_commit_timestamp: Optional[pulumi.Input[
|
|
2078
|
-
track_functions: Optional[pulumi.Input[
|
|
2079
|
-
track_io_timing: Optional[pulumi.Input[
|
|
2080
|
-
wal_sender_timeout: Optional[pulumi.Input[
|
|
2081
|
-
wal_writer_delay: Optional[pulumi.Input[
|
|
2082
|
-
work_mem: Optional[pulumi.Input[
|
|
2074
|
+
timezone: Optional[pulumi.Input[_builtins.str]] = None,
|
|
2075
|
+
track_activity_query_size: Optional[pulumi.Input[_builtins.int]] = None,
|
|
2076
|
+
track_commit_timestamp: Optional[pulumi.Input[_builtins.str]] = None,
|
|
2077
|
+
track_functions: Optional[pulumi.Input[_builtins.str]] = None,
|
|
2078
|
+
track_io_timing: Optional[pulumi.Input[_builtins.str]] = None,
|
|
2079
|
+
wal_sender_timeout: Optional[pulumi.Input[_builtins.int]] = None,
|
|
2080
|
+
wal_writer_delay: Optional[pulumi.Input[_builtins.int]] = None,
|
|
2081
|
+
work_mem: Optional[pulumi.Input[_builtins.int]] = None) -> 'DatabasePostgresqlConfig':
|
|
2083
2082
|
"""
|
|
2084
2083
|
Get an existing DatabasePostgresqlConfig resource's state with the given name, id, and optional extra
|
|
2085
2084
|
properties used to qualify the lookup.
|
|
@@ -2087,58 +2086,58 @@ class DatabasePostgresqlConfig(pulumi.CustomResource):
|
|
|
2087
2086
|
:param str resource_name: The unique name of the resulting resource.
|
|
2088
2087
|
:param pulumi.Input[str] id: The unique provider ID of the resource to lookup.
|
|
2089
2088
|
:param pulumi.ResourceOptions opts: Options for the resource.
|
|
2090
|
-
:param pulumi.Input[
|
|
2091
|
-
:param pulumi.Input[
|
|
2092
|
-
:param pulumi.Input[
|
|
2093
|
-
:param pulumi.Input[
|
|
2094
|
-
:param pulumi.Input[
|
|
2095
|
-
:param pulumi.Input[
|
|
2096
|
-
:param pulumi.Input[
|
|
2097
|
-
:param pulumi.Input[
|
|
2098
|
-
:param pulumi.Input[
|
|
2099
|
-
:param pulumi.Input[
|
|
2100
|
-
:param pulumi.Input[
|
|
2101
|
-
:param pulumi.Input[
|
|
2102
|
-
:param pulumi.Input[
|
|
2103
|
-
:param pulumi.Input[
|
|
2104
|
-
:param pulumi.Input[
|
|
2105
|
-
:param pulumi.Input[
|
|
2106
|
-
:param pulumi.Input[
|
|
2107
|
-
:param pulumi.Input[
|
|
2108
|
-
:param pulumi.Input[
|
|
2109
|
-
:param pulumi.Input[
|
|
2110
|
-
:param pulumi.Input[
|
|
2111
|
-
:param pulumi.Input[
|
|
2112
|
-
:param pulumi.Input[
|
|
2113
|
-
:param pulumi.Input[
|
|
2114
|
-
:param pulumi.Input[
|
|
2115
|
-
:param pulumi.Input[
|
|
2116
|
-
:param pulumi.Input[
|
|
2117
|
-
:param pulumi.Input[
|
|
2118
|
-
:param pulumi.Input[
|
|
2119
|
-
:param pulumi.Input[
|
|
2120
|
-
:param pulumi.Input[
|
|
2121
|
-
:param pulumi.Input[
|
|
2122
|
-
:param pulumi.Input[
|
|
2123
|
-
:param pulumi.Input[
|
|
2124
|
-
:param pulumi.Input[
|
|
2125
|
-
:param pulumi.Input[
|
|
2126
|
-
:param pulumi.Input[
|
|
2127
|
-
:param pulumi.Input[
|
|
2128
|
-
:param pulumi.Input[
|
|
2129
|
-
:param pulumi.Input[
|
|
2089
|
+
:param pulumi.Input[_builtins.float] autovacuum_analyze_scale_factor: Specifies a fraction, in a decimal value, of the table size to add to autovacuum_analyze_threshold when deciding whether to trigger an ANALYZE. The default is 0.2 (20% of table size).
|
|
2090
|
+
:param pulumi.Input[_builtins.int] autovacuum_analyze_threshold: Specifies the minimum number of inserted, updated, or deleted tuples needed to trigger an ANALYZE in any one table. The default is 50 tuples.
|
|
2091
|
+
:param pulumi.Input[_builtins.int] autovacuum_freeze_max_age: Specifies the maximum age (in transactions) that a table's pg_class.relfrozenxid field can attain before a VACUUM operation is forced to prevent transaction ID wraparound within the table. Note that the system will launch autovacuum processes to prevent wraparound even when autovacuum is otherwise disabled. This parameter will cause the server to be restarted.
|
|
2092
|
+
:param pulumi.Input[_builtins.int] autovacuum_max_workers: Specifies the maximum number of autovacuum processes (other than the autovacuum launcher) that may be running at any one time. The default is three. This parameter can only be set at server start.
|
|
2093
|
+
:param pulumi.Input[_builtins.int] autovacuum_naptime: Specifies the minimum delay, in seconds, between autovacuum runs on any given database. The default is one minute.
|
|
2094
|
+
:param pulumi.Input[_builtins.int] autovacuum_vacuum_cost_delay: Specifies the cost delay value, in milliseconds, that will be used in automatic VACUUM operations. If -1, uses the regular vacuum_cost_delay value, which is 20 milliseconds.
|
|
2095
|
+
:param pulumi.Input[_builtins.int] autovacuum_vacuum_cost_limit: Specifies the cost limit value that will be used in automatic VACUUM operations. If -1 is specified (which is the default), the regular vacuum_cost_limit value will be used.
|
|
2096
|
+
:param pulumi.Input[_builtins.float] autovacuum_vacuum_scale_factor: Specifies a fraction, in a decimal value, of the table size to add to autovacuum_vacuum_threshold when deciding whether to trigger a VACUUM. The default is 0.2 (20% of table size).
|
|
2097
|
+
:param pulumi.Input[_builtins.int] autovacuum_vacuum_threshold: Specifies the minimum number of updated or deleted tuples needed to trigger a VACUUM in any one table. The default is 50 tuples.
|
|
2098
|
+
:param pulumi.Input[_builtins.int] backup_hour: The hour of day (in UTC) when backup for the service starts. New backup only starts if previous backup has already completed.
|
|
2099
|
+
:param pulumi.Input[_builtins.int] backup_minute: The minute of the backup hour when backup for the service starts. New backup is only started if previous backup has already completed.
|
|
2100
|
+
:param pulumi.Input[_builtins.int] bgwriter_delay: Specifies the delay, in milliseconds, between activity rounds for the background writer. Default is 200 ms.
|
|
2101
|
+
:param pulumi.Input[_builtins.int] bgwriter_flush_after: The amount of kilobytes that need to be written by the background writer before attempting to force the OS to issue these writes to underlying storage. Specified in kilobytes, default is 512. Setting of 0 disables forced writeback.
|
|
2102
|
+
:param pulumi.Input[_builtins.int] bgwriter_lru_maxpages: The maximum number of buffers that the background writer can write. Setting this to zero disables background writing. Default is 100.
|
|
2103
|
+
:param pulumi.Input[_builtins.float] bgwriter_lru_multiplier: The average recent need for new buffers is multiplied by bgwriter_lru_multiplier to arrive at an estimate of the number that will be needed during the next round, (up to bgwriter_lru_maxpages). 1.0 represents a “just in time” policy of writing exactly the number of buffers predicted to be needed. Larger values provide some cushion against spikes in demand, while smaller values intentionally leave writes to be done by server processes. The default is 2.0.
|
|
2104
|
+
:param pulumi.Input[_builtins.str] cluster_id: The ID of the target PostgreSQL cluster.
|
|
2105
|
+
:param pulumi.Input[_builtins.int] deadlock_timeout: The amount of time, in milliseconds, to wait on a lock before checking to see if there is a deadlock condition.
|
|
2106
|
+
:param pulumi.Input[_builtins.str] default_toast_compression: Specifies the default TOAST compression method for values of compressible columns (the default is lz4). Supported values are: `lz4`, `pglz`.
|
|
2107
|
+
:param pulumi.Input[_builtins.int] idle_in_transaction_session_timeout: Time out sessions with open transactions after this number of milliseconds
|
|
2108
|
+
:param pulumi.Input[_builtins.bool] jit: Activates, in a boolean, the system-wide use of Just-in-Time Compilation (JIT).
|
|
2109
|
+
:param pulumi.Input[_builtins.int] log_autovacuum_min_duration: Causes each action executed by autovacuum to be logged if it ran for at least the specified number of milliseconds. Setting this to zero logs all autovacuum actions. Minus-one (the default) disables logging autovacuum actions.
|
|
2110
|
+
:param pulumi.Input[_builtins.str] log_error_verbosity: Controls the amount of detail written in the server log for each message that is logged. Supported values are: `TERSE`, `DEFAULT`, `VERBOSE`.
|
|
2111
|
+
:param pulumi.Input[_builtins.str] log_line_prefix: Selects one of the available log-formats. These can support popular log analyzers like pgbadger, pganalyze, etc. Supported values are: `pid=%p,user=%u,db=%d,app=%a,client=%h`, `%m [%p] %q[user=%u,db=%d,app=%a]`, `%t [%p]: [%l-1] user=%u,db=%d,app=%a,client=%h`.
|
|
2112
|
+
:param pulumi.Input[_builtins.int] log_min_duration_statement: Log statements that take more than this number of milliseconds to run. If -1, disables.
|
|
2113
|
+
:param pulumi.Input[_builtins.int] max_files_per_process: PostgreSQL maximum number of files that can be open per process.
|
|
2114
|
+
:param pulumi.Input[_builtins.int] max_locks_per_transaction: PostgreSQL maximum locks per transaction. Once increased, this parameter cannot be lowered from its set value.
|
|
2115
|
+
:param pulumi.Input[_builtins.int] max_logical_replication_workers: PostgreSQL maximum logical replication workers (taken from the pool of max_parallel_workers).
|
|
2116
|
+
:param pulumi.Input[_builtins.int] max_parallel_workers: Sets the maximum number of workers that the system can support for parallel queries.
|
|
2117
|
+
:param pulumi.Input[_builtins.int] max_parallel_workers_per_gather: Sets the maximum number of workers that can be started by a single Gather or Gather Merge node.
|
|
2118
|
+
:param pulumi.Input[_builtins.int] max_pred_locks_per_transaction: PostgreSQL maximum predicate locks per transaction.
|
|
2119
|
+
:param pulumi.Input[_builtins.int] max_prepared_transactions: PostgreSQL maximum prepared transactions. Once increased, this parameter cannot be lowered from its set value.
|
|
2120
|
+
:param pulumi.Input[_builtins.int] max_replication_slots: PostgreSQL maximum replication slots.
|
|
2121
|
+
:param pulumi.Input[_builtins.int] max_stack_depth: Maximum depth of the stack in bytes.
|
|
2122
|
+
:param pulumi.Input[_builtins.int] max_standby_archive_delay: Max standby archive delay in milliseconds.
|
|
2123
|
+
:param pulumi.Input[_builtins.int] max_standby_streaming_delay: Max standby streaming delay in milliseconds.
|
|
2124
|
+
:param pulumi.Input[_builtins.int] max_wal_senders: PostgreSQL maximum WAL senders. Once increased, this parameter cannot be lowered from its set value.
|
|
2125
|
+
:param pulumi.Input[_builtins.int] max_worker_processes: Sets the maximum number of background processes that the system can support. Once increased, this parameter cannot be lowered from its set value.
|
|
2126
|
+
:param pulumi.Input[_builtins.int] pg_partman_bgw_interval: Sets the time interval to run pg_partman's scheduled tasks.
|
|
2127
|
+
:param pulumi.Input[_builtins.str] pg_partman_bgw_role: Controls which role to use for pg_partman's scheduled background tasks. Must consist of alpha-numeric characters, dots, underscores, or dashes. May not start with dash or dot. Maximum of 64 characters.
|
|
2128
|
+
:param pulumi.Input[_builtins.str] pg_stat_statements_track: Controls which statements are counted. Specify 'top' to track top-level statements (those issued directly by clients), 'all' to also track nested statements (such as statements invoked within functions), or 'none' to disable statement statistics collection. The default value is top. Supported values are: `all`, `top`, `none`.
|
|
2130
2129
|
:param pulumi.Input[Sequence[pulumi.Input[Union['DatabasePostgresqlConfigPgbouncerArgs', 'DatabasePostgresqlConfigPgbouncerArgsDict']]]] pgbouncers: PGBouncer connection pooling settings
|
|
2131
|
-
:param pulumi.Input[
|
|
2132
|
-
:param pulumi.Input[
|
|
2130
|
+
:param pulumi.Input[_builtins.float] shared_buffers_percentage: Percentage of total RAM that the database server uses for shared memory buffers. Valid range is 20-60 (float), which corresponds to 20% - 60%. This setting adjusts the shared_buffers configuration value.
|
|
2131
|
+
:param pulumi.Input[_builtins.int] temp_file_limit: PostgreSQL temporary file limit in KiB. If -1, sets to unlimited.
|
|
2133
2132
|
:param pulumi.Input[Sequence[pulumi.Input[Union['DatabasePostgresqlConfigTimescaledbArgs', 'DatabasePostgresqlConfigTimescaledbArgsDict']]]] timescaledbs: TimescaleDB extension configuration values
|
|
2134
|
-
:param pulumi.Input[
|
|
2135
|
-
:param pulumi.Input[
|
|
2136
|
-
:param pulumi.Input[
|
|
2137
|
-
:param pulumi.Input[
|
|
2138
|
-
:param pulumi.Input[
|
|
2139
|
-
:param pulumi.Input[
|
|
2140
|
-
:param pulumi.Input[
|
|
2141
|
-
:param pulumi.Input[
|
|
2133
|
+
:param pulumi.Input[_builtins.str] timezone: PostgreSQL service timezone
|
|
2134
|
+
:param pulumi.Input[_builtins.int] track_activity_query_size: Specifies the number of bytes reserved to track the currently executing command for each active session.
|
|
2135
|
+
:param pulumi.Input[_builtins.str] track_commit_timestamp: Record commit time of transactions. The default value is top. Supported values are: `off`, `on`.
|
|
2136
|
+
:param pulumi.Input[_builtins.str] track_functions: Enables tracking of function call counts and time used. The default value is top. Supported values are: `all`, `pl`, `none`.
|
|
2137
|
+
:param pulumi.Input[_builtins.str] track_io_timing: Enables timing of database I/O calls. This parameter is off by default, because it will repeatedly query the operating system for the current time, which may cause significant overhead on some platforms. The default value is top. Supported values are: `off`, `on`.
|
|
2138
|
+
:param pulumi.Input[_builtins.int] wal_sender_timeout: Terminate replication connections that are inactive for longer than this amount of time, in milliseconds. Setting this value to zero disables the timeout. Must be either 0 or between 5000 and 10800000.
|
|
2139
|
+
:param pulumi.Input[_builtins.int] wal_writer_delay: WAL flush interval in milliseconds. Note that setting this value to lower than the default 200ms may negatively impact performance
|
|
2140
|
+
:param pulumi.Input[_builtins.int] work_mem: The maximum amount of memory, in MB, used by a query operation (such as a sort or hash table) before writing to temporary disk files. Default is 1MB + 0.075% of total RAM (up to 32MB).
|
|
2142
2141
|
"""
|
|
2143
2142
|
opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id))
|
|
2144
2143
|
|
|
@@ -2198,327 +2197,327 @@ class DatabasePostgresqlConfig(pulumi.CustomResource):
|
|
|
2198
2197
|
__props__.__dict__["work_mem"] = work_mem
|
|
2199
2198
|
return DatabasePostgresqlConfig(resource_name, opts=opts, __props__=__props__)
|
|
2200
2199
|
|
|
2201
|
-
@property
|
|
2200
|
+
@_builtins.property
|
|
2202
2201
|
@pulumi.getter(name="autovacuumAnalyzeScaleFactor")
|
|
2203
|
-
def autovacuum_analyze_scale_factor(self) -> pulumi.Output[
|
|
2202
|
+
def autovacuum_analyze_scale_factor(self) -> pulumi.Output[_builtins.float]:
|
|
2204
2203
|
"""
|
|
2205
2204
|
Specifies a fraction, in a decimal value, of the table size to add to autovacuum_analyze_threshold when deciding whether to trigger an ANALYZE. The default is 0.2 (20% of table size).
|
|
2206
2205
|
"""
|
|
2207
2206
|
return pulumi.get(self, "autovacuum_analyze_scale_factor")
|
|
2208
2207
|
|
|
2209
|
-
@property
|
|
2208
|
+
@_builtins.property
|
|
2210
2209
|
@pulumi.getter(name="autovacuumAnalyzeThreshold")
|
|
2211
|
-
def autovacuum_analyze_threshold(self) -> pulumi.Output[
|
|
2210
|
+
def autovacuum_analyze_threshold(self) -> pulumi.Output[_builtins.int]:
|
|
2212
2211
|
"""
|
|
2213
2212
|
Specifies the minimum number of inserted, updated, or deleted tuples needed to trigger an ANALYZE in any one table. The default is 50 tuples.
|
|
2214
2213
|
"""
|
|
2215
2214
|
return pulumi.get(self, "autovacuum_analyze_threshold")
|
|
2216
2215
|
|
|
2217
|
-
@property
|
|
2216
|
+
@_builtins.property
|
|
2218
2217
|
@pulumi.getter(name="autovacuumFreezeMaxAge")
|
|
2219
|
-
def autovacuum_freeze_max_age(self) -> pulumi.Output[
|
|
2218
|
+
def autovacuum_freeze_max_age(self) -> pulumi.Output[_builtins.int]:
|
|
2220
2219
|
"""
|
|
2221
2220
|
Specifies the maximum age (in transactions) that a table's pg_class.relfrozenxid field can attain before a VACUUM operation is forced to prevent transaction ID wraparound within the table. Note that the system will launch autovacuum processes to prevent wraparound even when autovacuum is otherwise disabled. This parameter will cause the server to be restarted.
|
|
2222
2221
|
"""
|
|
2223
2222
|
return pulumi.get(self, "autovacuum_freeze_max_age")
|
|
2224
2223
|
|
|
2225
|
-
@property
|
|
2224
|
+
@_builtins.property
|
|
2226
2225
|
@pulumi.getter(name="autovacuumMaxWorkers")
|
|
2227
|
-
def autovacuum_max_workers(self) -> pulumi.Output[
|
|
2226
|
+
def autovacuum_max_workers(self) -> pulumi.Output[_builtins.int]:
|
|
2228
2227
|
"""
|
|
2229
2228
|
Specifies the maximum number of autovacuum processes (other than the autovacuum launcher) that may be running at any one time. The default is three. This parameter can only be set at server start.
|
|
2230
2229
|
"""
|
|
2231
2230
|
return pulumi.get(self, "autovacuum_max_workers")
|
|
2232
2231
|
|
|
2233
|
-
@property
|
|
2232
|
+
@_builtins.property
|
|
2234
2233
|
@pulumi.getter(name="autovacuumNaptime")
|
|
2235
|
-
def autovacuum_naptime(self) -> pulumi.Output[
|
|
2234
|
+
def autovacuum_naptime(self) -> pulumi.Output[_builtins.int]:
|
|
2236
2235
|
"""
|
|
2237
2236
|
Specifies the minimum delay, in seconds, between autovacuum runs on any given database. The default is one minute.
|
|
2238
2237
|
"""
|
|
2239
2238
|
return pulumi.get(self, "autovacuum_naptime")
|
|
2240
2239
|
|
|
2241
|
-
@property
|
|
2240
|
+
@_builtins.property
|
|
2242
2241
|
@pulumi.getter(name="autovacuumVacuumCostDelay")
|
|
2243
|
-
def autovacuum_vacuum_cost_delay(self) -> pulumi.Output[
|
|
2242
|
+
def autovacuum_vacuum_cost_delay(self) -> pulumi.Output[_builtins.int]:
|
|
2244
2243
|
"""
|
|
2245
2244
|
Specifies the cost delay value, in milliseconds, that will be used in automatic VACUUM operations. If -1, uses the regular vacuum_cost_delay value, which is 20 milliseconds.
|
|
2246
2245
|
"""
|
|
2247
2246
|
return pulumi.get(self, "autovacuum_vacuum_cost_delay")
|
|
2248
2247
|
|
|
2249
|
-
@property
|
|
2248
|
+
@_builtins.property
|
|
2250
2249
|
@pulumi.getter(name="autovacuumVacuumCostLimit")
|
|
2251
|
-
def autovacuum_vacuum_cost_limit(self) -> pulumi.Output[
|
|
2250
|
+
def autovacuum_vacuum_cost_limit(self) -> pulumi.Output[_builtins.int]:
|
|
2252
2251
|
"""
|
|
2253
2252
|
Specifies the cost limit value that will be used in automatic VACUUM operations. If -1 is specified (which is the default), the regular vacuum_cost_limit value will be used.
|
|
2254
2253
|
"""
|
|
2255
2254
|
return pulumi.get(self, "autovacuum_vacuum_cost_limit")
|
|
2256
2255
|
|
|
2257
|
-
@property
|
|
2256
|
+
@_builtins.property
|
|
2258
2257
|
@pulumi.getter(name="autovacuumVacuumScaleFactor")
|
|
2259
|
-
def autovacuum_vacuum_scale_factor(self) -> pulumi.Output[
|
|
2258
|
+
def autovacuum_vacuum_scale_factor(self) -> pulumi.Output[_builtins.float]:
|
|
2260
2259
|
"""
|
|
2261
2260
|
Specifies a fraction, in a decimal value, of the table size to add to autovacuum_vacuum_threshold when deciding whether to trigger a VACUUM. The default is 0.2 (20% of table size).
|
|
2262
2261
|
"""
|
|
2263
2262
|
return pulumi.get(self, "autovacuum_vacuum_scale_factor")
|
|
2264
2263
|
|
|
2265
|
-
@property
|
|
2264
|
+
@_builtins.property
|
|
2266
2265
|
@pulumi.getter(name="autovacuumVacuumThreshold")
|
|
2267
|
-
def autovacuum_vacuum_threshold(self) -> pulumi.Output[
|
|
2266
|
+
def autovacuum_vacuum_threshold(self) -> pulumi.Output[_builtins.int]:
|
|
2268
2267
|
"""
|
|
2269
2268
|
Specifies the minimum number of updated or deleted tuples needed to trigger a VACUUM in any one table. The default is 50 tuples.
|
|
2270
2269
|
"""
|
|
2271
2270
|
return pulumi.get(self, "autovacuum_vacuum_threshold")
|
|
2272
2271
|
|
|
2273
|
-
@property
|
|
2272
|
+
@_builtins.property
|
|
2274
2273
|
@pulumi.getter(name="backupHour")
|
|
2275
|
-
def backup_hour(self) -> pulumi.Output[
|
|
2274
|
+
def backup_hour(self) -> pulumi.Output[_builtins.int]:
|
|
2276
2275
|
"""
|
|
2277
2276
|
The hour of day (in UTC) when backup for the service starts. New backup only starts if previous backup has already completed.
|
|
2278
2277
|
"""
|
|
2279
2278
|
return pulumi.get(self, "backup_hour")
|
|
2280
2279
|
|
|
2281
|
-
@property
|
|
2280
|
+
@_builtins.property
|
|
2282
2281
|
@pulumi.getter(name="backupMinute")
|
|
2283
|
-
def backup_minute(self) -> pulumi.Output[
|
|
2282
|
+
def backup_minute(self) -> pulumi.Output[_builtins.int]:
|
|
2284
2283
|
"""
|
|
2285
2284
|
The minute of the backup hour when backup for the service starts. New backup is only started if previous backup has already completed.
|
|
2286
2285
|
"""
|
|
2287
2286
|
return pulumi.get(self, "backup_minute")
|
|
2288
2287
|
|
|
2289
|
-
@property
|
|
2288
|
+
@_builtins.property
|
|
2290
2289
|
@pulumi.getter(name="bgwriterDelay")
|
|
2291
|
-
def bgwriter_delay(self) -> pulumi.Output[
|
|
2290
|
+
def bgwriter_delay(self) -> pulumi.Output[_builtins.int]:
|
|
2292
2291
|
"""
|
|
2293
2292
|
Specifies the delay, in milliseconds, between activity rounds for the background writer. Default is 200 ms.
|
|
2294
2293
|
"""
|
|
2295
2294
|
return pulumi.get(self, "bgwriter_delay")
|
|
2296
2295
|
|
|
2297
|
-
@property
|
|
2296
|
+
@_builtins.property
|
|
2298
2297
|
@pulumi.getter(name="bgwriterFlushAfter")
|
|
2299
|
-
def bgwriter_flush_after(self) -> pulumi.Output[
|
|
2298
|
+
def bgwriter_flush_after(self) -> pulumi.Output[_builtins.int]:
|
|
2300
2299
|
"""
|
|
2301
2300
|
The amount of kilobytes that need to be written by the background writer before attempting to force the OS to issue these writes to underlying storage. Specified in kilobytes, default is 512. Setting of 0 disables forced writeback.
|
|
2302
2301
|
"""
|
|
2303
2302
|
return pulumi.get(self, "bgwriter_flush_after")
|
|
2304
2303
|
|
|
2305
|
-
@property
|
|
2304
|
+
@_builtins.property
|
|
2306
2305
|
@pulumi.getter(name="bgwriterLruMaxpages")
|
|
2307
|
-
def bgwriter_lru_maxpages(self) -> pulumi.Output[
|
|
2306
|
+
def bgwriter_lru_maxpages(self) -> pulumi.Output[_builtins.int]:
|
|
2308
2307
|
"""
|
|
2309
2308
|
The maximum number of buffers that the background writer can write. Setting this to zero disables background writing. Default is 100.
|
|
2310
2309
|
"""
|
|
2311
2310
|
return pulumi.get(self, "bgwriter_lru_maxpages")
|
|
2312
2311
|
|
|
2313
|
-
@property
|
|
2312
|
+
@_builtins.property
|
|
2314
2313
|
@pulumi.getter(name="bgwriterLruMultiplier")
|
|
2315
|
-
def bgwriter_lru_multiplier(self) -> pulumi.Output[
|
|
2314
|
+
def bgwriter_lru_multiplier(self) -> pulumi.Output[_builtins.float]:
|
|
2316
2315
|
"""
|
|
2317
2316
|
The average recent need for new buffers is multiplied by bgwriter_lru_multiplier to arrive at an estimate of the number that will be needed during the next round, (up to bgwriter_lru_maxpages). 1.0 represents a “just in time” policy of writing exactly the number of buffers predicted to be needed. Larger values provide some cushion against spikes in demand, while smaller values intentionally leave writes to be done by server processes. The default is 2.0.
|
|
2318
2317
|
"""
|
|
2319
2318
|
return pulumi.get(self, "bgwriter_lru_multiplier")
|
|
2320
2319
|
|
|
2321
|
-
@property
|
|
2320
|
+
@_builtins.property
|
|
2322
2321
|
@pulumi.getter(name="clusterId")
|
|
2323
|
-
def cluster_id(self) -> pulumi.Output[
|
|
2322
|
+
def cluster_id(self) -> pulumi.Output[_builtins.str]:
|
|
2324
2323
|
"""
|
|
2325
2324
|
The ID of the target PostgreSQL cluster.
|
|
2326
2325
|
"""
|
|
2327
2326
|
return pulumi.get(self, "cluster_id")
|
|
2328
2327
|
|
|
2329
|
-
@property
|
|
2328
|
+
@_builtins.property
|
|
2330
2329
|
@pulumi.getter(name="deadlockTimeout")
|
|
2331
|
-
def deadlock_timeout(self) -> pulumi.Output[
|
|
2330
|
+
def deadlock_timeout(self) -> pulumi.Output[_builtins.int]:
|
|
2332
2331
|
"""
|
|
2333
2332
|
The amount of time, in milliseconds, to wait on a lock before checking to see if there is a deadlock condition.
|
|
2334
2333
|
"""
|
|
2335
2334
|
return pulumi.get(self, "deadlock_timeout")
|
|
2336
2335
|
|
|
2337
|
-
@property
|
|
2336
|
+
@_builtins.property
|
|
2338
2337
|
@pulumi.getter(name="defaultToastCompression")
|
|
2339
|
-
def default_toast_compression(self) -> pulumi.Output[
|
|
2338
|
+
def default_toast_compression(self) -> pulumi.Output[_builtins.str]:
|
|
2340
2339
|
"""
|
|
2341
2340
|
Specifies the default TOAST compression method for values of compressible columns (the default is lz4). Supported values are: `lz4`, `pglz`.
|
|
2342
2341
|
"""
|
|
2343
2342
|
return pulumi.get(self, "default_toast_compression")
|
|
2344
2343
|
|
|
2345
|
-
@property
|
|
2344
|
+
@_builtins.property
|
|
2346
2345
|
@pulumi.getter(name="idleInTransactionSessionTimeout")
|
|
2347
|
-
def idle_in_transaction_session_timeout(self) -> pulumi.Output[
|
|
2346
|
+
def idle_in_transaction_session_timeout(self) -> pulumi.Output[_builtins.int]:
|
|
2348
2347
|
"""
|
|
2349
2348
|
Time out sessions with open transactions after this number of milliseconds
|
|
2350
2349
|
"""
|
|
2351
2350
|
return pulumi.get(self, "idle_in_transaction_session_timeout")
|
|
2352
2351
|
|
|
2353
|
-
@property
|
|
2352
|
+
@_builtins.property
|
|
2354
2353
|
@pulumi.getter
|
|
2355
|
-
def jit(self) -> pulumi.Output[
|
|
2354
|
+
def jit(self) -> pulumi.Output[_builtins.bool]:
|
|
2356
2355
|
"""
|
|
2357
2356
|
Activates, in a boolean, the system-wide use of Just-in-Time Compilation (JIT).
|
|
2358
2357
|
"""
|
|
2359
2358
|
return pulumi.get(self, "jit")
|
|
2360
2359
|
|
|
2361
|
-
@property
|
|
2360
|
+
@_builtins.property
|
|
2362
2361
|
@pulumi.getter(name="logAutovacuumMinDuration")
|
|
2363
|
-
def log_autovacuum_min_duration(self) -> pulumi.Output[
|
|
2362
|
+
def log_autovacuum_min_duration(self) -> pulumi.Output[_builtins.int]:
|
|
2364
2363
|
"""
|
|
2365
2364
|
Causes each action executed by autovacuum to be logged if it ran for at least the specified number of milliseconds. Setting this to zero logs all autovacuum actions. Minus-one (the default) disables logging autovacuum actions.
|
|
2366
2365
|
"""
|
|
2367
2366
|
return pulumi.get(self, "log_autovacuum_min_duration")
|
|
2368
2367
|
|
|
2369
|
-
@property
|
|
2368
|
+
@_builtins.property
|
|
2370
2369
|
@pulumi.getter(name="logErrorVerbosity")
|
|
2371
|
-
def log_error_verbosity(self) -> pulumi.Output[
|
|
2370
|
+
def log_error_verbosity(self) -> pulumi.Output[_builtins.str]:
|
|
2372
2371
|
"""
|
|
2373
2372
|
Controls the amount of detail written in the server log for each message that is logged. Supported values are: `TERSE`, `DEFAULT`, `VERBOSE`.
|
|
2374
2373
|
"""
|
|
2375
2374
|
return pulumi.get(self, "log_error_verbosity")
|
|
2376
2375
|
|
|
2377
|
-
@property
|
|
2376
|
+
@_builtins.property
|
|
2378
2377
|
@pulumi.getter(name="logLinePrefix")
|
|
2379
|
-
def log_line_prefix(self) -> pulumi.Output[
|
|
2378
|
+
def log_line_prefix(self) -> pulumi.Output[_builtins.str]:
|
|
2380
2379
|
"""
|
|
2381
2380
|
Selects one of the available log-formats. These can support popular log analyzers like pgbadger, pganalyze, etc. Supported values are: `pid=%p,user=%u,db=%d,app=%a,client=%h`, `%m [%p] %q[user=%u,db=%d,app=%a]`, `%t [%p]: [%l-1] user=%u,db=%d,app=%a,client=%h`.
|
|
2382
2381
|
"""
|
|
2383
2382
|
return pulumi.get(self, "log_line_prefix")
|
|
2384
2383
|
|
|
2385
|
-
@property
|
|
2384
|
+
@_builtins.property
|
|
2386
2385
|
@pulumi.getter(name="logMinDurationStatement")
|
|
2387
|
-
def log_min_duration_statement(self) -> pulumi.Output[
|
|
2386
|
+
def log_min_duration_statement(self) -> pulumi.Output[_builtins.int]:
|
|
2388
2387
|
"""
|
|
2389
2388
|
Log statements that take more than this number of milliseconds to run. If -1, disables.
|
|
2390
2389
|
"""
|
|
2391
2390
|
return pulumi.get(self, "log_min_duration_statement")
|
|
2392
2391
|
|
|
2393
|
-
@property
|
|
2392
|
+
@_builtins.property
|
|
2394
2393
|
@pulumi.getter(name="maxFilesPerProcess")
|
|
2395
|
-
def max_files_per_process(self) -> pulumi.Output[
|
|
2394
|
+
def max_files_per_process(self) -> pulumi.Output[_builtins.int]:
|
|
2396
2395
|
"""
|
|
2397
2396
|
PostgreSQL maximum number of files that can be open per process.
|
|
2398
2397
|
"""
|
|
2399
2398
|
return pulumi.get(self, "max_files_per_process")
|
|
2400
2399
|
|
|
2401
|
-
@property
|
|
2400
|
+
@_builtins.property
|
|
2402
2401
|
@pulumi.getter(name="maxLocksPerTransaction")
|
|
2403
|
-
def max_locks_per_transaction(self) -> pulumi.Output[
|
|
2402
|
+
def max_locks_per_transaction(self) -> pulumi.Output[_builtins.int]:
|
|
2404
2403
|
"""
|
|
2405
2404
|
PostgreSQL maximum locks per transaction. Once increased, this parameter cannot be lowered from its set value.
|
|
2406
2405
|
"""
|
|
2407
2406
|
return pulumi.get(self, "max_locks_per_transaction")
|
|
2408
2407
|
|
|
2409
|
-
@property
|
|
2408
|
+
@_builtins.property
|
|
2410
2409
|
@pulumi.getter(name="maxLogicalReplicationWorkers")
|
|
2411
|
-
def max_logical_replication_workers(self) -> pulumi.Output[
|
|
2410
|
+
def max_logical_replication_workers(self) -> pulumi.Output[_builtins.int]:
|
|
2412
2411
|
"""
|
|
2413
2412
|
PostgreSQL maximum logical replication workers (taken from the pool of max_parallel_workers).
|
|
2414
2413
|
"""
|
|
2415
2414
|
return pulumi.get(self, "max_logical_replication_workers")
|
|
2416
2415
|
|
|
2417
|
-
@property
|
|
2416
|
+
@_builtins.property
|
|
2418
2417
|
@pulumi.getter(name="maxParallelWorkers")
|
|
2419
|
-
def max_parallel_workers(self) -> pulumi.Output[
|
|
2418
|
+
def max_parallel_workers(self) -> pulumi.Output[_builtins.int]:
|
|
2420
2419
|
"""
|
|
2421
2420
|
Sets the maximum number of workers that the system can support for parallel queries.
|
|
2422
2421
|
"""
|
|
2423
2422
|
return pulumi.get(self, "max_parallel_workers")
|
|
2424
2423
|
|
|
2425
|
-
@property
|
|
2424
|
+
@_builtins.property
|
|
2426
2425
|
@pulumi.getter(name="maxParallelWorkersPerGather")
|
|
2427
|
-
def max_parallel_workers_per_gather(self) -> pulumi.Output[
|
|
2426
|
+
def max_parallel_workers_per_gather(self) -> pulumi.Output[_builtins.int]:
|
|
2428
2427
|
"""
|
|
2429
2428
|
Sets the maximum number of workers that can be started by a single Gather or Gather Merge node.
|
|
2430
2429
|
"""
|
|
2431
2430
|
return pulumi.get(self, "max_parallel_workers_per_gather")
|
|
2432
2431
|
|
|
2433
|
-
@property
|
|
2432
|
+
@_builtins.property
|
|
2434
2433
|
@pulumi.getter(name="maxPredLocksPerTransaction")
|
|
2435
|
-
def max_pred_locks_per_transaction(self) -> pulumi.Output[
|
|
2434
|
+
def max_pred_locks_per_transaction(self) -> pulumi.Output[_builtins.int]:
|
|
2436
2435
|
"""
|
|
2437
2436
|
PostgreSQL maximum predicate locks per transaction.
|
|
2438
2437
|
"""
|
|
2439
2438
|
return pulumi.get(self, "max_pred_locks_per_transaction")
|
|
2440
2439
|
|
|
2441
|
-
@property
|
|
2440
|
+
@_builtins.property
|
|
2442
2441
|
@pulumi.getter(name="maxPreparedTransactions")
|
|
2443
|
-
def max_prepared_transactions(self) -> pulumi.Output[
|
|
2442
|
+
def max_prepared_transactions(self) -> pulumi.Output[_builtins.int]:
|
|
2444
2443
|
"""
|
|
2445
2444
|
PostgreSQL maximum prepared transactions. Once increased, this parameter cannot be lowered from its set value.
|
|
2446
2445
|
"""
|
|
2447
2446
|
return pulumi.get(self, "max_prepared_transactions")
|
|
2448
2447
|
|
|
2449
|
-
@property
|
|
2448
|
+
@_builtins.property
|
|
2450
2449
|
@pulumi.getter(name="maxReplicationSlots")
|
|
2451
|
-
def max_replication_slots(self) -> pulumi.Output[
|
|
2450
|
+
def max_replication_slots(self) -> pulumi.Output[_builtins.int]:
|
|
2452
2451
|
"""
|
|
2453
2452
|
PostgreSQL maximum replication slots.
|
|
2454
2453
|
"""
|
|
2455
2454
|
return pulumi.get(self, "max_replication_slots")
|
|
2456
2455
|
|
|
2457
|
-
@property
|
|
2456
|
+
@_builtins.property
|
|
2458
2457
|
@pulumi.getter(name="maxStackDepth")
|
|
2459
|
-
def max_stack_depth(self) -> pulumi.Output[
|
|
2458
|
+
def max_stack_depth(self) -> pulumi.Output[_builtins.int]:
|
|
2460
2459
|
"""
|
|
2461
2460
|
Maximum depth of the stack in bytes.
|
|
2462
2461
|
"""
|
|
2463
2462
|
return pulumi.get(self, "max_stack_depth")
|
|
2464
2463
|
|
|
2465
|
-
@property
|
|
2464
|
+
@_builtins.property
|
|
2466
2465
|
@pulumi.getter(name="maxStandbyArchiveDelay")
|
|
2467
|
-
def max_standby_archive_delay(self) -> pulumi.Output[
|
|
2466
|
+
def max_standby_archive_delay(self) -> pulumi.Output[_builtins.int]:
|
|
2468
2467
|
"""
|
|
2469
2468
|
Max standby archive delay in milliseconds.
|
|
2470
2469
|
"""
|
|
2471
2470
|
return pulumi.get(self, "max_standby_archive_delay")
|
|
2472
2471
|
|
|
2473
|
-
@property
|
|
2472
|
+
@_builtins.property
|
|
2474
2473
|
@pulumi.getter(name="maxStandbyStreamingDelay")
|
|
2475
|
-
def max_standby_streaming_delay(self) -> pulumi.Output[
|
|
2474
|
+
def max_standby_streaming_delay(self) -> pulumi.Output[_builtins.int]:
|
|
2476
2475
|
"""
|
|
2477
2476
|
Max standby streaming delay in milliseconds.
|
|
2478
2477
|
"""
|
|
2479
2478
|
return pulumi.get(self, "max_standby_streaming_delay")
|
|
2480
2479
|
|
|
2481
|
-
@property
|
|
2480
|
+
@_builtins.property
|
|
2482
2481
|
@pulumi.getter(name="maxWalSenders")
|
|
2483
|
-
def max_wal_senders(self) -> pulumi.Output[
|
|
2482
|
+
def max_wal_senders(self) -> pulumi.Output[_builtins.int]:
|
|
2484
2483
|
"""
|
|
2485
2484
|
PostgreSQL maximum WAL senders. Once increased, this parameter cannot be lowered from its set value.
|
|
2486
2485
|
"""
|
|
2487
2486
|
return pulumi.get(self, "max_wal_senders")
|
|
2488
2487
|
|
|
2489
|
-
@property
|
|
2488
|
+
@_builtins.property
|
|
2490
2489
|
@pulumi.getter(name="maxWorkerProcesses")
|
|
2491
|
-
def max_worker_processes(self) -> pulumi.Output[
|
|
2490
|
+
def max_worker_processes(self) -> pulumi.Output[_builtins.int]:
|
|
2492
2491
|
"""
|
|
2493
2492
|
Sets the maximum number of background processes that the system can support. Once increased, this parameter cannot be lowered from its set value.
|
|
2494
2493
|
"""
|
|
2495
2494
|
return pulumi.get(self, "max_worker_processes")
|
|
2496
2495
|
|
|
2497
|
-
@property
|
|
2496
|
+
@_builtins.property
|
|
2498
2497
|
@pulumi.getter(name="pgPartmanBgwInterval")
|
|
2499
|
-
def pg_partman_bgw_interval(self) -> pulumi.Output[
|
|
2498
|
+
def pg_partman_bgw_interval(self) -> pulumi.Output[_builtins.int]:
|
|
2500
2499
|
"""
|
|
2501
2500
|
Sets the time interval to run pg_partman's scheduled tasks.
|
|
2502
2501
|
"""
|
|
2503
2502
|
return pulumi.get(self, "pg_partman_bgw_interval")
|
|
2504
2503
|
|
|
2505
|
-
@property
|
|
2504
|
+
@_builtins.property
|
|
2506
2505
|
@pulumi.getter(name="pgPartmanBgwRole")
|
|
2507
|
-
def pg_partman_bgw_role(self) -> pulumi.Output[
|
|
2506
|
+
def pg_partman_bgw_role(self) -> pulumi.Output[_builtins.str]:
|
|
2508
2507
|
"""
|
|
2509
2508
|
Controls which role to use for pg_partman's scheduled background tasks. Must consist of alpha-numeric characters, dots, underscores, or dashes. May not start with dash or dot. Maximum of 64 characters.
|
|
2510
2509
|
"""
|
|
2511
2510
|
return pulumi.get(self, "pg_partman_bgw_role")
|
|
2512
2511
|
|
|
2513
|
-
@property
|
|
2512
|
+
@_builtins.property
|
|
2514
2513
|
@pulumi.getter(name="pgStatStatementsTrack")
|
|
2515
|
-
def pg_stat_statements_track(self) -> pulumi.Output[
|
|
2514
|
+
def pg_stat_statements_track(self) -> pulumi.Output[_builtins.str]:
|
|
2516
2515
|
"""
|
|
2517
2516
|
Controls which statements are counted. Specify 'top' to track top-level statements (those issued directly by clients), 'all' to also track nested statements (such as statements invoked within functions), or 'none' to disable statement statistics collection. The default value is top. Supported values are: `all`, `top`, `none`.
|
|
2518
2517
|
"""
|
|
2519
2518
|
return pulumi.get(self, "pg_stat_statements_track")
|
|
2520
2519
|
|
|
2521
|
-
@property
|
|
2520
|
+
@_builtins.property
|
|
2522
2521
|
@pulumi.getter
|
|
2523
2522
|
def pgbouncers(self) -> pulumi.Output[Sequence['outputs.DatabasePostgresqlConfigPgbouncer']]:
|
|
2524
2523
|
"""
|
|
@@ -2526,23 +2525,23 @@ class DatabasePostgresqlConfig(pulumi.CustomResource):
|
|
|
2526
2525
|
"""
|
|
2527
2526
|
return pulumi.get(self, "pgbouncers")
|
|
2528
2527
|
|
|
2529
|
-
@property
|
|
2528
|
+
@_builtins.property
|
|
2530
2529
|
@pulumi.getter(name="sharedBuffersPercentage")
|
|
2531
|
-
def shared_buffers_percentage(self) -> pulumi.Output[
|
|
2530
|
+
def shared_buffers_percentage(self) -> pulumi.Output[_builtins.float]:
|
|
2532
2531
|
"""
|
|
2533
2532
|
Percentage of total RAM that the database server uses for shared memory buffers. Valid range is 20-60 (float), which corresponds to 20% - 60%. This setting adjusts the shared_buffers configuration value.
|
|
2534
2533
|
"""
|
|
2535
2534
|
return pulumi.get(self, "shared_buffers_percentage")
|
|
2536
2535
|
|
|
2537
|
-
@property
|
|
2536
|
+
@_builtins.property
|
|
2538
2537
|
@pulumi.getter(name="tempFileLimit")
|
|
2539
|
-
def temp_file_limit(self) -> pulumi.Output[
|
|
2538
|
+
def temp_file_limit(self) -> pulumi.Output[_builtins.int]:
|
|
2540
2539
|
"""
|
|
2541
2540
|
PostgreSQL temporary file limit in KiB. If -1, sets to unlimited.
|
|
2542
2541
|
"""
|
|
2543
2542
|
return pulumi.get(self, "temp_file_limit")
|
|
2544
2543
|
|
|
2545
|
-
@property
|
|
2544
|
+
@_builtins.property
|
|
2546
2545
|
@pulumi.getter
|
|
2547
2546
|
def timescaledbs(self) -> pulumi.Output[Sequence['outputs.DatabasePostgresqlConfigTimescaledb']]:
|
|
2548
2547
|
"""
|
|
@@ -2550,65 +2549,65 @@ class DatabasePostgresqlConfig(pulumi.CustomResource):
|
|
|
2550
2549
|
"""
|
|
2551
2550
|
return pulumi.get(self, "timescaledbs")
|
|
2552
2551
|
|
|
2553
|
-
@property
|
|
2552
|
+
@_builtins.property
|
|
2554
2553
|
@pulumi.getter
|
|
2555
|
-
def timezone(self) -> pulumi.Output[
|
|
2554
|
+
def timezone(self) -> pulumi.Output[_builtins.str]:
|
|
2556
2555
|
"""
|
|
2557
2556
|
PostgreSQL service timezone
|
|
2558
2557
|
"""
|
|
2559
2558
|
return pulumi.get(self, "timezone")
|
|
2560
2559
|
|
|
2561
|
-
@property
|
|
2560
|
+
@_builtins.property
|
|
2562
2561
|
@pulumi.getter(name="trackActivityQuerySize")
|
|
2563
|
-
def track_activity_query_size(self) -> pulumi.Output[
|
|
2562
|
+
def track_activity_query_size(self) -> pulumi.Output[_builtins.int]:
|
|
2564
2563
|
"""
|
|
2565
2564
|
Specifies the number of bytes reserved to track the currently executing command for each active session.
|
|
2566
2565
|
"""
|
|
2567
2566
|
return pulumi.get(self, "track_activity_query_size")
|
|
2568
2567
|
|
|
2569
|
-
@property
|
|
2568
|
+
@_builtins.property
|
|
2570
2569
|
@pulumi.getter(name="trackCommitTimestamp")
|
|
2571
|
-
def track_commit_timestamp(self) -> pulumi.Output[
|
|
2570
|
+
def track_commit_timestamp(self) -> pulumi.Output[_builtins.str]:
|
|
2572
2571
|
"""
|
|
2573
2572
|
Record commit time of transactions. The default value is top. Supported values are: `off`, `on`.
|
|
2574
2573
|
"""
|
|
2575
2574
|
return pulumi.get(self, "track_commit_timestamp")
|
|
2576
2575
|
|
|
2577
|
-
@property
|
|
2576
|
+
@_builtins.property
|
|
2578
2577
|
@pulumi.getter(name="trackFunctions")
|
|
2579
|
-
def track_functions(self) -> pulumi.Output[
|
|
2578
|
+
def track_functions(self) -> pulumi.Output[_builtins.str]:
|
|
2580
2579
|
"""
|
|
2581
2580
|
Enables tracking of function call counts and time used. The default value is top. Supported values are: `all`, `pl`, `none`.
|
|
2582
2581
|
"""
|
|
2583
2582
|
return pulumi.get(self, "track_functions")
|
|
2584
2583
|
|
|
2585
|
-
@property
|
|
2584
|
+
@_builtins.property
|
|
2586
2585
|
@pulumi.getter(name="trackIoTiming")
|
|
2587
|
-
def track_io_timing(self) -> pulumi.Output[
|
|
2586
|
+
def track_io_timing(self) -> pulumi.Output[_builtins.str]:
|
|
2588
2587
|
"""
|
|
2589
2588
|
Enables timing of database I/O calls. This parameter is off by default, because it will repeatedly query the operating system for the current time, which may cause significant overhead on some platforms. The default value is top. Supported values are: `off`, `on`.
|
|
2590
2589
|
"""
|
|
2591
2590
|
return pulumi.get(self, "track_io_timing")
|
|
2592
2591
|
|
|
2593
|
-
@property
|
|
2592
|
+
@_builtins.property
|
|
2594
2593
|
@pulumi.getter(name="walSenderTimeout")
|
|
2595
|
-
def wal_sender_timeout(self) -> pulumi.Output[
|
|
2594
|
+
def wal_sender_timeout(self) -> pulumi.Output[_builtins.int]:
|
|
2596
2595
|
"""
|
|
2597
2596
|
Terminate replication connections that are inactive for longer than this amount of time, in milliseconds. Setting this value to zero disables the timeout. Must be either 0 or between 5000 and 10800000.
|
|
2598
2597
|
"""
|
|
2599
2598
|
return pulumi.get(self, "wal_sender_timeout")
|
|
2600
2599
|
|
|
2601
|
-
@property
|
|
2600
|
+
@_builtins.property
|
|
2602
2601
|
@pulumi.getter(name="walWriterDelay")
|
|
2603
|
-
def wal_writer_delay(self) -> pulumi.Output[
|
|
2602
|
+
def wal_writer_delay(self) -> pulumi.Output[_builtins.int]:
|
|
2604
2603
|
"""
|
|
2605
2604
|
WAL flush interval in milliseconds. Note that setting this value to lower than the default 200ms may negatively impact performance
|
|
2606
2605
|
"""
|
|
2607
2606
|
return pulumi.get(self, "wal_writer_delay")
|
|
2608
2607
|
|
|
2609
|
-
@property
|
|
2608
|
+
@_builtins.property
|
|
2610
2609
|
@pulumi.getter(name="workMem")
|
|
2611
|
-
def work_mem(self) -> pulumi.Output[
|
|
2610
|
+
def work_mem(self) -> pulumi.Output[_builtins.int]:
|
|
2612
2611
|
"""
|
|
2613
2612
|
The maximum amount of memory, in MB, used by a query operation (such as a sort or hash table) before writing to temporary disk files. Default is 1MB + 0.075% of total RAM (up to 32MB).
|
|
2614
2613
|
"""
|