pulumi-digitalocean 4.33.0a1727374775__py3-none-any.whl → 4.34.0__py3-none-any.whl
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Potentially problematic release.
This version of pulumi-digitalocean might be problematic. Click here for more details.
- pulumi_digitalocean/__init__.py +9 -0
- pulumi_digitalocean/_inputs.py +3336 -71
- pulumi_digitalocean/_utilities.py +1 -1
- pulumi_digitalocean/app.py +7 -0
- pulumi_digitalocean/cdn.py +5 -0
- pulumi_digitalocean/certificate.py +5 -0
- pulumi_digitalocean/config/__init__.pyi +5 -0
- pulumi_digitalocean/config/vars.py +5 -0
- pulumi_digitalocean/container_registry.py +5 -0
- pulumi_digitalocean/container_registry_docker_credentials.py +5 -0
- pulumi_digitalocean/custom_image.py +5 -0
- pulumi_digitalocean/database_cluster.py +5 -0
- pulumi_digitalocean/database_connection_pool.py +5 -0
- pulumi_digitalocean/database_db.py +5 -0
- pulumi_digitalocean/database_firewall.py +5 -0
- pulumi_digitalocean/database_kafka_config.py +5 -0
- pulumi_digitalocean/database_kafka_topic.py +5 -0
- pulumi_digitalocean/database_mongodb_config.py +5 -0
- pulumi_digitalocean/database_mysql_config.py +5 -0
- pulumi_digitalocean/database_opensearch_config.py +2069 -0
- pulumi_digitalocean/database_postgresql_config.py +5 -0
- pulumi_digitalocean/database_redis_config.py +5 -0
- pulumi_digitalocean/database_replica.py +5 -0
- pulumi_digitalocean/database_user.py +5 -0
- pulumi_digitalocean/dns_record.py +5 -0
- pulumi_digitalocean/domain.py +5 -0
- pulumi_digitalocean/droplet.py +5 -0
- pulumi_digitalocean/droplet_snapshot.py +5 -0
- pulumi_digitalocean/firewall.py +5 -0
- pulumi_digitalocean/floating_ip.py +5 -0
- pulumi_digitalocean/floating_ip_assignment.py +5 -0
- pulumi_digitalocean/get_account.py +17 -4
- pulumi_digitalocean/get_app.py +23 -4
- pulumi_digitalocean/get_certificate.py +18 -4
- pulumi_digitalocean/get_container_registry.py +18 -4
- pulumi_digitalocean/get_database_ca.py +13 -4
- pulumi_digitalocean/get_database_cluster.py +38 -4
- pulumi_digitalocean/get_database_connection_pool.py +24 -4
- pulumi_digitalocean/get_database_replica.py +28 -4
- pulumi_digitalocean/get_database_user.py +20 -4
- pulumi_digitalocean/get_domain.py +15 -4
- pulumi_digitalocean/get_domains.py +15 -4
- pulumi_digitalocean/get_droplet.py +38 -4
- pulumi_digitalocean/get_droplet_snapshot.py +23 -4
- pulumi_digitalocean/get_droplets.py +15 -4
- pulumi_digitalocean/get_firewall.py +24 -4
- pulumi_digitalocean/get_floating_ip.py +15 -4
- pulumi_digitalocean/get_image.py +29 -4
- pulumi_digitalocean/get_images.py +15 -4
- pulumi_digitalocean/get_kubernetes_cluster.py +31 -4
- pulumi_digitalocean/get_kubernetes_versions.py +14 -4
- pulumi_digitalocean/get_load_balancer.py +38 -4
- pulumi_digitalocean/get_project.py +22 -4
- pulumi_digitalocean/get_projects.py +15 -4
- pulumi_digitalocean/get_record.py +22 -4
- pulumi_digitalocean/get_records.py +17 -4
- pulumi_digitalocean/get_region.py +16 -4
- pulumi_digitalocean/get_regions.py +15 -4
- pulumi_digitalocean/get_reserved_ip.py +15 -4
- pulumi_digitalocean/get_sizes.py +15 -4
- pulumi_digitalocean/get_spaces_bucket.py +17 -4
- pulumi_digitalocean/get_spaces_bucket_object.py +33 -4
- pulumi_digitalocean/get_spaces_bucket_objects.py +25 -4
- pulumi_digitalocean/get_spaces_buckets.py +15 -4
- pulumi_digitalocean/get_ssh_key.py +14 -4
- pulumi_digitalocean/get_ssh_keys.py +15 -4
- pulumi_digitalocean/get_tag.py +18 -4
- pulumi_digitalocean/get_tags.py +15 -4
- pulumi_digitalocean/get_volume.py +22 -4
- pulumi_digitalocean/get_volume_snapshot.py +24 -4
- pulumi_digitalocean/get_vpc.py +20 -4
- pulumi_digitalocean/get_vpc_peering.py +17 -4
- pulumi_digitalocean/kubernetes_cluster.py +53 -10
- pulumi_digitalocean/kubernetes_node_pool.py +5 -0
- pulumi_digitalocean/load_balancer.py +5 -0
- pulumi_digitalocean/monitor_alert.py +5 -0
- pulumi_digitalocean/outputs.py +13 -8
- pulumi_digitalocean/project.py +5 -0
- pulumi_digitalocean/project_resources.py +5 -0
- pulumi_digitalocean/provider.py +5 -0
- pulumi_digitalocean/pulumi-plugin.json +1 -1
- pulumi_digitalocean/reserved_ip.py +5 -0
- pulumi_digitalocean/reserved_ip_assignment.py +5 -0
- pulumi_digitalocean/spaces_bucket.py +12 -7
- pulumi_digitalocean/spaces_bucket_cors_configuration.py +5 -0
- pulumi_digitalocean/spaces_bucket_object.py +5 -0
- pulumi_digitalocean/spaces_bucket_policy.py +5 -0
- pulumi_digitalocean/ssh_key.py +5 -0
- pulumi_digitalocean/tag.py +5 -0
- pulumi_digitalocean/uptime_alert.py +5 -0
- pulumi_digitalocean/uptime_check.py +5 -0
- pulumi_digitalocean/volume.py +5 -0
- pulumi_digitalocean/volume_attachment.py +5 -0
- pulumi_digitalocean/volume_snapshot.py +5 -0
- pulumi_digitalocean/vpc.py +5 -0
- pulumi_digitalocean/vpc_peering.py +5 -0
- {pulumi_digitalocean-4.33.0a1727374775.dist-info → pulumi_digitalocean-4.34.0.dist-info}/METADATA +3 -2
- pulumi_digitalocean-4.34.0.dist-info/RECORD +103 -0
- {pulumi_digitalocean-4.33.0a1727374775.dist-info → pulumi_digitalocean-4.34.0.dist-info}/WHEEL +1 -1
- pulumi_digitalocean-4.33.0a1727374775.dist-info/RECORD +0 -102
- {pulumi_digitalocean-4.33.0a1727374775.dist-info → pulumi_digitalocean-4.34.0.dist-info}/top_level.txt +0 -0
pulumi_digitalocean/_inputs.py
CHANGED
|
@@ -4,161 +4,331 @@
|
|
|
4
4
|
|
|
5
5
|
import copy
|
|
6
6
|
import warnings
|
|
7
|
+
import sys
|
|
7
8
|
import pulumi
|
|
8
9
|
import pulumi.runtime
|
|
9
10
|
from typing import Any, Mapping, Optional, Sequence, Union, overload
|
|
11
|
+
if sys.version_info >= (3, 11):
|
|
12
|
+
from typing import NotRequired, TypedDict, TypeAlias
|
|
13
|
+
else:
|
|
14
|
+
from typing_extensions import NotRequired, TypedDict, TypeAlias
|
|
10
15
|
from . import _utilities
|
|
11
16
|
from ._enums import *
|
|
12
17
|
|
|
13
18
|
__all__ = [
|
|
14
19
|
'AppDedicatedIpArgs',
|
|
20
|
+
'AppDedicatedIpArgsDict',
|
|
15
21
|
'AppSpecArgs',
|
|
22
|
+
'AppSpecArgsDict',
|
|
16
23
|
'AppSpecAlertArgs',
|
|
24
|
+
'AppSpecAlertArgsDict',
|
|
17
25
|
'AppSpecDatabaseArgs',
|
|
26
|
+
'AppSpecDatabaseArgsDict',
|
|
18
27
|
'AppSpecDomainNameArgs',
|
|
28
|
+
'AppSpecDomainNameArgsDict',
|
|
19
29
|
'AppSpecEgressArgs',
|
|
30
|
+
'AppSpecEgressArgsDict',
|
|
20
31
|
'AppSpecEnvArgs',
|
|
32
|
+
'AppSpecEnvArgsDict',
|
|
21
33
|
'AppSpecFunctionArgs',
|
|
34
|
+
'AppSpecFunctionArgsDict',
|
|
22
35
|
'AppSpecFunctionAlertArgs',
|
|
36
|
+
'AppSpecFunctionAlertArgsDict',
|
|
23
37
|
'AppSpecFunctionCorsArgs',
|
|
38
|
+
'AppSpecFunctionCorsArgsDict',
|
|
24
39
|
'AppSpecFunctionCorsAllowOriginsArgs',
|
|
40
|
+
'AppSpecFunctionCorsAllowOriginsArgsDict',
|
|
25
41
|
'AppSpecFunctionEnvArgs',
|
|
42
|
+
'AppSpecFunctionEnvArgsDict',
|
|
26
43
|
'AppSpecFunctionGitArgs',
|
|
44
|
+
'AppSpecFunctionGitArgsDict',
|
|
27
45
|
'AppSpecFunctionGithubArgs',
|
|
46
|
+
'AppSpecFunctionGithubArgsDict',
|
|
28
47
|
'AppSpecFunctionGitlabArgs',
|
|
48
|
+
'AppSpecFunctionGitlabArgsDict',
|
|
29
49
|
'AppSpecFunctionLogDestinationArgs',
|
|
50
|
+
'AppSpecFunctionLogDestinationArgsDict',
|
|
30
51
|
'AppSpecFunctionLogDestinationDatadogArgs',
|
|
52
|
+
'AppSpecFunctionLogDestinationDatadogArgsDict',
|
|
31
53
|
'AppSpecFunctionLogDestinationLogtailArgs',
|
|
54
|
+
'AppSpecFunctionLogDestinationLogtailArgsDict',
|
|
32
55
|
'AppSpecFunctionLogDestinationOpenSearchArgs',
|
|
56
|
+
'AppSpecFunctionLogDestinationOpenSearchArgsDict',
|
|
33
57
|
'AppSpecFunctionLogDestinationOpenSearchBasicAuthArgs',
|
|
58
|
+
'AppSpecFunctionLogDestinationOpenSearchBasicAuthArgsDict',
|
|
34
59
|
'AppSpecFunctionLogDestinationPapertrailArgs',
|
|
60
|
+
'AppSpecFunctionLogDestinationPapertrailArgsDict',
|
|
35
61
|
'AppSpecFunctionRouteArgs',
|
|
62
|
+
'AppSpecFunctionRouteArgsDict',
|
|
36
63
|
'AppSpecIngressArgs',
|
|
64
|
+
'AppSpecIngressArgsDict',
|
|
37
65
|
'AppSpecIngressRuleArgs',
|
|
66
|
+
'AppSpecIngressRuleArgsDict',
|
|
38
67
|
'AppSpecIngressRuleComponentArgs',
|
|
68
|
+
'AppSpecIngressRuleComponentArgsDict',
|
|
39
69
|
'AppSpecIngressRuleCorsArgs',
|
|
70
|
+
'AppSpecIngressRuleCorsArgsDict',
|
|
40
71
|
'AppSpecIngressRuleCorsAllowOriginsArgs',
|
|
72
|
+
'AppSpecIngressRuleCorsAllowOriginsArgsDict',
|
|
41
73
|
'AppSpecIngressRuleMatchArgs',
|
|
74
|
+
'AppSpecIngressRuleMatchArgsDict',
|
|
42
75
|
'AppSpecIngressRuleMatchPathArgs',
|
|
76
|
+
'AppSpecIngressRuleMatchPathArgsDict',
|
|
43
77
|
'AppSpecIngressRuleRedirectArgs',
|
|
78
|
+
'AppSpecIngressRuleRedirectArgsDict',
|
|
44
79
|
'AppSpecJobArgs',
|
|
80
|
+
'AppSpecJobArgsDict',
|
|
45
81
|
'AppSpecJobAlertArgs',
|
|
82
|
+
'AppSpecJobAlertArgsDict',
|
|
46
83
|
'AppSpecJobEnvArgs',
|
|
84
|
+
'AppSpecJobEnvArgsDict',
|
|
47
85
|
'AppSpecJobGitArgs',
|
|
86
|
+
'AppSpecJobGitArgsDict',
|
|
48
87
|
'AppSpecJobGithubArgs',
|
|
88
|
+
'AppSpecJobGithubArgsDict',
|
|
49
89
|
'AppSpecJobGitlabArgs',
|
|
90
|
+
'AppSpecJobGitlabArgsDict',
|
|
50
91
|
'AppSpecJobImageArgs',
|
|
92
|
+
'AppSpecJobImageArgsDict',
|
|
51
93
|
'AppSpecJobImageDeployOnPushArgs',
|
|
94
|
+
'AppSpecJobImageDeployOnPushArgsDict',
|
|
52
95
|
'AppSpecJobLogDestinationArgs',
|
|
96
|
+
'AppSpecJobLogDestinationArgsDict',
|
|
53
97
|
'AppSpecJobLogDestinationDatadogArgs',
|
|
98
|
+
'AppSpecJobLogDestinationDatadogArgsDict',
|
|
54
99
|
'AppSpecJobLogDestinationLogtailArgs',
|
|
100
|
+
'AppSpecJobLogDestinationLogtailArgsDict',
|
|
55
101
|
'AppSpecJobLogDestinationOpenSearchArgs',
|
|
102
|
+
'AppSpecJobLogDestinationOpenSearchArgsDict',
|
|
56
103
|
'AppSpecJobLogDestinationOpenSearchBasicAuthArgs',
|
|
104
|
+
'AppSpecJobLogDestinationOpenSearchBasicAuthArgsDict',
|
|
57
105
|
'AppSpecJobLogDestinationPapertrailArgs',
|
|
106
|
+
'AppSpecJobLogDestinationPapertrailArgsDict',
|
|
58
107
|
'AppSpecServiceArgs',
|
|
108
|
+
'AppSpecServiceArgsDict',
|
|
59
109
|
'AppSpecServiceAlertArgs',
|
|
110
|
+
'AppSpecServiceAlertArgsDict',
|
|
60
111
|
'AppSpecServiceAutoscalingArgs',
|
|
112
|
+
'AppSpecServiceAutoscalingArgsDict',
|
|
61
113
|
'AppSpecServiceAutoscalingMetricsArgs',
|
|
114
|
+
'AppSpecServiceAutoscalingMetricsArgsDict',
|
|
62
115
|
'AppSpecServiceAutoscalingMetricsCpuArgs',
|
|
116
|
+
'AppSpecServiceAutoscalingMetricsCpuArgsDict',
|
|
63
117
|
'AppSpecServiceCorsArgs',
|
|
118
|
+
'AppSpecServiceCorsArgsDict',
|
|
64
119
|
'AppSpecServiceCorsAllowOriginsArgs',
|
|
120
|
+
'AppSpecServiceCorsAllowOriginsArgsDict',
|
|
65
121
|
'AppSpecServiceEnvArgs',
|
|
122
|
+
'AppSpecServiceEnvArgsDict',
|
|
66
123
|
'AppSpecServiceGitArgs',
|
|
124
|
+
'AppSpecServiceGitArgsDict',
|
|
67
125
|
'AppSpecServiceGithubArgs',
|
|
126
|
+
'AppSpecServiceGithubArgsDict',
|
|
68
127
|
'AppSpecServiceGitlabArgs',
|
|
128
|
+
'AppSpecServiceGitlabArgsDict',
|
|
69
129
|
'AppSpecServiceHealthCheckArgs',
|
|
130
|
+
'AppSpecServiceHealthCheckArgsDict',
|
|
70
131
|
'AppSpecServiceImageArgs',
|
|
132
|
+
'AppSpecServiceImageArgsDict',
|
|
71
133
|
'AppSpecServiceImageDeployOnPushArgs',
|
|
134
|
+
'AppSpecServiceImageDeployOnPushArgsDict',
|
|
72
135
|
'AppSpecServiceLogDestinationArgs',
|
|
136
|
+
'AppSpecServiceLogDestinationArgsDict',
|
|
73
137
|
'AppSpecServiceLogDestinationDatadogArgs',
|
|
138
|
+
'AppSpecServiceLogDestinationDatadogArgsDict',
|
|
74
139
|
'AppSpecServiceLogDestinationLogtailArgs',
|
|
140
|
+
'AppSpecServiceLogDestinationLogtailArgsDict',
|
|
75
141
|
'AppSpecServiceLogDestinationOpenSearchArgs',
|
|
142
|
+
'AppSpecServiceLogDestinationOpenSearchArgsDict',
|
|
76
143
|
'AppSpecServiceLogDestinationOpenSearchBasicAuthArgs',
|
|
144
|
+
'AppSpecServiceLogDestinationOpenSearchBasicAuthArgsDict',
|
|
77
145
|
'AppSpecServiceLogDestinationPapertrailArgs',
|
|
146
|
+
'AppSpecServiceLogDestinationPapertrailArgsDict',
|
|
78
147
|
'AppSpecServiceRouteArgs',
|
|
148
|
+
'AppSpecServiceRouteArgsDict',
|
|
79
149
|
'AppSpecStaticSiteArgs',
|
|
150
|
+
'AppSpecStaticSiteArgsDict',
|
|
80
151
|
'AppSpecStaticSiteCorsArgs',
|
|
152
|
+
'AppSpecStaticSiteCorsArgsDict',
|
|
81
153
|
'AppSpecStaticSiteCorsAllowOriginsArgs',
|
|
154
|
+
'AppSpecStaticSiteCorsAllowOriginsArgsDict',
|
|
82
155
|
'AppSpecStaticSiteEnvArgs',
|
|
156
|
+
'AppSpecStaticSiteEnvArgsDict',
|
|
83
157
|
'AppSpecStaticSiteGitArgs',
|
|
158
|
+
'AppSpecStaticSiteGitArgsDict',
|
|
84
159
|
'AppSpecStaticSiteGithubArgs',
|
|
160
|
+
'AppSpecStaticSiteGithubArgsDict',
|
|
85
161
|
'AppSpecStaticSiteGitlabArgs',
|
|
162
|
+
'AppSpecStaticSiteGitlabArgsDict',
|
|
86
163
|
'AppSpecStaticSiteRouteArgs',
|
|
164
|
+
'AppSpecStaticSiteRouteArgsDict',
|
|
87
165
|
'AppSpecWorkerArgs',
|
|
166
|
+
'AppSpecWorkerArgsDict',
|
|
88
167
|
'AppSpecWorkerAlertArgs',
|
|
168
|
+
'AppSpecWorkerAlertArgsDict',
|
|
89
169
|
'AppSpecWorkerEnvArgs',
|
|
170
|
+
'AppSpecWorkerEnvArgsDict',
|
|
90
171
|
'AppSpecWorkerGitArgs',
|
|
172
|
+
'AppSpecWorkerGitArgsDict',
|
|
91
173
|
'AppSpecWorkerGithubArgs',
|
|
174
|
+
'AppSpecWorkerGithubArgsDict',
|
|
92
175
|
'AppSpecWorkerGitlabArgs',
|
|
176
|
+
'AppSpecWorkerGitlabArgsDict',
|
|
93
177
|
'AppSpecWorkerImageArgs',
|
|
178
|
+
'AppSpecWorkerImageArgsDict',
|
|
94
179
|
'AppSpecWorkerImageDeployOnPushArgs',
|
|
180
|
+
'AppSpecWorkerImageDeployOnPushArgsDict',
|
|
95
181
|
'AppSpecWorkerLogDestinationArgs',
|
|
182
|
+
'AppSpecWorkerLogDestinationArgsDict',
|
|
96
183
|
'AppSpecWorkerLogDestinationDatadogArgs',
|
|
184
|
+
'AppSpecWorkerLogDestinationDatadogArgsDict',
|
|
97
185
|
'AppSpecWorkerLogDestinationLogtailArgs',
|
|
186
|
+
'AppSpecWorkerLogDestinationLogtailArgsDict',
|
|
98
187
|
'AppSpecWorkerLogDestinationOpenSearchArgs',
|
|
188
|
+
'AppSpecWorkerLogDestinationOpenSearchArgsDict',
|
|
99
189
|
'AppSpecWorkerLogDestinationOpenSearchBasicAuthArgs',
|
|
190
|
+
'AppSpecWorkerLogDestinationOpenSearchBasicAuthArgsDict',
|
|
100
191
|
'AppSpecWorkerLogDestinationPapertrailArgs',
|
|
192
|
+
'AppSpecWorkerLogDestinationPapertrailArgsDict',
|
|
101
193
|
'DatabaseClusterBackupRestoreArgs',
|
|
194
|
+
'DatabaseClusterBackupRestoreArgsDict',
|
|
102
195
|
'DatabaseClusterMaintenanceWindowArgs',
|
|
196
|
+
'DatabaseClusterMaintenanceWindowArgsDict',
|
|
103
197
|
'DatabaseFirewallRuleArgs',
|
|
198
|
+
'DatabaseFirewallRuleArgsDict',
|
|
104
199
|
'DatabaseKafkaTopicConfigArgs',
|
|
200
|
+
'DatabaseKafkaTopicConfigArgsDict',
|
|
105
201
|
'DatabasePostgresqlConfigPgbouncerArgs',
|
|
202
|
+
'DatabasePostgresqlConfigPgbouncerArgsDict',
|
|
106
203
|
'DatabasePostgresqlConfigTimescaledbArgs',
|
|
204
|
+
'DatabasePostgresqlConfigTimescaledbArgsDict',
|
|
107
205
|
'DatabaseUserSettingArgs',
|
|
206
|
+
'DatabaseUserSettingArgsDict',
|
|
108
207
|
'DatabaseUserSettingAclArgs',
|
|
208
|
+
'DatabaseUserSettingAclArgsDict',
|
|
109
209
|
'DatabaseUserSettingOpensearchAclArgs',
|
|
210
|
+
'DatabaseUserSettingOpensearchAclArgsDict',
|
|
110
211
|
'FirewallInboundRuleArgs',
|
|
212
|
+
'FirewallInboundRuleArgsDict',
|
|
111
213
|
'FirewallOutboundRuleArgs',
|
|
214
|
+
'FirewallOutboundRuleArgsDict',
|
|
112
215
|
'FirewallPendingChangeArgs',
|
|
216
|
+
'FirewallPendingChangeArgsDict',
|
|
113
217
|
'KubernetesClusterKubeConfigArgs',
|
|
218
|
+
'KubernetesClusterKubeConfigArgsDict',
|
|
114
219
|
'KubernetesClusterMaintenancePolicyArgs',
|
|
220
|
+
'KubernetesClusterMaintenancePolicyArgsDict',
|
|
115
221
|
'KubernetesClusterNodePoolArgs',
|
|
222
|
+
'KubernetesClusterNodePoolArgsDict',
|
|
116
223
|
'KubernetesClusterNodePoolNodeArgs',
|
|
224
|
+
'KubernetesClusterNodePoolNodeArgsDict',
|
|
117
225
|
'KubernetesClusterNodePoolTaintArgs',
|
|
226
|
+
'KubernetesClusterNodePoolTaintArgsDict',
|
|
118
227
|
'KubernetesNodePoolNodeArgs',
|
|
228
|
+
'KubernetesNodePoolNodeArgsDict',
|
|
119
229
|
'KubernetesNodePoolTaintArgs',
|
|
230
|
+
'KubernetesNodePoolTaintArgsDict',
|
|
120
231
|
'LoadBalancerDomainArgs',
|
|
232
|
+
'LoadBalancerDomainArgsDict',
|
|
121
233
|
'LoadBalancerFirewallArgs',
|
|
234
|
+
'LoadBalancerFirewallArgsDict',
|
|
122
235
|
'LoadBalancerForwardingRuleArgs',
|
|
236
|
+
'LoadBalancerForwardingRuleArgsDict',
|
|
123
237
|
'LoadBalancerGlbSettingsArgs',
|
|
238
|
+
'LoadBalancerGlbSettingsArgsDict',
|
|
124
239
|
'LoadBalancerGlbSettingsCdnArgs',
|
|
240
|
+
'LoadBalancerGlbSettingsCdnArgsDict',
|
|
125
241
|
'LoadBalancerHealthcheckArgs',
|
|
242
|
+
'LoadBalancerHealthcheckArgsDict',
|
|
126
243
|
'LoadBalancerStickySessionsArgs',
|
|
244
|
+
'LoadBalancerStickySessionsArgsDict',
|
|
127
245
|
'MonitorAlertAlertsArgs',
|
|
246
|
+
'MonitorAlertAlertsArgsDict',
|
|
128
247
|
'MonitorAlertAlertsSlackArgs',
|
|
248
|
+
'MonitorAlertAlertsSlackArgsDict',
|
|
129
249
|
'SpacesBucketCorsConfigurationCorsRuleArgs',
|
|
250
|
+
'SpacesBucketCorsConfigurationCorsRuleArgsDict',
|
|
130
251
|
'SpacesBucketCorsRuleArgs',
|
|
252
|
+
'SpacesBucketCorsRuleArgsDict',
|
|
131
253
|
'SpacesBucketLifecycleRuleArgs',
|
|
254
|
+
'SpacesBucketLifecycleRuleArgsDict',
|
|
132
255
|
'SpacesBucketLifecycleRuleExpirationArgs',
|
|
256
|
+
'SpacesBucketLifecycleRuleExpirationArgsDict',
|
|
133
257
|
'SpacesBucketLifecycleRuleNoncurrentVersionExpirationArgs',
|
|
258
|
+
'SpacesBucketLifecycleRuleNoncurrentVersionExpirationArgsDict',
|
|
134
259
|
'SpacesBucketVersioningArgs',
|
|
260
|
+
'SpacesBucketVersioningArgsDict',
|
|
135
261
|
'UptimeAlertNotificationArgs',
|
|
262
|
+
'UptimeAlertNotificationArgsDict',
|
|
136
263
|
'UptimeAlertNotificationSlackArgs',
|
|
264
|
+
'UptimeAlertNotificationSlackArgsDict',
|
|
137
265
|
'GetAppDedicatedIpArgs',
|
|
266
|
+
'GetAppDedicatedIpArgsDict',
|
|
138
267
|
'GetDomainsFilterArgs',
|
|
268
|
+
'GetDomainsFilterArgsDict',
|
|
139
269
|
'GetDomainsSortArgs',
|
|
270
|
+
'GetDomainsSortArgsDict',
|
|
140
271
|
'GetDropletsFilterArgs',
|
|
272
|
+
'GetDropletsFilterArgsDict',
|
|
141
273
|
'GetDropletsSortArgs',
|
|
274
|
+
'GetDropletsSortArgsDict',
|
|
142
275
|
'GetFirewallInboundRuleArgs',
|
|
276
|
+
'GetFirewallInboundRuleArgsDict',
|
|
143
277
|
'GetFirewallOutboundRuleArgs',
|
|
278
|
+
'GetFirewallOutboundRuleArgsDict',
|
|
144
279
|
'GetImagesFilterArgs',
|
|
280
|
+
'GetImagesFilterArgsDict',
|
|
145
281
|
'GetImagesSortArgs',
|
|
282
|
+
'GetImagesSortArgsDict',
|
|
146
283
|
'GetProjectsFilterArgs',
|
|
284
|
+
'GetProjectsFilterArgsDict',
|
|
147
285
|
'GetProjectsSortArgs',
|
|
286
|
+
'GetProjectsSortArgsDict',
|
|
148
287
|
'GetRecordsFilterArgs',
|
|
288
|
+
'GetRecordsFilterArgsDict',
|
|
149
289
|
'GetRecordsSortArgs',
|
|
290
|
+
'GetRecordsSortArgsDict',
|
|
150
291
|
'GetRegionsFilterArgs',
|
|
292
|
+
'GetRegionsFilterArgsDict',
|
|
151
293
|
'GetRegionsSortArgs',
|
|
294
|
+
'GetRegionsSortArgsDict',
|
|
152
295
|
'GetSizesFilterArgs',
|
|
296
|
+
'GetSizesFilterArgsDict',
|
|
153
297
|
'GetSizesSortArgs',
|
|
298
|
+
'GetSizesSortArgsDict',
|
|
154
299
|
'GetSpacesBucketsFilterArgs',
|
|
300
|
+
'GetSpacesBucketsFilterArgsDict',
|
|
155
301
|
'GetSpacesBucketsSortArgs',
|
|
302
|
+
'GetSpacesBucketsSortArgsDict',
|
|
156
303
|
'GetSshKeysFilterArgs',
|
|
304
|
+
'GetSshKeysFilterArgsDict',
|
|
157
305
|
'GetSshKeysSortArgs',
|
|
306
|
+
'GetSshKeysSortArgsDict',
|
|
158
307
|
'GetTagsFilterArgs',
|
|
308
|
+
'GetTagsFilterArgsDict',
|
|
159
309
|
'GetTagsSortArgs',
|
|
310
|
+
'GetTagsSortArgsDict',
|
|
160
311
|
]
|
|
161
312
|
|
|
313
|
+
MYPY = False
|
|
314
|
+
|
|
315
|
+
if not MYPY:
|
|
316
|
+
class AppDedicatedIpArgsDict(TypedDict):
|
|
317
|
+
id: NotRequired[pulumi.Input[str]]
|
|
318
|
+
"""
|
|
319
|
+
The ID of the app.
|
|
320
|
+
"""
|
|
321
|
+
ip: NotRequired[pulumi.Input[str]]
|
|
322
|
+
"""
|
|
323
|
+
The IP address of the dedicated egress IP.
|
|
324
|
+
"""
|
|
325
|
+
status: NotRequired[pulumi.Input[str]]
|
|
326
|
+
"""
|
|
327
|
+
The status of the dedicated egress IP: 'UNKNOWN', 'ASSIGNING', 'ASSIGNED', or 'REMOVED'
|
|
328
|
+
"""
|
|
329
|
+
elif False:
|
|
330
|
+
AppDedicatedIpArgsDict: TypeAlias = Mapping[str, Any]
|
|
331
|
+
|
|
162
332
|
@pulumi.input_type
|
|
163
333
|
class AppDedicatedIpArgs:
|
|
164
334
|
def __init__(__self__, *,
|
|
@@ -214,6 +384,50 @@ class AppDedicatedIpArgs:
|
|
|
214
384
|
pulumi.set(self, "status", value)
|
|
215
385
|
|
|
216
386
|
|
|
387
|
+
if not MYPY:
|
|
388
|
+
class AppSpecArgsDict(TypedDict):
|
|
389
|
+
name: pulumi.Input[str]
|
|
390
|
+
"""
|
|
391
|
+
The name of the component.
|
|
392
|
+
"""
|
|
393
|
+
alerts: NotRequired[pulumi.Input[Sequence[pulumi.Input['AppSpecAlertArgsDict']]]]
|
|
394
|
+
"""
|
|
395
|
+
Describes an alert policy for the component.
|
|
396
|
+
"""
|
|
397
|
+
databases: NotRequired[pulumi.Input[Sequence[pulumi.Input['AppSpecDatabaseArgsDict']]]]
|
|
398
|
+
domain_names: NotRequired[pulumi.Input[Sequence[pulumi.Input['AppSpecDomainNameArgsDict']]]]
|
|
399
|
+
"""
|
|
400
|
+
Describes a domain where the application will be made available.
|
|
401
|
+
"""
|
|
402
|
+
domains: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
403
|
+
egresses: NotRequired[pulumi.Input[Sequence[pulumi.Input['AppSpecEgressArgsDict']]]]
|
|
404
|
+
"""
|
|
405
|
+
Specification for app egress configurations.
|
|
406
|
+
"""
|
|
407
|
+
envs: NotRequired[pulumi.Input[Sequence[pulumi.Input['AppSpecEnvArgsDict']]]]
|
|
408
|
+
"""
|
|
409
|
+
Describes an environment variable made available to an app competent.
|
|
410
|
+
"""
|
|
411
|
+
features: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
412
|
+
"""
|
|
413
|
+
A list of the features applied to the app. The default buildpack can be overridden here. List of available buildpacks can be found using the [doctl CLI](https://docs.digitalocean.com/reference/doctl/reference/apps/list-buildpacks/)
|
|
414
|
+
"""
|
|
415
|
+
functions: NotRequired[pulumi.Input[Sequence[pulumi.Input['AppSpecFunctionArgsDict']]]]
|
|
416
|
+
ingress: NotRequired[pulumi.Input['AppSpecIngressArgsDict']]
|
|
417
|
+
"""
|
|
418
|
+
Specification for component routing, rewrites, and redirects.
|
|
419
|
+
"""
|
|
420
|
+
jobs: NotRequired[pulumi.Input[Sequence[pulumi.Input['AppSpecJobArgsDict']]]]
|
|
421
|
+
region: NotRequired[pulumi.Input[str]]
|
|
422
|
+
"""
|
|
423
|
+
The slug for the DigitalOcean data center region hosting the app.
|
|
424
|
+
"""
|
|
425
|
+
services: NotRequired[pulumi.Input[Sequence[pulumi.Input['AppSpecServiceArgsDict']]]]
|
|
426
|
+
static_sites: NotRequired[pulumi.Input[Sequence[pulumi.Input['AppSpecStaticSiteArgsDict']]]]
|
|
427
|
+
workers: NotRequired[pulumi.Input[Sequence[pulumi.Input['AppSpecWorkerArgsDict']]]]
|
|
428
|
+
elif False:
|
|
429
|
+
AppSpecArgsDict: TypeAlias = Mapping[str, Any]
|
|
430
|
+
|
|
217
431
|
@pulumi.input_type
|
|
218
432
|
class AppSpecArgs:
|
|
219
433
|
def __init__(__self__, *,
|
|
@@ -436,6 +650,19 @@ class AppSpecArgs:
|
|
|
436
650
|
pulumi.set(self, "workers", value)
|
|
437
651
|
|
|
438
652
|
|
|
653
|
+
if not MYPY:
|
|
654
|
+
class AppSpecAlertArgsDict(TypedDict):
|
|
655
|
+
rule: pulumi.Input[str]
|
|
656
|
+
"""
|
|
657
|
+
The type of the alert to configure. Component app alert policies can be: `CPU_UTILIZATION`, `MEM_UTILIZATION`, or `RESTART_COUNT`.
|
|
658
|
+
"""
|
|
659
|
+
disabled: NotRequired[pulumi.Input[bool]]
|
|
660
|
+
"""
|
|
661
|
+
Determines whether or not the alert is disabled (default: `false`).
|
|
662
|
+
"""
|
|
663
|
+
elif False:
|
|
664
|
+
AppSpecAlertArgsDict: TypeAlias = Mapping[str, Any]
|
|
665
|
+
|
|
439
666
|
@pulumi.input_type
|
|
440
667
|
class AppSpecAlertArgs:
|
|
441
668
|
def __init__(__self__, *,
|
|
@@ -474,6 +701,41 @@ class AppSpecAlertArgs:
|
|
|
474
701
|
pulumi.set(self, "disabled", value)
|
|
475
702
|
|
|
476
703
|
|
|
704
|
+
if not MYPY:
|
|
705
|
+
class AppSpecDatabaseArgsDict(TypedDict):
|
|
706
|
+
cluster_name: NotRequired[pulumi.Input[str]]
|
|
707
|
+
"""
|
|
708
|
+
The name of the underlying DigitalOcean DBaaS cluster. This is required for production databases. For dev databases, if `cluster_name` is not set, a new cluster will be provisioned.
|
|
709
|
+
"""
|
|
710
|
+
db_name: NotRequired[pulumi.Input[str]]
|
|
711
|
+
"""
|
|
712
|
+
The name of the MySQL or PostgreSQL database to configure.
|
|
713
|
+
"""
|
|
714
|
+
db_user: NotRequired[pulumi.Input[str]]
|
|
715
|
+
"""
|
|
716
|
+
The name of the MySQL or PostgreSQL user to configure.
|
|
717
|
+
|
|
718
|
+
This resource supports customized create timeouts. The default timeout is 30 minutes.
|
|
719
|
+
"""
|
|
720
|
+
engine: NotRequired[pulumi.Input[str]]
|
|
721
|
+
"""
|
|
722
|
+
The database engine to use (`MYSQL`, `PG`, `REDIS`, `MONGODB`, `KAFKA`, or `OPENSEARCH`).
|
|
723
|
+
"""
|
|
724
|
+
name: NotRequired[pulumi.Input[str]]
|
|
725
|
+
"""
|
|
726
|
+
The name of the component.
|
|
727
|
+
"""
|
|
728
|
+
production: NotRequired[pulumi.Input[bool]]
|
|
729
|
+
"""
|
|
730
|
+
Whether this is a production or dev database.
|
|
731
|
+
"""
|
|
732
|
+
version: NotRequired[pulumi.Input[str]]
|
|
733
|
+
"""
|
|
734
|
+
The version of the database engine.
|
|
735
|
+
"""
|
|
736
|
+
elif False:
|
|
737
|
+
AppSpecDatabaseArgsDict: TypeAlias = Mapping[str, Any]
|
|
738
|
+
|
|
477
739
|
@pulumi.input_type
|
|
478
740
|
class AppSpecDatabaseArgs:
|
|
479
741
|
def __init__(__self__, *,
|
|
@@ -597,6 +859,30 @@ class AppSpecDatabaseArgs:
|
|
|
597
859
|
pulumi.set(self, "version", value)
|
|
598
860
|
|
|
599
861
|
|
|
862
|
+
if not MYPY:
|
|
863
|
+
class AppSpecDomainNameArgsDict(TypedDict):
|
|
864
|
+
name: pulumi.Input[str]
|
|
865
|
+
"""
|
|
866
|
+
The hostname for the domain.
|
|
867
|
+
"""
|
|
868
|
+
type: NotRequired[pulumi.Input[str]]
|
|
869
|
+
"""
|
|
870
|
+
The domain type, which can be one of the following:
|
|
871
|
+
- `DEFAULT`: The default .ondigitalocean.app domain assigned to this app.
|
|
872
|
+
- `PRIMARY`: The primary domain for this app that is displayed as the default in the control panel, used in bindable environment variables, and any other places that reference an app's live URL. Only one domain may be set as primary.
|
|
873
|
+
- `ALIAS`: A non-primary domain.
|
|
874
|
+
"""
|
|
875
|
+
wildcard: NotRequired[pulumi.Input[bool]]
|
|
876
|
+
"""
|
|
877
|
+
A boolean indicating whether the domain includes all sub-domains, in addition to the given domain.
|
|
878
|
+
"""
|
|
879
|
+
zone: NotRequired[pulumi.Input[str]]
|
|
880
|
+
"""
|
|
881
|
+
If the domain uses DigitalOcean DNS and you would like App Platform to automatically manage it for you, set this to the name of the domain on your account.
|
|
882
|
+
"""
|
|
883
|
+
elif False:
|
|
884
|
+
AppSpecDomainNameArgsDict: TypeAlias = Mapping[str, Any]
|
|
885
|
+
|
|
600
886
|
@pulumi.input_type
|
|
601
887
|
class AppSpecDomainNameArgs:
|
|
602
888
|
def __init__(__self__, *,
|
|
@@ -673,6 +959,15 @@ class AppSpecDomainNameArgs:
|
|
|
673
959
|
pulumi.set(self, "zone", value)
|
|
674
960
|
|
|
675
961
|
|
|
962
|
+
if not MYPY:
|
|
963
|
+
class AppSpecEgressArgsDict(TypedDict):
|
|
964
|
+
type: NotRequired[pulumi.Input[str]]
|
|
965
|
+
"""
|
|
966
|
+
The app egress type: `AUTOASSIGN`, `DEDICATED_IP`
|
|
967
|
+
"""
|
|
968
|
+
elif False:
|
|
969
|
+
AppSpecEgressArgsDict: TypeAlias = Mapping[str, Any]
|
|
970
|
+
|
|
676
971
|
@pulumi.input_type
|
|
677
972
|
class AppSpecEgressArgs:
|
|
678
973
|
def __init__(__self__, *,
|
|
@@ -696,6 +991,27 @@ class AppSpecEgressArgs:
|
|
|
696
991
|
pulumi.set(self, "type", value)
|
|
697
992
|
|
|
698
993
|
|
|
994
|
+
if not MYPY:
|
|
995
|
+
class AppSpecEnvArgsDict(TypedDict):
|
|
996
|
+
key: NotRequired[pulumi.Input[str]]
|
|
997
|
+
"""
|
|
998
|
+
The name of the environment variable.
|
|
999
|
+
"""
|
|
1000
|
+
scope: NotRequired[pulumi.Input[str]]
|
|
1001
|
+
"""
|
|
1002
|
+
The visibility scope of the environment variable. One of `RUN_TIME`, `BUILD_TIME`, or `RUN_AND_BUILD_TIME` (default).
|
|
1003
|
+
"""
|
|
1004
|
+
type: NotRequired[pulumi.Input[str]]
|
|
1005
|
+
"""
|
|
1006
|
+
The type of the environment variable, `GENERAL` or `SECRET`.
|
|
1007
|
+
"""
|
|
1008
|
+
value: NotRequired[pulumi.Input[str]]
|
|
1009
|
+
"""
|
|
1010
|
+
The value of the environment variable.
|
|
1011
|
+
"""
|
|
1012
|
+
elif False:
|
|
1013
|
+
AppSpecEnvArgsDict: TypeAlias = Mapping[str, Any]
|
|
1014
|
+
|
|
699
1015
|
@pulumi.input_type
|
|
700
1016
|
class AppSpecEnvArgs:
|
|
701
1017
|
def __init__(__self__, *,
|
|
@@ -767,6 +1083,51 @@ class AppSpecEnvArgs:
|
|
|
767
1083
|
pulumi.set(self, "value", value)
|
|
768
1084
|
|
|
769
1085
|
|
|
1086
|
+
if not MYPY:
|
|
1087
|
+
class AppSpecFunctionArgsDict(TypedDict):
|
|
1088
|
+
name: pulumi.Input[str]
|
|
1089
|
+
"""
|
|
1090
|
+
The name of the component.
|
|
1091
|
+
"""
|
|
1092
|
+
alerts: NotRequired[pulumi.Input[Sequence[pulumi.Input['AppSpecFunctionAlertArgsDict']]]]
|
|
1093
|
+
"""
|
|
1094
|
+
Describes an alert policy for the component.
|
|
1095
|
+
"""
|
|
1096
|
+
cors: NotRequired[pulumi.Input['AppSpecFunctionCorsArgsDict']]
|
|
1097
|
+
"""
|
|
1098
|
+
The [CORS](https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS) policies of the app.
|
|
1099
|
+
"""
|
|
1100
|
+
envs: NotRequired[pulumi.Input[Sequence[pulumi.Input['AppSpecFunctionEnvArgsDict']]]]
|
|
1101
|
+
"""
|
|
1102
|
+
Describes an environment variable made available to an app competent.
|
|
1103
|
+
"""
|
|
1104
|
+
git: NotRequired[pulumi.Input['AppSpecFunctionGitArgsDict']]
|
|
1105
|
+
"""
|
|
1106
|
+
A Git repo to use as the component's source. The repository must be able to be cloned without authentication. Only one of `git`, `github` or `gitlab` may be set.
|
|
1107
|
+
"""
|
|
1108
|
+
github: NotRequired[pulumi.Input['AppSpecFunctionGithubArgsDict']]
|
|
1109
|
+
"""
|
|
1110
|
+
A GitHub repo to use as the component's source. DigitalOcean App Platform must have [access to the repository](https://cloud.digitalocean.com/apps/github/install). Only one of `git`, `github`, `gitlab`, or `image` may be set.
|
|
1111
|
+
"""
|
|
1112
|
+
gitlab: NotRequired[pulumi.Input['AppSpecFunctionGitlabArgsDict']]
|
|
1113
|
+
"""
|
|
1114
|
+
A Gitlab repo to use as the component's source. DigitalOcean App Platform must have [access to the repository](https://cloud.digitalocean.com/apps/gitlab/install). Only one of `git`, `github`, `gitlab`, or `image` may be set.
|
|
1115
|
+
"""
|
|
1116
|
+
log_destinations: NotRequired[pulumi.Input[Sequence[pulumi.Input['AppSpecFunctionLogDestinationArgsDict']]]]
|
|
1117
|
+
"""
|
|
1118
|
+
Describes a log forwarding destination.
|
|
1119
|
+
"""
|
|
1120
|
+
routes: NotRequired[pulumi.Input[Sequence[pulumi.Input['AppSpecFunctionRouteArgsDict']]]]
|
|
1121
|
+
"""
|
|
1122
|
+
An HTTP paths that should be routed to this component.
|
|
1123
|
+
"""
|
|
1124
|
+
source_dir: NotRequired[pulumi.Input[str]]
|
|
1125
|
+
"""
|
|
1126
|
+
An optional path to the working directory to use for the build.
|
|
1127
|
+
"""
|
|
1128
|
+
elif False:
|
|
1129
|
+
AppSpecFunctionArgsDict: TypeAlias = Mapping[str, Any]
|
|
1130
|
+
|
|
770
1131
|
@pulumi.input_type
|
|
771
1132
|
class AppSpecFunctionArgs:
|
|
772
1133
|
def __init__(__self__, *,
|
|
@@ -941,6 +1302,31 @@ class AppSpecFunctionArgs:
|
|
|
941
1302
|
pulumi.set(self, "source_dir", value)
|
|
942
1303
|
|
|
943
1304
|
|
|
1305
|
+
if not MYPY:
|
|
1306
|
+
class AppSpecFunctionAlertArgsDict(TypedDict):
|
|
1307
|
+
operator: pulumi.Input[str]
|
|
1308
|
+
"""
|
|
1309
|
+
The operator to use. This is either of `GREATER_THAN` or `LESS_THAN`.
|
|
1310
|
+
"""
|
|
1311
|
+
rule: pulumi.Input[str]
|
|
1312
|
+
"""
|
|
1313
|
+
The type of the alert to configure. Component app alert policies can be: `CPU_UTILIZATION`, `MEM_UTILIZATION`, or `RESTART_COUNT`.
|
|
1314
|
+
"""
|
|
1315
|
+
value: pulumi.Input[float]
|
|
1316
|
+
"""
|
|
1317
|
+
The threshold for the type of the warning.
|
|
1318
|
+
"""
|
|
1319
|
+
window: pulumi.Input[str]
|
|
1320
|
+
"""
|
|
1321
|
+
The time before alerts should be triggered. This is may be one of: `FIVE_MINUTES`, `TEN_MINUTES`, `THIRTY_MINUTES`, `ONE_HOUR`.
|
|
1322
|
+
"""
|
|
1323
|
+
disabled: NotRequired[pulumi.Input[bool]]
|
|
1324
|
+
"""
|
|
1325
|
+
Determines whether or not the alert is disabled (default: `false`).
|
|
1326
|
+
"""
|
|
1327
|
+
elif False:
|
|
1328
|
+
AppSpecFunctionAlertArgsDict: TypeAlias = Mapping[str, Any]
|
|
1329
|
+
|
|
944
1330
|
@pulumi.input_type
|
|
945
1331
|
class AppSpecFunctionAlertArgs:
|
|
946
1332
|
def __init__(__self__, *,
|
|
@@ -1024,6 +1410,35 @@ class AppSpecFunctionAlertArgs:
|
|
|
1024
1410
|
pulumi.set(self, "disabled", value)
|
|
1025
1411
|
|
|
1026
1412
|
|
|
1413
|
+
if not MYPY:
|
|
1414
|
+
class AppSpecFunctionCorsArgsDict(TypedDict):
|
|
1415
|
+
allow_credentials: NotRequired[pulumi.Input[bool]]
|
|
1416
|
+
"""
|
|
1417
|
+
Whether browsers should expose the response to the client-side JavaScript code when the request’s credentials mode is `include`. This configures the Access-Control-Allow-Credentials header.
|
|
1418
|
+
"""
|
|
1419
|
+
allow_headers: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
1420
|
+
"""
|
|
1421
|
+
The set of allowed HTTP request headers. This configures the Access-Control-Allow-Headers header.
|
|
1422
|
+
"""
|
|
1423
|
+
allow_methods: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
1424
|
+
"""
|
|
1425
|
+
The set of allowed HTTP methods. This configures the Access-Control-Allow-Methods header.
|
|
1426
|
+
"""
|
|
1427
|
+
allow_origins: NotRequired[pulumi.Input['AppSpecFunctionCorsAllowOriginsArgsDict']]
|
|
1428
|
+
"""
|
|
1429
|
+
The set of allowed CORS origins. This configures the Access-Control-Allow-Origin header.
|
|
1430
|
+
"""
|
|
1431
|
+
expose_headers: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
1432
|
+
"""
|
|
1433
|
+
The set of HTTP response headers that browsers are allowed to access. This configures the Access-Control-Expose-Headers header.
|
|
1434
|
+
"""
|
|
1435
|
+
max_age: NotRequired[pulumi.Input[str]]
|
|
1436
|
+
"""
|
|
1437
|
+
An optional duration specifying how long browsers can cache the results of a preflight request. This configures the Access-Control-Max-Age header. Example: `5h30m`.
|
|
1438
|
+
"""
|
|
1439
|
+
elif False:
|
|
1440
|
+
AppSpecFunctionCorsArgsDict: TypeAlias = Mapping[str, Any]
|
|
1441
|
+
|
|
1027
1442
|
@pulumi.input_type
|
|
1028
1443
|
class AppSpecFunctionCorsArgs:
|
|
1029
1444
|
def __init__(__self__, *,
|
|
@@ -1127,6 +1542,23 @@ class AppSpecFunctionCorsArgs:
|
|
|
1127
1542
|
pulumi.set(self, "max_age", value)
|
|
1128
1543
|
|
|
1129
1544
|
|
|
1545
|
+
if not MYPY:
|
|
1546
|
+
class AppSpecFunctionCorsAllowOriginsArgsDict(TypedDict):
|
|
1547
|
+
exact: NotRequired[pulumi.Input[str]]
|
|
1548
|
+
"""
|
|
1549
|
+
Exact string match.
|
|
1550
|
+
"""
|
|
1551
|
+
prefix: NotRequired[pulumi.Input[str]]
|
|
1552
|
+
"""
|
|
1553
|
+
Prefix-based match.
|
|
1554
|
+
"""
|
|
1555
|
+
regex: NotRequired[pulumi.Input[str]]
|
|
1556
|
+
"""
|
|
1557
|
+
RE2 style regex-based match.
|
|
1558
|
+
"""
|
|
1559
|
+
elif False:
|
|
1560
|
+
AppSpecFunctionCorsAllowOriginsArgsDict: TypeAlias = Mapping[str, Any]
|
|
1561
|
+
|
|
1130
1562
|
@pulumi.input_type
|
|
1131
1563
|
class AppSpecFunctionCorsAllowOriginsArgs:
|
|
1132
1564
|
def __init__(__self__, *,
|
|
@@ -1186,6 +1618,27 @@ class AppSpecFunctionCorsAllowOriginsArgs:
|
|
|
1186
1618
|
pulumi.set(self, "regex", value)
|
|
1187
1619
|
|
|
1188
1620
|
|
|
1621
|
+
if not MYPY:
|
|
1622
|
+
class AppSpecFunctionEnvArgsDict(TypedDict):
|
|
1623
|
+
key: NotRequired[pulumi.Input[str]]
|
|
1624
|
+
"""
|
|
1625
|
+
The name of the environment variable.
|
|
1626
|
+
"""
|
|
1627
|
+
scope: NotRequired[pulumi.Input[str]]
|
|
1628
|
+
"""
|
|
1629
|
+
The visibility scope of the environment variable. One of `RUN_TIME`, `BUILD_TIME`, or `RUN_AND_BUILD_TIME` (default).
|
|
1630
|
+
"""
|
|
1631
|
+
type: NotRequired[pulumi.Input[str]]
|
|
1632
|
+
"""
|
|
1633
|
+
The type of the environment variable, `GENERAL` or `SECRET`.
|
|
1634
|
+
"""
|
|
1635
|
+
value: NotRequired[pulumi.Input[str]]
|
|
1636
|
+
"""
|
|
1637
|
+
The value of the environment variable.
|
|
1638
|
+
"""
|
|
1639
|
+
elif False:
|
|
1640
|
+
AppSpecFunctionEnvArgsDict: TypeAlias = Mapping[str, Any]
|
|
1641
|
+
|
|
1189
1642
|
@pulumi.input_type
|
|
1190
1643
|
class AppSpecFunctionEnvArgs:
|
|
1191
1644
|
def __init__(__self__, *,
|
|
@@ -1257,6 +1710,19 @@ class AppSpecFunctionEnvArgs:
|
|
|
1257
1710
|
pulumi.set(self, "value", value)
|
|
1258
1711
|
|
|
1259
1712
|
|
|
1713
|
+
if not MYPY:
|
|
1714
|
+
class AppSpecFunctionGitArgsDict(TypedDict):
|
|
1715
|
+
branch: NotRequired[pulumi.Input[str]]
|
|
1716
|
+
"""
|
|
1717
|
+
The name of the branch to use.
|
|
1718
|
+
"""
|
|
1719
|
+
repo_clone_url: NotRequired[pulumi.Input[str]]
|
|
1720
|
+
"""
|
|
1721
|
+
The clone URL of the repo.
|
|
1722
|
+
"""
|
|
1723
|
+
elif False:
|
|
1724
|
+
AppSpecFunctionGitArgsDict: TypeAlias = Mapping[str, Any]
|
|
1725
|
+
|
|
1260
1726
|
@pulumi.input_type
|
|
1261
1727
|
class AppSpecFunctionGitArgs:
|
|
1262
1728
|
def __init__(__self__, *,
|
|
@@ -1296,6 +1762,23 @@ class AppSpecFunctionGitArgs:
|
|
|
1296
1762
|
pulumi.set(self, "repo_clone_url", value)
|
|
1297
1763
|
|
|
1298
1764
|
|
|
1765
|
+
if not MYPY:
|
|
1766
|
+
class AppSpecFunctionGithubArgsDict(TypedDict):
|
|
1767
|
+
branch: NotRequired[pulumi.Input[str]]
|
|
1768
|
+
"""
|
|
1769
|
+
The name of the branch to use.
|
|
1770
|
+
"""
|
|
1771
|
+
deploy_on_push: NotRequired[pulumi.Input[bool]]
|
|
1772
|
+
"""
|
|
1773
|
+
Whether to automatically deploy new commits made to the repo.
|
|
1774
|
+
"""
|
|
1775
|
+
repo: NotRequired[pulumi.Input[str]]
|
|
1776
|
+
"""
|
|
1777
|
+
The name of the repo in the format `owner/repo`.
|
|
1778
|
+
"""
|
|
1779
|
+
elif False:
|
|
1780
|
+
AppSpecFunctionGithubArgsDict: TypeAlias = Mapping[str, Any]
|
|
1781
|
+
|
|
1299
1782
|
@pulumi.input_type
|
|
1300
1783
|
class AppSpecFunctionGithubArgs:
|
|
1301
1784
|
def __init__(__self__, *,
|
|
@@ -1351,6 +1834,23 @@ class AppSpecFunctionGithubArgs:
|
|
|
1351
1834
|
pulumi.set(self, "repo", value)
|
|
1352
1835
|
|
|
1353
1836
|
|
|
1837
|
+
if not MYPY:
|
|
1838
|
+
class AppSpecFunctionGitlabArgsDict(TypedDict):
|
|
1839
|
+
branch: NotRequired[pulumi.Input[str]]
|
|
1840
|
+
"""
|
|
1841
|
+
The name of the branch to use.
|
|
1842
|
+
"""
|
|
1843
|
+
deploy_on_push: NotRequired[pulumi.Input[bool]]
|
|
1844
|
+
"""
|
|
1845
|
+
Whether to automatically deploy new commits made to the repo.
|
|
1846
|
+
"""
|
|
1847
|
+
repo: NotRequired[pulumi.Input[str]]
|
|
1848
|
+
"""
|
|
1849
|
+
The name of the repo in the format `owner/repo`.
|
|
1850
|
+
"""
|
|
1851
|
+
elif False:
|
|
1852
|
+
AppSpecFunctionGitlabArgsDict: TypeAlias = Mapping[str, Any]
|
|
1853
|
+
|
|
1354
1854
|
@pulumi.input_type
|
|
1355
1855
|
class AppSpecFunctionGitlabArgs:
|
|
1356
1856
|
def __init__(__self__, *,
|
|
@@ -1406,6 +1906,31 @@ class AppSpecFunctionGitlabArgs:
|
|
|
1406
1906
|
pulumi.set(self, "repo", value)
|
|
1407
1907
|
|
|
1408
1908
|
|
|
1909
|
+
if not MYPY:
|
|
1910
|
+
class AppSpecFunctionLogDestinationArgsDict(TypedDict):
|
|
1911
|
+
name: pulumi.Input[str]
|
|
1912
|
+
"""
|
|
1913
|
+
Name of the log destination. Minimum length: 2. Maximum length: 42.
|
|
1914
|
+
"""
|
|
1915
|
+
datadog: NotRequired[pulumi.Input['AppSpecFunctionLogDestinationDatadogArgsDict']]
|
|
1916
|
+
"""
|
|
1917
|
+
Datadog configuration.
|
|
1918
|
+
"""
|
|
1919
|
+
logtail: NotRequired[pulumi.Input['AppSpecFunctionLogDestinationLogtailArgsDict']]
|
|
1920
|
+
"""
|
|
1921
|
+
Logtail configuration.
|
|
1922
|
+
"""
|
|
1923
|
+
open_search: NotRequired[pulumi.Input['AppSpecFunctionLogDestinationOpenSearchArgsDict']]
|
|
1924
|
+
"""
|
|
1925
|
+
OpenSearch configuration.
|
|
1926
|
+
"""
|
|
1927
|
+
papertrail: NotRequired[pulumi.Input['AppSpecFunctionLogDestinationPapertrailArgsDict']]
|
|
1928
|
+
"""
|
|
1929
|
+
Papertrail configuration.
|
|
1930
|
+
"""
|
|
1931
|
+
elif False:
|
|
1932
|
+
AppSpecFunctionLogDestinationArgsDict: TypeAlias = Mapping[str, Any]
|
|
1933
|
+
|
|
1409
1934
|
@pulumi.input_type
|
|
1410
1935
|
class AppSpecFunctionLogDestinationArgs:
|
|
1411
1936
|
def __init__(__self__, *,
|
|
@@ -1492,6 +2017,19 @@ class AppSpecFunctionLogDestinationArgs:
|
|
|
1492
2017
|
pulumi.set(self, "papertrail", value)
|
|
1493
2018
|
|
|
1494
2019
|
|
|
2020
|
+
if not MYPY:
|
|
2021
|
+
class AppSpecFunctionLogDestinationDatadogArgsDict(TypedDict):
|
|
2022
|
+
api_key: pulumi.Input[str]
|
|
2023
|
+
"""
|
|
2024
|
+
Datadog API key.
|
|
2025
|
+
"""
|
|
2026
|
+
endpoint: NotRequired[pulumi.Input[str]]
|
|
2027
|
+
"""
|
|
2028
|
+
Datadog HTTP log intake endpoint.
|
|
2029
|
+
"""
|
|
2030
|
+
elif False:
|
|
2031
|
+
AppSpecFunctionLogDestinationDatadogArgsDict: TypeAlias = Mapping[str, Any]
|
|
2032
|
+
|
|
1495
2033
|
@pulumi.input_type
|
|
1496
2034
|
class AppSpecFunctionLogDestinationDatadogArgs:
|
|
1497
2035
|
def __init__(__self__, *,
|
|
@@ -1530,6 +2068,15 @@ class AppSpecFunctionLogDestinationDatadogArgs:
|
|
|
1530
2068
|
pulumi.set(self, "endpoint", value)
|
|
1531
2069
|
|
|
1532
2070
|
|
|
2071
|
+
if not MYPY:
|
|
2072
|
+
class AppSpecFunctionLogDestinationLogtailArgsDict(TypedDict):
|
|
2073
|
+
token: pulumi.Input[str]
|
|
2074
|
+
"""
|
|
2075
|
+
Logtail token.
|
|
2076
|
+
"""
|
|
2077
|
+
elif False:
|
|
2078
|
+
AppSpecFunctionLogDestinationLogtailArgsDict: TypeAlias = Mapping[str, Any]
|
|
2079
|
+
|
|
1533
2080
|
@pulumi.input_type
|
|
1534
2081
|
class AppSpecFunctionLogDestinationLogtailArgs:
|
|
1535
2082
|
def __init__(__self__, *,
|
|
@@ -1552,6 +2099,27 @@ class AppSpecFunctionLogDestinationLogtailArgs:
|
|
|
1552
2099
|
pulumi.set(self, "token", value)
|
|
1553
2100
|
|
|
1554
2101
|
|
|
2102
|
+
if not MYPY:
|
|
2103
|
+
class AppSpecFunctionLogDestinationOpenSearchArgsDict(TypedDict):
|
|
2104
|
+
basic_auth: pulumi.Input['AppSpecFunctionLogDestinationOpenSearchBasicAuthArgsDict']
|
|
2105
|
+
"""
|
|
2106
|
+
Basic authentication details.
|
|
2107
|
+
"""
|
|
2108
|
+
cluster_name: NotRequired[pulumi.Input[str]]
|
|
2109
|
+
"""
|
|
2110
|
+
The name of the underlying DigitalOcean DBaaS cluster. This is required for production databases. For dev databases, if `cluster_name` is not set, a new cluster will be provisioned.
|
|
2111
|
+
"""
|
|
2112
|
+
endpoint: NotRequired[pulumi.Input[str]]
|
|
2113
|
+
"""
|
|
2114
|
+
OpenSearch endpoint.
|
|
2115
|
+
"""
|
|
2116
|
+
index_name: NotRequired[pulumi.Input[str]]
|
|
2117
|
+
"""
|
|
2118
|
+
OpenSearch index name.
|
|
2119
|
+
"""
|
|
2120
|
+
elif False:
|
|
2121
|
+
AppSpecFunctionLogDestinationOpenSearchArgsDict: TypeAlias = Mapping[str, Any]
|
|
2122
|
+
|
|
1555
2123
|
@pulumi.input_type
|
|
1556
2124
|
class AppSpecFunctionLogDestinationOpenSearchArgs:
|
|
1557
2125
|
def __init__(__self__, *,
|
|
@@ -1622,6 +2190,19 @@ class AppSpecFunctionLogDestinationOpenSearchArgs:
|
|
|
1622
2190
|
pulumi.set(self, "index_name", value)
|
|
1623
2191
|
|
|
1624
2192
|
|
|
2193
|
+
if not MYPY:
|
|
2194
|
+
class AppSpecFunctionLogDestinationOpenSearchBasicAuthArgsDict(TypedDict):
|
|
2195
|
+
password: NotRequired[pulumi.Input[str]]
|
|
2196
|
+
"""
|
|
2197
|
+
Password for basic authentication.
|
|
2198
|
+
"""
|
|
2199
|
+
user: NotRequired[pulumi.Input[str]]
|
|
2200
|
+
"""
|
|
2201
|
+
user for basic authentication.
|
|
2202
|
+
"""
|
|
2203
|
+
elif False:
|
|
2204
|
+
AppSpecFunctionLogDestinationOpenSearchBasicAuthArgsDict: TypeAlias = Mapping[str, Any]
|
|
2205
|
+
|
|
1625
2206
|
@pulumi.input_type
|
|
1626
2207
|
class AppSpecFunctionLogDestinationOpenSearchBasicAuthArgs:
|
|
1627
2208
|
def __init__(__self__, *,
|
|
@@ -1661,6 +2242,15 @@ class AppSpecFunctionLogDestinationOpenSearchBasicAuthArgs:
|
|
|
1661
2242
|
pulumi.set(self, "user", value)
|
|
1662
2243
|
|
|
1663
2244
|
|
|
2245
|
+
if not MYPY:
|
|
2246
|
+
class AppSpecFunctionLogDestinationPapertrailArgsDict(TypedDict):
|
|
2247
|
+
endpoint: pulumi.Input[str]
|
|
2248
|
+
"""
|
|
2249
|
+
Papertrail syslog endpoint.
|
|
2250
|
+
"""
|
|
2251
|
+
elif False:
|
|
2252
|
+
AppSpecFunctionLogDestinationPapertrailArgsDict: TypeAlias = Mapping[str, Any]
|
|
2253
|
+
|
|
1664
2254
|
@pulumi.input_type
|
|
1665
2255
|
class AppSpecFunctionLogDestinationPapertrailArgs:
|
|
1666
2256
|
def __init__(__self__, *,
|
|
@@ -1683,6 +2273,19 @@ class AppSpecFunctionLogDestinationPapertrailArgs:
|
|
|
1683
2273
|
pulumi.set(self, "endpoint", value)
|
|
1684
2274
|
|
|
1685
2275
|
|
|
2276
|
+
if not MYPY:
|
|
2277
|
+
class AppSpecFunctionRouteArgsDict(TypedDict):
|
|
2278
|
+
path: NotRequired[pulumi.Input[str]]
|
|
2279
|
+
"""
|
|
2280
|
+
Paths must start with `/` and must be unique within the app.
|
|
2281
|
+
"""
|
|
2282
|
+
preserve_path_prefix: NotRequired[pulumi.Input[bool]]
|
|
2283
|
+
"""
|
|
2284
|
+
An optional flag to preserve the path that is forwarded to the backend service.
|
|
2285
|
+
"""
|
|
2286
|
+
elif False:
|
|
2287
|
+
AppSpecFunctionRouteArgsDict: TypeAlias = Mapping[str, Any]
|
|
2288
|
+
|
|
1686
2289
|
@pulumi.input_type
|
|
1687
2290
|
class AppSpecFunctionRouteArgs:
|
|
1688
2291
|
def __init__(__self__, *,
|
|
@@ -1722,6 +2325,15 @@ class AppSpecFunctionRouteArgs:
|
|
|
1722
2325
|
pulumi.set(self, "preserve_path_prefix", value)
|
|
1723
2326
|
|
|
1724
2327
|
|
|
2328
|
+
if not MYPY:
|
|
2329
|
+
class AppSpecIngressArgsDict(TypedDict):
|
|
2330
|
+
rules: NotRequired[pulumi.Input[Sequence[pulumi.Input['AppSpecIngressRuleArgsDict']]]]
|
|
2331
|
+
"""
|
|
2332
|
+
Rules for configuring HTTP ingress for component routes, CORS, rewrites, and redirects.
|
|
2333
|
+
"""
|
|
2334
|
+
elif False:
|
|
2335
|
+
AppSpecIngressArgsDict: TypeAlias = Mapping[str, Any]
|
|
2336
|
+
|
|
1725
2337
|
@pulumi.input_type
|
|
1726
2338
|
class AppSpecIngressArgs:
|
|
1727
2339
|
def __init__(__self__, *,
|
|
@@ -1745,6 +2357,27 @@ class AppSpecIngressArgs:
|
|
|
1745
2357
|
pulumi.set(self, "rules", value)
|
|
1746
2358
|
|
|
1747
2359
|
|
|
2360
|
+
if not MYPY:
|
|
2361
|
+
class AppSpecIngressRuleArgsDict(TypedDict):
|
|
2362
|
+
component: NotRequired[pulumi.Input['AppSpecIngressRuleComponentArgsDict']]
|
|
2363
|
+
"""
|
|
2364
|
+
The component to route to. Only one of `component` or `redirect` may be set.
|
|
2365
|
+
"""
|
|
2366
|
+
cors: NotRequired[pulumi.Input['AppSpecIngressRuleCorsArgsDict']]
|
|
2367
|
+
"""
|
|
2368
|
+
The [CORS](https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS) policies of the app.
|
|
2369
|
+
"""
|
|
2370
|
+
match: NotRequired[pulumi.Input['AppSpecIngressRuleMatchArgsDict']]
|
|
2371
|
+
"""
|
|
2372
|
+
The match configuration for the rule
|
|
2373
|
+
"""
|
|
2374
|
+
redirect: NotRequired[pulumi.Input['AppSpecIngressRuleRedirectArgsDict']]
|
|
2375
|
+
"""
|
|
2376
|
+
The redirect configuration for the rule. Only one of `component` or `redirect` may be set.
|
|
2377
|
+
"""
|
|
2378
|
+
elif False:
|
|
2379
|
+
AppSpecIngressRuleArgsDict: TypeAlias = Mapping[str, Any]
|
|
2380
|
+
|
|
1748
2381
|
@pulumi.input_type
|
|
1749
2382
|
class AppSpecIngressRuleArgs:
|
|
1750
2383
|
def __init__(__self__, *,
|
|
@@ -1816,6 +2449,23 @@ class AppSpecIngressRuleArgs:
|
|
|
1816
2449
|
pulumi.set(self, "redirect", value)
|
|
1817
2450
|
|
|
1818
2451
|
|
|
2452
|
+
if not MYPY:
|
|
2453
|
+
class AppSpecIngressRuleComponentArgsDict(TypedDict):
|
|
2454
|
+
name: NotRequired[pulumi.Input[str]]
|
|
2455
|
+
"""
|
|
2456
|
+
The name of the component to route to.
|
|
2457
|
+
"""
|
|
2458
|
+
preserve_path_prefix: NotRequired[pulumi.Input[bool]]
|
|
2459
|
+
"""
|
|
2460
|
+
An optional boolean flag to preserve the path that is forwarded to the backend service. By default, the HTTP request path will be trimmed from the left when forwarded to the component.
|
|
2461
|
+
"""
|
|
2462
|
+
rewrite: NotRequired[pulumi.Input[str]]
|
|
2463
|
+
"""
|
|
2464
|
+
An optional field that will rewrite the path of the component to be what is specified here. This is mutually exclusive with `preserve_path_prefix`.
|
|
2465
|
+
"""
|
|
2466
|
+
elif False:
|
|
2467
|
+
AppSpecIngressRuleComponentArgsDict: TypeAlias = Mapping[str, Any]
|
|
2468
|
+
|
|
1819
2469
|
@pulumi.input_type
|
|
1820
2470
|
class AppSpecIngressRuleComponentArgs:
|
|
1821
2471
|
def __init__(__self__, *,
|
|
@@ -1871,6 +2521,35 @@ class AppSpecIngressRuleComponentArgs:
|
|
|
1871
2521
|
pulumi.set(self, "rewrite", value)
|
|
1872
2522
|
|
|
1873
2523
|
|
|
2524
|
+
if not MYPY:
|
|
2525
|
+
class AppSpecIngressRuleCorsArgsDict(TypedDict):
|
|
2526
|
+
allow_credentials: NotRequired[pulumi.Input[bool]]
|
|
2527
|
+
"""
|
|
2528
|
+
Whether browsers should expose the response to the client-side JavaScript code when the request's credentials mode is `include`. This configures the `Access-Control-Allow-Credentials` header.
|
|
2529
|
+
"""
|
|
2530
|
+
allow_headers: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
2531
|
+
"""
|
|
2532
|
+
The set of allowed HTTP request headers. This configures the `Access-Control-Allow-Headers` header.
|
|
2533
|
+
"""
|
|
2534
|
+
allow_methods: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
2535
|
+
"""
|
|
2536
|
+
The set of allowed HTTP methods. This configures the `Access-Control-Allow-Methods` header.
|
|
2537
|
+
"""
|
|
2538
|
+
allow_origins: NotRequired[pulumi.Input['AppSpecIngressRuleCorsAllowOriginsArgsDict']]
|
|
2539
|
+
"""
|
|
2540
|
+
The `Access-Control-Allow-Origin` can be
|
|
2541
|
+
"""
|
|
2542
|
+
expose_headers: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
2543
|
+
"""
|
|
2544
|
+
The set of HTTP response headers that browsers are allowed to access. This configures the `Access-Control-Expose-Headers` header.
|
|
2545
|
+
"""
|
|
2546
|
+
max_age: NotRequired[pulumi.Input[str]]
|
|
2547
|
+
"""
|
|
2548
|
+
An optional duration specifying how long browsers can cache the results of a preflight request. This configures the Access-Control-Max-Age header. Example: `5h30m`.
|
|
2549
|
+
"""
|
|
2550
|
+
elif False:
|
|
2551
|
+
AppSpecIngressRuleCorsArgsDict: TypeAlias = Mapping[str, Any]
|
|
2552
|
+
|
|
1874
2553
|
@pulumi.input_type
|
|
1875
2554
|
class AppSpecIngressRuleCorsArgs:
|
|
1876
2555
|
def __init__(__self__, *,
|
|
@@ -1974,6 +2653,23 @@ class AppSpecIngressRuleCorsArgs:
|
|
|
1974
2653
|
pulumi.set(self, "max_age", value)
|
|
1975
2654
|
|
|
1976
2655
|
|
|
2656
|
+
if not MYPY:
|
|
2657
|
+
class AppSpecIngressRuleCorsAllowOriginsArgsDict(TypedDict):
|
|
2658
|
+
exact: NotRequired[pulumi.Input[str]]
|
|
2659
|
+
"""
|
|
2660
|
+
The `Access-Control-Allow-Origin` header will be set to the client's origin only if the client's origin exactly matches the value you provide.
|
|
2661
|
+
"""
|
|
2662
|
+
prefix: NotRequired[pulumi.Input[str]]
|
|
2663
|
+
"""
|
|
2664
|
+
The `Access-Control-Allow-Origin` header will be set to the client's origin if the beginning of the client's origin matches the value you provide.
|
|
2665
|
+
"""
|
|
2666
|
+
regex: NotRequired[pulumi.Input[str]]
|
|
2667
|
+
"""
|
|
2668
|
+
The `Access-Control-Allow-Origin` header will be set to the client's origin if the client’s origin matches the regex you provide, in [RE2 style syntax](https://github.com/google/re2/wiki/Syntax).
|
|
2669
|
+
"""
|
|
2670
|
+
elif False:
|
|
2671
|
+
AppSpecIngressRuleCorsAllowOriginsArgsDict: TypeAlias = Mapping[str, Any]
|
|
2672
|
+
|
|
1977
2673
|
@pulumi.input_type
|
|
1978
2674
|
class AppSpecIngressRuleCorsAllowOriginsArgs:
|
|
1979
2675
|
def __init__(__self__, *,
|
|
@@ -2033,6 +2729,15 @@ class AppSpecIngressRuleCorsAllowOriginsArgs:
|
|
|
2033
2729
|
pulumi.set(self, "regex", value)
|
|
2034
2730
|
|
|
2035
2731
|
|
|
2732
|
+
if not MYPY:
|
|
2733
|
+
class AppSpecIngressRuleMatchArgsDict(TypedDict):
|
|
2734
|
+
path: NotRequired[pulumi.Input['AppSpecIngressRuleMatchPathArgsDict']]
|
|
2735
|
+
"""
|
|
2736
|
+
The path to match on.
|
|
2737
|
+
"""
|
|
2738
|
+
elif False:
|
|
2739
|
+
AppSpecIngressRuleMatchArgsDict: TypeAlias = Mapping[str, Any]
|
|
2740
|
+
|
|
2036
2741
|
@pulumi.input_type
|
|
2037
2742
|
class AppSpecIngressRuleMatchArgs:
|
|
2038
2743
|
def __init__(__self__, *,
|
|
@@ -2056,6 +2761,15 @@ class AppSpecIngressRuleMatchArgs:
|
|
|
2056
2761
|
pulumi.set(self, "path", value)
|
|
2057
2762
|
|
|
2058
2763
|
|
|
2764
|
+
if not MYPY:
|
|
2765
|
+
class AppSpecIngressRuleMatchPathArgsDict(TypedDict):
|
|
2766
|
+
prefix: NotRequired[pulumi.Input[str]]
|
|
2767
|
+
"""
|
|
2768
|
+
Prefix-based match.
|
|
2769
|
+
"""
|
|
2770
|
+
elif False:
|
|
2771
|
+
AppSpecIngressRuleMatchPathArgsDict: TypeAlias = Mapping[str, Any]
|
|
2772
|
+
|
|
2059
2773
|
@pulumi.input_type
|
|
2060
2774
|
class AppSpecIngressRuleMatchPathArgs:
|
|
2061
2775
|
def __init__(__self__, *,
|
|
@@ -2079,6 +2793,31 @@ class AppSpecIngressRuleMatchPathArgs:
|
|
|
2079
2793
|
pulumi.set(self, "prefix", value)
|
|
2080
2794
|
|
|
2081
2795
|
|
|
2796
|
+
if not MYPY:
|
|
2797
|
+
class AppSpecIngressRuleRedirectArgsDict(TypedDict):
|
|
2798
|
+
authority: NotRequired[pulumi.Input[str]]
|
|
2799
|
+
"""
|
|
2800
|
+
The authority/host to redirect to. This can be a hostname or IP address.
|
|
2801
|
+
"""
|
|
2802
|
+
port: NotRequired[pulumi.Input[int]]
|
|
2803
|
+
"""
|
|
2804
|
+
The port to redirect to.
|
|
2805
|
+
"""
|
|
2806
|
+
redirect_code: NotRequired[pulumi.Input[int]]
|
|
2807
|
+
"""
|
|
2808
|
+
The redirect code to use. Supported values are `300`, `301`, `302`, `303`, `304`, `307`, `308`.
|
|
2809
|
+
"""
|
|
2810
|
+
scheme: NotRequired[pulumi.Input[str]]
|
|
2811
|
+
"""
|
|
2812
|
+
The scheme to redirect to. Supported values are `http` or `https`
|
|
2813
|
+
"""
|
|
2814
|
+
uri: NotRequired[pulumi.Input[str]]
|
|
2815
|
+
"""
|
|
2816
|
+
An optional URI path to redirect to.
|
|
2817
|
+
"""
|
|
2818
|
+
elif False:
|
|
2819
|
+
AppSpecIngressRuleRedirectArgsDict: TypeAlias = Mapping[str, Any]
|
|
2820
|
+
|
|
2082
2821
|
@pulumi.input_type
|
|
2083
2822
|
class AppSpecIngressRuleRedirectArgs:
|
|
2084
2823
|
def __init__(__self__, *,
|
|
@@ -2166,6 +2905,79 @@ class AppSpecIngressRuleRedirectArgs:
|
|
|
2166
2905
|
pulumi.set(self, "uri", value)
|
|
2167
2906
|
|
|
2168
2907
|
|
|
2908
|
+
if not MYPY:
|
|
2909
|
+
class AppSpecJobArgsDict(TypedDict):
|
|
2910
|
+
name: pulumi.Input[str]
|
|
2911
|
+
"""
|
|
2912
|
+
The name of the component.
|
|
2913
|
+
"""
|
|
2914
|
+
alerts: NotRequired[pulumi.Input[Sequence[pulumi.Input['AppSpecJobAlertArgsDict']]]]
|
|
2915
|
+
"""
|
|
2916
|
+
Describes an alert policy for the component.
|
|
2917
|
+
"""
|
|
2918
|
+
build_command: NotRequired[pulumi.Input[str]]
|
|
2919
|
+
"""
|
|
2920
|
+
An optional build command to run while building this component from source.
|
|
2921
|
+
"""
|
|
2922
|
+
dockerfile_path: NotRequired[pulumi.Input[str]]
|
|
2923
|
+
"""
|
|
2924
|
+
The path to a Dockerfile relative to the root of the repo. If set, overrides usage of buildpacks.
|
|
2925
|
+
"""
|
|
2926
|
+
environment_slug: NotRequired[pulumi.Input[str]]
|
|
2927
|
+
"""
|
|
2928
|
+
An environment slug describing the type of this app.
|
|
2929
|
+
"""
|
|
2930
|
+
envs: NotRequired[pulumi.Input[Sequence[pulumi.Input['AppSpecJobEnvArgsDict']]]]
|
|
2931
|
+
"""
|
|
2932
|
+
Describes an environment variable made available to an app competent.
|
|
2933
|
+
"""
|
|
2934
|
+
git: NotRequired[pulumi.Input['AppSpecJobGitArgsDict']]
|
|
2935
|
+
"""
|
|
2936
|
+
A Git repo to use as the component's source. The repository must be able to be cloned without authentication. Only one of `git`, `github` or `gitlab` may be set.
|
|
2937
|
+
"""
|
|
2938
|
+
github: NotRequired[pulumi.Input['AppSpecJobGithubArgsDict']]
|
|
2939
|
+
"""
|
|
2940
|
+
A GitHub repo to use as the component's source. DigitalOcean App Platform must have [access to the repository](https://cloud.digitalocean.com/apps/github/install). Only one of `git`, `github`, `gitlab`, or `image` may be set.
|
|
2941
|
+
"""
|
|
2942
|
+
gitlab: NotRequired[pulumi.Input['AppSpecJobGitlabArgsDict']]
|
|
2943
|
+
"""
|
|
2944
|
+
A Gitlab repo to use as the component's source. DigitalOcean App Platform must have [access to the repository](https://cloud.digitalocean.com/apps/gitlab/install). Only one of `git`, `github`, `gitlab`, or `image` may be set.
|
|
2945
|
+
"""
|
|
2946
|
+
image: NotRequired[pulumi.Input['AppSpecJobImageArgsDict']]
|
|
2947
|
+
"""
|
|
2948
|
+
An image to use as the component's source. Only one of `git`, `github`, `gitlab`, or `image` may be set.
|
|
2949
|
+
"""
|
|
2950
|
+
instance_count: NotRequired[pulumi.Input[int]]
|
|
2951
|
+
"""
|
|
2952
|
+
The amount of instances that this component should be scaled to.
|
|
2953
|
+
"""
|
|
2954
|
+
instance_size_slug: NotRequired[pulumi.Input[str]]
|
|
2955
|
+
"""
|
|
2956
|
+
The instance size to use for this component. This determines the plan (basic or professional) and the available CPU and memory. The list of available instance sizes can be [found with the API](https://docs.digitalocean.com/reference/api/api-reference/#operation/list_instance_sizes) or using the [doctl CLI](https://docs.digitalocean.com/reference/doctl/) (`doctl apps tier instance-size list`). Default: `basic-xxs`
|
|
2957
|
+
"""
|
|
2958
|
+
kind: NotRequired[pulumi.Input[str]]
|
|
2959
|
+
"""
|
|
2960
|
+
The type of job and when it will be run during the deployment process. It may be one of:
|
|
2961
|
+
- `UNSPECIFIED`: Default job type, will auto-complete to POST_DEPLOY kind.
|
|
2962
|
+
- `PRE_DEPLOY`: Indicates a job that runs before an app deployment.
|
|
2963
|
+
- `POST_DEPLOY`: Indicates a job that runs after an app deployment.
|
|
2964
|
+
- `FAILED_DEPLOY`: Indicates a job that runs after a component fails to deploy.
|
|
2965
|
+
"""
|
|
2966
|
+
log_destinations: NotRequired[pulumi.Input[Sequence[pulumi.Input['AppSpecJobLogDestinationArgsDict']]]]
|
|
2967
|
+
"""
|
|
2968
|
+
Describes a log forwarding destination.
|
|
2969
|
+
"""
|
|
2970
|
+
run_command: NotRequired[pulumi.Input[str]]
|
|
2971
|
+
"""
|
|
2972
|
+
An optional run command to override the component's default.
|
|
2973
|
+
"""
|
|
2974
|
+
source_dir: NotRequired[pulumi.Input[str]]
|
|
2975
|
+
"""
|
|
2976
|
+
An optional path to the working directory to use for the build.
|
|
2977
|
+
"""
|
|
2978
|
+
elif False:
|
|
2979
|
+
AppSpecJobArgsDict: TypeAlias = Mapping[str, Any]
|
|
2980
|
+
|
|
2169
2981
|
@pulumi.input_type
|
|
2170
2982
|
class AppSpecJobArgs:
|
|
2171
2983
|
def __init__(__self__, *,
|
|
@@ -2436,6 +3248,31 @@ class AppSpecJobArgs:
|
|
|
2436
3248
|
pulumi.set(self, "source_dir", value)
|
|
2437
3249
|
|
|
2438
3250
|
|
|
3251
|
+
if not MYPY:
|
|
3252
|
+
class AppSpecJobAlertArgsDict(TypedDict):
|
|
3253
|
+
operator: pulumi.Input[str]
|
|
3254
|
+
"""
|
|
3255
|
+
The operator to use. This is either of `GREATER_THAN` or `LESS_THAN`.
|
|
3256
|
+
"""
|
|
3257
|
+
rule: pulumi.Input[str]
|
|
3258
|
+
"""
|
|
3259
|
+
The type of the alert to configure. Component app alert policies can be: `CPU_UTILIZATION`, `MEM_UTILIZATION`, or `RESTART_COUNT`.
|
|
3260
|
+
"""
|
|
3261
|
+
value: pulumi.Input[float]
|
|
3262
|
+
"""
|
|
3263
|
+
The threshold for the type of the warning.
|
|
3264
|
+
"""
|
|
3265
|
+
window: pulumi.Input[str]
|
|
3266
|
+
"""
|
|
3267
|
+
The time before alerts should be triggered. This is may be one of: `FIVE_MINUTES`, `TEN_MINUTES`, `THIRTY_MINUTES`, `ONE_HOUR`.
|
|
3268
|
+
"""
|
|
3269
|
+
disabled: NotRequired[pulumi.Input[bool]]
|
|
3270
|
+
"""
|
|
3271
|
+
Determines whether or not the alert is disabled (default: `false`).
|
|
3272
|
+
"""
|
|
3273
|
+
elif False:
|
|
3274
|
+
AppSpecJobAlertArgsDict: TypeAlias = Mapping[str, Any]
|
|
3275
|
+
|
|
2439
3276
|
@pulumi.input_type
|
|
2440
3277
|
class AppSpecJobAlertArgs:
|
|
2441
3278
|
def __init__(__self__, *,
|
|
@@ -2519,6 +3356,27 @@ class AppSpecJobAlertArgs:
|
|
|
2519
3356
|
pulumi.set(self, "disabled", value)
|
|
2520
3357
|
|
|
2521
3358
|
|
|
3359
|
+
if not MYPY:
|
|
3360
|
+
class AppSpecJobEnvArgsDict(TypedDict):
|
|
3361
|
+
key: NotRequired[pulumi.Input[str]]
|
|
3362
|
+
"""
|
|
3363
|
+
The name of the environment variable.
|
|
3364
|
+
"""
|
|
3365
|
+
scope: NotRequired[pulumi.Input[str]]
|
|
3366
|
+
"""
|
|
3367
|
+
The visibility scope of the environment variable. One of `RUN_TIME`, `BUILD_TIME`, or `RUN_AND_BUILD_TIME` (default).
|
|
3368
|
+
"""
|
|
3369
|
+
type: NotRequired[pulumi.Input[str]]
|
|
3370
|
+
"""
|
|
3371
|
+
The type of the environment variable, `GENERAL` or `SECRET`.
|
|
3372
|
+
"""
|
|
3373
|
+
value: NotRequired[pulumi.Input[str]]
|
|
3374
|
+
"""
|
|
3375
|
+
The value of the environment variable.
|
|
3376
|
+
"""
|
|
3377
|
+
elif False:
|
|
3378
|
+
AppSpecJobEnvArgsDict: TypeAlias = Mapping[str, Any]
|
|
3379
|
+
|
|
2522
3380
|
@pulumi.input_type
|
|
2523
3381
|
class AppSpecJobEnvArgs:
|
|
2524
3382
|
def __init__(__self__, *,
|
|
@@ -2590,6 +3448,19 @@ class AppSpecJobEnvArgs:
|
|
|
2590
3448
|
pulumi.set(self, "value", value)
|
|
2591
3449
|
|
|
2592
3450
|
|
|
3451
|
+
if not MYPY:
|
|
3452
|
+
class AppSpecJobGitArgsDict(TypedDict):
|
|
3453
|
+
branch: NotRequired[pulumi.Input[str]]
|
|
3454
|
+
"""
|
|
3455
|
+
The name of the branch to use.
|
|
3456
|
+
"""
|
|
3457
|
+
repo_clone_url: NotRequired[pulumi.Input[str]]
|
|
3458
|
+
"""
|
|
3459
|
+
The clone URL of the repo.
|
|
3460
|
+
"""
|
|
3461
|
+
elif False:
|
|
3462
|
+
AppSpecJobGitArgsDict: TypeAlias = Mapping[str, Any]
|
|
3463
|
+
|
|
2593
3464
|
@pulumi.input_type
|
|
2594
3465
|
class AppSpecJobGitArgs:
|
|
2595
3466
|
def __init__(__self__, *,
|
|
@@ -2629,6 +3500,23 @@ class AppSpecJobGitArgs:
|
|
|
2629
3500
|
pulumi.set(self, "repo_clone_url", value)
|
|
2630
3501
|
|
|
2631
3502
|
|
|
3503
|
+
if not MYPY:
|
|
3504
|
+
class AppSpecJobGithubArgsDict(TypedDict):
|
|
3505
|
+
branch: NotRequired[pulumi.Input[str]]
|
|
3506
|
+
"""
|
|
3507
|
+
The name of the branch to use.
|
|
3508
|
+
"""
|
|
3509
|
+
deploy_on_push: NotRequired[pulumi.Input[bool]]
|
|
3510
|
+
"""
|
|
3511
|
+
Whether to automatically deploy new commits made to the repo.
|
|
3512
|
+
"""
|
|
3513
|
+
repo: NotRequired[pulumi.Input[str]]
|
|
3514
|
+
"""
|
|
3515
|
+
The name of the repo in the format `owner/repo`.
|
|
3516
|
+
"""
|
|
3517
|
+
elif False:
|
|
3518
|
+
AppSpecJobGithubArgsDict: TypeAlias = Mapping[str, Any]
|
|
3519
|
+
|
|
2632
3520
|
@pulumi.input_type
|
|
2633
3521
|
class AppSpecJobGithubArgs:
|
|
2634
3522
|
def __init__(__self__, *,
|
|
@@ -2684,6 +3572,23 @@ class AppSpecJobGithubArgs:
|
|
|
2684
3572
|
pulumi.set(self, "repo", value)
|
|
2685
3573
|
|
|
2686
3574
|
|
|
3575
|
+
if not MYPY:
|
|
3576
|
+
class AppSpecJobGitlabArgsDict(TypedDict):
|
|
3577
|
+
branch: NotRequired[pulumi.Input[str]]
|
|
3578
|
+
"""
|
|
3579
|
+
The name of the branch to use.
|
|
3580
|
+
"""
|
|
3581
|
+
deploy_on_push: NotRequired[pulumi.Input[bool]]
|
|
3582
|
+
"""
|
|
3583
|
+
Whether to automatically deploy new commits made to the repo.
|
|
3584
|
+
"""
|
|
3585
|
+
repo: NotRequired[pulumi.Input[str]]
|
|
3586
|
+
"""
|
|
3587
|
+
The name of the repo in the format `owner/repo`.
|
|
3588
|
+
"""
|
|
3589
|
+
elif False:
|
|
3590
|
+
AppSpecJobGitlabArgsDict: TypeAlias = Mapping[str, Any]
|
|
3591
|
+
|
|
2687
3592
|
@pulumi.input_type
|
|
2688
3593
|
class AppSpecJobGitlabArgs:
|
|
2689
3594
|
def __init__(__self__, *,
|
|
@@ -2739,6 +3644,35 @@ class AppSpecJobGitlabArgs:
|
|
|
2739
3644
|
pulumi.set(self, "repo", value)
|
|
2740
3645
|
|
|
2741
3646
|
|
|
3647
|
+
if not MYPY:
|
|
3648
|
+
class AppSpecJobImageArgsDict(TypedDict):
|
|
3649
|
+
registry_type: pulumi.Input[str]
|
|
3650
|
+
"""
|
|
3651
|
+
The registry type. One of `DOCR` (DigitalOcean container registry) or `DOCKER_HUB`.
|
|
3652
|
+
"""
|
|
3653
|
+
repository: pulumi.Input[str]
|
|
3654
|
+
"""
|
|
3655
|
+
The repository name.
|
|
3656
|
+
"""
|
|
3657
|
+
deploy_on_pushes: NotRequired[pulumi.Input[Sequence[pulumi.Input['AppSpecJobImageDeployOnPushArgsDict']]]]
|
|
3658
|
+
"""
|
|
3659
|
+
Configures automatically deploying images pushed to DOCR.
|
|
3660
|
+
"""
|
|
3661
|
+
registry: NotRequired[pulumi.Input[str]]
|
|
3662
|
+
"""
|
|
3663
|
+
The registry name. Must be left empty for the `DOCR` registry type. Required for the `DOCKER_HUB` registry type.
|
|
3664
|
+
"""
|
|
3665
|
+
registry_credentials: NotRequired[pulumi.Input[str]]
|
|
3666
|
+
"""
|
|
3667
|
+
The credentials required to access a private Docker Hub or GitHub registry, in the following syntax `<username>:<token>`.
|
|
3668
|
+
"""
|
|
3669
|
+
tag: NotRequired[pulumi.Input[str]]
|
|
3670
|
+
"""
|
|
3671
|
+
The repository tag. Defaults to `latest` if not provided.
|
|
3672
|
+
"""
|
|
3673
|
+
elif False:
|
|
3674
|
+
AppSpecJobImageArgsDict: TypeAlias = Mapping[str, Any]
|
|
3675
|
+
|
|
2742
3676
|
@pulumi.input_type
|
|
2743
3677
|
class AppSpecJobImageArgs:
|
|
2744
3678
|
def __init__(__self__, *,
|
|
@@ -2840,6 +3774,15 @@ class AppSpecJobImageArgs:
|
|
|
2840
3774
|
pulumi.set(self, "tag", value)
|
|
2841
3775
|
|
|
2842
3776
|
|
|
3777
|
+
if not MYPY:
|
|
3778
|
+
class AppSpecJobImageDeployOnPushArgsDict(TypedDict):
|
|
3779
|
+
enabled: NotRequired[pulumi.Input[bool]]
|
|
3780
|
+
"""
|
|
3781
|
+
Whether to automatically deploy images pushed to DOCR.
|
|
3782
|
+
"""
|
|
3783
|
+
elif False:
|
|
3784
|
+
AppSpecJobImageDeployOnPushArgsDict: TypeAlias = Mapping[str, Any]
|
|
3785
|
+
|
|
2843
3786
|
@pulumi.input_type
|
|
2844
3787
|
class AppSpecJobImageDeployOnPushArgs:
|
|
2845
3788
|
def __init__(__self__, *,
|
|
@@ -2863,6 +3806,31 @@ class AppSpecJobImageDeployOnPushArgs:
|
|
|
2863
3806
|
pulumi.set(self, "enabled", value)
|
|
2864
3807
|
|
|
2865
3808
|
|
|
3809
|
+
if not MYPY:
|
|
3810
|
+
class AppSpecJobLogDestinationArgsDict(TypedDict):
|
|
3811
|
+
name: pulumi.Input[str]
|
|
3812
|
+
"""
|
|
3813
|
+
Name of the log destination. Minimum length: 2. Maximum length: 42.
|
|
3814
|
+
"""
|
|
3815
|
+
datadog: NotRequired[pulumi.Input['AppSpecJobLogDestinationDatadogArgsDict']]
|
|
3816
|
+
"""
|
|
3817
|
+
Datadog configuration.
|
|
3818
|
+
"""
|
|
3819
|
+
logtail: NotRequired[pulumi.Input['AppSpecJobLogDestinationLogtailArgsDict']]
|
|
3820
|
+
"""
|
|
3821
|
+
Logtail configuration.
|
|
3822
|
+
"""
|
|
3823
|
+
open_search: NotRequired[pulumi.Input['AppSpecJobLogDestinationOpenSearchArgsDict']]
|
|
3824
|
+
"""
|
|
3825
|
+
OpenSearch configuration.
|
|
3826
|
+
"""
|
|
3827
|
+
papertrail: NotRequired[pulumi.Input['AppSpecJobLogDestinationPapertrailArgsDict']]
|
|
3828
|
+
"""
|
|
3829
|
+
Papertrail configuration.
|
|
3830
|
+
"""
|
|
3831
|
+
elif False:
|
|
3832
|
+
AppSpecJobLogDestinationArgsDict: TypeAlias = Mapping[str, Any]
|
|
3833
|
+
|
|
2866
3834
|
@pulumi.input_type
|
|
2867
3835
|
class AppSpecJobLogDestinationArgs:
|
|
2868
3836
|
def __init__(__self__, *,
|
|
@@ -2949,6 +3917,19 @@ class AppSpecJobLogDestinationArgs:
|
|
|
2949
3917
|
pulumi.set(self, "papertrail", value)
|
|
2950
3918
|
|
|
2951
3919
|
|
|
3920
|
+
if not MYPY:
|
|
3921
|
+
class AppSpecJobLogDestinationDatadogArgsDict(TypedDict):
|
|
3922
|
+
api_key: pulumi.Input[str]
|
|
3923
|
+
"""
|
|
3924
|
+
Datadog API key.
|
|
3925
|
+
"""
|
|
3926
|
+
endpoint: NotRequired[pulumi.Input[str]]
|
|
3927
|
+
"""
|
|
3928
|
+
Datadog HTTP log intake endpoint.
|
|
3929
|
+
"""
|
|
3930
|
+
elif False:
|
|
3931
|
+
AppSpecJobLogDestinationDatadogArgsDict: TypeAlias = Mapping[str, Any]
|
|
3932
|
+
|
|
2952
3933
|
@pulumi.input_type
|
|
2953
3934
|
class AppSpecJobLogDestinationDatadogArgs:
|
|
2954
3935
|
def __init__(__self__, *,
|
|
@@ -2987,9 +3968,18 @@ class AppSpecJobLogDestinationDatadogArgs:
|
|
|
2987
3968
|
pulumi.set(self, "endpoint", value)
|
|
2988
3969
|
|
|
2989
3970
|
|
|
2990
|
-
|
|
2991
|
-
class
|
|
2992
|
-
|
|
3971
|
+
if not MYPY:
|
|
3972
|
+
class AppSpecJobLogDestinationLogtailArgsDict(TypedDict):
|
|
3973
|
+
token: pulumi.Input[str]
|
|
3974
|
+
"""
|
|
3975
|
+
Logtail token.
|
|
3976
|
+
"""
|
|
3977
|
+
elif False:
|
|
3978
|
+
AppSpecJobLogDestinationLogtailArgsDict: TypeAlias = Mapping[str, Any]
|
|
3979
|
+
|
|
3980
|
+
@pulumi.input_type
|
|
3981
|
+
class AppSpecJobLogDestinationLogtailArgs:
|
|
3982
|
+
def __init__(__self__, *,
|
|
2993
3983
|
token: pulumi.Input[str]):
|
|
2994
3984
|
"""
|
|
2995
3985
|
:param pulumi.Input[str] token: Logtail token.
|
|
@@ -3009,6 +3999,27 @@ class AppSpecJobLogDestinationLogtailArgs:
|
|
|
3009
3999
|
pulumi.set(self, "token", value)
|
|
3010
4000
|
|
|
3011
4001
|
|
|
4002
|
+
if not MYPY:
|
|
4003
|
+
class AppSpecJobLogDestinationOpenSearchArgsDict(TypedDict):
|
|
4004
|
+
basic_auth: pulumi.Input['AppSpecJobLogDestinationOpenSearchBasicAuthArgsDict']
|
|
4005
|
+
"""
|
|
4006
|
+
Basic authentication details.
|
|
4007
|
+
"""
|
|
4008
|
+
cluster_name: NotRequired[pulumi.Input[str]]
|
|
4009
|
+
"""
|
|
4010
|
+
The name of the underlying DigitalOcean DBaaS cluster. This is required for production databases. For dev databases, if `cluster_name` is not set, a new cluster will be provisioned.
|
|
4011
|
+
"""
|
|
4012
|
+
endpoint: NotRequired[pulumi.Input[str]]
|
|
4013
|
+
"""
|
|
4014
|
+
OpenSearch endpoint.
|
|
4015
|
+
"""
|
|
4016
|
+
index_name: NotRequired[pulumi.Input[str]]
|
|
4017
|
+
"""
|
|
4018
|
+
OpenSearch index name.
|
|
4019
|
+
"""
|
|
4020
|
+
elif False:
|
|
4021
|
+
AppSpecJobLogDestinationOpenSearchArgsDict: TypeAlias = Mapping[str, Any]
|
|
4022
|
+
|
|
3012
4023
|
@pulumi.input_type
|
|
3013
4024
|
class AppSpecJobLogDestinationOpenSearchArgs:
|
|
3014
4025
|
def __init__(__self__, *,
|
|
@@ -3079,6 +4090,19 @@ class AppSpecJobLogDestinationOpenSearchArgs:
|
|
|
3079
4090
|
pulumi.set(self, "index_name", value)
|
|
3080
4091
|
|
|
3081
4092
|
|
|
4093
|
+
if not MYPY:
|
|
4094
|
+
class AppSpecJobLogDestinationOpenSearchBasicAuthArgsDict(TypedDict):
|
|
4095
|
+
password: NotRequired[pulumi.Input[str]]
|
|
4096
|
+
"""
|
|
4097
|
+
Password for basic authentication.
|
|
4098
|
+
"""
|
|
4099
|
+
user: NotRequired[pulumi.Input[str]]
|
|
4100
|
+
"""
|
|
4101
|
+
user for basic authentication.
|
|
4102
|
+
"""
|
|
4103
|
+
elif False:
|
|
4104
|
+
AppSpecJobLogDestinationOpenSearchBasicAuthArgsDict: TypeAlias = Mapping[str, Any]
|
|
4105
|
+
|
|
3082
4106
|
@pulumi.input_type
|
|
3083
4107
|
class AppSpecJobLogDestinationOpenSearchBasicAuthArgs:
|
|
3084
4108
|
def __init__(__self__, *,
|
|
@@ -3118,6 +4142,15 @@ class AppSpecJobLogDestinationOpenSearchBasicAuthArgs:
|
|
|
3118
4142
|
pulumi.set(self, "user", value)
|
|
3119
4143
|
|
|
3120
4144
|
|
|
4145
|
+
if not MYPY:
|
|
4146
|
+
class AppSpecJobLogDestinationPapertrailArgsDict(TypedDict):
|
|
4147
|
+
endpoint: pulumi.Input[str]
|
|
4148
|
+
"""
|
|
4149
|
+
Papertrail syslog endpoint.
|
|
4150
|
+
"""
|
|
4151
|
+
elif False:
|
|
4152
|
+
AppSpecJobLogDestinationPapertrailArgsDict: TypeAlias = Mapping[str, Any]
|
|
4153
|
+
|
|
3121
4154
|
@pulumi.input_type
|
|
3122
4155
|
class AppSpecJobLogDestinationPapertrailArgs:
|
|
3123
4156
|
def __init__(__self__, *,
|
|
@@ -3140,6 +4173,95 @@ class AppSpecJobLogDestinationPapertrailArgs:
|
|
|
3140
4173
|
pulumi.set(self, "endpoint", value)
|
|
3141
4174
|
|
|
3142
4175
|
|
|
4176
|
+
if not MYPY:
|
|
4177
|
+
class AppSpecServiceArgsDict(TypedDict):
|
|
4178
|
+
name: pulumi.Input[str]
|
|
4179
|
+
"""
|
|
4180
|
+
The name of the component.
|
|
4181
|
+
"""
|
|
4182
|
+
alerts: NotRequired[pulumi.Input[Sequence[pulumi.Input['AppSpecServiceAlertArgsDict']]]]
|
|
4183
|
+
"""
|
|
4184
|
+
Describes an alert policy for the component.
|
|
4185
|
+
"""
|
|
4186
|
+
autoscaling: NotRequired[pulumi.Input['AppSpecServiceAutoscalingArgsDict']]
|
|
4187
|
+
"""
|
|
4188
|
+
Configuration for automatically scaling this component based on metrics.
|
|
4189
|
+
"""
|
|
4190
|
+
build_command: NotRequired[pulumi.Input[str]]
|
|
4191
|
+
"""
|
|
4192
|
+
An optional build command to run while building this component from source.
|
|
4193
|
+
"""
|
|
4194
|
+
cors: NotRequired[pulumi.Input['AppSpecServiceCorsArgsDict']]
|
|
4195
|
+
"""
|
|
4196
|
+
The [CORS](https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS) policies of the app.
|
|
4197
|
+
"""
|
|
4198
|
+
dockerfile_path: NotRequired[pulumi.Input[str]]
|
|
4199
|
+
"""
|
|
4200
|
+
The path to a Dockerfile relative to the root of the repo. If set, overrides usage of buildpacks.
|
|
4201
|
+
"""
|
|
4202
|
+
environment_slug: NotRequired[pulumi.Input[str]]
|
|
4203
|
+
"""
|
|
4204
|
+
An environment slug describing the type of this app.
|
|
4205
|
+
"""
|
|
4206
|
+
envs: NotRequired[pulumi.Input[Sequence[pulumi.Input['AppSpecServiceEnvArgsDict']]]]
|
|
4207
|
+
"""
|
|
4208
|
+
Describes an environment variable made available to an app competent.
|
|
4209
|
+
"""
|
|
4210
|
+
git: NotRequired[pulumi.Input['AppSpecServiceGitArgsDict']]
|
|
4211
|
+
"""
|
|
4212
|
+
A Git repo to use as the component's source. The repository must be able to be cloned without authentication. Only one of `git`, `github` or `gitlab` may be set.
|
|
4213
|
+
"""
|
|
4214
|
+
github: NotRequired[pulumi.Input['AppSpecServiceGithubArgsDict']]
|
|
4215
|
+
"""
|
|
4216
|
+
A GitHub repo to use as the component's source. DigitalOcean App Platform must have [access to the repository](https://cloud.digitalocean.com/apps/github/install). Only one of `git`, `github`, `gitlab`, or `image` may be set.
|
|
4217
|
+
"""
|
|
4218
|
+
gitlab: NotRequired[pulumi.Input['AppSpecServiceGitlabArgsDict']]
|
|
4219
|
+
"""
|
|
4220
|
+
A Gitlab repo to use as the component's source. DigitalOcean App Platform must have [access to the repository](https://cloud.digitalocean.com/apps/gitlab/install). Only one of `git`, `github`, `gitlab`, or `image` may be set.
|
|
4221
|
+
"""
|
|
4222
|
+
health_check: NotRequired[pulumi.Input['AppSpecServiceHealthCheckArgsDict']]
|
|
4223
|
+
"""
|
|
4224
|
+
A health check to determine the availability of this component.
|
|
4225
|
+
"""
|
|
4226
|
+
http_port: NotRequired[pulumi.Input[int]]
|
|
4227
|
+
"""
|
|
4228
|
+
The internal port on which this service's run command will listen.
|
|
4229
|
+
"""
|
|
4230
|
+
image: NotRequired[pulumi.Input['AppSpecServiceImageArgsDict']]
|
|
4231
|
+
"""
|
|
4232
|
+
An image to use as the component's source. Only one of `git`, `github`, `gitlab`, or `image` may be set.
|
|
4233
|
+
"""
|
|
4234
|
+
instance_count: NotRequired[pulumi.Input[int]]
|
|
4235
|
+
"""
|
|
4236
|
+
The amount of instances that this component should be scaled to.
|
|
4237
|
+
"""
|
|
4238
|
+
instance_size_slug: NotRequired[pulumi.Input[str]]
|
|
4239
|
+
"""
|
|
4240
|
+
The instance size to use for this component. This determines the plan (basic or professional) and the available CPU and memory. The list of available instance sizes can be [found with the API](https://docs.digitalocean.com/reference/api/api-reference/#operation/list_instance_sizes) or using the [doctl CLI](https://docs.digitalocean.com/reference/doctl/) (`doctl apps tier instance-size list`). Default: `basic-xxs`
|
|
4241
|
+
"""
|
|
4242
|
+
internal_ports: NotRequired[pulumi.Input[Sequence[pulumi.Input[int]]]]
|
|
4243
|
+
"""
|
|
4244
|
+
A list of ports on which this service will listen for internal traffic.
|
|
4245
|
+
"""
|
|
4246
|
+
log_destinations: NotRequired[pulumi.Input[Sequence[pulumi.Input['AppSpecServiceLogDestinationArgsDict']]]]
|
|
4247
|
+
"""
|
|
4248
|
+
Describes a log forwarding destination.
|
|
4249
|
+
"""
|
|
4250
|
+
routes: NotRequired[pulumi.Input[Sequence[pulumi.Input['AppSpecServiceRouteArgsDict']]]]
|
|
4251
|
+
"""
|
|
4252
|
+
An HTTP paths that should be routed to this component.
|
|
4253
|
+
"""
|
|
4254
|
+
run_command: NotRequired[pulumi.Input[str]]
|
|
4255
|
+
"""
|
|
4256
|
+
An optional run command to override the component's default.
|
|
4257
|
+
"""
|
|
4258
|
+
source_dir: NotRequired[pulumi.Input[str]]
|
|
4259
|
+
"""
|
|
4260
|
+
An optional path to the working directory to use for the build.
|
|
4261
|
+
"""
|
|
4262
|
+
elif False:
|
|
4263
|
+
AppSpecServiceArgsDict: TypeAlias = Mapping[str, Any]
|
|
4264
|
+
|
|
3143
4265
|
@pulumi.input_type
|
|
3144
4266
|
class AppSpecServiceArgs:
|
|
3145
4267
|
def __init__(__self__, *,
|
|
@@ -3490,6 +4612,31 @@ class AppSpecServiceArgs:
|
|
|
3490
4612
|
pulumi.set(self, "source_dir", value)
|
|
3491
4613
|
|
|
3492
4614
|
|
|
4615
|
+
if not MYPY:
|
|
4616
|
+
class AppSpecServiceAlertArgsDict(TypedDict):
|
|
4617
|
+
operator: pulumi.Input[str]
|
|
4618
|
+
"""
|
|
4619
|
+
The operator to use. This is either of `GREATER_THAN` or `LESS_THAN`.
|
|
4620
|
+
"""
|
|
4621
|
+
rule: pulumi.Input[str]
|
|
4622
|
+
"""
|
|
4623
|
+
The type of the alert to configure. Component app alert policies can be: `CPU_UTILIZATION`, `MEM_UTILIZATION`, or `RESTART_COUNT`.
|
|
4624
|
+
"""
|
|
4625
|
+
value: pulumi.Input[float]
|
|
4626
|
+
"""
|
|
4627
|
+
The threshold for the type of the warning.
|
|
4628
|
+
"""
|
|
4629
|
+
window: pulumi.Input[str]
|
|
4630
|
+
"""
|
|
4631
|
+
The time before alerts should be triggered. This is may be one of: `FIVE_MINUTES`, `TEN_MINUTES`, `THIRTY_MINUTES`, `ONE_HOUR`.
|
|
4632
|
+
"""
|
|
4633
|
+
disabled: NotRequired[pulumi.Input[bool]]
|
|
4634
|
+
"""
|
|
4635
|
+
Determines whether or not the alert is disabled (default: `false`).
|
|
4636
|
+
"""
|
|
4637
|
+
elif False:
|
|
4638
|
+
AppSpecServiceAlertArgsDict: TypeAlias = Mapping[str, Any]
|
|
4639
|
+
|
|
3493
4640
|
@pulumi.input_type
|
|
3494
4641
|
class AppSpecServiceAlertArgs:
|
|
3495
4642
|
def __init__(__self__, *,
|
|
@@ -3573,6 +4720,23 @@ class AppSpecServiceAlertArgs:
|
|
|
3573
4720
|
pulumi.set(self, "disabled", value)
|
|
3574
4721
|
|
|
3575
4722
|
|
|
4723
|
+
if not MYPY:
|
|
4724
|
+
class AppSpecServiceAutoscalingArgsDict(TypedDict):
|
|
4725
|
+
max_instance_count: pulumi.Input[int]
|
|
4726
|
+
"""
|
|
4727
|
+
The maximum amount of instances for this component. Must be more than min_instance_count.
|
|
4728
|
+
"""
|
|
4729
|
+
metrics: pulumi.Input['AppSpecServiceAutoscalingMetricsArgsDict']
|
|
4730
|
+
"""
|
|
4731
|
+
The metrics that the component is scaled on.
|
|
4732
|
+
"""
|
|
4733
|
+
min_instance_count: pulumi.Input[int]
|
|
4734
|
+
"""
|
|
4735
|
+
The minimum amount of instances for this component. Must be less than max_instance_count.
|
|
4736
|
+
"""
|
|
4737
|
+
elif False:
|
|
4738
|
+
AppSpecServiceAutoscalingArgsDict: TypeAlias = Mapping[str, Any]
|
|
4739
|
+
|
|
3576
4740
|
@pulumi.input_type
|
|
3577
4741
|
class AppSpecServiceAutoscalingArgs:
|
|
3578
4742
|
def __init__(__self__, *,
|
|
@@ -3625,6 +4789,15 @@ class AppSpecServiceAutoscalingArgs:
|
|
|
3625
4789
|
pulumi.set(self, "min_instance_count", value)
|
|
3626
4790
|
|
|
3627
4791
|
|
|
4792
|
+
if not MYPY:
|
|
4793
|
+
class AppSpecServiceAutoscalingMetricsArgsDict(TypedDict):
|
|
4794
|
+
cpu: NotRequired[pulumi.Input['AppSpecServiceAutoscalingMetricsCpuArgsDict']]
|
|
4795
|
+
"""
|
|
4796
|
+
Settings for scaling the component based on CPU utilization.
|
|
4797
|
+
"""
|
|
4798
|
+
elif False:
|
|
4799
|
+
AppSpecServiceAutoscalingMetricsArgsDict: TypeAlias = Mapping[str, Any]
|
|
4800
|
+
|
|
3628
4801
|
@pulumi.input_type
|
|
3629
4802
|
class AppSpecServiceAutoscalingMetricsArgs:
|
|
3630
4803
|
def __init__(__self__, *,
|
|
@@ -3648,6 +4821,17 @@ class AppSpecServiceAutoscalingMetricsArgs:
|
|
|
3648
4821
|
pulumi.set(self, "cpu", value)
|
|
3649
4822
|
|
|
3650
4823
|
|
|
4824
|
+
if not MYPY:
|
|
4825
|
+
class AppSpecServiceAutoscalingMetricsCpuArgsDict(TypedDict):
|
|
4826
|
+
percent: pulumi.Input[int]
|
|
4827
|
+
"""
|
|
4828
|
+
The average target CPU utilization for the component.
|
|
4829
|
+
|
|
4830
|
+
A `static_site` can contain:
|
|
4831
|
+
"""
|
|
4832
|
+
elif False:
|
|
4833
|
+
AppSpecServiceAutoscalingMetricsCpuArgsDict: TypeAlias = Mapping[str, Any]
|
|
4834
|
+
|
|
3651
4835
|
@pulumi.input_type
|
|
3652
4836
|
class AppSpecServiceAutoscalingMetricsCpuArgs:
|
|
3653
4837
|
def __init__(__self__, *,
|
|
@@ -3674,6 +4858,35 @@ class AppSpecServiceAutoscalingMetricsCpuArgs:
|
|
|
3674
4858
|
pulumi.set(self, "percent", value)
|
|
3675
4859
|
|
|
3676
4860
|
|
|
4861
|
+
if not MYPY:
|
|
4862
|
+
class AppSpecServiceCorsArgsDict(TypedDict):
|
|
4863
|
+
allow_credentials: NotRequired[pulumi.Input[bool]]
|
|
4864
|
+
"""
|
|
4865
|
+
Whether browsers should expose the response to the client-side JavaScript code when the request’s credentials mode is `include`. This configures the Access-Control-Allow-Credentials header.
|
|
4866
|
+
"""
|
|
4867
|
+
allow_headers: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
4868
|
+
"""
|
|
4869
|
+
The set of allowed HTTP request headers. This configures the Access-Control-Allow-Headers header.
|
|
4870
|
+
"""
|
|
4871
|
+
allow_methods: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
4872
|
+
"""
|
|
4873
|
+
The set of allowed HTTP methods. This configures the Access-Control-Allow-Methods header.
|
|
4874
|
+
"""
|
|
4875
|
+
allow_origins: NotRequired[pulumi.Input['AppSpecServiceCorsAllowOriginsArgsDict']]
|
|
4876
|
+
"""
|
|
4877
|
+
The set of allowed CORS origins. This configures the Access-Control-Allow-Origin header.
|
|
4878
|
+
"""
|
|
4879
|
+
expose_headers: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
4880
|
+
"""
|
|
4881
|
+
The set of HTTP response headers that browsers are allowed to access. This configures the Access-Control-Expose-Headers header.
|
|
4882
|
+
"""
|
|
4883
|
+
max_age: NotRequired[pulumi.Input[str]]
|
|
4884
|
+
"""
|
|
4885
|
+
An optional duration specifying how long browsers can cache the results of a preflight request. This configures the Access-Control-Max-Age header. Example: `5h30m`.
|
|
4886
|
+
"""
|
|
4887
|
+
elif False:
|
|
4888
|
+
AppSpecServiceCorsArgsDict: TypeAlias = Mapping[str, Any]
|
|
4889
|
+
|
|
3677
4890
|
@pulumi.input_type
|
|
3678
4891
|
class AppSpecServiceCorsArgs:
|
|
3679
4892
|
def __init__(__self__, *,
|
|
@@ -3777,6 +4990,23 @@ class AppSpecServiceCorsArgs:
|
|
|
3777
4990
|
pulumi.set(self, "max_age", value)
|
|
3778
4991
|
|
|
3779
4992
|
|
|
4993
|
+
if not MYPY:
|
|
4994
|
+
class AppSpecServiceCorsAllowOriginsArgsDict(TypedDict):
|
|
4995
|
+
exact: NotRequired[pulumi.Input[str]]
|
|
4996
|
+
"""
|
|
4997
|
+
Exact string match.
|
|
4998
|
+
"""
|
|
4999
|
+
prefix: NotRequired[pulumi.Input[str]]
|
|
5000
|
+
"""
|
|
5001
|
+
Prefix-based match.
|
|
5002
|
+
"""
|
|
5003
|
+
regex: NotRequired[pulumi.Input[str]]
|
|
5004
|
+
"""
|
|
5005
|
+
RE2 style regex-based match.
|
|
5006
|
+
"""
|
|
5007
|
+
elif False:
|
|
5008
|
+
AppSpecServiceCorsAllowOriginsArgsDict: TypeAlias = Mapping[str, Any]
|
|
5009
|
+
|
|
3780
5010
|
@pulumi.input_type
|
|
3781
5011
|
class AppSpecServiceCorsAllowOriginsArgs:
|
|
3782
5012
|
def __init__(__self__, *,
|
|
@@ -3836,6 +5066,27 @@ class AppSpecServiceCorsAllowOriginsArgs:
|
|
|
3836
5066
|
pulumi.set(self, "regex", value)
|
|
3837
5067
|
|
|
3838
5068
|
|
|
5069
|
+
if not MYPY:
|
|
5070
|
+
class AppSpecServiceEnvArgsDict(TypedDict):
|
|
5071
|
+
key: NotRequired[pulumi.Input[str]]
|
|
5072
|
+
"""
|
|
5073
|
+
The name of the environment variable.
|
|
5074
|
+
"""
|
|
5075
|
+
scope: NotRequired[pulumi.Input[str]]
|
|
5076
|
+
"""
|
|
5077
|
+
The visibility scope of the environment variable. One of `RUN_TIME`, `BUILD_TIME`, or `RUN_AND_BUILD_TIME` (default).
|
|
5078
|
+
"""
|
|
5079
|
+
type: NotRequired[pulumi.Input[str]]
|
|
5080
|
+
"""
|
|
5081
|
+
The type of the environment variable, `GENERAL` or `SECRET`.
|
|
5082
|
+
"""
|
|
5083
|
+
value: NotRequired[pulumi.Input[str]]
|
|
5084
|
+
"""
|
|
5085
|
+
The value of the environment variable.
|
|
5086
|
+
"""
|
|
5087
|
+
elif False:
|
|
5088
|
+
AppSpecServiceEnvArgsDict: TypeAlias = Mapping[str, Any]
|
|
5089
|
+
|
|
3839
5090
|
@pulumi.input_type
|
|
3840
5091
|
class AppSpecServiceEnvArgs:
|
|
3841
5092
|
def __init__(__self__, *,
|
|
@@ -3907,6 +5158,19 @@ class AppSpecServiceEnvArgs:
|
|
|
3907
5158
|
pulumi.set(self, "value", value)
|
|
3908
5159
|
|
|
3909
5160
|
|
|
5161
|
+
if not MYPY:
|
|
5162
|
+
class AppSpecServiceGitArgsDict(TypedDict):
|
|
5163
|
+
branch: NotRequired[pulumi.Input[str]]
|
|
5164
|
+
"""
|
|
5165
|
+
The name of the branch to use.
|
|
5166
|
+
"""
|
|
5167
|
+
repo_clone_url: NotRequired[pulumi.Input[str]]
|
|
5168
|
+
"""
|
|
5169
|
+
The clone URL of the repo.
|
|
5170
|
+
"""
|
|
5171
|
+
elif False:
|
|
5172
|
+
AppSpecServiceGitArgsDict: TypeAlias = Mapping[str, Any]
|
|
5173
|
+
|
|
3910
5174
|
@pulumi.input_type
|
|
3911
5175
|
class AppSpecServiceGitArgs:
|
|
3912
5176
|
def __init__(__self__, *,
|
|
@@ -3946,6 +5210,23 @@ class AppSpecServiceGitArgs:
|
|
|
3946
5210
|
pulumi.set(self, "repo_clone_url", value)
|
|
3947
5211
|
|
|
3948
5212
|
|
|
5213
|
+
if not MYPY:
|
|
5214
|
+
class AppSpecServiceGithubArgsDict(TypedDict):
|
|
5215
|
+
branch: NotRequired[pulumi.Input[str]]
|
|
5216
|
+
"""
|
|
5217
|
+
The name of the branch to use.
|
|
5218
|
+
"""
|
|
5219
|
+
deploy_on_push: NotRequired[pulumi.Input[bool]]
|
|
5220
|
+
"""
|
|
5221
|
+
Whether to automatically deploy new commits made to the repo.
|
|
5222
|
+
"""
|
|
5223
|
+
repo: NotRequired[pulumi.Input[str]]
|
|
5224
|
+
"""
|
|
5225
|
+
The name of the repo in the format `owner/repo`.
|
|
5226
|
+
"""
|
|
5227
|
+
elif False:
|
|
5228
|
+
AppSpecServiceGithubArgsDict: TypeAlias = Mapping[str, Any]
|
|
5229
|
+
|
|
3949
5230
|
@pulumi.input_type
|
|
3950
5231
|
class AppSpecServiceGithubArgs:
|
|
3951
5232
|
def __init__(__self__, *,
|
|
@@ -4001,6 +5282,23 @@ class AppSpecServiceGithubArgs:
|
|
|
4001
5282
|
pulumi.set(self, "repo", value)
|
|
4002
5283
|
|
|
4003
5284
|
|
|
5285
|
+
if not MYPY:
|
|
5286
|
+
class AppSpecServiceGitlabArgsDict(TypedDict):
|
|
5287
|
+
branch: NotRequired[pulumi.Input[str]]
|
|
5288
|
+
"""
|
|
5289
|
+
The name of the branch to use.
|
|
5290
|
+
"""
|
|
5291
|
+
deploy_on_push: NotRequired[pulumi.Input[bool]]
|
|
5292
|
+
"""
|
|
5293
|
+
Whether to automatically deploy new commits made to the repo.
|
|
5294
|
+
"""
|
|
5295
|
+
repo: NotRequired[pulumi.Input[str]]
|
|
5296
|
+
"""
|
|
5297
|
+
The name of the repo in the format `owner/repo`.
|
|
5298
|
+
"""
|
|
5299
|
+
elif False:
|
|
5300
|
+
AppSpecServiceGitlabArgsDict: TypeAlias = Mapping[str, Any]
|
|
5301
|
+
|
|
4004
5302
|
@pulumi.input_type
|
|
4005
5303
|
class AppSpecServiceGitlabArgs:
|
|
4006
5304
|
def __init__(__self__, *,
|
|
@@ -4056,6 +5354,39 @@ class AppSpecServiceGitlabArgs:
|
|
|
4056
5354
|
pulumi.set(self, "repo", value)
|
|
4057
5355
|
|
|
4058
5356
|
|
|
5357
|
+
if not MYPY:
|
|
5358
|
+
class AppSpecServiceHealthCheckArgsDict(TypedDict):
|
|
5359
|
+
failure_threshold: NotRequired[pulumi.Input[int]]
|
|
5360
|
+
"""
|
|
5361
|
+
The number of failed health checks before considered unhealthy.
|
|
5362
|
+
"""
|
|
5363
|
+
http_path: NotRequired[pulumi.Input[str]]
|
|
5364
|
+
"""
|
|
5365
|
+
The route path used for the HTTP health check ping.
|
|
5366
|
+
"""
|
|
5367
|
+
initial_delay_seconds: NotRequired[pulumi.Input[int]]
|
|
5368
|
+
"""
|
|
5369
|
+
The number of seconds to wait before beginning health checks.
|
|
5370
|
+
"""
|
|
5371
|
+
period_seconds: NotRequired[pulumi.Input[int]]
|
|
5372
|
+
"""
|
|
5373
|
+
The number of seconds to wait between health checks.
|
|
5374
|
+
"""
|
|
5375
|
+
port: NotRequired[pulumi.Input[int]]
|
|
5376
|
+
"""
|
|
5377
|
+
The health check will be performed on this port instead of component's HTTP port.
|
|
5378
|
+
"""
|
|
5379
|
+
success_threshold: NotRequired[pulumi.Input[int]]
|
|
5380
|
+
"""
|
|
5381
|
+
The number of successful health checks before considered healthy.
|
|
5382
|
+
"""
|
|
5383
|
+
timeout_seconds: NotRequired[pulumi.Input[int]]
|
|
5384
|
+
"""
|
|
5385
|
+
The number of seconds after which the check times out.
|
|
5386
|
+
"""
|
|
5387
|
+
elif False:
|
|
5388
|
+
AppSpecServiceHealthCheckArgsDict: TypeAlias = Mapping[str, Any]
|
|
5389
|
+
|
|
4059
5390
|
@pulumi.input_type
|
|
4060
5391
|
class AppSpecServiceHealthCheckArgs:
|
|
4061
5392
|
def __init__(__self__, *,
|
|
@@ -4175,6 +5506,35 @@ class AppSpecServiceHealthCheckArgs:
|
|
|
4175
5506
|
pulumi.set(self, "timeout_seconds", value)
|
|
4176
5507
|
|
|
4177
5508
|
|
|
5509
|
+
if not MYPY:
|
|
5510
|
+
class AppSpecServiceImageArgsDict(TypedDict):
|
|
5511
|
+
registry_type: pulumi.Input[str]
|
|
5512
|
+
"""
|
|
5513
|
+
The registry type. One of `DOCR` (DigitalOcean container registry) or `DOCKER_HUB`.
|
|
5514
|
+
"""
|
|
5515
|
+
repository: pulumi.Input[str]
|
|
5516
|
+
"""
|
|
5517
|
+
The repository name.
|
|
5518
|
+
"""
|
|
5519
|
+
deploy_on_pushes: NotRequired[pulumi.Input[Sequence[pulumi.Input['AppSpecServiceImageDeployOnPushArgsDict']]]]
|
|
5520
|
+
"""
|
|
5521
|
+
Configures automatically deploying images pushed to DOCR.
|
|
5522
|
+
"""
|
|
5523
|
+
registry: NotRequired[pulumi.Input[str]]
|
|
5524
|
+
"""
|
|
5525
|
+
The registry name. Must be left empty for the `DOCR` registry type. Required for the `DOCKER_HUB` registry type.
|
|
5526
|
+
"""
|
|
5527
|
+
registry_credentials: NotRequired[pulumi.Input[str]]
|
|
5528
|
+
"""
|
|
5529
|
+
The credentials required to access a private Docker Hub or GitHub registry, in the following syntax `<username>:<token>`.
|
|
5530
|
+
"""
|
|
5531
|
+
tag: NotRequired[pulumi.Input[str]]
|
|
5532
|
+
"""
|
|
5533
|
+
The repository tag. Defaults to `latest` if not provided.
|
|
5534
|
+
"""
|
|
5535
|
+
elif False:
|
|
5536
|
+
AppSpecServiceImageArgsDict: TypeAlias = Mapping[str, Any]
|
|
5537
|
+
|
|
4178
5538
|
@pulumi.input_type
|
|
4179
5539
|
class AppSpecServiceImageArgs:
|
|
4180
5540
|
def __init__(__self__, *,
|
|
@@ -4276,6 +5636,15 @@ class AppSpecServiceImageArgs:
|
|
|
4276
5636
|
pulumi.set(self, "tag", value)
|
|
4277
5637
|
|
|
4278
5638
|
|
|
5639
|
+
if not MYPY:
|
|
5640
|
+
class AppSpecServiceImageDeployOnPushArgsDict(TypedDict):
|
|
5641
|
+
enabled: NotRequired[pulumi.Input[bool]]
|
|
5642
|
+
"""
|
|
5643
|
+
Whether to automatically deploy images pushed to DOCR.
|
|
5644
|
+
"""
|
|
5645
|
+
elif False:
|
|
5646
|
+
AppSpecServiceImageDeployOnPushArgsDict: TypeAlias = Mapping[str, Any]
|
|
5647
|
+
|
|
4279
5648
|
@pulumi.input_type
|
|
4280
5649
|
class AppSpecServiceImageDeployOnPushArgs:
|
|
4281
5650
|
def __init__(__self__, *,
|
|
@@ -4299,18 +5668,43 @@ class AppSpecServiceImageDeployOnPushArgs:
|
|
|
4299
5668
|
pulumi.set(self, "enabled", value)
|
|
4300
5669
|
|
|
4301
5670
|
|
|
4302
|
-
|
|
4303
|
-
class
|
|
4304
|
-
|
|
4305
|
-
name: pulumi.Input[str],
|
|
4306
|
-
datadog: Optional[pulumi.Input['AppSpecServiceLogDestinationDatadogArgs']] = None,
|
|
4307
|
-
logtail: Optional[pulumi.Input['AppSpecServiceLogDestinationLogtailArgs']] = None,
|
|
4308
|
-
open_search: Optional[pulumi.Input['AppSpecServiceLogDestinationOpenSearchArgs']] = None,
|
|
4309
|
-
papertrail: Optional[pulumi.Input['AppSpecServiceLogDestinationPapertrailArgs']] = None):
|
|
5671
|
+
if not MYPY:
|
|
5672
|
+
class AppSpecServiceLogDestinationArgsDict(TypedDict):
|
|
5673
|
+
name: pulumi.Input[str]
|
|
4310
5674
|
"""
|
|
4311
|
-
|
|
4312
|
-
|
|
4313
|
-
:
|
|
5675
|
+
Name of the log destination. Minimum length: 2. Maximum length: 42.
|
|
5676
|
+
"""
|
|
5677
|
+
datadog: NotRequired[pulumi.Input['AppSpecServiceLogDestinationDatadogArgsDict']]
|
|
5678
|
+
"""
|
|
5679
|
+
Datadog configuration.
|
|
5680
|
+
"""
|
|
5681
|
+
logtail: NotRequired[pulumi.Input['AppSpecServiceLogDestinationLogtailArgsDict']]
|
|
5682
|
+
"""
|
|
5683
|
+
Logtail configuration.
|
|
5684
|
+
"""
|
|
5685
|
+
open_search: NotRequired[pulumi.Input['AppSpecServiceLogDestinationOpenSearchArgsDict']]
|
|
5686
|
+
"""
|
|
5687
|
+
OpenSearch configuration.
|
|
5688
|
+
"""
|
|
5689
|
+
papertrail: NotRequired[pulumi.Input['AppSpecServiceLogDestinationPapertrailArgsDict']]
|
|
5690
|
+
"""
|
|
5691
|
+
Papertrail configuration.
|
|
5692
|
+
"""
|
|
5693
|
+
elif False:
|
|
5694
|
+
AppSpecServiceLogDestinationArgsDict: TypeAlias = Mapping[str, Any]
|
|
5695
|
+
|
|
5696
|
+
@pulumi.input_type
|
|
5697
|
+
class AppSpecServiceLogDestinationArgs:
|
|
5698
|
+
def __init__(__self__, *,
|
|
5699
|
+
name: pulumi.Input[str],
|
|
5700
|
+
datadog: Optional[pulumi.Input['AppSpecServiceLogDestinationDatadogArgs']] = None,
|
|
5701
|
+
logtail: Optional[pulumi.Input['AppSpecServiceLogDestinationLogtailArgs']] = None,
|
|
5702
|
+
open_search: Optional[pulumi.Input['AppSpecServiceLogDestinationOpenSearchArgs']] = None,
|
|
5703
|
+
papertrail: Optional[pulumi.Input['AppSpecServiceLogDestinationPapertrailArgs']] = None):
|
|
5704
|
+
"""
|
|
5705
|
+
:param pulumi.Input[str] name: Name of the log destination. Minimum length: 2. Maximum length: 42.
|
|
5706
|
+
:param pulumi.Input['AppSpecServiceLogDestinationDatadogArgs'] datadog: Datadog configuration.
|
|
5707
|
+
:param pulumi.Input['AppSpecServiceLogDestinationLogtailArgs'] logtail: Logtail configuration.
|
|
4314
5708
|
:param pulumi.Input['AppSpecServiceLogDestinationOpenSearchArgs'] open_search: OpenSearch configuration.
|
|
4315
5709
|
:param pulumi.Input['AppSpecServiceLogDestinationPapertrailArgs'] papertrail: Papertrail configuration.
|
|
4316
5710
|
"""
|
|
@@ -4385,6 +5779,19 @@ class AppSpecServiceLogDestinationArgs:
|
|
|
4385
5779
|
pulumi.set(self, "papertrail", value)
|
|
4386
5780
|
|
|
4387
5781
|
|
|
5782
|
+
if not MYPY:
|
|
5783
|
+
class AppSpecServiceLogDestinationDatadogArgsDict(TypedDict):
|
|
5784
|
+
api_key: pulumi.Input[str]
|
|
5785
|
+
"""
|
|
5786
|
+
Datadog API key.
|
|
5787
|
+
"""
|
|
5788
|
+
endpoint: NotRequired[pulumi.Input[str]]
|
|
5789
|
+
"""
|
|
5790
|
+
Datadog HTTP log intake endpoint.
|
|
5791
|
+
"""
|
|
5792
|
+
elif False:
|
|
5793
|
+
AppSpecServiceLogDestinationDatadogArgsDict: TypeAlias = Mapping[str, Any]
|
|
5794
|
+
|
|
4388
5795
|
@pulumi.input_type
|
|
4389
5796
|
class AppSpecServiceLogDestinationDatadogArgs:
|
|
4390
5797
|
def __init__(__self__, *,
|
|
@@ -4423,6 +5830,15 @@ class AppSpecServiceLogDestinationDatadogArgs:
|
|
|
4423
5830
|
pulumi.set(self, "endpoint", value)
|
|
4424
5831
|
|
|
4425
5832
|
|
|
5833
|
+
if not MYPY:
|
|
5834
|
+
class AppSpecServiceLogDestinationLogtailArgsDict(TypedDict):
|
|
5835
|
+
token: pulumi.Input[str]
|
|
5836
|
+
"""
|
|
5837
|
+
Logtail token.
|
|
5838
|
+
"""
|
|
5839
|
+
elif False:
|
|
5840
|
+
AppSpecServiceLogDestinationLogtailArgsDict: TypeAlias = Mapping[str, Any]
|
|
5841
|
+
|
|
4426
5842
|
@pulumi.input_type
|
|
4427
5843
|
class AppSpecServiceLogDestinationLogtailArgs:
|
|
4428
5844
|
def __init__(__self__, *,
|
|
@@ -4445,6 +5861,27 @@ class AppSpecServiceLogDestinationLogtailArgs:
|
|
|
4445
5861
|
pulumi.set(self, "token", value)
|
|
4446
5862
|
|
|
4447
5863
|
|
|
5864
|
+
if not MYPY:
|
|
5865
|
+
class AppSpecServiceLogDestinationOpenSearchArgsDict(TypedDict):
|
|
5866
|
+
basic_auth: pulumi.Input['AppSpecServiceLogDestinationOpenSearchBasicAuthArgsDict']
|
|
5867
|
+
"""
|
|
5868
|
+
Basic authentication details.
|
|
5869
|
+
"""
|
|
5870
|
+
cluster_name: NotRequired[pulumi.Input[str]]
|
|
5871
|
+
"""
|
|
5872
|
+
The name of the underlying DigitalOcean DBaaS cluster. This is required for production databases. For dev databases, if `cluster_name` is not set, a new cluster will be provisioned.
|
|
5873
|
+
"""
|
|
5874
|
+
endpoint: NotRequired[pulumi.Input[str]]
|
|
5875
|
+
"""
|
|
5876
|
+
OpenSearch endpoint.
|
|
5877
|
+
"""
|
|
5878
|
+
index_name: NotRequired[pulumi.Input[str]]
|
|
5879
|
+
"""
|
|
5880
|
+
OpenSearch index name.
|
|
5881
|
+
"""
|
|
5882
|
+
elif False:
|
|
5883
|
+
AppSpecServiceLogDestinationOpenSearchArgsDict: TypeAlias = Mapping[str, Any]
|
|
5884
|
+
|
|
4448
5885
|
@pulumi.input_type
|
|
4449
5886
|
class AppSpecServiceLogDestinationOpenSearchArgs:
|
|
4450
5887
|
def __init__(__self__, *,
|
|
@@ -4515,6 +5952,19 @@ class AppSpecServiceLogDestinationOpenSearchArgs:
|
|
|
4515
5952
|
pulumi.set(self, "index_name", value)
|
|
4516
5953
|
|
|
4517
5954
|
|
|
5955
|
+
if not MYPY:
|
|
5956
|
+
class AppSpecServiceLogDestinationOpenSearchBasicAuthArgsDict(TypedDict):
|
|
5957
|
+
password: NotRequired[pulumi.Input[str]]
|
|
5958
|
+
"""
|
|
5959
|
+
Password for basic authentication.
|
|
5960
|
+
"""
|
|
5961
|
+
user: NotRequired[pulumi.Input[str]]
|
|
5962
|
+
"""
|
|
5963
|
+
user for basic authentication.
|
|
5964
|
+
"""
|
|
5965
|
+
elif False:
|
|
5966
|
+
AppSpecServiceLogDestinationOpenSearchBasicAuthArgsDict: TypeAlias = Mapping[str, Any]
|
|
5967
|
+
|
|
4518
5968
|
@pulumi.input_type
|
|
4519
5969
|
class AppSpecServiceLogDestinationOpenSearchBasicAuthArgs:
|
|
4520
5970
|
def __init__(__self__, *,
|
|
@@ -4554,6 +6004,15 @@ class AppSpecServiceLogDestinationOpenSearchBasicAuthArgs:
|
|
|
4554
6004
|
pulumi.set(self, "user", value)
|
|
4555
6005
|
|
|
4556
6006
|
|
|
6007
|
+
if not MYPY:
|
|
6008
|
+
class AppSpecServiceLogDestinationPapertrailArgsDict(TypedDict):
|
|
6009
|
+
endpoint: pulumi.Input[str]
|
|
6010
|
+
"""
|
|
6011
|
+
Papertrail syslog endpoint.
|
|
6012
|
+
"""
|
|
6013
|
+
elif False:
|
|
6014
|
+
AppSpecServiceLogDestinationPapertrailArgsDict: TypeAlias = Mapping[str, Any]
|
|
6015
|
+
|
|
4557
6016
|
@pulumi.input_type
|
|
4558
6017
|
class AppSpecServiceLogDestinationPapertrailArgs:
|
|
4559
6018
|
def __init__(__self__, *,
|
|
@@ -4576,6 +6035,19 @@ class AppSpecServiceLogDestinationPapertrailArgs:
|
|
|
4576
6035
|
pulumi.set(self, "endpoint", value)
|
|
4577
6036
|
|
|
4578
6037
|
|
|
6038
|
+
if not MYPY:
|
|
6039
|
+
class AppSpecServiceRouteArgsDict(TypedDict):
|
|
6040
|
+
path: NotRequired[pulumi.Input[str]]
|
|
6041
|
+
"""
|
|
6042
|
+
Paths must start with `/` and must be unique within the app.
|
|
6043
|
+
"""
|
|
6044
|
+
preserve_path_prefix: NotRequired[pulumi.Input[bool]]
|
|
6045
|
+
"""
|
|
6046
|
+
An optional flag to preserve the path that is forwarded to the backend service.
|
|
6047
|
+
"""
|
|
6048
|
+
elif False:
|
|
6049
|
+
AppSpecServiceRouteArgsDict: TypeAlias = Mapping[str, Any]
|
|
6050
|
+
|
|
4579
6051
|
@pulumi.input_type
|
|
4580
6052
|
class AppSpecServiceRouteArgs:
|
|
4581
6053
|
def __init__(__self__, *,
|
|
@@ -4615,6 +6087,71 @@ class AppSpecServiceRouteArgs:
|
|
|
4615
6087
|
pulumi.set(self, "preserve_path_prefix", value)
|
|
4616
6088
|
|
|
4617
6089
|
|
|
6090
|
+
if not MYPY:
|
|
6091
|
+
class AppSpecStaticSiteArgsDict(TypedDict):
|
|
6092
|
+
name: pulumi.Input[str]
|
|
6093
|
+
"""
|
|
6094
|
+
The name of the component.
|
|
6095
|
+
"""
|
|
6096
|
+
build_command: NotRequired[pulumi.Input[str]]
|
|
6097
|
+
"""
|
|
6098
|
+
An optional build command to run while building this component from source.
|
|
6099
|
+
"""
|
|
6100
|
+
catchall_document: NotRequired[pulumi.Input[str]]
|
|
6101
|
+
"""
|
|
6102
|
+
The name of the document to use as the fallback for any requests to documents that are not found when serving this static site.
|
|
6103
|
+
"""
|
|
6104
|
+
cors: NotRequired[pulumi.Input['AppSpecStaticSiteCorsArgsDict']]
|
|
6105
|
+
"""
|
|
6106
|
+
The [CORS](https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS) policies of the app.
|
|
6107
|
+
"""
|
|
6108
|
+
dockerfile_path: NotRequired[pulumi.Input[str]]
|
|
6109
|
+
"""
|
|
6110
|
+
The path to a Dockerfile relative to the root of the repo. If set, overrides usage of buildpacks.
|
|
6111
|
+
"""
|
|
6112
|
+
environment_slug: NotRequired[pulumi.Input[str]]
|
|
6113
|
+
"""
|
|
6114
|
+
An environment slug describing the type of this app.
|
|
6115
|
+
"""
|
|
6116
|
+
envs: NotRequired[pulumi.Input[Sequence[pulumi.Input['AppSpecStaticSiteEnvArgsDict']]]]
|
|
6117
|
+
"""
|
|
6118
|
+
Describes an environment variable made available to an app competent.
|
|
6119
|
+
"""
|
|
6120
|
+
error_document: NotRequired[pulumi.Input[str]]
|
|
6121
|
+
"""
|
|
6122
|
+
The name of the error document to use when serving this static site.
|
|
6123
|
+
"""
|
|
6124
|
+
git: NotRequired[pulumi.Input['AppSpecStaticSiteGitArgsDict']]
|
|
6125
|
+
"""
|
|
6126
|
+
A Git repo to use as the component's source. The repository must be able to be cloned without authentication. Only one of `git`, `github` or `gitlab` may be set.
|
|
6127
|
+
"""
|
|
6128
|
+
github: NotRequired[pulumi.Input['AppSpecStaticSiteGithubArgsDict']]
|
|
6129
|
+
"""
|
|
6130
|
+
A GitHub repo to use as the component's source. DigitalOcean App Platform must have [access to the repository](https://cloud.digitalocean.com/apps/github/install). Only one of `git`, `github`, `gitlab`, or `image` may be set.
|
|
6131
|
+
"""
|
|
6132
|
+
gitlab: NotRequired[pulumi.Input['AppSpecStaticSiteGitlabArgsDict']]
|
|
6133
|
+
"""
|
|
6134
|
+
A Gitlab repo to use as the component's source. DigitalOcean App Platform must have [access to the repository](https://cloud.digitalocean.com/apps/gitlab/install). Only one of `git`, `github`, `gitlab`, or `image` may be set.
|
|
6135
|
+
"""
|
|
6136
|
+
index_document: NotRequired[pulumi.Input[str]]
|
|
6137
|
+
"""
|
|
6138
|
+
The name of the index document to use when serving this static site.
|
|
6139
|
+
"""
|
|
6140
|
+
output_dir: NotRequired[pulumi.Input[str]]
|
|
6141
|
+
"""
|
|
6142
|
+
An optional path to where the built assets will be located, relative to the build context. If not set, App Platform will automatically scan for these directory names: `_static`, `dist`, `public`.
|
|
6143
|
+
"""
|
|
6144
|
+
routes: NotRequired[pulumi.Input[Sequence[pulumi.Input['AppSpecStaticSiteRouteArgsDict']]]]
|
|
6145
|
+
"""
|
|
6146
|
+
An HTTP paths that should be routed to this component.
|
|
6147
|
+
"""
|
|
6148
|
+
source_dir: NotRequired[pulumi.Input[str]]
|
|
6149
|
+
"""
|
|
6150
|
+
An optional path to the working directory to use for the build.
|
|
6151
|
+
"""
|
|
6152
|
+
elif False:
|
|
6153
|
+
AppSpecStaticSiteArgsDict: TypeAlias = Mapping[str, Any]
|
|
6154
|
+
|
|
4618
6155
|
@pulumi.input_type
|
|
4619
6156
|
class AppSpecStaticSiteArgs:
|
|
4620
6157
|
def __init__(__self__, *,
|
|
@@ -4869,6 +6406,35 @@ class AppSpecStaticSiteArgs:
|
|
|
4869
6406
|
pulumi.set(self, "source_dir", value)
|
|
4870
6407
|
|
|
4871
6408
|
|
|
6409
|
+
if not MYPY:
|
|
6410
|
+
class AppSpecStaticSiteCorsArgsDict(TypedDict):
|
|
6411
|
+
allow_credentials: NotRequired[pulumi.Input[bool]]
|
|
6412
|
+
"""
|
|
6413
|
+
Whether browsers should expose the response to the client-side JavaScript code when the request’s credentials mode is `include`. This configures the Access-Control-Allow-Credentials header.
|
|
6414
|
+
"""
|
|
6415
|
+
allow_headers: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
6416
|
+
"""
|
|
6417
|
+
The set of allowed HTTP request headers. This configures the Access-Control-Allow-Headers header.
|
|
6418
|
+
"""
|
|
6419
|
+
allow_methods: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
6420
|
+
"""
|
|
6421
|
+
The set of allowed HTTP methods. This configures the Access-Control-Allow-Methods header.
|
|
6422
|
+
"""
|
|
6423
|
+
allow_origins: NotRequired[pulumi.Input['AppSpecStaticSiteCorsAllowOriginsArgsDict']]
|
|
6424
|
+
"""
|
|
6425
|
+
The set of allowed CORS origins. This configures the Access-Control-Allow-Origin header.
|
|
6426
|
+
"""
|
|
6427
|
+
expose_headers: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
6428
|
+
"""
|
|
6429
|
+
The set of HTTP response headers that browsers are allowed to access. This configures the Access-Control-Expose-Headers header.
|
|
6430
|
+
"""
|
|
6431
|
+
max_age: NotRequired[pulumi.Input[str]]
|
|
6432
|
+
"""
|
|
6433
|
+
An optional duration specifying how long browsers can cache the results of a preflight request. This configures the Access-Control-Max-Age header. Example: `5h30m`.
|
|
6434
|
+
"""
|
|
6435
|
+
elif False:
|
|
6436
|
+
AppSpecStaticSiteCorsArgsDict: TypeAlias = Mapping[str, Any]
|
|
6437
|
+
|
|
4872
6438
|
@pulumi.input_type
|
|
4873
6439
|
class AppSpecStaticSiteCorsArgs:
|
|
4874
6440
|
def __init__(__self__, *,
|
|
@@ -4972,6 +6538,23 @@ class AppSpecStaticSiteCorsArgs:
|
|
|
4972
6538
|
pulumi.set(self, "max_age", value)
|
|
4973
6539
|
|
|
4974
6540
|
|
|
6541
|
+
if not MYPY:
|
|
6542
|
+
class AppSpecStaticSiteCorsAllowOriginsArgsDict(TypedDict):
|
|
6543
|
+
exact: NotRequired[pulumi.Input[str]]
|
|
6544
|
+
"""
|
|
6545
|
+
Exact string match.
|
|
6546
|
+
"""
|
|
6547
|
+
prefix: NotRequired[pulumi.Input[str]]
|
|
6548
|
+
"""
|
|
6549
|
+
Prefix-based match.
|
|
6550
|
+
"""
|
|
6551
|
+
regex: NotRequired[pulumi.Input[str]]
|
|
6552
|
+
"""
|
|
6553
|
+
RE2 style regex-based match.
|
|
6554
|
+
"""
|
|
6555
|
+
elif False:
|
|
6556
|
+
AppSpecStaticSiteCorsAllowOriginsArgsDict: TypeAlias = Mapping[str, Any]
|
|
6557
|
+
|
|
4975
6558
|
@pulumi.input_type
|
|
4976
6559
|
class AppSpecStaticSiteCorsAllowOriginsArgs:
|
|
4977
6560
|
def __init__(__self__, *,
|
|
@@ -5031,6 +6614,27 @@ class AppSpecStaticSiteCorsAllowOriginsArgs:
|
|
|
5031
6614
|
pulumi.set(self, "regex", value)
|
|
5032
6615
|
|
|
5033
6616
|
|
|
6617
|
+
if not MYPY:
|
|
6618
|
+
class AppSpecStaticSiteEnvArgsDict(TypedDict):
|
|
6619
|
+
key: NotRequired[pulumi.Input[str]]
|
|
6620
|
+
"""
|
|
6621
|
+
The name of the environment variable.
|
|
6622
|
+
"""
|
|
6623
|
+
scope: NotRequired[pulumi.Input[str]]
|
|
6624
|
+
"""
|
|
6625
|
+
The visibility scope of the environment variable. One of `RUN_TIME`, `BUILD_TIME`, or `RUN_AND_BUILD_TIME` (default).
|
|
6626
|
+
"""
|
|
6627
|
+
type: NotRequired[pulumi.Input[str]]
|
|
6628
|
+
"""
|
|
6629
|
+
The type of the environment variable, `GENERAL` or `SECRET`.
|
|
6630
|
+
"""
|
|
6631
|
+
value: NotRequired[pulumi.Input[str]]
|
|
6632
|
+
"""
|
|
6633
|
+
The value of the environment variable.
|
|
6634
|
+
"""
|
|
6635
|
+
elif False:
|
|
6636
|
+
AppSpecStaticSiteEnvArgsDict: TypeAlias = Mapping[str, Any]
|
|
6637
|
+
|
|
5034
6638
|
@pulumi.input_type
|
|
5035
6639
|
class AppSpecStaticSiteEnvArgs:
|
|
5036
6640
|
def __init__(__self__, *,
|
|
@@ -5102,6 +6706,19 @@ class AppSpecStaticSiteEnvArgs:
|
|
|
5102
6706
|
pulumi.set(self, "value", value)
|
|
5103
6707
|
|
|
5104
6708
|
|
|
6709
|
+
if not MYPY:
|
|
6710
|
+
class AppSpecStaticSiteGitArgsDict(TypedDict):
|
|
6711
|
+
branch: NotRequired[pulumi.Input[str]]
|
|
6712
|
+
"""
|
|
6713
|
+
The name of the branch to use.
|
|
6714
|
+
"""
|
|
6715
|
+
repo_clone_url: NotRequired[pulumi.Input[str]]
|
|
6716
|
+
"""
|
|
6717
|
+
The clone URL of the repo.
|
|
6718
|
+
"""
|
|
6719
|
+
elif False:
|
|
6720
|
+
AppSpecStaticSiteGitArgsDict: TypeAlias = Mapping[str, Any]
|
|
6721
|
+
|
|
5105
6722
|
@pulumi.input_type
|
|
5106
6723
|
class AppSpecStaticSiteGitArgs:
|
|
5107
6724
|
def __init__(__self__, *,
|
|
@@ -5141,6 +6758,23 @@ class AppSpecStaticSiteGitArgs:
|
|
|
5141
6758
|
pulumi.set(self, "repo_clone_url", value)
|
|
5142
6759
|
|
|
5143
6760
|
|
|
6761
|
+
if not MYPY:
|
|
6762
|
+
class AppSpecStaticSiteGithubArgsDict(TypedDict):
|
|
6763
|
+
branch: NotRequired[pulumi.Input[str]]
|
|
6764
|
+
"""
|
|
6765
|
+
The name of the branch to use.
|
|
6766
|
+
"""
|
|
6767
|
+
deploy_on_push: NotRequired[pulumi.Input[bool]]
|
|
6768
|
+
"""
|
|
6769
|
+
Whether to automatically deploy new commits made to the repo.
|
|
6770
|
+
"""
|
|
6771
|
+
repo: NotRequired[pulumi.Input[str]]
|
|
6772
|
+
"""
|
|
6773
|
+
The name of the repo in the format `owner/repo`.
|
|
6774
|
+
"""
|
|
6775
|
+
elif False:
|
|
6776
|
+
AppSpecStaticSiteGithubArgsDict: TypeAlias = Mapping[str, Any]
|
|
6777
|
+
|
|
5144
6778
|
@pulumi.input_type
|
|
5145
6779
|
class AppSpecStaticSiteGithubArgs:
|
|
5146
6780
|
def __init__(__self__, *,
|
|
@@ -5196,6 +6830,23 @@ class AppSpecStaticSiteGithubArgs:
|
|
|
5196
6830
|
pulumi.set(self, "repo", value)
|
|
5197
6831
|
|
|
5198
6832
|
|
|
6833
|
+
if not MYPY:
|
|
6834
|
+
class AppSpecStaticSiteGitlabArgsDict(TypedDict):
|
|
6835
|
+
branch: NotRequired[pulumi.Input[str]]
|
|
6836
|
+
"""
|
|
6837
|
+
The name of the branch to use.
|
|
6838
|
+
"""
|
|
6839
|
+
deploy_on_push: NotRequired[pulumi.Input[bool]]
|
|
6840
|
+
"""
|
|
6841
|
+
Whether to automatically deploy new commits made to the repo.
|
|
6842
|
+
"""
|
|
6843
|
+
repo: NotRequired[pulumi.Input[str]]
|
|
6844
|
+
"""
|
|
6845
|
+
The name of the repo in the format `owner/repo`.
|
|
6846
|
+
"""
|
|
6847
|
+
elif False:
|
|
6848
|
+
AppSpecStaticSiteGitlabArgsDict: TypeAlias = Mapping[str, Any]
|
|
6849
|
+
|
|
5199
6850
|
@pulumi.input_type
|
|
5200
6851
|
class AppSpecStaticSiteGitlabArgs:
|
|
5201
6852
|
def __init__(__self__, *,
|
|
@@ -5251,6 +6902,19 @@ class AppSpecStaticSiteGitlabArgs:
|
|
|
5251
6902
|
pulumi.set(self, "repo", value)
|
|
5252
6903
|
|
|
5253
6904
|
|
|
6905
|
+
if not MYPY:
|
|
6906
|
+
class AppSpecStaticSiteRouteArgsDict(TypedDict):
|
|
6907
|
+
path: NotRequired[pulumi.Input[str]]
|
|
6908
|
+
"""
|
|
6909
|
+
Paths must start with `/` and must be unique within the app.
|
|
6910
|
+
"""
|
|
6911
|
+
preserve_path_prefix: NotRequired[pulumi.Input[bool]]
|
|
6912
|
+
"""
|
|
6913
|
+
An optional flag to preserve the path that is forwarded to the backend service.
|
|
6914
|
+
"""
|
|
6915
|
+
elif False:
|
|
6916
|
+
AppSpecStaticSiteRouteArgsDict: TypeAlias = Mapping[str, Any]
|
|
6917
|
+
|
|
5254
6918
|
@pulumi.input_type
|
|
5255
6919
|
class AppSpecStaticSiteRouteArgs:
|
|
5256
6920
|
def __init__(__self__, *,
|
|
@@ -5290,6 +6954,71 @@ class AppSpecStaticSiteRouteArgs:
|
|
|
5290
6954
|
pulumi.set(self, "preserve_path_prefix", value)
|
|
5291
6955
|
|
|
5292
6956
|
|
|
6957
|
+
if not MYPY:
|
|
6958
|
+
class AppSpecWorkerArgsDict(TypedDict):
|
|
6959
|
+
name: pulumi.Input[str]
|
|
6960
|
+
"""
|
|
6961
|
+
The name of the component.
|
|
6962
|
+
"""
|
|
6963
|
+
alerts: NotRequired[pulumi.Input[Sequence[pulumi.Input['AppSpecWorkerAlertArgsDict']]]]
|
|
6964
|
+
"""
|
|
6965
|
+
Describes an alert policy for the component.
|
|
6966
|
+
"""
|
|
6967
|
+
build_command: NotRequired[pulumi.Input[str]]
|
|
6968
|
+
"""
|
|
6969
|
+
An optional build command to run while building this component from source.
|
|
6970
|
+
"""
|
|
6971
|
+
dockerfile_path: NotRequired[pulumi.Input[str]]
|
|
6972
|
+
"""
|
|
6973
|
+
The path to a Dockerfile relative to the root of the repo. If set, overrides usage of buildpacks.
|
|
6974
|
+
"""
|
|
6975
|
+
environment_slug: NotRequired[pulumi.Input[str]]
|
|
6976
|
+
"""
|
|
6977
|
+
An environment slug describing the type of this app.
|
|
6978
|
+
"""
|
|
6979
|
+
envs: NotRequired[pulumi.Input[Sequence[pulumi.Input['AppSpecWorkerEnvArgsDict']]]]
|
|
6980
|
+
"""
|
|
6981
|
+
Describes an environment variable made available to an app competent.
|
|
6982
|
+
"""
|
|
6983
|
+
git: NotRequired[pulumi.Input['AppSpecWorkerGitArgsDict']]
|
|
6984
|
+
"""
|
|
6985
|
+
A Git repo to use as the component's source. The repository must be able to be cloned without authentication. Only one of `git`, `github` or `gitlab` may be set.
|
|
6986
|
+
"""
|
|
6987
|
+
github: NotRequired[pulumi.Input['AppSpecWorkerGithubArgsDict']]
|
|
6988
|
+
"""
|
|
6989
|
+
A GitHub repo to use as the component's source. DigitalOcean App Platform must have [access to the repository](https://cloud.digitalocean.com/apps/github/install). Only one of `git`, `github`, `gitlab`, or `image` may be set.
|
|
6990
|
+
"""
|
|
6991
|
+
gitlab: NotRequired[pulumi.Input['AppSpecWorkerGitlabArgsDict']]
|
|
6992
|
+
"""
|
|
6993
|
+
A Gitlab repo to use as the component's source. DigitalOcean App Platform must have [access to the repository](https://cloud.digitalocean.com/apps/gitlab/install). Only one of `git`, `github`, `gitlab`, or `image` may be set.
|
|
6994
|
+
"""
|
|
6995
|
+
image: NotRequired[pulumi.Input['AppSpecWorkerImageArgsDict']]
|
|
6996
|
+
"""
|
|
6997
|
+
An image to use as the component's source. Only one of `git`, `github`, `gitlab`, or `image` may be set.
|
|
6998
|
+
"""
|
|
6999
|
+
instance_count: NotRequired[pulumi.Input[int]]
|
|
7000
|
+
"""
|
|
7001
|
+
The amount of instances that this component should be scaled to.
|
|
7002
|
+
"""
|
|
7003
|
+
instance_size_slug: NotRequired[pulumi.Input[str]]
|
|
7004
|
+
"""
|
|
7005
|
+
The instance size to use for this component. This determines the plan (basic or professional) and the available CPU and memory. The list of available instance sizes can be [found with the API](https://docs.digitalocean.com/reference/api/api-reference/#operation/list_instance_sizes) or using the [doctl CLI](https://docs.digitalocean.com/reference/doctl/) (`doctl apps tier instance-size list`). Default: `basic-xxs`
|
|
7006
|
+
"""
|
|
7007
|
+
log_destinations: NotRequired[pulumi.Input[Sequence[pulumi.Input['AppSpecWorkerLogDestinationArgsDict']]]]
|
|
7008
|
+
"""
|
|
7009
|
+
Describes a log forwarding destination.
|
|
7010
|
+
"""
|
|
7011
|
+
run_command: NotRequired[pulumi.Input[str]]
|
|
7012
|
+
"""
|
|
7013
|
+
An optional run command to override the component's default.
|
|
7014
|
+
"""
|
|
7015
|
+
source_dir: NotRequired[pulumi.Input[str]]
|
|
7016
|
+
"""
|
|
7017
|
+
An optional path to the working directory to use for the build.
|
|
7018
|
+
"""
|
|
7019
|
+
elif False:
|
|
7020
|
+
AppSpecWorkerArgsDict: TypeAlias = Mapping[str, Any]
|
|
7021
|
+
|
|
5293
7022
|
@pulumi.input_type
|
|
5294
7023
|
class AppSpecWorkerArgs:
|
|
5295
7024
|
def __init__(__self__, *,
|
|
@@ -5536,6 +7265,31 @@ class AppSpecWorkerArgs:
|
|
|
5536
7265
|
pulumi.set(self, "source_dir", value)
|
|
5537
7266
|
|
|
5538
7267
|
|
|
7268
|
+
if not MYPY:
|
|
7269
|
+
class AppSpecWorkerAlertArgsDict(TypedDict):
|
|
7270
|
+
operator: pulumi.Input[str]
|
|
7271
|
+
"""
|
|
7272
|
+
The operator to use. This is either of `GREATER_THAN` or `LESS_THAN`.
|
|
7273
|
+
"""
|
|
7274
|
+
rule: pulumi.Input[str]
|
|
7275
|
+
"""
|
|
7276
|
+
The type of the alert to configure. Component app alert policies can be: `CPU_UTILIZATION`, `MEM_UTILIZATION`, or `RESTART_COUNT`.
|
|
7277
|
+
"""
|
|
7278
|
+
value: pulumi.Input[float]
|
|
7279
|
+
"""
|
|
7280
|
+
The threshold for the type of the warning.
|
|
7281
|
+
"""
|
|
7282
|
+
window: pulumi.Input[str]
|
|
7283
|
+
"""
|
|
7284
|
+
The time before alerts should be triggered. This is may be one of: `FIVE_MINUTES`, `TEN_MINUTES`, `THIRTY_MINUTES`, `ONE_HOUR`.
|
|
7285
|
+
"""
|
|
7286
|
+
disabled: NotRequired[pulumi.Input[bool]]
|
|
7287
|
+
"""
|
|
7288
|
+
Determines whether or not the alert is disabled (default: `false`).
|
|
7289
|
+
"""
|
|
7290
|
+
elif False:
|
|
7291
|
+
AppSpecWorkerAlertArgsDict: TypeAlias = Mapping[str, Any]
|
|
7292
|
+
|
|
5539
7293
|
@pulumi.input_type
|
|
5540
7294
|
class AppSpecWorkerAlertArgs:
|
|
5541
7295
|
def __init__(__self__, *,
|
|
@@ -5619,9 +7373,30 @@ class AppSpecWorkerAlertArgs:
|
|
|
5619
7373
|
pulumi.set(self, "disabled", value)
|
|
5620
7374
|
|
|
5621
7375
|
|
|
5622
|
-
|
|
5623
|
-
class
|
|
5624
|
-
|
|
7376
|
+
if not MYPY:
|
|
7377
|
+
class AppSpecWorkerEnvArgsDict(TypedDict):
|
|
7378
|
+
key: NotRequired[pulumi.Input[str]]
|
|
7379
|
+
"""
|
|
7380
|
+
The name of the environment variable.
|
|
7381
|
+
"""
|
|
7382
|
+
scope: NotRequired[pulumi.Input[str]]
|
|
7383
|
+
"""
|
|
7384
|
+
The visibility scope of the environment variable. One of `RUN_TIME`, `BUILD_TIME`, or `RUN_AND_BUILD_TIME` (default).
|
|
7385
|
+
"""
|
|
7386
|
+
type: NotRequired[pulumi.Input[str]]
|
|
7387
|
+
"""
|
|
7388
|
+
The type of the environment variable, `GENERAL` or `SECRET`.
|
|
7389
|
+
"""
|
|
7390
|
+
value: NotRequired[pulumi.Input[str]]
|
|
7391
|
+
"""
|
|
7392
|
+
The value of the environment variable.
|
|
7393
|
+
"""
|
|
7394
|
+
elif False:
|
|
7395
|
+
AppSpecWorkerEnvArgsDict: TypeAlias = Mapping[str, Any]
|
|
7396
|
+
|
|
7397
|
+
@pulumi.input_type
|
|
7398
|
+
class AppSpecWorkerEnvArgs:
|
|
7399
|
+
def __init__(__self__, *,
|
|
5625
7400
|
key: Optional[pulumi.Input[str]] = None,
|
|
5626
7401
|
scope: Optional[pulumi.Input[str]] = None,
|
|
5627
7402
|
type: Optional[pulumi.Input[str]] = None,
|
|
@@ -5690,6 +7465,19 @@ class AppSpecWorkerEnvArgs:
|
|
|
5690
7465
|
pulumi.set(self, "value", value)
|
|
5691
7466
|
|
|
5692
7467
|
|
|
7468
|
+
if not MYPY:
|
|
7469
|
+
class AppSpecWorkerGitArgsDict(TypedDict):
|
|
7470
|
+
branch: NotRequired[pulumi.Input[str]]
|
|
7471
|
+
"""
|
|
7472
|
+
The name of the branch to use.
|
|
7473
|
+
"""
|
|
7474
|
+
repo_clone_url: NotRequired[pulumi.Input[str]]
|
|
7475
|
+
"""
|
|
7476
|
+
The clone URL of the repo.
|
|
7477
|
+
"""
|
|
7478
|
+
elif False:
|
|
7479
|
+
AppSpecWorkerGitArgsDict: TypeAlias = Mapping[str, Any]
|
|
7480
|
+
|
|
5693
7481
|
@pulumi.input_type
|
|
5694
7482
|
class AppSpecWorkerGitArgs:
|
|
5695
7483
|
def __init__(__self__, *,
|
|
@@ -5729,6 +7517,23 @@ class AppSpecWorkerGitArgs:
|
|
|
5729
7517
|
pulumi.set(self, "repo_clone_url", value)
|
|
5730
7518
|
|
|
5731
7519
|
|
|
7520
|
+
if not MYPY:
|
|
7521
|
+
class AppSpecWorkerGithubArgsDict(TypedDict):
|
|
7522
|
+
branch: NotRequired[pulumi.Input[str]]
|
|
7523
|
+
"""
|
|
7524
|
+
The name of the branch to use.
|
|
7525
|
+
"""
|
|
7526
|
+
deploy_on_push: NotRequired[pulumi.Input[bool]]
|
|
7527
|
+
"""
|
|
7528
|
+
Whether to automatically deploy new commits made to the repo.
|
|
7529
|
+
"""
|
|
7530
|
+
repo: NotRequired[pulumi.Input[str]]
|
|
7531
|
+
"""
|
|
7532
|
+
The name of the repo in the format `owner/repo`.
|
|
7533
|
+
"""
|
|
7534
|
+
elif False:
|
|
7535
|
+
AppSpecWorkerGithubArgsDict: TypeAlias = Mapping[str, Any]
|
|
7536
|
+
|
|
5732
7537
|
@pulumi.input_type
|
|
5733
7538
|
class AppSpecWorkerGithubArgs:
|
|
5734
7539
|
def __init__(__self__, *,
|
|
@@ -5784,6 +7589,23 @@ class AppSpecWorkerGithubArgs:
|
|
|
5784
7589
|
pulumi.set(self, "repo", value)
|
|
5785
7590
|
|
|
5786
7591
|
|
|
7592
|
+
if not MYPY:
|
|
7593
|
+
class AppSpecWorkerGitlabArgsDict(TypedDict):
|
|
7594
|
+
branch: NotRequired[pulumi.Input[str]]
|
|
7595
|
+
"""
|
|
7596
|
+
The name of the branch to use.
|
|
7597
|
+
"""
|
|
7598
|
+
deploy_on_push: NotRequired[pulumi.Input[bool]]
|
|
7599
|
+
"""
|
|
7600
|
+
Whether to automatically deploy new commits made to the repo.
|
|
7601
|
+
"""
|
|
7602
|
+
repo: NotRequired[pulumi.Input[str]]
|
|
7603
|
+
"""
|
|
7604
|
+
The name of the repo in the format `owner/repo`.
|
|
7605
|
+
"""
|
|
7606
|
+
elif False:
|
|
7607
|
+
AppSpecWorkerGitlabArgsDict: TypeAlias = Mapping[str, Any]
|
|
7608
|
+
|
|
5787
7609
|
@pulumi.input_type
|
|
5788
7610
|
class AppSpecWorkerGitlabArgs:
|
|
5789
7611
|
def __init__(__self__, *,
|
|
@@ -5839,6 +7661,35 @@ class AppSpecWorkerGitlabArgs:
|
|
|
5839
7661
|
pulumi.set(self, "repo", value)
|
|
5840
7662
|
|
|
5841
7663
|
|
|
7664
|
+
if not MYPY:
|
|
7665
|
+
class AppSpecWorkerImageArgsDict(TypedDict):
|
|
7666
|
+
registry_type: pulumi.Input[str]
|
|
7667
|
+
"""
|
|
7668
|
+
The registry type. One of `DOCR` (DigitalOcean container registry) or `DOCKER_HUB`.
|
|
7669
|
+
"""
|
|
7670
|
+
repository: pulumi.Input[str]
|
|
7671
|
+
"""
|
|
7672
|
+
The repository name.
|
|
7673
|
+
"""
|
|
7674
|
+
deploy_on_pushes: NotRequired[pulumi.Input[Sequence[pulumi.Input['AppSpecWorkerImageDeployOnPushArgsDict']]]]
|
|
7675
|
+
"""
|
|
7676
|
+
Configures automatically deploying images pushed to DOCR.
|
|
7677
|
+
"""
|
|
7678
|
+
registry: NotRequired[pulumi.Input[str]]
|
|
7679
|
+
"""
|
|
7680
|
+
The registry name. Must be left empty for the `DOCR` registry type. Required for the `DOCKER_HUB` registry type.
|
|
7681
|
+
"""
|
|
7682
|
+
registry_credentials: NotRequired[pulumi.Input[str]]
|
|
7683
|
+
"""
|
|
7684
|
+
The credentials required to access a private Docker Hub or GitHub registry, in the following syntax `<username>:<token>`.
|
|
7685
|
+
"""
|
|
7686
|
+
tag: NotRequired[pulumi.Input[str]]
|
|
7687
|
+
"""
|
|
7688
|
+
The repository tag. Defaults to `latest` if not provided.
|
|
7689
|
+
"""
|
|
7690
|
+
elif False:
|
|
7691
|
+
AppSpecWorkerImageArgsDict: TypeAlias = Mapping[str, Any]
|
|
7692
|
+
|
|
5842
7693
|
@pulumi.input_type
|
|
5843
7694
|
class AppSpecWorkerImageArgs:
|
|
5844
7695
|
def __init__(__self__, *,
|
|
@@ -5940,6 +7791,15 @@ class AppSpecWorkerImageArgs:
|
|
|
5940
7791
|
pulumi.set(self, "tag", value)
|
|
5941
7792
|
|
|
5942
7793
|
|
|
7794
|
+
if not MYPY:
|
|
7795
|
+
class AppSpecWorkerImageDeployOnPushArgsDict(TypedDict):
|
|
7796
|
+
enabled: NotRequired[pulumi.Input[bool]]
|
|
7797
|
+
"""
|
|
7798
|
+
Whether to automatically deploy images pushed to DOCR.
|
|
7799
|
+
"""
|
|
7800
|
+
elif False:
|
|
7801
|
+
AppSpecWorkerImageDeployOnPushArgsDict: TypeAlias = Mapping[str, Any]
|
|
7802
|
+
|
|
5943
7803
|
@pulumi.input_type
|
|
5944
7804
|
class AppSpecWorkerImageDeployOnPushArgs:
|
|
5945
7805
|
def __init__(__self__, *,
|
|
@@ -5963,6 +7823,31 @@ class AppSpecWorkerImageDeployOnPushArgs:
|
|
|
5963
7823
|
pulumi.set(self, "enabled", value)
|
|
5964
7824
|
|
|
5965
7825
|
|
|
7826
|
+
if not MYPY:
|
|
7827
|
+
class AppSpecWorkerLogDestinationArgsDict(TypedDict):
|
|
7828
|
+
name: pulumi.Input[str]
|
|
7829
|
+
"""
|
|
7830
|
+
Name of the log destination. Minimum length: 2. Maximum length: 42.
|
|
7831
|
+
"""
|
|
7832
|
+
datadog: NotRequired[pulumi.Input['AppSpecWorkerLogDestinationDatadogArgsDict']]
|
|
7833
|
+
"""
|
|
7834
|
+
Datadog configuration.
|
|
7835
|
+
"""
|
|
7836
|
+
logtail: NotRequired[pulumi.Input['AppSpecWorkerLogDestinationLogtailArgsDict']]
|
|
7837
|
+
"""
|
|
7838
|
+
Logtail configuration.
|
|
7839
|
+
"""
|
|
7840
|
+
open_search: NotRequired[pulumi.Input['AppSpecWorkerLogDestinationOpenSearchArgsDict']]
|
|
7841
|
+
"""
|
|
7842
|
+
OpenSearch configuration.
|
|
7843
|
+
"""
|
|
7844
|
+
papertrail: NotRequired[pulumi.Input['AppSpecWorkerLogDestinationPapertrailArgsDict']]
|
|
7845
|
+
"""
|
|
7846
|
+
Papertrail configuration.
|
|
7847
|
+
"""
|
|
7848
|
+
elif False:
|
|
7849
|
+
AppSpecWorkerLogDestinationArgsDict: TypeAlias = Mapping[str, Any]
|
|
7850
|
+
|
|
5966
7851
|
@pulumi.input_type
|
|
5967
7852
|
class AppSpecWorkerLogDestinationArgs:
|
|
5968
7853
|
def __init__(__self__, *,
|
|
@@ -6049,6 +7934,19 @@ class AppSpecWorkerLogDestinationArgs:
|
|
|
6049
7934
|
pulumi.set(self, "papertrail", value)
|
|
6050
7935
|
|
|
6051
7936
|
|
|
7937
|
+
if not MYPY:
|
|
7938
|
+
class AppSpecWorkerLogDestinationDatadogArgsDict(TypedDict):
|
|
7939
|
+
api_key: pulumi.Input[str]
|
|
7940
|
+
"""
|
|
7941
|
+
Datadog API key.
|
|
7942
|
+
"""
|
|
7943
|
+
endpoint: NotRequired[pulumi.Input[str]]
|
|
7944
|
+
"""
|
|
7945
|
+
Datadog HTTP log intake endpoint.
|
|
7946
|
+
"""
|
|
7947
|
+
elif False:
|
|
7948
|
+
AppSpecWorkerLogDestinationDatadogArgsDict: TypeAlias = Mapping[str, Any]
|
|
7949
|
+
|
|
6052
7950
|
@pulumi.input_type
|
|
6053
7951
|
class AppSpecWorkerLogDestinationDatadogArgs:
|
|
6054
7952
|
def __init__(__self__, *,
|
|
@@ -6087,6 +7985,15 @@ class AppSpecWorkerLogDestinationDatadogArgs:
|
|
|
6087
7985
|
pulumi.set(self, "endpoint", value)
|
|
6088
7986
|
|
|
6089
7987
|
|
|
7988
|
+
if not MYPY:
|
|
7989
|
+
class AppSpecWorkerLogDestinationLogtailArgsDict(TypedDict):
|
|
7990
|
+
token: pulumi.Input[str]
|
|
7991
|
+
"""
|
|
7992
|
+
Logtail token.
|
|
7993
|
+
"""
|
|
7994
|
+
elif False:
|
|
7995
|
+
AppSpecWorkerLogDestinationLogtailArgsDict: TypeAlias = Mapping[str, Any]
|
|
7996
|
+
|
|
6090
7997
|
@pulumi.input_type
|
|
6091
7998
|
class AppSpecWorkerLogDestinationLogtailArgs:
|
|
6092
7999
|
def __init__(__self__, *,
|
|
@@ -6109,6 +8016,27 @@ class AppSpecWorkerLogDestinationLogtailArgs:
|
|
|
6109
8016
|
pulumi.set(self, "token", value)
|
|
6110
8017
|
|
|
6111
8018
|
|
|
8019
|
+
if not MYPY:
|
|
8020
|
+
class AppSpecWorkerLogDestinationOpenSearchArgsDict(TypedDict):
|
|
8021
|
+
basic_auth: pulumi.Input['AppSpecWorkerLogDestinationOpenSearchBasicAuthArgsDict']
|
|
8022
|
+
"""
|
|
8023
|
+
Basic authentication details.
|
|
8024
|
+
"""
|
|
8025
|
+
cluster_name: NotRequired[pulumi.Input[str]]
|
|
8026
|
+
"""
|
|
8027
|
+
The name of the underlying DigitalOcean DBaaS cluster. This is required for production databases. For dev databases, if `cluster_name` is not set, a new cluster will be provisioned.
|
|
8028
|
+
"""
|
|
8029
|
+
endpoint: NotRequired[pulumi.Input[str]]
|
|
8030
|
+
"""
|
|
8031
|
+
OpenSearch endpoint.
|
|
8032
|
+
"""
|
|
8033
|
+
index_name: NotRequired[pulumi.Input[str]]
|
|
8034
|
+
"""
|
|
8035
|
+
OpenSearch index name.
|
|
8036
|
+
"""
|
|
8037
|
+
elif False:
|
|
8038
|
+
AppSpecWorkerLogDestinationOpenSearchArgsDict: TypeAlias = Mapping[str, Any]
|
|
8039
|
+
|
|
6112
8040
|
@pulumi.input_type
|
|
6113
8041
|
class AppSpecWorkerLogDestinationOpenSearchArgs:
|
|
6114
8042
|
def __init__(__self__, *,
|
|
@@ -6179,6 +8107,19 @@ class AppSpecWorkerLogDestinationOpenSearchArgs:
|
|
|
6179
8107
|
pulumi.set(self, "index_name", value)
|
|
6180
8108
|
|
|
6181
8109
|
|
|
8110
|
+
if not MYPY:
|
|
8111
|
+
class AppSpecWorkerLogDestinationOpenSearchBasicAuthArgsDict(TypedDict):
|
|
8112
|
+
password: NotRequired[pulumi.Input[str]]
|
|
8113
|
+
"""
|
|
8114
|
+
Password for basic authentication.
|
|
8115
|
+
"""
|
|
8116
|
+
user: NotRequired[pulumi.Input[str]]
|
|
8117
|
+
"""
|
|
8118
|
+
user for basic authentication.
|
|
8119
|
+
"""
|
|
8120
|
+
elif False:
|
|
8121
|
+
AppSpecWorkerLogDestinationOpenSearchBasicAuthArgsDict: TypeAlias = Mapping[str, Any]
|
|
8122
|
+
|
|
6182
8123
|
@pulumi.input_type
|
|
6183
8124
|
class AppSpecWorkerLogDestinationOpenSearchBasicAuthArgs:
|
|
6184
8125
|
def __init__(__self__, *,
|
|
@@ -6218,6 +8159,15 @@ class AppSpecWorkerLogDestinationOpenSearchBasicAuthArgs:
|
|
|
6218
8159
|
pulumi.set(self, "user", value)
|
|
6219
8160
|
|
|
6220
8161
|
|
|
8162
|
+
if not MYPY:
|
|
8163
|
+
class AppSpecWorkerLogDestinationPapertrailArgsDict(TypedDict):
|
|
8164
|
+
endpoint: pulumi.Input[str]
|
|
8165
|
+
"""
|
|
8166
|
+
Papertrail syslog endpoint.
|
|
8167
|
+
"""
|
|
8168
|
+
elif False:
|
|
8169
|
+
AppSpecWorkerLogDestinationPapertrailArgsDict: TypeAlias = Mapping[str, Any]
|
|
8170
|
+
|
|
6221
8171
|
@pulumi.input_type
|
|
6222
8172
|
class AppSpecWorkerLogDestinationPapertrailArgs:
|
|
6223
8173
|
def __init__(__self__, *,
|
|
@@ -6240,6 +8190,21 @@ class AppSpecWorkerLogDestinationPapertrailArgs:
|
|
|
6240
8190
|
pulumi.set(self, "endpoint", value)
|
|
6241
8191
|
|
|
6242
8192
|
|
|
8193
|
+
if not MYPY:
|
|
8194
|
+
class DatabaseClusterBackupRestoreArgsDict(TypedDict):
|
|
8195
|
+
database_name: pulumi.Input[str]
|
|
8196
|
+
"""
|
|
8197
|
+
The name of an existing database cluster from which the backup will be restored.
|
|
8198
|
+
"""
|
|
8199
|
+
backup_created_at: NotRequired[pulumi.Input[str]]
|
|
8200
|
+
"""
|
|
8201
|
+
The timestamp of an existing database cluster backup in ISO8601 combined date and time format. The most recent backup will be used if excluded.
|
|
8202
|
+
|
|
8203
|
+
This resource supports customized create timeouts. The default timeout is 30 minutes.
|
|
8204
|
+
"""
|
|
8205
|
+
elif False:
|
|
8206
|
+
DatabaseClusterBackupRestoreArgsDict: TypeAlias = Mapping[str, Any]
|
|
8207
|
+
|
|
6243
8208
|
@pulumi.input_type
|
|
6244
8209
|
class DatabaseClusterBackupRestoreArgs:
|
|
6245
8210
|
def __init__(__self__, *,
|
|
@@ -6282,6 +8247,19 @@ class DatabaseClusterBackupRestoreArgs:
|
|
|
6282
8247
|
pulumi.set(self, "backup_created_at", value)
|
|
6283
8248
|
|
|
6284
8249
|
|
|
8250
|
+
if not MYPY:
|
|
8251
|
+
class DatabaseClusterMaintenanceWindowArgsDict(TypedDict):
|
|
8252
|
+
day: pulumi.Input[str]
|
|
8253
|
+
"""
|
|
8254
|
+
The day of the week on which to apply maintenance updates.
|
|
8255
|
+
"""
|
|
8256
|
+
hour: pulumi.Input[str]
|
|
8257
|
+
"""
|
|
8258
|
+
The hour in UTC at which maintenance updates will be applied in 24 hour format.
|
|
8259
|
+
"""
|
|
8260
|
+
elif False:
|
|
8261
|
+
DatabaseClusterMaintenanceWindowArgsDict: TypeAlias = Mapping[str, Any]
|
|
8262
|
+
|
|
6285
8263
|
@pulumi.input_type
|
|
6286
8264
|
class DatabaseClusterMaintenanceWindowArgs:
|
|
6287
8265
|
def __init__(__self__, *,
|
|
@@ -6319,6 +8297,27 @@ class DatabaseClusterMaintenanceWindowArgs:
|
|
|
6319
8297
|
pulumi.set(self, "hour", value)
|
|
6320
8298
|
|
|
6321
8299
|
|
|
8300
|
+
if not MYPY:
|
|
8301
|
+
class DatabaseFirewallRuleArgsDict(TypedDict):
|
|
8302
|
+
type: pulumi.Input[str]
|
|
8303
|
+
"""
|
|
8304
|
+
The type of resource that the firewall rule allows to access the database cluster. The possible values are: `droplet`, `k8s`, `ip_addr`, `tag`, or `app`.
|
|
8305
|
+
"""
|
|
8306
|
+
value: pulumi.Input[str]
|
|
8307
|
+
"""
|
|
8308
|
+
The ID of the specific resource, the name of a tag applied to a group of resources, or the IP address that the firewall rule allows to access the database cluster.
|
|
8309
|
+
"""
|
|
8310
|
+
created_at: NotRequired[pulumi.Input[str]]
|
|
8311
|
+
"""
|
|
8312
|
+
The date and time when the firewall rule was created.
|
|
8313
|
+
"""
|
|
8314
|
+
uuid: NotRequired[pulumi.Input[str]]
|
|
8315
|
+
"""
|
|
8316
|
+
A unique identifier for the firewall rule.
|
|
8317
|
+
"""
|
|
8318
|
+
elif False:
|
|
8319
|
+
DatabaseFirewallRuleArgsDict: TypeAlias = Mapping[str, Any]
|
|
8320
|
+
|
|
6322
8321
|
@pulumi.input_type
|
|
6323
8322
|
class DatabaseFirewallRuleArgs:
|
|
6324
8323
|
def __init__(__self__, *,
|
|
@@ -6388,6 +8387,102 @@ class DatabaseFirewallRuleArgs:
|
|
|
6388
8387
|
pulumi.set(self, "uuid", value)
|
|
6389
8388
|
|
|
6390
8389
|
|
|
8390
|
+
if not MYPY:
|
|
8391
|
+
class DatabaseKafkaTopicConfigArgsDict(TypedDict):
|
|
8392
|
+
cleanup_policy: NotRequired[pulumi.Input[str]]
|
|
8393
|
+
"""
|
|
8394
|
+
The topic cleanup policy that describes whether messages should be deleted, compacted, or both when retention policies are violated.
|
|
8395
|
+
This may be one of "delete", "compact", or "compact_delete".
|
|
8396
|
+
"""
|
|
8397
|
+
compression_type: NotRequired[pulumi.Input[str]]
|
|
8398
|
+
"""
|
|
8399
|
+
The topic compression codecs used for a given topic.
|
|
8400
|
+
This may be one of "uncompressed", "gzip", "snappy", "lz4", "producer", "zstd". "uncompressed" indicates that there is no compression and "producer" retains the original compression codec set by the producer.
|
|
8401
|
+
"""
|
|
8402
|
+
delete_retention_ms: NotRequired[pulumi.Input[str]]
|
|
8403
|
+
"""
|
|
8404
|
+
The amount of time, in ms, that deleted records are retained.
|
|
8405
|
+
"""
|
|
8406
|
+
file_delete_delay_ms: NotRequired[pulumi.Input[str]]
|
|
8407
|
+
"""
|
|
8408
|
+
The amount of time, in ms, to wait before deleting a topic log segment from the filesystem.
|
|
8409
|
+
"""
|
|
8410
|
+
flush_messages: NotRequired[pulumi.Input[str]]
|
|
8411
|
+
"""
|
|
8412
|
+
The number of messages accumulated on a topic partition before they are flushed to disk.
|
|
8413
|
+
"""
|
|
8414
|
+
flush_ms: NotRequired[pulumi.Input[str]]
|
|
8415
|
+
"""
|
|
8416
|
+
The maximum time, in ms, that a topic is kept in memory before being flushed to disk.
|
|
8417
|
+
"""
|
|
8418
|
+
index_interval_bytes: NotRequired[pulumi.Input[str]]
|
|
8419
|
+
"""
|
|
8420
|
+
The interval, in bytes, in which entries are added to the offset index.
|
|
8421
|
+
"""
|
|
8422
|
+
max_compaction_lag_ms: NotRequired[pulumi.Input[str]]
|
|
8423
|
+
"""
|
|
8424
|
+
The maximum time, in ms, that a particular message will remain uncompacted. This will not apply if the `compression_type` is set to "uncompressed" or it is set to `producer` and the producer is not using compression.
|
|
8425
|
+
"""
|
|
8426
|
+
max_message_bytes: NotRequired[pulumi.Input[str]]
|
|
8427
|
+
"""
|
|
8428
|
+
The maximum size, in bytes, of a message.
|
|
8429
|
+
"""
|
|
8430
|
+
message_down_conversion_enable: NotRequired[pulumi.Input[bool]]
|
|
8431
|
+
"""
|
|
8432
|
+
Determines whether down-conversion of message formats for consumers is enabled.
|
|
8433
|
+
"""
|
|
8434
|
+
message_format_version: NotRequired[pulumi.Input[str]]
|
|
8435
|
+
"""
|
|
8436
|
+
The version of the inter-broker protocol that will be used. This may be one of "0.8.0", "0.8.1", "0.8.2", "0.9.0", "0.10.0", "0.10.0-IV0", "0.10.0-IV1", "0.10.1", "0.10.1-IV0", "0.10.1-IV1", "0.10.1-IV2", "0.10.2", "0.10.2-IV0", "0.11.0", "0.11.0-IV0", "0.11.0-IV1", "0.11.0-IV2", "1.0", "1.0-IV0", "1.1", "1.1-IV0", "2.0", "2.0-IV0", "2.0-IV1", "2.1", "2.1-IV0", "2.1-IV1", "2.1-IV2", "2.2", "2.2-IV0", "2.2-IV1", "2.3", "2.3-IV0", "2.3-IV1", "2.4", "2.4-IV0", "2.4-IV1", "2.5", "2.5-IV0", "2.6", "2.6-IV0", "2.7", "2.7-IV0", "2.7-IV1", "2.7-IV2", "2.8", "2.8-IV0", "2.8-IV1", "3.0", "3.0-IV0", "3.0-IV1", "3.1", "3.1-IV0", "3.2", "3.2-IV0", "3.3", "3.3-IV0", "3.3-IV1", "3.3-IV2", "3.3-IV3", "3.4", "3.4-IV0", "3.5", "3.5-IV0", "3.5-IV1", "3.5-IV2", "3.6", "3.6-IV0", "3.6-IV1", "3.6-IV2".
|
|
8437
|
+
"""
|
|
8438
|
+
message_timestamp_difference_max_ms: NotRequired[pulumi.Input[str]]
|
|
8439
|
+
"""
|
|
8440
|
+
The maximum difference, in ms, between the timestamp specific in a message and when the broker receives the message.
|
|
8441
|
+
"""
|
|
8442
|
+
message_timestamp_type: NotRequired[pulumi.Input[str]]
|
|
8443
|
+
"""
|
|
8444
|
+
Specifies which timestamp to use for the message. This may be one of "create_time" or "log_append_time".
|
|
8445
|
+
"""
|
|
8446
|
+
min_cleanable_dirty_ratio: NotRequired[pulumi.Input[float]]
|
|
8447
|
+
"""
|
|
8448
|
+
A scale between 0.0 and 1.0 which controls the frequency of the compactor. Larger values mean more frequent compactions. This is often paired with `max_compaction_lag_ms` to control the compactor frequency.
|
|
8449
|
+
"""
|
|
8450
|
+
min_compaction_lag_ms: NotRequired[pulumi.Input[str]]
|
|
8451
|
+
min_insync_replicas: NotRequired[pulumi.Input[int]]
|
|
8452
|
+
"""
|
|
8453
|
+
The number of replicas that must acknowledge a write before it is considered successful. -1 is a special setting to indicate that all nodes must ack a message before a write is considered successful. Default is 1, indicating at least 1 replica must acknowledge a write to be considered successful.
|
|
8454
|
+
"""
|
|
8455
|
+
preallocate: NotRequired[pulumi.Input[bool]]
|
|
8456
|
+
"""
|
|
8457
|
+
Determines whether to preallocate a file on disk when creating a new log segment within a topic.
|
|
8458
|
+
"""
|
|
8459
|
+
retention_bytes: NotRequired[pulumi.Input[str]]
|
|
8460
|
+
"""
|
|
8461
|
+
The maximum size, in bytes, of a topic before messages are deleted. -1 is a special setting indicating that this setting has no limit.
|
|
8462
|
+
"""
|
|
8463
|
+
retention_ms: NotRequired[pulumi.Input[str]]
|
|
8464
|
+
"""
|
|
8465
|
+
The maximum time, in ms, that a topic log file is retained before deleting it. -1 is a special setting indicating that this setting has no limit.
|
|
8466
|
+
"""
|
|
8467
|
+
segment_bytes: NotRequired[pulumi.Input[str]]
|
|
8468
|
+
"""
|
|
8469
|
+
The maximum size, in bytes, of a single topic log file.
|
|
8470
|
+
"""
|
|
8471
|
+
segment_index_bytes: NotRequired[pulumi.Input[str]]
|
|
8472
|
+
"""
|
|
8473
|
+
The maximum size, in bytes, of the offset index.
|
|
8474
|
+
"""
|
|
8475
|
+
segment_jitter_ms: NotRequired[pulumi.Input[str]]
|
|
8476
|
+
"""
|
|
8477
|
+
The maximum time, in ms, subtracted from the scheduled segment disk flush time to avoid the thundering herd problem for segment flushing.
|
|
8478
|
+
"""
|
|
8479
|
+
segment_ms: NotRequired[pulumi.Input[str]]
|
|
8480
|
+
"""
|
|
8481
|
+
The maximum time, in ms, before the topic log will flush to disk.
|
|
8482
|
+
"""
|
|
8483
|
+
elif False:
|
|
8484
|
+
DatabaseKafkaTopicConfigArgsDict: TypeAlias = Mapping[str, Any]
|
|
8485
|
+
|
|
6391
8486
|
@pulumi.input_type
|
|
6392
8487
|
class DatabaseKafkaTopicConfigArgs:
|
|
6393
8488
|
def __init__(__self__, *,
|
|
@@ -6763,6 +8858,20 @@ class DatabaseKafkaTopicConfigArgs:
|
|
|
6763
8858
|
pulumi.set(self, "segment_ms", value)
|
|
6764
8859
|
|
|
6765
8860
|
|
|
8861
|
+
if not MYPY:
|
|
8862
|
+
class DatabasePostgresqlConfigPgbouncerArgsDict(TypedDict):
|
|
8863
|
+
autodb_idle_timeout: NotRequired[pulumi.Input[int]]
|
|
8864
|
+
autodb_max_db_connections: NotRequired[pulumi.Input[int]]
|
|
8865
|
+
autodb_pool_mode: NotRequired[pulumi.Input[str]]
|
|
8866
|
+
autodb_pool_size: NotRequired[pulumi.Input[int]]
|
|
8867
|
+
ignore_startup_parameters: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
8868
|
+
min_pool_size: NotRequired[pulumi.Input[int]]
|
|
8869
|
+
server_idle_timeout: NotRequired[pulumi.Input[int]]
|
|
8870
|
+
server_lifetime: NotRequired[pulumi.Input[int]]
|
|
8871
|
+
server_reset_query_always: NotRequired[pulumi.Input[bool]]
|
|
8872
|
+
elif False:
|
|
8873
|
+
DatabasePostgresqlConfigPgbouncerArgsDict: TypeAlias = Mapping[str, Any]
|
|
8874
|
+
|
|
6766
8875
|
@pulumi.input_type
|
|
6767
8876
|
class DatabasePostgresqlConfigPgbouncerArgs:
|
|
6768
8877
|
def __init__(__self__, *,
|
|
@@ -6876,6 +8985,12 @@ class DatabasePostgresqlConfigPgbouncerArgs:
|
|
|
6876
8985
|
pulumi.set(self, "server_reset_query_always", value)
|
|
6877
8986
|
|
|
6878
8987
|
|
|
8988
|
+
if not MYPY:
|
|
8989
|
+
class DatabasePostgresqlConfigTimescaledbArgsDict(TypedDict):
|
|
8990
|
+
max_background_workers: NotRequired[pulumi.Input[int]]
|
|
8991
|
+
elif False:
|
|
8992
|
+
DatabasePostgresqlConfigTimescaledbArgsDict: TypeAlias = Mapping[str, Any]
|
|
8993
|
+
|
|
6879
8994
|
@pulumi.input_type
|
|
6880
8995
|
class DatabasePostgresqlConfigTimescaledbArgs:
|
|
6881
8996
|
def __init__(__self__, *,
|
|
@@ -6893,6 +9008,18 @@ class DatabasePostgresqlConfigTimescaledbArgs:
|
|
|
6893
9008
|
pulumi.set(self, "max_background_workers", value)
|
|
6894
9009
|
|
|
6895
9010
|
|
|
9011
|
+
if not MYPY:
|
|
9012
|
+
class DatabaseUserSettingArgsDict(TypedDict):
|
|
9013
|
+
acls: NotRequired[pulumi.Input[Sequence[pulumi.Input['DatabaseUserSettingAclArgsDict']]]]
|
|
9014
|
+
"""
|
|
9015
|
+
A set of ACLs (Access Control Lists) specifying permission on topics with a Kafka cluster. The properties of an individual ACL are described below:
|
|
9016
|
+
|
|
9017
|
+
An individual ACL includes the following:
|
|
9018
|
+
"""
|
|
9019
|
+
opensearch_acls: NotRequired[pulumi.Input[Sequence[pulumi.Input['DatabaseUserSettingOpensearchAclArgsDict']]]]
|
|
9020
|
+
elif False:
|
|
9021
|
+
DatabaseUserSettingArgsDict: TypeAlias = Mapping[str, Any]
|
|
9022
|
+
|
|
6896
9023
|
@pulumi.input_type
|
|
6897
9024
|
class DatabaseUserSettingArgs:
|
|
6898
9025
|
def __init__(__self__, *,
|
|
@@ -6932,6 +9059,23 @@ class DatabaseUserSettingArgs:
|
|
|
6932
9059
|
pulumi.set(self, "opensearch_acls", value)
|
|
6933
9060
|
|
|
6934
9061
|
|
|
9062
|
+
if not MYPY:
|
|
9063
|
+
class DatabaseUserSettingAclArgsDict(TypedDict):
|
|
9064
|
+
permission: pulumi.Input[str]
|
|
9065
|
+
"""
|
|
9066
|
+
The permission level applied to the ACL. This includes "admin", "consume", "produce", and "produceconsume". "admin" allows for producing and consuming as well as add/delete/update permission for topics. "consume" allows only for reading topic messages. "produce" allows only for writing topic messages. "produceconsume" allows for both reading and writing topic messages.
|
|
9067
|
+
"""
|
|
9068
|
+
topic: pulumi.Input[str]
|
|
9069
|
+
"""
|
|
9070
|
+
A regex for matching the topic(s) that this ACL should apply to. The regex can assume one of 3 patterns: "*", "<prefix>*", or "<literal>". "*" is a special value indicating a wildcard that matches on all topics. "<prefix>*" defines a regex that matches all topics with the prefix. "<literal>" performs an exact match on a topic name and only applies to that topic.
|
|
9071
|
+
"""
|
|
9072
|
+
id: NotRequired[pulumi.Input[str]]
|
|
9073
|
+
"""
|
|
9074
|
+
An identifier for the ACL, this will be automatically assigned when you create an ACL entry
|
|
9075
|
+
"""
|
|
9076
|
+
elif False:
|
|
9077
|
+
DatabaseUserSettingAclArgsDict: TypeAlias = Mapping[str, Any]
|
|
9078
|
+
|
|
6935
9079
|
@pulumi.input_type
|
|
6936
9080
|
class DatabaseUserSettingAclArgs:
|
|
6937
9081
|
def __init__(__self__, *,
|
|
@@ -6985,6 +9129,16 @@ class DatabaseUserSettingAclArgs:
|
|
|
6985
9129
|
pulumi.set(self, "id", value)
|
|
6986
9130
|
|
|
6987
9131
|
|
|
9132
|
+
if not MYPY:
|
|
9133
|
+
class DatabaseUserSettingOpensearchAclArgsDict(TypedDict):
|
|
9134
|
+
index: pulumi.Input[str]
|
|
9135
|
+
permission: pulumi.Input[str]
|
|
9136
|
+
"""
|
|
9137
|
+
The permission level applied to the ACL. This includes "admin", "consume", "produce", and "produceconsume". "admin" allows for producing and consuming as well as add/delete/update permission for topics. "consume" allows only for reading topic messages. "produce" allows only for writing topic messages. "produceconsume" allows for both reading and writing topic messages.
|
|
9138
|
+
"""
|
|
9139
|
+
elif False:
|
|
9140
|
+
DatabaseUserSettingOpensearchAclArgsDict: TypeAlias = Mapping[str, Any]
|
|
9141
|
+
|
|
6988
9142
|
@pulumi.input_type
|
|
6989
9143
|
class DatabaseUserSettingOpensearchAclArgs:
|
|
6990
9144
|
def __init__(__self__, *,
|
|
@@ -7018,26 +9172,70 @@ class DatabaseUserSettingOpensearchAclArgs:
|
|
|
7018
9172
|
pulumi.set(self, "permission", value)
|
|
7019
9173
|
|
|
7020
9174
|
|
|
7021
|
-
|
|
7022
|
-
class
|
|
7023
|
-
|
|
7024
|
-
protocol: pulumi.Input[str],
|
|
7025
|
-
port_range: Optional[pulumi.Input[str]] = None,
|
|
7026
|
-
source_addresses: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
7027
|
-
source_droplet_ids: Optional[pulumi.Input[Sequence[pulumi.Input[int]]]] = None,
|
|
7028
|
-
source_kubernetes_ids: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
7029
|
-
source_load_balancer_uids: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
7030
|
-
source_tags: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
|
|
9175
|
+
if not MYPY:
|
|
9176
|
+
class FirewallInboundRuleArgsDict(TypedDict):
|
|
9177
|
+
protocol: pulumi.Input[str]
|
|
7031
9178
|
"""
|
|
7032
|
-
|
|
7033
|
-
|
|
7034
|
-
|
|
7035
|
-
|
|
7036
|
-
|
|
7037
|
-
|
|
7038
|
-
|
|
7039
|
-
|
|
7040
|
-
|
|
9179
|
+
The type of traffic to be allowed.
|
|
9180
|
+
This may be one of "tcp", "udp", or "icmp".
|
|
9181
|
+
"""
|
|
9182
|
+
port_range: NotRequired[pulumi.Input[str]]
|
|
9183
|
+
"""
|
|
9184
|
+
The ports on which traffic will be allowed
|
|
9185
|
+
specified as a string containing a single port, a range (e.g. "8000-9000"),
|
|
9186
|
+
or "1-65535" to open all ports for a protocol. Required for when protocol is
|
|
9187
|
+
`tcp` or `udp`.
|
|
9188
|
+
"""
|
|
9189
|
+
source_addresses: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
9190
|
+
"""
|
|
9191
|
+
An array of strings containing the IPv4
|
|
9192
|
+
addresses, IPv6 addresses, IPv4 CIDRs, and/or IPv6 CIDRs from which the
|
|
9193
|
+
inbound traffic will be accepted.
|
|
9194
|
+
"""
|
|
9195
|
+
source_droplet_ids: NotRequired[pulumi.Input[Sequence[pulumi.Input[int]]]]
|
|
9196
|
+
"""
|
|
9197
|
+
An array containing the IDs of
|
|
9198
|
+
the Droplets from which the inbound traffic will be accepted.
|
|
9199
|
+
"""
|
|
9200
|
+
source_kubernetes_ids: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
9201
|
+
"""
|
|
9202
|
+
An array containing the IDs of
|
|
9203
|
+
the Kubernetes clusters from which the inbound traffic will be accepted.
|
|
9204
|
+
"""
|
|
9205
|
+
source_load_balancer_uids: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
9206
|
+
"""
|
|
9207
|
+
An array containing the IDs
|
|
9208
|
+
of the Load Balancers from which the inbound traffic will be accepted.
|
|
9209
|
+
"""
|
|
9210
|
+
source_tags: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
9211
|
+
"""
|
|
9212
|
+
An array containing the names of Tags
|
|
9213
|
+
corresponding to groups of Droplets from which the inbound traffic
|
|
9214
|
+
will be accepted.
|
|
9215
|
+
"""
|
|
9216
|
+
elif False:
|
|
9217
|
+
FirewallInboundRuleArgsDict: TypeAlias = Mapping[str, Any]
|
|
9218
|
+
|
|
9219
|
+
@pulumi.input_type
|
|
9220
|
+
class FirewallInboundRuleArgs:
|
|
9221
|
+
def __init__(__self__, *,
|
|
9222
|
+
protocol: pulumi.Input[str],
|
|
9223
|
+
port_range: Optional[pulumi.Input[str]] = None,
|
|
9224
|
+
source_addresses: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
9225
|
+
source_droplet_ids: Optional[pulumi.Input[Sequence[pulumi.Input[int]]]] = None,
|
|
9226
|
+
source_kubernetes_ids: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
9227
|
+
source_load_balancer_uids: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
9228
|
+
source_tags: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
|
|
9229
|
+
"""
|
|
9230
|
+
:param pulumi.Input[str] protocol: The type of traffic to be allowed.
|
|
9231
|
+
This may be one of "tcp", "udp", or "icmp".
|
|
9232
|
+
:param pulumi.Input[str] port_range: The ports on which traffic will be allowed
|
|
9233
|
+
specified as a string containing a single port, a range (e.g. "8000-9000"),
|
|
9234
|
+
or "1-65535" to open all ports for a protocol. Required for when protocol is
|
|
9235
|
+
`tcp` or `udp`.
|
|
9236
|
+
:param pulumi.Input[Sequence[pulumi.Input[str]]] source_addresses: An array of strings containing the IPv4
|
|
9237
|
+
addresses, IPv6 addresses, IPv4 CIDRs, and/or IPv6 CIDRs from which the
|
|
9238
|
+
inbound traffic will be accepted.
|
|
7041
9239
|
:param pulumi.Input[Sequence[pulumi.Input[int]]] source_droplet_ids: An array containing the IDs of
|
|
7042
9240
|
the Droplets from which the inbound traffic will be accepted.
|
|
7043
9241
|
:param pulumi.Input[Sequence[pulumi.Input[str]]] source_kubernetes_ids: An array containing the IDs of
|
|
@@ -7158,6 +9356,50 @@ class FirewallInboundRuleArgs:
|
|
|
7158
9356
|
pulumi.set(self, "source_tags", value)
|
|
7159
9357
|
|
|
7160
9358
|
|
|
9359
|
+
if not MYPY:
|
|
9360
|
+
class FirewallOutboundRuleArgsDict(TypedDict):
|
|
9361
|
+
protocol: pulumi.Input[str]
|
|
9362
|
+
"""
|
|
9363
|
+
The type of traffic to be allowed.
|
|
9364
|
+
This may be one of "tcp", "udp", or "icmp".
|
|
9365
|
+
"""
|
|
9366
|
+
destination_addresses: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
9367
|
+
"""
|
|
9368
|
+
An array of strings containing the IPv4
|
|
9369
|
+
addresses, IPv6 addresses, IPv4 CIDRs, and/or IPv6 CIDRs to which the
|
|
9370
|
+
outbound traffic will be allowed.
|
|
9371
|
+
"""
|
|
9372
|
+
destination_droplet_ids: NotRequired[pulumi.Input[Sequence[pulumi.Input[int]]]]
|
|
9373
|
+
"""
|
|
9374
|
+
An array containing the IDs of
|
|
9375
|
+
the Droplets to which the outbound traffic will be allowed.
|
|
9376
|
+
"""
|
|
9377
|
+
destination_kubernetes_ids: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
9378
|
+
"""
|
|
9379
|
+
An array containing the IDs of
|
|
9380
|
+
the Kubernetes clusters to which the outbound traffic will be allowed.
|
|
9381
|
+
"""
|
|
9382
|
+
destination_load_balancer_uids: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
9383
|
+
"""
|
|
9384
|
+
An array containing the IDs
|
|
9385
|
+
of the Load Balancers to which the outbound traffic will be allowed.
|
|
9386
|
+
"""
|
|
9387
|
+
destination_tags: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
9388
|
+
"""
|
|
9389
|
+
An array containing the names of Tags
|
|
9390
|
+
corresponding to groups of Droplets to which the outbound traffic will
|
|
9391
|
+
be allowed.
|
|
9392
|
+
"""
|
|
9393
|
+
port_range: NotRequired[pulumi.Input[str]]
|
|
9394
|
+
"""
|
|
9395
|
+
The ports on which traffic will be allowed
|
|
9396
|
+
specified as a string containing a single port, a range (e.g. "8000-9000"),
|
|
9397
|
+
or "1-65535" to open all ports for a protocol. Required for when protocol is
|
|
9398
|
+
`tcp` or `udp`.
|
|
9399
|
+
"""
|
|
9400
|
+
elif False:
|
|
9401
|
+
FirewallOutboundRuleArgsDict: TypeAlias = Mapping[str, Any]
|
|
9402
|
+
|
|
7161
9403
|
@pulumi.input_type
|
|
7162
9404
|
class FirewallOutboundRuleArgs:
|
|
7163
9405
|
def __init__(__self__, *,
|
|
@@ -7298,6 +9540,18 @@ class FirewallOutboundRuleArgs:
|
|
|
7298
9540
|
pulumi.set(self, "port_range", value)
|
|
7299
9541
|
|
|
7300
9542
|
|
|
9543
|
+
if not MYPY:
|
|
9544
|
+
class FirewallPendingChangeArgsDict(TypedDict):
|
|
9545
|
+
droplet_id: NotRequired[pulumi.Input[int]]
|
|
9546
|
+
removing: NotRequired[pulumi.Input[bool]]
|
|
9547
|
+
status: NotRequired[pulumi.Input[str]]
|
|
9548
|
+
"""
|
|
9549
|
+
A status string indicating the current state of the Firewall.
|
|
9550
|
+
This can be "waiting", "succeeded", or "failed".
|
|
9551
|
+
"""
|
|
9552
|
+
elif False:
|
|
9553
|
+
FirewallPendingChangeArgsDict: TypeAlias = Mapping[str, Any]
|
|
9554
|
+
|
|
7301
9555
|
@pulumi.input_type
|
|
7302
9556
|
class FirewallPendingChangeArgs:
|
|
7303
9557
|
def __init__(__self__, *,
|
|
@@ -7347,6 +9601,39 @@ class FirewallPendingChangeArgs:
|
|
|
7347
9601
|
pulumi.set(self, "status", value)
|
|
7348
9602
|
|
|
7349
9603
|
|
|
9604
|
+
if not MYPY:
|
|
9605
|
+
class KubernetesClusterKubeConfigArgsDict(TypedDict):
|
|
9606
|
+
client_certificate: NotRequired[pulumi.Input[str]]
|
|
9607
|
+
"""
|
|
9608
|
+
The base64 encoded public certificate used by clients to access the cluster. Only available if token authentication is not supported on your cluster.
|
|
9609
|
+
"""
|
|
9610
|
+
client_key: NotRequired[pulumi.Input[str]]
|
|
9611
|
+
"""
|
|
9612
|
+
The base64 encoded private key used by clients to access the cluster. Only available if token authentication is not supported on your cluster.
|
|
9613
|
+
"""
|
|
9614
|
+
cluster_ca_certificate: NotRequired[pulumi.Input[str]]
|
|
9615
|
+
"""
|
|
9616
|
+
The base64 encoded public certificate for the cluster's certificate authority.
|
|
9617
|
+
"""
|
|
9618
|
+
expires_at: NotRequired[pulumi.Input[str]]
|
|
9619
|
+
"""
|
|
9620
|
+
The date and time when the credentials will expire and need to be regenerated.
|
|
9621
|
+
"""
|
|
9622
|
+
host: NotRequired[pulumi.Input[str]]
|
|
9623
|
+
"""
|
|
9624
|
+
The URL of the API server on the Kubernetes master node.
|
|
9625
|
+
"""
|
|
9626
|
+
raw_config: NotRequired[pulumi.Input[str]]
|
|
9627
|
+
"""
|
|
9628
|
+
The full contents of the Kubernetes cluster's kubeconfig file.
|
|
9629
|
+
"""
|
|
9630
|
+
token: NotRequired[pulumi.Input[str]]
|
|
9631
|
+
"""
|
|
9632
|
+
The DigitalOcean API access token used by clients to access the cluster.
|
|
9633
|
+
"""
|
|
9634
|
+
elif False:
|
|
9635
|
+
KubernetesClusterKubeConfigArgsDict: TypeAlias = Mapping[str, Any]
|
|
9636
|
+
|
|
7350
9637
|
@pulumi.input_type
|
|
7351
9638
|
class KubernetesClusterKubeConfigArgs:
|
|
7352
9639
|
def __init__(__self__, *,
|
|
@@ -7466,6 +9753,23 @@ class KubernetesClusterKubeConfigArgs:
|
|
|
7466
9753
|
pulumi.set(self, "token", value)
|
|
7467
9754
|
|
|
7468
9755
|
|
|
9756
|
+
if not MYPY:
|
|
9757
|
+
class KubernetesClusterMaintenancePolicyArgsDict(TypedDict):
|
|
9758
|
+
day: NotRequired[pulumi.Input[str]]
|
|
9759
|
+
"""
|
|
9760
|
+
The day of the maintenance window policy. May be one of "monday" through "sunday", or "any" to indicate an arbitrary week day.
|
|
9761
|
+
"""
|
|
9762
|
+
duration: NotRequired[pulumi.Input[str]]
|
|
9763
|
+
"""
|
|
9764
|
+
A string denoting the duration of the service window, e.g., "04:00".
|
|
9765
|
+
"""
|
|
9766
|
+
start_time: NotRequired[pulumi.Input[str]]
|
|
9767
|
+
"""
|
|
9768
|
+
The start time in UTC of the maintenance window policy in 24-hour clock format / HH:MM notation (e.g., 15:00).
|
|
9769
|
+
"""
|
|
9770
|
+
elif False:
|
|
9771
|
+
KubernetesClusterMaintenancePolicyArgsDict: TypeAlias = Mapping[str, Any]
|
|
9772
|
+
|
|
7469
9773
|
@pulumi.input_type
|
|
7470
9774
|
class KubernetesClusterMaintenancePolicyArgs:
|
|
7471
9775
|
def __init__(__self__, *,
|
|
@@ -7521,6 +9825,59 @@ class KubernetesClusterMaintenancePolicyArgs:
|
|
|
7521
9825
|
pulumi.set(self, "start_time", value)
|
|
7522
9826
|
|
|
7523
9827
|
|
|
9828
|
+
if not MYPY:
|
|
9829
|
+
class KubernetesClusterNodePoolArgsDict(TypedDict):
|
|
9830
|
+
name: pulumi.Input[str]
|
|
9831
|
+
"""
|
|
9832
|
+
A name for the node pool.
|
|
9833
|
+
"""
|
|
9834
|
+
size: pulumi.Input[str]
|
|
9835
|
+
"""
|
|
9836
|
+
The slug identifier for the type of Droplet to be used as workers in the node pool.
|
|
9837
|
+
"""
|
|
9838
|
+
actual_node_count: NotRequired[pulumi.Input[int]]
|
|
9839
|
+
"""
|
|
9840
|
+
A computed field representing the actual number of nodes in the node pool, which is especially useful when auto-scaling is enabled.
|
|
9841
|
+
"""
|
|
9842
|
+
auto_scale: NotRequired[pulumi.Input[bool]]
|
|
9843
|
+
"""
|
|
9844
|
+
Enable auto-scaling of the number of nodes in the node pool within the given min/max range.
|
|
9845
|
+
"""
|
|
9846
|
+
id: NotRequired[pulumi.Input[str]]
|
|
9847
|
+
"""
|
|
9848
|
+
A unique ID that can be used to identify and reference the node.
|
|
9849
|
+
"""
|
|
9850
|
+
labels: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[str]]]]
|
|
9851
|
+
"""
|
|
9852
|
+
A map of key/value pairs to apply to nodes in the pool. The labels are exposed in the Kubernetes API as labels in the metadata of the corresponding [Node resources](https://kubernetes.io/docs/concepts/architecture/nodes/).
|
|
9853
|
+
"""
|
|
9854
|
+
max_nodes: NotRequired[pulumi.Input[int]]
|
|
9855
|
+
"""
|
|
9856
|
+
If auto-scaling is enabled, this represents the maximum number of nodes that the node pool can be scaled up to.
|
|
9857
|
+
"""
|
|
9858
|
+
min_nodes: NotRequired[pulumi.Input[int]]
|
|
9859
|
+
"""
|
|
9860
|
+
If auto-scaling is enabled, this represents the minimum number of nodes that the node pool can be scaled down to.
|
|
9861
|
+
"""
|
|
9862
|
+
node_count: NotRequired[pulumi.Input[int]]
|
|
9863
|
+
"""
|
|
9864
|
+
The number of Droplet instances in the node pool. If auto-scaling is enabled, this should only be set if the desired result is to explicitly reset the number of nodes to this value. If auto-scaling is enabled, and the node count is outside of the given min/max range, it will use the min nodes value.
|
|
9865
|
+
"""
|
|
9866
|
+
nodes: NotRequired[pulumi.Input[Sequence[pulumi.Input['KubernetesClusterNodePoolNodeArgsDict']]]]
|
|
9867
|
+
"""
|
|
9868
|
+
A list of nodes in the pool. Each node exports the following attributes:
|
|
9869
|
+
"""
|
|
9870
|
+
tags: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
9871
|
+
"""
|
|
9872
|
+
A list of tag names applied to the node pool.
|
|
9873
|
+
"""
|
|
9874
|
+
taints: NotRequired[pulumi.Input[Sequence[pulumi.Input['KubernetesClusterNodePoolTaintArgsDict']]]]
|
|
9875
|
+
"""
|
|
9876
|
+
A block representing a taint applied to all nodes in the pool. Each taint exports the following attributes (taints must be unique by key and effect pair):
|
|
9877
|
+
"""
|
|
9878
|
+
elif False:
|
|
9879
|
+
KubernetesClusterNodePoolArgsDict: TypeAlias = Mapping[str, Any]
|
|
9880
|
+
|
|
7524
9881
|
@pulumi.input_type
|
|
7525
9882
|
class KubernetesClusterNodePoolArgs:
|
|
7526
9883
|
def __init__(__self__, *,
|
|
@@ -7718,6 +10075,35 @@ class KubernetesClusterNodePoolArgs:
|
|
|
7718
10075
|
pulumi.set(self, "taints", value)
|
|
7719
10076
|
|
|
7720
10077
|
|
|
10078
|
+
if not MYPY:
|
|
10079
|
+
class KubernetesClusterNodePoolNodeArgsDict(TypedDict):
|
|
10080
|
+
created_at: NotRequired[pulumi.Input[str]]
|
|
10081
|
+
"""
|
|
10082
|
+
The date and time when the node was created.
|
|
10083
|
+
"""
|
|
10084
|
+
droplet_id: NotRequired[pulumi.Input[str]]
|
|
10085
|
+
"""
|
|
10086
|
+
The id of the node's droplet
|
|
10087
|
+
"""
|
|
10088
|
+
id: NotRequired[pulumi.Input[str]]
|
|
10089
|
+
"""
|
|
10090
|
+
A unique ID that can be used to identify and reference the node.
|
|
10091
|
+
"""
|
|
10092
|
+
name: NotRequired[pulumi.Input[str]]
|
|
10093
|
+
"""
|
|
10094
|
+
A name for the Kubernetes cluster.
|
|
10095
|
+
"""
|
|
10096
|
+
status: NotRequired[pulumi.Input[str]]
|
|
10097
|
+
"""
|
|
10098
|
+
A string indicating the current status of the individual node.
|
|
10099
|
+
"""
|
|
10100
|
+
updated_at: NotRequired[pulumi.Input[str]]
|
|
10101
|
+
"""
|
|
10102
|
+
The date and time when the node was last updated.
|
|
10103
|
+
"""
|
|
10104
|
+
elif False:
|
|
10105
|
+
KubernetesClusterNodePoolNodeArgsDict: TypeAlias = Mapping[str, Any]
|
|
10106
|
+
|
|
7721
10107
|
@pulumi.input_type
|
|
7722
10108
|
class KubernetesClusterNodePoolNodeArgs:
|
|
7723
10109
|
def __init__(__self__, *,
|
|
@@ -7821,6 +10207,23 @@ class KubernetesClusterNodePoolNodeArgs:
|
|
|
7821
10207
|
pulumi.set(self, "updated_at", value)
|
|
7822
10208
|
|
|
7823
10209
|
|
|
10210
|
+
if not MYPY:
|
|
10211
|
+
class KubernetesClusterNodePoolTaintArgsDict(TypedDict):
|
|
10212
|
+
effect: pulumi.Input[str]
|
|
10213
|
+
"""
|
|
10214
|
+
How the node reacts to pods that it won't tolerate. Available effect values are: "NoSchedule", "PreferNoSchedule", "NoExecute".
|
|
10215
|
+
"""
|
|
10216
|
+
key: pulumi.Input[str]
|
|
10217
|
+
"""
|
|
10218
|
+
An arbitrary string. The "key" and "value" fields of the "taint" object form a key-value pair.
|
|
10219
|
+
"""
|
|
10220
|
+
value: pulumi.Input[str]
|
|
10221
|
+
"""
|
|
10222
|
+
An arbitrary string. The "key" and "value" fields of the "taint" object form a key-value pair.
|
|
10223
|
+
"""
|
|
10224
|
+
elif False:
|
|
10225
|
+
KubernetesClusterNodePoolTaintArgsDict: TypeAlias = Mapping[str, Any]
|
|
10226
|
+
|
|
7824
10227
|
@pulumi.input_type
|
|
7825
10228
|
class KubernetesClusterNodePoolTaintArgs:
|
|
7826
10229
|
def __init__(__self__, *,
|
|
@@ -7873,6 +10276,35 @@ class KubernetesClusterNodePoolTaintArgs:
|
|
|
7873
10276
|
pulumi.set(self, "value", value)
|
|
7874
10277
|
|
|
7875
10278
|
|
|
10279
|
+
if not MYPY:
|
|
10280
|
+
class KubernetesNodePoolNodeArgsDict(TypedDict):
|
|
10281
|
+
created_at: NotRequired[pulumi.Input[str]]
|
|
10282
|
+
"""
|
|
10283
|
+
The date and time when the node was created.
|
|
10284
|
+
"""
|
|
10285
|
+
droplet_id: NotRequired[pulumi.Input[str]]
|
|
10286
|
+
"""
|
|
10287
|
+
The id of the node's droplet
|
|
10288
|
+
"""
|
|
10289
|
+
id: NotRequired[pulumi.Input[str]]
|
|
10290
|
+
"""
|
|
10291
|
+
A unique ID that can be used to identify and reference the node.
|
|
10292
|
+
"""
|
|
10293
|
+
name: NotRequired[pulumi.Input[str]]
|
|
10294
|
+
"""
|
|
10295
|
+
A name for the node pool.
|
|
10296
|
+
"""
|
|
10297
|
+
status: NotRequired[pulumi.Input[str]]
|
|
10298
|
+
"""
|
|
10299
|
+
A string indicating the current status of the individual node.
|
|
10300
|
+
"""
|
|
10301
|
+
updated_at: NotRequired[pulumi.Input[str]]
|
|
10302
|
+
"""
|
|
10303
|
+
The date and time when the node was last updated.
|
|
10304
|
+
"""
|
|
10305
|
+
elif False:
|
|
10306
|
+
KubernetesNodePoolNodeArgsDict: TypeAlias = Mapping[str, Any]
|
|
10307
|
+
|
|
7876
10308
|
@pulumi.input_type
|
|
7877
10309
|
class KubernetesNodePoolNodeArgs:
|
|
7878
10310
|
def __init__(__self__, *,
|
|
@@ -7976,6 +10408,23 @@ class KubernetesNodePoolNodeArgs:
|
|
|
7976
10408
|
pulumi.set(self, "updated_at", value)
|
|
7977
10409
|
|
|
7978
10410
|
|
|
10411
|
+
if not MYPY:
|
|
10412
|
+
class KubernetesNodePoolTaintArgsDict(TypedDict):
|
|
10413
|
+
effect: pulumi.Input[str]
|
|
10414
|
+
"""
|
|
10415
|
+
How the node reacts to pods that it won't tolerate. Available effect values are: "NoSchedule", "PreferNoSchedule", "NoExecute".
|
|
10416
|
+
"""
|
|
10417
|
+
key: pulumi.Input[str]
|
|
10418
|
+
"""
|
|
10419
|
+
An arbitrary string. The "key" and "value" fields of the "taint" object form a key-value pair.
|
|
10420
|
+
"""
|
|
10421
|
+
value: pulumi.Input[str]
|
|
10422
|
+
"""
|
|
10423
|
+
An arbitrary string. The "key" and "value" fields of the "taint" object form a key-value pair.
|
|
10424
|
+
"""
|
|
10425
|
+
elif False:
|
|
10426
|
+
KubernetesNodePoolTaintArgsDict: TypeAlias = Mapping[str, Any]
|
|
10427
|
+
|
|
7979
10428
|
@pulumi.input_type
|
|
7980
10429
|
class KubernetesNodePoolTaintArgs:
|
|
7981
10430
|
def __init__(__self__, *,
|
|
@@ -8028,6 +10477,31 @@ class KubernetesNodePoolTaintArgs:
|
|
|
8028
10477
|
pulumi.set(self, "value", value)
|
|
8029
10478
|
|
|
8030
10479
|
|
|
10480
|
+
if not MYPY:
|
|
10481
|
+
class LoadBalancerDomainArgsDict(TypedDict):
|
|
10482
|
+
name: pulumi.Input[str]
|
|
10483
|
+
"""
|
|
10484
|
+
The domain name to be used for ingressing traffic to a Global Load Balancer.
|
|
10485
|
+
"""
|
|
10486
|
+
certificate_name: NotRequired[pulumi.Input[str]]
|
|
10487
|
+
"""
|
|
10488
|
+
name of certificate required for TLS handshaking
|
|
10489
|
+
"""
|
|
10490
|
+
is_managed: NotRequired[pulumi.Input[bool]]
|
|
10491
|
+
"""
|
|
10492
|
+
Control flag to specify whether the domain is managed by DigitalOcean.
|
|
10493
|
+
"""
|
|
10494
|
+
ssl_validation_error_reasons: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
10495
|
+
"""
|
|
10496
|
+
list of domain SSL validation errors
|
|
10497
|
+
"""
|
|
10498
|
+
verification_error_reasons: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
10499
|
+
"""
|
|
10500
|
+
list of domain verification errors
|
|
10501
|
+
"""
|
|
10502
|
+
elif False:
|
|
10503
|
+
LoadBalancerDomainArgsDict: TypeAlias = Mapping[str, Any]
|
|
10504
|
+
|
|
8031
10505
|
@pulumi.input_type
|
|
8032
10506
|
class LoadBalancerDomainArgs:
|
|
8033
10507
|
def __init__(__self__, *,
|
|
@@ -8114,6 +10588,20 @@ class LoadBalancerDomainArgs:
|
|
|
8114
10588
|
pulumi.set(self, "verification_error_reasons", value)
|
|
8115
10589
|
|
|
8116
10590
|
|
|
10591
|
+
if not MYPY:
|
|
10592
|
+
class LoadBalancerFirewallArgsDict(TypedDict):
|
|
10593
|
+
allows: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
10594
|
+
"""
|
|
10595
|
+
A list of strings describing allow rules. Must be colon delimited strings of the form `{type}:{source}`
|
|
10596
|
+
* Ex. `deny = ["cidr:1.2.0.0/16", "ip:2.3.4.5"]` or `allow = ["ip:1.2.3.4", "cidr:2.3.4.0/24"]`
|
|
10597
|
+
"""
|
|
10598
|
+
denies: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
10599
|
+
"""
|
|
10600
|
+
A list of strings describing deny rules. Must be colon delimited strings of the form `{type}:{source}`
|
|
10601
|
+
"""
|
|
10602
|
+
elif False:
|
|
10603
|
+
LoadBalancerFirewallArgsDict: TypeAlias = Mapping[str, Any]
|
|
10604
|
+
|
|
8117
10605
|
@pulumi.input_type
|
|
8118
10606
|
class LoadBalancerFirewallArgs:
|
|
8119
10607
|
def __init__(__self__, *,
|
|
@@ -8155,22 +10643,55 @@ class LoadBalancerFirewallArgs:
|
|
|
8155
10643
|
pulumi.set(self, "denies", value)
|
|
8156
10644
|
|
|
8157
10645
|
|
|
8158
|
-
|
|
8159
|
-
class
|
|
8160
|
-
|
|
8161
|
-
entry_port: pulumi.Input[int],
|
|
8162
|
-
entry_protocol: pulumi.Input[str],
|
|
8163
|
-
target_port: pulumi.Input[int],
|
|
8164
|
-
target_protocol: pulumi.Input[str],
|
|
8165
|
-
certificate_id: Optional[pulumi.Input[str]] = None,
|
|
8166
|
-
certificate_name: Optional[pulumi.Input[str]] = None,
|
|
8167
|
-
tls_passthrough: Optional[pulumi.Input[bool]] = None):
|
|
10646
|
+
if not MYPY:
|
|
10647
|
+
class LoadBalancerForwardingRuleArgsDict(TypedDict):
|
|
10648
|
+
entry_port: pulumi.Input[int]
|
|
8168
10649
|
"""
|
|
8169
|
-
|
|
8170
|
-
|
|
8171
|
-
:
|
|
8172
|
-
|
|
8173
|
-
|
|
10650
|
+
An integer representing the port on which the Load Balancer instance will listen.
|
|
10651
|
+
"""
|
|
10652
|
+
entry_protocol: pulumi.Input[str]
|
|
10653
|
+
"""
|
|
10654
|
+
The protocol used for traffic to the Load Balancer. The possible values are: `http`, `https`, `http2`, `http3`, `tcp`, or `udp`.
|
|
10655
|
+
"""
|
|
10656
|
+
target_port: pulumi.Input[int]
|
|
10657
|
+
"""
|
|
10658
|
+
An integer representing the port on the backend Droplets to which the Load Balancer will send traffic.
|
|
10659
|
+
"""
|
|
10660
|
+
target_protocol: pulumi.Input[str]
|
|
10661
|
+
"""
|
|
10662
|
+
The protocol used for traffic from the Load Balancer to the backend Droplets. The possible values are: `http`, `https`, `http2`, `tcp`, or `udp`.
|
|
10663
|
+
"""
|
|
10664
|
+
certificate_id: NotRequired[pulumi.Input[str]]
|
|
10665
|
+
"""
|
|
10666
|
+
**Deprecated** The ID of the TLS certificate to be used for SSL termination.
|
|
10667
|
+
"""
|
|
10668
|
+
certificate_name: NotRequired[pulumi.Input[str]]
|
|
10669
|
+
"""
|
|
10670
|
+
The unique name of the TLS certificate to be used for SSL termination.
|
|
10671
|
+
"""
|
|
10672
|
+
tls_passthrough: NotRequired[pulumi.Input[bool]]
|
|
10673
|
+
"""
|
|
10674
|
+
A boolean value indicating whether SSL encrypted traffic will be passed through to the backend Droplets. The default value is `false`.
|
|
10675
|
+
"""
|
|
10676
|
+
elif False:
|
|
10677
|
+
LoadBalancerForwardingRuleArgsDict: TypeAlias = Mapping[str, Any]
|
|
10678
|
+
|
|
10679
|
+
@pulumi.input_type
|
|
10680
|
+
class LoadBalancerForwardingRuleArgs:
|
|
10681
|
+
def __init__(__self__, *,
|
|
10682
|
+
entry_port: pulumi.Input[int],
|
|
10683
|
+
entry_protocol: pulumi.Input[str],
|
|
10684
|
+
target_port: pulumi.Input[int],
|
|
10685
|
+
target_protocol: pulumi.Input[str],
|
|
10686
|
+
certificate_id: Optional[pulumi.Input[str]] = None,
|
|
10687
|
+
certificate_name: Optional[pulumi.Input[str]] = None,
|
|
10688
|
+
tls_passthrough: Optional[pulumi.Input[bool]] = None):
|
|
10689
|
+
"""
|
|
10690
|
+
:param pulumi.Input[int] entry_port: An integer representing the port on which the Load Balancer instance will listen.
|
|
10691
|
+
:param pulumi.Input[str] entry_protocol: The protocol used for traffic to the Load Balancer. The possible values are: `http`, `https`, `http2`, `http3`, `tcp`, or `udp`.
|
|
10692
|
+
:param pulumi.Input[int] target_port: An integer representing the port on the backend Droplets to which the Load Balancer will send traffic.
|
|
10693
|
+
:param pulumi.Input[str] target_protocol: The protocol used for traffic from the Load Balancer to the backend Droplets. The possible values are: `http`, `https`, `http2`, `tcp`, or `udp`.
|
|
10694
|
+
:param pulumi.Input[str] certificate_id: **Deprecated** The ID of the TLS certificate to be used for SSL termination.
|
|
8174
10695
|
:param pulumi.Input[str] certificate_name: The unique name of the TLS certificate to be used for SSL termination.
|
|
8175
10696
|
:param pulumi.Input[bool] tls_passthrough: A boolean value indicating whether SSL encrypted traffic will be passed through to the backend Droplets. The default value is `false`.
|
|
8176
10697
|
"""
|
|
@@ -8274,6 +10795,31 @@ class LoadBalancerForwardingRuleArgs:
|
|
|
8274
10795
|
pulumi.set(self, "tls_passthrough", value)
|
|
8275
10796
|
|
|
8276
10797
|
|
|
10798
|
+
if not MYPY:
|
|
10799
|
+
class LoadBalancerGlbSettingsArgsDict(TypedDict):
|
|
10800
|
+
target_port: pulumi.Input[int]
|
|
10801
|
+
"""
|
|
10802
|
+
An integer representing the port on the backend Droplets to which the Load Balancer will send traffic. The possible values are: `80` for `http` and `443` for `https`.
|
|
10803
|
+
"""
|
|
10804
|
+
target_protocol: pulumi.Input[str]
|
|
10805
|
+
"""
|
|
10806
|
+
The protocol used for traffic from the Load Balancer to the backend Droplets. The possible values are: `http` and `https`.
|
|
10807
|
+
"""
|
|
10808
|
+
cdn: NotRequired[pulumi.Input['LoadBalancerGlbSettingsCdnArgsDict']]
|
|
10809
|
+
"""
|
|
10810
|
+
CDN configuration supporting the following:
|
|
10811
|
+
"""
|
|
10812
|
+
failover_threshold: NotRequired[pulumi.Input[int]]
|
|
10813
|
+
"""
|
|
10814
|
+
fail-over threshold
|
|
10815
|
+
"""
|
|
10816
|
+
region_priorities: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[int]]]]
|
|
10817
|
+
"""
|
|
10818
|
+
region priority map
|
|
10819
|
+
"""
|
|
10820
|
+
elif False:
|
|
10821
|
+
LoadBalancerGlbSettingsArgsDict: TypeAlias = Mapping[str, Any]
|
|
10822
|
+
|
|
8277
10823
|
@pulumi.input_type
|
|
8278
10824
|
class LoadBalancerGlbSettingsArgs:
|
|
8279
10825
|
def __init__(__self__, *,
|
|
@@ -8359,6 +10905,15 @@ class LoadBalancerGlbSettingsArgs:
|
|
|
8359
10905
|
pulumi.set(self, "region_priorities", value)
|
|
8360
10906
|
|
|
8361
10907
|
|
|
10908
|
+
if not MYPY:
|
|
10909
|
+
class LoadBalancerGlbSettingsCdnArgsDict(TypedDict):
|
|
10910
|
+
is_enabled: NotRequired[pulumi.Input[bool]]
|
|
10911
|
+
"""
|
|
10912
|
+
Control flag to specify if caching is enabled.
|
|
10913
|
+
"""
|
|
10914
|
+
elif False:
|
|
10915
|
+
LoadBalancerGlbSettingsCdnArgsDict: TypeAlias = Mapping[str, Any]
|
|
10916
|
+
|
|
8362
10917
|
@pulumi.input_type
|
|
8363
10918
|
class LoadBalancerGlbSettingsCdnArgs:
|
|
8364
10919
|
def __init__(__self__, *,
|
|
@@ -8382,6 +10937,39 @@ class LoadBalancerGlbSettingsCdnArgs:
|
|
|
8382
10937
|
pulumi.set(self, "is_enabled", value)
|
|
8383
10938
|
|
|
8384
10939
|
|
|
10940
|
+
if not MYPY:
|
|
10941
|
+
class LoadBalancerHealthcheckArgsDict(TypedDict):
|
|
10942
|
+
port: pulumi.Input[int]
|
|
10943
|
+
"""
|
|
10944
|
+
An integer representing the port on the backend Droplets on which the health check will attempt a connection.
|
|
10945
|
+
"""
|
|
10946
|
+
protocol: pulumi.Input[str]
|
|
10947
|
+
"""
|
|
10948
|
+
The protocol used for health checks sent to the backend Droplets. The possible values are `http`, `https` or `tcp`.
|
|
10949
|
+
"""
|
|
10950
|
+
check_interval_seconds: NotRequired[pulumi.Input[int]]
|
|
10951
|
+
"""
|
|
10952
|
+
The number of seconds between two consecutive health checks. If not specified, the default value is `10`.
|
|
10953
|
+
"""
|
|
10954
|
+
healthy_threshold: NotRequired[pulumi.Input[int]]
|
|
10955
|
+
"""
|
|
10956
|
+
The number of times a health check must pass for a backend Droplet to be marked "healthy" and be re-added to the pool. If not specified, the default value is `5`.
|
|
10957
|
+
"""
|
|
10958
|
+
path: NotRequired[pulumi.Input[str]]
|
|
10959
|
+
"""
|
|
10960
|
+
The path on the backend Droplets to which the Load Balancer instance will send a request.
|
|
10961
|
+
"""
|
|
10962
|
+
response_timeout_seconds: NotRequired[pulumi.Input[int]]
|
|
10963
|
+
"""
|
|
10964
|
+
The number of seconds the Load Balancer instance will wait for a response until marking a health check as failed. If not specified, the default value is `5`.
|
|
10965
|
+
"""
|
|
10966
|
+
unhealthy_threshold: NotRequired[pulumi.Input[int]]
|
|
10967
|
+
"""
|
|
10968
|
+
The number of times a health check must fail for a backend Droplet to be marked "unhealthy" and be removed from the pool. If not specified, the default value is `3`.
|
|
10969
|
+
"""
|
|
10970
|
+
elif False:
|
|
10971
|
+
LoadBalancerHealthcheckArgsDict: TypeAlias = Mapping[str, Any]
|
|
10972
|
+
|
|
8385
10973
|
@pulumi.input_type
|
|
8386
10974
|
class LoadBalancerHealthcheckArgs:
|
|
8387
10975
|
def __init__(__self__, *,
|
|
@@ -8499,6 +11087,23 @@ class LoadBalancerHealthcheckArgs:
|
|
|
8499
11087
|
pulumi.set(self, "unhealthy_threshold", value)
|
|
8500
11088
|
|
|
8501
11089
|
|
|
11090
|
+
if not MYPY:
|
|
11091
|
+
class LoadBalancerStickySessionsArgsDict(TypedDict):
|
|
11092
|
+
cookie_name: NotRequired[pulumi.Input[str]]
|
|
11093
|
+
"""
|
|
11094
|
+
The name to be used for the cookie sent to the client. This attribute is required when using `cookies` for the sticky sessions type.
|
|
11095
|
+
"""
|
|
11096
|
+
cookie_ttl_seconds: NotRequired[pulumi.Input[int]]
|
|
11097
|
+
"""
|
|
11098
|
+
The number of seconds until the cookie set by the Load Balancer expires. This attribute is required when using `cookies` for the sticky sessions type.
|
|
11099
|
+
"""
|
|
11100
|
+
type: NotRequired[pulumi.Input[str]]
|
|
11101
|
+
"""
|
|
11102
|
+
An attribute indicating how and if requests from a client will be persistently served by the same backend Droplet. The possible values are `cookies` or `none`. If not specified, the default value is `none`.
|
|
11103
|
+
"""
|
|
11104
|
+
elif False:
|
|
11105
|
+
LoadBalancerStickySessionsArgsDict: TypeAlias = Mapping[str, Any]
|
|
11106
|
+
|
|
8502
11107
|
@pulumi.input_type
|
|
8503
11108
|
class LoadBalancerStickySessionsArgs:
|
|
8504
11109
|
def __init__(__self__, *,
|
|
@@ -8554,6 +11159,16 @@ class LoadBalancerStickySessionsArgs:
|
|
|
8554
11159
|
pulumi.set(self, "type", value)
|
|
8555
11160
|
|
|
8556
11161
|
|
|
11162
|
+
if not MYPY:
|
|
11163
|
+
class MonitorAlertAlertsArgsDict(TypedDict):
|
|
11164
|
+
emails: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
11165
|
+
"""
|
|
11166
|
+
List of email addresses to sent notifications to
|
|
11167
|
+
"""
|
|
11168
|
+
slacks: NotRequired[pulumi.Input[Sequence[pulumi.Input['MonitorAlertAlertsSlackArgsDict']]]]
|
|
11169
|
+
elif False:
|
|
11170
|
+
MonitorAlertAlertsArgsDict: TypeAlias = Mapping[str, Any]
|
|
11171
|
+
|
|
8557
11172
|
@pulumi.input_type
|
|
8558
11173
|
class MonitorAlertAlertsArgs:
|
|
8559
11174
|
def __init__(__self__, *,
|
|
@@ -8589,6 +11204,19 @@ class MonitorAlertAlertsArgs:
|
|
|
8589
11204
|
pulumi.set(self, "slacks", value)
|
|
8590
11205
|
|
|
8591
11206
|
|
|
11207
|
+
if not MYPY:
|
|
11208
|
+
class MonitorAlertAlertsSlackArgsDict(TypedDict):
|
|
11209
|
+
channel: pulumi.Input[str]
|
|
11210
|
+
"""
|
|
11211
|
+
The Slack channel to send alerts to
|
|
11212
|
+
"""
|
|
11213
|
+
url: pulumi.Input[str]
|
|
11214
|
+
"""
|
|
11215
|
+
The webhook URL for Slack
|
|
11216
|
+
"""
|
|
11217
|
+
elif False:
|
|
11218
|
+
MonitorAlertAlertsSlackArgsDict: TypeAlias = Mapping[str, Any]
|
|
11219
|
+
|
|
8592
11220
|
@pulumi.input_type
|
|
8593
11221
|
class MonitorAlertAlertsSlackArgs:
|
|
8594
11222
|
def __init__(__self__, *,
|
|
@@ -8626,6 +11254,35 @@ class MonitorAlertAlertsSlackArgs:
|
|
|
8626
11254
|
pulumi.set(self, "url", value)
|
|
8627
11255
|
|
|
8628
11256
|
|
|
11257
|
+
if not MYPY:
|
|
11258
|
+
class SpacesBucketCorsConfigurationCorsRuleArgsDict(TypedDict):
|
|
11259
|
+
allowed_methods: pulumi.Input[Sequence[pulumi.Input[str]]]
|
|
11260
|
+
"""
|
|
11261
|
+
Set of HTTP methods that you allow the origin to execute. Valid values are GET, PUT, HEAD, POST, and DELETE.
|
|
11262
|
+
"""
|
|
11263
|
+
allowed_origins: pulumi.Input[Sequence[pulumi.Input[str]]]
|
|
11264
|
+
"""
|
|
11265
|
+
Set of origins you want customers to be able to access the bucket from.
|
|
11266
|
+
"""
|
|
11267
|
+
allowed_headers: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
11268
|
+
"""
|
|
11269
|
+
Set of Headers that are specified in the Access-Control-Request-Headers header.
|
|
11270
|
+
"""
|
|
11271
|
+
expose_headers: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
11272
|
+
"""
|
|
11273
|
+
Set of headers in the response that you want customers to be able to access from their applications (for example, from a JavaScript XMLHttpRequest object).
|
|
11274
|
+
"""
|
|
11275
|
+
id: NotRequired[pulumi.Input[str]]
|
|
11276
|
+
"""
|
|
11277
|
+
Unique identifier for the rule. The value cannot be longer than 255 characters.
|
|
11278
|
+
"""
|
|
11279
|
+
max_age_seconds: NotRequired[pulumi.Input[int]]
|
|
11280
|
+
"""
|
|
11281
|
+
Time in seconds that your browser is to cache the preflight response for the specified resource.
|
|
11282
|
+
"""
|
|
11283
|
+
elif False:
|
|
11284
|
+
SpacesBucketCorsConfigurationCorsRuleArgsDict: TypeAlias = Mapping[str, Any]
|
|
11285
|
+
|
|
8629
11286
|
@pulumi.input_type
|
|
8630
11287
|
class SpacesBucketCorsConfigurationCorsRuleArgs:
|
|
8631
11288
|
def __init__(__self__, *,
|
|
@@ -8727,6 +11384,27 @@ class SpacesBucketCorsConfigurationCorsRuleArgs:
|
|
|
8727
11384
|
pulumi.set(self, "max_age_seconds", value)
|
|
8728
11385
|
|
|
8729
11386
|
|
|
11387
|
+
if not MYPY:
|
|
11388
|
+
class SpacesBucketCorsRuleArgsDict(TypedDict):
|
|
11389
|
+
allowed_methods: pulumi.Input[Sequence[pulumi.Input[str]]]
|
|
11390
|
+
"""
|
|
11391
|
+
A list of HTTP methods (e.g. `GET`) which are allowed from the specified origin.
|
|
11392
|
+
"""
|
|
11393
|
+
allowed_origins: pulumi.Input[Sequence[pulumi.Input[str]]]
|
|
11394
|
+
"""
|
|
11395
|
+
A list of hosts from which requests using the specified methods are allowed. A host may contain one wildcard (e.g. http://*.example.com).
|
|
11396
|
+
"""
|
|
11397
|
+
allowed_headers: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
11398
|
+
"""
|
|
11399
|
+
A list of headers that will be included in the CORS preflight request's `Access-Control-Request-Headers`. A header may contain one wildcard (e.g. `x-amz-*`).
|
|
11400
|
+
"""
|
|
11401
|
+
max_age_seconds: NotRequired[pulumi.Input[int]]
|
|
11402
|
+
"""
|
|
11403
|
+
The time in seconds that browser can cache the response for a preflight request.
|
|
11404
|
+
"""
|
|
11405
|
+
elif False:
|
|
11406
|
+
SpacesBucketCorsRuleArgsDict: TypeAlias = Mapping[str, Any]
|
|
11407
|
+
|
|
8730
11408
|
@pulumi.input_type
|
|
8731
11409
|
class SpacesBucketCorsRuleArgs:
|
|
8732
11410
|
def __init__(__self__, *,
|
|
@@ -8796,6 +11474,38 @@ class SpacesBucketCorsRuleArgs:
|
|
|
8796
11474
|
pulumi.set(self, "max_age_seconds", value)
|
|
8797
11475
|
|
|
8798
11476
|
|
|
11477
|
+
if not MYPY:
|
|
11478
|
+
class SpacesBucketLifecycleRuleArgsDict(TypedDict):
|
|
11479
|
+
enabled: pulumi.Input[bool]
|
|
11480
|
+
"""
|
|
11481
|
+
Specifies lifecycle rule status.
|
|
11482
|
+
"""
|
|
11483
|
+
abort_incomplete_multipart_upload_days: NotRequired[pulumi.Input[int]]
|
|
11484
|
+
"""
|
|
11485
|
+
Specifies the number of days after initiating a multipart
|
|
11486
|
+
upload when the multipart upload must be completed or else Spaces will abort the upload.
|
|
11487
|
+
"""
|
|
11488
|
+
expiration: NotRequired[pulumi.Input['SpacesBucketLifecycleRuleExpirationArgsDict']]
|
|
11489
|
+
"""
|
|
11490
|
+
Specifies a time period after which applicable objects expire (documented below).
|
|
11491
|
+
"""
|
|
11492
|
+
id: NotRequired[pulumi.Input[str]]
|
|
11493
|
+
"""
|
|
11494
|
+
Unique identifier for the rule.
|
|
11495
|
+
"""
|
|
11496
|
+
noncurrent_version_expiration: NotRequired[pulumi.Input['SpacesBucketLifecycleRuleNoncurrentVersionExpirationArgsDict']]
|
|
11497
|
+
"""
|
|
11498
|
+
Specifies when non-current object versions expire (documented below).
|
|
11499
|
+
|
|
11500
|
+
At least one of `expiration` or `noncurrent_version_expiration` must be specified.
|
|
11501
|
+
"""
|
|
11502
|
+
prefix: NotRequired[pulumi.Input[str]]
|
|
11503
|
+
"""
|
|
11504
|
+
Object key prefix identifying one or more objects to which the rule applies.
|
|
11505
|
+
"""
|
|
11506
|
+
elif False:
|
|
11507
|
+
SpacesBucketLifecycleRuleArgsDict: TypeAlias = Mapping[str, Any]
|
|
11508
|
+
|
|
8799
11509
|
@pulumi.input_type
|
|
8800
11510
|
class SpacesBucketLifecycleRuleArgs:
|
|
8801
11511
|
def __init__(__self__, *,
|
|
@@ -8904,6 +11614,25 @@ class SpacesBucketLifecycleRuleArgs:
|
|
|
8904
11614
|
pulumi.set(self, "prefix", value)
|
|
8905
11615
|
|
|
8906
11616
|
|
|
11617
|
+
if not MYPY:
|
|
11618
|
+
class SpacesBucketLifecycleRuleExpirationArgsDict(TypedDict):
|
|
11619
|
+
date: NotRequired[pulumi.Input[str]]
|
|
11620
|
+
"""
|
|
11621
|
+
Specifies the date/time after which you want applicable objects to expire. The argument uses
|
|
11622
|
+
RFC3339 format, e.g. "2020-03-22T15:03:55Z" or parts thereof e.g. "2019-02-28".
|
|
11623
|
+
"""
|
|
11624
|
+
days: NotRequired[pulumi.Input[int]]
|
|
11625
|
+
"""
|
|
11626
|
+
Specifies the number of days after object creation when the applicable objects will expire.
|
|
11627
|
+
"""
|
|
11628
|
+
expired_object_delete_marker: NotRequired[pulumi.Input[bool]]
|
|
11629
|
+
"""
|
|
11630
|
+
On a versioned bucket (versioning-enabled or versioning-suspended
|
|
11631
|
+
bucket), setting this to true directs Spaces to delete expired object delete markers.
|
|
11632
|
+
"""
|
|
11633
|
+
elif False:
|
|
11634
|
+
SpacesBucketLifecycleRuleExpirationArgsDict: TypeAlias = Mapping[str, Any]
|
|
11635
|
+
|
|
8907
11636
|
@pulumi.input_type
|
|
8908
11637
|
class SpacesBucketLifecycleRuleExpirationArgs:
|
|
8909
11638
|
def __init__(__self__, *,
|
|
@@ -8963,6 +11692,15 @@ class SpacesBucketLifecycleRuleExpirationArgs:
|
|
|
8963
11692
|
pulumi.set(self, "expired_object_delete_marker", value)
|
|
8964
11693
|
|
|
8965
11694
|
|
|
11695
|
+
if not MYPY:
|
|
11696
|
+
class SpacesBucketLifecycleRuleNoncurrentVersionExpirationArgsDict(TypedDict):
|
|
11697
|
+
days: NotRequired[pulumi.Input[int]]
|
|
11698
|
+
"""
|
|
11699
|
+
Specifies the number of days after which an object's non-current versions expire.
|
|
11700
|
+
"""
|
|
11701
|
+
elif False:
|
|
11702
|
+
SpacesBucketLifecycleRuleNoncurrentVersionExpirationArgsDict: TypeAlias = Mapping[str, Any]
|
|
11703
|
+
|
|
8966
11704
|
@pulumi.input_type
|
|
8967
11705
|
class SpacesBucketLifecycleRuleNoncurrentVersionExpirationArgs:
|
|
8968
11706
|
def __init__(__self__, *,
|
|
@@ -8986,6 +11724,16 @@ class SpacesBucketLifecycleRuleNoncurrentVersionExpirationArgs:
|
|
|
8986
11724
|
pulumi.set(self, "days", value)
|
|
8987
11725
|
|
|
8988
11726
|
|
|
11727
|
+
if not MYPY:
|
|
11728
|
+
class SpacesBucketVersioningArgsDict(TypedDict):
|
|
11729
|
+
enabled: NotRequired[pulumi.Input[bool]]
|
|
11730
|
+
"""
|
|
11731
|
+
Enable versioning. Once you version-enable a bucket, it can never return to an unversioned
|
|
11732
|
+
state. You can, however, suspend versioning on that bucket.
|
|
11733
|
+
"""
|
|
11734
|
+
elif False:
|
|
11735
|
+
SpacesBucketVersioningArgsDict: TypeAlias = Mapping[str, Any]
|
|
11736
|
+
|
|
8989
11737
|
@pulumi.input_type
|
|
8990
11738
|
class SpacesBucketVersioningArgs:
|
|
8991
11739
|
def __init__(__self__, *,
|
|
@@ -9011,6 +11759,16 @@ class SpacesBucketVersioningArgs:
|
|
|
9011
11759
|
pulumi.set(self, "enabled", value)
|
|
9012
11760
|
|
|
9013
11761
|
|
|
11762
|
+
if not MYPY:
|
|
11763
|
+
class UptimeAlertNotificationArgsDict(TypedDict):
|
|
11764
|
+
emails: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
11765
|
+
"""
|
|
11766
|
+
List of email addresses to sent notifications to.
|
|
11767
|
+
"""
|
|
11768
|
+
slacks: NotRequired[pulumi.Input[Sequence[pulumi.Input['UptimeAlertNotificationSlackArgsDict']]]]
|
|
11769
|
+
elif False:
|
|
11770
|
+
UptimeAlertNotificationArgsDict: TypeAlias = Mapping[str, Any]
|
|
11771
|
+
|
|
9014
11772
|
@pulumi.input_type
|
|
9015
11773
|
class UptimeAlertNotificationArgs:
|
|
9016
11774
|
def __init__(__self__, *,
|
|
@@ -9046,6 +11804,19 @@ class UptimeAlertNotificationArgs:
|
|
|
9046
11804
|
pulumi.set(self, "slacks", value)
|
|
9047
11805
|
|
|
9048
11806
|
|
|
11807
|
+
if not MYPY:
|
|
11808
|
+
class UptimeAlertNotificationSlackArgsDict(TypedDict):
|
|
11809
|
+
channel: pulumi.Input[str]
|
|
11810
|
+
"""
|
|
11811
|
+
The Slack channel to send alerts to.
|
|
11812
|
+
"""
|
|
11813
|
+
url: pulumi.Input[str]
|
|
11814
|
+
"""
|
|
11815
|
+
The webhook URL for Slack.
|
|
11816
|
+
"""
|
|
11817
|
+
elif False:
|
|
11818
|
+
UptimeAlertNotificationSlackArgsDict: TypeAlias = Mapping[str, Any]
|
|
11819
|
+
|
|
9049
11820
|
@pulumi.input_type
|
|
9050
11821
|
class UptimeAlertNotificationSlackArgs:
|
|
9051
11822
|
def __init__(__self__, *,
|
|
@@ -9083,6 +11854,23 @@ class UptimeAlertNotificationSlackArgs:
|
|
|
9083
11854
|
pulumi.set(self, "url", value)
|
|
9084
11855
|
|
|
9085
11856
|
|
|
11857
|
+
if not MYPY:
|
|
11858
|
+
class GetAppDedicatedIpArgsDict(TypedDict):
|
|
11859
|
+
id: str
|
|
11860
|
+
"""
|
|
11861
|
+
The ID of the dedicated egress IP.
|
|
11862
|
+
"""
|
|
11863
|
+
ip: str
|
|
11864
|
+
"""
|
|
11865
|
+
The IP address of the dedicated egress IP.
|
|
11866
|
+
"""
|
|
11867
|
+
status: str
|
|
11868
|
+
"""
|
|
11869
|
+
The status of the dedicated egress IP.
|
|
11870
|
+
"""
|
|
11871
|
+
elif False:
|
|
11872
|
+
GetAppDedicatedIpArgsDict: TypeAlias = Mapping[str, Any]
|
|
11873
|
+
|
|
9086
11874
|
@pulumi.input_type
|
|
9087
11875
|
class GetAppDedicatedIpArgs:
|
|
9088
11876
|
def __init__(__self__, *,
|
|
@@ -9135,6 +11923,32 @@ class GetAppDedicatedIpArgs:
|
|
|
9135
11923
|
pulumi.set(self, "status", value)
|
|
9136
11924
|
|
|
9137
11925
|
|
|
11926
|
+
if not MYPY:
|
|
11927
|
+
class GetDomainsFilterArgsDict(TypedDict):
|
|
11928
|
+
key: str
|
|
11929
|
+
"""
|
|
11930
|
+
Filter the domains by this key. This may be one of `name`, `urn`, and `ttl`.
|
|
11931
|
+
"""
|
|
11932
|
+
values: Sequence[str]
|
|
11933
|
+
"""
|
|
11934
|
+
A list of values to match against the `key` field. Only retrieves domains
|
|
11935
|
+
where the `key` field takes on one or more of the values provided here.
|
|
11936
|
+
"""
|
|
11937
|
+
all: NotRequired[bool]
|
|
11938
|
+
"""
|
|
11939
|
+
Set to `true` to require that a field match all of the `values` instead of just one or more of
|
|
11940
|
+
them. This is useful when matching against multi-valued fields such as lists or sets where you want to ensure
|
|
11941
|
+
that all of the `values` are present in the list or set.
|
|
11942
|
+
"""
|
|
11943
|
+
match_by: NotRequired[str]
|
|
11944
|
+
"""
|
|
11945
|
+
One of `exact` (default), `re`, or `substring`. For string-typed fields, specify `re` to
|
|
11946
|
+
match by using the `values` as regular expressions, or specify `substring` to match by treating the `values` as
|
|
11947
|
+
substrings to find within the string field.
|
|
11948
|
+
"""
|
|
11949
|
+
elif False:
|
|
11950
|
+
GetDomainsFilterArgsDict: TypeAlias = Mapping[str, Any]
|
|
11951
|
+
|
|
9138
11952
|
@pulumi.input_type
|
|
9139
11953
|
class GetDomainsFilterArgs:
|
|
9140
11954
|
def __init__(__self__, *,
|
|
@@ -9214,6 +12028,19 @@ class GetDomainsFilterArgs:
|
|
|
9214
12028
|
pulumi.set(self, "match_by", value)
|
|
9215
12029
|
|
|
9216
12030
|
|
|
12031
|
+
if not MYPY:
|
|
12032
|
+
class GetDomainsSortArgsDict(TypedDict):
|
|
12033
|
+
key: str
|
|
12034
|
+
"""
|
|
12035
|
+
Sort the domains by this key. This may be one of `name`, `urn`, and `ttl`.
|
|
12036
|
+
"""
|
|
12037
|
+
direction: NotRequired[str]
|
|
12038
|
+
"""
|
|
12039
|
+
The sort direction. This may be either `asc` or `desc`.
|
|
12040
|
+
"""
|
|
12041
|
+
elif False:
|
|
12042
|
+
GetDomainsSortArgsDict: TypeAlias = Mapping[str, Any]
|
|
12043
|
+
|
|
9217
12044
|
@pulumi.input_type
|
|
9218
12045
|
class GetDomainsSortArgs:
|
|
9219
12046
|
def __init__(__self__, *,
|
|
@@ -9252,6 +12079,35 @@ class GetDomainsSortArgs:
|
|
|
9252
12079
|
pulumi.set(self, "direction", value)
|
|
9253
12080
|
|
|
9254
12081
|
|
|
12082
|
+
if not MYPY:
|
|
12083
|
+
class GetDropletsFilterArgsDict(TypedDict):
|
|
12084
|
+
key: str
|
|
12085
|
+
"""
|
|
12086
|
+
Filter the Droplets by this key. This may be one of `backups`, `created_at`, `disk`, `id`,
|
|
12087
|
+
`image`, `ipv4_address`, `ipv4_address_private`, `ipv6`, `ipv6_address`, `ipv6_address_private`, `locked`,
|
|
12088
|
+
`memory`, `monitoring`, `name`, `price_hourly`, `price_monthly`, `private_networking`, `region`, `size`,
|
|
12089
|
+
`status`, `tags`, `urn`, `vcpus`, `volume_ids`, or `vpc_uuid`.
|
|
12090
|
+
"""
|
|
12091
|
+
values: Sequence[str]
|
|
12092
|
+
"""
|
|
12093
|
+
A list of values to match against the `key` field. Only retrieves Droplets
|
|
12094
|
+
where the `key` field takes on one or more of the values provided here.
|
|
12095
|
+
"""
|
|
12096
|
+
all: NotRequired[bool]
|
|
12097
|
+
"""
|
|
12098
|
+
Set to `true` to require that a field match all of the `values` instead of just one or more of
|
|
12099
|
+
them. This is useful when matching against multi-valued fields such as lists or sets where you want to ensure
|
|
12100
|
+
that all of the `values` are present in the list or set.
|
|
12101
|
+
"""
|
|
12102
|
+
match_by: NotRequired[str]
|
|
12103
|
+
"""
|
|
12104
|
+
One of `exact` (default), `re`, or `substring`. For string-typed fields, specify `re` to
|
|
12105
|
+
match by using the `values` as regular expressions, or specify `substring` to match by treating the `values` as
|
|
12106
|
+
substrings to find within the string field.
|
|
12107
|
+
"""
|
|
12108
|
+
elif False:
|
|
12109
|
+
GetDropletsFilterArgsDict: TypeAlias = Mapping[str, Any]
|
|
12110
|
+
|
|
9255
12111
|
@pulumi.input_type
|
|
9256
12112
|
class GetDropletsFilterArgs:
|
|
9257
12113
|
def __init__(__self__, *,
|
|
@@ -9337,6 +12193,22 @@ class GetDropletsFilterArgs:
|
|
|
9337
12193
|
pulumi.set(self, "match_by", value)
|
|
9338
12194
|
|
|
9339
12195
|
|
|
12196
|
+
if not MYPY:
|
|
12197
|
+
class GetDropletsSortArgsDict(TypedDict):
|
|
12198
|
+
key: str
|
|
12199
|
+
"""
|
|
12200
|
+
Sort the Droplets by this key. This may be one of `backups`, `created_at`, `disk`, `id`,
|
|
12201
|
+
`image`, `ipv4_address`, `ipv4_address_private`, `ipv6`, `ipv6_address`, `ipv6_address_private`, `locked`,
|
|
12202
|
+
`memory`, `monitoring`, `name`, `price_hourly`, `price_monthly`, `private_networking`, `region`, `size`,
|
|
12203
|
+
`status`, `urn`, `vcpus`, or `vpc_uuid`.
|
|
12204
|
+
"""
|
|
12205
|
+
direction: NotRequired[str]
|
|
12206
|
+
"""
|
|
12207
|
+
The sort direction. This may be either `asc` or `desc`.
|
|
12208
|
+
"""
|
|
12209
|
+
elif False:
|
|
12210
|
+
GetDropletsSortArgsDict: TypeAlias = Mapping[str, Any]
|
|
12211
|
+
|
|
9340
12212
|
@pulumi.input_type
|
|
9341
12213
|
class GetDropletsSortArgs:
|
|
9342
12214
|
def __init__(__self__, *,
|
|
@@ -9357,29 +12229,68 @@ class GetDropletsSortArgs:
|
|
|
9357
12229
|
@pulumi.getter
|
|
9358
12230
|
def key(self) -> str:
|
|
9359
12231
|
"""
|
|
9360
|
-
Sort the Droplets by this key. This may be one of `backups`, `created_at`, `disk`, `id`,
|
|
9361
|
-
`image`, `ipv4_address`, `ipv4_address_private`, `ipv6`, `ipv6_address`, `ipv6_address_private`, `locked`,
|
|
9362
|
-
`memory`, `monitoring`, `name`, `price_hourly`, `price_monthly`, `private_networking`, `region`, `size`,
|
|
9363
|
-
`status`, `urn`, `vcpus`, or `vpc_uuid`.
|
|
12232
|
+
Sort the Droplets by this key. This may be one of `backups`, `created_at`, `disk`, `id`,
|
|
12233
|
+
`image`, `ipv4_address`, `ipv4_address_private`, `ipv6`, `ipv6_address`, `ipv6_address_private`, `locked`,
|
|
12234
|
+
`memory`, `monitoring`, `name`, `price_hourly`, `price_monthly`, `private_networking`, `region`, `size`,
|
|
12235
|
+
`status`, `urn`, `vcpus`, or `vpc_uuid`.
|
|
12236
|
+
"""
|
|
12237
|
+
return pulumi.get(self, "key")
|
|
12238
|
+
|
|
12239
|
+
@key.setter
|
|
12240
|
+
def key(self, value: str):
|
|
12241
|
+
pulumi.set(self, "key", value)
|
|
12242
|
+
|
|
12243
|
+
@property
|
|
12244
|
+
@pulumi.getter
|
|
12245
|
+
def direction(self) -> Optional[str]:
|
|
12246
|
+
"""
|
|
12247
|
+
The sort direction. This may be either `asc` or `desc`.
|
|
12248
|
+
"""
|
|
12249
|
+
return pulumi.get(self, "direction")
|
|
12250
|
+
|
|
12251
|
+
@direction.setter
|
|
12252
|
+
def direction(self, value: Optional[str]):
|
|
12253
|
+
pulumi.set(self, "direction", value)
|
|
12254
|
+
|
|
12255
|
+
|
|
12256
|
+
if not MYPY:
|
|
12257
|
+
class GetFirewallInboundRuleArgsDict(TypedDict):
|
|
12258
|
+
protocol: str
|
|
12259
|
+
"""
|
|
12260
|
+
The type of traffic to be allowed.
|
|
12261
|
+
This may be one of "tcp", "udp", or "icmp".
|
|
12262
|
+
"""
|
|
12263
|
+
port_range: NotRequired[str]
|
|
12264
|
+
"""
|
|
12265
|
+
The ports on which traffic will be allowed
|
|
12266
|
+
specified as a string containing a single port, a range (e.g. "8000-9000"),
|
|
12267
|
+
or "1-65535" to open all ports for a protocol. Required for when protocol is
|
|
12268
|
+
`tcp` or `udp`.
|
|
12269
|
+
"""
|
|
12270
|
+
source_addresses: NotRequired[Sequence[str]]
|
|
12271
|
+
"""
|
|
12272
|
+
An array of strings containing the IPv4
|
|
12273
|
+
addresses, IPv6 addresses, IPv4 CIDRs, and/or IPv6 CIDRs from which the
|
|
12274
|
+
inbound traffic will be accepted.
|
|
12275
|
+
"""
|
|
12276
|
+
source_droplet_ids: NotRequired[Sequence[int]]
|
|
12277
|
+
"""
|
|
12278
|
+
An array containing the IDs of
|
|
12279
|
+
the Droplets from which the inbound traffic will be accepted.
|
|
12280
|
+
"""
|
|
12281
|
+
source_kubernetes_ids: NotRequired[Sequence[str]]
|
|
12282
|
+
source_load_balancer_uids: NotRequired[Sequence[str]]
|
|
9364
12283
|
"""
|
|
9365
|
-
|
|
9366
|
-
|
|
9367
|
-
@key.setter
|
|
9368
|
-
def key(self, value: str):
|
|
9369
|
-
pulumi.set(self, "key", value)
|
|
9370
|
-
|
|
9371
|
-
@property
|
|
9372
|
-
@pulumi.getter
|
|
9373
|
-
def direction(self) -> Optional[str]:
|
|
12284
|
+
An array containing the IDs
|
|
12285
|
+
of the Load Balancers from which the inbound traffic will be accepted.
|
|
9374
12286
|
"""
|
|
9375
|
-
|
|
12287
|
+
source_tags: NotRequired[Sequence[str]]
|
|
9376
12288
|
"""
|
|
9377
|
-
|
|
9378
|
-
|
|
9379
|
-
|
|
9380
|
-
|
|
9381
|
-
|
|
9382
|
-
|
|
12289
|
+
A set of names of Tags corresponding to group of
|
|
12290
|
+
Droplets from which the inbound traffic will be accepted.
|
|
12291
|
+
"""
|
|
12292
|
+
elif False:
|
|
12293
|
+
GetFirewallInboundRuleArgsDict: TypeAlias = Mapping[str, Any]
|
|
9383
12294
|
|
|
9384
12295
|
@pulumi.input_type
|
|
9385
12296
|
class GetFirewallInboundRuleArgs:
|
|
@@ -9513,6 +12424,47 @@ class GetFirewallInboundRuleArgs:
|
|
|
9513
12424
|
pulumi.set(self, "source_tags", value)
|
|
9514
12425
|
|
|
9515
12426
|
|
|
12427
|
+
if not MYPY:
|
|
12428
|
+
class GetFirewallOutboundRuleArgsDict(TypedDict):
|
|
12429
|
+
protocol: str
|
|
12430
|
+
"""
|
|
12431
|
+
The type of traffic to be allowed.
|
|
12432
|
+
This may be one of "tcp", "udp", or "icmp".
|
|
12433
|
+
"""
|
|
12434
|
+
destination_addresses: NotRequired[Sequence[str]]
|
|
12435
|
+
"""
|
|
12436
|
+
An array of strings containing the IPv4
|
|
12437
|
+
addresses, IPv6 addresses, IPv4 CIDRs, and/or IPv6 CIDRs to which the
|
|
12438
|
+
outbound traffic will be allowed.
|
|
12439
|
+
"""
|
|
12440
|
+
destination_droplet_ids: NotRequired[Sequence[int]]
|
|
12441
|
+
"""
|
|
12442
|
+
An array containing the IDs of
|
|
12443
|
+
the Droplets to which the outbound traffic will be allowed.
|
|
12444
|
+
"""
|
|
12445
|
+
destination_kubernetes_ids: NotRequired[Sequence[str]]
|
|
12446
|
+
destination_load_balancer_uids: NotRequired[Sequence[str]]
|
|
12447
|
+
"""
|
|
12448
|
+
An array containing the IDs
|
|
12449
|
+
of the Load Balancers to which the outbound traffic will be allowed.
|
|
12450
|
+
"""
|
|
12451
|
+
destination_tags: NotRequired[Sequence[str]]
|
|
12452
|
+
"""
|
|
12453
|
+
An array containing the names of Tags
|
|
12454
|
+
corresponding to groups of Droplets to which the outbound traffic will
|
|
12455
|
+
be allowed.
|
|
12456
|
+
traffic.
|
|
12457
|
+
"""
|
|
12458
|
+
port_range: NotRequired[str]
|
|
12459
|
+
"""
|
|
12460
|
+
The ports on which traffic will be allowed
|
|
12461
|
+
specified as a string containing a single port, a range (e.g. "8000-9000"),
|
|
12462
|
+
or "1-65535" to open all ports for a protocol. Required for when protocol is
|
|
12463
|
+
`tcp` or `udp`.
|
|
12464
|
+
"""
|
|
12465
|
+
elif False:
|
|
12466
|
+
GetFirewallOutboundRuleArgsDict: TypeAlias = Mapping[str, Any]
|
|
12467
|
+
|
|
9516
12468
|
@pulumi.input_type
|
|
9517
12469
|
class GetFirewallOutboundRuleArgs:
|
|
9518
12470
|
def __init__(__self__, *,
|
|
@@ -9649,6 +12601,34 @@ class GetFirewallOutboundRuleArgs:
|
|
|
9649
12601
|
pulumi.set(self, "port_range", value)
|
|
9650
12602
|
|
|
9651
12603
|
|
|
12604
|
+
if not MYPY:
|
|
12605
|
+
class GetImagesFilterArgsDict(TypedDict):
|
|
12606
|
+
key: str
|
|
12607
|
+
"""
|
|
12608
|
+
Filter the images by this key. This may be one of `distribution`, `error_message`,
|
|
12609
|
+
`id`, `image`, `min_disk_size`, `name`, `private`, `regions`, `size_gigabytes`, `slug`, `status`,
|
|
12610
|
+
`tags`, or `type`.
|
|
12611
|
+
"""
|
|
12612
|
+
values: Sequence[str]
|
|
12613
|
+
"""
|
|
12614
|
+
A list of values to match against the `key` field. Only retrieves images
|
|
12615
|
+
where the `key` field takes on one or more of the values provided here.
|
|
12616
|
+
"""
|
|
12617
|
+
all: NotRequired[bool]
|
|
12618
|
+
"""
|
|
12619
|
+
Set to `true` to require that a field match all of the `values` instead of just one or more of
|
|
12620
|
+
them. This is useful when matching against multi-valued fields such as lists or sets where you want to ensure
|
|
12621
|
+
that all of the `values` are present in the list or set.
|
|
12622
|
+
"""
|
|
12623
|
+
match_by: NotRequired[str]
|
|
12624
|
+
"""
|
|
12625
|
+
One of `exact` (default), `re`, or `substring`. For string-typed fields, specify `re` to
|
|
12626
|
+
match by using the `values` as regular expressions, or specify `substring` to match by treating the `values` as
|
|
12627
|
+
substrings to find within the string field.
|
|
12628
|
+
"""
|
|
12629
|
+
elif False:
|
|
12630
|
+
GetImagesFilterArgsDict: TypeAlias = Mapping[str, Any]
|
|
12631
|
+
|
|
9652
12632
|
@pulumi.input_type
|
|
9653
12633
|
class GetImagesFilterArgs:
|
|
9654
12634
|
def __init__(__self__, *,
|
|
@@ -9732,6 +12712,20 @@ class GetImagesFilterArgs:
|
|
|
9732
12712
|
pulumi.set(self, "match_by", value)
|
|
9733
12713
|
|
|
9734
12714
|
|
|
12715
|
+
if not MYPY:
|
|
12716
|
+
class GetImagesSortArgsDict(TypedDict):
|
|
12717
|
+
key: str
|
|
12718
|
+
"""
|
|
12719
|
+
Sort the images by this key. This may be one of `distribution`, `error_message`, `id`,
|
|
12720
|
+
`image`, `min_disk_size`, `name`, `private`, `size_gigabytes`, `slug`, `status`, or `type`.
|
|
12721
|
+
"""
|
|
12722
|
+
direction: NotRequired[str]
|
|
12723
|
+
"""
|
|
12724
|
+
The sort direction. This may be either `asc` or `desc`.
|
|
12725
|
+
"""
|
|
12726
|
+
elif False:
|
|
12727
|
+
GetImagesSortArgsDict: TypeAlias = Mapping[str, Any]
|
|
12728
|
+
|
|
9735
12729
|
@pulumi.input_type
|
|
9736
12730
|
class GetImagesSortArgs:
|
|
9737
12731
|
def __init__(__self__, *,
|
|
@@ -9772,6 +12766,33 @@ class GetImagesSortArgs:
|
|
|
9772
12766
|
pulumi.set(self, "direction", value)
|
|
9773
12767
|
|
|
9774
12768
|
|
|
12769
|
+
if not MYPY:
|
|
12770
|
+
class GetProjectsFilterArgsDict(TypedDict):
|
|
12771
|
+
key: str
|
|
12772
|
+
"""
|
|
12773
|
+
Filter the projects by this key. This may be one of `name`,
|
|
12774
|
+
`purpose`, `description`, `environment`, or `is_default`.
|
|
12775
|
+
"""
|
|
12776
|
+
values: Sequence[str]
|
|
12777
|
+
"""
|
|
12778
|
+
A list of values to match against the `key` field. Only retrieves projects
|
|
12779
|
+
where the `key` field takes on one or more of the values provided here.
|
|
12780
|
+
"""
|
|
12781
|
+
all: NotRequired[bool]
|
|
12782
|
+
"""
|
|
12783
|
+
Set to `true` to require that a field match all of the `values` instead of just one or more of
|
|
12784
|
+
them. This is useful when matching against multi-valued fields such as lists or sets where you want to ensure
|
|
12785
|
+
that all of the `values` are present in the list or set.
|
|
12786
|
+
"""
|
|
12787
|
+
match_by: NotRequired[str]
|
|
12788
|
+
"""
|
|
12789
|
+
One of `exact` (default), `re`, or `substring`. For string-typed fields, specify `re` to
|
|
12790
|
+
match by using the `values` as regular expressions, or specify `substring` to match by treating the `values` as
|
|
12791
|
+
substrings to find within the string field.
|
|
12792
|
+
"""
|
|
12793
|
+
elif False:
|
|
12794
|
+
GetProjectsFilterArgsDict: TypeAlias = Mapping[str, Any]
|
|
12795
|
+
|
|
9775
12796
|
@pulumi.input_type
|
|
9776
12797
|
class GetProjectsFilterArgs:
|
|
9777
12798
|
def __init__(__self__, *,
|
|
@@ -9853,6 +12874,20 @@ class GetProjectsFilterArgs:
|
|
|
9853
12874
|
pulumi.set(self, "match_by", value)
|
|
9854
12875
|
|
|
9855
12876
|
|
|
12877
|
+
if not MYPY:
|
|
12878
|
+
class GetProjectsSortArgsDict(TypedDict):
|
|
12879
|
+
key: str
|
|
12880
|
+
"""
|
|
12881
|
+
Sort the projects by this key. This may be one of `name`,
|
|
12882
|
+
`purpose`, `description`, or `environment`.
|
|
12883
|
+
"""
|
|
12884
|
+
direction: NotRequired[str]
|
|
12885
|
+
"""
|
|
12886
|
+
The sort direction. This may be either `asc` or `desc`.
|
|
12887
|
+
"""
|
|
12888
|
+
elif False:
|
|
12889
|
+
GetProjectsSortArgsDict: TypeAlias = Mapping[str, Any]
|
|
12890
|
+
|
|
9856
12891
|
@pulumi.input_type
|
|
9857
12892
|
class GetProjectsSortArgs:
|
|
9858
12893
|
def __init__(__self__, *,
|
|
@@ -9893,6 +12928,33 @@ class GetProjectsSortArgs:
|
|
|
9893
12928
|
pulumi.set(self, "direction", value)
|
|
9894
12929
|
|
|
9895
12930
|
|
|
12931
|
+
if not MYPY:
|
|
12932
|
+
class GetRecordsFilterArgsDict(TypedDict):
|
|
12933
|
+
key: str
|
|
12934
|
+
"""
|
|
12935
|
+
Filter the DNS records by this key. This may be one of `domain`, `flags`, `name`, `port`,
|
|
12936
|
+
`priority`, `tag`, `ttl`, `type`, `value`, or `weight`.
|
|
12937
|
+
"""
|
|
12938
|
+
values: Sequence[str]
|
|
12939
|
+
"""
|
|
12940
|
+
A list of values to match against the `key` field. Only retrieves DNS records
|
|
12941
|
+
where the `key` field takes on one or more of the values provided here.
|
|
12942
|
+
"""
|
|
12943
|
+
all: NotRequired[bool]
|
|
12944
|
+
"""
|
|
12945
|
+
Set to `true` to require that a field match all of the `values` instead of just one or more of
|
|
12946
|
+
them. This is useful when matching against multi-valued fields such as lists or sets where you want to ensure
|
|
12947
|
+
that all of the `values` are present in the list or set.
|
|
12948
|
+
"""
|
|
12949
|
+
match_by: NotRequired[str]
|
|
12950
|
+
"""
|
|
12951
|
+
One of `exact` (default), `re`, or `substring`. For string-typed fields, specify `re` to
|
|
12952
|
+
match by using the `values` as regular expressions, or specify `substring` to match by treating the `values` as
|
|
12953
|
+
substrings to find within the string field.
|
|
12954
|
+
"""
|
|
12955
|
+
elif False:
|
|
12956
|
+
GetRecordsFilterArgsDict: TypeAlias = Mapping[str, Any]
|
|
12957
|
+
|
|
9896
12958
|
@pulumi.input_type
|
|
9897
12959
|
class GetRecordsFilterArgs:
|
|
9898
12960
|
def __init__(__self__, *,
|
|
@@ -9974,6 +13036,20 @@ class GetRecordsFilterArgs:
|
|
|
9974
13036
|
pulumi.set(self, "match_by", value)
|
|
9975
13037
|
|
|
9976
13038
|
|
|
13039
|
+
if not MYPY:
|
|
13040
|
+
class GetRecordsSortArgsDict(TypedDict):
|
|
13041
|
+
key: str
|
|
13042
|
+
"""
|
|
13043
|
+
Sort the DNS records by this key. This may be one of `domain`, `flags`, `name`, `port`,
|
|
13044
|
+
`priority`, `tag`, `ttl`, `type`, `value`, or `weight`.
|
|
13045
|
+
"""
|
|
13046
|
+
direction: NotRequired[str]
|
|
13047
|
+
"""
|
|
13048
|
+
The sort direction. This may be either `asc` or `desc`.
|
|
13049
|
+
"""
|
|
13050
|
+
elif False:
|
|
13051
|
+
GetRecordsSortArgsDict: TypeAlias = Mapping[str, Any]
|
|
13052
|
+
|
|
9977
13053
|
@pulumi.input_type
|
|
9978
13054
|
class GetRecordsSortArgs:
|
|
9979
13055
|
def __init__(__self__, *,
|
|
@@ -10014,6 +13090,33 @@ class GetRecordsSortArgs:
|
|
|
10014
13090
|
pulumi.set(self, "direction", value)
|
|
10015
13091
|
|
|
10016
13092
|
|
|
13093
|
+
if not MYPY:
|
|
13094
|
+
class GetRegionsFilterArgsDict(TypedDict):
|
|
13095
|
+
key: str
|
|
13096
|
+
"""
|
|
13097
|
+
Filter the regions by this key. This may be one of `slug`,
|
|
13098
|
+
`name`, `available`, `features`, or `sizes`.
|
|
13099
|
+
"""
|
|
13100
|
+
values: Sequence[str]
|
|
13101
|
+
"""
|
|
13102
|
+
A list of values to match against the `key` field. Only retrieves regions
|
|
13103
|
+
where the `key` field takes on one or more of the values provided here.
|
|
13104
|
+
"""
|
|
13105
|
+
all: NotRequired[bool]
|
|
13106
|
+
"""
|
|
13107
|
+
Set to `true` to require that a field match all of the `values` instead of just one or more of
|
|
13108
|
+
them. This is useful when matching against multi-valued fields such as lists or sets where you want to ensure
|
|
13109
|
+
that all of the `values` are present in the list or set.
|
|
13110
|
+
"""
|
|
13111
|
+
match_by: NotRequired[str]
|
|
13112
|
+
"""
|
|
13113
|
+
One of `exact` (default), `re`, or `substring`. For string-typed fields, specify `re` to
|
|
13114
|
+
match by using the `values` as regular expressions, or specify `substring` to match by treating the `values` as
|
|
13115
|
+
substrings to find within the string field.
|
|
13116
|
+
"""
|
|
13117
|
+
elif False:
|
|
13118
|
+
GetRegionsFilterArgsDict: TypeAlias = Mapping[str, Any]
|
|
13119
|
+
|
|
10017
13120
|
@pulumi.input_type
|
|
10018
13121
|
class GetRegionsFilterArgs:
|
|
10019
13122
|
def __init__(__self__, *,
|
|
@@ -10095,6 +13198,20 @@ class GetRegionsFilterArgs:
|
|
|
10095
13198
|
pulumi.set(self, "match_by", value)
|
|
10096
13199
|
|
|
10097
13200
|
|
|
13201
|
+
if not MYPY:
|
|
13202
|
+
class GetRegionsSortArgsDict(TypedDict):
|
|
13203
|
+
key: str
|
|
13204
|
+
"""
|
|
13205
|
+
Sort the regions by this key. This may be one of `slug`,
|
|
13206
|
+
`name`, or `available`.
|
|
13207
|
+
"""
|
|
13208
|
+
direction: NotRequired[str]
|
|
13209
|
+
"""
|
|
13210
|
+
The sort direction. This may be either `asc` or `desc`.
|
|
13211
|
+
"""
|
|
13212
|
+
elif False:
|
|
13213
|
+
GetRegionsSortArgsDict: TypeAlias = Mapping[str, Any]
|
|
13214
|
+
|
|
10098
13215
|
@pulumi.input_type
|
|
10099
13216
|
class GetRegionsSortArgs:
|
|
10100
13217
|
def __init__(__self__, *,
|
|
@@ -10135,6 +13252,34 @@ class GetRegionsSortArgs:
|
|
|
10135
13252
|
pulumi.set(self, "direction", value)
|
|
10136
13253
|
|
|
10137
13254
|
|
|
13255
|
+
if not MYPY:
|
|
13256
|
+
class GetSizesFilterArgsDict(TypedDict):
|
|
13257
|
+
key: str
|
|
13258
|
+
"""
|
|
13259
|
+
Filter the sizes by this key. This may be one of `slug`,
|
|
13260
|
+
`regions`, `memory`, `vcpus`, `disk`, `transfer`, `price_monthly`,
|
|
13261
|
+
`price_hourly`, or `available`.
|
|
13262
|
+
"""
|
|
13263
|
+
values: Sequence[str]
|
|
13264
|
+
"""
|
|
13265
|
+
Only retrieves sizes which keys has value that matches
|
|
13266
|
+
one of the values provided here.
|
|
13267
|
+
"""
|
|
13268
|
+
all: NotRequired[bool]
|
|
13269
|
+
"""
|
|
13270
|
+
Set to `true` to require that a field match all of the `values` instead of just one or more of
|
|
13271
|
+
them. This is useful when matching against multi-valued fields such as lists or sets where you want to ensure
|
|
13272
|
+
that all of the `values` are present in the list or set.
|
|
13273
|
+
"""
|
|
13274
|
+
match_by: NotRequired[str]
|
|
13275
|
+
"""
|
|
13276
|
+
One of `exact` (default), `re`, or `substring`. For string-typed fields, specify `re` to
|
|
13277
|
+
match by using the `values` as regular expressions, or specify `substring` to match by treating the `values` as
|
|
13278
|
+
substrings to find within the string field.
|
|
13279
|
+
"""
|
|
13280
|
+
elif False:
|
|
13281
|
+
GetSizesFilterArgsDict: TypeAlias = Mapping[str, Any]
|
|
13282
|
+
|
|
10138
13283
|
@pulumi.input_type
|
|
10139
13284
|
class GetSizesFilterArgs:
|
|
10140
13285
|
def __init__(__self__, *,
|
|
@@ -10218,6 +13363,20 @@ class GetSizesFilterArgs:
|
|
|
10218
13363
|
pulumi.set(self, "match_by", value)
|
|
10219
13364
|
|
|
10220
13365
|
|
|
13366
|
+
if not MYPY:
|
|
13367
|
+
class GetSizesSortArgsDict(TypedDict):
|
|
13368
|
+
key: str
|
|
13369
|
+
"""
|
|
13370
|
+
Sort the sizes by this key. This may be one of `slug`,
|
|
13371
|
+
`memory`, `vcpus`, `disk`, `transfer`, `price_monthly`, or `price_hourly`.
|
|
13372
|
+
"""
|
|
13373
|
+
direction: NotRequired[str]
|
|
13374
|
+
"""
|
|
13375
|
+
The sort direction. This may be either `asc` or `desc`.
|
|
13376
|
+
"""
|
|
13377
|
+
elif False:
|
|
13378
|
+
GetSizesSortArgsDict: TypeAlias = Mapping[str, Any]
|
|
13379
|
+
|
|
10221
13380
|
@pulumi.input_type
|
|
10222
13381
|
class GetSizesSortArgs:
|
|
10223
13382
|
def __init__(__self__, *,
|
|
@@ -10258,6 +13417,32 @@ class GetSizesSortArgs:
|
|
|
10258
13417
|
pulumi.set(self, "direction", value)
|
|
10259
13418
|
|
|
10260
13419
|
|
|
13420
|
+
if not MYPY:
|
|
13421
|
+
class GetSpacesBucketsFilterArgsDict(TypedDict):
|
|
13422
|
+
key: str
|
|
13423
|
+
"""
|
|
13424
|
+
Filter the images by this key. This may be one of `bucket_domain_name`, `name`, `region`, or `urn`.
|
|
13425
|
+
"""
|
|
13426
|
+
values: Sequence[str]
|
|
13427
|
+
"""
|
|
13428
|
+
A list of values to match against the `key` field. Only retrieves Spaces buckets
|
|
13429
|
+
where the `key` field takes on one or more of the values provided here.
|
|
13430
|
+
"""
|
|
13431
|
+
all: NotRequired[bool]
|
|
13432
|
+
"""
|
|
13433
|
+
Set to `true` to require that a field match all of the `values` instead of just one or more of
|
|
13434
|
+
them. This is useful when matching against multi-valued fields such as lists or sets where you want to ensure
|
|
13435
|
+
that all of the `values` are present in the list or set.
|
|
13436
|
+
"""
|
|
13437
|
+
match_by: NotRequired[str]
|
|
13438
|
+
"""
|
|
13439
|
+
One of `exact` (default), `re`, or `substring`. For string-typed fields, specify `re` to
|
|
13440
|
+
match by using the `values` as regular expressions, or specify `substring` to match by treating the `values` as
|
|
13441
|
+
substrings to find within the string field.
|
|
13442
|
+
"""
|
|
13443
|
+
elif False:
|
|
13444
|
+
GetSpacesBucketsFilterArgsDict: TypeAlias = Mapping[str, Any]
|
|
13445
|
+
|
|
10261
13446
|
@pulumi.input_type
|
|
10262
13447
|
class GetSpacesBucketsFilterArgs:
|
|
10263
13448
|
def __init__(__self__, *,
|
|
@@ -10337,6 +13522,19 @@ class GetSpacesBucketsFilterArgs:
|
|
|
10337
13522
|
pulumi.set(self, "match_by", value)
|
|
10338
13523
|
|
|
10339
13524
|
|
|
13525
|
+
if not MYPY:
|
|
13526
|
+
class GetSpacesBucketsSortArgsDict(TypedDict):
|
|
13527
|
+
key: str
|
|
13528
|
+
"""
|
|
13529
|
+
Sort the images by this key. This may be one of `bucket_domain_name`, `name`, `region`, or `urn`.
|
|
13530
|
+
"""
|
|
13531
|
+
direction: NotRequired[str]
|
|
13532
|
+
"""
|
|
13533
|
+
The sort direction. This may be either `asc` or `desc`.
|
|
13534
|
+
"""
|
|
13535
|
+
elif False:
|
|
13536
|
+
GetSpacesBucketsSortArgsDict: TypeAlias = Mapping[str, Any]
|
|
13537
|
+
|
|
10340
13538
|
@pulumi.input_type
|
|
10341
13539
|
class GetSpacesBucketsSortArgs:
|
|
10342
13540
|
def __init__(__self__, *,
|
|
@@ -10375,6 +13573,21 @@ class GetSpacesBucketsSortArgs:
|
|
|
10375
13573
|
pulumi.set(self, "direction", value)
|
|
10376
13574
|
|
|
10377
13575
|
|
|
13576
|
+
if not MYPY:
|
|
13577
|
+
class GetSshKeysFilterArgsDict(TypedDict):
|
|
13578
|
+
key: str
|
|
13579
|
+
"""
|
|
13580
|
+
Filter the SSH Keys by this key. This may be one of `name`, `public_key`, or `fingerprint`.
|
|
13581
|
+
"""
|
|
13582
|
+
values: Sequence[str]
|
|
13583
|
+
"""
|
|
13584
|
+
A list of values to match against the key field. Only retrieves SSH keys where the key field matches one or more of the values provided here.
|
|
13585
|
+
"""
|
|
13586
|
+
all: NotRequired[bool]
|
|
13587
|
+
match_by: NotRequired[str]
|
|
13588
|
+
elif False:
|
|
13589
|
+
GetSshKeysFilterArgsDict: TypeAlias = Mapping[str, Any]
|
|
13590
|
+
|
|
10378
13591
|
@pulumi.input_type
|
|
10379
13592
|
class GetSshKeysFilterArgs:
|
|
10380
13593
|
def __init__(__self__, *,
|
|
@@ -10436,6 +13649,19 @@ class GetSshKeysFilterArgs:
|
|
|
10436
13649
|
pulumi.set(self, "match_by", value)
|
|
10437
13650
|
|
|
10438
13651
|
|
|
13652
|
+
if not MYPY:
|
|
13653
|
+
class GetSshKeysSortArgsDict(TypedDict):
|
|
13654
|
+
key: str
|
|
13655
|
+
"""
|
|
13656
|
+
Sort the SSH Keys by this key. This may be one of `name`, `public_key`, or `fingerprint`.
|
|
13657
|
+
"""
|
|
13658
|
+
direction: NotRequired[str]
|
|
13659
|
+
"""
|
|
13660
|
+
The sort direction. This may be either `asc` or `desc`.
|
|
13661
|
+
"""
|
|
13662
|
+
elif False:
|
|
13663
|
+
GetSshKeysSortArgsDict: TypeAlias = Mapping[str, Any]
|
|
13664
|
+
|
|
10439
13665
|
@pulumi.input_type
|
|
10440
13666
|
class GetSshKeysSortArgs:
|
|
10441
13667
|
def __init__(__self__, *,
|
|
@@ -10474,6 +13700,32 @@ class GetSshKeysSortArgs:
|
|
|
10474
13700
|
pulumi.set(self, "direction", value)
|
|
10475
13701
|
|
|
10476
13702
|
|
|
13703
|
+
if not MYPY:
|
|
13704
|
+
class GetTagsFilterArgsDict(TypedDict):
|
|
13705
|
+
key: str
|
|
13706
|
+
"""
|
|
13707
|
+
Filter the tags by this key. This may be one of `name`, `total_resource_count`, `droplets_count`, `images_count`, `volumes_count`, `volume_snapshots_count`, or `databases_count`.
|
|
13708
|
+
"""
|
|
13709
|
+
values: Sequence[str]
|
|
13710
|
+
"""
|
|
13711
|
+
Only retrieves tags which keys has value that matches
|
|
13712
|
+
one of the values provided here.
|
|
13713
|
+
"""
|
|
13714
|
+
all: NotRequired[bool]
|
|
13715
|
+
"""
|
|
13716
|
+
Set to `true` to require that a field match all of the `values` instead of just one or more of
|
|
13717
|
+
them. This is useful when matching against multi-valued fields such as lists or sets where you want to ensure
|
|
13718
|
+
that all of the `values` are present in the list or set.
|
|
13719
|
+
"""
|
|
13720
|
+
match_by: NotRequired[str]
|
|
13721
|
+
"""
|
|
13722
|
+
One of `exact` (default), `re`, or `substring`. For string-typed fields, specify `re` to
|
|
13723
|
+
match by using the `values` as regular expressions, or specify `substring` to match by treating the `values` as
|
|
13724
|
+
substrings to find within the string field.
|
|
13725
|
+
"""
|
|
13726
|
+
elif False:
|
|
13727
|
+
GetTagsFilterArgsDict: TypeAlias = Mapping[str, Any]
|
|
13728
|
+
|
|
10477
13729
|
@pulumi.input_type
|
|
10478
13730
|
class GetTagsFilterArgs:
|
|
10479
13731
|
def __init__(__self__, *,
|
|
@@ -10553,6 +13805,19 @@ class GetTagsFilterArgs:
|
|
|
10553
13805
|
pulumi.set(self, "match_by", value)
|
|
10554
13806
|
|
|
10555
13807
|
|
|
13808
|
+
if not MYPY:
|
|
13809
|
+
class GetTagsSortArgsDict(TypedDict):
|
|
13810
|
+
key: str
|
|
13811
|
+
"""
|
|
13812
|
+
Sort the tags by this key. This may be one of `name`, `total_resource_count`, `droplets_count`, `images_count`, `volumes_count`, `volume_snapshots_count`, or `databases_count`.
|
|
13813
|
+
"""
|
|
13814
|
+
direction: NotRequired[str]
|
|
13815
|
+
"""
|
|
13816
|
+
The sort direction. This may be either `asc` or `desc`.
|
|
13817
|
+
"""
|
|
13818
|
+
elif False:
|
|
13819
|
+
GetTagsSortArgsDict: TypeAlias = Mapping[str, Any]
|
|
13820
|
+
|
|
10556
13821
|
@pulumi.input_type
|
|
10557
13822
|
class GetTagsSortArgs:
|
|
10558
13823
|
def __init__(__self__, *,
|