pulumi-consul 3.12.0a1709360320__py3-none-any.whl → 3.13.0a1736832526__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-consul might be problematic. Click here for more details.
- pulumi_consul/__init__.py +10 -0
- pulumi_consul/_inputs.py +1592 -31
- pulumi_consul/_utilities.py +41 -5
- pulumi_consul/acl_auth_method.py +17 -14
- pulumi_consul/acl_binding_rule.py +12 -5
- pulumi_consul/acl_policy.py +9 -4
- pulumi_consul/acl_role.py +39 -30
- pulumi_consul/acl_role_policy_attachment.py +15 -8
- pulumi_consul/acl_token.py +36 -27
- pulumi_consul/acl_token_policy_attachment.py +7 -2
- pulumi_consul/acl_token_role_attachment.py +11 -4
- pulumi_consul/admin_partition.py +13 -4
- pulumi_consul/agent_service.py +7 -0
- pulumi_consul/autopilot_config.py +5 -0
- pulumi_consul/catalog_entry.py +16 -62
- pulumi_consul/certificate_authority.py +10 -51
- pulumi_consul/config/__init__.pyi +5 -0
- pulumi_consul/config/outputs.py +5 -0
- pulumi_consul/config/vars.py +5 -0
- pulumi_consul/config_entry.py +75 -26
- pulumi_consul/config_entry_service_defaults.py +58 -51
- pulumi_consul/config_entry_service_intentions.py +80 -71
- pulumi_consul/config_entry_service_resolver.py +94 -87
- pulumi_consul/config_entry_service_router.py +31 -62
- pulumi_consul/config_entry_service_splitter.py +104 -93
- pulumi_consul/config_entry_v2_exported_services.py +479 -0
- pulumi_consul/get_acl_auth_method.py +26 -8
- pulumi_consul/get_acl_policy.py +20 -5
- pulumi_consul/get_acl_role.py +24 -5
- pulumi_consul/get_acl_token.py +25 -5
- pulumi_consul/get_acl_token_secret_id.py +29 -11
- pulumi_consul/get_agent_config.py +17 -5
- pulumi_consul/get_agent_self.py +82 -5
- pulumi_consul/get_autopilot_health.py +16 -5
- pulumi_consul/get_catalog_nodes.py +21 -9
- pulumi_consul/get_catalog_service.py +56 -13
- pulumi_consul/get_catalog_services.py +53 -9
- pulumi_consul/get_config_entry.py +20 -5
- pulumi_consul/get_config_entry_v2_exported_services.py +232 -0
- pulumi_consul/get_datacenters.py +12 -5
- pulumi_consul/get_key_prefix.py +55 -38
- pulumi_consul/get_keys.py +44 -30
- pulumi_consul/get_network_area_members.py +26 -16
- pulumi_consul/get_network_segments.py +22 -14
- pulumi_consul/get_nodes.py +21 -9
- pulumi_consul/get_peering.py +22 -5
- pulumi_consul/get_peerings.py +14 -5
- pulumi_consul/get_service.py +56 -13
- pulumi_consul/get_service_health.py +28 -5
- pulumi_consul/get_services.py +53 -9
- pulumi_consul/intention.py +17 -12
- pulumi_consul/key_prefix.py +48 -50
- pulumi_consul/keys.py +26 -30
- pulumi_consul/license.py +9 -2
- pulumi_consul/namespace.py +13 -4
- pulumi_consul/namespace_policy_attachment.py +11 -4
- pulumi_consul/namespace_role_attachment.py +11 -4
- pulumi_consul/network_area.py +11 -15
- pulumi_consul/node.py +19 -19
- pulumi_consul/outputs.py +30 -27
- pulumi_consul/peering.py +13 -18
- pulumi_consul/peering_token.py +55 -11
- pulumi_consul/prepared_query.py +101 -101
- pulumi_consul/provider.py +11 -6
- pulumi_consul/pulumi-plugin.json +2 -1
- pulumi_consul/service.py +144 -19
- {pulumi_consul-3.12.0a1709360320.dist-info → pulumi_consul-3.13.0a1736832526.dist-info}/METADATA +7 -6
- pulumi_consul-3.13.0a1736832526.dist-info/RECORD +72 -0
- {pulumi_consul-3.12.0a1709360320.dist-info → pulumi_consul-3.13.0a1736832526.dist-info}/WHEEL +1 -1
- pulumi_consul-3.12.0a1709360320.dist-info/RECORD +0 -70
- {pulumi_consul-3.12.0a1709360320.dist-info → pulumi_consul-3.13.0a1736832526.dist-info}/top_level.txt +0 -0
pulumi_consul/_inputs.py
CHANGED
|
@@ -4,85 +4,176 @@
|
|
|
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
|
|
|
12
17
|
__all__ = [
|
|
13
18
|
'AclAuthMethodNamespaceRuleArgs',
|
|
19
|
+
'AclAuthMethodNamespaceRuleArgsDict',
|
|
14
20
|
'AclBindingRuleBindVarsArgs',
|
|
21
|
+
'AclBindingRuleBindVarsArgsDict',
|
|
15
22
|
'AclRoleNodeIdentityArgs',
|
|
23
|
+
'AclRoleNodeIdentityArgsDict',
|
|
16
24
|
'AclRoleServiceIdentityArgs',
|
|
25
|
+
'AclRoleServiceIdentityArgsDict',
|
|
17
26
|
'AclRoleTemplatedPolicyArgs',
|
|
27
|
+
'AclRoleTemplatedPolicyArgsDict',
|
|
18
28
|
'AclRoleTemplatedPolicyTemplateVariablesArgs',
|
|
29
|
+
'AclRoleTemplatedPolicyTemplateVariablesArgsDict',
|
|
19
30
|
'AclTokenNodeIdentityArgs',
|
|
31
|
+
'AclTokenNodeIdentityArgsDict',
|
|
20
32
|
'AclTokenServiceIdentityArgs',
|
|
33
|
+
'AclTokenServiceIdentityArgsDict',
|
|
21
34
|
'AclTokenTemplatedPolicyArgs',
|
|
35
|
+
'AclTokenTemplatedPolicyArgsDict',
|
|
22
36
|
'AclTokenTemplatedPolicyTemplateVariablesArgs',
|
|
37
|
+
'AclTokenTemplatedPolicyTemplateVariablesArgsDict',
|
|
23
38
|
'CatalogEntryServiceArgs',
|
|
39
|
+
'CatalogEntryServiceArgsDict',
|
|
24
40
|
'ConfigEntryServiceDefaultsDestinationArgs',
|
|
41
|
+
'ConfigEntryServiceDefaultsDestinationArgsDict',
|
|
25
42
|
'ConfigEntryServiceDefaultsEnvoyExtensionArgs',
|
|
43
|
+
'ConfigEntryServiceDefaultsEnvoyExtensionArgsDict',
|
|
26
44
|
'ConfigEntryServiceDefaultsExposeArgs',
|
|
45
|
+
'ConfigEntryServiceDefaultsExposeArgsDict',
|
|
27
46
|
'ConfigEntryServiceDefaultsExposePathArgs',
|
|
47
|
+
'ConfigEntryServiceDefaultsExposePathArgsDict',
|
|
28
48
|
'ConfigEntryServiceDefaultsMeshGatewayArgs',
|
|
49
|
+
'ConfigEntryServiceDefaultsMeshGatewayArgsDict',
|
|
29
50
|
'ConfigEntryServiceDefaultsTransparentProxyArgs',
|
|
51
|
+
'ConfigEntryServiceDefaultsTransparentProxyArgsDict',
|
|
30
52
|
'ConfigEntryServiceDefaultsUpstreamConfigArgs',
|
|
53
|
+
'ConfigEntryServiceDefaultsUpstreamConfigArgsDict',
|
|
31
54
|
'ConfigEntryServiceDefaultsUpstreamConfigDefaultArgs',
|
|
55
|
+
'ConfigEntryServiceDefaultsUpstreamConfigDefaultArgsDict',
|
|
32
56
|
'ConfigEntryServiceDefaultsUpstreamConfigDefaultLimitArgs',
|
|
57
|
+
'ConfigEntryServiceDefaultsUpstreamConfigDefaultLimitArgsDict',
|
|
33
58
|
'ConfigEntryServiceDefaultsUpstreamConfigDefaultMeshGatewayArgs',
|
|
59
|
+
'ConfigEntryServiceDefaultsUpstreamConfigDefaultMeshGatewayArgsDict',
|
|
34
60
|
'ConfigEntryServiceDefaultsUpstreamConfigDefaultPassiveHealthCheckArgs',
|
|
61
|
+
'ConfigEntryServiceDefaultsUpstreamConfigDefaultPassiveHealthCheckArgsDict',
|
|
35
62
|
'ConfigEntryServiceDefaultsUpstreamConfigOverrideArgs',
|
|
63
|
+
'ConfigEntryServiceDefaultsUpstreamConfigOverrideArgsDict',
|
|
36
64
|
'ConfigEntryServiceDefaultsUpstreamConfigOverrideLimitArgs',
|
|
65
|
+
'ConfigEntryServiceDefaultsUpstreamConfigOverrideLimitArgsDict',
|
|
37
66
|
'ConfigEntryServiceDefaultsUpstreamConfigOverrideMeshGatewayArgs',
|
|
67
|
+
'ConfigEntryServiceDefaultsUpstreamConfigOverrideMeshGatewayArgsDict',
|
|
38
68
|
'ConfigEntryServiceDefaultsUpstreamConfigOverridePassiveHealthCheckArgs',
|
|
69
|
+
'ConfigEntryServiceDefaultsUpstreamConfigOverridePassiveHealthCheckArgsDict',
|
|
39
70
|
'ConfigEntryServiceIntentionsJwtArgs',
|
|
71
|
+
'ConfigEntryServiceIntentionsJwtArgsDict',
|
|
40
72
|
'ConfigEntryServiceIntentionsJwtProviderArgs',
|
|
73
|
+
'ConfigEntryServiceIntentionsJwtProviderArgsDict',
|
|
41
74
|
'ConfigEntryServiceIntentionsJwtProviderVerifyClaimArgs',
|
|
75
|
+
'ConfigEntryServiceIntentionsJwtProviderVerifyClaimArgsDict',
|
|
42
76
|
'ConfigEntryServiceIntentionsSourceArgs',
|
|
77
|
+
'ConfigEntryServiceIntentionsSourceArgsDict',
|
|
43
78
|
'ConfigEntryServiceIntentionsSourcePermissionArgs',
|
|
79
|
+
'ConfigEntryServiceIntentionsSourcePermissionArgsDict',
|
|
44
80
|
'ConfigEntryServiceIntentionsSourcePermissionHttpArgs',
|
|
81
|
+
'ConfigEntryServiceIntentionsSourcePermissionHttpArgsDict',
|
|
45
82
|
'ConfigEntryServiceIntentionsSourcePermissionHttpHeaderArgs',
|
|
83
|
+
'ConfigEntryServiceIntentionsSourcePermissionHttpHeaderArgsDict',
|
|
46
84
|
'ConfigEntryServiceResolverFailoverArgs',
|
|
85
|
+
'ConfigEntryServiceResolverFailoverArgsDict',
|
|
47
86
|
'ConfigEntryServiceResolverFailoverTargetArgs',
|
|
87
|
+
'ConfigEntryServiceResolverFailoverTargetArgsDict',
|
|
48
88
|
'ConfigEntryServiceResolverLoadBalancerArgs',
|
|
89
|
+
'ConfigEntryServiceResolverLoadBalancerArgsDict',
|
|
49
90
|
'ConfigEntryServiceResolverLoadBalancerHashPolicyArgs',
|
|
91
|
+
'ConfigEntryServiceResolverLoadBalancerHashPolicyArgsDict',
|
|
50
92
|
'ConfigEntryServiceResolverLoadBalancerHashPolicyCookieConfigArgs',
|
|
93
|
+
'ConfigEntryServiceResolverLoadBalancerHashPolicyCookieConfigArgsDict',
|
|
51
94
|
'ConfigEntryServiceResolverLoadBalancerLeastRequestConfigArgs',
|
|
95
|
+
'ConfigEntryServiceResolverLoadBalancerLeastRequestConfigArgsDict',
|
|
52
96
|
'ConfigEntryServiceResolverLoadBalancerRingHashConfigArgs',
|
|
97
|
+
'ConfigEntryServiceResolverLoadBalancerRingHashConfigArgsDict',
|
|
53
98
|
'ConfigEntryServiceResolverRedirectArgs',
|
|
99
|
+
'ConfigEntryServiceResolverRedirectArgsDict',
|
|
54
100
|
'ConfigEntryServiceResolverSubsetArgs',
|
|
101
|
+
'ConfigEntryServiceResolverSubsetArgsDict',
|
|
55
102
|
'ConfigEntryServiceRouterRouteArgs',
|
|
103
|
+
'ConfigEntryServiceRouterRouteArgsDict',
|
|
56
104
|
'ConfigEntryServiceRouterRouteDestinationArgs',
|
|
105
|
+
'ConfigEntryServiceRouterRouteDestinationArgsDict',
|
|
57
106
|
'ConfigEntryServiceRouterRouteDestinationRequestHeadersArgs',
|
|
107
|
+
'ConfigEntryServiceRouterRouteDestinationRequestHeadersArgsDict',
|
|
58
108
|
'ConfigEntryServiceRouterRouteDestinationResponseHeadersArgs',
|
|
109
|
+
'ConfigEntryServiceRouterRouteDestinationResponseHeadersArgsDict',
|
|
59
110
|
'ConfigEntryServiceRouterRouteMatchArgs',
|
|
111
|
+
'ConfigEntryServiceRouterRouteMatchArgsDict',
|
|
60
112
|
'ConfigEntryServiceRouterRouteMatchHttpArgs',
|
|
113
|
+
'ConfigEntryServiceRouterRouteMatchHttpArgsDict',
|
|
61
114
|
'ConfigEntryServiceRouterRouteMatchHttpHeaderArgs',
|
|
115
|
+
'ConfigEntryServiceRouterRouteMatchHttpHeaderArgsDict',
|
|
62
116
|
'ConfigEntryServiceRouterRouteMatchHttpQueryParamArgs',
|
|
117
|
+
'ConfigEntryServiceRouterRouteMatchHttpQueryParamArgsDict',
|
|
63
118
|
'ConfigEntryServiceSplitterSplitArgs',
|
|
119
|
+
'ConfigEntryServiceSplitterSplitArgsDict',
|
|
64
120
|
'ConfigEntryServiceSplitterSplitRequestHeadersArgs',
|
|
121
|
+
'ConfigEntryServiceSplitterSplitRequestHeadersArgsDict',
|
|
65
122
|
'ConfigEntryServiceSplitterSplitResponseHeadersArgs',
|
|
123
|
+
'ConfigEntryServiceSplitterSplitResponseHeadersArgsDict',
|
|
66
124
|
'KeyPrefixSubkeyCollectionArgs',
|
|
125
|
+
'KeyPrefixSubkeyCollectionArgsDict',
|
|
67
126
|
'KeysKeyArgs',
|
|
127
|
+
'KeysKeyArgsDict',
|
|
68
128
|
'PreparedQueryDnsArgs',
|
|
129
|
+
'PreparedQueryDnsArgsDict',
|
|
69
130
|
'PreparedQueryFailoverArgs',
|
|
131
|
+
'PreparedQueryFailoverArgsDict',
|
|
70
132
|
'PreparedQueryFailoverTargetArgs',
|
|
133
|
+
'PreparedQueryFailoverTargetArgsDict',
|
|
71
134
|
'PreparedQueryTemplateArgs',
|
|
135
|
+
'PreparedQueryTemplateArgsDict',
|
|
72
136
|
'ProviderAuthJwtArgs',
|
|
137
|
+
'ProviderAuthJwtArgsDict',
|
|
73
138
|
'ProviderHeaderArgs',
|
|
139
|
+
'ProviderHeaderArgsDict',
|
|
74
140
|
'ServiceCheckArgs',
|
|
141
|
+
'ServiceCheckArgsDict',
|
|
75
142
|
'ServiceCheckHeaderArgs',
|
|
143
|
+
'ServiceCheckHeaderArgsDict',
|
|
76
144
|
'GetCatalogNodesQueryOptionArgs',
|
|
145
|
+
'GetCatalogNodesQueryOptionArgsDict',
|
|
77
146
|
'GetCatalogServiceQueryOptionArgs',
|
|
147
|
+
'GetCatalogServiceQueryOptionArgsDict',
|
|
78
148
|
'GetCatalogServicesQueryOptionArgs',
|
|
149
|
+
'GetCatalogServicesQueryOptionArgsDict',
|
|
79
150
|
'GetKeyPrefixSubkeyCollectionArgs',
|
|
151
|
+
'GetKeyPrefixSubkeyCollectionArgsDict',
|
|
80
152
|
'GetKeysKeyArgs',
|
|
153
|
+
'GetKeysKeyArgsDict',
|
|
81
154
|
'GetNodesQueryOptionArgs',
|
|
155
|
+
'GetNodesQueryOptionArgsDict',
|
|
82
156
|
'GetServiceQueryOptionArgs',
|
|
157
|
+
'GetServiceQueryOptionArgsDict',
|
|
83
158
|
'GetServicesQueryOptionArgs',
|
|
159
|
+
'GetServicesQueryOptionArgsDict',
|
|
84
160
|
]
|
|
85
161
|
|
|
162
|
+
MYPY = False
|
|
163
|
+
|
|
164
|
+
if not MYPY:
|
|
165
|
+
class AclAuthMethodNamespaceRuleArgsDict(TypedDict):
|
|
166
|
+
bind_namespace: pulumi.Input[str]
|
|
167
|
+
"""
|
|
168
|
+
If the namespace rule's `selector` matches then this is used to control the namespace where the token is created.
|
|
169
|
+
"""
|
|
170
|
+
selector: NotRequired[pulumi.Input[str]]
|
|
171
|
+
"""
|
|
172
|
+
Specifies the expression used to match this namespace rule against valid identities returned from an auth method validation.
|
|
173
|
+
"""
|
|
174
|
+
elif False:
|
|
175
|
+
AclAuthMethodNamespaceRuleArgsDict: TypeAlias = Mapping[str, Any]
|
|
176
|
+
|
|
86
177
|
@pulumi.input_type
|
|
87
178
|
class AclAuthMethodNamespaceRuleArgs:
|
|
88
179
|
def __init__(__self__, *,
|
|
@@ -121,6 +212,15 @@ class AclAuthMethodNamespaceRuleArgs:
|
|
|
121
212
|
pulumi.set(self, "selector", value)
|
|
122
213
|
|
|
123
214
|
|
|
215
|
+
if not MYPY:
|
|
216
|
+
class AclBindingRuleBindVarsArgsDict(TypedDict):
|
|
217
|
+
name: NotRequired[pulumi.Input[str]]
|
|
218
|
+
"""
|
|
219
|
+
The name of node, workload identity or service.
|
|
220
|
+
"""
|
|
221
|
+
elif False:
|
|
222
|
+
AclBindingRuleBindVarsArgsDict: TypeAlias = Mapping[str, Any]
|
|
223
|
+
|
|
124
224
|
@pulumi.input_type
|
|
125
225
|
class AclBindingRuleBindVarsArgs:
|
|
126
226
|
def __init__(__self__, *,
|
|
@@ -144,6 +244,19 @@ class AclBindingRuleBindVarsArgs:
|
|
|
144
244
|
pulumi.set(self, "name", value)
|
|
145
245
|
|
|
146
246
|
|
|
247
|
+
if not MYPY:
|
|
248
|
+
class AclRoleNodeIdentityArgsDict(TypedDict):
|
|
249
|
+
datacenter: pulumi.Input[str]
|
|
250
|
+
"""
|
|
251
|
+
Specifies the node's datacenter.
|
|
252
|
+
"""
|
|
253
|
+
node_name: pulumi.Input[str]
|
|
254
|
+
"""
|
|
255
|
+
The name of the node.
|
|
256
|
+
"""
|
|
257
|
+
elif False:
|
|
258
|
+
AclRoleNodeIdentityArgsDict: TypeAlias = Mapping[str, Any]
|
|
259
|
+
|
|
147
260
|
@pulumi.input_type
|
|
148
261
|
class AclRoleNodeIdentityArgs:
|
|
149
262
|
def __init__(__self__, *,
|
|
@@ -181,6 +294,19 @@ class AclRoleNodeIdentityArgs:
|
|
|
181
294
|
pulumi.set(self, "node_name", value)
|
|
182
295
|
|
|
183
296
|
|
|
297
|
+
if not MYPY:
|
|
298
|
+
class AclRoleServiceIdentityArgsDict(TypedDict):
|
|
299
|
+
service_name: pulumi.Input[str]
|
|
300
|
+
"""
|
|
301
|
+
The name of the service.
|
|
302
|
+
"""
|
|
303
|
+
datacenters: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
304
|
+
"""
|
|
305
|
+
The datacenters the effective policy is valid within. When no datacenters are provided the effective policy is valid in all datacenters including those which do not yet exist but may in the future.
|
|
306
|
+
"""
|
|
307
|
+
elif False:
|
|
308
|
+
AclRoleServiceIdentityArgsDict: TypeAlias = Mapping[str, Any]
|
|
309
|
+
|
|
184
310
|
@pulumi.input_type
|
|
185
311
|
class AclRoleServiceIdentityArgs:
|
|
186
312
|
def __init__(__self__, *,
|
|
@@ -219,6 +345,23 @@ class AclRoleServiceIdentityArgs:
|
|
|
219
345
|
pulumi.set(self, "datacenters", value)
|
|
220
346
|
|
|
221
347
|
|
|
348
|
+
if not MYPY:
|
|
349
|
+
class AclRoleTemplatedPolicyArgsDict(TypedDict):
|
|
350
|
+
template_name: pulumi.Input[str]
|
|
351
|
+
"""
|
|
352
|
+
The name of the templated policies.
|
|
353
|
+
"""
|
|
354
|
+
datacenters: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
355
|
+
"""
|
|
356
|
+
Specifies the datacenters the effective policy is valid within.
|
|
357
|
+
"""
|
|
358
|
+
template_variables: NotRequired[pulumi.Input['AclRoleTemplatedPolicyTemplateVariablesArgsDict']]
|
|
359
|
+
"""
|
|
360
|
+
The templated policy variables.
|
|
361
|
+
"""
|
|
362
|
+
elif False:
|
|
363
|
+
AclRoleTemplatedPolicyArgsDict: TypeAlias = Mapping[str, Any]
|
|
364
|
+
|
|
222
365
|
@pulumi.input_type
|
|
223
366
|
class AclRoleTemplatedPolicyArgs:
|
|
224
367
|
def __init__(__self__, *,
|
|
@@ -273,6 +416,15 @@ class AclRoleTemplatedPolicyArgs:
|
|
|
273
416
|
pulumi.set(self, "template_variables", value)
|
|
274
417
|
|
|
275
418
|
|
|
419
|
+
if not MYPY:
|
|
420
|
+
class AclRoleTemplatedPolicyTemplateVariablesArgsDict(TypedDict):
|
|
421
|
+
name: NotRequired[pulumi.Input[str]]
|
|
422
|
+
"""
|
|
423
|
+
The name of node, workload identity or service.
|
|
424
|
+
"""
|
|
425
|
+
elif False:
|
|
426
|
+
AclRoleTemplatedPolicyTemplateVariablesArgsDict: TypeAlias = Mapping[str, Any]
|
|
427
|
+
|
|
276
428
|
@pulumi.input_type
|
|
277
429
|
class AclRoleTemplatedPolicyTemplateVariablesArgs:
|
|
278
430
|
def __init__(__self__, *,
|
|
@@ -296,6 +448,19 @@ class AclRoleTemplatedPolicyTemplateVariablesArgs:
|
|
|
296
448
|
pulumi.set(self, "name", value)
|
|
297
449
|
|
|
298
450
|
|
|
451
|
+
if not MYPY:
|
|
452
|
+
class AclTokenNodeIdentityArgsDict(TypedDict):
|
|
453
|
+
datacenter: pulumi.Input[str]
|
|
454
|
+
"""
|
|
455
|
+
The datacenter of the node.
|
|
456
|
+
"""
|
|
457
|
+
node_name: pulumi.Input[str]
|
|
458
|
+
"""
|
|
459
|
+
The name of the node.
|
|
460
|
+
"""
|
|
461
|
+
elif False:
|
|
462
|
+
AclTokenNodeIdentityArgsDict: TypeAlias = Mapping[str, Any]
|
|
463
|
+
|
|
299
464
|
@pulumi.input_type
|
|
300
465
|
class AclTokenNodeIdentityArgs:
|
|
301
466
|
def __init__(__self__, *,
|
|
@@ -333,6 +498,19 @@ class AclTokenNodeIdentityArgs:
|
|
|
333
498
|
pulumi.set(self, "node_name", value)
|
|
334
499
|
|
|
335
500
|
|
|
501
|
+
if not MYPY:
|
|
502
|
+
class AclTokenServiceIdentityArgsDict(TypedDict):
|
|
503
|
+
service_name: pulumi.Input[str]
|
|
504
|
+
"""
|
|
505
|
+
The name of the service.
|
|
506
|
+
"""
|
|
507
|
+
datacenters: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
508
|
+
"""
|
|
509
|
+
Specifies the datacenters the effective policy is valid within.
|
|
510
|
+
"""
|
|
511
|
+
elif False:
|
|
512
|
+
AclTokenServiceIdentityArgsDict: TypeAlias = Mapping[str, Any]
|
|
513
|
+
|
|
336
514
|
@pulumi.input_type
|
|
337
515
|
class AclTokenServiceIdentityArgs:
|
|
338
516
|
def __init__(__self__, *,
|
|
@@ -371,6 +549,23 @@ class AclTokenServiceIdentityArgs:
|
|
|
371
549
|
pulumi.set(self, "datacenters", value)
|
|
372
550
|
|
|
373
551
|
|
|
552
|
+
if not MYPY:
|
|
553
|
+
class AclTokenTemplatedPolicyArgsDict(TypedDict):
|
|
554
|
+
template_name: pulumi.Input[str]
|
|
555
|
+
"""
|
|
556
|
+
The name of the templated policies.
|
|
557
|
+
"""
|
|
558
|
+
datacenters: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
559
|
+
"""
|
|
560
|
+
Specifies the datacenters the effective policy is valid within.
|
|
561
|
+
"""
|
|
562
|
+
template_variables: NotRequired[pulumi.Input['AclTokenTemplatedPolicyTemplateVariablesArgsDict']]
|
|
563
|
+
"""
|
|
564
|
+
The templated policy variables.
|
|
565
|
+
"""
|
|
566
|
+
elif False:
|
|
567
|
+
AclTokenTemplatedPolicyArgsDict: TypeAlias = Mapping[str, Any]
|
|
568
|
+
|
|
374
569
|
@pulumi.input_type
|
|
375
570
|
class AclTokenTemplatedPolicyArgs:
|
|
376
571
|
def __init__(__self__, *,
|
|
@@ -425,6 +620,15 @@ class AclTokenTemplatedPolicyArgs:
|
|
|
425
620
|
pulumi.set(self, "template_variables", value)
|
|
426
621
|
|
|
427
622
|
|
|
623
|
+
if not MYPY:
|
|
624
|
+
class AclTokenTemplatedPolicyTemplateVariablesArgsDict(TypedDict):
|
|
625
|
+
name: NotRequired[pulumi.Input[str]]
|
|
626
|
+
"""
|
|
627
|
+
The name of node, workload identity or service.
|
|
628
|
+
"""
|
|
629
|
+
elif False:
|
|
630
|
+
AclTokenTemplatedPolicyTemplateVariablesArgsDict: TypeAlias = Mapping[str, Any]
|
|
631
|
+
|
|
428
632
|
@pulumi.input_type
|
|
429
633
|
class AclTokenTemplatedPolicyTemplateVariablesArgs:
|
|
430
634
|
def __init__(__self__, *,
|
|
@@ -448,6 +652,33 @@ class AclTokenTemplatedPolicyTemplateVariablesArgs:
|
|
|
448
652
|
pulumi.set(self, "name", value)
|
|
449
653
|
|
|
450
654
|
|
|
655
|
+
if not MYPY:
|
|
656
|
+
class CatalogEntryServiceArgsDict(TypedDict):
|
|
657
|
+
name: pulumi.Input[str]
|
|
658
|
+
"""
|
|
659
|
+
The name of the service
|
|
660
|
+
"""
|
|
661
|
+
address: NotRequired[pulumi.Input[str]]
|
|
662
|
+
"""
|
|
663
|
+
The address of the service. Defaults to the
|
|
664
|
+
node address.
|
|
665
|
+
"""
|
|
666
|
+
id: NotRequired[pulumi.Input[str]]
|
|
667
|
+
"""
|
|
668
|
+
The ID of the service. Defaults to the `name`.
|
|
669
|
+
"""
|
|
670
|
+
port: NotRequired[pulumi.Input[int]]
|
|
671
|
+
"""
|
|
672
|
+
The port of the service.
|
|
673
|
+
"""
|
|
674
|
+
tags: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
675
|
+
"""
|
|
676
|
+
A list of values that are opaque to Consul,
|
|
677
|
+
but can be used to distinguish between services or nodes.
|
|
678
|
+
"""
|
|
679
|
+
elif False:
|
|
680
|
+
CatalogEntryServiceArgsDict: TypeAlias = Mapping[str, Any]
|
|
681
|
+
|
|
451
682
|
@pulumi.input_type
|
|
452
683
|
class CatalogEntryServiceArgs:
|
|
453
684
|
def __init__(__self__, *,
|
|
@@ -538,6 +769,13 @@ class CatalogEntryServiceArgs:
|
|
|
538
769
|
pulumi.set(self, "tags", value)
|
|
539
770
|
|
|
540
771
|
|
|
772
|
+
if not MYPY:
|
|
773
|
+
class ConfigEntryServiceDefaultsDestinationArgsDict(TypedDict):
|
|
774
|
+
addresses: pulumi.Input[Sequence[pulumi.Input[str]]]
|
|
775
|
+
port: pulumi.Input[int]
|
|
776
|
+
elif False:
|
|
777
|
+
ConfigEntryServiceDefaultsDestinationArgsDict: TypeAlias = Mapping[str, Any]
|
|
778
|
+
|
|
541
779
|
@pulumi.input_type
|
|
542
780
|
class ConfigEntryServiceDefaultsDestinationArgs:
|
|
543
781
|
def __init__(__self__, *,
|
|
@@ -565,6 +803,16 @@ class ConfigEntryServiceDefaultsDestinationArgs:
|
|
|
565
803
|
pulumi.set(self, "port", value)
|
|
566
804
|
|
|
567
805
|
|
|
806
|
+
if not MYPY:
|
|
807
|
+
class ConfigEntryServiceDefaultsEnvoyExtensionArgsDict(TypedDict):
|
|
808
|
+
arguments: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[str]]]]
|
|
809
|
+
consul_version: NotRequired[pulumi.Input[str]]
|
|
810
|
+
envoy_version: NotRequired[pulumi.Input[str]]
|
|
811
|
+
name: NotRequired[pulumi.Input[str]]
|
|
812
|
+
required: NotRequired[pulumi.Input[bool]]
|
|
813
|
+
elif False:
|
|
814
|
+
ConfigEntryServiceDefaultsEnvoyExtensionArgsDict: TypeAlias = Mapping[str, Any]
|
|
815
|
+
|
|
568
816
|
@pulumi.input_type
|
|
569
817
|
class ConfigEntryServiceDefaultsEnvoyExtensionArgs:
|
|
570
818
|
def __init__(__self__, *,
|
|
@@ -630,6 +878,13 @@ class ConfigEntryServiceDefaultsEnvoyExtensionArgs:
|
|
|
630
878
|
pulumi.set(self, "required", value)
|
|
631
879
|
|
|
632
880
|
|
|
881
|
+
if not MYPY:
|
|
882
|
+
class ConfigEntryServiceDefaultsExposeArgsDict(TypedDict):
|
|
883
|
+
checks: NotRequired[pulumi.Input[bool]]
|
|
884
|
+
paths: NotRequired[pulumi.Input[Sequence[pulumi.Input['ConfigEntryServiceDefaultsExposePathArgsDict']]]]
|
|
885
|
+
elif False:
|
|
886
|
+
ConfigEntryServiceDefaultsExposeArgsDict: TypeAlias = Mapping[str, Any]
|
|
887
|
+
|
|
633
888
|
@pulumi.input_type
|
|
634
889
|
class ConfigEntryServiceDefaultsExposeArgs:
|
|
635
890
|
def __init__(__self__, *,
|
|
@@ -659,6 +914,15 @@ class ConfigEntryServiceDefaultsExposeArgs:
|
|
|
659
914
|
pulumi.set(self, "paths", value)
|
|
660
915
|
|
|
661
916
|
|
|
917
|
+
if not MYPY:
|
|
918
|
+
class ConfigEntryServiceDefaultsExposePathArgsDict(TypedDict):
|
|
919
|
+
listener_port: NotRequired[pulumi.Input[int]]
|
|
920
|
+
local_path_port: NotRequired[pulumi.Input[int]]
|
|
921
|
+
path: NotRequired[pulumi.Input[str]]
|
|
922
|
+
protocol: NotRequired[pulumi.Input[str]]
|
|
923
|
+
elif False:
|
|
924
|
+
ConfigEntryServiceDefaultsExposePathArgsDict: TypeAlias = Mapping[str, Any]
|
|
925
|
+
|
|
662
926
|
@pulumi.input_type
|
|
663
927
|
class ConfigEntryServiceDefaultsExposePathArgs:
|
|
664
928
|
def __init__(__self__, *,
|
|
@@ -712,6 +976,12 @@ class ConfigEntryServiceDefaultsExposePathArgs:
|
|
|
712
976
|
pulumi.set(self, "protocol", value)
|
|
713
977
|
|
|
714
978
|
|
|
979
|
+
if not MYPY:
|
|
980
|
+
class ConfigEntryServiceDefaultsMeshGatewayArgsDict(TypedDict):
|
|
981
|
+
mode: pulumi.Input[str]
|
|
982
|
+
elif False:
|
|
983
|
+
ConfigEntryServiceDefaultsMeshGatewayArgsDict: TypeAlias = Mapping[str, Any]
|
|
984
|
+
|
|
715
985
|
@pulumi.input_type
|
|
716
986
|
class ConfigEntryServiceDefaultsMeshGatewayArgs:
|
|
717
987
|
def __init__(__self__, *,
|
|
@@ -728,6 +998,13 @@ class ConfigEntryServiceDefaultsMeshGatewayArgs:
|
|
|
728
998
|
pulumi.set(self, "mode", value)
|
|
729
999
|
|
|
730
1000
|
|
|
1001
|
+
if not MYPY:
|
|
1002
|
+
class ConfigEntryServiceDefaultsTransparentProxyArgsDict(TypedDict):
|
|
1003
|
+
dialed_directly: pulumi.Input[bool]
|
|
1004
|
+
outbound_listener_port: pulumi.Input[int]
|
|
1005
|
+
elif False:
|
|
1006
|
+
ConfigEntryServiceDefaultsTransparentProxyArgsDict: TypeAlias = Mapping[str, Any]
|
|
1007
|
+
|
|
731
1008
|
@pulumi.input_type
|
|
732
1009
|
class ConfigEntryServiceDefaultsTransparentProxyArgs:
|
|
733
1010
|
def __init__(__self__, *,
|
|
@@ -755,6 +1032,19 @@ class ConfigEntryServiceDefaultsTransparentProxyArgs:
|
|
|
755
1032
|
pulumi.set(self, "outbound_listener_port", value)
|
|
756
1033
|
|
|
757
1034
|
|
|
1035
|
+
if not MYPY:
|
|
1036
|
+
class ConfigEntryServiceDefaultsUpstreamConfigArgsDict(TypedDict):
|
|
1037
|
+
defaults: NotRequired[pulumi.Input[Sequence[pulumi.Input['ConfigEntryServiceDefaultsUpstreamConfigDefaultArgsDict']]]]
|
|
1038
|
+
"""
|
|
1039
|
+
Specifies configurations that set default upstream settings. For information about overriding the default configurations for in for individual upstreams, refer to UpstreamConfig.Overrides.
|
|
1040
|
+
"""
|
|
1041
|
+
overrides: NotRequired[pulumi.Input[Sequence[pulumi.Input['ConfigEntryServiceDefaultsUpstreamConfigOverrideArgsDict']]]]
|
|
1042
|
+
"""
|
|
1043
|
+
Specifies options that override the default upstream configurations for individual upstreams.
|
|
1044
|
+
"""
|
|
1045
|
+
elif False:
|
|
1046
|
+
ConfigEntryServiceDefaultsUpstreamConfigArgsDict: TypeAlias = Mapping[str, Any]
|
|
1047
|
+
|
|
758
1048
|
@pulumi.input_type
|
|
759
1049
|
class ConfigEntryServiceDefaultsUpstreamConfigArgs:
|
|
760
1050
|
def __init__(__self__, *,
|
|
@@ -794,6 +1084,32 @@ class ConfigEntryServiceDefaultsUpstreamConfigArgs:
|
|
|
794
1084
|
pulumi.set(self, "overrides", value)
|
|
795
1085
|
|
|
796
1086
|
|
|
1087
|
+
if not MYPY:
|
|
1088
|
+
class ConfigEntryServiceDefaultsUpstreamConfigDefaultArgsDict(TypedDict):
|
|
1089
|
+
balance_outbound_connections: NotRequired[pulumi.Input[str]]
|
|
1090
|
+
"""
|
|
1091
|
+
Sets the strategy for allocating outbound connections from upstreams across Envoy proxy threads.
|
|
1092
|
+
"""
|
|
1093
|
+
connect_timeout_ms: NotRequired[pulumi.Input[int]]
|
|
1094
|
+
limits: NotRequired[pulumi.Input[Sequence[pulumi.Input['ConfigEntryServiceDefaultsUpstreamConfigDefaultLimitArgsDict']]]]
|
|
1095
|
+
"""
|
|
1096
|
+
Map that specifies a set of limits to apply to when connecting upstream services.
|
|
1097
|
+
"""
|
|
1098
|
+
mesh_gateways: NotRequired[pulumi.Input[Sequence[pulumi.Input['ConfigEntryServiceDefaultsUpstreamConfigDefaultMeshGatewayArgsDict']]]]
|
|
1099
|
+
"""
|
|
1100
|
+
Specifies the default mesh gateway mode field for all upstreams.
|
|
1101
|
+
"""
|
|
1102
|
+
passive_health_checks: NotRequired[pulumi.Input[Sequence[pulumi.Input['ConfigEntryServiceDefaultsUpstreamConfigDefaultPassiveHealthCheckArgsDict']]]]
|
|
1103
|
+
"""
|
|
1104
|
+
Map that specifies a set of rules that enable Consul to remove hosts from the upstream cluster that are unreachable or that return errors.
|
|
1105
|
+
"""
|
|
1106
|
+
protocol: NotRequired[pulumi.Input[str]]
|
|
1107
|
+
"""
|
|
1108
|
+
Specifies the default protocol for the service.
|
|
1109
|
+
"""
|
|
1110
|
+
elif False:
|
|
1111
|
+
ConfigEntryServiceDefaultsUpstreamConfigDefaultArgsDict: TypeAlias = Mapping[str, Any]
|
|
1112
|
+
|
|
797
1113
|
@pulumi.input_type
|
|
798
1114
|
class ConfigEntryServiceDefaultsUpstreamConfigDefaultArgs:
|
|
799
1115
|
def __init__(__self__, *,
|
|
@@ -893,6 +1209,23 @@ class ConfigEntryServiceDefaultsUpstreamConfigDefaultArgs:
|
|
|
893
1209
|
pulumi.set(self, "protocol", value)
|
|
894
1210
|
|
|
895
1211
|
|
|
1212
|
+
if not MYPY:
|
|
1213
|
+
class ConfigEntryServiceDefaultsUpstreamConfigDefaultLimitArgsDict(TypedDict):
|
|
1214
|
+
max_concurrent_requests: NotRequired[pulumi.Input[int]]
|
|
1215
|
+
"""
|
|
1216
|
+
Specifies the maximum number of concurrent requests.
|
|
1217
|
+
"""
|
|
1218
|
+
max_connections: NotRequired[pulumi.Input[int]]
|
|
1219
|
+
"""
|
|
1220
|
+
Specifies the maximum number of connections a service instance can establish against the upstream.
|
|
1221
|
+
"""
|
|
1222
|
+
max_pending_requests: NotRequired[pulumi.Input[int]]
|
|
1223
|
+
"""
|
|
1224
|
+
Specifies the maximum number of requests that are queued while waiting for a connection to establish.
|
|
1225
|
+
"""
|
|
1226
|
+
elif False:
|
|
1227
|
+
ConfigEntryServiceDefaultsUpstreamConfigDefaultLimitArgsDict: TypeAlias = Mapping[str, Any]
|
|
1228
|
+
|
|
896
1229
|
@pulumi.input_type
|
|
897
1230
|
class ConfigEntryServiceDefaultsUpstreamConfigDefaultLimitArgs:
|
|
898
1231
|
def __init__(__self__, *,
|
|
@@ -948,6 +1281,12 @@ class ConfigEntryServiceDefaultsUpstreamConfigDefaultLimitArgs:
|
|
|
948
1281
|
pulumi.set(self, "max_pending_requests", value)
|
|
949
1282
|
|
|
950
1283
|
|
|
1284
|
+
if not MYPY:
|
|
1285
|
+
class ConfigEntryServiceDefaultsUpstreamConfigDefaultMeshGatewayArgsDict(TypedDict):
|
|
1286
|
+
mode: NotRequired[pulumi.Input[str]]
|
|
1287
|
+
elif False:
|
|
1288
|
+
ConfigEntryServiceDefaultsUpstreamConfigDefaultMeshGatewayArgsDict: TypeAlias = Mapping[str, Any]
|
|
1289
|
+
|
|
951
1290
|
@pulumi.input_type
|
|
952
1291
|
class ConfigEntryServiceDefaultsUpstreamConfigDefaultMeshGatewayArgs:
|
|
953
1292
|
def __init__(__self__, *,
|
|
@@ -965,6 +1304,31 @@ class ConfigEntryServiceDefaultsUpstreamConfigDefaultMeshGatewayArgs:
|
|
|
965
1304
|
pulumi.set(self, "mode", value)
|
|
966
1305
|
|
|
967
1306
|
|
|
1307
|
+
if not MYPY:
|
|
1308
|
+
class ConfigEntryServiceDefaultsUpstreamConfigDefaultPassiveHealthCheckArgsDict(TypedDict):
|
|
1309
|
+
base_ejection_time: NotRequired[pulumi.Input[str]]
|
|
1310
|
+
"""
|
|
1311
|
+
Specifies the minimum amount of time that an ejected host must remain outside the cluster before rejoining.
|
|
1312
|
+
"""
|
|
1313
|
+
enforcing_consecutive5xx: NotRequired[pulumi.Input[int]]
|
|
1314
|
+
"""
|
|
1315
|
+
Specifies a percentage that indicates how many times out of 100 that Consul ejects the host when it detects an outlier status.
|
|
1316
|
+
"""
|
|
1317
|
+
interval: NotRequired[pulumi.Input[str]]
|
|
1318
|
+
"""
|
|
1319
|
+
Specifies the time between checks.
|
|
1320
|
+
"""
|
|
1321
|
+
max_ejection_percent: NotRequired[pulumi.Input[int]]
|
|
1322
|
+
"""
|
|
1323
|
+
Specifies the maximum percentage of an upstream cluster that Consul ejects when the proxy reports an outlier.
|
|
1324
|
+
"""
|
|
1325
|
+
max_failures: NotRequired[pulumi.Input[int]]
|
|
1326
|
+
"""
|
|
1327
|
+
Specifies the number of consecutive failures allowed per check interval. If exceeded, Consul removes the host from the load balancer.
|
|
1328
|
+
"""
|
|
1329
|
+
elif False:
|
|
1330
|
+
ConfigEntryServiceDefaultsUpstreamConfigDefaultPassiveHealthCheckArgsDict: TypeAlias = Mapping[str, Any]
|
|
1331
|
+
|
|
968
1332
|
@pulumi.input_type
|
|
969
1333
|
class ConfigEntryServiceDefaultsUpstreamConfigDefaultPassiveHealthCheckArgs:
|
|
970
1334
|
def __init__(__self__, *,
|
|
@@ -1052,6 +1416,49 @@ class ConfigEntryServiceDefaultsUpstreamConfigDefaultPassiveHealthCheckArgs:
|
|
|
1052
1416
|
pulumi.set(self, "max_failures", value)
|
|
1053
1417
|
|
|
1054
1418
|
|
|
1419
|
+
if not MYPY:
|
|
1420
|
+
class ConfigEntryServiceDefaultsUpstreamConfigOverrideArgsDict(TypedDict):
|
|
1421
|
+
balance_outbound_connections: NotRequired[pulumi.Input[str]]
|
|
1422
|
+
"""
|
|
1423
|
+
Sets the strategy for allocating outbound connections from upstreams across Envoy proxy threads.
|
|
1424
|
+
"""
|
|
1425
|
+
connect_timeout_ms: NotRequired[pulumi.Input[int]]
|
|
1426
|
+
envoy_listener_json: NotRequired[pulumi.Input[str]]
|
|
1427
|
+
limits: NotRequired[pulumi.Input[Sequence[pulumi.Input['ConfigEntryServiceDefaultsUpstreamConfigOverrideLimitArgsDict']]]]
|
|
1428
|
+
"""
|
|
1429
|
+
Map that specifies a set of limits to apply to when connecting upstream services.
|
|
1430
|
+
"""
|
|
1431
|
+
mesh_gateways: NotRequired[pulumi.Input[Sequence[pulumi.Input['ConfigEntryServiceDefaultsUpstreamConfigOverrideMeshGatewayArgsDict']]]]
|
|
1432
|
+
"""
|
|
1433
|
+
Specifies the default mesh gateway mode field for all upstreams.
|
|
1434
|
+
"""
|
|
1435
|
+
name: NotRequired[pulumi.Input[str]]
|
|
1436
|
+
"""
|
|
1437
|
+
Specifies the name of the service you are setting the defaults for.
|
|
1438
|
+
"""
|
|
1439
|
+
namespace: NotRequired[pulumi.Input[str]]
|
|
1440
|
+
"""
|
|
1441
|
+
Specifies the namespace containing the upstream service that the configuration applies to.
|
|
1442
|
+
"""
|
|
1443
|
+
partition: NotRequired[pulumi.Input[str]]
|
|
1444
|
+
"""
|
|
1445
|
+
Specifies the name of the name of the Consul admin partition that the configuration entry applies to.
|
|
1446
|
+
"""
|
|
1447
|
+
passive_health_checks: NotRequired[pulumi.Input[Sequence[pulumi.Input['ConfigEntryServiceDefaultsUpstreamConfigOverridePassiveHealthCheckArgsDict']]]]
|
|
1448
|
+
"""
|
|
1449
|
+
Map that specifies a set of rules that enable Consul to remove hosts from the upstream cluster that are unreachable or that return errors.
|
|
1450
|
+
"""
|
|
1451
|
+
peer: NotRequired[pulumi.Input[str]]
|
|
1452
|
+
"""
|
|
1453
|
+
Specifies the peer name of the upstream service that the configuration applies to.
|
|
1454
|
+
"""
|
|
1455
|
+
protocol: NotRequired[pulumi.Input[str]]
|
|
1456
|
+
"""
|
|
1457
|
+
Specifies the default protocol for the service.
|
|
1458
|
+
"""
|
|
1459
|
+
elif False:
|
|
1460
|
+
ConfigEntryServiceDefaultsUpstreamConfigOverrideArgsDict: TypeAlias = Mapping[str, Any]
|
|
1461
|
+
|
|
1055
1462
|
@pulumi.input_type
|
|
1056
1463
|
class ConfigEntryServiceDefaultsUpstreamConfigOverrideArgs:
|
|
1057
1464
|
def __init__(__self__, *,
|
|
@@ -1227,6 +1634,23 @@ class ConfigEntryServiceDefaultsUpstreamConfigOverrideArgs:
|
|
|
1227
1634
|
pulumi.set(self, "protocol", value)
|
|
1228
1635
|
|
|
1229
1636
|
|
|
1637
|
+
if not MYPY:
|
|
1638
|
+
class ConfigEntryServiceDefaultsUpstreamConfigOverrideLimitArgsDict(TypedDict):
|
|
1639
|
+
max_concurrent_requests: NotRequired[pulumi.Input[int]]
|
|
1640
|
+
"""
|
|
1641
|
+
Specifies the maximum number of concurrent requests.
|
|
1642
|
+
"""
|
|
1643
|
+
max_connections: NotRequired[pulumi.Input[int]]
|
|
1644
|
+
"""
|
|
1645
|
+
Specifies the maximum number of connections a service instance can establish against the upstream.
|
|
1646
|
+
"""
|
|
1647
|
+
max_pending_requests: NotRequired[pulumi.Input[int]]
|
|
1648
|
+
"""
|
|
1649
|
+
Specifies the maximum number of requests that are queued while waiting for a connection to establish.
|
|
1650
|
+
"""
|
|
1651
|
+
elif False:
|
|
1652
|
+
ConfigEntryServiceDefaultsUpstreamConfigOverrideLimitArgsDict: TypeAlias = Mapping[str, Any]
|
|
1653
|
+
|
|
1230
1654
|
@pulumi.input_type
|
|
1231
1655
|
class ConfigEntryServiceDefaultsUpstreamConfigOverrideLimitArgs:
|
|
1232
1656
|
def __init__(__self__, *,
|
|
@@ -1282,6 +1706,12 @@ class ConfigEntryServiceDefaultsUpstreamConfigOverrideLimitArgs:
|
|
|
1282
1706
|
pulumi.set(self, "max_pending_requests", value)
|
|
1283
1707
|
|
|
1284
1708
|
|
|
1709
|
+
if not MYPY:
|
|
1710
|
+
class ConfigEntryServiceDefaultsUpstreamConfigOverrideMeshGatewayArgsDict(TypedDict):
|
|
1711
|
+
mode: NotRequired[pulumi.Input[str]]
|
|
1712
|
+
elif False:
|
|
1713
|
+
ConfigEntryServiceDefaultsUpstreamConfigOverrideMeshGatewayArgsDict: TypeAlias = Mapping[str, Any]
|
|
1714
|
+
|
|
1285
1715
|
@pulumi.input_type
|
|
1286
1716
|
class ConfigEntryServiceDefaultsUpstreamConfigOverrideMeshGatewayArgs:
|
|
1287
1717
|
def __init__(__self__, *,
|
|
@@ -1299,6 +1729,31 @@ class ConfigEntryServiceDefaultsUpstreamConfigOverrideMeshGatewayArgs:
|
|
|
1299
1729
|
pulumi.set(self, "mode", value)
|
|
1300
1730
|
|
|
1301
1731
|
|
|
1732
|
+
if not MYPY:
|
|
1733
|
+
class ConfigEntryServiceDefaultsUpstreamConfigOverridePassiveHealthCheckArgsDict(TypedDict):
|
|
1734
|
+
base_ejection_time: NotRequired[pulumi.Input[str]]
|
|
1735
|
+
"""
|
|
1736
|
+
Specifies the minimum amount of time that an ejected host must remain outside the cluster before rejoining.
|
|
1737
|
+
"""
|
|
1738
|
+
enforcing_consecutive5xx: NotRequired[pulumi.Input[int]]
|
|
1739
|
+
"""
|
|
1740
|
+
Specifies a percentage that indicates how many times out of 100 that Consul ejects the host when it detects an outlier status.
|
|
1741
|
+
"""
|
|
1742
|
+
interval: NotRequired[pulumi.Input[str]]
|
|
1743
|
+
"""
|
|
1744
|
+
Specifies the time between checks.
|
|
1745
|
+
"""
|
|
1746
|
+
max_ejection_percent: NotRequired[pulumi.Input[int]]
|
|
1747
|
+
"""
|
|
1748
|
+
Specifies the maximum percentage of an upstream cluster that Consul ejects when the proxy reports an outlier.
|
|
1749
|
+
"""
|
|
1750
|
+
max_failures: NotRequired[pulumi.Input[int]]
|
|
1751
|
+
"""
|
|
1752
|
+
Specifies the number of consecutive failures allowed per check interval. If exceeded, Consul removes the host from the load balancer.
|
|
1753
|
+
"""
|
|
1754
|
+
elif False:
|
|
1755
|
+
ConfigEntryServiceDefaultsUpstreamConfigOverridePassiveHealthCheckArgsDict: TypeAlias = Mapping[str, Any]
|
|
1756
|
+
|
|
1302
1757
|
@pulumi.input_type
|
|
1303
1758
|
class ConfigEntryServiceDefaultsUpstreamConfigOverridePassiveHealthCheckArgs:
|
|
1304
1759
|
def __init__(__self__, *,
|
|
@@ -1386,6 +1841,15 @@ class ConfigEntryServiceDefaultsUpstreamConfigOverridePassiveHealthCheckArgs:
|
|
|
1386
1841
|
pulumi.set(self, "max_failures", value)
|
|
1387
1842
|
|
|
1388
1843
|
|
|
1844
|
+
if not MYPY:
|
|
1845
|
+
class ConfigEntryServiceIntentionsJwtArgsDict(TypedDict):
|
|
1846
|
+
providers: NotRequired[pulumi.Input[Sequence[pulumi.Input['ConfigEntryServiceIntentionsJwtProviderArgsDict']]]]
|
|
1847
|
+
"""
|
|
1848
|
+
Specifies the names of one or more previously configured JWT provider configuration entries, which include the information necessary to validate a JSON web token.
|
|
1849
|
+
"""
|
|
1850
|
+
elif False:
|
|
1851
|
+
ConfigEntryServiceIntentionsJwtArgsDict: TypeAlias = Mapping[str, Any]
|
|
1852
|
+
|
|
1389
1853
|
@pulumi.input_type
|
|
1390
1854
|
class ConfigEntryServiceIntentionsJwtArgs:
|
|
1391
1855
|
def __init__(__self__, *,
|
|
@@ -1409,6 +1873,19 @@ class ConfigEntryServiceIntentionsJwtArgs:
|
|
|
1409
1873
|
pulumi.set(self, "providers", value)
|
|
1410
1874
|
|
|
1411
1875
|
|
|
1876
|
+
if not MYPY:
|
|
1877
|
+
class ConfigEntryServiceIntentionsJwtProviderArgsDict(TypedDict):
|
|
1878
|
+
name: NotRequired[pulumi.Input[str]]
|
|
1879
|
+
"""
|
|
1880
|
+
Specifies the name of a JWT provider defined in the Name field of the jwt-provider configuration entry.
|
|
1881
|
+
"""
|
|
1882
|
+
verify_claims: NotRequired[pulumi.Input[Sequence[pulumi.Input['ConfigEntryServiceIntentionsJwtProviderVerifyClaimArgsDict']]]]
|
|
1883
|
+
"""
|
|
1884
|
+
Specifies additional token information to verify beyond what is configured in the JWT provider configuration entry.
|
|
1885
|
+
"""
|
|
1886
|
+
elif False:
|
|
1887
|
+
ConfigEntryServiceIntentionsJwtProviderArgsDict: TypeAlias = Mapping[str, Any]
|
|
1888
|
+
|
|
1412
1889
|
@pulumi.input_type
|
|
1413
1890
|
class ConfigEntryServiceIntentionsJwtProviderArgs:
|
|
1414
1891
|
def __init__(__self__, *,
|
|
@@ -1448,6 +1925,19 @@ class ConfigEntryServiceIntentionsJwtProviderArgs:
|
|
|
1448
1925
|
pulumi.set(self, "verify_claims", value)
|
|
1449
1926
|
|
|
1450
1927
|
|
|
1928
|
+
if not MYPY:
|
|
1929
|
+
class ConfigEntryServiceIntentionsJwtProviderVerifyClaimArgsDict(TypedDict):
|
|
1930
|
+
paths: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
1931
|
+
"""
|
|
1932
|
+
Specifies the path to the claim in the JSON web token.
|
|
1933
|
+
"""
|
|
1934
|
+
value: NotRequired[pulumi.Input[str]]
|
|
1935
|
+
"""
|
|
1936
|
+
Specifies the value to match on when verifying the the claim designated in path.
|
|
1937
|
+
"""
|
|
1938
|
+
elif False:
|
|
1939
|
+
ConfigEntryServiceIntentionsJwtProviderVerifyClaimArgsDict: TypeAlias = Mapping[str, Any]
|
|
1940
|
+
|
|
1451
1941
|
@pulumi.input_type
|
|
1452
1942
|
class ConfigEntryServiceIntentionsJwtProviderVerifyClaimArgs:
|
|
1453
1943
|
def __init__(__self__, *,
|
|
@@ -1487,6 +1977,51 @@ class ConfigEntryServiceIntentionsJwtProviderVerifyClaimArgs:
|
|
|
1487
1977
|
pulumi.set(self, "value", value)
|
|
1488
1978
|
|
|
1489
1979
|
|
|
1980
|
+
if not MYPY:
|
|
1981
|
+
class ConfigEntryServiceIntentionsSourceArgsDict(TypedDict):
|
|
1982
|
+
action: NotRequired[pulumi.Input[str]]
|
|
1983
|
+
"""
|
|
1984
|
+
Specifies the action to take when the source sends traffic to the destination service.
|
|
1985
|
+
"""
|
|
1986
|
+
description: NotRequired[pulumi.Input[str]]
|
|
1987
|
+
"""
|
|
1988
|
+
Specifies a description of the intention.
|
|
1989
|
+
"""
|
|
1990
|
+
name: NotRequired[pulumi.Input[str]]
|
|
1991
|
+
"""
|
|
1992
|
+
Specifies the name of the source that the intention allows or denies traffic from.
|
|
1993
|
+
"""
|
|
1994
|
+
namespace: NotRequired[pulumi.Input[str]]
|
|
1995
|
+
"""
|
|
1996
|
+
Specifies the traffic source namespace that the intention allows or denies traffic from.
|
|
1997
|
+
"""
|
|
1998
|
+
partition: NotRequired[pulumi.Input[str]]
|
|
1999
|
+
"""
|
|
2000
|
+
Specifies the name of an admin partition that the intention allows or denies traffic from.
|
|
2001
|
+
"""
|
|
2002
|
+
peer: NotRequired[pulumi.Input[str]]
|
|
2003
|
+
"""
|
|
2004
|
+
Specifies the name of a peered Consul cluster that the intention allows or denies traffic from
|
|
2005
|
+
"""
|
|
2006
|
+
permissions: NotRequired[pulumi.Input[Sequence[pulumi.Input['ConfigEntryServiceIntentionsSourcePermissionArgsDict']]]]
|
|
2007
|
+
"""
|
|
2008
|
+
Specifies a list of permissions for L7 traffic sources. The list contains one or more actions and a set of match criteria for each action.
|
|
2009
|
+
"""
|
|
2010
|
+
precedence: NotRequired[pulumi.Input[int]]
|
|
2011
|
+
"""
|
|
2012
|
+
The Precedence field contains a read-only integer. Consul generates the value based on name configurations for the source and destination services.
|
|
2013
|
+
"""
|
|
2014
|
+
sameness_group: NotRequired[pulumi.Input[str]]
|
|
2015
|
+
"""
|
|
2016
|
+
Specifies the name of a sameness group that the intention allows or denies traffic from.
|
|
2017
|
+
"""
|
|
2018
|
+
type: NotRequired[pulumi.Input[str]]
|
|
2019
|
+
"""
|
|
2020
|
+
Specifies the type of destination service that the configuration entry applies to.
|
|
2021
|
+
"""
|
|
2022
|
+
elif False:
|
|
2023
|
+
ConfigEntryServiceIntentionsSourceArgsDict: TypeAlias = Mapping[str, Any]
|
|
2024
|
+
|
|
1490
2025
|
@pulumi.input_type
|
|
1491
2026
|
class ConfigEntryServiceIntentionsSourceArgs:
|
|
1492
2027
|
def __init__(__self__, *,
|
|
@@ -1654,13 +2189,26 @@ class ConfigEntryServiceIntentionsSourceArgs:
|
|
|
1654
2189
|
pulumi.set(self, "type", value)
|
|
1655
2190
|
|
|
1656
2191
|
|
|
2192
|
+
if not MYPY:
|
|
2193
|
+
class ConfigEntryServiceIntentionsSourcePermissionArgsDict(TypedDict):
|
|
2194
|
+
action: pulumi.Input[str]
|
|
2195
|
+
"""
|
|
2196
|
+
Specifies the action to take when the source sends traffic to the destination service. The value is either allow or deny.
|
|
2197
|
+
"""
|
|
2198
|
+
https: pulumi.Input[Sequence[pulumi.Input['ConfigEntryServiceIntentionsSourcePermissionHttpArgsDict']]]
|
|
2199
|
+
"""
|
|
2200
|
+
Specifies a set of HTTP-specific match criteria.
|
|
2201
|
+
"""
|
|
2202
|
+
elif False:
|
|
2203
|
+
ConfigEntryServiceIntentionsSourcePermissionArgsDict: TypeAlias = Mapping[str, Any]
|
|
2204
|
+
|
|
1657
2205
|
@pulumi.input_type
|
|
1658
2206
|
class ConfigEntryServiceIntentionsSourcePermissionArgs:
|
|
1659
2207
|
def __init__(__self__, *,
|
|
1660
2208
|
action: pulumi.Input[str],
|
|
1661
2209
|
https: pulumi.Input[Sequence[pulumi.Input['ConfigEntryServiceIntentionsSourcePermissionHttpArgs']]]):
|
|
1662
2210
|
"""
|
|
1663
|
-
:param pulumi.Input[str] action: Specifies the action to take when the source sends traffic to the destination service.
|
|
2211
|
+
:param pulumi.Input[str] action: Specifies the action to take when the source sends traffic to the destination service. The value is either allow or deny.
|
|
1664
2212
|
:param pulumi.Input[Sequence[pulumi.Input['ConfigEntryServiceIntentionsSourcePermissionHttpArgs']]] https: Specifies a set of HTTP-specific match criteria.
|
|
1665
2213
|
"""
|
|
1666
2214
|
pulumi.set(__self__, "action", action)
|
|
@@ -1670,7 +2218,7 @@ class ConfigEntryServiceIntentionsSourcePermissionArgs:
|
|
|
1670
2218
|
@pulumi.getter
|
|
1671
2219
|
def action(self) -> pulumi.Input[str]:
|
|
1672
2220
|
"""
|
|
1673
|
-
Specifies the action to take when the source sends traffic to the destination service.
|
|
2221
|
+
Specifies the action to take when the source sends traffic to the destination service. The value is either allow or deny.
|
|
1674
2222
|
"""
|
|
1675
2223
|
return pulumi.get(self, "action")
|
|
1676
2224
|
|
|
@@ -1691,8 +2239,33 @@ class ConfigEntryServiceIntentionsSourcePermissionArgs:
|
|
|
1691
2239
|
pulumi.set(self, "https", value)
|
|
1692
2240
|
|
|
1693
2241
|
|
|
1694
|
-
|
|
1695
|
-
class
|
|
2242
|
+
if not MYPY:
|
|
2243
|
+
class ConfigEntryServiceIntentionsSourcePermissionHttpArgsDict(TypedDict):
|
|
2244
|
+
headers: NotRequired[pulumi.Input[Sequence[pulumi.Input['ConfigEntryServiceIntentionsSourcePermissionHttpHeaderArgsDict']]]]
|
|
2245
|
+
"""
|
|
2246
|
+
Specifies a header name and matching criteria for HTTP request headers.
|
|
2247
|
+
"""
|
|
2248
|
+
methods: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
2249
|
+
"""
|
|
2250
|
+
Specifies a list of HTTP methods.
|
|
2251
|
+
"""
|
|
2252
|
+
path_exact: NotRequired[pulumi.Input[str]]
|
|
2253
|
+
"""
|
|
2254
|
+
Specifies an exact path to match on the HTTP request path.
|
|
2255
|
+
"""
|
|
2256
|
+
path_prefix: NotRequired[pulumi.Input[str]]
|
|
2257
|
+
"""
|
|
2258
|
+
Specifies a path prefix to match on the HTTP request path.
|
|
2259
|
+
"""
|
|
2260
|
+
path_regex: NotRequired[pulumi.Input[str]]
|
|
2261
|
+
"""
|
|
2262
|
+
Defines a regular expression to match on the HTTP request path.
|
|
2263
|
+
"""
|
|
2264
|
+
elif False:
|
|
2265
|
+
ConfigEntryServiceIntentionsSourcePermissionHttpArgsDict: TypeAlias = Mapping[str, Any]
|
|
2266
|
+
|
|
2267
|
+
@pulumi.input_type
|
|
2268
|
+
class ConfigEntryServiceIntentionsSourcePermissionHttpArgs:
|
|
1696
2269
|
def __init__(__self__, *,
|
|
1697
2270
|
headers: Optional[pulumi.Input[Sequence[pulumi.Input['ConfigEntryServiceIntentionsSourcePermissionHttpHeaderArgs']]]] = None,
|
|
1698
2271
|
methods: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
@@ -1778,6 +2351,39 @@ class ConfigEntryServiceIntentionsSourcePermissionHttpArgs:
|
|
|
1778
2351
|
pulumi.set(self, "path_regex", value)
|
|
1779
2352
|
|
|
1780
2353
|
|
|
2354
|
+
if not MYPY:
|
|
2355
|
+
class ConfigEntryServiceIntentionsSourcePermissionHttpHeaderArgsDict(TypedDict):
|
|
2356
|
+
name: pulumi.Input[str]
|
|
2357
|
+
"""
|
|
2358
|
+
Specifies the name of the header to match.
|
|
2359
|
+
"""
|
|
2360
|
+
exact: NotRequired[pulumi.Input[str]]
|
|
2361
|
+
"""
|
|
2362
|
+
Specifies a value for the header key set in the Name field. If the request header value matches the Exact value, Consul applies the permission.
|
|
2363
|
+
"""
|
|
2364
|
+
invert: NotRequired[pulumi.Input[bool]]
|
|
2365
|
+
"""
|
|
2366
|
+
Inverts the matching logic configured in the Header.
|
|
2367
|
+
"""
|
|
2368
|
+
prefix: NotRequired[pulumi.Input[str]]
|
|
2369
|
+
"""
|
|
2370
|
+
Specifies a prefix value for the header key set in the Name field.
|
|
2371
|
+
"""
|
|
2372
|
+
present: NotRequired[pulumi.Input[bool]]
|
|
2373
|
+
"""
|
|
2374
|
+
Enables a match if the header configured in the Name field appears in the request. Consul matches on any value as long as the header key appears in the request.
|
|
2375
|
+
"""
|
|
2376
|
+
regex: NotRequired[pulumi.Input[str]]
|
|
2377
|
+
"""
|
|
2378
|
+
Specifies a regular expression pattern as the value for the header key set in the Name field.
|
|
2379
|
+
"""
|
|
2380
|
+
suffix: NotRequired[pulumi.Input[str]]
|
|
2381
|
+
"""
|
|
2382
|
+
Specifies a suffix value for the header key set in the Name field.
|
|
2383
|
+
"""
|
|
2384
|
+
elif False:
|
|
2385
|
+
ConfigEntryServiceIntentionsSourcePermissionHttpHeaderArgsDict: TypeAlias = Mapping[str, Any]
|
|
2386
|
+
|
|
1781
2387
|
@pulumi.input_type
|
|
1782
2388
|
class ConfigEntryServiceIntentionsSourcePermissionHttpHeaderArgs:
|
|
1783
2389
|
def __init__(__self__, *,
|
|
@@ -1789,7 +2395,7 @@ class ConfigEntryServiceIntentionsSourcePermissionHttpHeaderArgs:
|
|
|
1789
2395
|
regex: Optional[pulumi.Input[str]] = None,
|
|
1790
2396
|
suffix: Optional[pulumi.Input[str]] = None):
|
|
1791
2397
|
"""
|
|
1792
|
-
:param pulumi.Input[str] name: Specifies the name of
|
|
2398
|
+
:param pulumi.Input[str] name: Specifies the name of the header to match.
|
|
1793
2399
|
:param pulumi.Input[str] exact: Specifies a value for the header key set in the Name field. If the request header value matches the Exact value, Consul applies the permission.
|
|
1794
2400
|
:param pulumi.Input[bool] invert: Inverts the matching logic configured in the Header.
|
|
1795
2401
|
:param pulumi.Input[str] prefix: Specifies a prefix value for the header key set in the Name field.
|
|
@@ -1815,7 +2421,7 @@ class ConfigEntryServiceIntentionsSourcePermissionHttpHeaderArgs:
|
|
|
1815
2421
|
@pulumi.getter
|
|
1816
2422
|
def name(self) -> pulumi.Input[str]:
|
|
1817
2423
|
"""
|
|
1818
|
-
Specifies the name of
|
|
2424
|
+
Specifies the name of the header to match.
|
|
1819
2425
|
"""
|
|
1820
2426
|
return pulumi.get(self, "name")
|
|
1821
2427
|
|
|
@@ -1896,6 +2502,39 @@ class ConfigEntryServiceIntentionsSourcePermissionHttpHeaderArgs:
|
|
|
1896
2502
|
pulumi.set(self, "suffix", value)
|
|
1897
2503
|
|
|
1898
2504
|
|
|
2505
|
+
if not MYPY:
|
|
2506
|
+
class ConfigEntryServiceResolverFailoverArgsDict(TypedDict):
|
|
2507
|
+
subset_name: pulumi.Input[str]
|
|
2508
|
+
"""
|
|
2509
|
+
Name of subset.
|
|
2510
|
+
"""
|
|
2511
|
+
datacenters: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
2512
|
+
"""
|
|
2513
|
+
Specifies an ordered list of datacenters at the failover location to attempt connections to during a failover scenario. When Consul cannot establish a connection with the first datacenter in the list, it proceeds sequentially until establishing a connection with another datacenter.
|
|
2514
|
+
"""
|
|
2515
|
+
namespace: NotRequired[pulumi.Input[str]]
|
|
2516
|
+
"""
|
|
2517
|
+
Specifies the namespace at the failover location where the failover services are deployed.
|
|
2518
|
+
"""
|
|
2519
|
+
sameness_group: NotRequired[pulumi.Input[str]]
|
|
2520
|
+
"""
|
|
2521
|
+
Specifies the sameness group at the failover location where the failover services are deployed.
|
|
2522
|
+
"""
|
|
2523
|
+
service: NotRequired[pulumi.Input[str]]
|
|
2524
|
+
"""
|
|
2525
|
+
Specifies the name of the service to resolve at the failover location during a failover scenario.
|
|
2526
|
+
"""
|
|
2527
|
+
service_subset: NotRequired[pulumi.Input[str]]
|
|
2528
|
+
"""
|
|
2529
|
+
Specifies the name of a subset of service instances to resolve at the failover location during a failover scenario.
|
|
2530
|
+
"""
|
|
2531
|
+
targets: NotRequired[pulumi.Input[Sequence[pulumi.Input['ConfigEntryServiceResolverFailoverTargetArgsDict']]]]
|
|
2532
|
+
"""
|
|
2533
|
+
Specifies a fixed list of failover targets to try during failover. This list can express complicated failover scenarios.
|
|
2534
|
+
"""
|
|
2535
|
+
elif False:
|
|
2536
|
+
ConfigEntryServiceResolverFailoverArgsDict: TypeAlias = Mapping[str, Any]
|
|
2537
|
+
|
|
1899
2538
|
@pulumi.input_type
|
|
1900
2539
|
class ConfigEntryServiceResolverFailoverArgs:
|
|
1901
2540
|
def __init__(__self__, *,
|
|
@@ -2014,6 +2653,35 @@ class ConfigEntryServiceResolverFailoverArgs:
|
|
|
2014
2653
|
pulumi.set(self, "targets", value)
|
|
2015
2654
|
|
|
2016
2655
|
|
|
2656
|
+
if not MYPY:
|
|
2657
|
+
class ConfigEntryServiceResolverFailoverTargetArgsDict(TypedDict):
|
|
2658
|
+
datacenter: NotRequired[pulumi.Input[str]]
|
|
2659
|
+
"""
|
|
2660
|
+
Specifies the WAN federated datacenter to use for the failover target. If empty, the current datacenter is used.
|
|
2661
|
+
"""
|
|
2662
|
+
namespace: NotRequired[pulumi.Input[str]]
|
|
2663
|
+
"""
|
|
2664
|
+
Specifies the namespace to use for the failover target. If empty, the default namespace is used.
|
|
2665
|
+
"""
|
|
2666
|
+
partition: NotRequired[pulumi.Input[str]]
|
|
2667
|
+
"""
|
|
2668
|
+
Specifies the admin partition within the same datacenter to use for the failover target. If empty, the default partition is used.
|
|
2669
|
+
"""
|
|
2670
|
+
peer: NotRequired[pulumi.Input[str]]
|
|
2671
|
+
"""
|
|
2672
|
+
Specifies the destination cluster peer to resolve the target service name from.
|
|
2673
|
+
"""
|
|
2674
|
+
service: NotRequired[pulumi.Input[str]]
|
|
2675
|
+
"""
|
|
2676
|
+
Specifies the service name to use for the failover target. If empty, the current service name is used.
|
|
2677
|
+
"""
|
|
2678
|
+
service_subset: NotRequired[pulumi.Input[str]]
|
|
2679
|
+
"""
|
|
2680
|
+
Specifies the named subset to use for the failover target. If empty, the default subset for the requested service name is used.
|
|
2681
|
+
"""
|
|
2682
|
+
elif False:
|
|
2683
|
+
ConfigEntryServiceResolverFailoverTargetArgsDict: TypeAlias = Mapping[str, Any]
|
|
2684
|
+
|
|
2017
2685
|
@pulumi.input_type
|
|
2018
2686
|
class ConfigEntryServiceResolverFailoverTargetArgs:
|
|
2019
2687
|
def __init__(__self__, *,
|
|
@@ -2025,11 +2693,11 @@ class ConfigEntryServiceResolverFailoverTargetArgs:
|
|
|
2025
2693
|
service_subset: Optional[pulumi.Input[str]] = None):
|
|
2026
2694
|
"""
|
|
2027
2695
|
:param pulumi.Input[str] datacenter: Specifies the WAN federated datacenter to use for the failover target. If empty, the current datacenter is used.
|
|
2028
|
-
:param pulumi.Input[str] namespace: Specifies the namespace
|
|
2696
|
+
:param pulumi.Input[str] namespace: Specifies the namespace to use for the failover target. If empty, the default namespace is used.
|
|
2029
2697
|
:param pulumi.Input[str] partition: Specifies the admin partition within the same datacenter to use for the failover target. If empty, the default partition is used.
|
|
2030
2698
|
:param pulumi.Input[str] peer: Specifies the destination cluster peer to resolve the target service name from.
|
|
2031
|
-
:param pulumi.Input[str] service: Specifies the name
|
|
2032
|
-
:param pulumi.Input[str] service_subset: Specifies the
|
|
2699
|
+
:param pulumi.Input[str] service: Specifies the service name to use for the failover target. If empty, the current service name is used.
|
|
2700
|
+
:param pulumi.Input[str] service_subset: Specifies the named subset to use for the failover target. If empty, the default subset for the requested service name is used.
|
|
2033
2701
|
"""
|
|
2034
2702
|
if datacenter is not None:
|
|
2035
2703
|
pulumi.set(__self__, "datacenter", datacenter)
|
|
@@ -2060,7 +2728,7 @@ class ConfigEntryServiceResolverFailoverTargetArgs:
|
|
|
2060
2728
|
@pulumi.getter
|
|
2061
2729
|
def namespace(self) -> Optional[pulumi.Input[str]]:
|
|
2062
2730
|
"""
|
|
2063
|
-
Specifies the namespace
|
|
2731
|
+
Specifies the namespace to use for the failover target. If empty, the default namespace is used.
|
|
2064
2732
|
"""
|
|
2065
2733
|
return pulumi.get(self, "namespace")
|
|
2066
2734
|
|
|
@@ -2096,7 +2764,7 @@ class ConfigEntryServiceResolverFailoverTargetArgs:
|
|
|
2096
2764
|
@pulumi.getter
|
|
2097
2765
|
def service(self) -> Optional[pulumi.Input[str]]:
|
|
2098
2766
|
"""
|
|
2099
|
-
Specifies the name
|
|
2767
|
+
Specifies the service name to use for the failover target. If empty, the current service name is used.
|
|
2100
2768
|
"""
|
|
2101
2769
|
return pulumi.get(self, "service")
|
|
2102
2770
|
|
|
@@ -2108,7 +2776,7 @@ class ConfigEntryServiceResolverFailoverTargetArgs:
|
|
|
2108
2776
|
@pulumi.getter(name="serviceSubset")
|
|
2109
2777
|
def service_subset(self) -> Optional[pulumi.Input[str]]:
|
|
2110
2778
|
"""
|
|
2111
|
-
Specifies the
|
|
2779
|
+
Specifies the named subset to use for the failover target. If empty, the default subset for the requested service name is used.
|
|
2112
2780
|
"""
|
|
2113
2781
|
return pulumi.get(self, "service_subset")
|
|
2114
2782
|
|
|
@@ -2117,6 +2785,27 @@ class ConfigEntryServiceResolverFailoverTargetArgs:
|
|
|
2117
2785
|
pulumi.set(self, "service_subset", value)
|
|
2118
2786
|
|
|
2119
2787
|
|
|
2788
|
+
if not MYPY:
|
|
2789
|
+
class ConfigEntryServiceResolverLoadBalancerArgsDict(TypedDict):
|
|
2790
|
+
hash_policies: NotRequired[pulumi.Input[Sequence[pulumi.Input['ConfigEntryServiceResolverLoadBalancerHashPolicyArgsDict']]]]
|
|
2791
|
+
"""
|
|
2792
|
+
Specifies a list of hash policies to use for hashing load balancing algorithms. Consul evaluates hash policies individually and combines them so that identical lists result in the same hash.
|
|
2793
|
+
"""
|
|
2794
|
+
least_request_configs: NotRequired[pulumi.Input[Sequence[pulumi.Input['ConfigEntryServiceResolverLoadBalancerLeastRequestConfigArgsDict']]]]
|
|
2795
|
+
"""
|
|
2796
|
+
Specifies configuration for the least*request policy type.
|
|
2797
|
+
"""
|
|
2798
|
+
policy: NotRequired[pulumi.Input[str]]
|
|
2799
|
+
"""
|
|
2800
|
+
Specifies the type of load balancing policy for selecting a host.
|
|
2801
|
+
"""
|
|
2802
|
+
ring_hash_configs: NotRequired[pulumi.Input[Sequence[pulumi.Input['ConfigEntryServiceResolverLoadBalancerRingHashConfigArgsDict']]]]
|
|
2803
|
+
"""
|
|
2804
|
+
Specifies configuration for the ring*hash policy type.
|
|
2805
|
+
"""
|
|
2806
|
+
elif False:
|
|
2807
|
+
ConfigEntryServiceResolverLoadBalancerArgsDict: TypeAlias = Mapping[str, Any]
|
|
2808
|
+
|
|
2120
2809
|
@pulumi.input_type
|
|
2121
2810
|
class ConfigEntryServiceResolverLoadBalancerArgs:
|
|
2122
2811
|
def __init__(__self__, *,
|
|
@@ -2188,6 +2877,31 @@ class ConfigEntryServiceResolverLoadBalancerArgs:
|
|
|
2188
2877
|
pulumi.set(self, "ring_hash_configs", value)
|
|
2189
2878
|
|
|
2190
2879
|
|
|
2880
|
+
if not MYPY:
|
|
2881
|
+
class ConfigEntryServiceResolverLoadBalancerHashPolicyArgsDict(TypedDict):
|
|
2882
|
+
cookie_configs: NotRequired[pulumi.Input[Sequence[pulumi.Input['ConfigEntryServiceResolverLoadBalancerHashPolicyCookieConfigArgsDict']]]]
|
|
2883
|
+
"""
|
|
2884
|
+
Specifies additional configuration options for the cookie hash policy type.
|
|
2885
|
+
"""
|
|
2886
|
+
field: NotRequired[pulumi.Input[str]]
|
|
2887
|
+
"""
|
|
2888
|
+
Specifies the attribute type to hash on. You cannot specify the Field parameter if SourceIP is also configured.
|
|
2889
|
+
"""
|
|
2890
|
+
field_value: NotRequired[pulumi.Input[str]]
|
|
2891
|
+
"""
|
|
2892
|
+
Specifies the value to hash, such as a header name, cookie name, or a URL query parameter name.
|
|
2893
|
+
"""
|
|
2894
|
+
source_ip: NotRequired[pulumi.Input[bool]]
|
|
2895
|
+
"""
|
|
2896
|
+
Determines if the hash type should be source IP address.
|
|
2897
|
+
"""
|
|
2898
|
+
terminal: NotRequired[pulumi.Input[bool]]
|
|
2899
|
+
"""
|
|
2900
|
+
Determines if Consul should stop computing the hash when multiple hash policies are present.
|
|
2901
|
+
"""
|
|
2902
|
+
elif False:
|
|
2903
|
+
ConfigEntryServiceResolverLoadBalancerHashPolicyArgsDict: TypeAlias = Mapping[str, Any]
|
|
2904
|
+
|
|
2191
2905
|
@pulumi.input_type
|
|
2192
2906
|
class ConfigEntryServiceResolverLoadBalancerHashPolicyArgs:
|
|
2193
2907
|
def __init__(__self__, *,
|
|
@@ -2275,6 +2989,23 @@ class ConfigEntryServiceResolverLoadBalancerHashPolicyArgs:
|
|
|
2275
2989
|
pulumi.set(self, "terminal", value)
|
|
2276
2990
|
|
|
2277
2991
|
|
|
2992
|
+
if not MYPY:
|
|
2993
|
+
class ConfigEntryServiceResolverLoadBalancerHashPolicyCookieConfigArgsDict(TypedDict):
|
|
2994
|
+
path: NotRequired[pulumi.Input[str]]
|
|
2995
|
+
"""
|
|
2996
|
+
Specifies the path to set for the cookie.
|
|
2997
|
+
"""
|
|
2998
|
+
session: NotRequired[pulumi.Input[bool]]
|
|
2999
|
+
"""
|
|
3000
|
+
Directs Consul to generate a session cookie with no expiration.
|
|
3001
|
+
"""
|
|
3002
|
+
ttl: NotRequired[pulumi.Input[str]]
|
|
3003
|
+
"""
|
|
3004
|
+
Specifies the TTL for generated cookies. Cannot be specified for session cookies.
|
|
3005
|
+
"""
|
|
3006
|
+
elif False:
|
|
3007
|
+
ConfigEntryServiceResolverLoadBalancerHashPolicyCookieConfigArgsDict: TypeAlias = Mapping[str, Any]
|
|
3008
|
+
|
|
2278
3009
|
@pulumi.input_type
|
|
2279
3010
|
class ConfigEntryServiceResolverLoadBalancerHashPolicyCookieConfigArgs:
|
|
2280
3011
|
def __init__(__self__, *,
|
|
@@ -2330,6 +3061,12 @@ class ConfigEntryServiceResolverLoadBalancerHashPolicyCookieConfigArgs:
|
|
|
2330
3061
|
pulumi.set(self, "ttl", value)
|
|
2331
3062
|
|
|
2332
3063
|
|
|
3064
|
+
if not MYPY:
|
|
3065
|
+
class ConfigEntryServiceResolverLoadBalancerLeastRequestConfigArgsDict(TypedDict):
|
|
3066
|
+
choice_count: NotRequired[pulumi.Input[int]]
|
|
3067
|
+
elif False:
|
|
3068
|
+
ConfigEntryServiceResolverLoadBalancerLeastRequestConfigArgsDict: TypeAlias = Mapping[str, Any]
|
|
3069
|
+
|
|
2333
3070
|
@pulumi.input_type
|
|
2334
3071
|
class ConfigEntryServiceResolverLoadBalancerLeastRequestConfigArgs:
|
|
2335
3072
|
def __init__(__self__, *,
|
|
@@ -2347,6 +3084,19 @@ class ConfigEntryServiceResolverLoadBalancerLeastRequestConfigArgs:
|
|
|
2347
3084
|
pulumi.set(self, "choice_count", value)
|
|
2348
3085
|
|
|
2349
3086
|
|
|
3087
|
+
if not MYPY:
|
|
3088
|
+
class ConfigEntryServiceResolverLoadBalancerRingHashConfigArgsDict(TypedDict):
|
|
3089
|
+
maximum_ring_size: NotRequired[pulumi.Input[int]]
|
|
3090
|
+
"""
|
|
3091
|
+
Determines the maximum number of entries in the hash ring.
|
|
3092
|
+
"""
|
|
3093
|
+
minimum_ring_size: NotRequired[pulumi.Input[int]]
|
|
3094
|
+
"""
|
|
3095
|
+
Determines the minimum number of entries in the hash ring.
|
|
3096
|
+
"""
|
|
3097
|
+
elif False:
|
|
3098
|
+
ConfigEntryServiceResolverLoadBalancerRingHashConfigArgsDict: TypeAlias = Mapping[str, Any]
|
|
3099
|
+
|
|
2350
3100
|
@pulumi.input_type
|
|
2351
3101
|
class ConfigEntryServiceResolverLoadBalancerRingHashConfigArgs:
|
|
2352
3102
|
def __init__(__self__, *,
|
|
@@ -2386,6 +3136,39 @@ class ConfigEntryServiceResolverLoadBalancerRingHashConfigArgs:
|
|
|
2386
3136
|
pulumi.set(self, "minimum_ring_size", value)
|
|
2387
3137
|
|
|
2388
3138
|
|
|
3139
|
+
if not MYPY:
|
|
3140
|
+
class ConfigEntryServiceResolverRedirectArgsDict(TypedDict):
|
|
3141
|
+
datacenter: NotRequired[pulumi.Input[str]]
|
|
3142
|
+
"""
|
|
3143
|
+
Specifies the datacenter at the redirect’s destination that resolves local upstream requests.
|
|
3144
|
+
"""
|
|
3145
|
+
namespace: NotRequired[pulumi.Input[str]]
|
|
3146
|
+
"""
|
|
3147
|
+
Specifies the namespace at the redirect’s destination that resolves local upstream requests.
|
|
3148
|
+
"""
|
|
3149
|
+
partition: NotRequired[pulumi.Input[str]]
|
|
3150
|
+
"""
|
|
3151
|
+
Specifies the admin partition at the redirect’s destination that resolves local upstream requests.
|
|
3152
|
+
"""
|
|
3153
|
+
peer: NotRequired[pulumi.Input[str]]
|
|
3154
|
+
"""
|
|
3155
|
+
Specifies the cluster with an active cluster peering connection at the redirect’s destination that resolves local upstream requests.
|
|
3156
|
+
"""
|
|
3157
|
+
sameness_group: NotRequired[pulumi.Input[str]]
|
|
3158
|
+
"""
|
|
3159
|
+
Specifies the sameness group at the redirect’s destination that resolves local upstream requests.
|
|
3160
|
+
"""
|
|
3161
|
+
service: NotRequired[pulumi.Input[str]]
|
|
3162
|
+
"""
|
|
3163
|
+
Specifies the name of a service at the redirect’s destination that resolves local upstream requests.
|
|
3164
|
+
"""
|
|
3165
|
+
service_subset: NotRequired[pulumi.Input[str]]
|
|
3166
|
+
"""
|
|
3167
|
+
Specifies the name of a subset of services at the redirect’s destination that resolves local upstream requests. If empty, the default subset is used. If specified, you must also specify at least one of the following in the same Redirect map: Service, Namespace, andDatacenter.
|
|
3168
|
+
"""
|
|
3169
|
+
elif False:
|
|
3170
|
+
ConfigEntryServiceResolverRedirectArgsDict: TypeAlias = Mapping[str, Any]
|
|
3171
|
+
|
|
2389
3172
|
@pulumi.input_type
|
|
2390
3173
|
class ConfigEntryServiceResolverRedirectArgs:
|
|
2391
3174
|
def __init__(__self__, *,
|
|
@@ -2505,6 +3288,23 @@ class ConfigEntryServiceResolverRedirectArgs:
|
|
|
2505
3288
|
pulumi.set(self, "service_subset", value)
|
|
2506
3289
|
|
|
2507
3290
|
|
|
3291
|
+
if not MYPY:
|
|
3292
|
+
class ConfigEntryServiceResolverSubsetArgsDict(TypedDict):
|
|
3293
|
+
filter: pulumi.Input[str]
|
|
3294
|
+
"""
|
|
3295
|
+
Specifies an expression that filters the DNS elements of service instances that belong to the subset. If empty, all healthy instances of a service are returned.
|
|
3296
|
+
"""
|
|
3297
|
+
name: pulumi.Input[str]
|
|
3298
|
+
"""
|
|
3299
|
+
Name of subset.
|
|
3300
|
+
"""
|
|
3301
|
+
only_passing: pulumi.Input[bool]
|
|
3302
|
+
"""
|
|
3303
|
+
Determines if instances that return a warning from a health check are allowed to resolve a request. When set to false, instances with passing and warning states are considered healthy. When set to true, only instances with a passing health check state are considered healthy.
|
|
3304
|
+
"""
|
|
3305
|
+
elif False:
|
|
3306
|
+
ConfigEntryServiceResolverSubsetArgsDict: TypeAlias = Mapping[str, Any]
|
|
3307
|
+
|
|
2508
3308
|
@pulumi.input_type
|
|
2509
3309
|
class ConfigEntryServiceResolverSubsetArgs:
|
|
2510
3310
|
def __init__(__self__, *,
|
|
@@ -2557,6 +3357,19 @@ class ConfigEntryServiceResolverSubsetArgs:
|
|
|
2557
3357
|
pulumi.set(self, "only_passing", value)
|
|
2558
3358
|
|
|
2559
3359
|
|
|
3360
|
+
if not MYPY:
|
|
3361
|
+
class ConfigEntryServiceRouterRouteArgsDict(TypedDict):
|
|
3362
|
+
destination: NotRequired[pulumi.Input['ConfigEntryServiceRouterRouteDestinationArgsDict']]
|
|
3363
|
+
"""
|
|
3364
|
+
Specifies the target service to route matching requests to, as well as behavior for the request to follow when routed.
|
|
3365
|
+
"""
|
|
3366
|
+
match: NotRequired[pulumi.Input['ConfigEntryServiceRouterRouteMatchArgsDict']]
|
|
3367
|
+
"""
|
|
3368
|
+
Describes a set of criteria that Consul compares incoming L7 traffic with.
|
|
3369
|
+
"""
|
|
3370
|
+
elif False:
|
|
3371
|
+
ConfigEntryServiceRouterRouteArgsDict: TypeAlias = Mapping[str, Any]
|
|
3372
|
+
|
|
2560
3373
|
@pulumi.input_type
|
|
2561
3374
|
class ConfigEntryServiceRouterRouteArgs:
|
|
2562
3375
|
def __init__(__self__, *,
|
|
@@ -2596,6 +3409,63 @@ class ConfigEntryServiceRouterRouteArgs:
|
|
|
2596
3409
|
pulumi.set(self, "match", value)
|
|
2597
3410
|
|
|
2598
3411
|
|
|
3412
|
+
if not MYPY:
|
|
3413
|
+
class ConfigEntryServiceRouterRouteDestinationArgsDict(TypedDict):
|
|
3414
|
+
idle_timeout: NotRequired[pulumi.Input[str]]
|
|
3415
|
+
"""
|
|
3416
|
+
Specifies the total amount of time permitted for the request stream to be idle.
|
|
3417
|
+
"""
|
|
3418
|
+
namespace: NotRequired[pulumi.Input[str]]
|
|
3419
|
+
"""
|
|
3420
|
+
Specifies the Consul namespace to resolve the service from instead of the current namespace.
|
|
3421
|
+
"""
|
|
3422
|
+
num_retries: NotRequired[pulumi.Input[int]]
|
|
3423
|
+
"""
|
|
3424
|
+
Specifies the number of times to retry the request when a retry condition occurs.
|
|
3425
|
+
"""
|
|
3426
|
+
partition: NotRequired[pulumi.Input[str]]
|
|
3427
|
+
"""
|
|
3428
|
+
Specifies the Consul admin partition to resolve the service from instead of the current partition.
|
|
3429
|
+
"""
|
|
3430
|
+
prefix_rewrite: NotRequired[pulumi.Input[str]]
|
|
3431
|
+
"""
|
|
3432
|
+
Specifies rewrites to the HTTP request path before proxying it to its final destination.
|
|
3433
|
+
"""
|
|
3434
|
+
request_headers: NotRequired[pulumi.Input['ConfigEntryServiceRouterRouteDestinationRequestHeadersArgsDict']]
|
|
3435
|
+
"""
|
|
3436
|
+
Specifies a set of HTTP-specific header modification rules applied to requests routed with the service router.
|
|
3437
|
+
"""
|
|
3438
|
+
request_timeout: NotRequired[pulumi.Input[str]]
|
|
3439
|
+
"""
|
|
3440
|
+
Specifies the total amount of time permitted for the entire downstream request to be processed, including retry attempts.
|
|
3441
|
+
"""
|
|
3442
|
+
response_headers: NotRequired[pulumi.Input['ConfigEntryServiceRouterRouteDestinationResponseHeadersArgsDict']]
|
|
3443
|
+
"""
|
|
3444
|
+
Specifies a set of HTTP-specific header modification rules applied to responses routed with the service router.
|
|
3445
|
+
"""
|
|
3446
|
+
retry_on_connect_failure: NotRequired[pulumi.Input[bool]]
|
|
3447
|
+
"""
|
|
3448
|
+
Specifies that connection failure errors that trigger a retry request.
|
|
3449
|
+
"""
|
|
3450
|
+
retry_on_status_codes: NotRequired[pulumi.Input[Sequence[pulumi.Input[int]]]]
|
|
3451
|
+
"""
|
|
3452
|
+
Specifies a list of integers for HTTP response status codes that trigger a retry request.
|
|
3453
|
+
"""
|
|
3454
|
+
retry_ons: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
3455
|
+
"""
|
|
3456
|
+
Specifies a list of conditions for Consul to retry requests based on the response from an upstream service.
|
|
3457
|
+
"""
|
|
3458
|
+
service: NotRequired[pulumi.Input[str]]
|
|
3459
|
+
"""
|
|
3460
|
+
Specifies the name of the service to resolve.
|
|
3461
|
+
"""
|
|
3462
|
+
service_subset: NotRequired[pulumi.Input[str]]
|
|
3463
|
+
"""
|
|
3464
|
+
Specifies a named subset of the given service to resolve instead of the one defined as that service's `default_subset` in the service resolver configuration entry.
|
|
3465
|
+
"""
|
|
3466
|
+
elif False:
|
|
3467
|
+
ConfigEntryServiceRouterRouteDestinationArgsDict: TypeAlias = Mapping[str, Any]
|
|
3468
|
+
|
|
2599
3469
|
@pulumi.input_type
|
|
2600
3470
|
class ConfigEntryServiceRouterRouteDestinationArgs:
|
|
2601
3471
|
def __init__(__self__, *,
|
|
@@ -2811,6 +3681,23 @@ class ConfigEntryServiceRouterRouteDestinationArgs:
|
|
|
2811
3681
|
pulumi.set(self, "service_subset", value)
|
|
2812
3682
|
|
|
2813
3683
|
|
|
3684
|
+
if not MYPY:
|
|
3685
|
+
class ConfigEntryServiceRouterRouteDestinationRequestHeadersArgsDict(TypedDict):
|
|
3686
|
+
add: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[str]]]]
|
|
3687
|
+
"""
|
|
3688
|
+
Defines a set of key-value pairs to add to the header. Use header names as the keys.
|
|
3689
|
+
"""
|
|
3690
|
+
removes: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
3691
|
+
"""
|
|
3692
|
+
Defines a list of headers to remove.
|
|
3693
|
+
"""
|
|
3694
|
+
set: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[str]]]]
|
|
3695
|
+
"""
|
|
3696
|
+
Defines a set of key-value pairs to add to the request header or to replace existing header values with.
|
|
3697
|
+
"""
|
|
3698
|
+
elif False:
|
|
3699
|
+
ConfigEntryServiceRouterRouteDestinationRequestHeadersArgsDict: TypeAlias = Mapping[str, Any]
|
|
3700
|
+
|
|
2814
3701
|
@pulumi.input_type
|
|
2815
3702
|
class ConfigEntryServiceRouterRouteDestinationRequestHeadersArgs:
|
|
2816
3703
|
def __init__(__self__, *,
|
|
@@ -2866,6 +3753,23 @@ class ConfigEntryServiceRouterRouteDestinationRequestHeadersArgs:
|
|
|
2866
3753
|
pulumi.set(self, "set", value)
|
|
2867
3754
|
|
|
2868
3755
|
|
|
3756
|
+
if not MYPY:
|
|
3757
|
+
class ConfigEntryServiceRouterRouteDestinationResponseHeadersArgsDict(TypedDict):
|
|
3758
|
+
add: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[str]]]]
|
|
3759
|
+
"""
|
|
3760
|
+
Defines a set of key-value pairs to add to the header. Use header names as the keys
|
|
3761
|
+
"""
|
|
3762
|
+
removes: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
3763
|
+
"""
|
|
3764
|
+
Defines a list of headers to remove.
|
|
3765
|
+
"""
|
|
3766
|
+
set: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[str]]]]
|
|
3767
|
+
"""
|
|
3768
|
+
Defines a set of key-value pairs to add to the response header or to replace existing header values with
|
|
3769
|
+
"""
|
|
3770
|
+
elif False:
|
|
3771
|
+
ConfigEntryServiceRouterRouteDestinationResponseHeadersArgsDict: TypeAlias = Mapping[str, Any]
|
|
3772
|
+
|
|
2869
3773
|
@pulumi.input_type
|
|
2870
3774
|
class ConfigEntryServiceRouterRouteDestinationResponseHeadersArgs:
|
|
2871
3775
|
def __init__(__self__, *,
|
|
@@ -2873,9 +3777,9 @@ class ConfigEntryServiceRouterRouteDestinationResponseHeadersArgs:
|
|
|
2873
3777
|
removes: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
2874
3778
|
set: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None):
|
|
2875
3779
|
"""
|
|
2876
|
-
:param pulumi.Input[Mapping[str, pulumi.Input[str]]] add: Defines a set of key-value pairs to add to the header. Use header names as the keys
|
|
3780
|
+
:param pulumi.Input[Mapping[str, pulumi.Input[str]]] add: Defines a set of key-value pairs to add to the header. Use header names as the keys
|
|
2877
3781
|
:param pulumi.Input[Sequence[pulumi.Input[str]]] removes: Defines a list of headers to remove.
|
|
2878
|
-
:param pulumi.Input[Mapping[str, pulumi.Input[str]]] set: Defines a set of key-value pairs to add to the
|
|
3782
|
+
:param pulumi.Input[Mapping[str, pulumi.Input[str]]] set: Defines a set of key-value pairs to add to the response header or to replace existing header values with
|
|
2879
3783
|
"""
|
|
2880
3784
|
if add is not None:
|
|
2881
3785
|
pulumi.set(__self__, "add", add)
|
|
@@ -2888,7 +3792,7 @@ class ConfigEntryServiceRouterRouteDestinationResponseHeadersArgs:
|
|
|
2888
3792
|
@pulumi.getter
|
|
2889
3793
|
def add(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
|
|
2890
3794
|
"""
|
|
2891
|
-
Defines a set of key-value pairs to add to the header. Use header names as the keys
|
|
3795
|
+
Defines a set of key-value pairs to add to the header. Use header names as the keys
|
|
2892
3796
|
"""
|
|
2893
3797
|
return pulumi.get(self, "add")
|
|
2894
3798
|
|
|
@@ -2912,7 +3816,7 @@ class ConfigEntryServiceRouterRouteDestinationResponseHeadersArgs:
|
|
|
2912
3816
|
@pulumi.getter
|
|
2913
3817
|
def set(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
|
|
2914
3818
|
"""
|
|
2915
|
-
Defines a set of key-value pairs to add to the
|
|
3819
|
+
Defines a set of key-value pairs to add to the response header or to replace existing header values with
|
|
2916
3820
|
"""
|
|
2917
3821
|
return pulumi.get(self, "set")
|
|
2918
3822
|
|
|
@@ -2921,6 +3825,15 @@ class ConfigEntryServiceRouterRouteDestinationResponseHeadersArgs:
|
|
|
2921
3825
|
pulumi.set(self, "set", value)
|
|
2922
3826
|
|
|
2923
3827
|
|
|
3828
|
+
if not MYPY:
|
|
3829
|
+
class ConfigEntryServiceRouterRouteMatchArgsDict(TypedDict):
|
|
3830
|
+
http: NotRequired[pulumi.Input['ConfigEntryServiceRouterRouteMatchHttpArgsDict']]
|
|
3831
|
+
"""
|
|
3832
|
+
Specifies a set of HTTP criteria used to evaluate incoming L7 traffic for matches.
|
|
3833
|
+
"""
|
|
3834
|
+
elif False:
|
|
3835
|
+
ConfigEntryServiceRouterRouteMatchArgsDict: TypeAlias = Mapping[str, Any]
|
|
3836
|
+
|
|
2924
3837
|
@pulumi.input_type
|
|
2925
3838
|
class ConfigEntryServiceRouterRouteMatchArgs:
|
|
2926
3839
|
def __init__(__self__, *,
|
|
@@ -2944,6 +3857,35 @@ class ConfigEntryServiceRouterRouteMatchArgs:
|
|
|
2944
3857
|
pulumi.set(self, "http", value)
|
|
2945
3858
|
|
|
2946
3859
|
|
|
3860
|
+
if not MYPY:
|
|
3861
|
+
class ConfigEntryServiceRouterRouteMatchHttpArgsDict(TypedDict):
|
|
3862
|
+
headers: NotRequired[pulumi.Input[Sequence[pulumi.Input['ConfigEntryServiceRouterRouteMatchHttpHeaderArgsDict']]]]
|
|
3863
|
+
"""
|
|
3864
|
+
Specifies information in the HTTP request header to match with.
|
|
3865
|
+
"""
|
|
3866
|
+
methods: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
3867
|
+
"""
|
|
3868
|
+
Specifies HTTP methods that the match applies to.
|
|
3869
|
+
"""
|
|
3870
|
+
path_exact: NotRequired[pulumi.Input[str]]
|
|
3871
|
+
"""
|
|
3872
|
+
Specifies the exact path to match on the HTTP request path.
|
|
3873
|
+
"""
|
|
3874
|
+
path_prefix: NotRequired[pulumi.Input[str]]
|
|
3875
|
+
"""
|
|
3876
|
+
Specifies the path prefix to match on the HTTP request path.
|
|
3877
|
+
"""
|
|
3878
|
+
path_regex: NotRequired[pulumi.Input[str]]
|
|
3879
|
+
"""
|
|
3880
|
+
Specifies a regular expression to match on the HTTP request path.
|
|
3881
|
+
"""
|
|
3882
|
+
query_params: NotRequired[pulumi.Input[Sequence[pulumi.Input['ConfigEntryServiceRouterRouteMatchHttpQueryParamArgsDict']]]]
|
|
3883
|
+
"""
|
|
3884
|
+
Specifies information to match to on HTTP query parameters.
|
|
3885
|
+
"""
|
|
3886
|
+
elif False:
|
|
3887
|
+
ConfigEntryServiceRouterRouteMatchHttpArgsDict: TypeAlias = Mapping[str, Any]
|
|
3888
|
+
|
|
2947
3889
|
@pulumi.input_type
|
|
2948
3890
|
class ConfigEntryServiceRouterRouteMatchHttpArgs:
|
|
2949
3891
|
def __init__(__self__, *,
|
|
@@ -3047,6 +3989,39 @@ class ConfigEntryServiceRouterRouteMatchHttpArgs:
|
|
|
3047
3989
|
pulumi.set(self, "query_params", value)
|
|
3048
3990
|
|
|
3049
3991
|
|
|
3992
|
+
if not MYPY:
|
|
3993
|
+
class ConfigEntryServiceRouterRouteMatchHttpHeaderArgsDict(TypedDict):
|
|
3994
|
+
exact: NotRequired[pulumi.Input[str]]
|
|
3995
|
+
"""
|
|
3996
|
+
Specifies that a request matches when the header with the given name is this exact value.
|
|
3997
|
+
"""
|
|
3998
|
+
invert: NotRequired[pulumi.Input[bool]]
|
|
3999
|
+
"""
|
|
4000
|
+
Specifies that the logic for the HTTP header match should be inverted.
|
|
4001
|
+
"""
|
|
4002
|
+
name: NotRequired[pulumi.Input[str]]
|
|
4003
|
+
"""
|
|
4004
|
+
Specifies the name of the HTTP header to match.
|
|
4005
|
+
"""
|
|
4006
|
+
prefix: NotRequired[pulumi.Input[str]]
|
|
4007
|
+
"""
|
|
4008
|
+
Specifies that a request matches when the header with the given name has this prefix.
|
|
4009
|
+
"""
|
|
4010
|
+
present: NotRequired[pulumi.Input[bool]]
|
|
4011
|
+
"""
|
|
4012
|
+
Specifies that a request matches when the value in the `name` argument is present anywhere in the HTTP header.
|
|
4013
|
+
"""
|
|
4014
|
+
regex: NotRequired[pulumi.Input[str]]
|
|
4015
|
+
"""
|
|
4016
|
+
Specifies that a request matches when the header with the given name matches this regular expression.
|
|
4017
|
+
"""
|
|
4018
|
+
suffix: NotRequired[pulumi.Input[str]]
|
|
4019
|
+
"""
|
|
4020
|
+
Specifies that a request matches when the header with the given name has this suffix.
|
|
4021
|
+
"""
|
|
4022
|
+
elif False:
|
|
4023
|
+
ConfigEntryServiceRouterRouteMatchHttpHeaderArgsDict: TypeAlias = Mapping[str, Any]
|
|
4024
|
+
|
|
3050
4025
|
@pulumi.input_type
|
|
3051
4026
|
class ConfigEntryServiceRouterRouteMatchHttpHeaderArgs:
|
|
3052
4027
|
def __init__(__self__, *,
|
|
@@ -3166,6 +4141,27 @@ class ConfigEntryServiceRouterRouteMatchHttpHeaderArgs:
|
|
|
3166
4141
|
pulumi.set(self, "suffix", value)
|
|
3167
4142
|
|
|
3168
4143
|
|
|
4144
|
+
if not MYPY:
|
|
4145
|
+
class ConfigEntryServiceRouterRouteMatchHttpQueryParamArgsDict(TypedDict):
|
|
4146
|
+
exact: NotRequired[pulumi.Input[str]]
|
|
4147
|
+
"""
|
|
4148
|
+
Specifies that a request matches when the query parameter with the given name is this exact value.
|
|
4149
|
+
"""
|
|
4150
|
+
name: NotRequired[pulumi.Input[str]]
|
|
4151
|
+
"""
|
|
4152
|
+
Specifies the name of the HTTP query parameter to match.
|
|
4153
|
+
"""
|
|
4154
|
+
present: NotRequired[pulumi.Input[bool]]
|
|
4155
|
+
"""
|
|
4156
|
+
Specifies that a request matches when the value in the `name` argument is present anywhere in the HTTP query parameter.
|
|
4157
|
+
"""
|
|
4158
|
+
regex: NotRequired[pulumi.Input[str]]
|
|
4159
|
+
"""
|
|
4160
|
+
Specifies that a request matches when the query parameter with the given name matches this regular expression.
|
|
4161
|
+
"""
|
|
4162
|
+
elif False:
|
|
4163
|
+
ConfigEntryServiceRouterRouteMatchHttpQueryParamArgsDict: TypeAlias = Mapping[str, Any]
|
|
4164
|
+
|
|
3169
4165
|
@pulumi.input_type
|
|
3170
4166
|
class ConfigEntryServiceRouterRouteMatchHttpQueryParamArgs:
|
|
3171
4167
|
def __init__(__self__, *,
|
|
@@ -3174,10 +4170,10 @@ class ConfigEntryServiceRouterRouteMatchHttpQueryParamArgs:
|
|
|
3174
4170
|
present: Optional[pulumi.Input[bool]] = None,
|
|
3175
4171
|
regex: Optional[pulumi.Input[str]] = None):
|
|
3176
4172
|
"""
|
|
3177
|
-
:param pulumi.Input[str] exact: Specifies that a request matches when the
|
|
3178
|
-
:param pulumi.Input[str] name: Specifies the name of the HTTP
|
|
3179
|
-
:param pulumi.Input[bool] present: Specifies that a request matches when the value in the `name` argument is present anywhere in the HTTP
|
|
3180
|
-
:param pulumi.Input[str] regex: Specifies that a request matches when the
|
|
4173
|
+
:param pulumi.Input[str] exact: Specifies that a request matches when the query parameter with the given name is this exact value.
|
|
4174
|
+
:param pulumi.Input[str] name: Specifies the name of the HTTP query parameter to match.
|
|
4175
|
+
:param pulumi.Input[bool] present: Specifies that a request matches when the value in the `name` argument is present anywhere in the HTTP query parameter.
|
|
4176
|
+
:param pulumi.Input[str] regex: Specifies that a request matches when the query parameter with the given name matches this regular expression.
|
|
3181
4177
|
"""
|
|
3182
4178
|
if exact is not None:
|
|
3183
4179
|
pulumi.set(__self__, "exact", exact)
|
|
@@ -3192,7 +4188,7 @@ class ConfigEntryServiceRouterRouteMatchHttpQueryParamArgs:
|
|
|
3192
4188
|
@pulumi.getter
|
|
3193
4189
|
def exact(self) -> Optional[pulumi.Input[str]]:
|
|
3194
4190
|
"""
|
|
3195
|
-
Specifies that a request matches when the
|
|
4191
|
+
Specifies that a request matches when the query parameter with the given name is this exact value.
|
|
3196
4192
|
"""
|
|
3197
4193
|
return pulumi.get(self, "exact")
|
|
3198
4194
|
|
|
@@ -3204,7 +4200,7 @@ class ConfigEntryServiceRouterRouteMatchHttpQueryParamArgs:
|
|
|
3204
4200
|
@pulumi.getter
|
|
3205
4201
|
def name(self) -> Optional[pulumi.Input[str]]:
|
|
3206
4202
|
"""
|
|
3207
|
-
Specifies the name of the HTTP
|
|
4203
|
+
Specifies the name of the HTTP query parameter to match.
|
|
3208
4204
|
"""
|
|
3209
4205
|
return pulumi.get(self, "name")
|
|
3210
4206
|
|
|
@@ -3216,7 +4212,7 @@ class ConfigEntryServiceRouterRouteMatchHttpQueryParamArgs:
|
|
|
3216
4212
|
@pulumi.getter
|
|
3217
4213
|
def present(self) -> Optional[pulumi.Input[bool]]:
|
|
3218
4214
|
"""
|
|
3219
|
-
Specifies that a request matches when the value in the `name` argument is present anywhere in the HTTP
|
|
4215
|
+
Specifies that a request matches when the value in the `name` argument is present anywhere in the HTTP query parameter.
|
|
3220
4216
|
"""
|
|
3221
4217
|
return pulumi.get(self, "present")
|
|
3222
4218
|
|
|
@@ -3228,7 +4224,7 @@ class ConfigEntryServiceRouterRouteMatchHttpQueryParamArgs:
|
|
|
3228
4224
|
@pulumi.getter
|
|
3229
4225
|
def regex(self) -> Optional[pulumi.Input[str]]:
|
|
3230
4226
|
"""
|
|
3231
|
-
Specifies that a request matches when the
|
|
4227
|
+
Specifies that a request matches when the query parameter with the given name matches this regular expression.
|
|
3232
4228
|
"""
|
|
3233
4229
|
return pulumi.get(self, "regex")
|
|
3234
4230
|
|
|
@@ -3237,6 +4233,39 @@ class ConfigEntryServiceRouterRouteMatchHttpQueryParamArgs:
|
|
|
3237
4233
|
pulumi.set(self, "regex", value)
|
|
3238
4234
|
|
|
3239
4235
|
|
|
4236
|
+
if not MYPY:
|
|
4237
|
+
class ConfigEntryServiceSplitterSplitArgsDict(TypedDict):
|
|
4238
|
+
service: pulumi.Input[str]
|
|
4239
|
+
"""
|
|
4240
|
+
Specifies the name of the service to resolve.
|
|
4241
|
+
"""
|
|
4242
|
+
weight: pulumi.Input[float]
|
|
4243
|
+
"""
|
|
4244
|
+
Specifies the percentage of traffic sent to the set of service instances specified in the `service` field. Each weight must be a floating integer between `0` and `100`. The smallest representable value is `.01`. The sum of weights across all splits must add up to `100`.
|
|
4245
|
+
"""
|
|
4246
|
+
namespace: NotRequired[pulumi.Input[str]]
|
|
4247
|
+
"""
|
|
4248
|
+
Specifies the namespace to use in the FQDN when resolving the service.
|
|
4249
|
+
"""
|
|
4250
|
+
partition: NotRequired[pulumi.Input[str]]
|
|
4251
|
+
"""
|
|
4252
|
+
Specifies the admin partition to use in the FQDN when resolving the service.
|
|
4253
|
+
"""
|
|
4254
|
+
request_headers: NotRequired[pulumi.Input['ConfigEntryServiceSplitterSplitRequestHeadersArgsDict']]
|
|
4255
|
+
"""
|
|
4256
|
+
Specifies a set of HTTP-specific header modification rules applied to requests routed with the service split. You cannot configure request headers if the listener protocol is set to `tcp`.
|
|
4257
|
+
"""
|
|
4258
|
+
response_headers: NotRequired[pulumi.Input['ConfigEntryServiceSplitterSplitResponseHeadersArgsDict']]
|
|
4259
|
+
"""
|
|
4260
|
+
Specifies a set of HTTP-specific header modification rules applied to responses routed with the service split. You cannot configure request headers if the listener protocol is set to `tcp`.
|
|
4261
|
+
"""
|
|
4262
|
+
service_subset: NotRequired[pulumi.Input[str]]
|
|
4263
|
+
"""
|
|
4264
|
+
Specifies a subset of the service to resolve. A service subset assigns a name to a specific subset of discoverable service instances within a datacenter, such as `version2` or `canary`. All services have an unnamed default subset that returns all healthy instances.
|
|
4265
|
+
"""
|
|
4266
|
+
elif False:
|
|
4267
|
+
ConfigEntryServiceSplitterSplitArgsDict: TypeAlias = Mapping[str, Any]
|
|
4268
|
+
|
|
3240
4269
|
@pulumi.input_type
|
|
3241
4270
|
class ConfigEntryServiceSplitterSplitArgs:
|
|
3242
4271
|
def __init__(__self__, *,
|
|
@@ -3354,6 +4383,23 @@ class ConfigEntryServiceSplitterSplitArgs:
|
|
|
3354
4383
|
pulumi.set(self, "service_subset", value)
|
|
3355
4384
|
|
|
3356
4385
|
|
|
4386
|
+
if not MYPY:
|
|
4387
|
+
class ConfigEntryServiceSplitterSplitRequestHeadersArgsDict(TypedDict):
|
|
4388
|
+
add: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[str]]]]
|
|
4389
|
+
"""
|
|
4390
|
+
Map of one or more key-value pairs. Defines a set of key-value pairs to add to the header. Use header names as the keys. Header names are not case-sensitive. If header values with the same name already exist, the value is appended and Consul applies both headers.
|
|
4391
|
+
"""
|
|
4392
|
+
removes: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
4393
|
+
"""
|
|
4394
|
+
Defines an list of headers to remove. Consul removes only headers containing exact matches. Header names are not case-sensitive.
|
|
4395
|
+
"""
|
|
4396
|
+
set: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[str]]]]
|
|
4397
|
+
"""
|
|
4398
|
+
Map of one or more key-value pairs. Defines a set of key-value pairs to add to the request header or to replace existing header values with. Use header names as the keys. Header names are not case-sensitive. If header values with the same names already exist, Consul replaces the header values.
|
|
4399
|
+
"""
|
|
4400
|
+
elif False:
|
|
4401
|
+
ConfigEntryServiceSplitterSplitRequestHeadersArgsDict: TypeAlias = Mapping[str, Any]
|
|
4402
|
+
|
|
3357
4403
|
@pulumi.input_type
|
|
3358
4404
|
class ConfigEntryServiceSplitterSplitRequestHeadersArgs:
|
|
3359
4405
|
def __init__(__self__, *,
|
|
@@ -3409,6 +4455,23 @@ class ConfigEntryServiceSplitterSplitRequestHeadersArgs:
|
|
|
3409
4455
|
pulumi.set(self, "set", value)
|
|
3410
4456
|
|
|
3411
4457
|
|
|
4458
|
+
if not MYPY:
|
|
4459
|
+
class ConfigEntryServiceSplitterSplitResponseHeadersArgsDict(TypedDict):
|
|
4460
|
+
add: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[str]]]]
|
|
4461
|
+
"""
|
|
4462
|
+
Map of one or more key-value pairs. Defines a set of key-value pairs to add to the header. Use header names as the keys. Header names are not case-sensitive. If header values with the same name already exist, the value is appended and Consul applies both headers.
|
|
4463
|
+
"""
|
|
4464
|
+
removes: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
4465
|
+
"""
|
|
4466
|
+
Defines an list of headers to remove. Consul removes only headers containing exact matches. Header names are not case-sensitive.
|
|
4467
|
+
"""
|
|
4468
|
+
set: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[str]]]]
|
|
4469
|
+
"""
|
|
4470
|
+
Map of one or more key-value pairs. Defines a set of key-value pairs to add to the request header or to replace existing header values with. Use header names as the keys. Header names are not case-sensitive. If header values with the same names already exist, Consul replaces the header values.
|
|
4471
|
+
"""
|
|
4472
|
+
elif False:
|
|
4473
|
+
ConfigEntryServiceSplitterSplitResponseHeadersArgsDict: TypeAlias = Mapping[str, Any]
|
|
4474
|
+
|
|
3412
4475
|
@pulumi.input_type
|
|
3413
4476
|
class ConfigEntryServiceSplitterSplitResponseHeadersArgs:
|
|
3414
4477
|
def __init__(__self__, *,
|
|
@@ -3464,6 +4527,25 @@ class ConfigEntryServiceSplitterSplitResponseHeadersArgs:
|
|
|
3464
4527
|
pulumi.set(self, "set", value)
|
|
3465
4528
|
|
|
3466
4529
|
|
|
4530
|
+
if not MYPY:
|
|
4531
|
+
class KeyPrefixSubkeyCollectionArgsDict(TypedDict):
|
|
4532
|
+
path: pulumi.Input[str]
|
|
4533
|
+
"""
|
|
4534
|
+
This is the path (which will be appended to the given
|
|
4535
|
+
`path_prefix`) in Consul that should be written to.
|
|
4536
|
+
"""
|
|
4537
|
+
value: pulumi.Input[str]
|
|
4538
|
+
"""
|
|
4539
|
+
The value to write to the given path.
|
|
4540
|
+
"""
|
|
4541
|
+
flags: NotRequired[pulumi.Input[int]]
|
|
4542
|
+
"""
|
|
4543
|
+
An [unsigned integer value](https://www.consul.io/api/kv.html#flags-1)
|
|
4544
|
+
to attach to the key (defaults to 0).
|
|
4545
|
+
"""
|
|
4546
|
+
elif False:
|
|
4547
|
+
KeyPrefixSubkeyCollectionArgsDict: TypeAlias = Mapping[str, Any]
|
|
4548
|
+
|
|
3467
4549
|
@pulumi.input_type
|
|
3468
4550
|
class KeyPrefixSubkeyCollectionArgs:
|
|
3469
4551
|
def __init__(__self__, *,
|
|
@@ -3521,6 +4603,33 @@ class KeyPrefixSubkeyCollectionArgs:
|
|
|
3521
4603
|
pulumi.set(self, "flags", value)
|
|
3522
4604
|
|
|
3523
4605
|
|
|
4606
|
+
if not MYPY:
|
|
4607
|
+
class KeysKeyArgsDict(TypedDict):
|
|
4608
|
+
path: pulumi.Input[str]
|
|
4609
|
+
"""
|
|
4610
|
+
This is the path in Consul that should be written to.
|
|
4611
|
+
"""
|
|
4612
|
+
default: NotRequired[pulumi.Input[str]]
|
|
4613
|
+
delete: NotRequired[pulumi.Input[bool]]
|
|
4614
|
+
"""
|
|
4615
|
+
If true, then the key will be deleted when
|
|
4616
|
+
either its configuration block is removed from the configuration or
|
|
4617
|
+
the entire resource is destroyed. Otherwise, it will be left in Consul.
|
|
4618
|
+
Defaults to false.
|
|
4619
|
+
"""
|
|
4620
|
+
flags: NotRequired[pulumi.Input[int]]
|
|
4621
|
+
"""
|
|
4622
|
+
An [unsigned integer value](https://www.consul.io/api/kv.html#flags-1)
|
|
4623
|
+
to attach to the key (defaults to 0).
|
|
4624
|
+
"""
|
|
4625
|
+
name: NotRequired[pulumi.Input[str]]
|
|
4626
|
+
value: NotRequired[pulumi.Input[str]]
|
|
4627
|
+
"""
|
|
4628
|
+
The value to write to the given path.
|
|
4629
|
+
"""
|
|
4630
|
+
elif False:
|
|
4631
|
+
KeysKeyArgsDict: TypeAlias = Mapping[str, Any]
|
|
4632
|
+
|
|
3524
4633
|
@pulumi.input_type
|
|
3525
4634
|
class KeysKeyArgs:
|
|
3526
4635
|
def __init__(__self__, *,
|
|
@@ -3548,8 +4657,8 @@ class KeysKeyArgs:
|
|
|
3548
4657
|
if flags is not None:
|
|
3549
4658
|
pulumi.set(__self__, "flags", flags)
|
|
3550
4659
|
if name is not None:
|
|
3551
|
-
warnings.warn("""Using
|
|
3552
|
-
pulumi.log.warn("""name is deprecated: Using
|
|
4660
|
+
warnings.warn("""Using Keys resource to *read* is deprecated; please use Keys data source instead""", DeprecationWarning)
|
|
4661
|
+
pulumi.log.warn("""name is deprecated: Using Keys resource to *read* is deprecated; please use Keys data source instead""")
|
|
3553
4662
|
if name is not None:
|
|
3554
4663
|
pulumi.set(__self__, "name", name)
|
|
3555
4664
|
if value is not None:
|
|
@@ -3606,10 +4715,8 @@ class KeysKeyArgs:
|
|
|
3606
4715
|
|
|
3607
4716
|
@property
|
|
3608
4717
|
@pulumi.getter
|
|
4718
|
+
@_utilities.deprecated("""Using Keys resource to *read* is deprecated; please use Keys data source instead""")
|
|
3609
4719
|
def name(self) -> Optional[pulumi.Input[str]]:
|
|
3610
|
-
warnings.warn("""Using consul_keys resource to *read* is deprecated; please use consul_keys data source instead""", DeprecationWarning)
|
|
3611
|
-
pulumi.log.warn("""name is deprecated: Using consul_keys resource to *read* is deprecated; please use consul_keys data source instead""")
|
|
3612
|
-
|
|
3613
4720
|
return pulumi.get(self, "name")
|
|
3614
4721
|
|
|
3615
4722
|
@name.setter
|
|
@@ -3629,6 +4736,15 @@ class KeysKeyArgs:
|
|
|
3629
4736
|
pulumi.set(self, "value", value)
|
|
3630
4737
|
|
|
3631
4738
|
|
|
4739
|
+
if not MYPY:
|
|
4740
|
+
class PreparedQueryDnsArgsDict(TypedDict):
|
|
4741
|
+
ttl: NotRequired[pulumi.Input[str]]
|
|
4742
|
+
"""
|
|
4743
|
+
The TTL to send when returning DNS results.
|
|
4744
|
+
"""
|
|
4745
|
+
elif False:
|
|
4746
|
+
PreparedQueryDnsArgsDict: TypeAlias = Mapping[str, Any]
|
|
4747
|
+
|
|
3632
4748
|
@pulumi.input_type
|
|
3633
4749
|
class PreparedQueryDnsArgs:
|
|
3634
4750
|
def __init__(__self__, *,
|
|
@@ -3652,6 +4768,23 @@ class PreparedQueryDnsArgs:
|
|
|
3652
4768
|
pulumi.set(self, "ttl", value)
|
|
3653
4769
|
|
|
3654
4770
|
|
|
4771
|
+
if not MYPY:
|
|
4772
|
+
class PreparedQueryFailoverArgsDict(TypedDict):
|
|
4773
|
+
datacenters: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
4774
|
+
"""
|
|
4775
|
+
Remote datacenters to return results from.
|
|
4776
|
+
"""
|
|
4777
|
+
nearest_n: NotRequired[pulumi.Input[int]]
|
|
4778
|
+
"""
|
|
4779
|
+
Return results from this many datacenters, sorted in ascending order of estimated RTT.
|
|
4780
|
+
"""
|
|
4781
|
+
targets: NotRequired[pulumi.Input[Sequence[pulumi.Input['PreparedQueryFailoverTargetArgsDict']]]]
|
|
4782
|
+
"""
|
|
4783
|
+
Specifies a sequential list of remote datacenters and cluster peers to failover to if there are no healthy service instances in the local datacenter. This option cannot be used with `nearest_n` or `datacenters`.
|
|
4784
|
+
"""
|
|
4785
|
+
elif False:
|
|
4786
|
+
PreparedQueryFailoverArgsDict: TypeAlias = Mapping[str, Any]
|
|
4787
|
+
|
|
3655
4788
|
@pulumi.input_type
|
|
3656
4789
|
class PreparedQueryFailoverArgs:
|
|
3657
4790
|
def __init__(__self__, *,
|
|
@@ -3707,6 +4840,19 @@ class PreparedQueryFailoverArgs:
|
|
|
3707
4840
|
pulumi.set(self, "targets", value)
|
|
3708
4841
|
|
|
3709
4842
|
|
|
4843
|
+
if not MYPY:
|
|
4844
|
+
class PreparedQueryFailoverTargetArgsDict(TypedDict):
|
|
4845
|
+
datacenter: NotRequired[pulumi.Input[str]]
|
|
4846
|
+
"""
|
|
4847
|
+
Specifies a WAN federated datacenter to forward the query to.
|
|
4848
|
+
"""
|
|
4849
|
+
peer: NotRequired[pulumi.Input[str]]
|
|
4850
|
+
"""
|
|
4851
|
+
Specifies a cluster peer to use for failover.
|
|
4852
|
+
"""
|
|
4853
|
+
elif False:
|
|
4854
|
+
PreparedQueryFailoverTargetArgsDict: TypeAlias = Mapping[str, Any]
|
|
4855
|
+
|
|
3710
4856
|
@pulumi.input_type
|
|
3711
4857
|
class PreparedQueryFailoverTargetArgs:
|
|
3712
4858
|
def __init__(__self__, *,
|
|
@@ -3746,6 +4892,23 @@ class PreparedQueryFailoverTargetArgs:
|
|
|
3746
4892
|
pulumi.set(self, "peer", value)
|
|
3747
4893
|
|
|
3748
4894
|
|
|
4895
|
+
if not MYPY:
|
|
4896
|
+
class PreparedQueryTemplateArgsDict(TypedDict):
|
|
4897
|
+
regexp: pulumi.Input[str]
|
|
4898
|
+
"""
|
|
4899
|
+
The regular expression to match with. When using `name_prefix_match`, this regex is applied against the query name.
|
|
4900
|
+
"""
|
|
4901
|
+
type: pulumi.Input[str]
|
|
4902
|
+
"""
|
|
4903
|
+
The type of template matching to perform. Currently only `name_prefix_match` is supported.
|
|
4904
|
+
"""
|
|
4905
|
+
remove_empty_tags: NotRequired[pulumi.Input[bool]]
|
|
4906
|
+
"""
|
|
4907
|
+
If set to true, will cause the tags list inside the service structure to be stripped of any empty strings.
|
|
4908
|
+
"""
|
|
4909
|
+
elif False:
|
|
4910
|
+
PreparedQueryTemplateArgsDict: TypeAlias = Mapping[str, Any]
|
|
4911
|
+
|
|
3749
4912
|
@pulumi.input_type
|
|
3750
4913
|
class PreparedQueryTemplateArgs:
|
|
3751
4914
|
def __init__(__self__, *,
|
|
@@ -3799,6 +4962,24 @@ class PreparedQueryTemplateArgs:
|
|
|
3799
4962
|
pulumi.set(self, "remove_empty_tags", value)
|
|
3800
4963
|
|
|
3801
4964
|
|
|
4965
|
+
if not MYPY:
|
|
4966
|
+
class ProviderAuthJwtArgsDict(TypedDict):
|
|
4967
|
+
auth_method: pulumi.Input[str]
|
|
4968
|
+
"""
|
|
4969
|
+
The name of the auth method to use for login.
|
|
4970
|
+
"""
|
|
4971
|
+
bearer_token: NotRequired[pulumi.Input[str]]
|
|
4972
|
+
"""
|
|
4973
|
+
The bearer token to present to the auth method during login for authentication purposes. For the Kubernetes auth method this is a [Service Account Token (JWT)](https://kubernetes.io/docs/reference/access-authn-authz/authentication/#service-account-tokens).
|
|
4974
|
+
"""
|
|
4975
|
+
meta: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[str]]]]
|
|
4976
|
+
"""
|
|
4977
|
+
Specifies arbitrary KV metadata linked to the token. Can be useful to track origins.
|
|
4978
|
+
"""
|
|
4979
|
+
use_terraform_cloud_workload_identity: NotRequired[pulumi.Input[bool]]
|
|
4980
|
+
elif False:
|
|
4981
|
+
ProviderAuthJwtArgsDict: TypeAlias = Mapping[str, Any]
|
|
4982
|
+
|
|
3802
4983
|
@pulumi.input_type
|
|
3803
4984
|
class ProviderAuthJwtArgs:
|
|
3804
4985
|
def __init__(__self__, *,
|
|
@@ -3865,6 +5046,19 @@ class ProviderAuthJwtArgs:
|
|
|
3865
5046
|
pulumi.set(self, "use_terraform_cloud_workload_identity", value)
|
|
3866
5047
|
|
|
3867
5048
|
|
|
5049
|
+
if not MYPY:
|
|
5050
|
+
class ProviderHeaderArgsDict(TypedDict):
|
|
5051
|
+
name: pulumi.Input[str]
|
|
5052
|
+
"""
|
|
5053
|
+
The name of the header.
|
|
5054
|
+
"""
|
|
5055
|
+
value: pulumi.Input[str]
|
|
5056
|
+
"""
|
|
5057
|
+
The value of the header.
|
|
5058
|
+
"""
|
|
5059
|
+
elif False:
|
|
5060
|
+
ProviderHeaderArgsDict: TypeAlias = Mapping[str, Any]
|
|
5061
|
+
|
|
3868
5062
|
@pulumi.input_type
|
|
3869
5063
|
class ProviderHeaderArgs:
|
|
3870
5064
|
def __init__(__self__, *,
|
|
@@ -3902,6 +5096,59 @@ class ProviderHeaderArgs:
|
|
|
3902
5096
|
pulumi.set(self, "value", value)
|
|
3903
5097
|
|
|
3904
5098
|
|
|
5099
|
+
if not MYPY:
|
|
5100
|
+
class ServiceCheckArgsDict(TypedDict):
|
|
5101
|
+
check_id: pulumi.Input[str]
|
|
5102
|
+
"""
|
|
5103
|
+
An ID, *unique per agent*.
|
|
5104
|
+
"""
|
|
5105
|
+
interval: pulumi.Input[str]
|
|
5106
|
+
"""
|
|
5107
|
+
The interval to wait between each health-check invocation.
|
|
5108
|
+
"""
|
|
5109
|
+
name: pulumi.Input[str]
|
|
5110
|
+
"""
|
|
5111
|
+
The name of the health-check.
|
|
5112
|
+
"""
|
|
5113
|
+
timeout: pulumi.Input[str]
|
|
5114
|
+
"""
|
|
5115
|
+
Specifies a timeout for outgoing connections in the case of a HTTP or TCP check.
|
|
5116
|
+
"""
|
|
5117
|
+
deregister_critical_service_after: NotRequired[pulumi.Input[str]]
|
|
5118
|
+
"""
|
|
5119
|
+
The time after which the service is automatically deregistered when in the `critical` state. Defaults to `30s`. Setting to `0` will disable.
|
|
5120
|
+
"""
|
|
5121
|
+
headers: NotRequired[pulumi.Input[Sequence[pulumi.Input['ServiceCheckHeaderArgsDict']]]]
|
|
5122
|
+
"""
|
|
5123
|
+
The headers to send for an HTTP check. The attributes of each header is given below.
|
|
5124
|
+
"""
|
|
5125
|
+
http: NotRequired[pulumi.Input[str]]
|
|
5126
|
+
"""
|
|
5127
|
+
The HTTP endpoint to call for an HTTP check.
|
|
5128
|
+
"""
|
|
5129
|
+
method: NotRequired[pulumi.Input[str]]
|
|
5130
|
+
"""
|
|
5131
|
+
The method to use for HTTP health-checks. Defaults to `GET`.
|
|
5132
|
+
"""
|
|
5133
|
+
notes: NotRequired[pulumi.Input[str]]
|
|
5134
|
+
"""
|
|
5135
|
+
An opaque field meant to hold human readable text.
|
|
5136
|
+
"""
|
|
5137
|
+
status: NotRequired[pulumi.Input[str]]
|
|
5138
|
+
"""
|
|
5139
|
+
The initial health-check status.
|
|
5140
|
+
"""
|
|
5141
|
+
tcp: NotRequired[pulumi.Input[str]]
|
|
5142
|
+
"""
|
|
5143
|
+
The TCP address and port to connect to for a TCP check.
|
|
5144
|
+
"""
|
|
5145
|
+
tls_skip_verify: NotRequired[pulumi.Input[bool]]
|
|
5146
|
+
"""
|
|
5147
|
+
Whether to deactivate certificate verification for HTTP health-checks. Defaults to `false`.
|
|
5148
|
+
"""
|
|
5149
|
+
elif False:
|
|
5150
|
+
ServiceCheckArgsDict: TypeAlias = Mapping[str, Any]
|
|
5151
|
+
|
|
3905
5152
|
@pulumi.input_type
|
|
3906
5153
|
class ServiceCheckArgs:
|
|
3907
5154
|
def __init__(__self__, *,
|
|
@@ -3922,7 +5169,7 @@ class ServiceCheckArgs:
|
|
|
3922
5169
|
:param pulumi.Input[str] interval: The interval to wait between each health-check invocation.
|
|
3923
5170
|
:param pulumi.Input[str] name: The name of the health-check.
|
|
3924
5171
|
:param pulumi.Input[str] timeout: Specifies a timeout for outgoing connections in the case of a HTTP or TCP check.
|
|
3925
|
-
:param pulumi.Input[str] deregister_critical_service_after: The time after which the service is automatically deregistered when in the `critical` state. Defaults to `30s`.
|
|
5172
|
+
:param pulumi.Input[str] deregister_critical_service_after: The time after which the service is automatically deregistered when in the `critical` state. Defaults to `30s`. Setting to `0` will disable.
|
|
3926
5173
|
:param pulumi.Input[Sequence[pulumi.Input['ServiceCheckHeaderArgs']]] headers: The headers to send for an HTTP check. The attributes of each header is given below.
|
|
3927
5174
|
:param pulumi.Input[str] http: The HTTP endpoint to call for an HTTP check.
|
|
3928
5175
|
:param pulumi.Input[str] method: The method to use for HTTP health-checks. Defaults to `GET`.
|
|
@@ -4004,7 +5251,7 @@ class ServiceCheckArgs:
|
|
|
4004
5251
|
@pulumi.getter(name="deregisterCriticalServiceAfter")
|
|
4005
5252
|
def deregister_critical_service_after(self) -> Optional[pulumi.Input[str]]:
|
|
4006
5253
|
"""
|
|
4007
|
-
The time after which the service is automatically deregistered when in the `critical` state. Defaults to `30s`.
|
|
5254
|
+
The time after which the service is automatically deregistered when in the `critical` state. Defaults to `30s`. Setting to `0` will disable.
|
|
4008
5255
|
"""
|
|
4009
5256
|
return pulumi.get(self, "deregister_critical_service_after")
|
|
4010
5257
|
|
|
@@ -4097,6 +5344,19 @@ class ServiceCheckArgs:
|
|
|
4097
5344
|
pulumi.set(self, "tls_skip_verify", value)
|
|
4098
5345
|
|
|
4099
5346
|
|
|
5347
|
+
if not MYPY:
|
|
5348
|
+
class ServiceCheckHeaderArgsDict(TypedDict):
|
|
5349
|
+
name: pulumi.Input[str]
|
|
5350
|
+
"""
|
|
5351
|
+
The name of the header.
|
|
5352
|
+
"""
|
|
5353
|
+
values: pulumi.Input[Sequence[pulumi.Input[str]]]
|
|
5354
|
+
"""
|
|
5355
|
+
The header's list of values.
|
|
5356
|
+
"""
|
|
5357
|
+
elif False:
|
|
5358
|
+
ServiceCheckHeaderArgsDict: TypeAlias = Mapping[str, Any]
|
|
5359
|
+
|
|
4100
5360
|
@pulumi.input_type
|
|
4101
5361
|
class ServiceCheckHeaderArgs:
|
|
4102
5362
|
def __init__(__self__, *,
|
|
@@ -4134,6 +5394,47 @@ class ServiceCheckHeaderArgs:
|
|
|
4134
5394
|
pulumi.set(self, "values", value)
|
|
4135
5395
|
|
|
4136
5396
|
|
|
5397
|
+
if not MYPY:
|
|
5398
|
+
class GetCatalogNodesQueryOptionArgsDict(TypedDict):
|
|
5399
|
+
allow_stale: NotRequired[bool]
|
|
5400
|
+
"""
|
|
5401
|
+
When `true`, the default, allow responses from
|
|
5402
|
+
Consul servers that are followers.
|
|
5403
|
+
"""
|
|
5404
|
+
datacenter: NotRequired[str]
|
|
5405
|
+
"""
|
|
5406
|
+
The Consul datacenter to query. Defaults to the
|
|
5407
|
+
same value found in `query_options` parameter specified below, or if that is
|
|
5408
|
+
empty, the `datacenter` value found in the Consul agent that this provider is
|
|
5409
|
+
configured to talk to then the datacenter in the provider setup.
|
|
5410
|
+
"""
|
|
5411
|
+
near: NotRequired[str]
|
|
5412
|
+
node_meta: NotRequired[Mapping[str, str]]
|
|
5413
|
+
partition: NotRequired[str]
|
|
5414
|
+
require_consistent: NotRequired[bool]
|
|
5415
|
+
"""
|
|
5416
|
+
When `true` force the client to perform a
|
|
5417
|
+
read on at least quorum servers and verify the result is the same. Defaults
|
|
5418
|
+
to `false`.
|
|
5419
|
+
"""
|
|
5420
|
+
token: NotRequired[str]
|
|
5421
|
+
"""
|
|
5422
|
+
Specify the Consul ACL token to use when performing the
|
|
5423
|
+
request. This defaults to the same API token configured by the `consul`
|
|
5424
|
+
provider but may be overridden if necessary.
|
|
5425
|
+
"""
|
|
5426
|
+
wait_index: NotRequired[int]
|
|
5427
|
+
"""
|
|
5428
|
+
Index number used to enable blocking queries.
|
|
5429
|
+
"""
|
|
5430
|
+
wait_time: NotRequired[str]
|
|
5431
|
+
"""
|
|
5432
|
+
Max time the client should wait for a blocking query
|
|
5433
|
+
to return.
|
|
5434
|
+
"""
|
|
5435
|
+
elif False:
|
|
5436
|
+
GetCatalogNodesQueryOptionArgsDict: TypeAlias = Mapping[str, Any]
|
|
5437
|
+
|
|
4137
5438
|
@pulumi.input_type
|
|
4138
5439
|
class GetCatalogNodesQueryOptionArgs:
|
|
4139
5440
|
def __init__(__self__, *,
|
|
@@ -4291,6 +5592,51 @@ class GetCatalogNodesQueryOptionArgs:
|
|
|
4291
5592
|
pulumi.set(self, "wait_time", value)
|
|
4292
5593
|
|
|
4293
5594
|
|
|
5595
|
+
if not MYPY:
|
|
5596
|
+
class GetCatalogServiceQueryOptionArgsDict(TypedDict):
|
|
5597
|
+
allow_stale: NotRequired[bool]
|
|
5598
|
+
"""
|
|
5599
|
+
When `true`, the default, allow responses from
|
|
5600
|
+
Consul servers that are followers.
|
|
5601
|
+
"""
|
|
5602
|
+
datacenter: NotRequired[str]
|
|
5603
|
+
"""
|
|
5604
|
+
The Consul datacenter to query. Defaults to the
|
|
5605
|
+
same value found in `query_options` parameter specified below, or if that is
|
|
5606
|
+
empty, the `datacenter` value found in the Consul agent that this provider is
|
|
5607
|
+
configured to talk to.
|
|
5608
|
+
"""
|
|
5609
|
+
namespace: NotRequired[str]
|
|
5610
|
+
"""
|
|
5611
|
+
The namespace to lookup the service.
|
|
5612
|
+
"""
|
|
5613
|
+
near: NotRequired[str]
|
|
5614
|
+
node_meta: NotRequired[Mapping[str, str]]
|
|
5615
|
+
partition: NotRequired[str]
|
|
5616
|
+
require_consistent: NotRequired[bool]
|
|
5617
|
+
"""
|
|
5618
|
+
When `true` force the client to perform a
|
|
5619
|
+
read on at least quorum servers and verify the result is the same. Defaults
|
|
5620
|
+
to `false`.
|
|
5621
|
+
"""
|
|
5622
|
+
token: NotRequired[str]
|
|
5623
|
+
"""
|
|
5624
|
+
Specify the Consul ACL token to use when performing the
|
|
5625
|
+
request. This defaults to the same API token configured by the `consul`
|
|
5626
|
+
provider but may be overridden if necessary.
|
|
5627
|
+
"""
|
|
5628
|
+
wait_index: NotRequired[int]
|
|
5629
|
+
"""
|
|
5630
|
+
Index number used to enable blocking queries.
|
|
5631
|
+
"""
|
|
5632
|
+
wait_time: NotRequired[str]
|
|
5633
|
+
"""
|
|
5634
|
+
Max time the client should wait for a blocking query
|
|
5635
|
+
to return.
|
|
5636
|
+
"""
|
|
5637
|
+
elif False:
|
|
5638
|
+
GetCatalogServiceQueryOptionArgsDict: TypeAlias = Mapping[str, Any]
|
|
5639
|
+
|
|
4294
5640
|
@pulumi.input_type
|
|
4295
5641
|
class GetCatalogServiceQueryOptionArgs:
|
|
4296
5642
|
def __init__(__self__, *,
|
|
@@ -4464,6 +5810,51 @@ class GetCatalogServiceQueryOptionArgs:
|
|
|
4464
5810
|
pulumi.set(self, "wait_time", value)
|
|
4465
5811
|
|
|
4466
5812
|
|
|
5813
|
+
if not MYPY:
|
|
5814
|
+
class GetCatalogServicesQueryOptionArgsDict(TypedDict):
|
|
5815
|
+
allow_stale: NotRequired[bool]
|
|
5816
|
+
"""
|
|
5817
|
+
When `true`, the default, allow responses from
|
|
5818
|
+
Consul servers that are followers.
|
|
5819
|
+
"""
|
|
5820
|
+
datacenter: NotRequired[str]
|
|
5821
|
+
"""
|
|
5822
|
+
The Consul datacenter to query. Defaults to the
|
|
5823
|
+
same value found in `query_options` parameter specified below, or if that is
|
|
5824
|
+
empty, the `datacenter` value found in the Consul agent that this provider is
|
|
5825
|
+
configured to talk to.
|
|
5826
|
+
"""
|
|
5827
|
+
namespace: NotRequired[str]
|
|
5828
|
+
"""
|
|
5829
|
+
The namespace to lookup the services.
|
|
5830
|
+
"""
|
|
5831
|
+
near: NotRequired[str]
|
|
5832
|
+
node_meta: NotRequired[Mapping[str, str]]
|
|
5833
|
+
partition: NotRequired[str]
|
|
5834
|
+
require_consistent: NotRequired[bool]
|
|
5835
|
+
"""
|
|
5836
|
+
When `true` force the client to perform a
|
|
5837
|
+
read on at least quorum servers and verify the result is the same. Defaults
|
|
5838
|
+
to `false`.
|
|
5839
|
+
"""
|
|
5840
|
+
token: NotRequired[str]
|
|
5841
|
+
"""
|
|
5842
|
+
Specify the Consul ACL token to use when performing the
|
|
5843
|
+
request. This defaults to the same API token configured by the `consul`
|
|
5844
|
+
provider but may be overridden if necessary.
|
|
5845
|
+
"""
|
|
5846
|
+
wait_index: NotRequired[int]
|
|
5847
|
+
"""
|
|
5848
|
+
Index number used to enable blocking queries.
|
|
5849
|
+
"""
|
|
5850
|
+
wait_time: NotRequired[str]
|
|
5851
|
+
"""
|
|
5852
|
+
Max time the client should wait for a blocking query
|
|
5853
|
+
to return.
|
|
5854
|
+
"""
|
|
5855
|
+
elif False:
|
|
5856
|
+
GetCatalogServicesQueryOptionArgsDict: TypeAlias = Mapping[str, Any]
|
|
5857
|
+
|
|
4467
5858
|
@pulumi.input_type
|
|
4468
5859
|
class GetCatalogServicesQueryOptionArgs:
|
|
4469
5860
|
def __init__(__self__, *,
|
|
@@ -4637,6 +6028,28 @@ class GetCatalogServicesQueryOptionArgs:
|
|
|
4637
6028
|
pulumi.set(self, "wait_time", value)
|
|
4638
6029
|
|
|
4639
6030
|
|
|
6031
|
+
if not MYPY:
|
|
6032
|
+
class GetKeyPrefixSubkeyCollectionArgsDict(TypedDict):
|
|
6033
|
+
name: str
|
|
6034
|
+
"""
|
|
6035
|
+
This is the name of the key. This value of the
|
|
6036
|
+
key is exposed as `var.<name>`. This is not the path of the subkey
|
|
6037
|
+
in Consul.
|
|
6038
|
+
"""
|
|
6039
|
+
path: str
|
|
6040
|
+
"""
|
|
6041
|
+
This is the subkey path in Consul (which will be appended
|
|
6042
|
+
to the given `path_prefix`) to construct the full key that will be used
|
|
6043
|
+
to read the value.
|
|
6044
|
+
"""
|
|
6045
|
+
default: NotRequired[str]
|
|
6046
|
+
"""
|
|
6047
|
+
This is the default value to set for `var.<name>`
|
|
6048
|
+
if the key does not exist in Consul. Defaults to an empty string.
|
|
6049
|
+
"""
|
|
6050
|
+
elif False:
|
|
6051
|
+
GetKeyPrefixSubkeyCollectionArgsDict: TypeAlias = Mapping[str, Any]
|
|
6052
|
+
|
|
4640
6053
|
@pulumi.input_type
|
|
4641
6054
|
class GetKeyPrefixSubkeyCollectionArgs:
|
|
4642
6055
|
def __init__(__self__, *,
|
|
@@ -4700,6 +6113,23 @@ class GetKeyPrefixSubkeyCollectionArgs:
|
|
|
4700
6113
|
pulumi.set(self, "default", value)
|
|
4701
6114
|
|
|
4702
6115
|
|
|
6116
|
+
if not MYPY:
|
|
6117
|
+
class GetKeysKeyArgsDict(TypedDict):
|
|
6118
|
+
name: str
|
|
6119
|
+
"""
|
|
6120
|
+
This is the name of the key. This value of the key is exposed as `var.<name>`. This is not the path of the key in Consul.
|
|
6121
|
+
"""
|
|
6122
|
+
path: str
|
|
6123
|
+
"""
|
|
6124
|
+
This is the path in Consul that should be read or written to.
|
|
6125
|
+
"""
|
|
6126
|
+
default: NotRequired[str]
|
|
6127
|
+
"""
|
|
6128
|
+
This is the default value to set for `var.<name>` if the key does not exist in Consul. Defaults to an empty string.
|
|
6129
|
+
"""
|
|
6130
|
+
elif False:
|
|
6131
|
+
GetKeysKeyArgsDict: TypeAlias = Mapping[str, Any]
|
|
6132
|
+
|
|
4703
6133
|
@pulumi.input_type
|
|
4704
6134
|
class GetKeysKeyArgs:
|
|
4705
6135
|
def __init__(__self__, *,
|
|
@@ -4753,6 +6183,47 @@ class GetKeysKeyArgs:
|
|
|
4753
6183
|
pulumi.set(self, "default", value)
|
|
4754
6184
|
|
|
4755
6185
|
|
|
6186
|
+
if not MYPY:
|
|
6187
|
+
class GetNodesQueryOptionArgsDict(TypedDict):
|
|
6188
|
+
allow_stale: NotRequired[bool]
|
|
6189
|
+
"""
|
|
6190
|
+
When `true`, the default, allow responses from
|
|
6191
|
+
Consul servers that are followers.
|
|
6192
|
+
"""
|
|
6193
|
+
datacenter: NotRequired[str]
|
|
6194
|
+
"""
|
|
6195
|
+
The Consul datacenter to query. Defaults to the
|
|
6196
|
+
same value found in `query_options` parameter specified below, or if that is
|
|
6197
|
+
empty, the `datacenter` value found in the Consul agent that this provider is
|
|
6198
|
+
configured to talk to then the datacenter in the provider setup.
|
|
6199
|
+
"""
|
|
6200
|
+
near: NotRequired[str]
|
|
6201
|
+
node_meta: NotRequired[Mapping[str, str]]
|
|
6202
|
+
partition: NotRequired[str]
|
|
6203
|
+
require_consistent: NotRequired[bool]
|
|
6204
|
+
"""
|
|
6205
|
+
When `true` force the client to perform a
|
|
6206
|
+
read on at least quorum servers and verify the result is the same. Defaults
|
|
6207
|
+
to `false`.
|
|
6208
|
+
"""
|
|
6209
|
+
token: NotRequired[str]
|
|
6210
|
+
"""
|
|
6211
|
+
Specify the Consul ACL token to use when performing the
|
|
6212
|
+
request. This defaults to the same API token configured by the `consul`
|
|
6213
|
+
provider but may be overridden if necessary.
|
|
6214
|
+
"""
|
|
6215
|
+
wait_index: NotRequired[int]
|
|
6216
|
+
"""
|
|
6217
|
+
Index number used to enable blocking queries.
|
|
6218
|
+
"""
|
|
6219
|
+
wait_time: NotRequired[str]
|
|
6220
|
+
"""
|
|
6221
|
+
Max time the client should wait for a blocking query
|
|
6222
|
+
to return.
|
|
6223
|
+
"""
|
|
6224
|
+
elif False:
|
|
6225
|
+
GetNodesQueryOptionArgsDict: TypeAlias = Mapping[str, Any]
|
|
6226
|
+
|
|
4756
6227
|
@pulumi.input_type
|
|
4757
6228
|
class GetNodesQueryOptionArgs:
|
|
4758
6229
|
def __init__(__self__, *,
|
|
@@ -4910,6 +6381,51 @@ class GetNodesQueryOptionArgs:
|
|
|
4910
6381
|
pulumi.set(self, "wait_time", value)
|
|
4911
6382
|
|
|
4912
6383
|
|
|
6384
|
+
if not MYPY:
|
|
6385
|
+
class GetServiceQueryOptionArgsDict(TypedDict):
|
|
6386
|
+
allow_stale: NotRequired[bool]
|
|
6387
|
+
"""
|
|
6388
|
+
When `true`, the default, allow responses from
|
|
6389
|
+
Consul servers that are followers.
|
|
6390
|
+
"""
|
|
6391
|
+
datacenter: NotRequired[str]
|
|
6392
|
+
"""
|
|
6393
|
+
The Consul datacenter to query. Defaults to the
|
|
6394
|
+
same value found in `query_options` parameter specified below, or if that is
|
|
6395
|
+
empty, the `datacenter` value found in the Consul agent that this provider is
|
|
6396
|
+
configured to talk to.
|
|
6397
|
+
"""
|
|
6398
|
+
namespace: NotRequired[str]
|
|
6399
|
+
"""
|
|
6400
|
+
The namespace to lookup the service.
|
|
6401
|
+
"""
|
|
6402
|
+
near: NotRequired[str]
|
|
6403
|
+
node_meta: NotRequired[Mapping[str, str]]
|
|
6404
|
+
partition: NotRequired[str]
|
|
6405
|
+
require_consistent: NotRequired[bool]
|
|
6406
|
+
"""
|
|
6407
|
+
When `true` force the client to perform a
|
|
6408
|
+
read on at least quorum servers and verify the result is the same. Defaults
|
|
6409
|
+
to `false`.
|
|
6410
|
+
"""
|
|
6411
|
+
token: NotRequired[str]
|
|
6412
|
+
"""
|
|
6413
|
+
Specify the Consul ACL token to use when performing the
|
|
6414
|
+
request. This defaults to the same API token configured by the `consul`
|
|
6415
|
+
provider but may be overridden if necessary.
|
|
6416
|
+
"""
|
|
6417
|
+
wait_index: NotRequired[int]
|
|
6418
|
+
"""
|
|
6419
|
+
Index number used to enable blocking queries.
|
|
6420
|
+
"""
|
|
6421
|
+
wait_time: NotRequired[str]
|
|
6422
|
+
"""
|
|
6423
|
+
Max time the client should wait for a blocking query
|
|
6424
|
+
to return.
|
|
6425
|
+
"""
|
|
6426
|
+
elif False:
|
|
6427
|
+
GetServiceQueryOptionArgsDict: TypeAlias = Mapping[str, Any]
|
|
6428
|
+
|
|
4913
6429
|
@pulumi.input_type
|
|
4914
6430
|
class GetServiceQueryOptionArgs:
|
|
4915
6431
|
def __init__(__self__, *,
|
|
@@ -5083,6 +6599,51 @@ class GetServiceQueryOptionArgs:
|
|
|
5083
6599
|
pulumi.set(self, "wait_time", value)
|
|
5084
6600
|
|
|
5085
6601
|
|
|
6602
|
+
if not MYPY:
|
|
6603
|
+
class GetServicesQueryOptionArgsDict(TypedDict):
|
|
6604
|
+
allow_stale: NotRequired[bool]
|
|
6605
|
+
"""
|
|
6606
|
+
When `true`, the default, allow responses from
|
|
6607
|
+
Consul servers that are followers.
|
|
6608
|
+
"""
|
|
6609
|
+
datacenter: NotRequired[str]
|
|
6610
|
+
"""
|
|
6611
|
+
The Consul datacenter to query. Defaults to the
|
|
6612
|
+
same value found in `query_options` parameter specified below, or if that is
|
|
6613
|
+
empty, the `datacenter` value found in the Consul agent that this provider is
|
|
6614
|
+
configured to talk to.
|
|
6615
|
+
"""
|
|
6616
|
+
namespace: NotRequired[str]
|
|
6617
|
+
"""
|
|
6618
|
+
The namespace to lookup the services.
|
|
6619
|
+
"""
|
|
6620
|
+
near: NotRequired[str]
|
|
6621
|
+
node_meta: NotRequired[Mapping[str, str]]
|
|
6622
|
+
partition: NotRequired[str]
|
|
6623
|
+
require_consistent: NotRequired[bool]
|
|
6624
|
+
"""
|
|
6625
|
+
When `true` force the client to perform a
|
|
6626
|
+
read on at least quorum servers and verify the result is the same. Defaults
|
|
6627
|
+
to `false`.
|
|
6628
|
+
"""
|
|
6629
|
+
token: NotRequired[str]
|
|
6630
|
+
"""
|
|
6631
|
+
Specify the Consul ACL token to use when performing the
|
|
6632
|
+
request. This defaults to the same API token configured by the `consul`
|
|
6633
|
+
provider but may be overridden if necessary.
|
|
6634
|
+
"""
|
|
6635
|
+
wait_index: NotRequired[int]
|
|
6636
|
+
"""
|
|
6637
|
+
Index number used to enable blocking queries.
|
|
6638
|
+
"""
|
|
6639
|
+
wait_time: NotRequired[str]
|
|
6640
|
+
"""
|
|
6641
|
+
Max time the client should wait for a blocking query
|
|
6642
|
+
to return.
|
|
6643
|
+
"""
|
|
6644
|
+
elif False:
|
|
6645
|
+
GetServicesQueryOptionArgsDict: TypeAlias = Mapping[str, Any]
|
|
6646
|
+
|
|
5086
6647
|
@pulumi.input_type
|
|
5087
6648
|
class GetServicesQueryOptionArgs:
|
|
5088
6649
|
def __init__(__self__, *,
|