pulumi-digitalocean 4.33.0a1727221610__py3-none-any.whl → 4.33.1__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 +18 -0
- pulumi_digitalocean/_inputs.py +3372 -61
- pulumi_digitalocean/_utilities.py +1 -1
- pulumi_digitalocean/app.py +5 -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 +1040 -0
- pulumi_digitalocean/database_kafka_topic.py +5 -0
- pulumi_digitalocean/database_mongodb_config.py +452 -0
- pulumi_digitalocean/database_mysql_config.py +5 -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 +5 -0
- 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 +57 -1
- 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 +5 -0
- 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.0a1727221610.dist-info → pulumi_digitalocean-4.33.1.dist-info}/METADATA +3 -2
- pulumi_digitalocean-4.33.1.dist-info/RECORD +102 -0
- {pulumi_digitalocean-4.33.0a1727221610.dist-info → pulumi_digitalocean-4.33.1.dist-info}/WHEEL +1 -1
- pulumi_digitalocean-4.33.0a1727221610.dist-info/RECORD +0 -100
- {pulumi_digitalocean-4.33.0a1727221610.dist-info → pulumi_digitalocean-4.33.1.dist-info}/top_level.txt +0 -0
pulumi_digitalocean/_inputs.py
CHANGED
|
@@ -4,160 +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',
|
|
209
|
+
'DatabaseUserSettingOpensearchAclArgs',
|
|
210
|
+
'DatabaseUserSettingOpensearchAclArgsDict',
|
|
109
211
|
'FirewallInboundRuleArgs',
|
|
212
|
+
'FirewallInboundRuleArgsDict',
|
|
110
213
|
'FirewallOutboundRuleArgs',
|
|
214
|
+
'FirewallOutboundRuleArgsDict',
|
|
111
215
|
'FirewallPendingChangeArgs',
|
|
216
|
+
'FirewallPendingChangeArgsDict',
|
|
112
217
|
'KubernetesClusterKubeConfigArgs',
|
|
218
|
+
'KubernetesClusterKubeConfigArgsDict',
|
|
113
219
|
'KubernetesClusterMaintenancePolicyArgs',
|
|
220
|
+
'KubernetesClusterMaintenancePolicyArgsDict',
|
|
114
221
|
'KubernetesClusterNodePoolArgs',
|
|
222
|
+
'KubernetesClusterNodePoolArgsDict',
|
|
115
223
|
'KubernetesClusterNodePoolNodeArgs',
|
|
224
|
+
'KubernetesClusterNodePoolNodeArgsDict',
|
|
116
225
|
'KubernetesClusterNodePoolTaintArgs',
|
|
226
|
+
'KubernetesClusterNodePoolTaintArgsDict',
|
|
117
227
|
'KubernetesNodePoolNodeArgs',
|
|
228
|
+
'KubernetesNodePoolNodeArgsDict',
|
|
118
229
|
'KubernetesNodePoolTaintArgs',
|
|
230
|
+
'KubernetesNodePoolTaintArgsDict',
|
|
119
231
|
'LoadBalancerDomainArgs',
|
|
232
|
+
'LoadBalancerDomainArgsDict',
|
|
120
233
|
'LoadBalancerFirewallArgs',
|
|
234
|
+
'LoadBalancerFirewallArgsDict',
|
|
121
235
|
'LoadBalancerForwardingRuleArgs',
|
|
236
|
+
'LoadBalancerForwardingRuleArgsDict',
|
|
122
237
|
'LoadBalancerGlbSettingsArgs',
|
|
238
|
+
'LoadBalancerGlbSettingsArgsDict',
|
|
123
239
|
'LoadBalancerGlbSettingsCdnArgs',
|
|
240
|
+
'LoadBalancerGlbSettingsCdnArgsDict',
|
|
124
241
|
'LoadBalancerHealthcheckArgs',
|
|
242
|
+
'LoadBalancerHealthcheckArgsDict',
|
|
125
243
|
'LoadBalancerStickySessionsArgs',
|
|
244
|
+
'LoadBalancerStickySessionsArgsDict',
|
|
126
245
|
'MonitorAlertAlertsArgs',
|
|
246
|
+
'MonitorAlertAlertsArgsDict',
|
|
127
247
|
'MonitorAlertAlertsSlackArgs',
|
|
248
|
+
'MonitorAlertAlertsSlackArgsDict',
|
|
128
249
|
'SpacesBucketCorsConfigurationCorsRuleArgs',
|
|
250
|
+
'SpacesBucketCorsConfigurationCorsRuleArgsDict',
|
|
129
251
|
'SpacesBucketCorsRuleArgs',
|
|
252
|
+
'SpacesBucketCorsRuleArgsDict',
|
|
130
253
|
'SpacesBucketLifecycleRuleArgs',
|
|
254
|
+
'SpacesBucketLifecycleRuleArgsDict',
|
|
131
255
|
'SpacesBucketLifecycleRuleExpirationArgs',
|
|
256
|
+
'SpacesBucketLifecycleRuleExpirationArgsDict',
|
|
132
257
|
'SpacesBucketLifecycleRuleNoncurrentVersionExpirationArgs',
|
|
258
|
+
'SpacesBucketLifecycleRuleNoncurrentVersionExpirationArgsDict',
|
|
133
259
|
'SpacesBucketVersioningArgs',
|
|
260
|
+
'SpacesBucketVersioningArgsDict',
|
|
134
261
|
'UptimeAlertNotificationArgs',
|
|
262
|
+
'UptimeAlertNotificationArgsDict',
|
|
135
263
|
'UptimeAlertNotificationSlackArgs',
|
|
264
|
+
'UptimeAlertNotificationSlackArgsDict',
|
|
136
265
|
'GetAppDedicatedIpArgs',
|
|
266
|
+
'GetAppDedicatedIpArgsDict',
|
|
137
267
|
'GetDomainsFilterArgs',
|
|
268
|
+
'GetDomainsFilterArgsDict',
|
|
138
269
|
'GetDomainsSortArgs',
|
|
270
|
+
'GetDomainsSortArgsDict',
|
|
139
271
|
'GetDropletsFilterArgs',
|
|
272
|
+
'GetDropletsFilterArgsDict',
|
|
140
273
|
'GetDropletsSortArgs',
|
|
274
|
+
'GetDropletsSortArgsDict',
|
|
141
275
|
'GetFirewallInboundRuleArgs',
|
|
276
|
+
'GetFirewallInboundRuleArgsDict',
|
|
142
277
|
'GetFirewallOutboundRuleArgs',
|
|
278
|
+
'GetFirewallOutboundRuleArgsDict',
|
|
143
279
|
'GetImagesFilterArgs',
|
|
280
|
+
'GetImagesFilterArgsDict',
|
|
144
281
|
'GetImagesSortArgs',
|
|
282
|
+
'GetImagesSortArgsDict',
|
|
145
283
|
'GetProjectsFilterArgs',
|
|
284
|
+
'GetProjectsFilterArgsDict',
|
|
146
285
|
'GetProjectsSortArgs',
|
|
286
|
+
'GetProjectsSortArgsDict',
|
|
147
287
|
'GetRecordsFilterArgs',
|
|
288
|
+
'GetRecordsFilterArgsDict',
|
|
148
289
|
'GetRecordsSortArgs',
|
|
290
|
+
'GetRecordsSortArgsDict',
|
|
149
291
|
'GetRegionsFilterArgs',
|
|
292
|
+
'GetRegionsFilterArgsDict',
|
|
150
293
|
'GetRegionsSortArgs',
|
|
294
|
+
'GetRegionsSortArgsDict',
|
|
151
295
|
'GetSizesFilterArgs',
|
|
296
|
+
'GetSizesFilterArgsDict',
|
|
152
297
|
'GetSizesSortArgs',
|
|
298
|
+
'GetSizesSortArgsDict',
|
|
153
299
|
'GetSpacesBucketsFilterArgs',
|
|
300
|
+
'GetSpacesBucketsFilterArgsDict',
|
|
154
301
|
'GetSpacesBucketsSortArgs',
|
|
302
|
+
'GetSpacesBucketsSortArgsDict',
|
|
155
303
|
'GetSshKeysFilterArgs',
|
|
304
|
+
'GetSshKeysFilterArgsDict',
|
|
156
305
|
'GetSshKeysSortArgs',
|
|
306
|
+
'GetSshKeysSortArgsDict',
|
|
157
307
|
'GetTagsFilterArgs',
|
|
308
|
+
'GetTagsFilterArgsDict',
|
|
158
309
|
'GetTagsSortArgs',
|
|
310
|
+
'GetTagsSortArgsDict',
|
|
159
311
|
]
|
|
160
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
|
+
|
|
161
332
|
@pulumi.input_type
|
|
162
333
|
class AppDedicatedIpArgs:
|
|
163
334
|
def __init__(__self__, *,
|
|
@@ -213,6 +384,50 @@ class AppDedicatedIpArgs:
|
|
|
213
384
|
pulumi.set(self, "status", value)
|
|
214
385
|
|
|
215
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
|
+
|
|
216
431
|
@pulumi.input_type
|
|
217
432
|
class AppSpecArgs:
|
|
218
433
|
def __init__(__self__, *,
|
|
@@ -435,6 +650,19 @@ class AppSpecArgs:
|
|
|
435
650
|
pulumi.set(self, "workers", value)
|
|
436
651
|
|
|
437
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
|
+
|
|
438
666
|
@pulumi.input_type
|
|
439
667
|
class AppSpecAlertArgs:
|
|
440
668
|
def __init__(__self__, *,
|
|
@@ -473,6 +701,41 @@ class AppSpecAlertArgs:
|
|
|
473
701
|
pulumi.set(self, "disabled", value)
|
|
474
702
|
|
|
475
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
|
+
|
|
476
739
|
@pulumi.input_type
|
|
477
740
|
class AppSpecDatabaseArgs:
|
|
478
741
|
def __init__(__self__, *,
|
|
@@ -596,6 +859,30 @@ class AppSpecDatabaseArgs:
|
|
|
596
859
|
pulumi.set(self, "version", value)
|
|
597
860
|
|
|
598
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
|
+
|
|
599
886
|
@pulumi.input_type
|
|
600
887
|
class AppSpecDomainNameArgs:
|
|
601
888
|
def __init__(__self__, *,
|
|
@@ -672,6 +959,15 @@ class AppSpecDomainNameArgs:
|
|
|
672
959
|
pulumi.set(self, "zone", value)
|
|
673
960
|
|
|
674
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
|
+
|
|
675
971
|
@pulumi.input_type
|
|
676
972
|
class AppSpecEgressArgs:
|
|
677
973
|
def __init__(__self__, *,
|
|
@@ -695,6 +991,27 @@ class AppSpecEgressArgs:
|
|
|
695
991
|
pulumi.set(self, "type", value)
|
|
696
992
|
|
|
697
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
|
+
|
|
698
1015
|
@pulumi.input_type
|
|
699
1016
|
class AppSpecEnvArgs:
|
|
700
1017
|
def __init__(__self__, *,
|
|
@@ -766,6 +1083,51 @@ class AppSpecEnvArgs:
|
|
|
766
1083
|
pulumi.set(self, "value", value)
|
|
767
1084
|
|
|
768
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
|
+
|
|
769
1131
|
@pulumi.input_type
|
|
770
1132
|
class AppSpecFunctionArgs:
|
|
771
1133
|
def __init__(__self__, *,
|
|
@@ -940,6 +1302,31 @@ class AppSpecFunctionArgs:
|
|
|
940
1302
|
pulumi.set(self, "source_dir", value)
|
|
941
1303
|
|
|
942
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
|
+
|
|
943
1330
|
@pulumi.input_type
|
|
944
1331
|
class AppSpecFunctionAlertArgs:
|
|
945
1332
|
def __init__(__self__, *,
|
|
@@ -1023,6 +1410,35 @@ class AppSpecFunctionAlertArgs:
|
|
|
1023
1410
|
pulumi.set(self, "disabled", value)
|
|
1024
1411
|
|
|
1025
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
|
+
|
|
1026
1442
|
@pulumi.input_type
|
|
1027
1443
|
class AppSpecFunctionCorsArgs:
|
|
1028
1444
|
def __init__(__self__, *,
|
|
@@ -1126,6 +1542,23 @@ class AppSpecFunctionCorsArgs:
|
|
|
1126
1542
|
pulumi.set(self, "max_age", value)
|
|
1127
1543
|
|
|
1128
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
|
+
|
|
1129
1562
|
@pulumi.input_type
|
|
1130
1563
|
class AppSpecFunctionCorsAllowOriginsArgs:
|
|
1131
1564
|
def __init__(__self__, *,
|
|
@@ -1185,6 +1618,27 @@ class AppSpecFunctionCorsAllowOriginsArgs:
|
|
|
1185
1618
|
pulumi.set(self, "regex", value)
|
|
1186
1619
|
|
|
1187
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
|
+
|
|
1188
1642
|
@pulumi.input_type
|
|
1189
1643
|
class AppSpecFunctionEnvArgs:
|
|
1190
1644
|
def __init__(__self__, *,
|
|
@@ -1256,6 +1710,19 @@ class AppSpecFunctionEnvArgs:
|
|
|
1256
1710
|
pulumi.set(self, "value", value)
|
|
1257
1711
|
|
|
1258
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
|
+
|
|
1259
1726
|
@pulumi.input_type
|
|
1260
1727
|
class AppSpecFunctionGitArgs:
|
|
1261
1728
|
def __init__(__self__, *,
|
|
@@ -1295,6 +1762,23 @@ class AppSpecFunctionGitArgs:
|
|
|
1295
1762
|
pulumi.set(self, "repo_clone_url", value)
|
|
1296
1763
|
|
|
1297
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
|
+
|
|
1298
1782
|
@pulumi.input_type
|
|
1299
1783
|
class AppSpecFunctionGithubArgs:
|
|
1300
1784
|
def __init__(__self__, *,
|
|
@@ -1350,6 +1834,23 @@ class AppSpecFunctionGithubArgs:
|
|
|
1350
1834
|
pulumi.set(self, "repo", value)
|
|
1351
1835
|
|
|
1352
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
|
+
|
|
1353
1854
|
@pulumi.input_type
|
|
1354
1855
|
class AppSpecFunctionGitlabArgs:
|
|
1355
1856
|
def __init__(__self__, *,
|
|
@@ -1405,6 +1906,31 @@ class AppSpecFunctionGitlabArgs:
|
|
|
1405
1906
|
pulumi.set(self, "repo", value)
|
|
1406
1907
|
|
|
1407
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
|
+
|
|
1408
1934
|
@pulumi.input_type
|
|
1409
1935
|
class AppSpecFunctionLogDestinationArgs:
|
|
1410
1936
|
def __init__(__self__, *,
|
|
@@ -1491,6 +2017,19 @@ class AppSpecFunctionLogDestinationArgs:
|
|
|
1491
2017
|
pulumi.set(self, "papertrail", value)
|
|
1492
2018
|
|
|
1493
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
|
+
|
|
1494
2033
|
@pulumi.input_type
|
|
1495
2034
|
class AppSpecFunctionLogDestinationDatadogArgs:
|
|
1496
2035
|
def __init__(__self__, *,
|
|
@@ -1529,6 +2068,15 @@ class AppSpecFunctionLogDestinationDatadogArgs:
|
|
|
1529
2068
|
pulumi.set(self, "endpoint", value)
|
|
1530
2069
|
|
|
1531
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
|
+
|
|
1532
2080
|
@pulumi.input_type
|
|
1533
2081
|
class AppSpecFunctionLogDestinationLogtailArgs:
|
|
1534
2082
|
def __init__(__self__, *,
|
|
@@ -1551,6 +2099,27 @@ class AppSpecFunctionLogDestinationLogtailArgs:
|
|
|
1551
2099
|
pulumi.set(self, "token", value)
|
|
1552
2100
|
|
|
1553
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
|
+
|
|
1554
2123
|
@pulumi.input_type
|
|
1555
2124
|
class AppSpecFunctionLogDestinationOpenSearchArgs:
|
|
1556
2125
|
def __init__(__self__, *,
|
|
@@ -1621,6 +2190,19 @@ class AppSpecFunctionLogDestinationOpenSearchArgs:
|
|
|
1621
2190
|
pulumi.set(self, "index_name", value)
|
|
1622
2191
|
|
|
1623
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
|
+
|
|
1624
2206
|
@pulumi.input_type
|
|
1625
2207
|
class AppSpecFunctionLogDestinationOpenSearchBasicAuthArgs:
|
|
1626
2208
|
def __init__(__self__, *,
|
|
@@ -1660,6 +2242,15 @@ class AppSpecFunctionLogDestinationOpenSearchBasicAuthArgs:
|
|
|
1660
2242
|
pulumi.set(self, "user", value)
|
|
1661
2243
|
|
|
1662
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
|
+
|
|
1663
2254
|
@pulumi.input_type
|
|
1664
2255
|
class AppSpecFunctionLogDestinationPapertrailArgs:
|
|
1665
2256
|
def __init__(__self__, *,
|
|
@@ -1682,6 +2273,19 @@ class AppSpecFunctionLogDestinationPapertrailArgs:
|
|
|
1682
2273
|
pulumi.set(self, "endpoint", value)
|
|
1683
2274
|
|
|
1684
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
|
+
|
|
1685
2289
|
@pulumi.input_type
|
|
1686
2290
|
class AppSpecFunctionRouteArgs:
|
|
1687
2291
|
def __init__(__self__, *,
|
|
@@ -1721,6 +2325,15 @@ class AppSpecFunctionRouteArgs:
|
|
|
1721
2325
|
pulumi.set(self, "preserve_path_prefix", value)
|
|
1722
2326
|
|
|
1723
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
|
+
|
|
1724
2337
|
@pulumi.input_type
|
|
1725
2338
|
class AppSpecIngressArgs:
|
|
1726
2339
|
def __init__(__self__, *,
|
|
@@ -1744,6 +2357,27 @@ class AppSpecIngressArgs:
|
|
|
1744
2357
|
pulumi.set(self, "rules", value)
|
|
1745
2358
|
|
|
1746
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
|
+
|
|
1747
2381
|
@pulumi.input_type
|
|
1748
2382
|
class AppSpecIngressRuleArgs:
|
|
1749
2383
|
def __init__(__self__, *,
|
|
@@ -1815,6 +2449,23 @@ class AppSpecIngressRuleArgs:
|
|
|
1815
2449
|
pulumi.set(self, "redirect", value)
|
|
1816
2450
|
|
|
1817
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
|
+
|
|
1818
2469
|
@pulumi.input_type
|
|
1819
2470
|
class AppSpecIngressRuleComponentArgs:
|
|
1820
2471
|
def __init__(__self__, *,
|
|
@@ -1870,6 +2521,35 @@ class AppSpecIngressRuleComponentArgs:
|
|
|
1870
2521
|
pulumi.set(self, "rewrite", value)
|
|
1871
2522
|
|
|
1872
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
|
+
|
|
1873
2553
|
@pulumi.input_type
|
|
1874
2554
|
class AppSpecIngressRuleCorsArgs:
|
|
1875
2555
|
def __init__(__self__, *,
|
|
@@ -1973,6 +2653,23 @@ class AppSpecIngressRuleCorsArgs:
|
|
|
1973
2653
|
pulumi.set(self, "max_age", value)
|
|
1974
2654
|
|
|
1975
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
|
+
|
|
1976
2673
|
@pulumi.input_type
|
|
1977
2674
|
class AppSpecIngressRuleCorsAllowOriginsArgs:
|
|
1978
2675
|
def __init__(__self__, *,
|
|
@@ -2032,6 +2729,15 @@ class AppSpecIngressRuleCorsAllowOriginsArgs:
|
|
|
2032
2729
|
pulumi.set(self, "regex", value)
|
|
2033
2730
|
|
|
2034
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
|
+
|
|
2035
2741
|
@pulumi.input_type
|
|
2036
2742
|
class AppSpecIngressRuleMatchArgs:
|
|
2037
2743
|
def __init__(__self__, *,
|
|
@@ -2055,6 +2761,15 @@ class AppSpecIngressRuleMatchArgs:
|
|
|
2055
2761
|
pulumi.set(self, "path", value)
|
|
2056
2762
|
|
|
2057
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
|
+
|
|
2058
2773
|
@pulumi.input_type
|
|
2059
2774
|
class AppSpecIngressRuleMatchPathArgs:
|
|
2060
2775
|
def __init__(__self__, *,
|
|
@@ -2078,6 +2793,31 @@ class AppSpecIngressRuleMatchPathArgs:
|
|
|
2078
2793
|
pulumi.set(self, "prefix", value)
|
|
2079
2794
|
|
|
2080
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
|
+
|
|
2081
2821
|
@pulumi.input_type
|
|
2082
2822
|
class AppSpecIngressRuleRedirectArgs:
|
|
2083
2823
|
def __init__(__self__, *,
|
|
@@ -2165,6 +2905,79 @@ class AppSpecIngressRuleRedirectArgs:
|
|
|
2165
2905
|
pulumi.set(self, "uri", value)
|
|
2166
2906
|
|
|
2167
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
|
+
|
|
2168
2981
|
@pulumi.input_type
|
|
2169
2982
|
class AppSpecJobArgs:
|
|
2170
2983
|
def __init__(__self__, *,
|
|
@@ -2435,6 +3248,31 @@ class AppSpecJobArgs:
|
|
|
2435
3248
|
pulumi.set(self, "source_dir", value)
|
|
2436
3249
|
|
|
2437
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
|
+
|
|
2438
3276
|
@pulumi.input_type
|
|
2439
3277
|
class AppSpecJobAlertArgs:
|
|
2440
3278
|
def __init__(__self__, *,
|
|
@@ -2518,6 +3356,27 @@ class AppSpecJobAlertArgs:
|
|
|
2518
3356
|
pulumi.set(self, "disabled", value)
|
|
2519
3357
|
|
|
2520
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
|
+
|
|
2521
3380
|
@pulumi.input_type
|
|
2522
3381
|
class AppSpecJobEnvArgs:
|
|
2523
3382
|
def __init__(__self__, *,
|
|
@@ -2589,6 +3448,19 @@ class AppSpecJobEnvArgs:
|
|
|
2589
3448
|
pulumi.set(self, "value", value)
|
|
2590
3449
|
|
|
2591
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
|
+
|
|
2592
3464
|
@pulumi.input_type
|
|
2593
3465
|
class AppSpecJobGitArgs:
|
|
2594
3466
|
def __init__(__self__, *,
|
|
@@ -2628,6 +3500,23 @@ class AppSpecJobGitArgs:
|
|
|
2628
3500
|
pulumi.set(self, "repo_clone_url", value)
|
|
2629
3501
|
|
|
2630
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
|
+
|
|
2631
3520
|
@pulumi.input_type
|
|
2632
3521
|
class AppSpecJobGithubArgs:
|
|
2633
3522
|
def __init__(__self__, *,
|
|
@@ -2683,6 +3572,23 @@ class AppSpecJobGithubArgs:
|
|
|
2683
3572
|
pulumi.set(self, "repo", value)
|
|
2684
3573
|
|
|
2685
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
|
+
|
|
2686
3592
|
@pulumi.input_type
|
|
2687
3593
|
class AppSpecJobGitlabArgs:
|
|
2688
3594
|
def __init__(__self__, *,
|
|
@@ -2738,6 +3644,35 @@ class AppSpecJobGitlabArgs:
|
|
|
2738
3644
|
pulumi.set(self, "repo", value)
|
|
2739
3645
|
|
|
2740
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
|
+
|
|
2741
3676
|
@pulumi.input_type
|
|
2742
3677
|
class AppSpecJobImageArgs:
|
|
2743
3678
|
def __init__(__self__, *,
|
|
@@ -2839,6 +3774,15 @@ class AppSpecJobImageArgs:
|
|
|
2839
3774
|
pulumi.set(self, "tag", value)
|
|
2840
3775
|
|
|
2841
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
|
+
|
|
2842
3786
|
@pulumi.input_type
|
|
2843
3787
|
class AppSpecJobImageDeployOnPushArgs:
|
|
2844
3788
|
def __init__(__self__, *,
|
|
@@ -2862,6 +3806,31 @@ class AppSpecJobImageDeployOnPushArgs:
|
|
|
2862
3806
|
pulumi.set(self, "enabled", value)
|
|
2863
3807
|
|
|
2864
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
|
+
|
|
2865
3834
|
@pulumi.input_type
|
|
2866
3835
|
class AppSpecJobLogDestinationArgs:
|
|
2867
3836
|
def __init__(__self__, *,
|
|
@@ -2948,6 +3917,19 @@ class AppSpecJobLogDestinationArgs:
|
|
|
2948
3917
|
pulumi.set(self, "papertrail", value)
|
|
2949
3918
|
|
|
2950
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
|
+
|
|
2951
3933
|
@pulumi.input_type
|
|
2952
3934
|
class AppSpecJobLogDestinationDatadogArgs:
|
|
2953
3935
|
def __init__(__self__, *,
|
|
@@ -2986,9 +3968,18 @@ class AppSpecJobLogDestinationDatadogArgs:
|
|
|
2986
3968
|
pulumi.set(self, "endpoint", value)
|
|
2987
3969
|
|
|
2988
3970
|
|
|
2989
|
-
|
|
2990
|
-
class
|
|
2991
|
-
|
|
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__, *,
|
|
2992
3983
|
token: pulumi.Input[str]):
|
|
2993
3984
|
"""
|
|
2994
3985
|
:param pulumi.Input[str] token: Logtail token.
|
|
@@ -3008,6 +3999,27 @@ class AppSpecJobLogDestinationLogtailArgs:
|
|
|
3008
3999
|
pulumi.set(self, "token", value)
|
|
3009
4000
|
|
|
3010
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
|
+
|
|
3011
4023
|
@pulumi.input_type
|
|
3012
4024
|
class AppSpecJobLogDestinationOpenSearchArgs:
|
|
3013
4025
|
def __init__(__self__, *,
|
|
@@ -3078,6 +4090,19 @@ class AppSpecJobLogDestinationOpenSearchArgs:
|
|
|
3078
4090
|
pulumi.set(self, "index_name", value)
|
|
3079
4091
|
|
|
3080
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
|
+
|
|
3081
4106
|
@pulumi.input_type
|
|
3082
4107
|
class AppSpecJobLogDestinationOpenSearchBasicAuthArgs:
|
|
3083
4108
|
def __init__(__self__, *,
|
|
@@ -3117,6 +4142,15 @@ class AppSpecJobLogDestinationOpenSearchBasicAuthArgs:
|
|
|
3117
4142
|
pulumi.set(self, "user", value)
|
|
3118
4143
|
|
|
3119
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
|
+
|
|
3120
4154
|
@pulumi.input_type
|
|
3121
4155
|
class AppSpecJobLogDestinationPapertrailArgs:
|
|
3122
4156
|
def __init__(__self__, *,
|
|
@@ -3139,6 +4173,95 @@ class AppSpecJobLogDestinationPapertrailArgs:
|
|
|
3139
4173
|
pulumi.set(self, "endpoint", value)
|
|
3140
4174
|
|
|
3141
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
|
+
|
|
3142
4265
|
@pulumi.input_type
|
|
3143
4266
|
class AppSpecServiceArgs:
|
|
3144
4267
|
def __init__(__self__, *,
|
|
@@ -3489,6 +4612,31 @@ class AppSpecServiceArgs:
|
|
|
3489
4612
|
pulumi.set(self, "source_dir", value)
|
|
3490
4613
|
|
|
3491
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
|
+
|
|
3492
4640
|
@pulumi.input_type
|
|
3493
4641
|
class AppSpecServiceAlertArgs:
|
|
3494
4642
|
def __init__(__self__, *,
|
|
@@ -3572,6 +4720,23 @@ class AppSpecServiceAlertArgs:
|
|
|
3572
4720
|
pulumi.set(self, "disabled", value)
|
|
3573
4721
|
|
|
3574
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
|
+
|
|
3575
4740
|
@pulumi.input_type
|
|
3576
4741
|
class AppSpecServiceAutoscalingArgs:
|
|
3577
4742
|
def __init__(__self__, *,
|
|
@@ -3624,6 +4789,15 @@ class AppSpecServiceAutoscalingArgs:
|
|
|
3624
4789
|
pulumi.set(self, "min_instance_count", value)
|
|
3625
4790
|
|
|
3626
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
|
+
|
|
3627
4801
|
@pulumi.input_type
|
|
3628
4802
|
class AppSpecServiceAutoscalingMetricsArgs:
|
|
3629
4803
|
def __init__(__self__, *,
|
|
@@ -3647,6 +4821,17 @@ class AppSpecServiceAutoscalingMetricsArgs:
|
|
|
3647
4821
|
pulumi.set(self, "cpu", value)
|
|
3648
4822
|
|
|
3649
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
|
+
|
|
3650
4835
|
@pulumi.input_type
|
|
3651
4836
|
class AppSpecServiceAutoscalingMetricsCpuArgs:
|
|
3652
4837
|
def __init__(__self__, *,
|
|
@@ -3673,6 +4858,35 @@ class AppSpecServiceAutoscalingMetricsCpuArgs:
|
|
|
3673
4858
|
pulumi.set(self, "percent", value)
|
|
3674
4859
|
|
|
3675
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
|
+
|
|
3676
4890
|
@pulumi.input_type
|
|
3677
4891
|
class AppSpecServiceCorsArgs:
|
|
3678
4892
|
def __init__(__self__, *,
|
|
@@ -3776,6 +4990,23 @@ class AppSpecServiceCorsArgs:
|
|
|
3776
4990
|
pulumi.set(self, "max_age", value)
|
|
3777
4991
|
|
|
3778
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
|
+
|
|
3779
5010
|
@pulumi.input_type
|
|
3780
5011
|
class AppSpecServiceCorsAllowOriginsArgs:
|
|
3781
5012
|
def __init__(__self__, *,
|
|
@@ -3835,6 +5066,27 @@ class AppSpecServiceCorsAllowOriginsArgs:
|
|
|
3835
5066
|
pulumi.set(self, "regex", value)
|
|
3836
5067
|
|
|
3837
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
|
+
|
|
3838
5090
|
@pulumi.input_type
|
|
3839
5091
|
class AppSpecServiceEnvArgs:
|
|
3840
5092
|
def __init__(__self__, *,
|
|
@@ -3906,6 +5158,19 @@ class AppSpecServiceEnvArgs:
|
|
|
3906
5158
|
pulumi.set(self, "value", value)
|
|
3907
5159
|
|
|
3908
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
|
+
|
|
3909
5174
|
@pulumi.input_type
|
|
3910
5175
|
class AppSpecServiceGitArgs:
|
|
3911
5176
|
def __init__(__self__, *,
|
|
@@ -3945,6 +5210,23 @@ class AppSpecServiceGitArgs:
|
|
|
3945
5210
|
pulumi.set(self, "repo_clone_url", value)
|
|
3946
5211
|
|
|
3947
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
|
+
|
|
3948
5230
|
@pulumi.input_type
|
|
3949
5231
|
class AppSpecServiceGithubArgs:
|
|
3950
5232
|
def __init__(__self__, *,
|
|
@@ -4000,6 +5282,23 @@ class AppSpecServiceGithubArgs:
|
|
|
4000
5282
|
pulumi.set(self, "repo", value)
|
|
4001
5283
|
|
|
4002
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
|
+
|
|
4003
5302
|
@pulumi.input_type
|
|
4004
5303
|
class AppSpecServiceGitlabArgs:
|
|
4005
5304
|
def __init__(__self__, *,
|
|
@@ -4055,6 +5354,39 @@ class AppSpecServiceGitlabArgs:
|
|
|
4055
5354
|
pulumi.set(self, "repo", value)
|
|
4056
5355
|
|
|
4057
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
|
+
|
|
4058
5390
|
@pulumi.input_type
|
|
4059
5391
|
class AppSpecServiceHealthCheckArgs:
|
|
4060
5392
|
def __init__(__self__, *,
|
|
@@ -4174,6 +5506,35 @@ class AppSpecServiceHealthCheckArgs:
|
|
|
4174
5506
|
pulumi.set(self, "timeout_seconds", value)
|
|
4175
5507
|
|
|
4176
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
|
+
|
|
4177
5538
|
@pulumi.input_type
|
|
4178
5539
|
class AppSpecServiceImageArgs:
|
|
4179
5540
|
def __init__(__self__, *,
|
|
@@ -4275,6 +5636,15 @@ class AppSpecServiceImageArgs:
|
|
|
4275
5636
|
pulumi.set(self, "tag", value)
|
|
4276
5637
|
|
|
4277
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
|
+
|
|
4278
5648
|
@pulumi.input_type
|
|
4279
5649
|
class AppSpecServiceImageDeployOnPushArgs:
|
|
4280
5650
|
def __init__(__self__, *,
|
|
@@ -4298,18 +5668,43 @@ class AppSpecServiceImageDeployOnPushArgs:
|
|
|
4298
5668
|
pulumi.set(self, "enabled", value)
|
|
4299
5669
|
|
|
4300
5670
|
|
|
4301
|
-
|
|
4302
|
-
class
|
|
4303
|
-
|
|
4304
|
-
name: pulumi.Input[str],
|
|
4305
|
-
datadog: Optional[pulumi.Input['AppSpecServiceLogDestinationDatadogArgs']] = None,
|
|
4306
|
-
logtail: Optional[pulumi.Input['AppSpecServiceLogDestinationLogtailArgs']] = None,
|
|
4307
|
-
open_search: Optional[pulumi.Input['AppSpecServiceLogDestinationOpenSearchArgs']] = None,
|
|
4308
|
-
papertrail: Optional[pulumi.Input['AppSpecServiceLogDestinationPapertrailArgs']] = None):
|
|
5671
|
+
if not MYPY:
|
|
5672
|
+
class AppSpecServiceLogDestinationArgsDict(TypedDict):
|
|
5673
|
+
name: pulumi.Input[str]
|
|
4309
5674
|
"""
|
|
4310
|
-
|
|
4311
|
-
|
|
4312
|
-
:
|
|
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.
|
|
4313
5708
|
:param pulumi.Input['AppSpecServiceLogDestinationOpenSearchArgs'] open_search: OpenSearch configuration.
|
|
4314
5709
|
:param pulumi.Input['AppSpecServiceLogDestinationPapertrailArgs'] papertrail: Papertrail configuration.
|
|
4315
5710
|
"""
|
|
@@ -4384,6 +5779,19 @@ class AppSpecServiceLogDestinationArgs:
|
|
|
4384
5779
|
pulumi.set(self, "papertrail", value)
|
|
4385
5780
|
|
|
4386
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
|
+
|
|
4387
5795
|
@pulumi.input_type
|
|
4388
5796
|
class AppSpecServiceLogDestinationDatadogArgs:
|
|
4389
5797
|
def __init__(__self__, *,
|
|
@@ -4422,6 +5830,15 @@ class AppSpecServiceLogDestinationDatadogArgs:
|
|
|
4422
5830
|
pulumi.set(self, "endpoint", value)
|
|
4423
5831
|
|
|
4424
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
|
+
|
|
4425
5842
|
@pulumi.input_type
|
|
4426
5843
|
class AppSpecServiceLogDestinationLogtailArgs:
|
|
4427
5844
|
def __init__(__self__, *,
|
|
@@ -4444,6 +5861,27 @@ class AppSpecServiceLogDestinationLogtailArgs:
|
|
|
4444
5861
|
pulumi.set(self, "token", value)
|
|
4445
5862
|
|
|
4446
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
|
+
|
|
4447
5885
|
@pulumi.input_type
|
|
4448
5886
|
class AppSpecServiceLogDestinationOpenSearchArgs:
|
|
4449
5887
|
def __init__(__self__, *,
|
|
@@ -4514,6 +5952,19 @@ class AppSpecServiceLogDestinationOpenSearchArgs:
|
|
|
4514
5952
|
pulumi.set(self, "index_name", value)
|
|
4515
5953
|
|
|
4516
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
|
+
|
|
4517
5968
|
@pulumi.input_type
|
|
4518
5969
|
class AppSpecServiceLogDestinationOpenSearchBasicAuthArgs:
|
|
4519
5970
|
def __init__(__self__, *,
|
|
@@ -4553,6 +6004,15 @@ class AppSpecServiceLogDestinationOpenSearchBasicAuthArgs:
|
|
|
4553
6004
|
pulumi.set(self, "user", value)
|
|
4554
6005
|
|
|
4555
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
|
+
|
|
4556
6016
|
@pulumi.input_type
|
|
4557
6017
|
class AppSpecServiceLogDestinationPapertrailArgs:
|
|
4558
6018
|
def __init__(__self__, *,
|
|
@@ -4575,6 +6035,19 @@ class AppSpecServiceLogDestinationPapertrailArgs:
|
|
|
4575
6035
|
pulumi.set(self, "endpoint", value)
|
|
4576
6036
|
|
|
4577
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
|
+
|
|
4578
6051
|
@pulumi.input_type
|
|
4579
6052
|
class AppSpecServiceRouteArgs:
|
|
4580
6053
|
def __init__(__self__, *,
|
|
@@ -4614,6 +6087,71 @@ class AppSpecServiceRouteArgs:
|
|
|
4614
6087
|
pulumi.set(self, "preserve_path_prefix", value)
|
|
4615
6088
|
|
|
4616
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
|
+
|
|
4617
6155
|
@pulumi.input_type
|
|
4618
6156
|
class AppSpecStaticSiteArgs:
|
|
4619
6157
|
def __init__(__self__, *,
|
|
@@ -4868,6 +6406,35 @@ class AppSpecStaticSiteArgs:
|
|
|
4868
6406
|
pulumi.set(self, "source_dir", value)
|
|
4869
6407
|
|
|
4870
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
|
+
|
|
4871
6438
|
@pulumi.input_type
|
|
4872
6439
|
class AppSpecStaticSiteCorsArgs:
|
|
4873
6440
|
def __init__(__self__, *,
|
|
@@ -4971,6 +6538,23 @@ class AppSpecStaticSiteCorsArgs:
|
|
|
4971
6538
|
pulumi.set(self, "max_age", value)
|
|
4972
6539
|
|
|
4973
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
|
+
|
|
4974
6558
|
@pulumi.input_type
|
|
4975
6559
|
class AppSpecStaticSiteCorsAllowOriginsArgs:
|
|
4976
6560
|
def __init__(__self__, *,
|
|
@@ -5030,6 +6614,27 @@ class AppSpecStaticSiteCorsAllowOriginsArgs:
|
|
|
5030
6614
|
pulumi.set(self, "regex", value)
|
|
5031
6615
|
|
|
5032
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
|
+
|
|
5033
6638
|
@pulumi.input_type
|
|
5034
6639
|
class AppSpecStaticSiteEnvArgs:
|
|
5035
6640
|
def __init__(__self__, *,
|
|
@@ -5101,6 +6706,19 @@ class AppSpecStaticSiteEnvArgs:
|
|
|
5101
6706
|
pulumi.set(self, "value", value)
|
|
5102
6707
|
|
|
5103
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
|
+
|
|
5104
6722
|
@pulumi.input_type
|
|
5105
6723
|
class AppSpecStaticSiteGitArgs:
|
|
5106
6724
|
def __init__(__self__, *,
|
|
@@ -5140,6 +6758,23 @@ class AppSpecStaticSiteGitArgs:
|
|
|
5140
6758
|
pulumi.set(self, "repo_clone_url", value)
|
|
5141
6759
|
|
|
5142
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
|
+
|
|
5143
6778
|
@pulumi.input_type
|
|
5144
6779
|
class AppSpecStaticSiteGithubArgs:
|
|
5145
6780
|
def __init__(__self__, *,
|
|
@@ -5195,6 +6830,23 @@ class AppSpecStaticSiteGithubArgs:
|
|
|
5195
6830
|
pulumi.set(self, "repo", value)
|
|
5196
6831
|
|
|
5197
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
|
+
|
|
5198
6850
|
@pulumi.input_type
|
|
5199
6851
|
class AppSpecStaticSiteGitlabArgs:
|
|
5200
6852
|
def __init__(__self__, *,
|
|
@@ -5250,6 +6902,19 @@ class AppSpecStaticSiteGitlabArgs:
|
|
|
5250
6902
|
pulumi.set(self, "repo", value)
|
|
5251
6903
|
|
|
5252
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
|
+
|
|
5253
6918
|
@pulumi.input_type
|
|
5254
6919
|
class AppSpecStaticSiteRouteArgs:
|
|
5255
6920
|
def __init__(__self__, *,
|
|
@@ -5289,6 +6954,71 @@ class AppSpecStaticSiteRouteArgs:
|
|
|
5289
6954
|
pulumi.set(self, "preserve_path_prefix", value)
|
|
5290
6955
|
|
|
5291
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
|
+
|
|
5292
7022
|
@pulumi.input_type
|
|
5293
7023
|
class AppSpecWorkerArgs:
|
|
5294
7024
|
def __init__(__self__, *,
|
|
@@ -5535,6 +7265,31 @@ class AppSpecWorkerArgs:
|
|
|
5535
7265
|
pulumi.set(self, "source_dir", value)
|
|
5536
7266
|
|
|
5537
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
|
+
|
|
5538
7293
|
@pulumi.input_type
|
|
5539
7294
|
class AppSpecWorkerAlertArgs:
|
|
5540
7295
|
def __init__(__self__, *,
|
|
@@ -5618,9 +7373,30 @@ class AppSpecWorkerAlertArgs:
|
|
|
5618
7373
|
pulumi.set(self, "disabled", value)
|
|
5619
7374
|
|
|
5620
7375
|
|
|
5621
|
-
|
|
5622
|
-
class
|
|
5623
|
-
|
|
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__, *,
|
|
5624
7400
|
key: Optional[pulumi.Input[str]] = None,
|
|
5625
7401
|
scope: Optional[pulumi.Input[str]] = None,
|
|
5626
7402
|
type: Optional[pulumi.Input[str]] = None,
|
|
@@ -5689,6 +7465,19 @@ class AppSpecWorkerEnvArgs:
|
|
|
5689
7465
|
pulumi.set(self, "value", value)
|
|
5690
7466
|
|
|
5691
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
|
+
|
|
5692
7481
|
@pulumi.input_type
|
|
5693
7482
|
class AppSpecWorkerGitArgs:
|
|
5694
7483
|
def __init__(__self__, *,
|
|
@@ -5728,6 +7517,23 @@ class AppSpecWorkerGitArgs:
|
|
|
5728
7517
|
pulumi.set(self, "repo_clone_url", value)
|
|
5729
7518
|
|
|
5730
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
|
+
|
|
5731
7537
|
@pulumi.input_type
|
|
5732
7538
|
class AppSpecWorkerGithubArgs:
|
|
5733
7539
|
def __init__(__self__, *,
|
|
@@ -5783,6 +7589,23 @@ class AppSpecWorkerGithubArgs:
|
|
|
5783
7589
|
pulumi.set(self, "repo", value)
|
|
5784
7590
|
|
|
5785
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
|
+
|
|
5786
7609
|
@pulumi.input_type
|
|
5787
7610
|
class AppSpecWorkerGitlabArgs:
|
|
5788
7611
|
def __init__(__self__, *,
|
|
@@ -5838,6 +7661,35 @@ class AppSpecWorkerGitlabArgs:
|
|
|
5838
7661
|
pulumi.set(self, "repo", value)
|
|
5839
7662
|
|
|
5840
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
|
+
|
|
5841
7693
|
@pulumi.input_type
|
|
5842
7694
|
class AppSpecWorkerImageArgs:
|
|
5843
7695
|
def __init__(__self__, *,
|
|
@@ -5939,6 +7791,15 @@ class AppSpecWorkerImageArgs:
|
|
|
5939
7791
|
pulumi.set(self, "tag", value)
|
|
5940
7792
|
|
|
5941
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
|
+
|
|
5942
7803
|
@pulumi.input_type
|
|
5943
7804
|
class AppSpecWorkerImageDeployOnPushArgs:
|
|
5944
7805
|
def __init__(__self__, *,
|
|
@@ -5962,6 +7823,31 @@ class AppSpecWorkerImageDeployOnPushArgs:
|
|
|
5962
7823
|
pulumi.set(self, "enabled", value)
|
|
5963
7824
|
|
|
5964
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
|
+
|
|
5965
7851
|
@pulumi.input_type
|
|
5966
7852
|
class AppSpecWorkerLogDestinationArgs:
|
|
5967
7853
|
def __init__(__self__, *,
|
|
@@ -6048,6 +7934,19 @@ class AppSpecWorkerLogDestinationArgs:
|
|
|
6048
7934
|
pulumi.set(self, "papertrail", value)
|
|
6049
7935
|
|
|
6050
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
|
+
|
|
6051
7950
|
@pulumi.input_type
|
|
6052
7951
|
class AppSpecWorkerLogDestinationDatadogArgs:
|
|
6053
7952
|
def __init__(__self__, *,
|
|
@@ -6086,6 +7985,15 @@ class AppSpecWorkerLogDestinationDatadogArgs:
|
|
|
6086
7985
|
pulumi.set(self, "endpoint", value)
|
|
6087
7986
|
|
|
6088
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
|
+
|
|
6089
7997
|
@pulumi.input_type
|
|
6090
7998
|
class AppSpecWorkerLogDestinationLogtailArgs:
|
|
6091
7999
|
def __init__(__self__, *,
|
|
@@ -6108,6 +8016,27 @@ class AppSpecWorkerLogDestinationLogtailArgs:
|
|
|
6108
8016
|
pulumi.set(self, "token", value)
|
|
6109
8017
|
|
|
6110
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
|
+
|
|
6111
8040
|
@pulumi.input_type
|
|
6112
8041
|
class AppSpecWorkerLogDestinationOpenSearchArgs:
|
|
6113
8042
|
def __init__(__self__, *,
|
|
@@ -6178,6 +8107,19 @@ class AppSpecWorkerLogDestinationOpenSearchArgs:
|
|
|
6178
8107
|
pulumi.set(self, "index_name", value)
|
|
6179
8108
|
|
|
6180
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
|
+
|
|
6181
8123
|
@pulumi.input_type
|
|
6182
8124
|
class AppSpecWorkerLogDestinationOpenSearchBasicAuthArgs:
|
|
6183
8125
|
def __init__(__self__, *,
|
|
@@ -6217,6 +8159,15 @@ class AppSpecWorkerLogDestinationOpenSearchBasicAuthArgs:
|
|
|
6217
8159
|
pulumi.set(self, "user", value)
|
|
6218
8160
|
|
|
6219
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
|
+
|
|
6220
8171
|
@pulumi.input_type
|
|
6221
8172
|
class AppSpecWorkerLogDestinationPapertrailArgs:
|
|
6222
8173
|
def __init__(__self__, *,
|
|
@@ -6239,6 +8190,21 @@ class AppSpecWorkerLogDestinationPapertrailArgs:
|
|
|
6239
8190
|
pulumi.set(self, "endpoint", value)
|
|
6240
8191
|
|
|
6241
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
|
+
|
|
6242
8208
|
@pulumi.input_type
|
|
6243
8209
|
class DatabaseClusterBackupRestoreArgs:
|
|
6244
8210
|
def __init__(__self__, *,
|
|
@@ -6281,6 +8247,19 @@ class DatabaseClusterBackupRestoreArgs:
|
|
|
6281
8247
|
pulumi.set(self, "backup_created_at", value)
|
|
6282
8248
|
|
|
6283
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
|
+
|
|
6284
8263
|
@pulumi.input_type
|
|
6285
8264
|
class DatabaseClusterMaintenanceWindowArgs:
|
|
6286
8265
|
def __init__(__self__, *,
|
|
@@ -6318,6 +8297,27 @@ class DatabaseClusterMaintenanceWindowArgs:
|
|
|
6318
8297
|
pulumi.set(self, "hour", value)
|
|
6319
8298
|
|
|
6320
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
|
+
|
|
6321
8321
|
@pulumi.input_type
|
|
6322
8322
|
class DatabaseFirewallRuleArgs:
|
|
6323
8323
|
def __init__(__self__, *,
|
|
@@ -6387,6 +8387,102 @@ class DatabaseFirewallRuleArgs:
|
|
|
6387
8387
|
pulumi.set(self, "uuid", value)
|
|
6388
8388
|
|
|
6389
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
|
+
|
|
6390
8486
|
@pulumi.input_type
|
|
6391
8487
|
class DatabaseKafkaTopicConfigArgs:
|
|
6392
8488
|
def __init__(__self__, *,
|
|
@@ -6762,6 +8858,20 @@ class DatabaseKafkaTopicConfigArgs:
|
|
|
6762
8858
|
pulumi.set(self, "segment_ms", value)
|
|
6763
8859
|
|
|
6764
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
|
+
|
|
6765
8875
|
@pulumi.input_type
|
|
6766
8876
|
class DatabasePostgresqlConfigPgbouncerArgs:
|
|
6767
8877
|
def __init__(__self__, *,
|
|
@@ -6875,6 +8985,12 @@ class DatabasePostgresqlConfigPgbouncerArgs:
|
|
|
6875
8985
|
pulumi.set(self, "server_reset_query_always", value)
|
|
6876
8986
|
|
|
6877
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
|
+
|
|
6878
8994
|
@pulumi.input_type
|
|
6879
8995
|
class DatabasePostgresqlConfigTimescaledbArgs:
|
|
6880
8996
|
def __init__(__self__, *,
|
|
@@ -6892,10 +9008,23 @@ class DatabasePostgresqlConfigTimescaledbArgs:
|
|
|
6892
9008
|
pulumi.set(self, "max_background_workers", value)
|
|
6893
9009
|
|
|
6894
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
|
+
|
|
6895
9023
|
@pulumi.input_type
|
|
6896
9024
|
class DatabaseUserSettingArgs:
|
|
6897
9025
|
def __init__(__self__, *,
|
|
6898
|
-
acls: Optional[pulumi.Input[Sequence[pulumi.Input['DatabaseUserSettingAclArgs']]]] = None
|
|
9026
|
+
acls: Optional[pulumi.Input[Sequence[pulumi.Input['DatabaseUserSettingAclArgs']]]] = None,
|
|
9027
|
+
opensearch_acls: Optional[pulumi.Input[Sequence[pulumi.Input['DatabaseUserSettingOpensearchAclArgs']]]] = None):
|
|
6899
9028
|
"""
|
|
6900
9029
|
:param pulumi.Input[Sequence[pulumi.Input['DatabaseUserSettingAclArgs']]] acls: A set of ACLs (Access Control Lists) specifying permission on topics with a Kafka cluster. The properties of an individual ACL are described below:
|
|
6901
9030
|
|
|
@@ -6903,6 +9032,8 @@ class DatabaseUserSettingArgs:
|
|
|
6903
9032
|
"""
|
|
6904
9033
|
if acls is not None:
|
|
6905
9034
|
pulumi.set(__self__, "acls", acls)
|
|
9035
|
+
if opensearch_acls is not None:
|
|
9036
|
+
pulumi.set(__self__, "opensearch_acls", opensearch_acls)
|
|
6906
9037
|
|
|
6907
9038
|
@property
|
|
6908
9039
|
@pulumi.getter
|
|
@@ -6918,6 +9049,32 @@ class DatabaseUserSettingArgs:
|
|
|
6918
9049
|
def acls(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['DatabaseUserSettingAclArgs']]]]):
|
|
6919
9050
|
pulumi.set(self, "acls", value)
|
|
6920
9051
|
|
|
9052
|
+
@property
|
|
9053
|
+
@pulumi.getter(name="opensearchAcls")
|
|
9054
|
+
def opensearch_acls(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['DatabaseUserSettingOpensearchAclArgs']]]]:
|
|
9055
|
+
return pulumi.get(self, "opensearch_acls")
|
|
9056
|
+
|
|
9057
|
+
@opensearch_acls.setter
|
|
9058
|
+
def opensearch_acls(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['DatabaseUserSettingOpensearchAclArgs']]]]):
|
|
9059
|
+
pulumi.set(self, "opensearch_acls", value)
|
|
9060
|
+
|
|
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]
|
|
6921
9078
|
|
|
6922
9079
|
@pulumi.input_type
|
|
6923
9080
|
class DatabaseUserSettingAclArgs:
|
|
@@ -6972,25 +9129,112 @@ class DatabaseUserSettingAclArgs:
|
|
|
6972
9129
|
pulumi.set(self, "id", value)
|
|
6973
9130
|
|
|
6974
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
|
+
|
|
6975
9142
|
@pulumi.input_type
|
|
6976
|
-
class
|
|
9143
|
+
class DatabaseUserSettingOpensearchAclArgs:
|
|
6977
9144
|
def __init__(__self__, *,
|
|
6978
|
-
|
|
6979
|
-
|
|
6980
|
-
source_addresses: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
6981
|
-
source_droplet_ids: Optional[pulumi.Input[Sequence[pulumi.Input[int]]]] = None,
|
|
6982
|
-
source_kubernetes_ids: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
6983
|
-
source_load_balancer_uids: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
6984
|
-
source_tags: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
|
|
9145
|
+
index: pulumi.Input[str],
|
|
9146
|
+
permission: pulumi.Input[str]):
|
|
6985
9147
|
"""
|
|
6986
|
-
:param pulumi.Input[str]
|
|
6987
|
-
|
|
6988
|
-
|
|
6989
|
-
|
|
6990
|
-
|
|
6991
|
-
|
|
6992
|
-
|
|
6993
|
-
|
|
9148
|
+
:param pulumi.Input[str] permission: 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.
|
|
9149
|
+
"""
|
|
9150
|
+
pulumi.set(__self__, "index", index)
|
|
9151
|
+
pulumi.set(__self__, "permission", permission)
|
|
9152
|
+
|
|
9153
|
+
@property
|
|
9154
|
+
@pulumi.getter
|
|
9155
|
+
def index(self) -> pulumi.Input[str]:
|
|
9156
|
+
return pulumi.get(self, "index")
|
|
9157
|
+
|
|
9158
|
+
@index.setter
|
|
9159
|
+
def index(self, value: pulumi.Input[str]):
|
|
9160
|
+
pulumi.set(self, "index", value)
|
|
9161
|
+
|
|
9162
|
+
@property
|
|
9163
|
+
@pulumi.getter
|
|
9164
|
+
def permission(self) -> pulumi.Input[str]:
|
|
9165
|
+
"""
|
|
9166
|
+
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.
|
|
9167
|
+
"""
|
|
9168
|
+
return pulumi.get(self, "permission")
|
|
9169
|
+
|
|
9170
|
+
@permission.setter
|
|
9171
|
+
def permission(self, value: pulumi.Input[str]):
|
|
9172
|
+
pulumi.set(self, "permission", value)
|
|
9173
|
+
|
|
9174
|
+
|
|
9175
|
+
if not MYPY:
|
|
9176
|
+
class FirewallInboundRuleArgsDict(TypedDict):
|
|
9177
|
+
protocol: pulumi.Input[str]
|
|
9178
|
+
"""
|
|
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
|
|
6994
9238
|
inbound traffic will be accepted.
|
|
6995
9239
|
:param pulumi.Input[Sequence[pulumi.Input[int]]] source_droplet_ids: An array containing the IDs of
|
|
6996
9240
|
the Droplets from which the inbound traffic will be accepted.
|
|
@@ -7112,6 +9356,50 @@ class FirewallInboundRuleArgs:
|
|
|
7112
9356
|
pulumi.set(self, "source_tags", value)
|
|
7113
9357
|
|
|
7114
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
|
+
|
|
7115
9403
|
@pulumi.input_type
|
|
7116
9404
|
class FirewallOutboundRuleArgs:
|
|
7117
9405
|
def __init__(__self__, *,
|
|
@@ -7252,6 +9540,18 @@ class FirewallOutboundRuleArgs:
|
|
|
7252
9540
|
pulumi.set(self, "port_range", value)
|
|
7253
9541
|
|
|
7254
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
|
+
|
|
7255
9555
|
@pulumi.input_type
|
|
7256
9556
|
class FirewallPendingChangeArgs:
|
|
7257
9557
|
def __init__(__self__, *,
|
|
@@ -7301,6 +9601,39 @@ class FirewallPendingChangeArgs:
|
|
|
7301
9601
|
pulumi.set(self, "status", value)
|
|
7302
9602
|
|
|
7303
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
|
+
|
|
7304
9637
|
@pulumi.input_type
|
|
7305
9638
|
class KubernetesClusterKubeConfigArgs:
|
|
7306
9639
|
def __init__(__self__, *,
|
|
@@ -7420,6 +9753,23 @@ class KubernetesClusterKubeConfigArgs:
|
|
|
7420
9753
|
pulumi.set(self, "token", value)
|
|
7421
9754
|
|
|
7422
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
|
+
|
|
7423
9773
|
@pulumi.input_type
|
|
7424
9774
|
class KubernetesClusterMaintenancePolicyArgs:
|
|
7425
9775
|
def __init__(__self__, *,
|
|
@@ -7475,6 +9825,59 @@ class KubernetesClusterMaintenancePolicyArgs:
|
|
|
7475
9825
|
pulumi.set(self, "start_time", value)
|
|
7476
9826
|
|
|
7477
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
|
+
|
|
7478
9881
|
@pulumi.input_type
|
|
7479
9882
|
class KubernetesClusterNodePoolArgs:
|
|
7480
9883
|
def __init__(__self__, *,
|
|
@@ -7672,6 +10075,35 @@ class KubernetesClusterNodePoolArgs:
|
|
|
7672
10075
|
pulumi.set(self, "taints", value)
|
|
7673
10076
|
|
|
7674
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
|
+
|
|
7675
10107
|
@pulumi.input_type
|
|
7676
10108
|
class KubernetesClusterNodePoolNodeArgs:
|
|
7677
10109
|
def __init__(__self__, *,
|
|
@@ -7775,6 +10207,23 @@ class KubernetesClusterNodePoolNodeArgs:
|
|
|
7775
10207
|
pulumi.set(self, "updated_at", value)
|
|
7776
10208
|
|
|
7777
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
|
+
|
|
7778
10227
|
@pulumi.input_type
|
|
7779
10228
|
class KubernetesClusterNodePoolTaintArgs:
|
|
7780
10229
|
def __init__(__self__, *,
|
|
@@ -7827,6 +10276,35 @@ class KubernetesClusterNodePoolTaintArgs:
|
|
|
7827
10276
|
pulumi.set(self, "value", value)
|
|
7828
10277
|
|
|
7829
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
|
+
|
|
7830
10308
|
@pulumi.input_type
|
|
7831
10309
|
class KubernetesNodePoolNodeArgs:
|
|
7832
10310
|
def __init__(__self__, *,
|
|
@@ -7930,6 +10408,23 @@ class KubernetesNodePoolNodeArgs:
|
|
|
7930
10408
|
pulumi.set(self, "updated_at", value)
|
|
7931
10409
|
|
|
7932
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
|
+
|
|
7933
10428
|
@pulumi.input_type
|
|
7934
10429
|
class KubernetesNodePoolTaintArgs:
|
|
7935
10430
|
def __init__(__self__, *,
|
|
@@ -7982,6 +10477,31 @@ class KubernetesNodePoolTaintArgs:
|
|
|
7982
10477
|
pulumi.set(self, "value", value)
|
|
7983
10478
|
|
|
7984
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
|
+
|
|
7985
10505
|
@pulumi.input_type
|
|
7986
10506
|
class LoadBalancerDomainArgs:
|
|
7987
10507
|
def __init__(__self__, *,
|
|
@@ -8068,6 +10588,20 @@ class LoadBalancerDomainArgs:
|
|
|
8068
10588
|
pulumi.set(self, "verification_error_reasons", value)
|
|
8069
10589
|
|
|
8070
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
|
+
|
|
8071
10605
|
@pulumi.input_type
|
|
8072
10606
|
class LoadBalancerFirewallArgs:
|
|
8073
10607
|
def __init__(__self__, *,
|
|
@@ -8109,6 +10643,39 @@ class LoadBalancerFirewallArgs:
|
|
|
8109
10643
|
pulumi.set(self, "denies", value)
|
|
8110
10644
|
|
|
8111
10645
|
|
|
10646
|
+
if not MYPY:
|
|
10647
|
+
class LoadBalancerForwardingRuleArgsDict(TypedDict):
|
|
10648
|
+
entry_port: pulumi.Input[int]
|
|
10649
|
+
"""
|
|
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
|
+
|
|
8112
10679
|
@pulumi.input_type
|
|
8113
10680
|
class LoadBalancerForwardingRuleArgs:
|
|
8114
10681
|
def __init__(__self__, *,
|
|
@@ -8219,14 +10786,39 @@ class LoadBalancerForwardingRuleArgs:
|
|
|
8219
10786
|
@pulumi.getter(name="tlsPassthrough")
|
|
8220
10787
|
def tls_passthrough(self) -> Optional[pulumi.Input[bool]]:
|
|
8221
10788
|
"""
|
|
8222
|
-
A boolean value indicating whether SSL encrypted traffic will be passed through to the backend Droplets. The default value is `false`.
|
|
10789
|
+
A boolean value indicating whether SSL encrypted traffic will be passed through to the backend Droplets. The default value is `false`.
|
|
10790
|
+
"""
|
|
10791
|
+
return pulumi.get(self, "tls_passthrough")
|
|
10792
|
+
|
|
10793
|
+
@tls_passthrough.setter
|
|
10794
|
+
def tls_passthrough(self, value: Optional[pulumi.Input[bool]]):
|
|
10795
|
+
pulumi.set(self, "tls_passthrough", value)
|
|
10796
|
+
|
|
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:
|
|
8223
10811
|
"""
|
|
8224
|
-
|
|
8225
|
-
|
|
8226
|
-
|
|
8227
|
-
|
|
8228
|
-
pulumi.
|
|
8229
|
-
|
|
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]
|
|
8230
10822
|
|
|
8231
10823
|
@pulumi.input_type
|
|
8232
10824
|
class LoadBalancerGlbSettingsArgs:
|
|
@@ -8313,6 +10905,15 @@ class LoadBalancerGlbSettingsArgs:
|
|
|
8313
10905
|
pulumi.set(self, "region_priorities", value)
|
|
8314
10906
|
|
|
8315
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
|
+
|
|
8316
10917
|
@pulumi.input_type
|
|
8317
10918
|
class LoadBalancerGlbSettingsCdnArgs:
|
|
8318
10919
|
def __init__(__self__, *,
|
|
@@ -8336,6 +10937,39 @@ class LoadBalancerGlbSettingsCdnArgs:
|
|
|
8336
10937
|
pulumi.set(self, "is_enabled", value)
|
|
8337
10938
|
|
|
8338
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
|
+
|
|
8339
10973
|
@pulumi.input_type
|
|
8340
10974
|
class LoadBalancerHealthcheckArgs:
|
|
8341
10975
|
def __init__(__self__, *,
|
|
@@ -8453,6 +11087,23 @@ class LoadBalancerHealthcheckArgs:
|
|
|
8453
11087
|
pulumi.set(self, "unhealthy_threshold", value)
|
|
8454
11088
|
|
|
8455
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
|
+
|
|
8456
11107
|
@pulumi.input_type
|
|
8457
11108
|
class LoadBalancerStickySessionsArgs:
|
|
8458
11109
|
def __init__(__self__, *,
|
|
@@ -8508,6 +11159,16 @@ class LoadBalancerStickySessionsArgs:
|
|
|
8508
11159
|
pulumi.set(self, "type", value)
|
|
8509
11160
|
|
|
8510
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
|
+
|
|
8511
11172
|
@pulumi.input_type
|
|
8512
11173
|
class MonitorAlertAlertsArgs:
|
|
8513
11174
|
def __init__(__self__, *,
|
|
@@ -8543,6 +11204,19 @@ class MonitorAlertAlertsArgs:
|
|
|
8543
11204
|
pulumi.set(self, "slacks", value)
|
|
8544
11205
|
|
|
8545
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
|
+
|
|
8546
11220
|
@pulumi.input_type
|
|
8547
11221
|
class MonitorAlertAlertsSlackArgs:
|
|
8548
11222
|
def __init__(__self__, *,
|
|
@@ -8580,6 +11254,35 @@ class MonitorAlertAlertsSlackArgs:
|
|
|
8580
11254
|
pulumi.set(self, "url", value)
|
|
8581
11255
|
|
|
8582
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
|
+
|
|
8583
11286
|
@pulumi.input_type
|
|
8584
11287
|
class SpacesBucketCorsConfigurationCorsRuleArgs:
|
|
8585
11288
|
def __init__(__self__, *,
|
|
@@ -8681,6 +11384,27 @@ class SpacesBucketCorsConfigurationCorsRuleArgs:
|
|
|
8681
11384
|
pulumi.set(self, "max_age_seconds", value)
|
|
8682
11385
|
|
|
8683
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
|
+
|
|
8684
11408
|
@pulumi.input_type
|
|
8685
11409
|
class SpacesBucketCorsRuleArgs:
|
|
8686
11410
|
def __init__(__self__, *,
|
|
@@ -8750,6 +11474,38 @@ class SpacesBucketCorsRuleArgs:
|
|
|
8750
11474
|
pulumi.set(self, "max_age_seconds", value)
|
|
8751
11475
|
|
|
8752
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
|
+
|
|
8753
11509
|
@pulumi.input_type
|
|
8754
11510
|
class SpacesBucketLifecycleRuleArgs:
|
|
8755
11511
|
def __init__(__self__, *,
|
|
@@ -8858,6 +11614,25 @@ class SpacesBucketLifecycleRuleArgs:
|
|
|
8858
11614
|
pulumi.set(self, "prefix", value)
|
|
8859
11615
|
|
|
8860
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
|
+
|
|
8861
11636
|
@pulumi.input_type
|
|
8862
11637
|
class SpacesBucketLifecycleRuleExpirationArgs:
|
|
8863
11638
|
def __init__(__self__, *,
|
|
@@ -8917,6 +11692,15 @@ class SpacesBucketLifecycleRuleExpirationArgs:
|
|
|
8917
11692
|
pulumi.set(self, "expired_object_delete_marker", value)
|
|
8918
11693
|
|
|
8919
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
|
+
|
|
8920
11704
|
@pulumi.input_type
|
|
8921
11705
|
class SpacesBucketLifecycleRuleNoncurrentVersionExpirationArgs:
|
|
8922
11706
|
def __init__(__self__, *,
|
|
@@ -8940,6 +11724,16 @@ class SpacesBucketLifecycleRuleNoncurrentVersionExpirationArgs:
|
|
|
8940
11724
|
pulumi.set(self, "days", value)
|
|
8941
11725
|
|
|
8942
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
|
+
|
|
8943
11737
|
@pulumi.input_type
|
|
8944
11738
|
class SpacesBucketVersioningArgs:
|
|
8945
11739
|
def __init__(__self__, *,
|
|
@@ -8965,6 +11759,16 @@ class SpacesBucketVersioningArgs:
|
|
|
8965
11759
|
pulumi.set(self, "enabled", value)
|
|
8966
11760
|
|
|
8967
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
|
+
|
|
8968
11772
|
@pulumi.input_type
|
|
8969
11773
|
class UptimeAlertNotificationArgs:
|
|
8970
11774
|
def __init__(__self__, *,
|
|
@@ -9000,6 +11804,19 @@ class UptimeAlertNotificationArgs:
|
|
|
9000
11804
|
pulumi.set(self, "slacks", value)
|
|
9001
11805
|
|
|
9002
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
|
+
|
|
9003
11820
|
@pulumi.input_type
|
|
9004
11821
|
class UptimeAlertNotificationSlackArgs:
|
|
9005
11822
|
def __init__(__self__, *,
|
|
@@ -9037,6 +11854,23 @@ class UptimeAlertNotificationSlackArgs:
|
|
|
9037
11854
|
pulumi.set(self, "url", value)
|
|
9038
11855
|
|
|
9039
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
|
+
|
|
9040
11874
|
@pulumi.input_type
|
|
9041
11875
|
class GetAppDedicatedIpArgs:
|
|
9042
11876
|
def __init__(__self__, *,
|
|
@@ -9089,6 +11923,32 @@ class GetAppDedicatedIpArgs:
|
|
|
9089
11923
|
pulumi.set(self, "status", value)
|
|
9090
11924
|
|
|
9091
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
|
+
|
|
9092
11952
|
@pulumi.input_type
|
|
9093
11953
|
class GetDomainsFilterArgs:
|
|
9094
11954
|
def __init__(__self__, *,
|
|
@@ -9168,6 +12028,19 @@ class GetDomainsFilterArgs:
|
|
|
9168
12028
|
pulumi.set(self, "match_by", value)
|
|
9169
12029
|
|
|
9170
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
|
+
|
|
9171
12044
|
@pulumi.input_type
|
|
9172
12045
|
class GetDomainsSortArgs:
|
|
9173
12046
|
def __init__(__self__, *,
|
|
@@ -9206,6 +12079,35 @@ class GetDomainsSortArgs:
|
|
|
9206
12079
|
pulumi.set(self, "direction", value)
|
|
9207
12080
|
|
|
9208
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
|
+
|
|
9209
12111
|
@pulumi.input_type
|
|
9210
12112
|
class GetDropletsFilterArgs:
|
|
9211
12113
|
def __init__(__self__, *,
|
|
@@ -9291,6 +12193,22 @@ class GetDropletsFilterArgs:
|
|
|
9291
12193
|
pulumi.set(self, "match_by", value)
|
|
9292
12194
|
|
|
9293
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
|
+
|
|
9294
12212
|
@pulumi.input_type
|
|
9295
12213
|
class GetDropletsSortArgs:
|
|
9296
12214
|
def __init__(__self__, *,
|
|
@@ -9311,29 +12229,68 @@ class GetDropletsSortArgs:
|
|
|
9311
12229
|
@pulumi.getter
|
|
9312
12230
|
def key(self) -> str:
|
|
9313
12231
|
"""
|
|
9314
|
-
Sort the Droplets by this key. This may be one of `backups`, `created_at`, `disk`, `id`,
|
|
9315
|
-
`image`, `ipv4_address`, `ipv4_address_private`, `ipv6`, `ipv6_address`, `ipv6_address_private`, `locked`,
|
|
9316
|
-
`memory`, `monitoring`, `name`, `price_hourly`, `price_monthly`, `private_networking`, `region`, `size`,
|
|
9317
|
-
`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]]
|
|
9318
12283
|
"""
|
|
9319
|
-
|
|
9320
|
-
|
|
9321
|
-
@key.setter
|
|
9322
|
-
def key(self, value: str):
|
|
9323
|
-
pulumi.set(self, "key", value)
|
|
9324
|
-
|
|
9325
|
-
@property
|
|
9326
|
-
@pulumi.getter
|
|
9327
|
-
def direction(self) -> Optional[str]:
|
|
12284
|
+
An array containing the IDs
|
|
12285
|
+
of the Load Balancers from which the inbound traffic will be accepted.
|
|
9328
12286
|
"""
|
|
9329
|
-
|
|
12287
|
+
source_tags: NotRequired[Sequence[str]]
|
|
9330
12288
|
"""
|
|
9331
|
-
|
|
9332
|
-
|
|
9333
|
-
|
|
9334
|
-
|
|
9335
|
-
|
|
9336
|
-
|
|
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]
|
|
9337
12294
|
|
|
9338
12295
|
@pulumi.input_type
|
|
9339
12296
|
class GetFirewallInboundRuleArgs:
|
|
@@ -9467,6 +12424,47 @@ class GetFirewallInboundRuleArgs:
|
|
|
9467
12424
|
pulumi.set(self, "source_tags", value)
|
|
9468
12425
|
|
|
9469
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
|
+
|
|
9470
12468
|
@pulumi.input_type
|
|
9471
12469
|
class GetFirewallOutboundRuleArgs:
|
|
9472
12470
|
def __init__(__self__, *,
|
|
@@ -9603,6 +12601,34 @@ class GetFirewallOutboundRuleArgs:
|
|
|
9603
12601
|
pulumi.set(self, "port_range", value)
|
|
9604
12602
|
|
|
9605
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
|
+
|
|
9606
12632
|
@pulumi.input_type
|
|
9607
12633
|
class GetImagesFilterArgs:
|
|
9608
12634
|
def __init__(__self__, *,
|
|
@@ -9686,6 +12712,20 @@ class GetImagesFilterArgs:
|
|
|
9686
12712
|
pulumi.set(self, "match_by", value)
|
|
9687
12713
|
|
|
9688
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
|
+
|
|
9689
12729
|
@pulumi.input_type
|
|
9690
12730
|
class GetImagesSortArgs:
|
|
9691
12731
|
def __init__(__self__, *,
|
|
@@ -9726,6 +12766,33 @@ class GetImagesSortArgs:
|
|
|
9726
12766
|
pulumi.set(self, "direction", value)
|
|
9727
12767
|
|
|
9728
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
|
+
|
|
9729
12796
|
@pulumi.input_type
|
|
9730
12797
|
class GetProjectsFilterArgs:
|
|
9731
12798
|
def __init__(__self__, *,
|
|
@@ -9807,6 +12874,20 @@ class GetProjectsFilterArgs:
|
|
|
9807
12874
|
pulumi.set(self, "match_by", value)
|
|
9808
12875
|
|
|
9809
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
|
+
|
|
9810
12891
|
@pulumi.input_type
|
|
9811
12892
|
class GetProjectsSortArgs:
|
|
9812
12893
|
def __init__(__self__, *,
|
|
@@ -9847,6 +12928,33 @@ class GetProjectsSortArgs:
|
|
|
9847
12928
|
pulumi.set(self, "direction", value)
|
|
9848
12929
|
|
|
9849
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
|
+
|
|
9850
12958
|
@pulumi.input_type
|
|
9851
12959
|
class GetRecordsFilterArgs:
|
|
9852
12960
|
def __init__(__self__, *,
|
|
@@ -9928,6 +13036,20 @@ class GetRecordsFilterArgs:
|
|
|
9928
13036
|
pulumi.set(self, "match_by", value)
|
|
9929
13037
|
|
|
9930
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
|
+
|
|
9931
13053
|
@pulumi.input_type
|
|
9932
13054
|
class GetRecordsSortArgs:
|
|
9933
13055
|
def __init__(__self__, *,
|
|
@@ -9968,6 +13090,33 @@ class GetRecordsSortArgs:
|
|
|
9968
13090
|
pulumi.set(self, "direction", value)
|
|
9969
13091
|
|
|
9970
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
|
+
|
|
9971
13120
|
@pulumi.input_type
|
|
9972
13121
|
class GetRegionsFilterArgs:
|
|
9973
13122
|
def __init__(__self__, *,
|
|
@@ -10049,6 +13198,20 @@ class GetRegionsFilterArgs:
|
|
|
10049
13198
|
pulumi.set(self, "match_by", value)
|
|
10050
13199
|
|
|
10051
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
|
+
|
|
10052
13215
|
@pulumi.input_type
|
|
10053
13216
|
class GetRegionsSortArgs:
|
|
10054
13217
|
def __init__(__self__, *,
|
|
@@ -10089,6 +13252,34 @@ class GetRegionsSortArgs:
|
|
|
10089
13252
|
pulumi.set(self, "direction", value)
|
|
10090
13253
|
|
|
10091
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
|
+
|
|
10092
13283
|
@pulumi.input_type
|
|
10093
13284
|
class GetSizesFilterArgs:
|
|
10094
13285
|
def __init__(__self__, *,
|
|
@@ -10172,6 +13363,20 @@ class GetSizesFilterArgs:
|
|
|
10172
13363
|
pulumi.set(self, "match_by", value)
|
|
10173
13364
|
|
|
10174
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
|
+
|
|
10175
13380
|
@pulumi.input_type
|
|
10176
13381
|
class GetSizesSortArgs:
|
|
10177
13382
|
def __init__(__self__, *,
|
|
@@ -10212,6 +13417,32 @@ class GetSizesSortArgs:
|
|
|
10212
13417
|
pulumi.set(self, "direction", value)
|
|
10213
13418
|
|
|
10214
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
|
+
|
|
10215
13446
|
@pulumi.input_type
|
|
10216
13447
|
class GetSpacesBucketsFilterArgs:
|
|
10217
13448
|
def __init__(__self__, *,
|
|
@@ -10291,6 +13522,19 @@ class GetSpacesBucketsFilterArgs:
|
|
|
10291
13522
|
pulumi.set(self, "match_by", value)
|
|
10292
13523
|
|
|
10293
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
|
+
|
|
10294
13538
|
@pulumi.input_type
|
|
10295
13539
|
class GetSpacesBucketsSortArgs:
|
|
10296
13540
|
def __init__(__self__, *,
|
|
@@ -10329,6 +13573,21 @@ class GetSpacesBucketsSortArgs:
|
|
|
10329
13573
|
pulumi.set(self, "direction", value)
|
|
10330
13574
|
|
|
10331
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
|
+
|
|
10332
13591
|
@pulumi.input_type
|
|
10333
13592
|
class GetSshKeysFilterArgs:
|
|
10334
13593
|
def __init__(__self__, *,
|
|
@@ -10390,6 +13649,19 @@ class GetSshKeysFilterArgs:
|
|
|
10390
13649
|
pulumi.set(self, "match_by", value)
|
|
10391
13650
|
|
|
10392
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
|
+
|
|
10393
13665
|
@pulumi.input_type
|
|
10394
13666
|
class GetSshKeysSortArgs:
|
|
10395
13667
|
def __init__(__self__, *,
|
|
@@ -10428,6 +13700,32 @@ class GetSshKeysSortArgs:
|
|
|
10428
13700
|
pulumi.set(self, "direction", value)
|
|
10429
13701
|
|
|
10430
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
|
+
|
|
10431
13729
|
@pulumi.input_type
|
|
10432
13730
|
class GetTagsFilterArgs:
|
|
10433
13731
|
def __init__(__self__, *,
|
|
@@ -10507,6 +13805,19 @@ class GetTagsFilterArgs:
|
|
|
10507
13805
|
pulumi.set(self, "match_by", value)
|
|
10508
13806
|
|
|
10509
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
|
+
|
|
10510
13821
|
@pulumi.input_type
|
|
10511
13822
|
class GetTagsSortArgs:
|
|
10512
13823
|
def __init__(__self__, *,
|