pulumi-azure-native 3.7.0a1755038471__py3-none-any.whl → 3.7.0a1755047742__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-azure-native might be problematic. Click here for more details.
- pulumi_azure_native/app/_enums.py +89 -1
- pulumi_azure_native/app/_inputs.py +2903 -126
- pulumi_azure_native/app/app_resiliency.py +4 -4
- pulumi_azure_native/app/build.py +4 -4
- pulumi_azure_native/app/builder.py +4 -4
- pulumi_azure_native/app/certificate.py +5 -4
- pulumi_azure_native/app/connected_environment.py +4 -4
- pulumi_azure_native/app/connected_environments_certificate.py +5 -4
- pulumi_azure_native/app/connected_environments_dapr_component.py +53 -4
- pulumi_azure_native/app/connected_environments_storage.py +4 -4
- pulumi_azure_native/app/container_app.py +72 -4
- pulumi_azure_native/app/container_apps_auth_config.py +4 -4
- pulumi_azure_native/app/container_apps_session_pool.py +4 -4
- pulumi_azure_native/app/container_apps_source_control.py +4 -4
- pulumi_azure_native/app/dapr_component.py +33 -4
- pulumi_azure_native/app/dapr_component_resiliency_policy.py +4 -4
- pulumi_azure_native/app/dapr_subscription.py +4 -4
- pulumi_azure_native/app/dot_net_component.py +4 -4
- pulumi_azure_native/app/get_app_resiliency.py +4 -4
- pulumi_azure_native/app/get_build.py +4 -4
- pulumi_azure_native/app/get_builder.py +4 -4
- pulumi_azure_native/app/get_certificate.py +4 -4
- pulumi_azure_native/app/get_connected_environment.py +4 -4
- pulumi_azure_native/app/get_connected_environments_certificate.py +4 -4
- pulumi_azure_native/app/get_connected_environments_dapr_component.py +47 -5
- pulumi_azure_native/app/get_connected_environments_storage.py +4 -4
- pulumi_azure_native/app/get_container_app.py +47 -5
- pulumi_azure_native/app/get_container_app_auth_token.py +4 -4
- pulumi_azure_native/app/get_container_apps_auth_config.py +4 -4
- pulumi_azure_native/app/get_container_apps_session_pool.py +4 -4
- pulumi_azure_native/app/get_container_apps_source_control.py +4 -4
- pulumi_azure_native/app/get_custom_domain_verification_id.py +4 -4
- pulumi_azure_native/app/get_dapr_component.py +19 -5
- pulumi_azure_native/app/get_dapr_component_resiliency_policy.py +4 -4
- pulumi_azure_native/app/get_dapr_subscription.py +4 -4
- pulumi_azure_native/app/get_dot_net_component.py +4 -4
- pulumi_azure_native/app/get_http_route_config.py +4 -4
- pulumi_azure_native/app/get_java_component.py +4 -4
- pulumi_azure_native/app/get_job.py +33 -5
- pulumi_azure_native/app/get_logic_app.py +4 -4
- pulumi_azure_native/app/get_maintenance_configuration.py +4 -4
- pulumi_azure_native/app/get_managed_certificate.py +4 -4
- pulumi_azure_native/app/get_managed_environment.py +118 -6
- pulumi_azure_native/app/get_managed_environment_auth_token.py +4 -4
- pulumi_azure_native/app/get_managed_environment_private_endpoint_connection.py +4 -4
- pulumi_azure_native/app/get_managed_environments_storage.py +4 -4
- pulumi_azure_native/app/http_route_config.py +4 -4
- pulumi_azure_native/app/java_component.py +11 -11
- pulumi_azure_native/app/job.py +43 -4
- pulumi_azure_native/app/list_build_auth_token.py +4 -4
- pulumi_azure_native/app/list_connected_environments_dapr_component_secrets.py +4 -4
- pulumi_azure_native/app/list_container_app_custom_host_name_analysis.py +4 -4
- pulumi_azure_native/app/list_container_app_secrets.py +4 -4
- pulumi_azure_native/app/list_dapr_component_secrets.py +4 -4
- pulumi_azure_native/app/list_job_secrets.py +4 -4
- pulumi_azure_native/app/list_logic_app_workflows_connections.py +4 -4
- pulumi_azure_native/app/logic_app.py +4 -4
- pulumi_azure_native/app/maintenance_configuration.py +4 -4
- pulumi_azure_native/app/managed_certificate.py +4 -4
- pulumi_azure_native/app/managed_environment.py +202 -8
- pulumi_azure_native/app/managed_environment_private_endpoint_connection.py +4 -4
- pulumi_azure_native/app/managed_environments_storage.py +4 -4
- pulumi_azure_native/app/outputs.py +2484 -150
- pulumi_azure_native/pulumi-plugin.json +1 -1
- {pulumi_azure_native-3.7.0a1755038471.dist-info → pulumi_azure_native-3.7.0a1755047742.dist-info}/METADATA +1 -1
- {pulumi_azure_native-3.7.0a1755038471.dist-info → pulumi_azure_native-3.7.0a1755047742.dist-info}/RECORD +68 -68
- {pulumi_azure_native-3.7.0a1755038471.dist-info → pulumi_azure_native-3.7.0a1755047742.dist-info}/WHEEL +0 -0
- {pulumi_azure_native-3.7.0a1755038471.dist-info → pulumi_azure_native-3.7.0a1755047742.dist-info}/top_level.txt +0 -0
|
@@ -21,6 +21,8 @@ __all__ = [
|
|
|
21
21
|
'AllowedAudiencesValidationArgsDict',
|
|
22
22
|
'AllowedPrincipalsArgs',
|
|
23
23
|
'AllowedPrincipalsArgsDict',
|
|
24
|
+
'AppInsightsConfigurationArgs',
|
|
25
|
+
'AppInsightsConfigurationArgsDict',
|
|
24
26
|
'AppLogsConfigurationArgs',
|
|
25
27
|
'AppLogsConfigurationArgsDict',
|
|
26
28
|
'AppRegistrationArgs',
|
|
@@ -63,6 +65,8 @@ __all__ = [
|
|
|
63
65
|
'ConfigurationArgsDict',
|
|
64
66
|
'ConnectedEnvironmentStoragePropertiesArgs',
|
|
65
67
|
'ConnectedEnvironmentStoragePropertiesArgsDict',
|
|
68
|
+
'ContainerAppPatchingConfigurationArgs',
|
|
69
|
+
'ContainerAppPatchingConfigurationArgsDict',
|
|
66
70
|
'ContainerAppProbeHttpGetArgs',
|
|
67
71
|
'ContainerAppProbeHttpGetArgsDict',
|
|
68
72
|
'ContainerAppProbeHttpHeadersArgs',
|
|
@@ -93,6 +97,8 @@ __all__ = [
|
|
|
93
97
|
'CustomOpenIdConnectProviderArgsDict',
|
|
94
98
|
'CustomScaleRuleArgs',
|
|
95
99
|
'CustomScaleRuleArgsDict',
|
|
100
|
+
'DaprAppHealthArgs',
|
|
101
|
+
'DaprAppHealthArgsDict',
|
|
96
102
|
'DaprComponentResiliencyPolicyCircuitBreakerPolicyConfigurationArgs',
|
|
97
103
|
'DaprComponentResiliencyPolicyCircuitBreakerPolicyConfigurationArgsDict',
|
|
98
104
|
'DaprComponentResiliencyPolicyConfigurationArgs',
|
|
@@ -103,8 +109,12 @@ __all__ = [
|
|
|
103
109
|
'DaprComponentResiliencyPolicyHttpRetryPolicyConfigurationArgsDict',
|
|
104
110
|
'DaprComponentResiliencyPolicyTimeoutPolicyConfigurationArgs',
|
|
105
111
|
'DaprComponentResiliencyPolicyTimeoutPolicyConfigurationArgsDict',
|
|
112
|
+
'DaprComponentServiceBindingArgs',
|
|
113
|
+
'DaprComponentServiceBindingArgsDict',
|
|
106
114
|
'DaprMetadataArgs',
|
|
107
115
|
'DaprMetadataArgsDict',
|
|
116
|
+
'DaprServiceBindMetadataArgs',
|
|
117
|
+
'DaprServiceBindMetadataArgsDict',
|
|
108
118
|
'DaprSubscriptionBulkSubscribeOptionsArgs',
|
|
109
119
|
'DaprSubscriptionBulkSubscribeOptionsArgsDict',
|
|
110
120
|
'DaprSubscriptionRouteRuleArgs',
|
|
@@ -113,8 +123,18 @@ __all__ = [
|
|
|
113
123
|
'DaprSubscriptionRoutesArgsDict',
|
|
114
124
|
'DaprArgs',
|
|
115
125
|
'DaprArgsDict',
|
|
126
|
+
'DataDogConfigurationArgs',
|
|
127
|
+
'DataDogConfigurationArgsDict',
|
|
116
128
|
'DefaultAuthorizationPolicyArgs',
|
|
117
129
|
'DefaultAuthorizationPolicyArgsDict',
|
|
130
|
+
'DestinationsConfigurationArgs',
|
|
131
|
+
'DestinationsConfigurationArgsDict',
|
|
132
|
+
'DiskEncryptionConfigurationAuthArgs',
|
|
133
|
+
'DiskEncryptionConfigurationAuthArgsDict',
|
|
134
|
+
'DiskEncryptionConfigurationKeyVaultConfigurationArgs',
|
|
135
|
+
'DiskEncryptionConfigurationKeyVaultConfigurationArgsDict',
|
|
136
|
+
'DiskEncryptionConfigurationArgs',
|
|
137
|
+
'DiskEncryptionConfigurationArgsDict',
|
|
118
138
|
'DotNetComponentConfigurationPropertyArgs',
|
|
119
139
|
'DotNetComponentConfigurationPropertyArgsDict',
|
|
120
140
|
'DotNetComponentServiceBindArgs',
|
|
@@ -143,6 +163,8 @@ __all__ = [
|
|
|
143
163
|
'GoogleArgsDict',
|
|
144
164
|
'HeaderMatchArgs',
|
|
145
165
|
'HeaderMatchArgsDict',
|
|
166
|
+
'HeaderArgs',
|
|
167
|
+
'HeaderArgsDict',
|
|
146
168
|
'HttpConnectionPoolArgs',
|
|
147
169
|
'HttpConnectionPoolArgsDict',
|
|
148
170
|
'HttpGetArgs',
|
|
@@ -171,6 +193,10 @@ __all__ = [
|
|
|
171
193
|
'IdentityProvidersArgsDict',
|
|
172
194
|
'IdentitySettingsArgs',
|
|
173
195
|
'IdentitySettingsArgsDict',
|
|
196
|
+
'IngressConfigurationScaleArgs',
|
|
197
|
+
'IngressConfigurationScaleArgsDict',
|
|
198
|
+
'IngressConfigurationArgs',
|
|
199
|
+
'IngressConfigurationArgsDict',
|
|
174
200
|
'IngressPortMappingArgs',
|
|
175
201
|
'IngressPortMappingArgsDict',
|
|
176
202
|
'IngressStickySessionsArgs',
|
|
@@ -207,12 +233,16 @@ __all__ = [
|
|
|
207
233
|
'LifecycleConfigurationArgsDict',
|
|
208
234
|
'LogAnalyticsConfigurationArgs',
|
|
209
235
|
'LogAnalyticsConfigurationArgsDict',
|
|
236
|
+
'LoggerSettingArgs',
|
|
237
|
+
'LoggerSettingArgsDict',
|
|
210
238
|
'LoginRoutesArgs',
|
|
211
239
|
'LoginRoutesArgsDict',
|
|
212
240
|
'LoginScopesArgs',
|
|
213
241
|
'LoginScopesArgsDict',
|
|
214
242
|
'LoginArgs',
|
|
215
243
|
'LoginArgsDict',
|
|
244
|
+
'LogsConfigurationArgs',
|
|
245
|
+
'LogsConfigurationArgsDict',
|
|
216
246
|
'ManagedCertificatePropertiesArgs',
|
|
217
247
|
'ManagedCertificatePropertiesArgsDict',
|
|
218
248
|
'ManagedEnvironmentEncryptionArgs',
|
|
@@ -227,8 +257,12 @@ __all__ = [
|
|
|
227
257
|
'ManagedIdentitySettingArgsDict',
|
|
228
258
|
'ManagedServiceIdentityArgs',
|
|
229
259
|
'ManagedServiceIdentityArgsDict',
|
|
260
|
+
'MetricsConfigurationArgs',
|
|
261
|
+
'MetricsConfigurationArgsDict',
|
|
230
262
|
'MtlsArgs',
|
|
231
263
|
'MtlsArgsDict',
|
|
264
|
+
'NacosComponentArgs',
|
|
265
|
+
'NacosComponentArgsDict',
|
|
232
266
|
'NfsAzureFilePropertiesArgs',
|
|
233
267
|
'NfsAzureFilePropertiesArgsDict',
|
|
234
268
|
'NonceArgs',
|
|
@@ -241,6 +275,10 @@ __all__ = [
|
|
|
241
275
|
'OpenIdConnectLoginArgsDict',
|
|
242
276
|
'OpenIdConnectRegistrationArgs',
|
|
243
277
|
'OpenIdConnectRegistrationArgsDict',
|
|
278
|
+
'OpenTelemetryConfigurationArgs',
|
|
279
|
+
'OpenTelemetryConfigurationArgsDict',
|
|
280
|
+
'OtlpConfigurationArgs',
|
|
281
|
+
'OtlpConfigurationArgsDict',
|
|
244
282
|
'PreBuildStepArgs',
|
|
245
283
|
'PreBuildStepArgsDict',
|
|
246
284
|
'PrivateLinkServiceConnectionStateArgs',
|
|
@@ -251,8 +289,14 @@ __all__ = [
|
|
|
251
289
|
'RegistryCredentialsArgsDict',
|
|
252
290
|
'RegistryInfoArgs',
|
|
253
291
|
'RegistryInfoArgsDict',
|
|
292
|
+
'RuntimeDotnetArgs',
|
|
293
|
+
'RuntimeDotnetArgsDict',
|
|
294
|
+
'RuntimeJavaAgentArgs',
|
|
295
|
+
'RuntimeJavaAgentArgsDict',
|
|
254
296
|
'RuntimeJavaArgs',
|
|
255
297
|
'RuntimeJavaArgsDict',
|
|
298
|
+
'RuntimeLoggingArgs',
|
|
299
|
+
'RuntimeLoggingArgsDict',
|
|
256
300
|
'RuntimeArgs',
|
|
257
301
|
'RuntimeArgsDict',
|
|
258
302
|
'ScaleConfigurationArgs',
|
|
@@ -263,8 +307,12 @@ __all__ = [
|
|
|
263
307
|
'ScaleRuleArgsDict',
|
|
264
308
|
'ScaleArgs',
|
|
265
309
|
'ScaleArgsDict',
|
|
310
|
+
'ScgRouteArgs',
|
|
311
|
+
'ScgRouteArgsDict',
|
|
266
312
|
'ScheduledEntryArgs',
|
|
267
313
|
'ScheduledEntryArgsDict',
|
|
314
|
+
'SecretKeyVaultPropertiesArgs',
|
|
315
|
+
'SecretKeyVaultPropertiesArgsDict',
|
|
268
316
|
'SecretVolumeItemArgs',
|
|
269
317
|
'SecretVolumeItemArgsDict',
|
|
270
318
|
'SecretArgs',
|
|
@@ -283,14 +331,26 @@ __all__ = [
|
|
|
283
331
|
'SessionNetworkConfigurationArgsDict',
|
|
284
332
|
'SessionPoolSecretArgs',
|
|
285
333
|
'SessionPoolSecretArgsDict',
|
|
334
|
+
'SessionProbeHttpGetArgs',
|
|
335
|
+
'SessionProbeHttpGetArgsDict',
|
|
336
|
+
'SessionProbeHttpHeadersArgs',
|
|
337
|
+
'SessionProbeHttpHeadersArgsDict',
|
|
338
|
+
'SessionProbeTcpSocketArgs',
|
|
339
|
+
'SessionProbeTcpSocketArgsDict',
|
|
340
|
+
'SessionProbeArgs',
|
|
341
|
+
'SessionProbeArgsDict',
|
|
286
342
|
'SessionRegistryCredentialsArgs',
|
|
287
343
|
'SessionRegistryCredentialsArgsDict',
|
|
344
|
+
'SmbStorageArgs',
|
|
345
|
+
'SmbStorageArgsDict',
|
|
288
346
|
'SpringBootAdminComponentArgs',
|
|
289
347
|
'SpringBootAdminComponentArgsDict',
|
|
290
348
|
'SpringCloudConfigComponentArgs',
|
|
291
349
|
'SpringCloudConfigComponentArgsDict',
|
|
292
350
|
'SpringCloudEurekaComponentArgs',
|
|
293
351
|
'SpringCloudEurekaComponentArgsDict',
|
|
352
|
+
'SpringCloudGatewayComponentArgs',
|
|
353
|
+
'SpringCloudGatewayComponentArgsDict',
|
|
294
354
|
'TcpConnectionPoolArgs',
|
|
295
355
|
'TcpConnectionPoolArgsDict',
|
|
296
356
|
'TcpRetryPolicyArgs',
|
|
@@ -303,6 +363,8 @@ __all__ = [
|
|
|
303
363
|
'TimeoutPolicyArgsDict',
|
|
304
364
|
'TokenStoreArgs',
|
|
305
365
|
'TokenStoreArgsDict',
|
|
366
|
+
'TracesConfigurationArgs',
|
|
367
|
+
'TracesConfigurationArgsDict',
|
|
306
368
|
'TrafficWeightArgs',
|
|
307
369
|
'TrafficWeightArgsDict',
|
|
308
370
|
'TwitterRegistrationArgs',
|
|
@@ -413,6 +475,42 @@ class AllowedPrincipalsArgs:
|
|
|
413
475
|
pulumi.set(self, "identities", value)
|
|
414
476
|
|
|
415
477
|
|
|
478
|
+
if not MYPY:
|
|
479
|
+
class AppInsightsConfigurationArgsDict(TypedDict):
|
|
480
|
+
"""
|
|
481
|
+
Configuration of Application Insights
|
|
482
|
+
"""
|
|
483
|
+
connection_string: NotRequired[pulumi.Input[builtins.str]]
|
|
484
|
+
"""
|
|
485
|
+
Application Insights connection string
|
|
486
|
+
"""
|
|
487
|
+
elif False:
|
|
488
|
+
AppInsightsConfigurationArgsDict: TypeAlias = Mapping[str, Any]
|
|
489
|
+
|
|
490
|
+
@pulumi.input_type
|
|
491
|
+
class AppInsightsConfigurationArgs:
|
|
492
|
+
def __init__(__self__, *,
|
|
493
|
+
connection_string: Optional[pulumi.Input[builtins.str]] = None):
|
|
494
|
+
"""
|
|
495
|
+
Configuration of Application Insights
|
|
496
|
+
:param pulumi.Input[builtins.str] connection_string: Application Insights connection string
|
|
497
|
+
"""
|
|
498
|
+
if connection_string is not None:
|
|
499
|
+
pulumi.set(__self__, "connection_string", connection_string)
|
|
500
|
+
|
|
501
|
+
@property
|
|
502
|
+
@pulumi.getter(name="connectionString")
|
|
503
|
+
def connection_string(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
504
|
+
"""
|
|
505
|
+
Application Insights connection string
|
|
506
|
+
"""
|
|
507
|
+
return pulumi.get(self, "connection_string")
|
|
508
|
+
|
|
509
|
+
@connection_string.setter
|
|
510
|
+
def connection_string(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
511
|
+
pulumi.set(self, "connection_string", value)
|
|
512
|
+
|
|
513
|
+
|
|
416
514
|
if not MYPY:
|
|
417
515
|
class AppLogsConfigurationArgsDict(TypedDict):
|
|
418
516
|
"""
|
|
@@ -1265,6 +1363,10 @@ if not MYPY:
|
|
|
1265
1363
|
"""
|
|
1266
1364
|
Storage account key for azure file.
|
|
1267
1365
|
"""
|
|
1366
|
+
account_key_vault_properties: NotRequired[pulumi.Input['SecretKeyVaultPropertiesArgsDict']]
|
|
1367
|
+
"""
|
|
1368
|
+
Storage account key stored as an Azure Key Vault secret.
|
|
1369
|
+
"""
|
|
1268
1370
|
account_name: NotRequired[pulumi.Input[builtins.str]]
|
|
1269
1371
|
"""
|
|
1270
1372
|
Storage account name for azure file.
|
|
@@ -1281,12 +1383,14 @@ class AzureFilePropertiesArgs:
|
|
|
1281
1383
|
def __init__(__self__, *,
|
|
1282
1384
|
access_mode: Optional[pulumi.Input[Union[builtins.str, 'AccessMode']]] = None,
|
|
1283
1385
|
account_key: Optional[pulumi.Input[builtins.str]] = None,
|
|
1386
|
+
account_key_vault_properties: Optional[pulumi.Input['SecretKeyVaultPropertiesArgs']] = None,
|
|
1284
1387
|
account_name: Optional[pulumi.Input[builtins.str]] = None,
|
|
1285
1388
|
share_name: Optional[pulumi.Input[builtins.str]] = None):
|
|
1286
1389
|
"""
|
|
1287
1390
|
Azure File Properties.
|
|
1288
1391
|
:param pulumi.Input[Union[builtins.str, 'AccessMode']] access_mode: Access mode for storage
|
|
1289
1392
|
:param pulumi.Input[builtins.str] account_key: Storage account key for azure file.
|
|
1393
|
+
:param pulumi.Input['SecretKeyVaultPropertiesArgs'] account_key_vault_properties: Storage account key stored as an Azure Key Vault secret.
|
|
1290
1394
|
:param pulumi.Input[builtins.str] account_name: Storage account name for azure file.
|
|
1291
1395
|
:param pulumi.Input[builtins.str] share_name: Azure file share name.
|
|
1292
1396
|
"""
|
|
@@ -1294,6 +1398,8 @@ class AzureFilePropertiesArgs:
|
|
|
1294
1398
|
pulumi.set(__self__, "access_mode", access_mode)
|
|
1295
1399
|
if account_key is not None:
|
|
1296
1400
|
pulumi.set(__self__, "account_key", account_key)
|
|
1401
|
+
if account_key_vault_properties is not None:
|
|
1402
|
+
pulumi.set(__self__, "account_key_vault_properties", account_key_vault_properties)
|
|
1297
1403
|
if account_name is not None:
|
|
1298
1404
|
pulumi.set(__self__, "account_name", account_name)
|
|
1299
1405
|
if share_name is not None:
|
|
@@ -1323,6 +1429,18 @@ class AzureFilePropertiesArgs:
|
|
|
1323
1429
|
def account_key(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
1324
1430
|
pulumi.set(self, "account_key", value)
|
|
1325
1431
|
|
|
1432
|
+
@property
|
|
1433
|
+
@pulumi.getter(name="accountKeyVaultProperties")
|
|
1434
|
+
def account_key_vault_properties(self) -> Optional[pulumi.Input['SecretKeyVaultPropertiesArgs']]:
|
|
1435
|
+
"""
|
|
1436
|
+
Storage account key stored as an Azure Key Vault secret.
|
|
1437
|
+
"""
|
|
1438
|
+
return pulumi.get(self, "account_key_vault_properties")
|
|
1439
|
+
|
|
1440
|
+
@account_key_vault_properties.setter
|
|
1441
|
+
def account_key_vault_properties(self, value: Optional[pulumi.Input['SecretKeyVaultPropertiesArgs']]):
|
|
1442
|
+
pulumi.set(self, "account_key_vault_properties", value)
|
|
1443
|
+
|
|
1326
1444
|
@property
|
|
1327
1445
|
@pulumi.getter(name="accountName")
|
|
1328
1446
|
def account_name(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
@@ -1445,9 +1563,21 @@ if not MYPY:
|
|
|
1445
1563
|
"""
|
|
1446
1564
|
The configuration settings of the storage of the tokens if blob storage is used.
|
|
1447
1565
|
"""
|
|
1448
|
-
|
|
1566
|
+
blob_container_uri: NotRequired[pulumi.Input[builtins.str]]
|
|
1567
|
+
"""
|
|
1568
|
+
The URI of the blob storage containing the tokens. Should not be used along with sasUrlSettingName.
|
|
1569
|
+
"""
|
|
1570
|
+
client_id: NotRequired[pulumi.Input[builtins.str]]
|
|
1571
|
+
"""
|
|
1572
|
+
The Client ID of a User-Assigned Managed Identity. Should not be used along with managedIdentityResourceId.
|
|
1573
|
+
"""
|
|
1574
|
+
managed_identity_resource_id: NotRequired[pulumi.Input[builtins.str]]
|
|
1575
|
+
"""
|
|
1576
|
+
The Resource ID of a User-Assigned Managed Identity. Should not be used along with clientId.
|
|
1577
|
+
"""
|
|
1578
|
+
sas_url_setting_name: NotRequired[pulumi.Input[builtins.str]]
|
|
1449
1579
|
"""
|
|
1450
|
-
The name of the app secrets containing the SAS URL of the blob storage containing the tokens.
|
|
1580
|
+
The name of the app secrets containing the SAS URL of the blob storage containing the tokens. Should not be used along with blobContainerUri.
|
|
1451
1581
|
"""
|
|
1452
1582
|
elif False:
|
|
1453
1583
|
BlobStorageTokenStoreArgsDict: TypeAlias = Mapping[str, Any]
|
|
@@ -1455,23 +1585,72 @@ elif False:
|
|
|
1455
1585
|
@pulumi.input_type
|
|
1456
1586
|
class BlobStorageTokenStoreArgs:
|
|
1457
1587
|
def __init__(__self__, *,
|
|
1458
|
-
|
|
1588
|
+
blob_container_uri: Optional[pulumi.Input[builtins.str]] = None,
|
|
1589
|
+
client_id: Optional[pulumi.Input[builtins.str]] = None,
|
|
1590
|
+
managed_identity_resource_id: Optional[pulumi.Input[builtins.str]] = None,
|
|
1591
|
+
sas_url_setting_name: Optional[pulumi.Input[builtins.str]] = None):
|
|
1459
1592
|
"""
|
|
1460
1593
|
The configuration settings of the storage of the tokens if blob storage is used.
|
|
1461
|
-
:param pulumi.Input[builtins.str]
|
|
1594
|
+
:param pulumi.Input[builtins.str] blob_container_uri: The URI of the blob storage containing the tokens. Should not be used along with sasUrlSettingName.
|
|
1595
|
+
:param pulumi.Input[builtins.str] client_id: The Client ID of a User-Assigned Managed Identity. Should not be used along with managedIdentityResourceId.
|
|
1596
|
+
:param pulumi.Input[builtins.str] managed_identity_resource_id: The Resource ID of a User-Assigned Managed Identity. Should not be used along with clientId.
|
|
1597
|
+
:param pulumi.Input[builtins.str] sas_url_setting_name: The name of the app secrets containing the SAS URL of the blob storage containing the tokens. Should not be used along with blobContainerUri.
|
|
1598
|
+
"""
|
|
1599
|
+
if blob_container_uri is not None:
|
|
1600
|
+
pulumi.set(__self__, "blob_container_uri", blob_container_uri)
|
|
1601
|
+
if client_id is not None:
|
|
1602
|
+
pulumi.set(__self__, "client_id", client_id)
|
|
1603
|
+
if managed_identity_resource_id is not None:
|
|
1604
|
+
pulumi.set(__self__, "managed_identity_resource_id", managed_identity_resource_id)
|
|
1605
|
+
if sas_url_setting_name is not None:
|
|
1606
|
+
pulumi.set(__self__, "sas_url_setting_name", sas_url_setting_name)
|
|
1607
|
+
|
|
1608
|
+
@property
|
|
1609
|
+
@pulumi.getter(name="blobContainerUri")
|
|
1610
|
+
def blob_container_uri(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
1611
|
+
"""
|
|
1612
|
+
The URI of the blob storage containing the tokens. Should not be used along with sasUrlSettingName.
|
|
1613
|
+
"""
|
|
1614
|
+
return pulumi.get(self, "blob_container_uri")
|
|
1615
|
+
|
|
1616
|
+
@blob_container_uri.setter
|
|
1617
|
+
def blob_container_uri(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
1618
|
+
pulumi.set(self, "blob_container_uri", value)
|
|
1619
|
+
|
|
1620
|
+
@property
|
|
1621
|
+
@pulumi.getter(name="clientId")
|
|
1622
|
+
def client_id(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
1623
|
+
"""
|
|
1624
|
+
The Client ID of a User-Assigned Managed Identity. Should not be used along with managedIdentityResourceId.
|
|
1625
|
+
"""
|
|
1626
|
+
return pulumi.get(self, "client_id")
|
|
1627
|
+
|
|
1628
|
+
@client_id.setter
|
|
1629
|
+
def client_id(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
1630
|
+
pulumi.set(self, "client_id", value)
|
|
1631
|
+
|
|
1632
|
+
@property
|
|
1633
|
+
@pulumi.getter(name="managedIdentityResourceId")
|
|
1634
|
+
def managed_identity_resource_id(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
1462
1635
|
"""
|
|
1463
|
-
|
|
1636
|
+
The Resource ID of a User-Assigned Managed Identity. Should not be used along with clientId.
|
|
1637
|
+
"""
|
|
1638
|
+
return pulumi.get(self, "managed_identity_resource_id")
|
|
1639
|
+
|
|
1640
|
+
@managed_identity_resource_id.setter
|
|
1641
|
+
def managed_identity_resource_id(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
1642
|
+
pulumi.set(self, "managed_identity_resource_id", value)
|
|
1464
1643
|
|
|
1465
1644
|
@property
|
|
1466
1645
|
@pulumi.getter(name="sasUrlSettingName")
|
|
1467
|
-
def sas_url_setting_name(self) -> pulumi.Input[builtins.str]:
|
|
1646
|
+
def sas_url_setting_name(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
1468
1647
|
"""
|
|
1469
|
-
The name of the app secrets containing the SAS URL of the blob storage containing the tokens.
|
|
1648
|
+
The name of the app secrets containing the SAS URL of the blob storage containing the tokens. Should not be used along with blobContainerUri.
|
|
1470
1649
|
"""
|
|
1471
1650
|
return pulumi.get(self, "sas_url_setting_name")
|
|
1472
1651
|
|
|
1473
1652
|
@sas_url_setting_name.setter
|
|
1474
|
-
def sas_url_setting_name(self, value: pulumi.Input[builtins.str]):
|
|
1653
|
+
def sas_url_setting_name(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
1475
1654
|
pulumi.set(self, "sas_url_setting_name", value)
|
|
1476
1655
|
|
|
1477
1656
|
|
|
@@ -1656,6 +1835,10 @@ if not MYPY:
|
|
|
1656
1835
|
"""
|
|
1657
1836
|
Properties for a certificate stored in a Key Vault.
|
|
1658
1837
|
"""
|
|
1838
|
+
certificate_type: NotRequired[pulumi.Input[Union[builtins.str, 'CertificateType']]]
|
|
1839
|
+
"""
|
|
1840
|
+
The type of the certificate. Allowed values are `ServerSSLCertificate` and `ImagePullTrustedCA`
|
|
1841
|
+
"""
|
|
1659
1842
|
password: NotRequired[pulumi.Input[builtins.str]]
|
|
1660
1843
|
"""
|
|
1661
1844
|
Certificate password.
|
|
@@ -1671,16 +1854,20 @@ elif False:
|
|
|
1671
1854
|
class CertificatePropertiesArgs:
|
|
1672
1855
|
def __init__(__self__, *,
|
|
1673
1856
|
certificate_key_vault_properties: Optional[pulumi.Input['CertificateKeyVaultPropertiesArgs']] = None,
|
|
1857
|
+
certificate_type: Optional[pulumi.Input[Union[builtins.str, 'CertificateType']]] = None,
|
|
1674
1858
|
password: Optional[pulumi.Input[builtins.str]] = None,
|
|
1675
1859
|
value: Optional[pulumi.Input[builtins.str]] = None):
|
|
1676
1860
|
"""
|
|
1677
1861
|
Certificate resource specific properties
|
|
1678
1862
|
:param pulumi.Input['CertificateKeyVaultPropertiesArgs'] certificate_key_vault_properties: Properties for a certificate stored in a Key Vault.
|
|
1863
|
+
:param pulumi.Input[Union[builtins.str, 'CertificateType']] certificate_type: The type of the certificate. Allowed values are `ServerSSLCertificate` and `ImagePullTrustedCA`
|
|
1679
1864
|
:param pulumi.Input[builtins.str] password: Certificate password.
|
|
1680
1865
|
:param pulumi.Input[builtins.str] value: PFX or PEM blob
|
|
1681
1866
|
"""
|
|
1682
1867
|
if certificate_key_vault_properties is not None:
|
|
1683
1868
|
pulumi.set(__self__, "certificate_key_vault_properties", certificate_key_vault_properties)
|
|
1869
|
+
if certificate_type is not None:
|
|
1870
|
+
pulumi.set(__self__, "certificate_type", certificate_type)
|
|
1684
1871
|
if password is not None:
|
|
1685
1872
|
pulumi.set(__self__, "password", password)
|
|
1686
1873
|
if value is not None:
|
|
@@ -1698,6 +1885,18 @@ class CertificatePropertiesArgs:
|
|
|
1698
1885
|
def certificate_key_vault_properties(self, value: Optional[pulumi.Input['CertificateKeyVaultPropertiesArgs']]):
|
|
1699
1886
|
pulumi.set(self, "certificate_key_vault_properties", value)
|
|
1700
1887
|
|
|
1888
|
+
@property
|
|
1889
|
+
@pulumi.getter(name="certificateType")
|
|
1890
|
+
def certificate_type(self) -> Optional[pulumi.Input[Union[builtins.str, 'CertificateType']]]:
|
|
1891
|
+
"""
|
|
1892
|
+
The type of the certificate. Allowed values are `ServerSSLCertificate` and `ImagePullTrustedCA`
|
|
1893
|
+
"""
|
|
1894
|
+
return pulumi.get(self, "certificate_type")
|
|
1895
|
+
|
|
1896
|
+
@certificate_type.setter
|
|
1897
|
+
def certificate_type(self, value: Optional[pulumi.Input[Union[builtins.str, 'CertificateType']]]):
|
|
1898
|
+
pulumi.set(self, "certificate_type", value)
|
|
1899
|
+
|
|
1701
1900
|
@property
|
|
1702
1901
|
@pulumi.getter
|
|
1703
1902
|
def password(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
@@ -1863,7 +2062,7 @@ if not MYPY:
|
|
|
1863
2062
|
active_revisions_mode: NotRequired[pulumi.Input[Union[builtins.str, 'ActiveRevisionsMode']]]
|
|
1864
2063
|
"""
|
|
1865
2064
|
ActiveRevisionsMode controls how active revisions are handled for the Container app:
|
|
1866
|
-
<list><item>
|
|
2065
|
+
<list><item>Single: Only one revision can be active at a time. Traffic weights cannot be used. This is the default.</item><item>Multiple: Multiple revisions can be active, including optional traffic weights and labels.</item><item>Labels: Only revisions with labels are active. Traffic weights can be applied to labels.</item></list>
|
|
1867
2066
|
"""
|
|
1868
2067
|
dapr: NotRequired[pulumi.Input['DaprArgsDict']]
|
|
1869
2068
|
"""
|
|
@@ -1885,6 +2084,10 @@ if not MYPY:
|
|
|
1885
2084
|
"""
|
|
1886
2085
|
Collection of private container registry credentials for containers used by the Container app
|
|
1887
2086
|
"""
|
|
2087
|
+
revision_transition_threshold: NotRequired[pulumi.Input[builtins.int]]
|
|
2088
|
+
"""
|
|
2089
|
+
Optional. The percent of the total number of replicas that must be brought up before revision transition occurs. Defaults to 100 when none is given. Value must be greater than 0 and less than or equal to 100.
|
|
2090
|
+
"""
|
|
1888
2091
|
runtime: NotRequired[pulumi.Input['RuntimeArgsDict']]
|
|
1889
2092
|
"""
|
|
1890
2093
|
App runtime configuration for the Container App.
|
|
@@ -1897,6 +2100,10 @@ if not MYPY:
|
|
|
1897
2100
|
"""
|
|
1898
2101
|
Container App to be a dev Container App Service
|
|
1899
2102
|
"""
|
|
2103
|
+
target_label: NotRequired[pulumi.Input[builtins.str]]
|
|
2104
|
+
"""
|
|
2105
|
+
Required in labels revisions mode. Label to apply to newly created revision.
|
|
2106
|
+
"""
|
|
1900
2107
|
elif False:
|
|
1901
2108
|
ConfigurationArgsDict: TypeAlias = Mapping[str, Any]
|
|
1902
2109
|
|
|
@@ -1909,21 +2116,25 @@ class ConfigurationArgs:
|
|
|
1909
2116
|
ingress: Optional[pulumi.Input['IngressArgs']] = None,
|
|
1910
2117
|
max_inactive_revisions: Optional[pulumi.Input[builtins.int]] = None,
|
|
1911
2118
|
registries: Optional[pulumi.Input[Sequence[pulumi.Input['RegistryCredentialsArgs']]]] = None,
|
|
2119
|
+
revision_transition_threshold: Optional[pulumi.Input[builtins.int]] = None,
|
|
1912
2120
|
runtime: Optional[pulumi.Input['RuntimeArgs']] = None,
|
|
1913
2121
|
secrets: Optional[pulumi.Input[Sequence[pulumi.Input['SecretArgs']]]] = None,
|
|
1914
|
-
service: Optional[pulumi.Input['ServiceArgs']] = None
|
|
2122
|
+
service: Optional[pulumi.Input['ServiceArgs']] = None,
|
|
2123
|
+
target_label: Optional[pulumi.Input[builtins.str]] = None):
|
|
1915
2124
|
"""
|
|
1916
2125
|
Non versioned Container App configuration properties that define the mutable settings of a Container app
|
|
1917
2126
|
:param pulumi.Input[Union[builtins.str, 'ActiveRevisionsMode']] active_revisions_mode: ActiveRevisionsMode controls how active revisions are handled for the Container app:
|
|
1918
|
-
<list><item>
|
|
2127
|
+
<list><item>Single: Only one revision can be active at a time. Traffic weights cannot be used. This is the default.</item><item>Multiple: Multiple revisions can be active, including optional traffic weights and labels.</item><item>Labels: Only revisions with labels are active. Traffic weights can be applied to labels.</item></list>
|
|
1919
2128
|
:param pulumi.Input['DaprArgs'] dapr: Dapr configuration for the Container App.
|
|
1920
2129
|
:param pulumi.Input[Sequence[pulumi.Input['IdentitySettingsArgs']]] identity_settings: Optional settings for Managed Identities that are assigned to the Container App. If a Managed Identity is not specified here, default settings will be used.
|
|
1921
2130
|
:param pulumi.Input['IngressArgs'] ingress: Ingress configurations.
|
|
1922
2131
|
:param pulumi.Input[builtins.int] max_inactive_revisions: Optional. Max inactive revisions a Container App can have.
|
|
1923
2132
|
:param pulumi.Input[Sequence[pulumi.Input['RegistryCredentialsArgs']]] registries: Collection of private container registry credentials for containers used by the Container app
|
|
2133
|
+
:param pulumi.Input[builtins.int] revision_transition_threshold: Optional. The percent of the total number of replicas that must be brought up before revision transition occurs. Defaults to 100 when none is given. Value must be greater than 0 and less than or equal to 100.
|
|
1924
2134
|
:param pulumi.Input['RuntimeArgs'] runtime: App runtime configuration for the Container App.
|
|
1925
2135
|
:param pulumi.Input[Sequence[pulumi.Input['SecretArgs']]] secrets: Collection of secrets used by a Container app
|
|
1926
2136
|
:param pulumi.Input['ServiceArgs'] service: Container App to be a dev Container App Service
|
|
2137
|
+
:param pulumi.Input[builtins.str] target_label: Required in labels revisions mode. Label to apply to newly created revision.
|
|
1927
2138
|
"""
|
|
1928
2139
|
if active_revisions_mode is None:
|
|
1929
2140
|
active_revisions_mode = 'Single'
|
|
@@ -1939,19 +2150,23 @@ class ConfigurationArgs:
|
|
|
1939
2150
|
pulumi.set(__self__, "max_inactive_revisions", max_inactive_revisions)
|
|
1940
2151
|
if registries is not None:
|
|
1941
2152
|
pulumi.set(__self__, "registries", registries)
|
|
2153
|
+
if revision_transition_threshold is not None:
|
|
2154
|
+
pulumi.set(__self__, "revision_transition_threshold", revision_transition_threshold)
|
|
1942
2155
|
if runtime is not None:
|
|
1943
2156
|
pulumi.set(__self__, "runtime", runtime)
|
|
1944
2157
|
if secrets is not None:
|
|
1945
2158
|
pulumi.set(__self__, "secrets", secrets)
|
|
1946
2159
|
if service is not None:
|
|
1947
2160
|
pulumi.set(__self__, "service", service)
|
|
2161
|
+
if target_label is not None:
|
|
2162
|
+
pulumi.set(__self__, "target_label", target_label)
|
|
1948
2163
|
|
|
1949
2164
|
@property
|
|
1950
2165
|
@pulumi.getter(name="activeRevisionsMode")
|
|
1951
2166
|
def active_revisions_mode(self) -> Optional[pulumi.Input[Union[builtins.str, 'ActiveRevisionsMode']]]:
|
|
1952
2167
|
"""
|
|
1953
2168
|
ActiveRevisionsMode controls how active revisions are handled for the Container app:
|
|
1954
|
-
<list><item>
|
|
2169
|
+
<list><item>Single: Only one revision can be active at a time. Traffic weights cannot be used. This is the default.</item><item>Multiple: Multiple revisions can be active, including optional traffic weights and labels.</item><item>Labels: Only revisions with labels are active. Traffic weights can be applied to labels.</item></list>
|
|
1955
2170
|
"""
|
|
1956
2171
|
return pulumi.get(self, "active_revisions_mode")
|
|
1957
2172
|
|
|
@@ -2019,6 +2234,18 @@ class ConfigurationArgs:
|
|
|
2019
2234
|
def registries(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['RegistryCredentialsArgs']]]]):
|
|
2020
2235
|
pulumi.set(self, "registries", value)
|
|
2021
2236
|
|
|
2237
|
+
@property
|
|
2238
|
+
@pulumi.getter(name="revisionTransitionThreshold")
|
|
2239
|
+
def revision_transition_threshold(self) -> Optional[pulumi.Input[builtins.int]]:
|
|
2240
|
+
"""
|
|
2241
|
+
Optional. The percent of the total number of replicas that must be brought up before revision transition occurs. Defaults to 100 when none is given. Value must be greater than 0 and less than or equal to 100.
|
|
2242
|
+
"""
|
|
2243
|
+
return pulumi.get(self, "revision_transition_threshold")
|
|
2244
|
+
|
|
2245
|
+
@revision_transition_threshold.setter
|
|
2246
|
+
def revision_transition_threshold(self, value: Optional[pulumi.Input[builtins.int]]):
|
|
2247
|
+
pulumi.set(self, "revision_transition_threshold", value)
|
|
2248
|
+
|
|
2022
2249
|
@property
|
|
2023
2250
|
@pulumi.getter
|
|
2024
2251
|
def runtime(self) -> Optional[pulumi.Input['RuntimeArgs']]:
|
|
@@ -2055,6 +2282,18 @@ class ConfigurationArgs:
|
|
|
2055
2282
|
def service(self, value: Optional[pulumi.Input['ServiceArgs']]):
|
|
2056
2283
|
pulumi.set(self, "service", value)
|
|
2057
2284
|
|
|
2285
|
+
@property
|
|
2286
|
+
@pulumi.getter(name="targetLabel")
|
|
2287
|
+
def target_label(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
2288
|
+
"""
|
|
2289
|
+
Required in labels revisions mode. Label to apply to newly created revision.
|
|
2290
|
+
"""
|
|
2291
|
+
return pulumi.get(self, "target_label")
|
|
2292
|
+
|
|
2293
|
+
@target_label.setter
|
|
2294
|
+
def target_label(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
2295
|
+
pulumi.set(self, "target_label", value)
|
|
2296
|
+
|
|
2058
2297
|
|
|
2059
2298
|
if not MYPY:
|
|
2060
2299
|
class ConnectedEnvironmentStoragePropertiesArgsDict(TypedDict):
|
|
@@ -2065,19 +2304,27 @@ if not MYPY:
|
|
|
2065
2304
|
"""
|
|
2066
2305
|
Azure file properties
|
|
2067
2306
|
"""
|
|
2307
|
+
smb: NotRequired[pulumi.Input['SmbStorageArgsDict']]
|
|
2308
|
+
"""
|
|
2309
|
+
SMB storage properties
|
|
2310
|
+
"""
|
|
2068
2311
|
elif False:
|
|
2069
2312
|
ConnectedEnvironmentStoragePropertiesArgsDict: TypeAlias = Mapping[str, Any]
|
|
2070
2313
|
|
|
2071
2314
|
@pulumi.input_type
|
|
2072
2315
|
class ConnectedEnvironmentStoragePropertiesArgs:
|
|
2073
2316
|
def __init__(__self__, *,
|
|
2074
|
-
azure_file: Optional[pulumi.Input['AzureFilePropertiesArgs']] = None
|
|
2317
|
+
azure_file: Optional[pulumi.Input['AzureFilePropertiesArgs']] = None,
|
|
2318
|
+
smb: Optional[pulumi.Input['SmbStorageArgs']] = None):
|
|
2075
2319
|
"""
|
|
2076
2320
|
Storage properties
|
|
2077
2321
|
:param pulumi.Input['AzureFilePropertiesArgs'] azure_file: Azure file properties
|
|
2322
|
+
:param pulumi.Input['SmbStorageArgs'] smb: SMB storage properties
|
|
2078
2323
|
"""
|
|
2079
2324
|
if azure_file is not None:
|
|
2080
2325
|
pulumi.set(__self__, "azure_file", azure_file)
|
|
2326
|
+
if smb is not None:
|
|
2327
|
+
pulumi.set(__self__, "smb", smb)
|
|
2081
2328
|
|
|
2082
2329
|
@property
|
|
2083
2330
|
@pulumi.getter(name="azureFile")
|
|
@@ -2091,6 +2338,54 @@ class ConnectedEnvironmentStoragePropertiesArgs:
|
|
|
2091
2338
|
def azure_file(self, value: Optional[pulumi.Input['AzureFilePropertiesArgs']]):
|
|
2092
2339
|
pulumi.set(self, "azure_file", value)
|
|
2093
2340
|
|
|
2341
|
+
@property
|
|
2342
|
+
@pulumi.getter
|
|
2343
|
+
def smb(self) -> Optional[pulumi.Input['SmbStorageArgs']]:
|
|
2344
|
+
"""
|
|
2345
|
+
SMB storage properties
|
|
2346
|
+
"""
|
|
2347
|
+
return pulumi.get(self, "smb")
|
|
2348
|
+
|
|
2349
|
+
@smb.setter
|
|
2350
|
+
def smb(self, value: Optional[pulumi.Input['SmbStorageArgs']]):
|
|
2351
|
+
pulumi.set(self, "smb", value)
|
|
2352
|
+
|
|
2353
|
+
|
|
2354
|
+
if not MYPY:
|
|
2355
|
+
class ContainerAppPatchingConfigurationArgsDict(TypedDict):
|
|
2356
|
+
"""
|
|
2357
|
+
Container App auto patch configuration.
|
|
2358
|
+
"""
|
|
2359
|
+
patching_mode: NotRequired[pulumi.Input[Union[builtins.str, 'PatchingMode']]]
|
|
2360
|
+
"""
|
|
2361
|
+
Patching mode for the container app. Null or default in this field will be interpreted as Automatic by RP. Automatic mode will automatically apply available patches. Manual mode will require the user to manually apply patches. Disabled mode will stop patch detection and auto patching.
|
|
2362
|
+
"""
|
|
2363
|
+
elif False:
|
|
2364
|
+
ContainerAppPatchingConfigurationArgsDict: TypeAlias = Mapping[str, Any]
|
|
2365
|
+
|
|
2366
|
+
@pulumi.input_type
|
|
2367
|
+
class ContainerAppPatchingConfigurationArgs:
|
|
2368
|
+
def __init__(__self__, *,
|
|
2369
|
+
patching_mode: Optional[pulumi.Input[Union[builtins.str, 'PatchingMode']]] = None):
|
|
2370
|
+
"""
|
|
2371
|
+
Container App auto patch configuration.
|
|
2372
|
+
:param pulumi.Input[Union[builtins.str, 'PatchingMode']] patching_mode: Patching mode for the container app. Null or default in this field will be interpreted as Automatic by RP. Automatic mode will automatically apply available patches. Manual mode will require the user to manually apply patches. Disabled mode will stop patch detection and auto patching.
|
|
2373
|
+
"""
|
|
2374
|
+
if patching_mode is not None:
|
|
2375
|
+
pulumi.set(__self__, "patching_mode", patching_mode)
|
|
2376
|
+
|
|
2377
|
+
@property
|
|
2378
|
+
@pulumi.getter(name="patchingMode")
|
|
2379
|
+
def patching_mode(self) -> Optional[pulumi.Input[Union[builtins.str, 'PatchingMode']]]:
|
|
2380
|
+
"""
|
|
2381
|
+
Patching mode for the container app. Null or default in this field will be interpreted as Automatic by RP. Automatic mode will automatically apply available patches. Manual mode will require the user to manually apply patches. Disabled mode will stop patch detection and auto patching.
|
|
2382
|
+
"""
|
|
2383
|
+
return pulumi.get(self, "patching_mode")
|
|
2384
|
+
|
|
2385
|
+
@patching_mode.setter
|
|
2386
|
+
def patching_mode(self, value: Optional[pulumi.Input[Union[builtins.str, 'PatchingMode']]]):
|
|
2387
|
+
pulumi.set(self, "patching_mode", value)
|
|
2388
|
+
|
|
2094
2389
|
|
|
2095
2390
|
if not MYPY:
|
|
2096
2391
|
class ContainerAppProbeHttpGetArgsDict(TypedDict):
|
|
@@ -2630,6 +2925,10 @@ if not MYPY:
|
|
|
2630
2925
|
"""
|
|
2631
2926
|
Required CPU in cores, e.g. 0.5
|
|
2632
2927
|
"""
|
|
2928
|
+
gpu: NotRequired[pulumi.Input[builtins.float]]
|
|
2929
|
+
"""
|
|
2930
|
+
Required GPU in cores for GPU based app, e.g. 1.0
|
|
2931
|
+
"""
|
|
2633
2932
|
memory: NotRequired[pulumi.Input[builtins.str]]
|
|
2634
2933
|
"""
|
|
2635
2934
|
Required memory, e.g. "250Mb"
|
|
@@ -2641,14 +2940,18 @@ elif False:
|
|
|
2641
2940
|
class ContainerResourcesArgs:
|
|
2642
2941
|
def __init__(__self__, *,
|
|
2643
2942
|
cpu: Optional[pulumi.Input[builtins.float]] = None,
|
|
2943
|
+
gpu: Optional[pulumi.Input[builtins.float]] = None,
|
|
2644
2944
|
memory: Optional[pulumi.Input[builtins.str]] = None):
|
|
2645
2945
|
"""
|
|
2646
2946
|
Container App container resource requirements.
|
|
2647
2947
|
:param pulumi.Input[builtins.float] cpu: Required CPU in cores, e.g. 0.5
|
|
2948
|
+
:param pulumi.Input[builtins.float] gpu: Required GPU in cores for GPU based app, e.g. 1.0
|
|
2648
2949
|
:param pulumi.Input[builtins.str] memory: Required memory, e.g. "250Mb"
|
|
2649
2950
|
"""
|
|
2650
2951
|
if cpu is not None:
|
|
2651
2952
|
pulumi.set(__self__, "cpu", cpu)
|
|
2953
|
+
if gpu is not None:
|
|
2954
|
+
pulumi.set(__self__, "gpu", gpu)
|
|
2652
2955
|
if memory is not None:
|
|
2653
2956
|
pulumi.set(__self__, "memory", memory)
|
|
2654
2957
|
|
|
@@ -2664,6 +2967,18 @@ class ContainerResourcesArgs:
|
|
|
2664
2967
|
def cpu(self, value: Optional[pulumi.Input[builtins.float]]):
|
|
2665
2968
|
pulumi.set(self, "cpu", value)
|
|
2666
2969
|
|
|
2970
|
+
@property
|
|
2971
|
+
@pulumi.getter
|
|
2972
|
+
def gpu(self) -> Optional[pulumi.Input[builtins.float]]:
|
|
2973
|
+
"""
|
|
2974
|
+
Required GPU in cores for GPU based app, e.g. 1.0
|
|
2975
|
+
"""
|
|
2976
|
+
return pulumi.get(self, "gpu")
|
|
2977
|
+
|
|
2978
|
+
@gpu.setter
|
|
2979
|
+
def gpu(self, value: Optional[pulumi.Input[builtins.float]]):
|
|
2980
|
+
pulumi.set(self, "gpu", value)
|
|
2981
|
+
|
|
2667
2982
|
@property
|
|
2668
2983
|
@pulumi.getter
|
|
2669
2984
|
def memory(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
@@ -2698,6 +3013,10 @@ if not MYPY:
|
|
|
2698
3013
|
"""
|
|
2699
3014
|
Container image tag.
|
|
2700
3015
|
"""
|
|
3016
|
+
image_type: NotRequired[pulumi.Input[Union[builtins.str, 'ImageType']]]
|
|
3017
|
+
"""
|
|
3018
|
+
The type of the image. Set to CloudBuild to let the system manages the image, where user will not be able to update image through image field. Set to ContainerImage for user provided image.
|
|
3019
|
+
"""
|
|
2701
3020
|
name: NotRequired[pulumi.Input[builtins.str]]
|
|
2702
3021
|
"""
|
|
2703
3022
|
Custom container name.
|
|
@@ -2724,6 +3043,7 @@ class ContainerArgs:
|
|
|
2724
3043
|
command: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
|
|
2725
3044
|
env: Optional[pulumi.Input[Sequence[pulumi.Input['EnvironmentVarArgs']]]] = None,
|
|
2726
3045
|
image: Optional[pulumi.Input[builtins.str]] = None,
|
|
3046
|
+
image_type: Optional[pulumi.Input[Union[builtins.str, 'ImageType']]] = None,
|
|
2727
3047
|
name: Optional[pulumi.Input[builtins.str]] = None,
|
|
2728
3048
|
probes: Optional[pulumi.Input[Sequence[pulumi.Input['ContainerAppProbeArgs']]]] = None,
|
|
2729
3049
|
resources: Optional[pulumi.Input['ContainerResourcesArgs']] = None,
|
|
@@ -2734,6 +3054,7 @@ class ContainerArgs:
|
|
|
2734
3054
|
:param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] command: Container start command.
|
|
2735
3055
|
:param pulumi.Input[Sequence[pulumi.Input['EnvironmentVarArgs']]] env: Container environment variables.
|
|
2736
3056
|
:param pulumi.Input[builtins.str] image: Container image tag.
|
|
3057
|
+
:param pulumi.Input[Union[builtins.str, 'ImageType']] image_type: The type of the image. Set to CloudBuild to let the system manages the image, where user will not be able to update image through image field. Set to ContainerImage for user provided image.
|
|
2737
3058
|
:param pulumi.Input[builtins.str] name: Custom container name.
|
|
2738
3059
|
:param pulumi.Input[Sequence[pulumi.Input['ContainerAppProbeArgs']]] probes: List of probes for the container.
|
|
2739
3060
|
:param pulumi.Input['ContainerResourcesArgs'] resources: Container resource requirements.
|
|
@@ -2747,6 +3068,8 @@ class ContainerArgs:
|
|
|
2747
3068
|
pulumi.set(__self__, "env", env)
|
|
2748
3069
|
if image is not None:
|
|
2749
3070
|
pulumi.set(__self__, "image", image)
|
|
3071
|
+
if image_type is not None:
|
|
3072
|
+
pulumi.set(__self__, "image_type", image_type)
|
|
2750
3073
|
if name is not None:
|
|
2751
3074
|
pulumi.set(__self__, "name", name)
|
|
2752
3075
|
if probes is not None:
|
|
@@ -2804,6 +3127,18 @@ class ContainerArgs:
|
|
|
2804
3127
|
def image(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
2805
3128
|
pulumi.set(self, "image", value)
|
|
2806
3129
|
|
|
3130
|
+
@property
|
|
3131
|
+
@pulumi.getter(name="imageType")
|
|
3132
|
+
def image_type(self) -> Optional[pulumi.Input[Union[builtins.str, 'ImageType']]]:
|
|
3133
|
+
"""
|
|
3134
|
+
The type of the image. Set to CloudBuild to let the system manages the image, where user will not be able to update image through image field. Set to ContainerImage for user provided image.
|
|
3135
|
+
"""
|
|
3136
|
+
return pulumi.get(self, "image_type")
|
|
3137
|
+
|
|
3138
|
+
@image_type.setter
|
|
3139
|
+
def image_type(self, value: Optional[pulumi.Input[Union[builtins.str, 'ImageType']]]):
|
|
3140
|
+
pulumi.set(self, "image_type", value)
|
|
3141
|
+
|
|
2807
3142
|
@property
|
|
2808
3143
|
@pulumi.getter
|
|
2809
3144
|
def name(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
@@ -3466,6 +3801,122 @@ class CustomScaleRuleArgs:
|
|
|
3466
3801
|
pulumi.set(self, "type", value)
|
|
3467
3802
|
|
|
3468
3803
|
|
|
3804
|
+
if not MYPY:
|
|
3805
|
+
class DaprAppHealthArgsDict(TypedDict):
|
|
3806
|
+
"""
|
|
3807
|
+
Dapr application health check configuration
|
|
3808
|
+
"""
|
|
3809
|
+
enabled: NotRequired[pulumi.Input[builtins.bool]]
|
|
3810
|
+
"""
|
|
3811
|
+
Boolean indicating if the health probe is enabled
|
|
3812
|
+
"""
|
|
3813
|
+
path: NotRequired[pulumi.Input[builtins.str]]
|
|
3814
|
+
"""
|
|
3815
|
+
Path for the health probe
|
|
3816
|
+
"""
|
|
3817
|
+
probe_interval_seconds: NotRequired[pulumi.Input[builtins.int]]
|
|
3818
|
+
"""
|
|
3819
|
+
Interval for the health probe in seconds
|
|
3820
|
+
"""
|
|
3821
|
+
probe_timeout_milliseconds: NotRequired[pulumi.Input[builtins.int]]
|
|
3822
|
+
"""
|
|
3823
|
+
Timeout for the health probe in milliseconds
|
|
3824
|
+
"""
|
|
3825
|
+
threshold: NotRequired[pulumi.Input[builtins.int]]
|
|
3826
|
+
"""
|
|
3827
|
+
Threshold for the health probe
|
|
3828
|
+
"""
|
|
3829
|
+
elif False:
|
|
3830
|
+
DaprAppHealthArgsDict: TypeAlias = Mapping[str, Any]
|
|
3831
|
+
|
|
3832
|
+
@pulumi.input_type
|
|
3833
|
+
class DaprAppHealthArgs:
|
|
3834
|
+
def __init__(__self__, *,
|
|
3835
|
+
enabled: Optional[pulumi.Input[builtins.bool]] = None,
|
|
3836
|
+
path: Optional[pulumi.Input[builtins.str]] = None,
|
|
3837
|
+
probe_interval_seconds: Optional[pulumi.Input[builtins.int]] = None,
|
|
3838
|
+
probe_timeout_milliseconds: Optional[pulumi.Input[builtins.int]] = None,
|
|
3839
|
+
threshold: Optional[pulumi.Input[builtins.int]] = None):
|
|
3840
|
+
"""
|
|
3841
|
+
Dapr application health check configuration
|
|
3842
|
+
:param pulumi.Input[builtins.bool] enabled: Boolean indicating if the health probe is enabled
|
|
3843
|
+
:param pulumi.Input[builtins.str] path: Path for the health probe
|
|
3844
|
+
:param pulumi.Input[builtins.int] probe_interval_seconds: Interval for the health probe in seconds
|
|
3845
|
+
:param pulumi.Input[builtins.int] probe_timeout_milliseconds: Timeout for the health probe in milliseconds
|
|
3846
|
+
:param pulumi.Input[builtins.int] threshold: Threshold for the health probe
|
|
3847
|
+
"""
|
|
3848
|
+
if enabled is not None:
|
|
3849
|
+
pulumi.set(__self__, "enabled", enabled)
|
|
3850
|
+
if path is not None:
|
|
3851
|
+
pulumi.set(__self__, "path", path)
|
|
3852
|
+
if probe_interval_seconds is not None:
|
|
3853
|
+
pulumi.set(__self__, "probe_interval_seconds", probe_interval_seconds)
|
|
3854
|
+
if probe_timeout_milliseconds is not None:
|
|
3855
|
+
pulumi.set(__self__, "probe_timeout_milliseconds", probe_timeout_milliseconds)
|
|
3856
|
+
if threshold is not None:
|
|
3857
|
+
pulumi.set(__self__, "threshold", threshold)
|
|
3858
|
+
|
|
3859
|
+
@property
|
|
3860
|
+
@pulumi.getter
|
|
3861
|
+
def enabled(self) -> Optional[pulumi.Input[builtins.bool]]:
|
|
3862
|
+
"""
|
|
3863
|
+
Boolean indicating if the health probe is enabled
|
|
3864
|
+
"""
|
|
3865
|
+
return pulumi.get(self, "enabled")
|
|
3866
|
+
|
|
3867
|
+
@enabled.setter
|
|
3868
|
+
def enabled(self, value: Optional[pulumi.Input[builtins.bool]]):
|
|
3869
|
+
pulumi.set(self, "enabled", value)
|
|
3870
|
+
|
|
3871
|
+
@property
|
|
3872
|
+
@pulumi.getter
|
|
3873
|
+
def path(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
3874
|
+
"""
|
|
3875
|
+
Path for the health probe
|
|
3876
|
+
"""
|
|
3877
|
+
return pulumi.get(self, "path")
|
|
3878
|
+
|
|
3879
|
+
@path.setter
|
|
3880
|
+
def path(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
3881
|
+
pulumi.set(self, "path", value)
|
|
3882
|
+
|
|
3883
|
+
@property
|
|
3884
|
+
@pulumi.getter(name="probeIntervalSeconds")
|
|
3885
|
+
def probe_interval_seconds(self) -> Optional[pulumi.Input[builtins.int]]:
|
|
3886
|
+
"""
|
|
3887
|
+
Interval for the health probe in seconds
|
|
3888
|
+
"""
|
|
3889
|
+
return pulumi.get(self, "probe_interval_seconds")
|
|
3890
|
+
|
|
3891
|
+
@probe_interval_seconds.setter
|
|
3892
|
+
def probe_interval_seconds(self, value: Optional[pulumi.Input[builtins.int]]):
|
|
3893
|
+
pulumi.set(self, "probe_interval_seconds", value)
|
|
3894
|
+
|
|
3895
|
+
@property
|
|
3896
|
+
@pulumi.getter(name="probeTimeoutMilliseconds")
|
|
3897
|
+
def probe_timeout_milliseconds(self) -> Optional[pulumi.Input[builtins.int]]:
|
|
3898
|
+
"""
|
|
3899
|
+
Timeout for the health probe in milliseconds
|
|
3900
|
+
"""
|
|
3901
|
+
return pulumi.get(self, "probe_timeout_milliseconds")
|
|
3902
|
+
|
|
3903
|
+
@probe_timeout_milliseconds.setter
|
|
3904
|
+
def probe_timeout_milliseconds(self, value: Optional[pulumi.Input[builtins.int]]):
|
|
3905
|
+
pulumi.set(self, "probe_timeout_milliseconds", value)
|
|
3906
|
+
|
|
3907
|
+
@property
|
|
3908
|
+
@pulumi.getter
|
|
3909
|
+
def threshold(self) -> Optional[pulumi.Input[builtins.int]]:
|
|
3910
|
+
"""
|
|
3911
|
+
Threshold for the health probe
|
|
3912
|
+
"""
|
|
3913
|
+
return pulumi.get(self, "threshold")
|
|
3914
|
+
|
|
3915
|
+
@threshold.setter
|
|
3916
|
+
def threshold(self, value: Optional[pulumi.Input[builtins.int]]):
|
|
3917
|
+
pulumi.set(self, "threshold", value)
|
|
3918
|
+
|
|
3919
|
+
|
|
3469
3920
|
if not MYPY:
|
|
3470
3921
|
class DaprComponentResiliencyPolicyCircuitBreakerPolicyConfigurationArgsDict(TypedDict):
|
|
3471
3922
|
"""
|
|
@@ -3766,6 +4217,82 @@ class DaprComponentResiliencyPolicyTimeoutPolicyConfigurationArgs:
|
|
|
3766
4217
|
pulumi.set(self, "response_timeout_in_seconds", value)
|
|
3767
4218
|
|
|
3768
4219
|
|
|
4220
|
+
if not MYPY:
|
|
4221
|
+
class DaprComponentServiceBindingArgsDict(TypedDict):
|
|
4222
|
+
"""
|
|
4223
|
+
Configuration to bind a Dapr Component to a dev ContainerApp Service
|
|
4224
|
+
"""
|
|
4225
|
+
metadata: NotRequired[pulumi.Input['DaprServiceBindMetadataArgsDict']]
|
|
4226
|
+
"""
|
|
4227
|
+
Service bind metadata
|
|
4228
|
+
"""
|
|
4229
|
+
name: NotRequired[pulumi.Input[builtins.str]]
|
|
4230
|
+
"""
|
|
4231
|
+
Name of the service bind
|
|
4232
|
+
"""
|
|
4233
|
+
service_id: NotRequired[pulumi.Input[builtins.str]]
|
|
4234
|
+
"""
|
|
4235
|
+
Resource id of the target service
|
|
4236
|
+
"""
|
|
4237
|
+
elif False:
|
|
4238
|
+
DaprComponentServiceBindingArgsDict: TypeAlias = Mapping[str, Any]
|
|
4239
|
+
|
|
4240
|
+
@pulumi.input_type
|
|
4241
|
+
class DaprComponentServiceBindingArgs:
|
|
4242
|
+
def __init__(__self__, *,
|
|
4243
|
+
metadata: Optional[pulumi.Input['DaprServiceBindMetadataArgs']] = None,
|
|
4244
|
+
name: Optional[pulumi.Input[builtins.str]] = None,
|
|
4245
|
+
service_id: Optional[pulumi.Input[builtins.str]] = None):
|
|
4246
|
+
"""
|
|
4247
|
+
Configuration to bind a Dapr Component to a dev ContainerApp Service
|
|
4248
|
+
:param pulumi.Input['DaprServiceBindMetadataArgs'] metadata: Service bind metadata
|
|
4249
|
+
:param pulumi.Input[builtins.str] name: Name of the service bind
|
|
4250
|
+
:param pulumi.Input[builtins.str] service_id: Resource id of the target service
|
|
4251
|
+
"""
|
|
4252
|
+
if metadata is not None:
|
|
4253
|
+
pulumi.set(__self__, "metadata", metadata)
|
|
4254
|
+
if name is not None:
|
|
4255
|
+
pulumi.set(__self__, "name", name)
|
|
4256
|
+
if service_id is not None:
|
|
4257
|
+
pulumi.set(__self__, "service_id", service_id)
|
|
4258
|
+
|
|
4259
|
+
@property
|
|
4260
|
+
@pulumi.getter
|
|
4261
|
+
def metadata(self) -> Optional[pulumi.Input['DaprServiceBindMetadataArgs']]:
|
|
4262
|
+
"""
|
|
4263
|
+
Service bind metadata
|
|
4264
|
+
"""
|
|
4265
|
+
return pulumi.get(self, "metadata")
|
|
4266
|
+
|
|
4267
|
+
@metadata.setter
|
|
4268
|
+
def metadata(self, value: Optional[pulumi.Input['DaprServiceBindMetadataArgs']]):
|
|
4269
|
+
pulumi.set(self, "metadata", value)
|
|
4270
|
+
|
|
4271
|
+
@property
|
|
4272
|
+
@pulumi.getter
|
|
4273
|
+
def name(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
4274
|
+
"""
|
|
4275
|
+
Name of the service bind
|
|
4276
|
+
"""
|
|
4277
|
+
return pulumi.get(self, "name")
|
|
4278
|
+
|
|
4279
|
+
@name.setter
|
|
4280
|
+
def name(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
4281
|
+
pulumi.set(self, "name", value)
|
|
4282
|
+
|
|
4283
|
+
@property
|
|
4284
|
+
@pulumi.getter(name="serviceId")
|
|
4285
|
+
def service_id(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
4286
|
+
"""
|
|
4287
|
+
Resource id of the target service
|
|
4288
|
+
"""
|
|
4289
|
+
return pulumi.get(self, "service_id")
|
|
4290
|
+
|
|
4291
|
+
@service_id.setter
|
|
4292
|
+
def service_id(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
4293
|
+
pulumi.set(self, "service_id", value)
|
|
4294
|
+
|
|
4295
|
+
|
|
3769
4296
|
if not MYPY:
|
|
3770
4297
|
class DaprMetadataArgsDict(TypedDict):
|
|
3771
4298
|
"""
|
|
@@ -3843,13 +4370,69 @@ class DaprMetadataArgs:
|
|
|
3843
4370
|
|
|
3844
4371
|
|
|
3845
4372
|
if not MYPY:
|
|
3846
|
-
class
|
|
4373
|
+
class DaprServiceBindMetadataArgsDict(TypedDict):
|
|
3847
4374
|
"""
|
|
3848
|
-
Dapr
|
|
4375
|
+
Dapr component metadata.
|
|
3849
4376
|
"""
|
|
3850
|
-
|
|
4377
|
+
name: NotRequired[pulumi.Input[builtins.str]]
|
|
3851
4378
|
"""
|
|
3852
|
-
|
|
4379
|
+
Service bind metadata property name.
|
|
4380
|
+
"""
|
|
4381
|
+
value: NotRequired[pulumi.Input[builtins.str]]
|
|
4382
|
+
"""
|
|
4383
|
+
Service bind metadata property value.
|
|
4384
|
+
"""
|
|
4385
|
+
elif False:
|
|
4386
|
+
DaprServiceBindMetadataArgsDict: TypeAlias = Mapping[str, Any]
|
|
4387
|
+
|
|
4388
|
+
@pulumi.input_type
|
|
4389
|
+
class DaprServiceBindMetadataArgs:
|
|
4390
|
+
def __init__(__self__, *,
|
|
4391
|
+
name: Optional[pulumi.Input[builtins.str]] = None,
|
|
4392
|
+
value: Optional[pulumi.Input[builtins.str]] = None):
|
|
4393
|
+
"""
|
|
4394
|
+
Dapr component metadata.
|
|
4395
|
+
:param pulumi.Input[builtins.str] name: Service bind metadata property name.
|
|
4396
|
+
:param pulumi.Input[builtins.str] value: Service bind metadata property value.
|
|
4397
|
+
"""
|
|
4398
|
+
if name is not None:
|
|
4399
|
+
pulumi.set(__self__, "name", name)
|
|
4400
|
+
if value is not None:
|
|
4401
|
+
pulumi.set(__self__, "value", value)
|
|
4402
|
+
|
|
4403
|
+
@property
|
|
4404
|
+
@pulumi.getter
|
|
4405
|
+
def name(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
4406
|
+
"""
|
|
4407
|
+
Service bind metadata property name.
|
|
4408
|
+
"""
|
|
4409
|
+
return pulumi.get(self, "name")
|
|
4410
|
+
|
|
4411
|
+
@name.setter
|
|
4412
|
+
def name(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
4413
|
+
pulumi.set(self, "name", value)
|
|
4414
|
+
|
|
4415
|
+
@property
|
|
4416
|
+
@pulumi.getter
|
|
4417
|
+
def value(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
4418
|
+
"""
|
|
4419
|
+
Service bind metadata property value.
|
|
4420
|
+
"""
|
|
4421
|
+
return pulumi.get(self, "value")
|
|
4422
|
+
|
|
4423
|
+
@value.setter
|
|
4424
|
+
def value(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
4425
|
+
pulumi.set(self, "value", value)
|
|
4426
|
+
|
|
4427
|
+
|
|
4428
|
+
if not MYPY:
|
|
4429
|
+
class DaprSubscriptionBulkSubscribeOptionsArgsDict(TypedDict):
|
|
4430
|
+
"""
|
|
4431
|
+
Dapr PubSub Bulk Subscription Options.
|
|
4432
|
+
"""
|
|
4433
|
+
enabled: NotRequired[pulumi.Input[builtins.bool]]
|
|
4434
|
+
"""
|
|
4435
|
+
Enable bulk subscription
|
|
3853
4436
|
"""
|
|
3854
4437
|
max_await_duration_ms: NotRequired[pulumi.Input[builtins.int]]
|
|
3855
4438
|
"""
|
|
@@ -4037,6 +4620,10 @@ if not MYPY:
|
|
|
4037
4620
|
"""
|
|
4038
4621
|
Container App Dapr configuration.
|
|
4039
4622
|
"""
|
|
4623
|
+
app_health: NotRequired[pulumi.Input['DaprAppHealthArgsDict']]
|
|
4624
|
+
"""
|
|
4625
|
+
Dapr application health check configuration
|
|
4626
|
+
"""
|
|
4040
4627
|
app_id: NotRequired[pulumi.Input[builtins.str]]
|
|
4041
4628
|
"""
|
|
4042
4629
|
Dapr application identifier
|
|
@@ -4069,12 +4656,17 @@ if not MYPY:
|
|
|
4069
4656
|
"""
|
|
4070
4657
|
Sets the log level for the Dapr sidecar. Allowed values are debug, info, warn, error. Default is info.
|
|
4071
4658
|
"""
|
|
4659
|
+
max_concurrency: NotRequired[pulumi.Input[builtins.int]]
|
|
4660
|
+
"""
|
|
4661
|
+
Maximum number of concurrent requests, events handled by the Dapr sidecar
|
|
4662
|
+
"""
|
|
4072
4663
|
elif False:
|
|
4073
4664
|
DaprArgsDict: TypeAlias = Mapping[str, Any]
|
|
4074
4665
|
|
|
4075
4666
|
@pulumi.input_type
|
|
4076
4667
|
class DaprArgs:
|
|
4077
4668
|
def __init__(__self__, *,
|
|
4669
|
+
app_health: Optional[pulumi.Input['DaprAppHealthArgs']] = None,
|
|
4078
4670
|
app_id: Optional[pulumi.Input[builtins.str]] = None,
|
|
4079
4671
|
app_port: Optional[pulumi.Input[builtins.int]] = None,
|
|
4080
4672
|
app_protocol: Optional[pulumi.Input[Union[builtins.str, 'AppProtocol']]] = None,
|
|
@@ -4082,9 +4674,11 @@ class DaprArgs:
|
|
|
4082
4674
|
enabled: Optional[pulumi.Input[builtins.bool]] = None,
|
|
4083
4675
|
http_max_request_size: Optional[pulumi.Input[builtins.int]] = None,
|
|
4084
4676
|
http_read_buffer_size: Optional[pulumi.Input[builtins.int]] = None,
|
|
4085
|
-
log_level: Optional[pulumi.Input[Union[builtins.str, 'LogLevel']]] = None
|
|
4677
|
+
log_level: Optional[pulumi.Input[Union[builtins.str, 'LogLevel']]] = None,
|
|
4678
|
+
max_concurrency: Optional[pulumi.Input[builtins.int]] = None):
|
|
4086
4679
|
"""
|
|
4087
4680
|
Container App Dapr configuration.
|
|
4681
|
+
:param pulumi.Input['DaprAppHealthArgs'] app_health: Dapr application health check configuration
|
|
4088
4682
|
:param pulumi.Input[builtins.str] app_id: Dapr application identifier
|
|
4089
4683
|
:param pulumi.Input[builtins.int] app_port: Tells Dapr which port your application is listening on
|
|
4090
4684
|
:param pulumi.Input[Union[builtins.str, 'AppProtocol']] app_protocol: Tells Dapr which protocol your application is using. Valid options are http and grpc. Default is http
|
|
@@ -4093,7 +4687,10 @@ class DaprArgs:
|
|
|
4093
4687
|
:param pulumi.Input[builtins.int] http_max_request_size: Increasing max size of request body http and grpc servers parameter in MB to handle uploading of big files. Default is 4 MB.
|
|
4094
4688
|
:param pulumi.Input[builtins.int] http_read_buffer_size: Dapr max size of http header read buffer in KB to handle when sending multi-KB headers. Default is 65KB.
|
|
4095
4689
|
:param pulumi.Input[Union[builtins.str, 'LogLevel']] log_level: Sets the log level for the Dapr sidecar. Allowed values are debug, info, warn, error. Default is info.
|
|
4690
|
+
:param pulumi.Input[builtins.int] max_concurrency: Maximum number of concurrent requests, events handled by the Dapr sidecar
|
|
4096
4691
|
"""
|
|
4692
|
+
if app_health is not None:
|
|
4693
|
+
pulumi.set(__self__, "app_health", app_health)
|
|
4097
4694
|
if app_id is not None:
|
|
4098
4695
|
pulumi.set(__self__, "app_id", app_id)
|
|
4099
4696
|
if app_port is not None:
|
|
@@ -4114,6 +4711,20 @@ class DaprArgs:
|
|
|
4114
4711
|
pulumi.set(__self__, "http_read_buffer_size", http_read_buffer_size)
|
|
4115
4712
|
if log_level is not None:
|
|
4116
4713
|
pulumi.set(__self__, "log_level", log_level)
|
|
4714
|
+
if max_concurrency is not None:
|
|
4715
|
+
pulumi.set(__self__, "max_concurrency", max_concurrency)
|
|
4716
|
+
|
|
4717
|
+
@property
|
|
4718
|
+
@pulumi.getter(name="appHealth")
|
|
4719
|
+
def app_health(self) -> Optional[pulumi.Input['DaprAppHealthArgs']]:
|
|
4720
|
+
"""
|
|
4721
|
+
Dapr application health check configuration
|
|
4722
|
+
"""
|
|
4723
|
+
return pulumi.get(self, "app_health")
|
|
4724
|
+
|
|
4725
|
+
@app_health.setter
|
|
4726
|
+
def app_health(self, value: Optional[pulumi.Input['DaprAppHealthArgs']]):
|
|
4727
|
+
pulumi.set(self, "app_health", value)
|
|
4117
4728
|
|
|
4118
4729
|
@property
|
|
4119
4730
|
@pulumi.getter(name="appId")
|
|
@@ -4211,6 +4822,74 @@ class DaprArgs:
|
|
|
4211
4822
|
def log_level(self, value: Optional[pulumi.Input[Union[builtins.str, 'LogLevel']]]):
|
|
4212
4823
|
pulumi.set(self, "log_level", value)
|
|
4213
4824
|
|
|
4825
|
+
@property
|
|
4826
|
+
@pulumi.getter(name="maxConcurrency")
|
|
4827
|
+
def max_concurrency(self) -> Optional[pulumi.Input[builtins.int]]:
|
|
4828
|
+
"""
|
|
4829
|
+
Maximum number of concurrent requests, events handled by the Dapr sidecar
|
|
4830
|
+
"""
|
|
4831
|
+
return pulumi.get(self, "max_concurrency")
|
|
4832
|
+
|
|
4833
|
+
@max_concurrency.setter
|
|
4834
|
+
def max_concurrency(self, value: Optional[pulumi.Input[builtins.int]]):
|
|
4835
|
+
pulumi.set(self, "max_concurrency", value)
|
|
4836
|
+
|
|
4837
|
+
|
|
4838
|
+
if not MYPY:
|
|
4839
|
+
class DataDogConfigurationArgsDict(TypedDict):
|
|
4840
|
+
"""
|
|
4841
|
+
Configuration of datadog
|
|
4842
|
+
"""
|
|
4843
|
+
key: NotRequired[pulumi.Input[builtins.str]]
|
|
4844
|
+
"""
|
|
4845
|
+
The data dog api key
|
|
4846
|
+
"""
|
|
4847
|
+
site: NotRequired[pulumi.Input[builtins.str]]
|
|
4848
|
+
"""
|
|
4849
|
+
The data dog site
|
|
4850
|
+
"""
|
|
4851
|
+
elif False:
|
|
4852
|
+
DataDogConfigurationArgsDict: TypeAlias = Mapping[str, Any]
|
|
4853
|
+
|
|
4854
|
+
@pulumi.input_type
|
|
4855
|
+
class DataDogConfigurationArgs:
|
|
4856
|
+
def __init__(__self__, *,
|
|
4857
|
+
key: Optional[pulumi.Input[builtins.str]] = None,
|
|
4858
|
+
site: Optional[pulumi.Input[builtins.str]] = None):
|
|
4859
|
+
"""
|
|
4860
|
+
Configuration of datadog
|
|
4861
|
+
:param pulumi.Input[builtins.str] key: The data dog api key
|
|
4862
|
+
:param pulumi.Input[builtins.str] site: The data dog site
|
|
4863
|
+
"""
|
|
4864
|
+
if key is not None:
|
|
4865
|
+
pulumi.set(__self__, "key", key)
|
|
4866
|
+
if site is not None:
|
|
4867
|
+
pulumi.set(__self__, "site", site)
|
|
4868
|
+
|
|
4869
|
+
@property
|
|
4870
|
+
@pulumi.getter
|
|
4871
|
+
def key(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
4872
|
+
"""
|
|
4873
|
+
The data dog api key
|
|
4874
|
+
"""
|
|
4875
|
+
return pulumi.get(self, "key")
|
|
4876
|
+
|
|
4877
|
+
@key.setter
|
|
4878
|
+
def key(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
4879
|
+
pulumi.set(self, "key", value)
|
|
4880
|
+
|
|
4881
|
+
@property
|
|
4882
|
+
@pulumi.getter
|
|
4883
|
+
def site(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
4884
|
+
"""
|
|
4885
|
+
The data dog site
|
|
4886
|
+
"""
|
|
4887
|
+
return pulumi.get(self, "site")
|
|
4888
|
+
|
|
4889
|
+
@site.setter
|
|
4890
|
+
def site(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
4891
|
+
pulumi.set(self, "site", value)
|
|
4892
|
+
|
|
4214
4893
|
|
|
4215
4894
|
if not MYPY:
|
|
4216
4895
|
class DefaultAuthorizationPolicyArgsDict(TypedDict):
|
|
@@ -4268,6 +4947,190 @@ class DefaultAuthorizationPolicyArgs:
|
|
|
4268
4947
|
pulumi.set(self, "allowed_principals", value)
|
|
4269
4948
|
|
|
4270
4949
|
|
|
4950
|
+
if not MYPY:
|
|
4951
|
+
class DestinationsConfigurationArgsDict(TypedDict):
|
|
4952
|
+
"""
|
|
4953
|
+
Configuration of Open Telemetry destinations
|
|
4954
|
+
"""
|
|
4955
|
+
data_dog_configuration: NotRequired[pulumi.Input['DataDogConfigurationArgsDict']]
|
|
4956
|
+
"""
|
|
4957
|
+
Open telemetry datadog destination configuration
|
|
4958
|
+
"""
|
|
4959
|
+
otlp_configurations: NotRequired[pulumi.Input[Sequence[pulumi.Input['OtlpConfigurationArgsDict']]]]
|
|
4960
|
+
"""
|
|
4961
|
+
Open telemetry otlp configurations
|
|
4962
|
+
"""
|
|
4963
|
+
elif False:
|
|
4964
|
+
DestinationsConfigurationArgsDict: TypeAlias = Mapping[str, Any]
|
|
4965
|
+
|
|
4966
|
+
@pulumi.input_type
|
|
4967
|
+
class DestinationsConfigurationArgs:
|
|
4968
|
+
def __init__(__self__, *,
|
|
4969
|
+
data_dog_configuration: Optional[pulumi.Input['DataDogConfigurationArgs']] = None,
|
|
4970
|
+
otlp_configurations: Optional[pulumi.Input[Sequence[pulumi.Input['OtlpConfigurationArgs']]]] = None):
|
|
4971
|
+
"""
|
|
4972
|
+
Configuration of Open Telemetry destinations
|
|
4973
|
+
:param pulumi.Input['DataDogConfigurationArgs'] data_dog_configuration: Open telemetry datadog destination configuration
|
|
4974
|
+
:param pulumi.Input[Sequence[pulumi.Input['OtlpConfigurationArgs']]] otlp_configurations: Open telemetry otlp configurations
|
|
4975
|
+
"""
|
|
4976
|
+
if data_dog_configuration is not None:
|
|
4977
|
+
pulumi.set(__self__, "data_dog_configuration", data_dog_configuration)
|
|
4978
|
+
if otlp_configurations is not None:
|
|
4979
|
+
pulumi.set(__self__, "otlp_configurations", otlp_configurations)
|
|
4980
|
+
|
|
4981
|
+
@property
|
|
4982
|
+
@pulumi.getter(name="dataDogConfiguration")
|
|
4983
|
+
def data_dog_configuration(self) -> Optional[pulumi.Input['DataDogConfigurationArgs']]:
|
|
4984
|
+
"""
|
|
4985
|
+
Open telemetry datadog destination configuration
|
|
4986
|
+
"""
|
|
4987
|
+
return pulumi.get(self, "data_dog_configuration")
|
|
4988
|
+
|
|
4989
|
+
@data_dog_configuration.setter
|
|
4990
|
+
def data_dog_configuration(self, value: Optional[pulumi.Input['DataDogConfigurationArgs']]):
|
|
4991
|
+
pulumi.set(self, "data_dog_configuration", value)
|
|
4992
|
+
|
|
4993
|
+
@property
|
|
4994
|
+
@pulumi.getter(name="otlpConfigurations")
|
|
4995
|
+
def otlp_configurations(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['OtlpConfigurationArgs']]]]:
|
|
4996
|
+
"""
|
|
4997
|
+
Open telemetry otlp configurations
|
|
4998
|
+
"""
|
|
4999
|
+
return pulumi.get(self, "otlp_configurations")
|
|
5000
|
+
|
|
5001
|
+
@otlp_configurations.setter
|
|
5002
|
+
def otlp_configurations(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['OtlpConfigurationArgs']]]]):
|
|
5003
|
+
pulumi.set(self, "otlp_configurations", value)
|
|
5004
|
+
|
|
5005
|
+
|
|
5006
|
+
if not MYPY:
|
|
5007
|
+
class DiskEncryptionConfigurationAuthArgsDict(TypedDict):
|
|
5008
|
+
"""
|
|
5009
|
+
Configuration properties for the authentication to the Key Vault
|
|
5010
|
+
"""
|
|
5011
|
+
identity: NotRequired[pulumi.Input[builtins.str]]
|
|
5012
|
+
"""
|
|
5013
|
+
Resource ID of a user-assigned managed identity to authenticate to the Key Vault. The identity must be assigned to the managed environment, in the same tenant as the Key Vault, and it must have the following key permissions on the Key Vault: wrapkey, unwrapkey, get.
|
|
5014
|
+
"""
|
|
5015
|
+
elif False:
|
|
5016
|
+
DiskEncryptionConfigurationAuthArgsDict: TypeAlias = Mapping[str, Any]
|
|
5017
|
+
|
|
5018
|
+
@pulumi.input_type
|
|
5019
|
+
class DiskEncryptionConfigurationAuthArgs:
|
|
5020
|
+
def __init__(__self__, *,
|
|
5021
|
+
identity: Optional[pulumi.Input[builtins.str]] = None):
|
|
5022
|
+
"""
|
|
5023
|
+
Configuration properties for the authentication to the Key Vault
|
|
5024
|
+
:param pulumi.Input[builtins.str] identity: Resource ID of a user-assigned managed identity to authenticate to the Key Vault. The identity must be assigned to the managed environment, in the same tenant as the Key Vault, and it must have the following key permissions on the Key Vault: wrapkey, unwrapkey, get.
|
|
5025
|
+
"""
|
|
5026
|
+
if identity is not None:
|
|
5027
|
+
pulumi.set(__self__, "identity", identity)
|
|
5028
|
+
|
|
5029
|
+
@property
|
|
5030
|
+
@pulumi.getter
|
|
5031
|
+
def identity(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
5032
|
+
"""
|
|
5033
|
+
Resource ID of a user-assigned managed identity to authenticate to the Key Vault. The identity must be assigned to the managed environment, in the same tenant as the Key Vault, and it must have the following key permissions on the Key Vault: wrapkey, unwrapkey, get.
|
|
5034
|
+
"""
|
|
5035
|
+
return pulumi.get(self, "identity")
|
|
5036
|
+
|
|
5037
|
+
@identity.setter
|
|
5038
|
+
def identity(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
5039
|
+
pulumi.set(self, "identity", value)
|
|
5040
|
+
|
|
5041
|
+
|
|
5042
|
+
if not MYPY:
|
|
5043
|
+
class DiskEncryptionConfigurationKeyVaultConfigurationArgsDict(TypedDict):
|
|
5044
|
+
"""
|
|
5045
|
+
The Key Vault that contains your key to use for disk encryption. The Key Vault must be in the same region as the Managed Environment.
|
|
5046
|
+
"""
|
|
5047
|
+
auth: NotRequired[pulumi.Input['DiskEncryptionConfigurationAuthArgsDict']]
|
|
5048
|
+
"""
|
|
5049
|
+
Configuration properties for the authentication to the Key Vault
|
|
5050
|
+
"""
|
|
5051
|
+
key_url: NotRequired[pulumi.Input[builtins.str]]
|
|
5052
|
+
"""
|
|
5053
|
+
Key URL pointing to a key in KeyVault. Version segment of the Url is required.
|
|
5054
|
+
"""
|
|
5055
|
+
elif False:
|
|
5056
|
+
DiskEncryptionConfigurationKeyVaultConfigurationArgsDict: TypeAlias = Mapping[str, Any]
|
|
5057
|
+
|
|
5058
|
+
@pulumi.input_type
|
|
5059
|
+
class DiskEncryptionConfigurationKeyVaultConfigurationArgs:
|
|
5060
|
+
def __init__(__self__, *,
|
|
5061
|
+
auth: Optional[pulumi.Input['DiskEncryptionConfigurationAuthArgs']] = None,
|
|
5062
|
+
key_url: Optional[pulumi.Input[builtins.str]] = None):
|
|
5063
|
+
"""
|
|
5064
|
+
The Key Vault that contains your key to use for disk encryption. The Key Vault must be in the same region as the Managed Environment.
|
|
5065
|
+
:param pulumi.Input['DiskEncryptionConfigurationAuthArgs'] auth: Configuration properties for the authentication to the Key Vault
|
|
5066
|
+
:param pulumi.Input[builtins.str] key_url: Key URL pointing to a key in KeyVault. Version segment of the Url is required.
|
|
5067
|
+
"""
|
|
5068
|
+
if auth is not None:
|
|
5069
|
+
pulumi.set(__self__, "auth", auth)
|
|
5070
|
+
if key_url is not None:
|
|
5071
|
+
pulumi.set(__self__, "key_url", key_url)
|
|
5072
|
+
|
|
5073
|
+
@property
|
|
5074
|
+
@pulumi.getter
|
|
5075
|
+
def auth(self) -> Optional[pulumi.Input['DiskEncryptionConfigurationAuthArgs']]:
|
|
5076
|
+
"""
|
|
5077
|
+
Configuration properties for the authentication to the Key Vault
|
|
5078
|
+
"""
|
|
5079
|
+
return pulumi.get(self, "auth")
|
|
5080
|
+
|
|
5081
|
+
@auth.setter
|
|
5082
|
+
def auth(self, value: Optional[pulumi.Input['DiskEncryptionConfigurationAuthArgs']]):
|
|
5083
|
+
pulumi.set(self, "auth", value)
|
|
5084
|
+
|
|
5085
|
+
@property
|
|
5086
|
+
@pulumi.getter(name="keyUrl")
|
|
5087
|
+
def key_url(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
5088
|
+
"""
|
|
5089
|
+
Key URL pointing to a key in KeyVault. Version segment of the Url is required.
|
|
5090
|
+
"""
|
|
5091
|
+
return pulumi.get(self, "key_url")
|
|
5092
|
+
|
|
5093
|
+
@key_url.setter
|
|
5094
|
+
def key_url(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
5095
|
+
pulumi.set(self, "key_url", value)
|
|
5096
|
+
|
|
5097
|
+
|
|
5098
|
+
if not MYPY:
|
|
5099
|
+
class DiskEncryptionConfigurationArgsDict(TypedDict):
|
|
5100
|
+
"""
|
|
5101
|
+
Configuration properties for disk encryption
|
|
5102
|
+
"""
|
|
5103
|
+
key_vault_configuration: NotRequired[pulumi.Input['DiskEncryptionConfigurationKeyVaultConfigurationArgsDict']]
|
|
5104
|
+
"""
|
|
5105
|
+
The Key Vault that contains your key to use for disk encryption. The Key Vault must be in the same region as the Managed Environment.
|
|
5106
|
+
"""
|
|
5107
|
+
elif False:
|
|
5108
|
+
DiskEncryptionConfigurationArgsDict: TypeAlias = Mapping[str, Any]
|
|
5109
|
+
|
|
5110
|
+
@pulumi.input_type
|
|
5111
|
+
class DiskEncryptionConfigurationArgs:
|
|
5112
|
+
def __init__(__self__, *,
|
|
5113
|
+
key_vault_configuration: Optional[pulumi.Input['DiskEncryptionConfigurationKeyVaultConfigurationArgs']] = None):
|
|
5114
|
+
"""
|
|
5115
|
+
Configuration properties for disk encryption
|
|
5116
|
+
:param pulumi.Input['DiskEncryptionConfigurationKeyVaultConfigurationArgs'] key_vault_configuration: The Key Vault that contains your key to use for disk encryption. The Key Vault must be in the same region as the Managed Environment.
|
|
5117
|
+
"""
|
|
5118
|
+
if key_vault_configuration is not None:
|
|
5119
|
+
pulumi.set(__self__, "key_vault_configuration", key_vault_configuration)
|
|
5120
|
+
|
|
5121
|
+
@property
|
|
5122
|
+
@pulumi.getter(name="keyVaultConfiguration")
|
|
5123
|
+
def key_vault_configuration(self) -> Optional[pulumi.Input['DiskEncryptionConfigurationKeyVaultConfigurationArgs']]:
|
|
5124
|
+
"""
|
|
5125
|
+
The Key Vault that contains your key to use for disk encryption. The Key Vault must be in the same region as the Managed Environment.
|
|
5126
|
+
"""
|
|
5127
|
+
return pulumi.get(self, "key_vault_configuration")
|
|
5128
|
+
|
|
5129
|
+
@key_vault_configuration.setter
|
|
5130
|
+
def key_vault_configuration(self, value: Optional[pulumi.Input['DiskEncryptionConfigurationKeyVaultConfigurationArgs']]):
|
|
5131
|
+
pulumi.set(self, "key_vault_configuration", value)
|
|
5132
|
+
|
|
5133
|
+
|
|
4271
5134
|
if not MYPY:
|
|
4272
5135
|
class DotNetComponentConfigurationPropertyArgsDict(TypedDict):
|
|
4273
5136
|
"""
|
|
@@ -4915,10 +5778,18 @@ if not MYPY:
|
|
|
4915
5778
|
"""
|
|
4916
5779
|
AzureCredentials configurations.
|
|
4917
5780
|
"""
|
|
5781
|
+
build_environment_variables: NotRequired[pulumi.Input[Sequence[pulumi.Input['EnvironmentVariableArgsDict']]]]
|
|
5782
|
+
"""
|
|
5783
|
+
List of environment variables to be passed to the build.
|
|
5784
|
+
"""
|
|
4918
5785
|
context_path: NotRequired[pulumi.Input[builtins.str]]
|
|
4919
5786
|
"""
|
|
4920
5787
|
Context path
|
|
4921
5788
|
"""
|
|
5789
|
+
dockerfile_path: NotRequired[pulumi.Input[builtins.str]]
|
|
5790
|
+
"""
|
|
5791
|
+
Dockerfile path
|
|
5792
|
+
"""
|
|
4922
5793
|
github_personal_access_token: NotRequired[pulumi.Input[builtins.str]]
|
|
4923
5794
|
"""
|
|
4924
5795
|
One time Github PAT to configure github environment
|
|
@@ -4954,7 +5825,9 @@ elif False:
|
|
|
4954
5825
|
class GithubActionConfigurationArgs:
|
|
4955
5826
|
def __init__(__self__, *,
|
|
4956
5827
|
azure_credentials: Optional[pulumi.Input['AzureCredentialsArgs']] = None,
|
|
5828
|
+
build_environment_variables: Optional[pulumi.Input[Sequence[pulumi.Input['EnvironmentVariableArgs']]]] = None,
|
|
4957
5829
|
context_path: Optional[pulumi.Input[builtins.str]] = None,
|
|
5830
|
+
dockerfile_path: Optional[pulumi.Input[builtins.str]] = None,
|
|
4958
5831
|
github_personal_access_token: Optional[pulumi.Input[builtins.str]] = None,
|
|
4959
5832
|
image: Optional[pulumi.Input[builtins.str]] = None,
|
|
4960
5833
|
os: Optional[pulumi.Input[builtins.str]] = None,
|
|
@@ -4965,7 +5838,9 @@ class GithubActionConfigurationArgs:
|
|
|
4965
5838
|
"""
|
|
4966
5839
|
Configuration properties that define the mutable settings of a Container App SourceControl
|
|
4967
5840
|
:param pulumi.Input['AzureCredentialsArgs'] azure_credentials: AzureCredentials configurations.
|
|
5841
|
+
:param pulumi.Input[Sequence[pulumi.Input['EnvironmentVariableArgs']]] build_environment_variables: List of environment variables to be passed to the build.
|
|
4968
5842
|
:param pulumi.Input[builtins.str] context_path: Context path
|
|
5843
|
+
:param pulumi.Input[builtins.str] dockerfile_path: Dockerfile path
|
|
4969
5844
|
:param pulumi.Input[builtins.str] github_personal_access_token: One time Github PAT to configure github environment
|
|
4970
5845
|
:param pulumi.Input[builtins.str] image: Image name
|
|
4971
5846
|
:param pulumi.Input[builtins.str] os: Operation system
|
|
@@ -4976,8 +5851,12 @@ class GithubActionConfigurationArgs:
|
|
|
4976
5851
|
"""
|
|
4977
5852
|
if azure_credentials is not None:
|
|
4978
5853
|
pulumi.set(__self__, "azure_credentials", azure_credentials)
|
|
5854
|
+
if build_environment_variables is not None:
|
|
5855
|
+
pulumi.set(__self__, "build_environment_variables", build_environment_variables)
|
|
4979
5856
|
if context_path is not None:
|
|
4980
5857
|
pulumi.set(__self__, "context_path", context_path)
|
|
5858
|
+
if dockerfile_path is not None:
|
|
5859
|
+
pulumi.set(__self__, "dockerfile_path", dockerfile_path)
|
|
4981
5860
|
if github_personal_access_token is not None:
|
|
4982
5861
|
pulumi.set(__self__, "github_personal_access_token", github_personal_access_token)
|
|
4983
5862
|
if image is not None:
|
|
@@ -5005,6 +5884,18 @@ class GithubActionConfigurationArgs:
|
|
|
5005
5884
|
def azure_credentials(self, value: Optional[pulumi.Input['AzureCredentialsArgs']]):
|
|
5006
5885
|
pulumi.set(self, "azure_credentials", value)
|
|
5007
5886
|
|
|
5887
|
+
@property
|
|
5888
|
+
@pulumi.getter(name="buildEnvironmentVariables")
|
|
5889
|
+
def build_environment_variables(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['EnvironmentVariableArgs']]]]:
|
|
5890
|
+
"""
|
|
5891
|
+
List of environment variables to be passed to the build.
|
|
5892
|
+
"""
|
|
5893
|
+
return pulumi.get(self, "build_environment_variables")
|
|
5894
|
+
|
|
5895
|
+
@build_environment_variables.setter
|
|
5896
|
+
def build_environment_variables(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['EnvironmentVariableArgs']]]]):
|
|
5897
|
+
pulumi.set(self, "build_environment_variables", value)
|
|
5898
|
+
|
|
5008
5899
|
@property
|
|
5009
5900
|
@pulumi.getter(name="contextPath")
|
|
5010
5901
|
def context_path(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
@@ -5017,6 +5908,18 @@ class GithubActionConfigurationArgs:
|
|
|
5017
5908
|
def context_path(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
5018
5909
|
pulumi.set(self, "context_path", value)
|
|
5019
5910
|
|
|
5911
|
+
@property
|
|
5912
|
+
@pulumi.getter(name="dockerfilePath")
|
|
5913
|
+
def dockerfile_path(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
5914
|
+
"""
|
|
5915
|
+
Dockerfile path
|
|
5916
|
+
"""
|
|
5917
|
+
return pulumi.get(self, "dockerfile_path")
|
|
5918
|
+
|
|
5919
|
+
@dockerfile_path.setter
|
|
5920
|
+
def dockerfile_path(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
5921
|
+
pulumi.set(self, "dockerfile_path", value)
|
|
5922
|
+
|
|
5020
5923
|
@property
|
|
5021
5924
|
@pulumi.getter(name="githubPersonalAccessToken")
|
|
5022
5925
|
def github_personal_access_token(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
@@ -5396,6 +6299,62 @@ class HeaderMatchArgs:
|
|
|
5396
6299
|
pulumi.set(self, "suffix_match", value)
|
|
5397
6300
|
|
|
5398
6301
|
|
|
6302
|
+
if not MYPY:
|
|
6303
|
+
class HeaderArgsDict(TypedDict):
|
|
6304
|
+
"""
|
|
6305
|
+
Header of otlp configuration
|
|
6306
|
+
"""
|
|
6307
|
+
key: NotRequired[pulumi.Input[builtins.str]]
|
|
6308
|
+
"""
|
|
6309
|
+
The key of otlp configuration header
|
|
6310
|
+
"""
|
|
6311
|
+
value: NotRequired[pulumi.Input[builtins.str]]
|
|
6312
|
+
"""
|
|
6313
|
+
The value of otlp configuration header
|
|
6314
|
+
"""
|
|
6315
|
+
elif False:
|
|
6316
|
+
HeaderArgsDict: TypeAlias = Mapping[str, Any]
|
|
6317
|
+
|
|
6318
|
+
@pulumi.input_type
|
|
6319
|
+
class HeaderArgs:
|
|
6320
|
+
def __init__(__self__, *,
|
|
6321
|
+
key: Optional[pulumi.Input[builtins.str]] = None,
|
|
6322
|
+
value: Optional[pulumi.Input[builtins.str]] = None):
|
|
6323
|
+
"""
|
|
6324
|
+
Header of otlp configuration
|
|
6325
|
+
:param pulumi.Input[builtins.str] key: The key of otlp configuration header
|
|
6326
|
+
:param pulumi.Input[builtins.str] value: The value of otlp configuration header
|
|
6327
|
+
"""
|
|
6328
|
+
if key is not None:
|
|
6329
|
+
pulumi.set(__self__, "key", key)
|
|
6330
|
+
if value is not None:
|
|
6331
|
+
pulumi.set(__self__, "value", value)
|
|
6332
|
+
|
|
6333
|
+
@property
|
|
6334
|
+
@pulumi.getter
|
|
6335
|
+
def key(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
6336
|
+
"""
|
|
6337
|
+
The key of otlp configuration header
|
|
6338
|
+
"""
|
|
6339
|
+
return pulumi.get(self, "key")
|
|
6340
|
+
|
|
6341
|
+
@key.setter
|
|
6342
|
+
def key(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
6343
|
+
pulumi.set(self, "key", value)
|
|
6344
|
+
|
|
6345
|
+
@property
|
|
6346
|
+
@pulumi.getter
|
|
6347
|
+
def value(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
6348
|
+
"""
|
|
6349
|
+
The value of otlp configuration header
|
|
6350
|
+
"""
|
|
6351
|
+
return pulumi.get(self, "value")
|
|
6352
|
+
|
|
6353
|
+
@value.setter
|
|
6354
|
+
def value(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
6355
|
+
pulumi.set(self, "value", value)
|
|
6356
|
+
|
|
6357
|
+
|
|
5399
6358
|
if not MYPY:
|
|
5400
6359
|
class HttpConnectionPoolArgsDict(TypedDict):
|
|
5401
6360
|
"""
|
|
@@ -6503,29 +7462,201 @@ class IdentitySettingsArgs:
|
|
|
6503
7462
|
|
|
6504
7463
|
|
|
6505
7464
|
if not MYPY:
|
|
6506
|
-
class
|
|
6507
|
-
"""
|
|
6508
|
-
Port mappings of container app ingress
|
|
7465
|
+
class IngressConfigurationScaleArgsDict(TypedDict):
|
|
6509
7466
|
"""
|
|
6510
|
-
|
|
6511
|
-
"""
|
|
6512
|
-
Specifies whether the app port is accessible outside of the environment
|
|
7467
|
+
Scaling configuration for the ingress component. Required.
|
|
6513
7468
|
"""
|
|
6514
|
-
|
|
7469
|
+
max_replicas: NotRequired[pulumi.Input[builtins.int]]
|
|
6515
7470
|
"""
|
|
6516
|
-
|
|
7471
|
+
Maximum number of ingress replicas. Must be greater than or equal to minReplicas.
|
|
6517
7472
|
"""
|
|
6518
|
-
|
|
7473
|
+
min_replicas: NotRequired[pulumi.Input[builtins.int]]
|
|
6519
7474
|
"""
|
|
6520
|
-
|
|
7475
|
+
Minimum number of ingress replicas. Must be at least 2. Required.
|
|
6521
7476
|
"""
|
|
6522
7477
|
elif False:
|
|
6523
|
-
|
|
7478
|
+
IngressConfigurationScaleArgsDict: TypeAlias = Mapping[str, Any]
|
|
6524
7479
|
|
|
6525
7480
|
@pulumi.input_type
|
|
6526
|
-
class
|
|
7481
|
+
class IngressConfigurationScaleArgs:
|
|
6527
7482
|
def __init__(__self__, *,
|
|
6528
|
-
|
|
7483
|
+
max_replicas: Optional[pulumi.Input[builtins.int]] = None,
|
|
7484
|
+
min_replicas: Optional[pulumi.Input[builtins.int]] = None):
|
|
7485
|
+
"""
|
|
7486
|
+
Scaling configuration for the ingress component. Required.
|
|
7487
|
+
:param pulumi.Input[builtins.int] max_replicas: Maximum number of ingress replicas. Must be greater than or equal to minReplicas.
|
|
7488
|
+
:param pulumi.Input[builtins.int] min_replicas: Minimum number of ingress replicas. Must be at least 2. Required.
|
|
7489
|
+
"""
|
|
7490
|
+
if max_replicas is not None:
|
|
7491
|
+
pulumi.set(__self__, "max_replicas", max_replicas)
|
|
7492
|
+
if min_replicas is not None:
|
|
7493
|
+
pulumi.set(__self__, "min_replicas", min_replicas)
|
|
7494
|
+
|
|
7495
|
+
@property
|
|
7496
|
+
@pulumi.getter(name="maxReplicas")
|
|
7497
|
+
def max_replicas(self) -> Optional[pulumi.Input[builtins.int]]:
|
|
7498
|
+
"""
|
|
7499
|
+
Maximum number of ingress replicas. Must be greater than or equal to minReplicas.
|
|
7500
|
+
"""
|
|
7501
|
+
return pulumi.get(self, "max_replicas")
|
|
7502
|
+
|
|
7503
|
+
@max_replicas.setter
|
|
7504
|
+
def max_replicas(self, value: Optional[pulumi.Input[builtins.int]]):
|
|
7505
|
+
pulumi.set(self, "max_replicas", value)
|
|
7506
|
+
|
|
7507
|
+
@property
|
|
7508
|
+
@pulumi.getter(name="minReplicas")
|
|
7509
|
+
def min_replicas(self) -> Optional[pulumi.Input[builtins.int]]:
|
|
7510
|
+
"""
|
|
7511
|
+
Minimum number of ingress replicas. Must be at least 2. Required.
|
|
7512
|
+
"""
|
|
7513
|
+
return pulumi.get(self, "min_replicas")
|
|
7514
|
+
|
|
7515
|
+
@min_replicas.setter
|
|
7516
|
+
def min_replicas(self, value: Optional[pulumi.Input[builtins.int]]):
|
|
7517
|
+
pulumi.set(self, "min_replicas", value)
|
|
7518
|
+
|
|
7519
|
+
|
|
7520
|
+
if not MYPY:
|
|
7521
|
+
class IngressConfigurationArgsDict(TypedDict):
|
|
7522
|
+
"""
|
|
7523
|
+
Settings for the ingress component, including workload profile, scaling, and connection handling.
|
|
7524
|
+
"""
|
|
7525
|
+
header_count_limit: NotRequired[pulumi.Input[builtins.int]]
|
|
7526
|
+
"""
|
|
7527
|
+
Maximum number of headers per request allowed by the ingress. Must be at least 1. Defaults to 100.
|
|
7528
|
+
"""
|
|
7529
|
+
request_idle_timeout: NotRequired[pulumi.Input[builtins.int]]
|
|
7530
|
+
"""
|
|
7531
|
+
Duration (in minutes) before idle requests are timed out. Must be at least 1 minute. Defaults to 4 minutes.
|
|
7532
|
+
"""
|
|
7533
|
+
scale: NotRequired[pulumi.Input['IngressConfigurationScaleArgsDict']]
|
|
7534
|
+
"""
|
|
7535
|
+
Scaling configuration for the ingress component. Required.
|
|
7536
|
+
"""
|
|
7537
|
+
termination_grace_period_seconds: NotRequired[pulumi.Input[builtins.int]]
|
|
7538
|
+
"""
|
|
7539
|
+
Time (in seconds) to allow active connections to complete on termination. Must be between 0 and 3600. Defaults to 480 seconds.
|
|
7540
|
+
"""
|
|
7541
|
+
workload_profile_name: NotRequired[pulumi.Input[builtins.str]]
|
|
7542
|
+
"""
|
|
7543
|
+
Name of the workload profile used by the ingress component. Required.
|
|
7544
|
+
"""
|
|
7545
|
+
elif False:
|
|
7546
|
+
IngressConfigurationArgsDict: TypeAlias = Mapping[str, Any]
|
|
7547
|
+
|
|
7548
|
+
@pulumi.input_type
|
|
7549
|
+
class IngressConfigurationArgs:
|
|
7550
|
+
def __init__(__self__, *,
|
|
7551
|
+
header_count_limit: Optional[pulumi.Input[builtins.int]] = None,
|
|
7552
|
+
request_idle_timeout: Optional[pulumi.Input[builtins.int]] = None,
|
|
7553
|
+
scale: Optional[pulumi.Input['IngressConfigurationScaleArgs']] = None,
|
|
7554
|
+
termination_grace_period_seconds: Optional[pulumi.Input[builtins.int]] = None,
|
|
7555
|
+
workload_profile_name: Optional[pulumi.Input[builtins.str]] = None):
|
|
7556
|
+
"""
|
|
7557
|
+
Settings for the ingress component, including workload profile, scaling, and connection handling.
|
|
7558
|
+
:param pulumi.Input[builtins.int] header_count_limit: Maximum number of headers per request allowed by the ingress. Must be at least 1. Defaults to 100.
|
|
7559
|
+
:param pulumi.Input[builtins.int] request_idle_timeout: Duration (in minutes) before idle requests are timed out. Must be at least 1 minute. Defaults to 4 minutes.
|
|
7560
|
+
:param pulumi.Input['IngressConfigurationScaleArgs'] scale: Scaling configuration for the ingress component. Required.
|
|
7561
|
+
:param pulumi.Input[builtins.int] termination_grace_period_seconds: Time (in seconds) to allow active connections to complete on termination. Must be between 0 and 3600. Defaults to 480 seconds.
|
|
7562
|
+
:param pulumi.Input[builtins.str] workload_profile_name: Name of the workload profile used by the ingress component. Required.
|
|
7563
|
+
"""
|
|
7564
|
+
if header_count_limit is not None:
|
|
7565
|
+
pulumi.set(__self__, "header_count_limit", header_count_limit)
|
|
7566
|
+
if request_idle_timeout is not None:
|
|
7567
|
+
pulumi.set(__self__, "request_idle_timeout", request_idle_timeout)
|
|
7568
|
+
if scale is not None:
|
|
7569
|
+
pulumi.set(__self__, "scale", scale)
|
|
7570
|
+
if termination_grace_period_seconds is not None:
|
|
7571
|
+
pulumi.set(__self__, "termination_grace_period_seconds", termination_grace_period_seconds)
|
|
7572
|
+
if workload_profile_name is not None:
|
|
7573
|
+
pulumi.set(__self__, "workload_profile_name", workload_profile_name)
|
|
7574
|
+
|
|
7575
|
+
@property
|
|
7576
|
+
@pulumi.getter(name="headerCountLimit")
|
|
7577
|
+
def header_count_limit(self) -> Optional[pulumi.Input[builtins.int]]:
|
|
7578
|
+
"""
|
|
7579
|
+
Maximum number of headers per request allowed by the ingress. Must be at least 1. Defaults to 100.
|
|
7580
|
+
"""
|
|
7581
|
+
return pulumi.get(self, "header_count_limit")
|
|
7582
|
+
|
|
7583
|
+
@header_count_limit.setter
|
|
7584
|
+
def header_count_limit(self, value: Optional[pulumi.Input[builtins.int]]):
|
|
7585
|
+
pulumi.set(self, "header_count_limit", value)
|
|
7586
|
+
|
|
7587
|
+
@property
|
|
7588
|
+
@pulumi.getter(name="requestIdleTimeout")
|
|
7589
|
+
def request_idle_timeout(self) -> Optional[pulumi.Input[builtins.int]]:
|
|
7590
|
+
"""
|
|
7591
|
+
Duration (in minutes) before idle requests are timed out. Must be at least 1 minute. Defaults to 4 minutes.
|
|
7592
|
+
"""
|
|
7593
|
+
return pulumi.get(self, "request_idle_timeout")
|
|
7594
|
+
|
|
7595
|
+
@request_idle_timeout.setter
|
|
7596
|
+
def request_idle_timeout(self, value: Optional[pulumi.Input[builtins.int]]):
|
|
7597
|
+
pulumi.set(self, "request_idle_timeout", value)
|
|
7598
|
+
|
|
7599
|
+
@property
|
|
7600
|
+
@pulumi.getter
|
|
7601
|
+
def scale(self) -> Optional[pulumi.Input['IngressConfigurationScaleArgs']]:
|
|
7602
|
+
"""
|
|
7603
|
+
Scaling configuration for the ingress component. Required.
|
|
7604
|
+
"""
|
|
7605
|
+
return pulumi.get(self, "scale")
|
|
7606
|
+
|
|
7607
|
+
@scale.setter
|
|
7608
|
+
def scale(self, value: Optional[pulumi.Input['IngressConfigurationScaleArgs']]):
|
|
7609
|
+
pulumi.set(self, "scale", value)
|
|
7610
|
+
|
|
7611
|
+
@property
|
|
7612
|
+
@pulumi.getter(name="terminationGracePeriodSeconds")
|
|
7613
|
+
def termination_grace_period_seconds(self) -> Optional[pulumi.Input[builtins.int]]:
|
|
7614
|
+
"""
|
|
7615
|
+
Time (in seconds) to allow active connections to complete on termination. Must be between 0 and 3600. Defaults to 480 seconds.
|
|
7616
|
+
"""
|
|
7617
|
+
return pulumi.get(self, "termination_grace_period_seconds")
|
|
7618
|
+
|
|
7619
|
+
@termination_grace_period_seconds.setter
|
|
7620
|
+
def termination_grace_period_seconds(self, value: Optional[pulumi.Input[builtins.int]]):
|
|
7621
|
+
pulumi.set(self, "termination_grace_period_seconds", value)
|
|
7622
|
+
|
|
7623
|
+
@property
|
|
7624
|
+
@pulumi.getter(name="workloadProfileName")
|
|
7625
|
+
def workload_profile_name(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
7626
|
+
"""
|
|
7627
|
+
Name of the workload profile used by the ingress component. Required.
|
|
7628
|
+
"""
|
|
7629
|
+
return pulumi.get(self, "workload_profile_name")
|
|
7630
|
+
|
|
7631
|
+
@workload_profile_name.setter
|
|
7632
|
+
def workload_profile_name(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
7633
|
+
pulumi.set(self, "workload_profile_name", value)
|
|
7634
|
+
|
|
7635
|
+
|
|
7636
|
+
if not MYPY:
|
|
7637
|
+
class IngressPortMappingArgsDict(TypedDict):
|
|
7638
|
+
"""
|
|
7639
|
+
Port mappings of container app ingress
|
|
7640
|
+
"""
|
|
7641
|
+
external: pulumi.Input[builtins.bool]
|
|
7642
|
+
"""
|
|
7643
|
+
Specifies whether the app port is accessible outside of the environment
|
|
7644
|
+
"""
|
|
7645
|
+
target_port: pulumi.Input[builtins.int]
|
|
7646
|
+
"""
|
|
7647
|
+
Specifies the port user's container listens on
|
|
7648
|
+
"""
|
|
7649
|
+
exposed_port: NotRequired[pulumi.Input[builtins.int]]
|
|
7650
|
+
"""
|
|
7651
|
+
Specifies the exposed port for the target port. If not specified, it defaults to target port
|
|
7652
|
+
"""
|
|
7653
|
+
elif False:
|
|
7654
|
+
IngressPortMappingArgsDict: TypeAlias = Mapping[str, Any]
|
|
7655
|
+
|
|
7656
|
+
@pulumi.input_type
|
|
7657
|
+
class IngressPortMappingArgs:
|
|
7658
|
+
def __init__(__self__, *,
|
|
7659
|
+
external: pulumi.Input[builtins.bool],
|
|
6529
7660
|
target_port: pulumi.Input[builtins.int],
|
|
6530
7661
|
exposed_port: Optional[pulumi.Input[builtins.int]] = None):
|
|
6531
7662
|
"""
|
|
@@ -6657,6 +7788,10 @@ if not MYPY:
|
|
|
6657
7788
|
"""
|
|
6658
7789
|
Target Port in containers for traffic from ingress
|
|
6659
7790
|
"""
|
|
7791
|
+
target_port_http_scheme: NotRequired[pulumi.Input[Union[builtins.str, 'IngressTargetPortHttpScheme']]]
|
|
7792
|
+
"""
|
|
7793
|
+
Whether an http app listens on http or https
|
|
7794
|
+
"""
|
|
6660
7795
|
traffic: NotRequired[pulumi.Input[Sequence[pulumi.Input['TrafficWeightArgsDict']]]]
|
|
6661
7796
|
"""
|
|
6662
7797
|
Traffic weights for app's revisions
|
|
@@ -6681,6 +7816,7 @@ class IngressArgs:
|
|
|
6681
7816
|
ip_security_restrictions: Optional[pulumi.Input[Sequence[pulumi.Input['IpSecurityRestrictionRuleArgs']]]] = None,
|
|
6682
7817
|
sticky_sessions: Optional[pulumi.Input['IngressStickySessionsArgs']] = None,
|
|
6683
7818
|
target_port: Optional[pulumi.Input[builtins.int]] = None,
|
|
7819
|
+
target_port_http_scheme: Optional[pulumi.Input[Union[builtins.str, 'IngressTargetPortHttpScheme']]] = None,
|
|
6684
7820
|
traffic: Optional[pulumi.Input[Sequence[pulumi.Input['TrafficWeightArgs']]]] = None,
|
|
6685
7821
|
transport: Optional[pulumi.Input[Union[builtins.str, 'IngressTransportMethod']]] = None):
|
|
6686
7822
|
"""
|
|
@@ -6695,6 +7831,7 @@ class IngressArgs:
|
|
|
6695
7831
|
:param pulumi.Input[Sequence[pulumi.Input['IpSecurityRestrictionRuleArgs']]] ip_security_restrictions: Rules to restrict incoming IP address.
|
|
6696
7832
|
:param pulumi.Input['IngressStickySessionsArgs'] sticky_sessions: Sticky Sessions for Single Revision Mode
|
|
6697
7833
|
:param pulumi.Input[builtins.int] target_port: Target Port in containers for traffic from ingress
|
|
7834
|
+
:param pulumi.Input[Union[builtins.str, 'IngressTargetPortHttpScheme']] target_port_http_scheme: Whether an http app listens on http or https
|
|
6698
7835
|
:param pulumi.Input[Sequence[pulumi.Input['TrafficWeightArgs']]] traffic: Traffic weights for app's revisions
|
|
6699
7836
|
:param pulumi.Input[Union[builtins.str, 'IngressTransportMethod']] transport: Ingress transport protocol
|
|
6700
7837
|
"""
|
|
@@ -6722,6 +7859,8 @@ class IngressArgs:
|
|
|
6722
7859
|
pulumi.set(__self__, "sticky_sessions", sticky_sessions)
|
|
6723
7860
|
if target_port is not None:
|
|
6724
7861
|
pulumi.set(__self__, "target_port", target_port)
|
|
7862
|
+
if target_port_http_scheme is not None:
|
|
7863
|
+
pulumi.set(__self__, "target_port_http_scheme", target_port_http_scheme)
|
|
6725
7864
|
if traffic is not None:
|
|
6726
7865
|
pulumi.set(__self__, "traffic", traffic)
|
|
6727
7866
|
if transport is None:
|
|
@@ -6849,6 +7988,18 @@ class IngressArgs:
|
|
|
6849
7988
|
def target_port(self, value: Optional[pulumi.Input[builtins.int]]):
|
|
6850
7989
|
pulumi.set(self, "target_port", value)
|
|
6851
7990
|
|
|
7991
|
+
@property
|
|
7992
|
+
@pulumi.getter(name="targetPortHttpScheme")
|
|
7993
|
+
def target_port_http_scheme(self) -> Optional[pulumi.Input[Union[builtins.str, 'IngressTargetPortHttpScheme']]]:
|
|
7994
|
+
"""
|
|
7995
|
+
Whether an http app listens on http or https
|
|
7996
|
+
"""
|
|
7997
|
+
return pulumi.get(self, "target_port_http_scheme")
|
|
7998
|
+
|
|
7999
|
+
@target_port_http_scheme.setter
|
|
8000
|
+
def target_port_http_scheme(self, value: Optional[pulumi.Input[Union[builtins.str, 'IngressTargetPortHttpScheme']]]):
|
|
8001
|
+
pulumi.set(self, "target_port_http_scheme", value)
|
|
8002
|
+
|
|
6852
8003
|
@property
|
|
6853
8004
|
@pulumi.getter
|
|
6854
8005
|
def traffic(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['TrafficWeightArgs']]]]:
|
|
@@ -6895,6 +8046,10 @@ if not MYPY:
|
|
|
6895
8046
|
"""
|
|
6896
8047
|
Container image tag.
|
|
6897
8048
|
"""
|
|
8049
|
+
image_type: NotRequired[pulumi.Input[Union[builtins.str, 'ImageType']]]
|
|
8050
|
+
"""
|
|
8051
|
+
The type of the image. Set to CloudBuild to let the system manages the image, where user will not be able to update image through image field. Set to ContainerImage for user provided image.
|
|
8052
|
+
"""
|
|
6898
8053
|
name: NotRequired[pulumi.Input[builtins.str]]
|
|
6899
8054
|
"""
|
|
6900
8055
|
Custom container name.
|
|
@@ -6917,6 +8072,7 @@ class InitContainerArgs:
|
|
|
6917
8072
|
command: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
|
|
6918
8073
|
env: Optional[pulumi.Input[Sequence[pulumi.Input['EnvironmentVarArgs']]]] = None,
|
|
6919
8074
|
image: Optional[pulumi.Input[builtins.str]] = None,
|
|
8075
|
+
image_type: Optional[pulumi.Input[Union[builtins.str, 'ImageType']]] = None,
|
|
6920
8076
|
name: Optional[pulumi.Input[builtins.str]] = None,
|
|
6921
8077
|
resources: Optional[pulumi.Input['ContainerResourcesArgs']] = None,
|
|
6922
8078
|
volume_mounts: Optional[pulumi.Input[Sequence[pulumi.Input['VolumeMountArgs']]]] = None):
|
|
@@ -6926,6 +8082,7 @@ class InitContainerArgs:
|
|
|
6926
8082
|
:param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] command: Container start command.
|
|
6927
8083
|
:param pulumi.Input[Sequence[pulumi.Input['EnvironmentVarArgs']]] env: Container environment variables.
|
|
6928
8084
|
:param pulumi.Input[builtins.str] image: Container image tag.
|
|
8085
|
+
:param pulumi.Input[Union[builtins.str, 'ImageType']] image_type: The type of the image. Set to CloudBuild to let the system manages the image, where user will not be able to update image through image field. Set to ContainerImage for user provided image.
|
|
6929
8086
|
:param pulumi.Input[builtins.str] name: Custom container name.
|
|
6930
8087
|
:param pulumi.Input['ContainerResourcesArgs'] resources: Container resource requirements.
|
|
6931
8088
|
:param pulumi.Input[Sequence[pulumi.Input['VolumeMountArgs']]] volume_mounts: Container volume mounts.
|
|
@@ -6938,6 +8095,8 @@ class InitContainerArgs:
|
|
|
6938
8095
|
pulumi.set(__self__, "env", env)
|
|
6939
8096
|
if image is not None:
|
|
6940
8097
|
pulumi.set(__self__, "image", image)
|
|
8098
|
+
if image_type is not None:
|
|
8099
|
+
pulumi.set(__self__, "image_type", image_type)
|
|
6941
8100
|
if name is not None:
|
|
6942
8101
|
pulumi.set(__self__, "name", name)
|
|
6943
8102
|
if resources is not None:
|
|
@@ -6993,6 +8152,18 @@ class InitContainerArgs:
|
|
|
6993
8152
|
def image(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
6994
8153
|
pulumi.set(self, "image", value)
|
|
6995
8154
|
|
|
8155
|
+
@property
|
|
8156
|
+
@pulumi.getter(name="imageType")
|
|
8157
|
+
def image_type(self) -> Optional[pulumi.Input[Union[builtins.str, 'ImageType']]]:
|
|
8158
|
+
"""
|
|
8159
|
+
The type of the image. Set to CloudBuild to let the system manages the image, where user will not be able to update image through image field. Set to ContainerImage for user provided image.
|
|
8160
|
+
"""
|
|
8161
|
+
return pulumi.get(self, "image_type")
|
|
8162
|
+
|
|
8163
|
+
@image_type.setter
|
|
8164
|
+
def image_type(self, value: Optional[pulumi.Input[Union[builtins.str, 'ImageType']]]):
|
|
8165
|
+
pulumi.set(self, "image_type", value)
|
|
8166
|
+
|
|
6996
8167
|
@property
|
|
6997
8168
|
@pulumi.getter
|
|
6998
8169
|
def name(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
@@ -7705,7 +8876,7 @@ if not MYPY:
|
|
|
7705
8876
|
"""
|
|
7706
8877
|
identity: NotRequired[pulumi.Input[builtins.str]]
|
|
7707
8878
|
"""
|
|
7708
|
-
The resource ID of a user-assigned managed identity that is assigned to the
|
|
8879
|
+
The resource ID of a user-assigned managed identity that is assigned to the job, or 'system' for system-assigned identity.
|
|
7709
8880
|
"""
|
|
7710
8881
|
metadata: NotRequired[Any]
|
|
7711
8882
|
"""
|
|
@@ -7734,7 +8905,7 @@ class JobScaleRuleArgs:
|
|
|
7734
8905
|
"""
|
|
7735
8906
|
Scaling rule.
|
|
7736
8907
|
:param pulumi.Input[Sequence[pulumi.Input['ScaleRuleAuthArgs']]] auth: Authentication secrets for the scale rule.
|
|
7737
|
-
:param pulumi.Input[builtins.str] identity: The resource ID of a user-assigned managed identity that is assigned to the
|
|
8908
|
+
:param pulumi.Input[builtins.str] identity: The resource ID of a user-assigned managed identity that is assigned to the job, or 'system' for system-assigned identity.
|
|
7738
8909
|
:param Any metadata: Metadata properties to describe the scale rule.
|
|
7739
8910
|
:param pulumi.Input[builtins.str] name: Scale Rule Name
|
|
7740
8911
|
:param pulumi.Input[builtins.str] type: Type of the scale rule
|
|
@@ -7767,7 +8938,7 @@ class JobScaleRuleArgs:
|
|
|
7767
8938
|
@pulumi.getter
|
|
7768
8939
|
def identity(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
7769
8940
|
"""
|
|
7770
|
-
The resource ID of a user-assigned managed identity that is assigned to the
|
|
8941
|
+
The resource ID of a user-assigned managed identity that is assigned to the job, or 'system' for system-assigned identity.
|
|
7771
8942
|
"""
|
|
7772
8943
|
return pulumi.get(self, "identity")
|
|
7773
8944
|
|
|
@@ -8130,6 +9301,10 @@ if not MYPY:
|
|
|
8130
9301
|
"""
|
|
8131
9302
|
Log analytics customer id
|
|
8132
9303
|
"""
|
|
9304
|
+
dynamic_json_columns: NotRequired[pulumi.Input[builtins.bool]]
|
|
9305
|
+
"""
|
|
9306
|
+
Boolean indicating whether to parse json string log into dynamic json columns
|
|
9307
|
+
"""
|
|
8133
9308
|
shared_key: NotRequired[pulumi.Input[builtins.str]]
|
|
8134
9309
|
"""
|
|
8135
9310
|
Log analytics customer key
|
|
@@ -8141,14 +9316,18 @@ elif False:
|
|
|
8141
9316
|
class LogAnalyticsConfigurationArgs:
|
|
8142
9317
|
def __init__(__self__, *,
|
|
8143
9318
|
customer_id: Optional[pulumi.Input[builtins.str]] = None,
|
|
9319
|
+
dynamic_json_columns: Optional[pulumi.Input[builtins.bool]] = None,
|
|
8144
9320
|
shared_key: Optional[pulumi.Input[builtins.str]] = None):
|
|
8145
9321
|
"""
|
|
8146
9322
|
Log Analytics configuration, must only be provided when destination is configured as 'log-analytics'
|
|
8147
9323
|
:param pulumi.Input[builtins.str] customer_id: Log analytics customer id
|
|
9324
|
+
:param pulumi.Input[builtins.bool] dynamic_json_columns: Boolean indicating whether to parse json string log into dynamic json columns
|
|
8148
9325
|
:param pulumi.Input[builtins.str] shared_key: Log analytics customer key
|
|
8149
9326
|
"""
|
|
8150
9327
|
if customer_id is not None:
|
|
8151
9328
|
pulumi.set(__self__, "customer_id", customer_id)
|
|
9329
|
+
if dynamic_json_columns is not None:
|
|
9330
|
+
pulumi.set(__self__, "dynamic_json_columns", dynamic_json_columns)
|
|
8152
9331
|
if shared_key is not None:
|
|
8153
9332
|
pulumi.set(__self__, "shared_key", shared_key)
|
|
8154
9333
|
|
|
@@ -8164,6 +9343,18 @@ class LogAnalyticsConfigurationArgs:
|
|
|
8164
9343
|
def customer_id(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
8165
9344
|
pulumi.set(self, "customer_id", value)
|
|
8166
9345
|
|
|
9346
|
+
@property
|
|
9347
|
+
@pulumi.getter(name="dynamicJsonColumns")
|
|
9348
|
+
def dynamic_json_columns(self) -> Optional[pulumi.Input[builtins.bool]]:
|
|
9349
|
+
"""
|
|
9350
|
+
Boolean indicating whether to parse json string log into dynamic json columns
|
|
9351
|
+
"""
|
|
9352
|
+
return pulumi.get(self, "dynamic_json_columns")
|
|
9353
|
+
|
|
9354
|
+
@dynamic_json_columns.setter
|
|
9355
|
+
def dynamic_json_columns(self, value: Optional[pulumi.Input[builtins.bool]]):
|
|
9356
|
+
pulumi.set(self, "dynamic_json_columns", value)
|
|
9357
|
+
|
|
8167
9358
|
@property
|
|
8168
9359
|
@pulumi.getter(name="sharedKey")
|
|
8169
9360
|
def shared_key(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
@@ -8177,6 +9368,60 @@ class LogAnalyticsConfigurationArgs:
|
|
|
8177
9368
|
pulumi.set(self, "shared_key", value)
|
|
8178
9369
|
|
|
8179
9370
|
|
|
9371
|
+
if not MYPY:
|
|
9372
|
+
class LoggerSettingArgsDict(TypedDict):
|
|
9373
|
+
"""
|
|
9374
|
+
Logger settings for java workloads.
|
|
9375
|
+
"""
|
|
9376
|
+
level: pulumi.Input[Union[builtins.str, 'Level']]
|
|
9377
|
+
"""
|
|
9378
|
+
The specified logger's log level.
|
|
9379
|
+
"""
|
|
9380
|
+
logger: pulumi.Input[builtins.str]
|
|
9381
|
+
"""
|
|
9382
|
+
Logger name.
|
|
9383
|
+
"""
|
|
9384
|
+
elif False:
|
|
9385
|
+
LoggerSettingArgsDict: TypeAlias = Mapping[str, Any]
|
|
9386
|
+
|
|
9387
|
+
@pulumi.input_type
|
|
9388
|
+
class LoggerSettingArgs:
|
|
9389
|
+
def __init__(__self__, *,
|
|
9390
|
+
level: pulumi.Input[Union[builtins.str, 'Level']],
|
|
9391
|
+
logger: pulumi.Input[builtins.str]):
|
|
9392
|
+
"""
|
|
9393
|
+
Logger settings for java workloads.
|
|
9394
|
+
:param pulumi.Input[Union[builtins.str, 'Level']] level: The specified logger's log level.
|
|
9395
|
+
:param pulumi.Input[builtins.str] logger: Logger name.
|
|
9396
|
+
"""
|
|
9397
|
+
pulumi.set(__self__, "level", level)
|
|
9398
|
+
pulumi.set(__self__, "logger", logger)
|
|
9399
|
+
|
|
9400
|
+
@property
|
|
9401
|
+
@pulumi.getter
|
|
9402
|
+
def level(self) -> pulumi.Input[Union[builtins.str, 'Level']]:
|
|
9403
|
+
"""
|
|
9404
|
+
The specified logger's log level.
|
|
9405
|
+
"""
|
|
9406
|
+
return pulumi.get(self, "level")
|
|
9407
|
+
|
|
9408
|
+
@level.setter
|
|
9409
|
+
def level(self, value: pulumi.Input[Union[builtins.str, 'Level']]):
|
|
9410
|
+
pulumi.set(self, "level", value)
|
|
9411
|
+
|
|
9412
|
+
@property
|
|
9413
|
+
@pulumi.getter
|
|
9414
|
+
def logger(self) -> pulumi.Input[builtins.str]:
|
|
9415
|
+
"""
|
|
9416
|
+
Logger name.
|
|
9417
|
+
"""
|
|
9418
|
+
return pulumi.get(self, "logger")
|
|
9419
|
+
|
|
9420
|
+
@logger.setter
|
|
9421
|
+
def logger(self, value: pulumi.Input[builtins.str]):
|
|
9422
|
+
pulumi.set(self, "logger", value)
|
|
9423
|
+
|
|
9424
|
+
|
|
8180
9425
|
if not MYPY:
|
|
8181
9426
|
class LoginRoutesArgsDict(TypedDict):
|
|
8182
9427
|
"""
|
|
@@ -8391,6 +9636,42 @@ class LoginArgs:
|
|
|
8391
9636
|
pulumi.set(self, "token_store", value)
|
|
8392
9637
|
|
|
8393
9638
|
|
|
9639
|
+
if not MYPY:
|
|
9640
|
+
class LogsConfigurationArgsDict(TypedDict):
|
|
9641
|
+
"""
|
|
9642
|
+
Configuration of Open Telemetry logs
|
|
9643
|
+
"""
|
|
9644
|
+
destinations: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]
|
|
9645
|
+
"""
|
|
9646
|
+
Open telemetry logs destinations
|
|
9647
|
+
"""
|
|
9648
|
+
elif False:
|
|
9649
|
+
LogsConfigurationArgsDict: TypeAlias = Mapping[str, Any]
|
|
9650
|
+
|
|
9651
|
+
@pulumi.input_type
|
|
9652
|
+
class LogsConfigurationArgs:
|
|
9653
|
+
def __init__(__self__, *,
|
|
9654
|
+
destinations: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None):
|
|
9655
|
+
"""
|
|
9656
|
+
Configuration of Open Telemetry logs
|
|
9657
|
+
:param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] destinations: Open telemetry logs destinations
|
|
9658
|
+
"""
|
|
9659
|
+
if destinations is not None:
|
|
9660
|
+
pulumi.set(__self__, "destinations", destinations)
|
|
9661
|
+
|
|
9662
|
+
@property
|
|
9663
|
+
@pulumi.getter
|
|
9664
|
+
def destinations(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
|
|
9665
|
+
"""
|
|
9666
|
+
Open telemetry logs destinations
|
|
9667
|
+
"""
|
|
9668
|
+
return pulumi.get(self, "destinations")
|
|
9669
|
+
|
|
9670
|
+
@destinations.setter
|
|
9671
|
+
def destinations(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]):
|
|
9672
|
+
pulumi.set(self, "destinations", value)
|
|
9673
|
+
|
|
9674
|
+
|
|
8394
9675
|
if not MYPY:
|
|
8395
9676
|
class ManagedCertificatePropertiesArgsDict(TypedDict):
|
|
8396
9677
|
"""
|
|
@@ -8723,6 +10004,62 @@ class ManagedServiceIdentityArgs:
|
|
|
8723
10004
|
pulumi.set(self, "user_assigned_identities", value)
|
|
8724
10005
|
|
|
8725
10006
|
|
|
10007
|
+
if not MYPY:
|
|
10008
|
+
class MetricsConfigurationArgsDict(TypedDict):
|
|
10009
|
+
"""
|
|
10010
|
+
Configuration of Open Telemetry metrics
|
|
10011
|
+
"""
|
|
10012
|
+
destinations: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]
|
|
10013
|
+
"""
|
|
10014
|
+
Open telemetry metrics destinations
|
|
10015
|
+
"""
|
|
10016
|
+
include_keda: NotRequired[pulumi.Input[builtins.bool]]
|
|
10017
|
+
"""
|
|
10018
|
+
Boolean indicating if including keda metrics
|
|
10019
|
+
"""
|
|
10020
|
+
elif False:
|
|
10021
|
+
MetricsConfigurationArgsDict: TypeAlias = Mapping[str, Any]
|
|
10022
|
+
|
|
10023
|
+
@pulumi.input_type
|
|
10024
|
+
class MetricsConfigurationArgs:
|
|
10025
|
+
def __init__(__self__, *,
|
|
10026
|
+
destinations: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
|
|
10027
|
+
include_keda: Optional[pulumi.Input[builtins.bool]] = None):
|
|
10028
|
+
"""
|
|
10029
|
+
Configuration of Open Telemetry metrics
|
|
10030
|
+
:param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] destinations: Open telemetry metrics destinations
|
|
10031
|
+
:param pulumi.Input[builtins.bool] include_keda: Boolean indicating if including keda metrics
|
|
10032
|
+
"""
|
|
10033
|
+
if destinations is not None:
|
|
10034
|
+
pulumi.set(__self__, "destinations", destinations)
|
|
10035
|
+
if include_keda is not None:
|
|
10036
|
+
pulumi.set(__self__, "include_keda", include_keda)
|
|
10037
|
+
|
|
10038
|
+
@property
|
|
10039
|
+
@pulumi.getter
|
|
10040
|
+
def destinations(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
|
|
10041
|
+
"""
|
|
10042
|
+
Open telemetry metrics destinations
|
|
10043
|
+
"""
|
|
10044
|
+
return pulumi.get(self, "destinations")
|
|
10045
|
+
|
|
10046
|
+
@destinations.setter
|
|
10047
|
+
def destinations(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]):
|
|
10048
|
+
pulumi.set(self, "destinations", value)
|
|
10049
|
+
|
|
10050
|
+
@property
|
|
10051
|
+
@pulumi.getter(name="includeKeda")
|
|
10052
|
+
def include_keda(self) -> Optional[pulumi.Input[builtins.bool]]:
|
|
10053
|
+
"""
|
|
10054
|
+
Boolean indicating if including keda metrics
|
|
10055
|
+
"""
|
|
10056
|
+
return pulumi.get(self, "include_keda")
|
|
10057
|
+
|
|
10058
|
+
@include_keda.setter
|
|
10059
|
+
def include_keda(self, value: Optional[pulumi.Input[builtins.bool]]):
|
|
10060
|
+
pulumi.set(self, "include_keda", value)
|
|
10061
|
+
|
|
10062
|
+
|
|
8726
10063
|
if not MYPY:
|
|
8727
10064
|
class MtlsArgsDict(TypedDict):
|
|
8728
10065
|
"""
|
|
@@ -8760,46 +10097,144 @@ class MtlsArgs:
|
|
|
8760
10097
|
|
|
8761
10098
|
|
|
8762
10099
|
if not MYPY:
|
|
8763
|
-
class
|
|
10100
|
+
class NacosComponentArgsDict(TypedDict):
|
|
8764
10101
|
"""
|
|
8765
|
-
|
|
10102
|
+
Nacos properties.
|
|
8766
10103
|
"""
|
|
8767
|
-
|
|
10104
|
+
component_type: pulumi.Input[builtins.str]
|
|
8768
10105
|
"""
|
|
8769
|
-
|
|
10106
|
+
Type of the Java Component.
|
|
10107
|
+
Expected value is 'Nacos'.
|
|
8770
10108
|
"""
|
|
8771
|
-
|
|
10109
|
+
configurations: NotRequired[pulumi.Input[Sequence[pulumi.Input['JavaComponentConfigurationPropertyArgsDict']]]]
|
|
8772
10110
|
"""
|
|
8773
|
-
|
|
10111
|
+
List of Java Components configuration properties
|
|
8774
10112
|
"""
|
|
8775
|
-
|
|
10113
|
+
scale: NotRequired[pulumi.Input['JavaComponentPropertiesScaleArgsDict']]
|
|
8776
10114
|
"""
|
|
8777
|
-
|
|
10115
|
+
Java component scaling configurations
|
|
10116
|
+
"""
|
|
10117
|
+
service_binds: NotRequired[pulumi.Input[Sequence[pulumi.Input['JavaComponentServiceBindArgsDict']]]]
|
|
10118
|
+
"""
|
|
10119
|
+
List of Java Components that are bound to the Java component
|
|
8778
10120
|
"""
|
|
8779
10121
|
elif False:
|
|
8780
|
-
|
|
10122
|
+
NacosComponentArgsDict: TypeAlias = Mapping[str, Any]
|
|
8781
10123
|
|
|
8782
10124
|
@pulumi.input_type
|
|
8783
|
-
class
|
|
10125
|
+
class NacosComponentArgs:
|
|
8784
10126
|
def __init__(__self__, *,
|
|
8785
|
-
|
|
8786
|
-
|
|
8787
|
-
|
|
10127
|
+
component_type: pulumi.Input[builtins.str],
|
|
10128
|
+
configurations: Optional[pulumi.Input[Sequence[pulumi.Input['JavaComponentConfigurationPropertyArgs']]]] = None,
|
|
10129
|
+
scale: Optional[pulumi.Input['JavaComponentPropertiesScaleArgs']] = None,
|
|
10130
|
+
service_binds: Optional[pulumi.Input[Sequence[pulumi.Input['JavaComponentServiceBindArgs']]]] = None):
|
|
8788
10131
|
"""
|
|
8789
|
-
|
|
8790
|
-
:param pulumi.Input[
|
|
8791
|
-
|
|
8792
|
-
:param pulumi.Input[
|
|
10132
|
+
Nacos properties.
|
|
10133
|
+
:param pulumi.Input[builtins.str] component_type: Type of the Java Component.
|
|
10134
|
+
Expected value is 'Nacos'.
|
|
10135
|
+
:param pulumi.Input[Sequence[pulumi.Input['JavaComponentConfigurationPropertyArgs']]] configurations: List of Java Components configuration properties
|
|
10136
|
+
:param pulumi.Input['JavaComponentPropertiesScaleArgs'] scale: Java component scaling configurations
|
|
10137
|
+
:param pulumi.Input[Sequence[pulumi.Input['JavaComponentServiceBindArgs']]] service_binds: List of Java Components that are bound to the Java component
|
|
8793
10138
|
"""
|
|
8794
|
-
|
|
8795
|
-
|
|
8796
|
-
|
|
8797
|
-
|
|
8798
|
-
|
|
8799
|
-
|
|
10139
|
+
pulumi.set(__self__, "component_type", 'Nacos')
|
|
10140
|
+
if configurations is not None:
|
|
10141
|
+
pulumi.set(__self__, "configurations", configurations)
|
|
10142
|
+
if scale is not None:
|
|
10143
|
+
pulumi.set(__self__, "scale", scale)
|
|
10144
|
+
if service_binds is not None:
|
|
10145
|
+
pulumi.set(__self__, "service_binds", service_binds)
|
|
8800
10146
|
|
|
8801
10147
|
@property
|
|
8802
|
-
@pulumi.getter(name="
|
|
10148
|
+
@pulumi.getter(name="componentType")
|
|
10149
|
+
def component_type(self) -> pulumi.Input[builtins.str]:
|
|
10150
|
+
"""
|
|
10151
|
+
Type of the Java Component.
|
|
10152
|
+
Expected value is 'Nacos'.
|
|
10153
|
+
"""
|
|
10154
|
+
return pulumi.get(self, "component_type")
|
|
10155
|
+
|
|
10156
|
+
@component_type.setter
|
|
10157
|
+
def component_type(self, value: pulumi.Input[builtins.str]):
|
|
10158
|
+
pulumi.set(self, "component_type", value)
|
|
10159
|
+
|
|
10160
|
+
@property
|
|
10161
|
+
@pulumi.getter
|
|
10162
|
+
def configurations(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['JavaComponentConfigurationPropertyArgs']]]]:
|
|
10163
|
+
"""
|
|
10164
|
+
List of Java Components configuration properties
|
|
10165
|
+
"""
|
|
10166
|
+
return pulumi.get(self, "configurations")
|
|
10167
|
+
|
|
10168
|
+
@configurations.setter
|
|
10169
|
+
def configurations(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['JavaComponentConfigurationPropertyArgs']]]]):
|
|
10170
|
+
pulumi.set(self, "configurations", value)
|
|
10171
|
+
|
|
10172
|
+
@property
|
|
10173
|
+
@pulumi.getter
|
|
10174
|
+
def scale(self) -> Optional[pulumi.Input['JavaComponentPropertiesScaleArgs']]:
|
|
10175
|
+
"""
|
|
10176
|
+
Java component scaling configurations
|
|
10177
|
+
"""
|
|
10178
|
+
return pulumi.get(self, "scale")
|
|
10179
|
+
|
|
10180
|
+
@scale.setter
|
|
10181
|
+
def scale(self, value: Optional[pulumi.Input['JavaComponentPropertiesScaleArgs']]):
|
|
10182
|
+
pulumi.set(self, "scale", value)
|
|
10183
|
+
|
|
10184
|
+
@property
|
|
10185
|
+
@pulumi.getter(name="serviceBinds")
|
|
10186
|
+
def service_binds(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['JavaComponentServiceBindArgs']]]]:
|
|
10187
|
+
"""
|
|
10188
|
+
List of Java Components that are bound to the Java component
|
|
10189
|
+
"""
|
|
10190
|
+
return pulumi.get(self, "service_binds")
|
|
10191
|
+
|
|
10192
|
+
@service_binds.setter
|
|
10193
|
+
def service_binds(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['JavaComponentServiceBindArgs']]]]):
|
|
10194
|
+
pulumi.set(self, "service_binds", value)
|
|
10195
|
+
|
|
10196
|
+
|
|
10197
|
+
if not MYPY:
|
|
10198
|
+
class NfsAzureFilePropertiesArgsDict(TypedDict):
|
|
10199
|
+
"""
|
|
10200
|
+
NFS Azure File Properties.
|
|
10201
|
+
"""
|
|
10202
|
+
access_mode: NotRequired[pulumi.Input[Union[builtins.str, 'AccessMode']]]
|
|
10203
|
+
"""
|
|
10204
|
+
Access mode for storage
|
|
10205
|
+
"""
|
|
10206
|
+
server: NotRequired[pulumi.Input[builtins.str]]
|
|
10207
|
+
"""
|
|
10208
|
+
Server for NFS azure file.
|
|
10209
|
+
"""
|
|
10210
|
+
share_name: NotRequired[pulumi.Input[builtins.str]]
|
|
10211
|
+
"""
|
|
10212
|
+
NFS Azure file share name.
|
|
10213
|
+
"""
|
|
10214
|
+
elif False:
|
|
10215
|
+
NfsAzureFilePropertiesArgsDict: TypeAlias = Mapping[str, Any]
|
|
10216
|
+
|
|
10217
|
+
@pulumi.input_type
|
|
10218
|
+
class NfsAzureFilePropertiesArgs:
|
|
10219
|
+
def __init__(__self__, *,
|
|
10220
|
+
access_mode: Optional[pulumi.Input[Union[builtins.str, 'AccessMode']]] = None,
|
|
10221
|
+
server: Optional[pulumi.Input[builtins.str]] = None,
|
|
10222
|
+
share_name: Optional[pulumi.Input[builtins.str]] = None):
|
|
10223
|
+
"""
|
|
10224
|
+
NFS Azure File Properties.
|
|
10225
|
+
:param pulumi.Input[Union[builtins.str, 'AccessMode']] access_mode: Access mode for storage
|
|
10226
|
+
:param pulumi.Input[builtins.str] server: Server for NFS azure file.
|
|
10227
|
+
:param pulumi.Input[builtins.str] share_name: NFS Azure file share name.
|
|
10228
|
+
"""
|
|
10229
|
+
if access_mode is not None:
|
|
10230
|
+
pulumi.set(__self__, "access_mode", access_mode)
|
|
10231
|
+
if server is not None:
|
|
10232
|
+
pulumi.set(__self__, "server", server)
|
|
10233
|
+
if share_name is not None:
|
|
10234
|
+
pulumi.set(__self__, "share_name", share_name)
|
|
10235
|
+
|
|
10236
|
+
@property
|
|
10237
|
+
@pulumi.getter(name="accessMode")
|
|
8803
10238
|
def access_mode(self) -> Optional[pulumi.Input[Union[builtins.str, 'AccessMode']]]:
|
|
8804
10239
|
"""
|
|
8805
10240
|
Access mode for storage
|
|
@@ -8814,7 +10249,7 @@ class NfsAzureFilePropertiesArgs:
|
|
|
8814
10249
|
@pulumi.getter
|
|
8815
10250
|
def server(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
8816
10251
|
"""
|
|
8817
|
-
Server for NFS azure file.
|
|
10252
|
+
Server for NFS azure file.
|
|
8818
10253
|
"""
|
|
8819
10254
|
return pulumi.get(self, "server")
|
|
8820
10255
|
|
|
@@ -9195,6 +10630,198 @@ class OpenIdConnectRegistrationArgs:
|
|
|
9195
10630
|
pulumi.set(self, "open_id_connect_configuration", value)
|
|
9196
10631
|
|
|
9197
10632
|
|
|
10633
|
+
if not MYPY:
|
|
10634
|
+
class OpenTelemetryConfigurationArgsDict(TypedDict):
|
|
10635
|
+
"""
|
|
10636
|
+
Configuration of Open Telemetry
|
|
10637
|
+
"""
|
|
10638
|
+
destinations_configuration: NotRequired[pulumi.Input['DestinationsConfigurationArgsDict']]
|
|
10639
|
+
"""
|
|
10640
|
+
Open telemetry destinations configuration
|
|
10641
|
+
"""
|
|
10642
|
+
logs_configuration: NotRequired[pulumi.Input['LogsConfigurationArgsDict']]
|
|
10643
|
+
"""
|
|
10644
|
+
Open telemetry logs configuration
|
|
10645
|
+
"""
|
|
10646
|
+
metrics_configuration: NotRequired[pulumi.Input['MetricsConfigurationArgsDict']]
|
|
10647
|
+
"""
|
|
10648
|
+
Open telemetry metrics configuration
|
|
10649
|
+
"""
|
|
10650
|
+
traces_configuration: NotRequired[pulumi.Input['TracesConfigurationArgsDict']]
|
|
10651
|
+
"""
|
|
10652
|
+
Open telemetry trace configuration
|
|
10653
|
+
"""
|
|
10654
|
+
elif False:
|
|
10655
|
+
OpenTelemetryConfigurationArgsDict: TypeAlias = Mapping[str, Any]
|
|
10656
|
+
|
|
10657
|
+
@pulumi.input_type
|
|
10658
|
+
class OpenTelemetryConfigurationArgs:
|
|
10659
|
+
def __init__(__self__, *,
|
|
10660
|
+
destinations_configuration: Optional[pulumi.Input['DestinationsConfigurationArgs']] = None,
|
|
10661
|
+
logs_configuration: Optional[pulumi.Input['LogsConfigurationArgs']] = None,
|
|
10662
|
+
metrics_configuration: Optional[pulumi.Input['MetricsConfigurationArgs']] = None,
|
|
10663
|
+
traces_configuration: Optional[pulumi.Input['TracesConfigurationArgs']] = None):
|
|
10664
|
+
"""
|
|
10665
|
+
Configuration of Open Telemetry
|
|
10666
|
+
:param pulumi.Input['DestinationsConfigurationArgs'] destinations_configuration: Open telemetry destinations configuration
|
|
10667
|
+
:param pulumi.Input['LogsConfigurationArgs'] logs_configuration: Open telemetry logs configuration
|
|
10668
|
+
:param pulumi.Input['MetricsConfigurationArgs'] metrics_configuration: Open telemetry metrics configuration
|
|
10669
|
+
:param pulumi.Input['TracesConfigurationArgs'] traces_configuration: Open telemetry trace configuration
|
|
10670
|
+
"""
|
|
10671
|
+
if destinations_configuration is not None:
|
|
10672
|
+
pulumi.set(__self__, "destinations_configuration", destinations_configuration)
|
|
10673
|
+
if logs_configuration is not None:
|
|
10674
|
+
pulumi.set(__self__, "logs_configuration", logs_configuration)
|
|
10675
|
+
if metrics_configuration is not None:
|
|
10676
|
+
pulumi.set(__self__, "metrics_configuration", metrics_configuration)
|
|
10677
|
+
if traces_configuration is not None:
|
|
10678
|
+
pulumi.set(__self__, "traces_configuration", traces_configuration)
|
|
10679
|
+
|
|
10680
|
+
@property
|
|
10681
|
+
@pulumi.getter(name="destinationsConfiguration")
|
|
10682
|
+
def destinations_configuration(self) -> Optional[pulumi.Input['DestinationsConfigurationArgs']]:
|
|
10683
|
+
"""
|
|
10684
|
+
Open telemetry destinations configuration
|
|
10685
|
+
"""
|
|
10686
|
+
return pulumi.get(self, "destinations_configuration")
|
|
10687
|
+
|
|
10688
|
+
@destinations_configuration.setter
|
|
10689
|
+
def destinations_configuration(self, value: Optional[pulumi.Input['DestinationsConfigurationArgs']]):
|
|
10690
|
+
pulumi.set(self, "destinations_configuration", value)
|
|
10691
|
+
|
|
10692
|
+
@property
|
|
10693
|
+
@pulumi.getter(name="logsConfiguration")
|
|
10694
|
+
def logs_configuration(self) -> Optional[pulumi.Input['LogsConfigurationArgs']]:
|
|
10695
|
+
"""
|
|
10696
|
+
Open telemetry logs configuration
|
|
10697
|
+
"""
|
|
10698
|
+
return pulumi.get(self, "logs_configuration")
|
|
10699
|
+
|
|
10700
|
+
@logs_configuration.setter
|
|
10701
|
+
def logs_configuration(self, value: Optional[pulumi.Input['LogsConfigurationArgs']]):
|
|
10702
|
+
pulumi.set(self, "logs_configuration", value)
|
|
10703
|
+
|
|
10704
|
+
@property
|
|
10705
|
+
@pulumi.getter(name="metricsConfiguration")
|
|
10706
|
+
def metrics_configuration(self) -> Optional[pulumi.Input['MetricsConfigurationArgs']]:
|
|
10707
|
+
"""
|
|
10708
|
+
Open telemetry metrics configuration
|
|
10709
|
+
"""
|
|
10710
|
+
return pulumi.get(self, "metrics_configuration")
|
|
10711
|
+
|
|
10712
|
+
@metrics_configuration.setter
|
|
10713
|
+
def metrics_configuration(self, value: Optional[pulumi.Input['MetricsConfigurationArgs']]):
|
|
10714
|
+
pulumi.set(self, "metrics_configuration", value)
|
|
10715
|
+
|
|
10716
|
+
@property
|
|
10717
|
+
@pulumi.getter(name="tracesConfiguration")
|
|
10718
|
+
def traces_configuration(self) -> Optional[pulumi.Input['TracesConfigurationArgs']]:
|
|
10719
|
+
"""
|
|
10720
|
+
Open telemetry trace configuration
|
|
10721
|
+
"""
|
|
10722
|
+
return pulumi.get(self, "traces_configuration")
|
|
10723
|
+
|
|
10724
|
+
@traces_configuration.setter
|
|
10725
|
+
def traces_configuration(self, value: Optional[pulumi.Input['TracesConfigurationArgs']]):
|
|
10726
|
+
pulumi.set(self, "traces_configuration", value)
|
|
10727
|
+
|
|
10728
|
+
|
|
10729
|
+
if not MYPY:
|
|
10730
|
+
class OtlpConfigurationArgsDict(TypedDict):
|
|
10731
|
+
"""
|
|
10732
|
+
Configuration of otlp
|
|
10733
|
+
"""
|
|
10734
|
+
endpoint: NotRequired[pulumi.Input[builtins.str]]
|
|
10735
|
+
"""
|
|
10736
|
+
The endpoint of otlp configuration
|
|
10737
|
+
"""
|
|
10738
|
+
headers: NotRequired[pulumi.Input[Sequence[pulumi.Input['HeaderArgsDict']]]]
|
|
10739
|
+
"""
|
|
10740
|
+
Headers of otlp configurations
|
|
10741
|
+
"""
|
|
10742
|
+
insecure: NotRequired[pulumi.Input[builtins.bool]]
|
|
10743
|
+
"""
|
|
10744
|
+
Boolean indicating if otlp configuration is insecure
|
|
10745
|
+
"""
|
|
10746
|
+
name: NotRequired[pulumi.Input[builtins.str]]
|
|
10747
|
+
"""
|
|
10748
|
+
The name of otlp configuration
|
|
10749
|
+
"""
|
|
10750
|
+
elif False:
|
|
10751
|
+
OtlpConfigurationArgsDict: TypeAlias = Mapping[str, Any]
|
|
10752
|
+
|
|
10753
|
+
@pulumi.input_type
|
|
10754
|
+
class OtlpConfigurationArgs:
|
|
10755
|
+
def __init__(__self__, *,
|
|
10756
|
+
endpoint: Optional[pulumi.Input[builtins.str]] = None,
|
|
10757
|
+
headers: Optional[pulumi.Input[Sequence[pulumi.Input['HeaderArgs']]]] = None,
|
|
10758
|
+
insecure: Optional[pulumi.Input[builtins.bool]] = None,
|
|
10759
|
+
name: Optional[pulumi.Input[builtins.str]] = None):
|
|
10760
|
+
"""
|
|
10761
|
+
Configuration of otlp
|
|
10762
|
+
:param pulumi.Input[builtins.str] endpoint: The endpoint of otlp configuration
|
|
10763
|
+
:param pulumi.Input[Sequence[pulumi.Input['HeaderArgs']]] headers: Headers of otlp configurations
|
|
10764
|
+
:param pulumi.Input[builtins.bool] insecure: Boolean indicating if otlp configuration is insecure
|
|
10765
|
+
:param pulumi.Input[builtins.str] name: The name of otlp configuration
|
|
10766
|
+
"""
|
|
10767
|
+
if endpoint is not None:
|
|
10768
|
+
pulumi.set(__self__, "endpoint", endpoint)
|
|
10769
|
+
if headers is not None:
|
|
10770
|
+
pulumi.set(__self__, "headers", headers)
|
|
10771
|
+
if insecure is not None:
|
|
10772
|
+
pulumi.set(__self__, "insecure", insecure)
|
|
10773
|
+
if name is not None:
|
|
10774
|
+
pulumi.set(__self__, "name", name)
|
|
10775
|
+
|
|
10776
|
+
@property
|
|
10777
|
+
@pulumi.getter
|
|
10778
|
+
def endpoint(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
10779
|
+
"""
|
|
10780
|
+
The endpoint of otlp configuration
|
|
10781
|
+
"""
|
|
10782
|
+
return pulumi.get(self, "endpoint")
|
|
10783
|
+
|
|
10784
|
+
@endpoint.setter
|
|
10785
|
+
def endpoint(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
10786
|
+
pulumi.set(self, "endpoint", value)
|
|
10787
|
+
|
|
10788
|
+
@property
|
|
10789
|
+
@pulumi.getter
|
|
10790
|
+
def headers(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['HeaderArgs']]]]:
|
|
10791
|
+
"""
|
|
10792
|
+
Headers of otlp configurations
|
|
10793
|
+
"""
|
|
10794
|
+
return pulumi.get(self, "headers")
|
|
10795
|
+
|
|
10796
|
+
@headers.setter
|
|
10797
|
+
def headers(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['HeaderArgs']]]]):
|
|
10798
|
+
pulumi.set(self, "headers", value)
|
|
10799
|
+
|
|
10800
|
+
@property
|
|
10801
|
+
@pulumi.getter
|
|
10802
|
+
def insecure(self) -> Optional[pulumi.Input[builtins.bool]]:
|
|
10803
|
+
"""
|
|
10804
|
+
Boolean indicating if otlp configuration is insecure
|
|
10805
|
+
"""
|
|
10806
|
+
return pulumi.get(self, "insecure")
|
|
10807
|
+
|
|
10808
|
+
@insecure.setter
|
|
10809
|
+
def insecure(self, value: Optional[pulumi.Input[builtins.bool]]):
|
|
10810
|
+
pulumi.set(self, "insecure", value)
|
|
10811
|
+
|
|
10812
|
+
@property
|
|
10813
|
+
@pulumi.getter
|
|
10814
|
+
def name(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
10815
|
+
"""
|
|
10816
|
+
The name of otlp configuration
|
|
10817
|
+
"""
|
|
10818
|
+
return pulumi.get(self, "name")
|
|
10819
|
+
|
|
10820
|
+
@name.setter
|
|
10821
|
+
def name(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
10822
|
+
pulumi.set(self, "name", value)
|
|
10823
|
+
|
|
10824
|
+
|
|
9198
10825
|
if not MYPY:
|
|
9199
10826
|
class PreBuildStepArgsDict(TypedDict):
|
|
9200
10827
|
"""
|
|
@@ -9636,105 +11263,273 @@ class RegistryInfoArgs:
|
|
|
9636
11263
|
|
|
9637
11264
|
|
|
9638
11265
|
if not MYPY:
|
|
9639
|
-
class
|
|
11266
|
+
class RuntimeDotnetArgsDict(TypedDict):
|
|
9640
11267
|
"""
|
|
9641
|
-
|
|
11268
|
+
.NET app configuration
|
|
9642
11269
|
"""
|
|
9643
|
-
|
|
11270
|
+
auto_configure_data_protection: NotRequired[pulumi.Input[builtins.bool]]
|
|
9644
11271
|
"""
|
|
9645
|
-
|
|
11272
|
+
Auto configure the ASP.NET Core Data Protection feature
|
|
9646
11273
|
"""
|
|
9647
11274
|
elif False:
|
|
9648
|
-
|
|
11275
|
+
RuntimeDotnetArgsDict: TypeAlias = Mapping[str, Any]
|
|
9649
11276
|
|
|
9650
11277
|
@pulumi.input_type
|
|
9651
|
-
class
|
|
11278
|
+
class RuntimeDotnetArgs:
|
|
9652
11279
|
def __init__(__self__, *,
|
|
9653
|
-
|
|
11280
|
+
auto_configure_data_protection: Optional[pulumi.Input[builtins.bool]] = None):
|
|
9654
11281
|
"""
|
|
9655
|
-
|
|
9656
|
-
:param pulumi.Input[builtins.bool]
|
|
11282
|
+
.NET app configuration
|
|
11283
|
+
:param pulumi.Input[builtins.bool] auto_configure_data_protection: Auto configure the ASP.NET Core Data Protection feature
|
|
9657
11284
|
"""
|
|
9658
|
-
if
|
|
9659
|
-
pulumi.set(__self__, "
|
|
11285
|
+
if auto_configure_data_protection is not None:
|
|
11286
|
+
pulumi.set(__self__, "auto_configure_data_protection", auto_configure_data_protection)
|
|
9660
11287
|
|
|
9661
11288
|
@property
|
|
9662
|
-
@pulumi.getter(name="
|
|
9663
|
-
def
|
|
11289
|
+
@pulumi.getter(name="autoConfigureDataProtection")
|
|
11290
|
+
def auto_configure_data_protection(self) -> Optional[pulumi.Input[builtins.bool]]:
|
|
9664
11291
|
"""
|
|
9665
|
-
|
|
11292
|
+
Auto configure the ASP.NET Core Data Protection feature
|
|
9666
11293
|
"""
|
|
9667
|
-
return pulumi.get(self, "
|
|
11294
|
+
return pulumi.get(self, "auto_configure_data_protection")
|
|
9668
11295
|
|
|
9669
|
-
@
|
|
9670
|
-
def
|
|
9671
|
-
pulumi.set(self, "
|
|
11296
|
+
@auto_configure_data_protection.setter
|
|
11297
|
+
def auto_configure_data_protection(self, value: Optional[pulumi.Input[builtins.bool]]):
|
|
11298
|
+
pulumi.set(self, "auto_configure_data_protection", value)
|
|
9672
11299
|
|
|
9673
11300
|
|
|
9674
11301
|
if not MYPY:
|
|
9675
|
-
class
|
|
11302
|
+
class RuntimeJavaAgentArgsDict(TypedDict):
|
|
9676
11303
|
"""
|
|
9677
|
-
|
|
11304
|
+
Diagnostic capabilities achieved by java agent
|
|
9678
11305
|
"""
|
|
9679
|
-
|
|
11306
|
+
enabled: NotRequired[pulumi.Input[builtins.bool]]
|
|
9680
11307
|
"""
|
|
9681
|
-
|
|
11308
|
+
Enable java agent injection for the java app.
|
|
11309
|
+
"""
|
|
11310
|
+
logging: NotRequired[pulumi.Input['RuntimeLoggingArgsDict']]
|
|
11311
|
+
"""
|
|
11312
|
+
Capabilities on the java logging scenario.
|
|
9682
11313
|
"""
|
|
9683
11314
|
elif False:
|
|
9684
|
-
|
|
11315
|
+
RuntimeJavaAgentArgsDict: TypeAlias = Mapping[str, Any]
|
|
9685
11316
|
|
|
9686
11317
|
@pulumi.input_type
|
|
9687
|
-
class
|
|
11318
|
+
class RuntimeJavaAgentArgs:
|
|
9688
11319
|
def __init__(__self__, *,
|
|
9689
|
-
|
|
11320
|
+
enabled: Optional[pulumi.Input[builtins.bool]] = None,
|
|
11321
|
+
logging: Optional[pulumi.Input['RuntimeLoggingArgs']] = None):
|
|
9690
11322
|
"""
|
|
9691
|
-
|
|
9692
|
-
:param pulumi.Input[
|
|
11323
|
+
Diagnostic capabilities achieved by java agent
|
|
11324
|
+
:param pulumi.Input[builtins.bool] enabled: Enable java agent injection for the java app.
|
|
11325
|
+
:param pulumi.Input['RuntimeLoggingArgs'] logging: Capabilities on the java logging scenario.
|
|
9693
11326
|
"""
|
|
9694
|
-
if
|
|
9695
|
-
pulumi.set(__self__, "
|
|
11327
|
+
if enabled is not None:
|
|
11328
|
+
pulumi.set(__self__, "enabled", enabled)
|
|
11329
|
+
if logging is not None:
|
|
11330
|
+
pulumi.set(__self__, "logging", logging)
|
|
9696
11331
|
|
|
9697
11332
|
@property
|
|
9698
11333
|
@pulumi.getter
|
|
9699
|
-
def
|
|
11334
|
+
def enabled(self) -> Optional[pulumi.Input[builtins.bool]]:
|
|
9700
11335
|
"""
|
|
9701
|
-
|
|
11336
|
+
Enable java agent injection for the java app.
|
|
9702
11337
|
"""
|
|
9703
|
-
return pulumi.get(self, "
|
|
11338
|
+
return pulumi.get(self, "enabled")
|
|
9704
11339
|
|
|
9705
|
-
@
|
|
9706
|
-
def
|
|
9707
|
-
pulumi.set(self, "
|
|
11340
|
+
@enabled.setter
|
|
11341
|
+
def enabled(self, value: Optional[pulumi.Input[builtins.bool]]):
|
|
11342
|
+
pulumi.set(self, "enabled", value)
|
|
11343
|
+
|
|
11344
|
+
@property
|
|
11345
|
+
@pulumi.getter
|
|
11346
|
+
def logging(self) -> Optional[pulumi.Input['RuntimeLoggingArgs']]:
|
|
11347
|
+
"""
|
|
11348
|
+
Capabilities on the java logging scenario.
|
|
11349
|
+
"""
|
|
11350
|
+
return pulumi.get(self, "logging")
|
|
11351
|
+
|
|
11352
|
+
@logging.setter
|
|
11353
|
+
def logging(self, value: Optional[pulumi.Input['RuntimeLoggingArgs']]):
|
|
11354
|
+
pulumi.set(self, "logging", value)
|
|
9708
11355
|
|
|
9709
11356
|
|
|
9710
11357
|
if not MYPY:
|
|
9711
|
-
class
|
|
11358
|
+
class RuntimeJavaArgsDict(TypedDict):
|
|
9712
11359
|
"""
|
|
9713
|
-
|
|
11360
|
+
Java app configuration
|
|
9714
11361
|
"""
|
|
9715
|
-
|
|
11362
|
+
enable_metrics: NotRequired[pulumi.Input[builtins.bool]]
|
|
9716
11363
|
"""
|
|
9717
|
-
|
|
11364
|
+
Enable jmx core metrics for the java app
|
|
9718
11365
|
"""
|
|
9719
|
-
|
|
11366
|
+
java_agent: NotRequired[pulumi.Input['RuntimeJavaAgentArgsDict']]
|
|
9720
11367
|
"""
|
|
9721
|
-
|
|
11368
|
+
Diagnostic capabilities achieved by java agent
|
|
9722
11369
|
"""
|
|
9723
11370
|
elif False:
|
|
9724
|
-
|
|
11371
|
+
RuntimeJavaArgsDict: TypeAlias = Mapping[str, Any]
|
|
9725
11372
|
|
|
9726
11373
|
@pulumi.input_type
|
|
9727
|
-
class
|
|
11374
|
+
class RuntimeJavaArgs:
|
|
9728
11375
|
def __init__(__self__, *,
|
|
9729
|
-
|
|
9730
|
-
|
|
11376
|
+
enable_metrics: Optional[pulumi.Input[builtins.bool]] = None,
|
|
11377
|
+
java_agent: Optional[pulumi.Input['RuntimeJavaAgentArgs']] = None):
|
|
9731
11378
|
"""
|
|
9732
|
-
|
|
9733
|
-
:param pulumi.Input[builtins.
|
|
9734
|
-
:param pulumi.Input[
|
|
11379
|
+
Java app configuration
|
|
11380
|
+
:param pulumi.Input[builtins.bool] enable_metrics: Enable jmx core metrics for the java app
|
|
11381
|
+
:param pulumi.Input['RuntimeJavaAgentArgs'] java_agent: Diagnostic capabilities achieved by java agent
|
|
9735
11382
|
"""
|
|
9736
|
-
if
|
|
9737
|
-
pulumi.set(__self__, "
|
|
11383
|
+
if enable_metrics is not None:
|
|
11384
|
+
pulumi.set(__self__, "enable_metrics", enable_metrics)
|
|
11385
|
+
if java_agent is not None:
|
|
11386
|
+
pulumi.set(__self__, "java_agent", java_agent)
|
|
11387
|
+
|
|
11388
|
+
@property
|
|
11389
|
+
@pulumi.getter(name="enableMetrics")
|
|
11390
|
+
def enable_metrics(self) -> Optional[pulumi.Input[builtins.bool]]:
|
|
11391
|
+
"""
|
|
11392
|
+
Enable jmx core metrics for the java app
|
|
11393
|
+
"""
|
|
11394
|
+
return pulumi.get(self, "enable_metrics")
|
|
11395
|
+
|
|
11396
|
+
@enable_metrics.setter
|
|
11397
|
+
def enable_metrics(self, value: Optional[pulumi.Input[builtins.bool]]):
|
|
11398
|
+
pulumi.set(self, "enable_metrics", value)
|
|
11399
|
+
|
|
11400
|
+
@property
|
|
11401
|
+
@pulumi.getter(name="javaAgent")
|
|
11402
|
+
def java_agent(self) -> Optional[pulumi.Input['RuntimeJavaAgentArgs']]:
|
|
11403
|
+
"""
|
|
11404
|
+
Diagnostic capabilities achieved by java agent
|
|
11405
|
+
"""
|
|
11406
|
+
return pulumi.get(self, "java_agent")
|
|
11407
|
+
|
|
11408
|
+
@java_agent.setter
|
|
11409
|
+
def java_agent(self, value: Optional[pulumi.Input['RuntimeJavaAgentArgs']]):
|
|
11410
|
+
pulumi.set(self, "java_agent", value)
|
|
11411
|
+
|
|
11412
|
+
|
|
11413
|
+
if not MYPY:
|
|
11414
|
+
class RuntimeLoggingArgsDict(TypedDict):
|
|
11415
|
+
"""
|
|
11416
|
+
Capabilities on the java logging scenario.
|
|
11417
|
+
"""
|
|
11418
|
+
logger_settings: NotRequired[pulumi.Input[Sequence[pulumi.Input['LoggerSettingArgsDict']]]]
|
|
11419
|
+
"""
|
|
11420
|
+
Settings of the logger for the java app.
|
|
11421
|
+
"""
|
|
11422
|
+
elif False:
|
|
11423
|
+
RuntimeLoggingArgsDict: TypeAlias = Mapping[str, Any]
|
|
11424
|
+
|
|
11425
|
+
@pulumi.input_type
|
|
11426
|
+
class RuntimeLoggingArgs:
|
|
11427
|
+
def __init__(__self__, *,
|
|
11428
|
+
logger_settings: Optional[pulumi.Input[Sequence[pulumi.Input['LoggerSettingArgs']]]] = None):
|
|
11429
|
+
"""
|
|
11430
|
+
Capabilities on the java logging scenario.
|
|
11431
|
+
:param pulumi.Input[Sequence[pulumi.Input['LoggerSettingArgs']]] logger_settings: Settings of the logger for the java app.
|
|
11432
|
+
"""
|
|
11433
|
+
if logger_settings is not None:
|
|
11434
|
+
pulumi.set(__self__, "logger_settings", logger_settings)
|
|
11435
|
+
|
|
11436
|
+
@property
|
|
11437
|
+
@pulumi.getter(name="loggerSettings")
|
|
11438
|
+
def logger_settings(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['LoggerSettingArgs']]]]:
|
|
11439
|
+
"""
|
|
11440
|
+
Settings of the logger for the java app.
|
|
11441
|
+
"""
|
|
11442
|
+
return pulumi.get(self, "logger_settings")
|
|
11443
|
+
|
|
11444
|
+
@logger_settings.setter
|
|
11445
|
+
def logger_settings(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['LoggerSettingArgs']]]]):
|
|
11446
|
+
pulumi.set(self, "logger_settings", value)
|
|
11447
|
+
|
|
11448
|
+
|
|
11449
|
+
if not MYPY:
|
|
11450
|
+
class RuntimeArgsDict(TypedDict):
|
|
11451
|
+
"""
|
|
11452
|
+
Container App Runtime configuration.
|
|
11453
|
+
"""
|
|
11454
|
+
dotnet: NotRequired[pulumi.Input['RuntimeDotnetArgsDict']]
|
|
11455
|
+
"""
|
|
11456
|
+
.NET app configuration
|
|
11457
|
+
"""
|
|
11458
|
+
java: NotRequired[pulumi.Input['RuntimeJavaArgsDict']]
|
|
11459
|
+
"""
|
|
11460
|
+
Java app configuration
|
|
11461
|
+
"""
|
|
11462
|
+
elif False:
|
|
11463
|
+
RuntimeArgsDict: TypeAlias = Mapping[str, Any]
|
|
11464
|
+
|
|
11465
|
+
@pulumi.input_type
|
|
11466
|
+
class RuntimeArgs:
|
|
11467
|
+
def __init__(__self__, *,
|
|
11468
|
+
dotnet: Optional[pulumi.Input['RuntimeDotnetArgs']] = None,
|
|
11469
|
+
java: Optional[pulumi.Input['RuntimeJavaArgs']] = None):
|
|
11470
|
+
"""
|
|
11471
|
+
Container App Runtime configuration.
|
|
11472
|
+
:param pulumi.Input['RuntimeDotnetArgs'] dotnet: .NET app configuration
|
|
11473
|
+
:param pulumi.Input['RuntimeJavaArgs'] java: Java app configuration
|
|
11474
|
+
"""
|
|
11475
|
+
if dotnet is not None:
|
|
11476
|
+
pulumi.set(__self__, "dotnet", dotnet)
|
|
11477
|
+
if java is not None:
|
|
11478
|
+
pulumi.set(__self__, "java", java)
|
|
11479
|
+
|
|
11480
|
+
@property
|
|
11481
|
+
@pulumi.getter
|
|
11482
|
+
def dotnet(self) -> Optional[pulumi.Input['RuntimeDotnetArgs']]:
|
|
11483
|
+
"""
|
|
11484
|
+
.NET app configuration
|
|
11485
|
+
"""
|
|
11486
|
+
return pulumi.get(self, "dotnet")
|
|
11487
|
+
|
|
11488
|
+
@dotnet.setter
|
|
11489
|
+
def dotnet(self, value: Optional[pulumi.Input['RuntimeDotnetArgs']]):
|
|
11490
|
+
pulumi.set(self, "dotnet", value)
|
|
11491
|
+
|
|
11492
|
+
@property
|
|
11493
|
+
@pulumi.getter
|
|
11494
|
+
def java(self) -> Optional[pulumi.Input['RuntimeJavaArgs']]:
|
|
11495
|
+
"""
|
|
11496
|
+
Java app configuration
|
|
11497
|
+
"""
|
|
11498
|
+
return pulumi.get(self, "java")
|
|
11499
|
+
|
|
11500
|
+
@java.setter
|
|
11501
|
+
def java(self, value: Optional[pulumi.Input['RuntimeJavaArgs']]):
|
|
11502
|
+
pulumi.set(self, "java", value)
|
|
11503
|
+
|
|
11504
|
+
|
|
11505
|
+
if not MYPY:
|
|
11506
|
+
class ScaleConfigurationArgsDict(TypedDict):
|
|
11507
|
+
"""
|
|
11508
|
+
Scale configuration.
|
|
11509
|
+
"""
|
|
11510
|
+
max_concurrent_sessions: NotRequired[pulumi.Input[builtins.int]]
|
|
11511
|
+
"""
|
|
11512
|
+
The maximum count of sessions at the same time.
|
|
11513
|
+
"""
|
|
11514
|
+
ready_session_instances: NotRequired[pulumi.Input[builtins.int]]
|
|
11515
|
+
"""
|
|
11516
|
+
The minimum count of ready session instances.
|
|
11517
|
+
"""
|
|
11518
|
+
elif False:
|
|
11519
|
+
ScaleConfigurationArgsDict: TypeAlias = Mapping[str, Any]
|
|
11520
|
+
|
|
11521
|
+
@pulumi.input_type
|
|
11522
|
+
class ScaleConfigurationArgs:
|
|
11523
|
+
def __init__(__self__, *,
|
|
11524
|
+
max_concurrent_sessions: Optional[pulumi.Input[builtins.int]] = None,
|
|
11525
|
+
ready_session_instances: Optional[pulumi.Input[builtins.int]] = None):
|
|
11526
|
+
"""
|
|
11527
|
+
Scale configuration.
|
|
11528
|
+
:param pulumi.Input[builtins.int] max_concurrent_sessions: The maximum count of sessions at the same time.
|
|
11529
|
+
:param pulumi.Input[builtins.int] ready_session_instances: The minimum count of ready session instances.
|
|
11530
|
+
"""
|
|
11531
|
+
if max_concurrent_sessions is not None:
|
|
11532
|
+
pulumi.set(__self__, "max_concurrent_sessions", max_concurrent_sessions)
|
|
9738
11533
|
if ready_session_instances is not None:
|
|
9739
11534
|
pulumi.set(__self__, "ready_session_instances", ready_session_instances)
|
|
9740
11535
|
|
|
@@ -9942,7 +11737,7 @@ if not MYPY:
|
|
|
9942
11737
|
"""
|
|
9943
11738
|
cooldown_period: NotRequired[pulumi.Input[builtins.int]]
|
|
9944
11739
|
"""
|
|
9945
|
-
Optional. KEDA Cooldown Period
|
|
11740
|
+
Optional. KEDA Cooldown Period. Defaults to 300 seconds if not set.
|
|
9946
11741
|
"""
|
|
9947
11742
|
max_replicas: NotRequired[pulumi.Input[builtins.int]]
|
|
9948
11743
|
"""
|
|
@@ -9954,7 +11749,7 @@ if not MYPY:
|
|
|
9954
11749
|
"""
|
|
9955
11750
|
polling_interval: NotRequired[pulumi.Input[builtins.int]]
|
|
9956
11751
|
"""
|
|
9957
|
-
Optional. KEDA Polling Interval
|
|
11752
|
+
Optional. KEDA Polling Interval. Defaults to 30 seconds if not set.
|
|
9958
11753
|
"""
|
|
9959
11754
|
rules: NotRequired[pulumi.Input[Sequence[pulumi.Input['ScaleRuleArgsDict']]]]
|
|
9960
11755
|
"""
|
|
@@ -9973,10 +11768,10 @@ class ScaleArgs:
|
|
|
9973
11768
|
rules: Optional[pulumi.Input[Sequence[pulumi.Input['ScaleRuleArgs']]]] = None):
|
|
9974
11769
|
"""
|
|
9975
11770
|
Container App scaling configurations.
|
|
9976
|
-
:param pulumi.Input[builtins.int] cooldown_period: Optional. KEDA Cooldown Period
|
|
11771
|
+
:param pulumi.Input[builtins.int] cooldown_period: Optional. KEDA Cooldown Period. Defaults to 300 seconds if not set.
|
|
9977
11772
|
:param pulumi.Input[builtins.int] max_replicas: Optional. Maximum number of container replicas. Defaults to 10 if not set.
|
|
9978
11773
|
:param pulumi.Input[builtins.int] min_replicas: Optional. Minimum number of container replicas.
|
|
9979
|
-
:param pulumi.Input[builtins.int] polling_interval: Optional. KEDA Polling Interval
|
|
11774
|
+
:param pulumi.Input[builtins.int] polling_interval: Optional. KEDA Polling Interval. Defaults to 30 seconds if not set.
|
|
9980
11775
|
:param pulumi.Input[Sequence[pulumi.Input['ScaleRuleArgs']]] rules: Scaling rules.
|
|
9981
11776
|
"""
|
|
9982
11777
|
if cooldown_period is not None:
|
|
@@ -9996,7 +11791,7 @@ class ScaleArgs:
|
|
|
9996
11791
|
@pulumi.getter(name="cooldownPeriod")
|
|
9997
11792
|
def cooldown_period(self) -> Optional[pulumi.Input[builtins.int]]:
|
|
9998
11793
|
"""
|
|
9999
|
-
Optional. KEDA Cooldown Period
|
|
11794
|
+
Optional. KEDA Cooldown Period. Defaults to 300 seconds if not set.
|
|
10000
11795
|
"""
|
|
10001
11796
|
return pulumi.get(self, "cooldown_period")
|
|
10002
11797
|
|
|
@@ -10032,7 +11827,7 @@ class ScaleArgs:
|
|
|
10032
11827
|
@pulumi.getter(name="pollingInterval")
|
|
10033
11828
|
def polling_interval(self) -> Optional[pulumi.Input[builtins.int]]:
|
|
10034
11829
|
"""
|
|
10035
|
-
Optional. KEDA Polling Interval
|
|
11830
|
+
Optional. KEDA Polling Interval. Defaults to 30 seconds if not set.
|
|
10036
11831
|
"""
|
|
10037
11832
|
return pulumi.get(self, "polling_interval")
|
|
10038
11833
|
|
|
@@ -10053,6 +11848,120 @@ class ScaleArgs:
|
|
|
10053
11848
|
pulumi.set(self, "rules", value)
|
|
10054
11849
|
|
|
10055
11850
|
|
|
11851
|
+
if not MYPY:
|
|
11852
|
+
class ScgRouteArgsDict(TypedDict):
|
|
11853
|
+
"""
|
|
11854
|
+
Spring Cloud Gateway route definition
|
|
11855
|
+
"""
|
|
11856
|
+
id: pulumi.Input[builtins.str]
|
|
11857
|
+
"""
|
|
11858
|
+
Id of the route
|
|
11859
|
+
"""
|
|
11860
|
+
uri: pulumi.Input[builtins.str]
|
|
11861
|
+
"""
|
|
11862
|
+
Uri of the route
|
|
11863
|
+
"""
|
|
11864
|
+
filters: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]
|
|
11865
|
+
"""
|
|
11866
|
+
Filters of the route
|
|
11867
|
+
"""
|
|
11868
|
+
order: NotRequired[pulumi.Input[builtins.float]]
|
|
11869
|
+
"""
|
|
11870
|
+
Order of the route
|
|
11871
|
+
"""
|
|
11872
|
+
predicates: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]
|
|
11873
|
+
"""
|
|
11874
|
+
Predicates of the route
|
|
11875
|
+
"""
|
|
11876
|
+
elif False:
|
|
11877
|
+
ScgRouteArgsDict: TypeAlias = Mapping[str, Any]
|
|
11878
|
+
|
|
11879
|
+
@pulumi.input_type
|
|
11880
|
+
class ScgRouteArgs:
|
|
11881
|
+
def __init__(__self__, *,
|
|
11882
|
+
id: pulumi.Input[builtins.str],
|
|
11883
|
+
uri: pulumi.Input[builtins.str],
|
|
11884
|
+
filters: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
|
|
11885
|
+
order: Optional[pulumi.Input[builtins.float]] = None,
|
|
11886
|
+
predicates: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None):
|
|
11887
|
+
"""
|
|
11888
|
+
Spring Cloud Gateway route definition
|
|
11889
|
+
:param pulumi.Input[builtins.str] id: Id of the route
|
|
11890
|
+
:param pulumi.Input[builtins.str] uri: Uri of the route
|
|
11891
|
+
:param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] filters: Filters of the route
|
|
11892
|
+
:param pulumi.Input[builtins.float] order: Order of the route
|
|
11893
|
+
:param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] predicates: Predicates of the route
|
|
11894
|
+
"""
|
|
11895
|
+
pulumi.set(__self__, "id", id)
|
|
11896
|
+
pulumi.set(__self__, "uri", uri)
|
|
11897
|
+
if filters is not None:
|
|
11898
|
+
pulumi.set(__self__, "filters", filters)
|
|
11899
|
+
if order is not None:
|
|
11900
|
+
pulumi.set(__self__, "order", order)
|
|
11901
|
+
if predicates is not None:
|
|
11902
|
+
pulumi.set(__self__, "predicates", predicates)
|
|
11903
|
+
|
|
11904
|
+
@property
|
|
11905
|
+
@pulumi.getter
|
|
11906
|
+
def id(self) -> pulumi.Input[builtins.str]:
|
|
11907
|
+
"""
|
|
11908
|
+
Id of the route
|
|
11909
|
+
"""
|
|
11910
|
+
return pulumi.get(self, "id")
|
|
11911
|
+
|
|
11912
|
+
@id.setter
|
|
11913
|
+
def id(self, value: pulumi.Input[builtins.str]):
|
|
11914
|
+
pulumi.set(self, "id", value)
|
|
11915
|
+
|
|
11916
|
+
@property
|
|
11917
|
+
@pulumi.getter
|
|
11918
|
+
def uri(self) -> pulumi.Input[builtins.str]:
|
|
11919
|
+
"""
|
|
11920
|
+
Uri of the route
|
|
11921
|
+
"""
|
|
11922
|
+
return pulumi.get(self, "uri")
|
|
11923
|
+
|
|
11924
|
+
@uri.setter
|
|
11925
|
+
def uri(self, value: pulumi.Input[builtins.str]):
|
|
11926
|
+
pulumi.set(self, "uri", value)
|
|
11927
|
+
|
|
11928
|
+
@property
|
|
11929
|
+
@pulumi.getter
|
|
11930
|
+
def filters(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
|
|
11931
|
+
"""
|
|
11932
|
+
Filters of the route
|
|
11933
|
+
"""
|
|
11934
|
+
return pulumi.get(self, "filters")
|
|
11935
|
+
|
|
11936
|
+
@filters.setter
|
|
11937
|
+
def filters(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]):
|
|
11938
|
+
pulumi.set(self, "filters", value)
|
|
11939
|
+
|
|
11940
|
+
@property
|
|
11941
|
+
@pulumi.getter
|
|
11942
|
+
def order(self) -> Optional[pulumi.Input[builtins.float]]:
|
|
11943
|
+
"""
|
|
11944
|
+
Order of the route
|
|
11945
|
+
"""
|
|
11946
|
+
return pulumi.get(self, "order")
|
|
11947
|
+
|
|
11948
|
+
@order.setter
|
|
11949
|
+
def order(self, value: Optional[pulumi.Input[builtins.float]]):
|
|
11950
|
+
pulumi.set(self, "order", value)
|
|
11951
|
+
|
|
11952
|
+
@property
|
|
11953
|
+
@pulumi.getter
|
|
11954
|
+
def predicates(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
|
|
11955
|
+
"""
|
|
11956
|
+
Predicates of the route
|
|
11957
|
+
"""
|
|
11958
|
+
return pulumi.get(self, "predicates")
|
|
11959
|
+
|
|
11960
|
+
@predicates.setter
|
|
11961
|
+
def predicates(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]):
|
|
11962
|
+
pulumi.set(self, "predicates", value)
|
|
11963
|
+
|
|
11964
|
+
|
|
10056
11965
|
if not MYPY:
|
|
10057
11966
|
class ScheduledEntryArgsDict(TypedDict):
|
|
10058
11967
|
"""
|
|
@@ -10126,6 +12035,62 @@ class ScheduledEntryArgs:
|
|
|
10126
12035
|
pulumi.set(self, "week_day", value)
|
|
10127
12036
|
|
|
10128
12037
|
|
|
12038
|
+
if not MYPY:
|
|
12039
|
+
class SecretKeyVaultPropertiesArgsDict(TypedDict):
|
|
12040
|
+
"""
|
|
12041
|
+
Properties for a secret stored in a Key Vault.
|
|
12042
|
+
"""
|
|
12043
|
+
identity: NotRequired[pulumi.Input[builtins.str]]
|
|
12044
|
+
"""
|
|
12045
|
+
Resource ID of a managed identity to authenticate with Azure Key Vault, or System to use a system-assigned identity.
|
|
12046
|
+
"""
|
|
12047
|
+
key_vault_url: NotRequired[pulumi.Input[builtins.str]]
|
|
12048
|
+
"""
|
|
12049
|
+
URL pointing to the Azure Key Vault secret.
|
|
12050
|
+
"""
|
|
12051
|
+
elif False:
|
|
12052
|
+
SecretKeyVaultPropertiesArgsDict: TypeAlias = Mapping[str, Any]
|
|
12053
|
+
|
|
12054
|
+
@pulumi.input_type
|
|
12055
|
+
class SecretKeyVaultPropertiesArgs:
|
|
12056
|
+
def __init__(__self__, *,
|
|
12057
|
+
identity: Optional[pulumi.Input[builtins.str]] = None,
|
|
12058
|
+
key_vault_url: Optional[pulumi.Input[builtins.str]] = None):
|
|
12059
|
+
"""
|
|
12060
|
+
Properties for a secret stored in a Key Vault.
|
|
12061
|
+
:param pulumi.Input[builtins.str] identity: Resource ID of a managed identity to authenticate with Azure Key Vault, or System to use a system-assigned identity.
|
|
12062
|
+
:param pulumi.Input[builtins.str] key_vault_url: URL pointing to the Azure Key Vault secret.
|
|
12063
|
+
"""
|
|
12064
|
+
if identity is not None:
|
|
12065
|
+
pulumi.set(__self__, "identity", identity)
|
|
12066
|
+
if key_vault_url is not None:
|
|
12067
|
+
pulumi.set(__self__, "key_vault_url", key_vault_url)
|
|
12068
|
+
|
|
12069
|
+
@property
|
|
12070
|
+
@pulumi.getter
|
|
12071
|
+
def identity(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
12072
|
+
"""
|
|
12073
|
+
Resource ID of a managed identity to authenticate with Azure Key Vault, or System to use a system-assigned identity.
|
|
12074
|
+
"""
|
|
12075
|
+
return pulumi.get(self, "identity")
|
|
12076
|
+
|
|
12077
|
+
@identity.setter
|
|
12078
|
+
def identity(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
12079
|
+
pulumi.set(self, "identity", value)
|
|
12080
|
+
|
|
12081
|
+
@property
|
|
12082
|
+
@pulumi.getter(name="keyVaultUrl")
|
|
12083
|
+
def key_vault_url(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
12084
|
+
"""
|
|
12085
|
+
URL pointing to the Azure Key Vault secret.
|
|
12086
|
+
"""
|
|
12087
|
+
return pulumi.get(self, "key_vault_url")
|
|
12088
|
+
|
|
12089
|
+
@key_vault_url.setter
|
|
12090
|
+
def key_vault_url(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
12091
|
+
pulumi.set(self, "key_vault_url", value)
|
|
12092
|
+
|
|
12093
|
+
|
|
10129
12094
|
if not MYPY:
|
|
10130
12095
|
class SecretVolumeItemArgsDict(TypedDict):
|
|
10131
12096
|
"""
|
|
@@ -10283,6 +12248,14 @@ if not MYPY:
|
|
|
10283
12248
|
"""
|
|
10284
12249
|
Configuration to bind a ContainerApp to a dev ContainerApp Service
|
|
10285
12250
|
"""
|
|
12251
|
+
client_type: NotRequired[pulumi.Input[builtins.str]]
|
|
12252
|
+
"""
|
|
12253
|
+
Type of the client to be used to connect to the service
|
|
12254
|
+
"""
|
|
12255
|
+
customized_keys: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]
|
|
12256
|
+
"""
|
|
12257
|
+
Customized keys for customizing injected values to the app
|
|
12258
|
+
"""
|
|
10286
12259
|
name: NotRequired[pulumi.Input[builtins.str]]
|
|
10287
12260
|
"""
|
|
10288
12261
|
Name of the service bind
|
|
@@ -10297,18 +12270,50 @@ elif False:
|
|
|
10297
12270
|
@pulumi.input_type
|
|
10298
12271
|
class ServiceBindArgs:
|
|
10299
12272
|
def __init__(__self__, *,
|
|
12273
|
+
client_type: Optional[pulumi.Input[builtins.str]] = None,
|
|
12274
|
+
customized_keys: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]] = None,
|
|
10300
12275
|
name: Optional[pulumi.Input[builtins.str]] = None,
|
|
10301
12276
|
service_id: Optional[pulumi.Input[builtins.str]] = None):
|
|
10302
12277
|
"""
|
|
10303
12278
|
Configuration to bind a ContainerApp to a dev ContainerApp Service
|
|
12279
|
+
:param pulumi.Input[builtins.str] client_type: Type of the client to be used to connect to the service
|
|
12280
|
+
:param pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]] customized_keys: Customized keys for customizing injected values to the app
|
|
10304
12281
|
:param pulumi.Input[builtins.str] name: Name of the service bind
|
|
10305
12282
|
:param pulumi.Input[builtins.str] service_id: Resource id of the target service
|
|
10306
12283
|
"""
|
|
12284
|
+
if client_type is not None:
|
|
12285
|
+
pulumi.set(__self__, "client_type", client_type)
|
|
12286
|
+
if customized_keys is not None:
|
|
12287
|
+
pulumi.set(__self__, "customized_keys", customized_keys)
|
|
10307
12288
|
if name is not None:
|
|
10308
12289
|
pulumi.set(__self__, "name", name)
|
|
10309
12290
|
if service_id is not None:
|
|
10310
12291
|
pulumi.set(__self__, "service_id", service_id)
|
|
10311
12292
|
|
|
12293
|
+
@property
|
|
12294
|
+
@pulumi.getter(name="clientType")
|
|
12295
|
+
def client_type(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
12296
|
+
"""
|
|
12297
|
+
Type of the client to be used to connect to the service
|
|
12298
|
+
"""
|
|
12299
|
+
return pulumi.get(self, "client_type")
|
|
12300
|
+
|
|
12301
|
+
@client_type.setter
|
|
12302
|
+
def client_type(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
12303
|
+
pulumi.set(self, "client_type", value)
|
|
12304
|
+
|
|
12305
|
+
@property
|
|
12306
|
+
@pulumi.getter(name="customizedKeys")
|
|
12307
|
+
def customized_keys(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]:
|
|
12308
|
+
"""
|
|
12309
|
+
Customized keys for customizing injected values to the app
|
|
12310
|
+
"""
|
|
12311
|
+
return pulumi.get(self, "customized_keys")
|
|
12312
|
+
|
|
12313
|
+
@customized_keys.setter
|
|
12314
|
+
def customized_keys(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]):
|
|
12315
|
+
pulumi.set(self, "customized_keys", value)
|
|
12316
|
+
|
|
10312
12317
|
@property
|
|
10313
12318
|
@pulumi.getter
|
|
10314
12319
|
def name(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
@@ -10450,6 +12455,10 @@ if not MYPY:
|
|
|
10450
12455
|
"""
|
|
10451
12456
|
Custom container name.
|
|
10452
12457
|
"""
|
|
12458
|
+
probes: NotRequired[pulumi.Input[Sequence[pulumi.Input['SessionProbeArgsDict']]]]
|
|
12459
|
+
"""
|
|
12460
|
+
List of probes for the container.
|
|
12461
|
+
"""
|
|
10453
12462
|
resources: NotRequired[pulumi.Input['SessionContainerResourcesArgsDict']]
|
|
10454
12463
|
"""
|
|
10455
12464
|
Container resource requirements.
|
|
@@ -10465,6 +12474,7 @@ class SessionContainerArgs:
|
|
|
10465
12474
|
env: Optional[pulumi.Input[Sequence[pulumi.Input['EnvironmentVarArgs']]]] = None,
|
|
10466
12475
|
image: Optional[pulumi.Input[builtins.str]] = None,
|
|
10467
12476
|
name: Optional[pulumi.Input[builtins.str]] = None,
|
|
12477
|
+
probes: Optional[pulumi.Input[Sequence[pulumi.Input['SessionProbeArgs']]]] = None,
|
|
10468
12478
|
resources: Optional[pulumi.Input['SessionContainerResourcesArgs']] = None):
|
|
10469
12479
|
"""
|
|
10470
12480
|
Container definitions for the sessions of the session pool.
|
|
@@ -10473,6 +12483,7 @@ class SessionContainerArgs:
|
|
|
10473
12483
|
:param pulumi.Input[Sequence[pulumi.Input['EnvironmentVarArgs']]] env: Container environment variables.
|
|
10474
12484
|
:param pulumi.Input[builtins.str] image: Container image tag.
|
|
10475
12485
|
:param pulumi.Input[builtins.str] name: Custom container name.
|
|
12486
|
+
:param pulumi.Input[Sequence[pulumi.Input['SessionProbeArgs']]] probes: List of probes for the container.
|
|
10476
12487
|
:param pulumi.Input['SessionContainerResourcesArgs'] resources: Container resource requirements.
|
|
10477
12488
|
"""
|
|
10478
12489
|
if args is not None:
|
|
@@ -10485,6 +12496,8 @@ class SessionContainerArgs:
|
|
|
10485
12496
|
pulumi.set(__self__, "image", image)
|
|
10486
12497
|
if name is not None:
|
|
10487
12498
|
pulumi.set(__self__, "name", name)
|
|
12499
|
+
if probes is not None:
|
|
12500
|
+
pulumi.set(__self__, "probes", probes)
|
|
10488
12501
|
if resources is not None:
|
|
10489
12502
|
pulumi.set(__self__, "resources", resources)
|
|
10490
12503
|
|
|
@@ -10548,6 +12561,18 @@ class SessionContainerArgs:
|
|
|
10548
12561
|
def name(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
10549
12562
|
pulumi.set(self, "name", value)
|
|
10550
12563
|
|
|
12564
|
+
@property
|
|
12565
|
+
@pulumi.getter
|
|
12566
|
+
def probes(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['SessionProbeArgs']]]]:
|
|
12567
|
+
"""
|
|
12568
|
+
List of probes for the container.
|
|
12569
|
+
"""
|
|
12570
|
+
return pulumi.get(self, "probes")
|
|
12571
|
+
|
|
12572
|
+
@probes.setter
|
|
12573
|
+
def probes(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['SessionProbeArgs']]]]):
|
|
12574
|
+
pulumi.set(self, "probes", value)
|
|
12575
|
+
|
|
10551
12576
|
@property
|
|
10552
12577
|
@pulumi.getter
|
|
10553
12578
|
def resources(self) -> Optional[pulumi.Input['SessionContainerResourcesArgs']]:
|
|
@@ -10668,25 +12693,445 @@ class SessionPoolSecretArgs:
|
|
|
10668
12693
|
@pulumi.getter
|
|
10669
12694
|
def name(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
10670
12695
|
"""
|
|
10671
|
-
Secret Name.
|
|
12696
|
+
Secret Name.
|
|
12697
|
+
"""
|
|
12698
|
+
return pulumi.get(self, "name")
|
|
12699
|
+
|
|
12700
|
+
@name.setter
|
|
12701
|
+
def name(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
12702
|
+
pulumi.set(self, "name", value)
|
|
12703
|
+
|
|
12704
|
+
@property
|
|
12705
|
+
@pulumi.getter
|
|
12706
|
+
def value(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
12707
|
+
"""
|
|
12708
|
+
Secret Value.
|
|
12709
|
+
"""
|
|
12710
|
+
return pulumi.get(self, "value")
|
|
12711
|
+
|
|
12712
|
+
@value.setter
|
|
12713
|
+
def value(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
12714
|
+
pulumi.set(self, "value", value)
|
|
12715
|
+
|
|
12716
|
+
|
|
12717
|
+
if not MYPY:
|
|
12718
|
+
class SessionProbeHttpGetArgsDict(TypedDict):
|
|
12719
|
+
"""
|
|
12720
|
+
HTTPGet specifies the http request to perform.
|
|
12721
|
+
"""
|
|
12722
|
+
port: pulumi.Input[builtins.int]
|
|
12723
|
+
"""
|
|
12724
|
+
Name or number of the port to access on the container. Number must be in the range 1 to 65535. Name must be an IANA_SVC_NAME.
|
|
12725
|
+
"""
|
|
12726
|
+
host: NotRequired[pulumi.Input[builtins.str]]
|
|
12727
|
+
"""
|
|
12728
|
+
Host name to connect to, defaults to the pod IP. You probably want to set "Host" in httpHeaders instead.
|
|
12729
|
+
"""
|
|
12730
|
+
http_headers: NotRequired[pulumi.Input[Sequence[pulumi.Input['SessionProbeHttpHeadersArgsDict']]]]
|
|
12731
|
+
"""
|
|
12732
|
+
Custom headers to set in the request. HTTP allows repeated headers.
|
|
12733
|
+
"""
|
|
12734
|
+
path: NotRequired[pulumi.Input[builtins.str]]
|
|
12735
|
+
"""
|
|
12736
|
+
Path to access on the HTTP server.
|
|
12737
|
+
"""
|
|
12738
|
+
scheme: NotRequired[pulumi.Input[Union[builtins.str, 'Scheme']]]
|
|
12739
|
+
"""
|
|
12740
|
+
Scheme to use for connecting to the host. Defaults to HTTP.
|
|
12741
|
+
"""
|
|
12742
|
+
elif False:
|
|
12743
|
+
SessionProbeHttpGetArgsDict: TypeAlias = Mapping[str, Any]
|
|
12744
|
+
|
|
12745
|
+
@pulumi.input_type
|
|
12746
|
+
class SessionProbeHttpGetArgs:
|
|
12747
|
+
def __init__(__self__, *,
|
|
12748
|
+
port: pulumi.Input[builtins.int],
|
|
12749
|
+
host: Optional[pulumi.Input[builtins.str]] = None,
|
|
12750
|
+
http_headers: Optional[pulumi.Input[Sequence[pulumi.Input['SessionProbeHttpHeadersArgs']]]] = None,
|
|
12751
|
+
path: Optional[pulumi.Input[builtins.str]] = None,
|
|
12752
|
+
scheme: Optional[pulumi.Input[Union[builtins.str, 'Scheme']]] = None):
|
|
12753
|
+
"""
|
|
12754
|
+
HTTPGet specifies the http request to perform.
|
|
12755
|
+
:param pulumi.Input[builtins.int] port: Name or number of the port to access on the container. Number must be in the range 1 to 65535. Name must be an IANA_SVC_NAME.
|
|
12756
|
+
:param pulumi.Input[builtins.str] host: Host name to connect to, defaults to the pod IP. You probably want to set "Host" in httpHeaders instead.
|
|
12757
|
+
:param pulumi.Input[Sequence[pulumi.Input['SessionProbeHttpHeadersArgs']]] http_headers: Custom headers to set in the request. HTTP allows repeated headers.
|
|
12758
|
+
:param pulumi.Input[builtins.str] path: Path to access on the HTTP server.
|
|
12759
|
+
:param pulumi.Input[Union[builtins.str, 'Scheme']] scheme: Scheme to use for connecting to the host. Defaults to HTTP.
|
|
12760
|
+
"""
|
|
12761
|
+
pulumi.set(__self__, "port", port)
|
|
12762
|
+
if host is not None:
|
|
12763
|
+
pulumi.set(__self__, "host", host)
|
|
12764
|
+
if http_headers is not None:
|
|
12765
|
+
pulumi.set(__self__, "http_headers", http_headers)
|
|
12766
|
+
if path is not None:
|
|
12767
|
+
pulumi.set(__self__, "path", path)
|
|
12768
|
+
if scheme is not None:
|
|
12769
|
+
pulumi.set(__self__, "scheme", scheme)
|
|
12770
|
+
|
|
12771
|
+
@property
|
|
12772
|
+
@pulumi.getter
|
|
12773
|
+
def port(self) -> pulumi.Input[builtins.int]:
|
|
12774
|
+
"""
|
|
12775
|
+
Name or number of the port to access on the container. Number must be in the range 1 to 65535. Name must be an IANA_SVC_NAME.
|
|
12776
|
+
"""
|
|
12777
|
+
return pulumi.get(self, "port")
|
|
12778
|
+
|
|
12779
|
+
@port.setter
|
|
12780
|
+
def port(self, value: pulumi.Input[builtins.int]):
|
|
12781
|
+
pulumi.set(self, "port", value)
|
|
12782
|
+
|
|
12783
|
+
@property
|
|
12784
|
+
@pulumi.getter
|
|
12785
|
+
def host(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
12786
|
+
"""
|
|
12787
|
+
Host name to connect to, defaults to the pod IP. You probably want to set "Host" in httpHeaders instead.
|
|
12788
|
+
"""
|
|
12789
|
+
return pulumi.get(self, "host")
|
|
12790
|
+
|
|
12791
|
+
@host.setter
|
|
12792
|
+
def host(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
12793
|
+
pulumi.set(self, "host", value)
|
|
12794
|
+
|
|
12795
|
+
@property
|
|
12796
|
+
@pulumi.getter(name="httpHeaders")
|
|
12797
|
+
def http_headers(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['SessionProbeHttpHeadersArgs']]]]:
|
|
12798
|
+
"""
|
|
12799
|
+
Custom headers to set in the request. HTTP allows repeated headers.
|
|
12800
|
+
"""
|
|
12801
|
+
return pulumi.get(self, "http_headers")
|
|
12802
|
+
|
|
12803
|
+
@http_headers.setter
|
|
12804
|
+
def http_headers(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['SessionProbeHttpHeadersArgs']]]]):
|
|
12805
|
+
pulumi.set(self, "http_headers", value)
|
|
12806
|
+
|
|
12807
|
+
@property
|
|
12808
|
+
@pulumi.getter
|
|
12809
|
+
def path(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
12810
|
+
"""
|
|
12811
|
+
Path to access on the HTTP server.
|
|
12812
|
+
"""
|
|
12813
|
+
return pulumi.get(self, "path")
|
|
12814
|
+
|
|
12815
|
+
@path.setter
|
|
12816
|
+
def path(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
12817
|
+
pulumi.set(self, "path", value)
|
|
12818
|
+
|
|
12819
|
+
@property
|
|
12820
|
+
@pulumi.getter
|
|
12821
|
+
def scheme(self) -> Optional[pulumi.Input[Union[builtins.str, 'Scheme']]]:
|
|
12822
|
+
"""
|
|
12823
|
+
Scheme to use for connecting to the host. Defaults to HTTP.
|
|
12824
|
+
"""
|
|
12825
|
+
return pulumi.get(self, "scheme")
|
|
12826
|
+
|
|
12827
|
+
@scheme.setter
|
|
12828
|
+
def scheme(self, value: Optional[pulumi.Input[Union[builtins.str, 'Scheme']]]):
|
|
12829
|
+
pulumi.set(self, "scheme", value)
|
|
12830
|
+
|
|
12831
|
+
|
|
12832
|
+
if not MYPY:
|
|
12833
|
+
class SessionProbeHttpHeadersArgsDict(TypedDict):
|
|
12834
|
+
"""
|
|
12835
|
+
HTTPHeader describes a custom header to be used in HTTP probes
|
|
12836
|
+
"""
|
|
12837
|
+
name: pulumi.Input[builtins.str]
|
|
12838
|
+
"""
|
|
12839
|
+
The header field name
|
|
12840
|
+
"""
|
|
12841
|
+
value: pulumi.Input[builtins.str]
|
|
12842
|
+
"""
|
|
12843
|
+
The header field value
|
|
12844
|
+
"""
|
|
12845
|
+
elif False:
|
|
12846
|
+
SessionProbeHttpHeadersArgsDict: TypeAlias = Mapping[str, Any]
|
|
12847
|
+
|
|
12848
|
+
@pulumi.input_type
|
|
12849
|
+
class SessionProbeHttpHeadersArgs:
|
|
12850
|
+
def __init__(__self__, *,
|
|
12851
|
+
name: pulumi.Input[builtins.str],
|
|
12852
|
+
value: pulumi.Input[builtins.str]):
|
|
12853
|
+
"""
|
|
12854
|
+
HTTPHeader describes a custom header to be used in HTTP probes
|
|
12855
|
+
:param pulumi.Input[builtins.str] name: The header field name
|
|
12856
|
+
:param pulumi.Input[builtins.str] value: The header field value
|
|
12857
|
+
"""
|
|
12858
|
+
pulumi.set(__self__, "name", name)
|
|
12859
|
+
pulumi.set(__self__, "value", value)
|
|
12860
|
+
|
|
12861
|
+
@property
|
|
12862
|
+
@pulumi.getter
|
|
12863
|
+
def name(self) -> pulumi.Input[builtins.str]:
|
|
12864
|
+
"""
|
|
12865
|
+
The header field name
|
|
12866
|
+
"""
|
|
12867
|
+
return pulumi.get(self, "name")
|
|
12868
|
+
|
|
12869
|
+
@name.setter
|
|
12870
|
+
def name(self, value: pulumi.Input[builtins.str]):
|
|
12871
|
+
pulumi.set(self, "name", value)
|
|
12872
|
+
|
|
12873
|
+
@property
|
|
12874
|
+
@pulumi.getter
|
|
12875
|
+
def value(self) -> pulumi.Input[builtins.str]:
|
|
12876
|
+
"""
|
|
12877
|
+
The header field value
|
|
12878
|
+
"""
|
|
12879
|
+
return pulumi.get(self, "value")
|
|
12880
|
+
|
|
12881
|
+
@value.setter
|
|
12882
|
+
def value(self, value: pulumi.Input[builtins.str]):
|
|
12883
|
+
pulumi.set(self, "value", value)
|
|
12884
|
+
|
|
12885
|
+
|
|
12886
|
+
if not MYPY:
|
|
12887
|
+
class SessionProbeTcpSocketArgsDict(TypedDict):
|
|
12888
|
+
"""
|
|
12889
|
+
TCPSocket specifies an action involving a TCP port. TCP hooks not yet supported.
|
|
12890
|
+
"""
|
|
12891
|
+
port: pulumi.Input[builtins.int]
|
|
12892
|
+
"""
|
|
12893
|
+
Number or name of the port to access on the container. Number must be in the range 1 to 65535. Name must be an IANA_SVC_NAME.
|
|
12894
|
+
"""
|
|
12895
|
+
host: NotRequired[pulumi.Input[builtins.str]]
|
|
12896
|
+
"""
|
|
12897
|
+
Optional: Host name to connect to, defaults to the pod IP.
|
|
12898
|
+
"""
|
|
12899
|
+
elif False:
|
|
12900
|
+
SessionProbeTcpSocketArgsDict: TypeAlias = Mapping[str, Any]
|
|
12901
|
+
|
|
12902
|
+
@pulumi.input_type
|
|
12903
|
+
class SessionProbeTcpSocketArgs:
|
|
12904
|
+
def __init__(__self__, *,
|
|
12905
|
+
port: pulumi.Input[builtins.int],
|
|
12906
|
+
host: Optional[pulumi.Input[builtins.str]] = None):
|
|
12907
|
+
"""
|
|
12908
|
+
TCPSocket specifies an action involving a TCP port. TCP hooks not yet supported.
|
|
12909
|
+
:param pulumi.Input[builtins.int] port: Number or name of the port to access on the container. Number must be in the range 1 to 65535. Name must be an IANA_SVC_NAME.
|
|
12910
|
+
:param pulumi.Input[builtins.str] host: Optional: Host name to connect to, defaults to the pod IP.
|
|
12911
|
+
"""
|
|
12912
|
+
pulumi.set(__self__, "port", port)
|
|
12913
|
+
if host is not None:
|
|
12914
|
+
pulumi.set(__self__, "host", host)
|
|
12915
|
+
|
|
12916
|
+
@property
|
|
12917
|
+
@pulumi.getter
|
|
12918
|
+
def port(self) -> pulumi.Input[builtins.int]:
|
|
12919
|
+
"""
|
|
12920
|
+
Number or name of the port to access on the container. Number must be in the range 1 to 65535. Name must be an IANA_SVC_NAME.
|
|
12921
|
+
"""
|
|
12922
|
+
return pulumi.get(self, "port")
|
|
12923
|
+
|
|
12924
|
+
@port.setter
|
|
12925
|
+
def port(self, value: pulumi.Input[builtins.int]):
|
|
12926
|
+
pulumi.set(self, "port", value)
|
|
12927
|
+
|
|
12928
|
+
@property
|
|
12929
|
+
@pulumi.getter
|
|
12930
|
+
def host(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
12931
|
+
"""
|
|
12932
|
+
Optional: Host name to connect to, defaults to the pod IP.
|
|
12933
|
+
"""
|
|
12934
|
+
return pulumi.get(self, "host")
|
|
12935
|
+
|
|
12936
|
+
@host.setter
|
|
12937
|
+
def host(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
12938
|
+
pulumi.set(self, "host", value)
|
|
12939
|
+
|
|
12940
|
+
|
|
12941
|
+
if not MYPY:
|
|
12942
|
+
class SessionProbeArgsDict(TypedDict):
|
|
12943
|
+
"""
|
|
12944
|
+
Session probe configuration.
|
|
12945
|
+
"""
|
|
12946
|
+
failure_threshold: NotRequired[pulumi.Input[builtins.int]]
|
|
12947
|
+
"""
|
|
12948
|
+
Minimum consecutive failures for the probe to be considered failed after having succeeded. Defaults to 3. Minimum value is 1. Maximum value is 10.
|
|
12949
|
+
"""
|
|
12950
|
+
http_get: NotRequired[pulumi.Input['SessionProbeHttpGetArgsDict']]
|
|
12951
|
+
"""
|
|
12952
|
+
HTTPGet specifies the http request to perform.
|
|
12953
|
+
"""
|
|
12954
|
+
initial_delay_seconds: NotRequired[pulumi.Input[builtins.int]]
|
|
12955
|
+
"""
|
|
12956
|
+
Number of seconds after the container has started before liveness probes are initiated. Minimum value is 1. Maximum value is 60.
|
|
12957
|
+
"""
|
|
12958
|
+
period_seconds: NotRequired[pulumi.Input[builtins.int]]
|
|
12959
|
+
"""
|
|
12960
|
+
How often (in seconds) to perform the probe. Default to 10 seconds. Minimum value is 1. Maximum value is 240.
|
|
12961
|
+
"""
|
|
12962
|
+
success_threshold: NotRequired[pulumi.Input[builtins.int]]
|
|
12963
|
+
"""
|
|
12964
|
+
Minimum consecutive successes for the probe to be considered successful after having failed. Defaults to 1. Must be 1 for liveness and startup. Minimum value is 1. Maximum value is 10.
|
|
12965
|
+
"""
|
|
12966
|
+
tcp_socket: NotRequired[pulumi.Input['SessionProbeTcpSocketArgsDict']]
|
|
12967
|
+
"""
|
|
12968
|
+
TCPSocket specifies an action involving a TCP port. TCP hooks not yet supported.
|
|
12969
|
+
"""
|
|
12970
|
+
termination_grace_period_seconds: NotRequired[pulumi.Input[builtins.float]]
|
|
12971
|
+
"""
|
|
12972
|
+
Optional duration in seconds the pod needs to terminate gracefully upon probe failure. The grace period is the duration in seconds after the processes running in the pod are sent a termination signal and the time when the processes are forcibly halted with a kill signal. Set this value longer than the expected cleanup time for your process. If this value is nil, the pod's terminationGracePeriodSeconds will be used. Otherwise, this value overrides the value provided by the pod spec. Value must be non-negative integer. The value zero indicates stop immediately via the kill signal (no opportunity to shut down). This is an alpha field and requires enabling ProbeTerminationGracePeriod feature gate. Maximum value is 3600 seconds (1 hour)
|
|
12973
|
+
"""
|
|
12974
|
+
timeout_seconds: NotRequired[pulumi.Input[builtins.int]]
|
|
12975
|
+
"""
|
|
12976
|
+
Number of seconds after which the probe times out. Defaults to 1 second. Minimum value is 1. Maximum value is 240.
|
|
12977
|
+
"""
|
|
12978
|
+
type: NotRequired[pulumi.Input[Union[builtins.str, 'SessionProbeType']]]
|
|
12979
|
+
"""
|
|
12980
|
+
Denotes the type of probe. Can be Liveness or Startup, Readiness probe is not supported in sessions. Type must be unique for each probe within the context of a list of probes (SessionProbes).
|
|
12981
|
+
"""
|
|
12982
|
+
elif False:
|
|
12983
|
+
SessionProbeArgsDict: TypeAlias = Mapping[str, Any]
|
|
12984
|
+
|
|
12985
|
+
@pulumi.input_type
|
|
12986
|
+
class SessionProbeArgs:
|
|
12987
|
+
def __init__(__self__, *,
|
|
12988
|
+
failure_threshold: Optional[pulumi.Input[builtins.int]] = None,
|
|
12989
|
+
http_get: Optional[pulumi.Input['SessionProbeHttpGetArgs']] = None,
|
|
12990
|
+
initial_delay_seconds: Optional[pulumi.Input[builtins.int]] = None,
|
|
12991
|
+
period_seconds: Optional[pulumi.Input[builtins.int]] = None,
|
|
12992
|
+
success_threshold: Optional[pulumi.Input[builtins.int]] = None,
|
|
12993
|
+
tcp_socket: Optional[pulumi.Input['SessionProbeTcpSocketArgs']] = None,
|
|
12994
|
+
termination_grace_period_seconds: Optional[pulumi.Input[builtins.float]] = None,
|
|
12995
|
+
timeout_seconds: Optional[pulumi.Input[builtins.int]] = None,
|
|
12996
|
+
type: Optional[pulumi.Input[Union[builtins.str, 'SessionProbeType']]] = None):
|
|
12997
|
+
"""
|
|
12998
|
+
Session probe configuration.
|
|
12999
|
+
:param pulumi.Input[builtins.int] failure_threshold: Minimum consecutive failures for the probe to be considered failed after having succeeded. Defaults to 3. Minimum value is 1. Maximum value is 10.
|
|
13000
|
+
:param pulumi.Input['SessionProbeHttpGetArgs'] http_get: HTTPGet specifies the http request to perform.
|
|
13001
|
+
:param pulumi.Input[builtins.int] initial_delay_seconds: Number of seconds after the container has started before liveness probes are initiated. Minimum value is 1. Maximum value is 60.
|
|
13002
|
+
:param pulumi.Input[builtins.int] period_seconds: How often (in seconds) to perform the probe. Default to 10 seconds. Minimum value is 1. Maximum value is 240.
|
|
13003
|
+
:param pulumi.Input[builtins.int] success_threshold: Minimum consecutive successes for the probe to be considered successful after having failed. Defaults to 1. Must be 1 for liveness and startup. Minimum value is 1. Maximum value is 10.
|
|
13004
|
+
:param pulumi.Input['SessionProbeTcpSocketArgs'] tcp_socket: TCPSocket specifies an action involving a TCP port. TCP hooks not yet supported.
|
|
13005
|
+
:param pulumi.Input[builtins.float] termination_grace_period_seconds: Optional duration in seconds the pod needs to terminate gracefully upon probe failure. The grace period is the duration in seconds after the processes running in the pod are sent a termination signal and the time when the processes are forcibly halted with a kill signal. Set this value longer than the expected cleanup time for your process. If this value is nil, the pod's terminationGracePeriodSeconds will be used. Otherwise, this value overrides the value provided by the pod spec. Value must be non-negative integer. The value zero indicates stop immediately via the kill signal (no opportunity to shut down). This is an alpha field and requires enabling ProbeTerminationGracePeriod feature gate. Maximum value is 3600 seconds (1 hour)
|
|
13006
|
+
:param pulumi.Input[builtins.int] timeout_seconds: Number of seconds after which the probe times out. Defaults to 1 second. Minimum value is 1. Maximum value is 240.
|
|
13007
|
+
:param pulumi.Input[Union[builtins.str, 'SessionProbeType']] type: Denotes the type of probe. Can be Liveness or Startup, Readiness probe is not supported in sessions. Type must be unique for each probe within the context of a list of probes (SessionProbes).
|
|
13008
|
+
"""
|
|
13009
|
+
if failure_threshold is not None:
|
|
13010
|
+
pulumi.set(__self__, "failure_threshold", failure_threshold)
|
|
13011
|
+
if http_get is not None:
|
|
13012
|
+
pulumi.set(__self__, "http_get", http_get)
|
|
13013
|
+
if initial_delay_seconds is not None:
|
|
13014
|
+
pulumi.set(__self__, "initial_delay_seconds", initial_delay_seconds)
|
|
13015
|
+
if period_seconds is not None:
|
|
13016
|
+
pulumi.set(__self__, "period_seconds", period_seconds)
|
|
13017
|
+
if success_threshold is not None:
|
|
13018
|
+
pulumi.set(__self__, "success_threshold", success_threshold)
|
|
13019
|
+
if tcp_socket is not None:
|
|
13020
|
+
pulumi.set(__self__, "tcp_socket", tcp_socket)
|
|
13021
|
+
if termination_grace_period_seconds is not None:
|
|
13022
|
+
pulumi.set(__self__, "termination_grace_period_seconds", termination_grace_period_seconds)
|
|
13023
|
+
if timeout_seconds is not None:
|
|
13024
|
+
pulumi.set(__self__, "timeout_seconds", timeout_seconds)
|
|
13025
|
+
if type is not None:
|
|
13026
|
+
pulumi.set(__self__, "type", type)
|
|
13027
|
+
|
|
13028
|
+
@property
|
|
13029
|
+
@pulumi.getter(name="failureThreshold")
|
|
13030
|
+
def failure_threshold(self) -> Optional[pulumi.Input[builtins.int]]:
|
|
13031
|
+
"""
|
|
13032
|
+
Minimum consecutive failures for the probe to be considered failed after having succeeded. Defaults to 3. Minimum value is 1. Maximum value is 10.
|
|
13033
|
+
"""
|
|
13034
|
+
return pulumi.get(self, "failure_threshold")
|
|
13035
|
+
|
|
13036
|
+
@failure_threshold.setter
|
|
13037
|
+
def failure_threshold(self, value: Optional[pulumi.Input[builtins.int]]):
|
|
13038
|
+
pulumi.set(self, "failure_threshold", value)
|
|
13039
|
+
|
|
13040
|
+
@property
|
|
13041
|
+
@pulumi.getter(name="httpGet")
|
|
13042
|
+
def http_get(self) -> Optional[pulumi.Input['SessionProbeHttpGetArgs']]:
|
|
13043
|
+
"""
|
|
13044
|
+
HTTPGet specifies the http request to perform.
|
|
13045
|
+
"""
|
|
13046
|
+
return pulumi.get(self, "http_get")
|
|
13047
|
+
|
|
13048
|
+
@http_get.setter
|
|
13049
|
+
def http_get(self, value: Optional[pulumi.Input['SessionProbeHttpGetArgs']]):
|
|
13050
|
+
pulumi.set(self, "http_get", value)
|
|
13051
|
+
|
|
13052
|
+
@property
|
|
13053
|
+
@pulumi.getter(name="initialDelaySeconds")
|
|
13054
|
+
def initial_delay_seconds(self) -> Optional[pulumi.Input[builtins.int]]:
|
|
13055
|
+
"""
|
|
13056
|
+
Number of seconds after the container has started before liveness probes are initiated. Minimum value is 1. Maximum value is 60.
|
|
13057
|
+
"""
|
|
13058
|
+
return pulumi.get(self, "initial_delay_seconds")
|
|
13059
|
+
|
|
13060
|
+
@initial_delay_seconds.setter
|
|
13061
|
+
def initial_delay_seconds(self, value: Optional[pulumi.Input[builtins.int]]):
|
|
13062
|
+
pulumi.set(self, "initial_delay_seconds", value)
|
|
13063
|
+
|
|
13064
|
+
@property
|
|
13065
|
+
@pulumi.getter(name="periodSeconds")
|
|
13066
|
+
def period_seconds(self) -> Optional[pulumi.Input[builtins.int]]:
|
|
13067
|
+
"""
|
|
13068
|
+
How often (in seconds) to perform the probe. Default to 10 seconds. Minimum value is 1. Maximum value is 240.
|
|
13069
|
+
"""
|
|
13070
|
+
return pulumi.get(self, "period_seconds")
|
|
13071
|
+
|
|
13072
|
+
@period_seconds.setter
|
|
13073
|
+
def period_seconds(self, value: Optional[pulumi.Input[builtins.int]]):
|
|
13074
|
+
pulumi.set(self, "period_seconds", value)
|
|
13075
|
+
|
|
13076
|
+
@property
|
|
13077
|
+
@pulumi.getter(name="successThreshold")
|
|
13078
|
+
def success_threshold(self) -> Optional[pulumi.Input[builtins.int]]:
|
|
13079
|
+
"""
|
|
13080
|
+
Minimum consecutive successes for the probe to be considered successful after having failed. Defaults to 1. Must be 1 for liveness and startup. Minimum value is 1. Maximum value is 10.
|
|
13081
|
+
"""
|
|
13082
|
+
return pulumi.get(self, "success_threshold")
|
|
13083
|
+
|
|
13084
|
+
@success_threshold.setter
|
|
13085
|
+
def success_threshold(self, value: Optional[pulumi.Input[builtins.int]]):
|
|
13086
|
+
pulumi.set(self, "success_threshold", value)
|
|
13087
|
+
|
|
13088
|
+
@property
|
|
13089
|
+
@pulumi.getter(name="tcpSocket")
|
|
13090
|
+
def tcp_socket(self) -> Optional[pulumi.Input['SessionProbeTcpSocketArgs']]:
|
|
13091
|
+
"""
|
|
13092
|
+
TCPSocket specifies an action involving a TCP port. TCP hooks not yet supported.
|
|
13093
|
+
"""
|
|
13094
|
+
return pulumi.get(self, "tcp_socket")
|
|
13095
|
+
|
|
13096
|
+
@tcp_socket.setter
|
|
13097
|
+
def tcp_socket(self, value: Optional[pulumi.Input['SessionProbeTcpSocketArgs']]):
|
|
13098
|
+
pulumi.set(self, "tcp_socket", value)
|
|
13099
|
+
|
|
13100
|
+
@property
|
|
13101
|
+
@pulumi.getter(name="terminationGracePeriodSeconds")
|
|
13102
|
+
def termination_grace_period_seconds(self) -> Optional[pulumi.Input[builtins.float]]:
|
|
13103
|
+
"""
|
|
13104
|
+
Optional duration in seconds the pod needs to terminate gracefully upon probe failure. The grace period is the duration in seconds after the processes running in the pod are sent a termination signal and the time when the processes are forcibly halted with a kill signal. Set this value longer than the expected cleanup time for your process. If this value is nil, the pod's terminationGracePeriodSeconds will be used. Otherwise, this value overrides the value provided by the pod spec. Value must be non-negative integer. The value zero indicates stop immediately via the kill signal (no opportunity to shut down). This is an alpha field and requires enabling ProbeTerminationGracePeriod feature gate. Maximum value is 3600 seconds (1 hour)
|
|
13105
|
+
"""
|
|
13106
|
+
return pulumi.get(self, "termination_grace_period_seconds")
|
|
13107
|
+
|
|
13108
|
+
@termination_grace_period_seconds.setter
|
|
13109
|
+
def termination_grace_period_seconds(self, value: Optional[pulumi.Input[builtins.float]]):
|
|
13110
|
+
pulumi.set(self, "termination_grace_period_seconds", value)
|
|
13111
|
+
|
|
13112
|
+
@property
|
|
13113
|
+
@pulumi.getter(name="timeoutSeconds")
|
|
13114
|
+
def timeout_seconds(self) -> Optional[pulumi.Input[builtins.int]]:
|
|
13115
|
+
"""
|
|
13116
|
+
Number of seconds after which the probe times out. Defaults to 1 second. Minimum value is 1. Maximum value is 240.
|
|
10672
13117
|
"""
|
|
10673
|
-
return pulumi.get(self, "
|
|
13118
|
+
return pulumi.get(self, "timeout_seconds")
|
|
10674
13119
|
|
|
10675
|
-
@
|
|
10676
|
-
def
|
|
10677
|
-
pulumi.set(self, "
|
|
13120
|
+
@timeout_seconds.setter
|
|
13121
|
+
def timeout_seconds(self, value: Optional[pulumi.Input[builtins.int]]):
|
|
13122
|
+
pulumi.set(self, "timeout_seconds", value)
|
|
10678
13123
|
|
|
10679
13124
|
@property
|
|
10680
13125
|
@pulumi.getter
|
|
10681
|
-
def
|
|
13126
|
+
def type(self) -> Optional[pulumi.Input[Union[builtins.str, 'SessionProbeType']]]:
|
|
10682
13127
|
"""
|
|
10683
|
-
|
|
13128
|
+
Denotes the type of probe. Can be Liveness or Startup, Readiness probe is not supported in sessions. Type must be unique for each probe within the context of a list of probes (SessionProbes).
|
|
10684
13129
|
"""
|
|
10685
|
-
return pulumi.get(self, "
|
|
13130
|
+
return pulumi.get(self, "type")
|
|
10686
13131
|
|
|
10687
|
-
@
|
|
10688
|
-
def
|
|
10689
|
-
pulumi.set(self, "
|
|
13132
|
+
@type.setter
|
|
13133
|
+
def type(self, value: Optional[pulumi.Input[Union[builtins.str, 'SessionProbeType']]]):
|
|
13134
|
+
pulumi.set(self, "type", value)
|
|
10690
13135
|
|
|
10691
13136
|
|
|
10692
13137
|
if not MYPY:
|
|
@@ -10785,6 +13230,142 @@ class SessionRegistryCredentialsArgs:
|
|
|
10785
13230
|
pulumi.set(self, "username", value)
|
|
10786
13231
|
|
|
10787
13232
|
|
|
13233
|
+
if not MYPY:
|
|
13234
|
+
class SmbStorageArgsDict(TypedDict):
|
|
13235
|
+
"""
|
|
13236
|
+
SMB storage properties
|
|
13237
|
+
"""
|
|
13238
|
+
access_mode: NotRequired[pulumi.Input[Union[builtins.str, 'AccessMode']]]
|
|
13239
|
+
"""
|
|
13240
|
+
Access mode for storage
|
|
13241
|
+
"""
|
|
13242
|
+
domain: NotRequired[pulumi.Input[builtins.str]]
|
|
13243
|
+
"""
|
|
13244
|
+
The domain name for the user.
|
|
13245
|
+
"""
|
|
13246
|
+
host: NotRequired[pulumi.Input[builtins.str]]
|
|
13247
|
+
"""
|
|
13248
|
+
The host name or IP address of the SMB server.
|
|
13249
|
+
"""
|
|
13250
|
+
password: NotRequired[pulumi.Input[builtins.str]]
|
|
13251
|
+
"""
|
|
13252
|
+
The password for the user.
|
|
13253
|
+
"""
|
|
13254
|
+
share_name: NotRequired[pulumi.Input[builtins.str]]
|
|
13255
|
+
"""
|
|
13256
|
+
The path to the SMB shared folder.
|
|
13257
|
+
"""
|
|
13258
|
+
username: NotRequired[pulumi.Input[builtins.str]]
|
|
13259
|
+
"""
|
|
13260
|
+
The user to log on to the SMB server.
|
|
13261
|
+
"""
|
|
13262
|
+
elif False:
|
|
13263
|
+
SmbStorageArgsDict: TypeAlias = Mapping[str, Any]
|
|
13264
|
+
|
|
13265
|
+
@pulumi.input_type
|
|
13266
|
+
class SmbStorageArgs:
|
|
13267
|
+
def __init__(__self__, *,
|
|
13268
|
+
access_mode: Optional[pulumi.Input[Union[builtins.str, 'AccessMode']]] = None,
|
|
13269
|
+
domain: Optional[pulumi.Input[builtins.str]] = None,
|
|
13270
|
+
host: Optional[pulumi.Input[builtins.str]] = None,
|
|
13271
|
+
password: Optional[pulumi.Input[builtins.str]] = None,
|
|
13272
|
+
share_name: Optional[pulumi.Input[builtins.str]] = None,
|
|
13273
|
+
username: Optional[pulumi.Input[builtins.str]] = None):
|
|
13274
|
+
"""
|
|
13275
|
+
SMB storage properties
|
|
13276
|
+
:param pulumi.Input[Union[builtins.str, 'AccessMode']] access_mode: Access mode for storage
|
|
13277
|
+
:param pulumi.Input[builtins.str] domain: The domain name for the user.
|
|
13278
|
+
:param pulumi.Input[builtins.str] host: The host name or IP address of the SMB server.
|
|
13279
|
+
:param pulumi.Input[builtins.str] password: The password for the user.
|
|
13280
|
+
:param pulumi.Input[builtins.str] share_name: The path to the SMB shared folder.
|
|
13281
|
+
:param pulumi.Input[builtins.str] username: The user to log on to the SMB server.
|
|
13282
|
+
"""
|
|
13283
|
+
if access_mode is not None:
|
|
13284
|
+
pulumi.set(__self__, "access_mode", access_mode)
|
|
13285
|
+
if domain is not None:
|
|
13286
|
+
pulumi.set(__self__, "domain", domain)
|
|
13287
|
+
if host is not None:
|
|
13288
|
+
pulumi.set(__self__, "host", host)
|
|
13289
|
+
if password is not None:
|
|
13290
|
+
pulumi.set(__self__, "password", password)
|
|
13291
|
+
if share_name is not None:
|
|
13292
|
+
pulumi.set(__self__, "share_name", share_name)
|
|
13293
|
+
if username is not None:
|
|
13294
|
+
pulumi.set(__self__, "username", username)
|
|
13295
|
+
|
|
13296
|
+
@property
|
|
13297
|
+
@pulumi.getter(name="accessMode")
|
|
13298
|
+
def access_mode(self) -> Optional[pulumi.Input[Union[builtins.str, 'AccessMode']]]:
|
|
13299
|
+
"""
|
|
13300
|
+
Access mode for storage
|
|
13301
|
+
"""
|
|
13302
|
+
return pulumi.get(self, "access_mode")
|
|
13303
|
+
|
|
13304
|
+
@access_mode.setter
|
|
13305
|
+
def access_mode(self, value: Optional[pulumi.Input[Union[builtins.str, 'AccessMode']]]):
|
|
13306
|
+
pulumi.set(self, "access_mode", value)
|
|
13307
|
+
|
|
13308
|
+
@property
|
|
13309
|
+
@pulumi.getter
|
|
13310
|
+
def domain(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
13311
|
+
"""
|
|
13312
|
+
The domain name for the user.
|
|
13313
|
+
"""
|
|
13314
|
+
return pulumi.get(self, "domain")
|
|
13315
|
+
|
|
13316
|
+
@domain.setter
|
|
13317
|
+
def domain(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
13318
|
+
pulumi.set(self, "domain", value)
|
|
13319
|
+
|
|
13320
|
+
@property
|
|
13321
|
+
@pulumi.getter
|
|
13322
|
+
def host(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
13323
|
+
"""
|
|
13324
|
+
The host name or IP address of the SMB server.
|
|
13325
|
+
"""
|
|
13326
|
+
return pulumi.get(self, "host")
|
|
13327
|
+
|
|
13328
|
+
@host.setter
|
|
13329
|
+
def host(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
13330
|
+
pulumi.set(self, "host", value)
|
|
13331
|
+
|
|
13332
|
+
@property
|
|
13333
|
+
@pulumi.getter
|
|
13334
|
+
def password(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
13335
|
+
"""
|
|
13336
|
+
The password for the user.
|
|
13337
|
+
"""
|
|
13338
|
+
return pulumi.get(self, "password")
|
|
13339
|
+
|
|
13340
|
+
@password.setter
|
|
13341
|
+
def password(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
13342
|
+
pulumi.set(self, "password", value)
|
|
13343
|
+
|
|
13344
|
+
@property
|
|
13345
|
+
@pulumi.getter(name="shareName")
|
|
13346
|
+
def share_name(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
13347
|
+
"""
|
|
13348
|
+
The path to the SMB shared folder.
|
|
13349
|
+
"""
|
|
13350
|
+
return pulumi.get(self, "share_name")
|
|
13351
|
+
|
|
13352
|
+
@share_name.setter
|
|
13353
|
+
def share_name(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
13354
|
+
pulumi.set(self, "share_name", value)
|
|
13355
|
+
|
|
13356
|
+
@property
|
|
13357
|
+
@pulumi.getter
|
|
13358
|
+
def username(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
13359
|
+
"""
|
|
13360
|
+
The user to log on to the SMB server.
|
|
13361
|
+
"""
|
|
13362
|
+
return pulumi.get(self, "username")
|
|
13363
|
+
|
|
13364
|
+
@username.setter
|
|
13365
|
+
def username(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
13366
|
+
pulumi.set(self, "username", value)
|
|
13367
|
+
|
|
13368
|
+
|
|
10788
13369
|
if not MYPY:
|
|
10789
13370
|
class SpringBootAdminComponentArgsDict(TypedDict):
|
|
10790
13371
|
"""
|
|
@@ -11079,6 +13660,124 @@ class SpringCloudEurekaComponentArgs:
|
|
|
11079
13660
|
pulumi.set(self, "service_binds", value)
|
|
11080
13661
|
|
|
11081
13662
|
|
|
13663
|
+
if not MYPY:
|
|
13664
|
+
class SpringCloudGatewayComponentArgsDict(TypedDict):
|
|
13665
|
+
"""
|
|
13666
|
+
Spring Cloud Gateway properties.
|
|
13667
|
+
"""
|
|
13668
|
+
component_type: pulumi.Input[builtins.str]
|
|
13669
|
+
"""
|
|
13670
|
+
Type of the Java Component.
|
|
13671
|
+
Expected value is 'SpringCloudGateway'.
|
|
13672
|
+
"""
|
|
13673
|
+
configurations: NotRequired[pulumi.Input[Sequence[pulumi.Input['JavaComponentConfigurationPropertyArgsDict']]]]
|
|
13674
|
+
"""
|
|
13675
|
+
List of Java Components configuration properties
|
|
13676
|
+
"""
|
|
13677
|
+
scale: NotRequired[pulumi.Input['JavaComponentPropertiesScaleArgsDict']]
|
|
13678
|
+
"""
|
|
13679
|
+
Java component scaling configurations
|
|
13680
|
+
"""
|
|
13681
|
+
service_binds: NotRequired[pulumi.Input[Sequence[pulumi.Input['JavaComponentServiceBindArgsDict']]]]
|
|
13682
|
+
"""
|
|
13683
|
+
List of Java Components that are bound to the Java component
|
|
13684
|
+
"""
|
|
13685
|
+
spring_cloud_gateway_routes: NotRequired[pulumi.Input[Sequence[pulumi.Input['ScgRouteArgsDict']]]]
|
|
13686
|
+
"""
|
|
13687
|
+
Gateway route definition
|
|
13688
|
+
"""
|
|
13689
|
+
elif False:
|
|
13690
|
+
SpringCloudGatewayComponentArgsDict: TypeAlias = Mapping[str, Any]
|
|
13691
|
+
|
|
13692
|
+
@pulumi.input_type
|
|
13693
|
+
class SpringCloudGatewayComponentArgs:
|
|
13694
|
+
def __init__(__self__, *,
|
|
13695
|
+
component_type: pulumi.Input[builtins.str],
|
|
13696
|
+
configurations: Optional[pulumi.Input[Sequence[pulumi.Input['JavaComponentConfigurationPropertyArgs']]]] = None,
|
|
13697
|
+
scale: Optional[pulumi.Input['JavaComponentPropertiesScaleArgs']] = None,
|
|
13698
|
+
service_binds: Optional[pulumi.Input[Sequence[pulumi.Input['JavaComponentServiceBindArgs']]]] = None,
|
|
13699
|
+
spring_cloud_gateway_routes: Optional[pulumi.Input[Sequence[pulumi.Input['ScgRouteArgs']]]] = None):
|
|
13700
|
+
"""
|
|
13701
|
+
Spring Cloud Gateway properties.
|
|
13702
|
+
:param pulumi.Input[builtins.str] component_type: Type of the Java Component.
|
|
13703
|
+
Expected value is 'SpringCloudGateway'.
|
|
13704
|
+
:param pulumi.Input[Sequence[pulumi.Input['JavaComponentConfigurationPropertyArgs']]] configurations: List of Java Components configuration properties
|
|
13705
|
+
:param pulumi.Input['JavaComponentPropertiesScaleArgs'] scale: Java component scaling configurations
|
|
13706
|
+
:param pulumi.Input[Sequence[pulumi.Input['JavaComponentServiceBindArgs']]] service_binds: List of Java Components that are bound to the Java component
|
|
13707
|
+
:param pulumi.Input[Sequence[pulumi.Input['ScgRouteArgs']]] spring_cloud_gateway_routes: Gateway route definition
|
|
13708
|
+
"""
|
|
13709
|
+
pulumi.set(__self__, "component_type", 'SpringCloudGateway')
|
|
13710
|
+
if configurations is not None:
|
|
13711
|
+
pulumi.set(__self__, "configurations", configurations)
|
|
13712
|
+
if scale is not None:
|
|
13713
|
+
pulumi.set(__self__, "scale", scale)
|
|
13714
|
+
if service_binds is not None:
|
|
13715
|
+
pulumi.set(__self__, "service_binds", service_binds)
|
|
13716
|
+
if spring_cloud_gateway_routes is not None:
|
|
13717
|
+
pulumi.set(__self__, "spring_cloud_gateway_routes", spring_cloud_gateway_routes)
|
|
13718
|
+
|
|
13719
|
+
@property
|
|
13720
|
+
@pulumi.getter(name="componentType")
|
|
13721
|
+
def component_type(self) -> pulumi.Input[builtins.str]:
|
|
13722
|
+
"""
|
|
13723
|
+
Type of the Java Component.
|
|
13724
|
+
Expected value is 'SpringCloudGateway'.
|
|
13725
|
+
"""
|
|
13726
|
+
return pulumi.get(self, "component_type")
|
|
13727
|
+
|
|
13728
|
+
@component_type.setter
|
|
13729
|
+
def component_type(self, value: pulumi.Input[builtins.str]):
|
|
13730
|
+
pulumi.set(self, "component_type", value)
|
|
13731
|
+
|
|
13732
|
+
@property
|
|
13733
|
+
@pulumi.getter
|
|
13734
|
+
def configurations(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['JavaComponentConfigurationPropertyArgs']]]]:
|
|
13735
|
+
"""
|
|
13736
|
+
List of Java Components configuration properties
|
|
13737
|
+
"""
|
|
13738
|
+
return pulumi.get(self, "configurations")
|
|
13739
|
+
|
|
13740
|
+
@configurations.setter
|
|
13741
|
+
def configurations(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['JavaComponentConfigurationPropertyArgs']]]]):
|
|
13742
|
+
pulumi.set(self, "configurations", value)
|
|
13743
|
+
|
|
13744
|
+
@property
|
|
13745
|
+
@pulumi.getter
|
|
13746
|
+
def scale(self) -> Optional[pulumi.Input['JavaComponentPropertiesScaleArgs']]:
|
|
13747
|
+
"""
|
|
13748
|
+
Java component scaling configurations
|
|
13749
|
+
"""
|
|
13750
|
+
return pulumi.get(self, "scale")
|
|
13751
|
+
|
|
13752
|
+
@scale.setter
|
|
13753
|
+
def scale(self, value: Optional[pulumi.Input['JavaComponentPropertiesScaleArgs']]):
|
|
13754
|
+
pulumi.set(self, "scale", value)
|
|
13755
|
+
|
|
13756
|
+
@property
|
|
13757
|
+
@pulumi.getter(name="serviceBinds")
|
|
13758
|
+
def service_binds(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['JavaComponentServiceBindArgs']]]]:
|
|
13759
|
+
"""
|
|
13760
|
+
List of Java Components that are bound to the Java component
|
|
13761
|
+
"""
|
|
13762
|
+
return pulumi.get(self, "service_binds")
|
|
13763
|
+
|
|
13764
|
+
@service_binds.setter
|
|
13765
|
+
def service_binds(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['JavaComponentServiceBindArgs']]]]):
|
|
13766
|
+
pulumi.set(self, "service_binds", value)
|
|
13767
|
+
|
|
13768
|
+
@property
|
|
13769
|
+
@pulumi.getter(name="springCloudGatewayRoutes")
|
|
13770
|
+
def spring_cloud_gateway_routes(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ScgRouteArgs']]]]:
|
|
13771
|
+
"""
|
|
13772
|
+
Gateway route definition
|
|
13773
|
+
"""
|
|
13774
|
+
return pulumi.get(self, "spring_cloud_gateway_routes")
|
|
13775
|
+
|
|
13776
|
+
@spring_cloud_gateway_routes.setter
|
|
13777
|
+
def spring_cloud_gateway_routes(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ScgRouteArgs']]]]):
|
|
13778
|
+
pulumi.set(self, "spring_cloud_gateway_routes", value)
|
|
13779
|
+
|
|
13780
|
+
|
|
11082
13781
|
if not MYPY:
|
|
11083
13782
|
class TcpConnectionPoolArgsDict(TypedDict):
|
|
11084
13783
|
"""
|
|
@@ -11525,6 +14224,62 @@ class TokenStoreArgs:
|
|
|
11525
14224
|
pulumi.set(self, "token_refresh_extension_hours", value)
|
|
11526
14225
|
|
|
11527
14226
|
|
|
14227
|
+
if not MYPY:
|
|
14228
|
+
class TracesConfigurationArgsDict(TypedDict):
|
|
14229
|
+
"""
|
|
14230
|
+
Configuration of Open Telemetry traces
|
|
14231
|
+
"""
|
|
14232
|
+
destinations: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]
|
|
14233
|
+
"""
|
|
14234
|
+
Open telemetry traces destinations
|
|
14235
|
+
"""
|
|
14236
|
+
include_dapr: NotRequired[pulumi.Input[builtins.bool]]
|
|
14237
|
+
"""
|
|
14238
|
+
Boolean indicating if including dapr traces
|
|
14239
|
+
"""
|
|
14240
|
+
elif False:
|
|
14241
|
+
TracesConfigurationArgsDict: TypeAlias = Mapping[str, Any]
|
|
14242
|
+
|
|
14243
|
+
@pulumi.input_type
|
|
14244
|
+
class TracesConfigurationArgs:
|
|
14245
|
+
def __init__(__self__, *,
|
|
14246
|
+
destinations: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
|
|
14247
|
+
include_dapr: Optional[pulumi.Input[builtins.bool]] = None):
|
|
14248
|
+
"""
|
|
14249
|
+
Configuration of Open Telemetry traces
|
|
14250
|
+
:param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] destinations: Open telemetry traces destinations
|
|
14251
|
+
:param pulumi.Input[builtins.bool] include_dapr: Boolean indicating if including dapr traces
|
|
14252
|
+
"""
|
|
14253
|
+
if destinations is not None:
|
|
14254
|
+
pulumi.set(__self__, "destinations", destinations)
|
|
14255
|
+
if include_dapr is not None:
|
|
14256
|
+
pulumi.set(__self__, "include_dapr", include_dapr)
|
|
14257
|
+
|
|
14258
|
+
@property
|
|
14259
|
+
@pulumi.getter
|
|
14260
|
+
def destinations(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
|
|
14261
|
+
"""
|
|
14262
|
+
Open telemetry traces destinations
|
|
14263
|
+
"""
|
|
14264
|
+
return pulumi.get(self, "destinations")
|
|
14265
|
+
|
|
14266
|
+
@destinations.setter
|
|
14267
|
+
def destinations(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]):
|
|
14268
|
+
pulumi.set(self, "destinations", value)
|
|
14269
|
+
|
|
14270
|
+
@property
|
|
14271
|
+
@pulumi.getter(name="includeDapr")
|
|
14272
|
+
def include_dapr(self) -> Optional[pulumi.Input[builtins.bool]]:
|
|
14273
|
+
"""
|
|
14274
|
+
Boolean indicating if including dapr traces
|
|
14275
|
+
"""
|
|
14276
|
+
return pulumi.get(self, "include_dapr")
|
|
14277
|
+
|
|
14278
|
+
@include_dapr.setter
|
|
14279
|
+
def include_dapr(self, value: Optional[pulumi.Input[builtins.bool]]):
|
|
14280
|
+
pulumi.set(self, "include_dapr", value)
|
|
14281
|
+
|
|
14282
|
+
|
|
11528
14283
|
if not MYPY:
|
|
11529
14284
|
class TrafficWeightArgsDict(TypedDict):
|
|
11530
14285
|
"""
|
|
@@ -12065,6 +14820,10 @@ if not MYPY:
|
|
|
12065
14820
|
"""
|
|
12066
14821
|
Workload profile type for the workloads to run on.
|
|
12067
14822
|
"""
|
|
14823
|
+
enable_fips: NotRequired[pulumi.Input[builtins.bool]]
|
|
14824
|
+
"""
|
|
14825
|
+
Whether to use a FIPS-enabled OS. Supported only for dedicated workload profiles.
|
|
14826
|
+
"""
|
|
12068
14827
|
maximum_count: NotRequired[pulumi.Input[builtins.int]]
|
|
12069
14828
|
"""
|
|
12070
14829
|
The maximum capacity.
|
|
@@ -12081,17 +14840,23 @@ class WorkloadProfileArgs:
|
|
|
12081
14840
|
def __init__(__self__, *,
|
|
12082
14841
|
name: pulumi.Input[builtins.str],
|
|
12083
14842
|
workload_profile_type: pulumi.Input[builtins.str],
|
|
14843
|
+
enable_fips: Optional[pulumi.Input[builtins.bool]] = None,
|
|
12084
14844
|
maximum_count: Optional[pulumi.Input[builtins.int]] = None,
|
|
12085
14845
|
minimum_count: Optional[pulumi.Input[builtins.int]] = None):
|
|
12086
14846
|
"""
|
|
12087
14847
|
Workload profile to scope container app execution.
|
|
12088
14848
|
:param pulumi.Input[builtins.str] name: Workload profile type for the workloads to run on.
|
|
12089
14849
|
:param pulumi.Input[builtins.str] workload_profile_type: Workload profile type for the workloads to run on.
|
|
14850
|
+
:param pulumi.Input[builtins.bool] enable_fips: Whether to use a FIPS-enabled OS. Supported only for dedicated workload profiles.
|
|
12090
14851
|
:param pulumi.Input[builtins.int] maximum_count: The maximum capacity.
|
|
12091
14852
|
:param pulumi.Input[builtins.int] minimum_count: The minimum capacity.
|
|
12092
14853
|
"""
|
|
12093
14854
|
pulumi.set(__self__, "name", name)
|
|
12094
14855
|
pulumi.set(__self__, "workload_profile_type", workload_profile_type)
|
|
14856
|
+
if enable_fips is None:
|
|
14857
|
+
enable_fips = False
|
|
14858
|
+
if enable_fips is not None:
|
|
14859
|
+
pulumi.set(__self__, "enable_fips", enable_fips)
|
|
12095
14860
|
if maximum_count is not None:
|
|
12096
14861
|
pulumi.set(__self__, "maximum_count", maximum_count)
|
|
12097
14862
|
if minimum_count is not None:
|
|
@@ -12121,6 +14886,18 @@ class WorkloadProfileArgs:
|
|
|
12121
14886
|
def workload_profile_type(self, value: pulumi.Input[builtins.str]):
|
|
12122
14887
|
pulumi.set(self, "workload_profile_type", value)
|
|
12123
14888
|
|
|
14889
|
+
@property
|
|
14890
|
+
@pulumi.getter(name="enableFips")
|
|
14891
|
+
def enable_fips(self) -> Optional[pulumi.Input[builtins.bool]]:
|
|
14892
|
+
"""
|
|
14893
|
+
Whether to use a FIPS-enabled OS. Supported only for dedicated workload profiles.
|
|
14894
|
+
"""
|
|
14895
|
+
return pulumi.get(self, "enable_fips")
|
|
14896
|
+
|
|
14897
|
+
@enable_fips.setter
|
|
14898
|
+
def enable_fips(self, value: Optional[pulumi.Input[builtins.bool]]):
|
|
14899
|
+
pulumi.set(self, "enable_fips", value)
|
|
14900
|
+
|
|
12124
14901
|
@property
|
|
12125
14902
|
@pulumi.getter(name="maximumCount")
|
|
12126
14903
|
def maximum_count(self) -> Optional[pulumi.Input[builtins.int]]:
|