pulumi-harness 0.5.0a1736833425__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-harness might be problematic. Click here for more details.
- pulumi_harness/__init__.py +1257 -0
- pulumi_harness/_inputs.py +4025 -0
- pulumi_harness/_utilities.py +327 -0
- pulumi_harness/add_user_to_group.py +241 -0
- pulumi_harness/application.py +393 -0
- pulumi_harness/application_git_sync.py +411 -0
- pulumi_harness/autostopping/__init__.py +27 -0
- pulumi_harness/autostopping/_inputs.py +2688 -0
- pulumi_harness/autostopping/aws_alb.py +640 -0
- pulumi_harness/autostopping/aws_proxy.py +760 -0
- pulumi_harness/autostopping/azure_gateway.py +798 -0
- pulumi_harness/autostopping/azure_proxy.py +855 -0
- pulumi_harness/autostopping/gcp_proxy.py +779 -0
- pulumi_harness/autostopping/get_aws_alb.py +278 -0
- pulumi_harness/autostopping/get_aws_proxy.py +335 -0
- pulumi_harness/autostopping/get_azure_gateway.py +343 -0
- pulumi_harness/autostopping/get_azure_proxy.py +375 -0
- pulumi_harness/autostopping/get_gcp_proxy.py +340 -0
- pulumi_harness/autostopping/get_rule_ecs.py +225 -0
- pulumi_harness/autostopping/get_rule_rds.py +205 -0
- pulumi_harness/autostopping/get_rule_vm.py +265 -0
- pulumi_harness/autostopping/get_schedule.py +193 -0
- pulumi_harness/autostopping/outputs.py +1971 -0
- pulumi_harness/autostopping/rule_ecs.py +450 -0
- pulumi_harness/autostopping/rule_rds.py +448 -0
- pulumi_harness/autostopping/rule_vm.py +663 -0
- pulumi_harness/autostopping/schedule.py +465 -0
- pulumi_harness/cloudprovider/__init__.py +17 -0
- pulumi_harness/cloudprovider/_inputs.py +777 -0
- pulumi_harness/cloudprovider/aws.py +586 -0
- pulumi_harness/cloudprovider/azure.py +393 -0
- pulumi_harness/cloudprovider/datacenter.py +233 -0
- pulumi_harness/cloudprovider/gcp.py +340 -0
- pulumi_harness/cloudprovider/get_delegate_ids.py +148 -0
- pulumi_harness/cloudprovider/kubernetes.py +310 -0
- pulumi_harness/cloudprovider/outputs.py +657 -0
- pulumi_harness/cloudprovider/spot.py +296 -0
- pulumi_harness/cloudprovider/tanzu.py +441 -0
- pulumi_harness/cluster/__init__.py +9 -0
- pulumi_harness/cluster/get_orchestrator.py +134 -0
- pulumi_harness/cluster/orchestrator.py +286 -0
- pulumi_harness/config/__init__.py +8 -0
- pulumi_harness/config/__init__.pyi +40 -0
- pulumi_harness/config/vars.py +54 -0
- pulumi_harness/delegate_approval.py +267 -0
- pulumi_harness/encrypted_text.py +499 -0
- pulumi_harness/environment.py +446 -0
- pulumi_harness/get_application.py +180 -0
- pulumi_harness/get_current_account.py +108 -0
- pulumi_harness/get_delegate.py +280 -0
- pulumi_harness/get_encrypted_text.py +136 -0
- pulumi_harness/get_environment.py +184 -0
- pulumi_harness/get_git_connector.py +255 -0
- pulumi_harness/get_secret_manager.py +142 -0
- pulumi_harness/get_service.py +198 -0
- pulumi_harness/get_ssh_credential.py +122 -0
- pulumi_harness/get_sso_provider.py +114 -0
- pulumi_harness/get_trigger.py +177 -0
- pulumi_harness/get_user.py +184 -0
- pulumi_harness/get_user_group.py +100 -0
- pulumi_harness/get_yaml_config.py +142 -0
- pulumi_harness/git_connector.py +738 -0
- pulumi_harness/governance/__init__.py +13 -0
- pulumi_harness/governance/get_rule.py +168 -0
- pulumi_harness/governance/get_rule_enforcement.py +266 -0
- pulumi_harness/governance/get_rule_set.py +150 -0
- pulumi_harness/governance/rule.py +337 -0
- pulumi_harness/governance/rule_enforcement.py +668 -0
- pulumi_harness/governance/rule_set.py +321 -0
- pulumi_harness/infrastructure_definition.py +1246 -0
- pulumi_harness/outputs.py +3306 -0
- pulumi_harness/platform/__init__.py +220 -0
- pulumi_harness/platform/_inputs.py +22314 -0
- pulumi_harness/platform/app_dynamics_connector.py +733 -0
- pulumi_harness/platform/artifactory_connector.py +748 -0
- pulumi_harness/platform/aws_cc_connector.py +716 -0
- pulumi_harness/platform/aws_connector.py +851 -0
- pulumi_harness/platform/aws_kms_connector.py +619 -0
- pulumi_harness/platform/aws_secret_manager_connector.py +712 -0
- pulumi_harness/platform/azure_cloud_cost_connector.py +675 -0
- pulumi_harness/platform/azure_cloud_provider_connector.py +826 -0
- pulumi_harness/platform/azure_key_vault_connector.py +843 -0
- pulumi_harness/platform/bitbucket_connector.py +713 -0
- pulumi_harness/platform/connector_azure_artifacts.py +529 -0
- pulumi_harness/platform/connector_custom_secret_manager.py +887 -0
- pulumi_harness/platform/connector_customhealthsource.py +807 -0
- pulumi_harness/platform/connector_jdbc.py +609 -0
- pulumi_harness/platform/connector_pdc.py +527 -0
- pulumi_harness/platform/connector_rancher.py +617 -0
- pulumi_harness/platform/datadog_connector.py +651 -0
- pulumi_harness/platform/db_instance.py +636 -0
- pulumi_harness/platform/db_schema.py +547 -0
- pulumi_harness/platform/delegatetoken.py +520 -0
- pulumi_harness/platform/docker_connector.py +669 -0
- pulumi_harness/platform/dynatrace_connector.py +601 -0
- pulumi_harness/platform/elasticsearch_connector.py +744 -0
- pulumi_harness/platform/environment.py +1173 -0
- pulumi_harness/platform/environment_clusters_mapping.py +454 -0
- pulumi_harness/platform/environment_group.py +560 -0
- pulumi_harness/platform/environment_service_overrides.py +688 -0
- pulumi_harness/platform/feature_flag.py +724 -0
- pulumi_harness/platform/feature_flag_api_key.py +550 -0
- pulumi_harness/platform/feature_flag_target.py +473 -0
- pulumi_harness/platform/feature_flag_target_group.py +577 -0
- pulumi_harness/platform/file_store_file.py +822 -0
- pulumi_harness/platform/file_store_folder.py +628 -0
- pulumi_harness/platform/filters.py +511 -0
- pulumi_harness/platform/gcp_cloud_cost_connector.py +669 -0
- pulumi_harness/platform/gcp_connector.py +663 -0
- pulumi_harness/platform/gcp_secret_manager_connector.py +594 -0
- pulumi_harness/platform/get_api_key.py +292 -0
- pulumi_harness/platform/get_app_dynamics_connector.py +271 -0
- pulumi_harness/platform/get_artifactory_connector.py +243 -0
- pulumi_harness/platform/get_aws_cc_connector.py +271 -0
- pulumi_harness/platform/get_aws_connector.py +313 -0
- pulumi_harness/platform/get_aws_kms_connector.py +253 -0
- pulumi_harness/platform/get_aws_secret_manager_connector.py +267 -0
- pulumi_harness/platform/get_azure_cloud_cost_connector.py +257 -0
- pulumi_harness/platform/get_azure_cloud_provider_connector.py +257 -0
- pulumi_harness/platform/get_azure_key_vault_connector.py +308 -0
- pulumi_harness/platform/get_bitbucket_connector.py +285 -0
- pulumi_harness/platform/get_ccm_filters.py +221 -0
- pulumi_harness/platform/get_connector_custom_secret_manager.py +330 -0
- pulumi_harness/platform/get_connector_customhealthsource.py +281 -0
- pulumi_harness/platform/get_connector_jdbc.py +243 -0
- pulumi_harness/platform/get_connector_pdc.py +229 -0
- pulumi_harness/platform/get_connector_rancher.py +236 -0
- pulumi_harness/platform/get_current_account.py +126 -0
- pulumi_harness/platform/get_current_user.py +252 -0
- pulumi_harness/platform/get_datadog_connector.py +262 -0
- pulumi_harness/platform/get_db_instance.py +268 -0
- pulumi_harness/platform/get_db_schema.py +233 -0
- pulumi_harness/platform/get_delegatetoken.py +214 -0
- pulumi_harness/platform/get_docker_connector.py +257 -0
- pulumi_harness/platform/get_dynatrace_connector.py +242 -0
- pulumi_harness/platform/get_elasticsearch_connector.py +257 -0
- pulumi_harness/platform/get_environment.py +263 -0
- pulumi_harness/platform/get_environment_clusters_mapping.py +262 -0
- pulumi_harness/platform/get_environment_group.py +190 -0
- pulumi_harness/platform/get_environment_list.py +172 -0
- pulumi_harness/platform/get_environment_service_overrides.py +212 -0
- pulumi_harness/platform/get_file_store_file.py +327 -0
- pulumi_harness/platform/get_file_store_folder.py +271 -0
- pulumi_harness/platform/get_filters.py +217 -0
- pulumi_harness/platform/get_gcp_cloud_cost_connector.py +257 -0
- pulumi_harness/platform/get_gcp_connector.py +243 -0
- pulumi_harness/platform/get_gcp_secret_manager_connector.py +238 -0
- pulumi_harness/platform/get_git_connector.py +271 -0
- pulumi_harness/platform/get_github_connector.py +296 -0
- pulumi_harness/platform/get_gitlab_connector.py +285 -0
- pulumi_harness/platform/get_gitops_agent.py +303 -0
- pulumi_harness/platform/get_gitops_agent_deploy_yaml.py +257 -0
- pulumi_harness/platform/get_gitops_app_project.py +191 -0
- pulumi_harness/platform/get_gitops_app_project_mapping.py +189 -0
- pulumi_harness/platform/get_gitops_applications.py +351 -0
- pulumi_harness/platform/get_gitops_cluster.py +216 -0
- pulumi_harness/platform/get_gitops_gnupg.py +219 -0
- pulumi_harness/platform/get_gitops_repo_cert.py +155 -0
- pulumi_harness/platform/get_gitops_repo_cred.py +223 -0
- pulumi_harness/platform/get_gitops_repository.py +230 -0
- pulumi_harness/platform/get_gitx_webhook.py +194 -0
- pulumi_harness/platform/get_helm_connector.py +243 -0
- pulumi_harness/platform/get_iacm_default_pipeline.py +168 -0
- pulumi_harness/platform/get_infra_module.py +320 -0
- pulumi_harness/platform/get_infrastructure.py +287 -0
- pulumi_harness/platform/get_input_set.py +238 -0
- pulumi_harness/platform/get_jenkins_connector.py +243 -0
- pulumi_harness/platform/get_jira_connector.py +285 -0
- pulumi_harness/platform/get_kubernetes_cloud_cost_connector.py +228 -0
- pulumi_harness/platform/get_kubernetes_connector.py +285 -0
- pulumi_harness/platform/get_manual_freeze.py +305 -0
- pulumi_harness/platform/get_monitored_service.py +134 -0
- pulumi_harness/platform/get_nexus_connector.py +257 -0
- pulumi_harness/platform/get_notification_rule.py +156 -0
- pulumi_harness/platform/get_oci_helm_connector.py +243 -0
- pulumi_harness/platform/get_organization.py +156 -0
- pulumi_harness/platform/get_overrides.py +198 -0
- pulumi_harness/platform/get_pagerduty_connector.py +224 -0
- pulumi_harness/platform/get_permissions.py +149 -0
- pulumi_harness/platform/get_pipeline.py +268 -0
- pulumi_harness/platform/get_pipeline_filters.py +197 -0
- pulumi_harness/platform/get_pipeline_list.py +269 -0
- pulumi_harness/platform/get_policy.py +220 -0
- pulumi_harness/platform/get_policy_set.py +298 -0
- pulumi_harness/platform/get_project.py +210 -0
- pulumi_harness/platform/get_project_list.py +249 -0
- pulumi_harness/platform/get_prometheus_connector.py +271 -0
- pulumi_harness/platform/get_provider.py +85 -0
- pulumi_harness/platform/get_repo.py +362 -0
- pulumi_harness/platform/get_repo_rule_branch.py +312 -0
- pulumi_harness/platform/get_repo_webhook.py +316 -0
- pulumi_harness/platform/get_resource_group.py +267 -0
- pulumi_harness/platform/get_role_assignments.py +223 -0
- pulumi_harness/platform/get_roles.py +240 -0
- pulumi_harness/platform/get_secret_file.py +224 -0
- pulumi_harness/platform/get_secret_sshkey.py +239 -0
- pulumi_harness/platform/get_secret_text.py +264 -0
- pulumi_harness/platform/get_service.py +235 -0
- pulumi_harness/platform/get_service_account.py +224 -0
- pulumi_harness/platform/get_service_list.py +172 -0
- pulumi_harness/platform/get_service_now_connector.py +285 -0
- pulumi_harness/platform/get_service_overrides_v2.py +220 -0
- pulumi_harness/platform/get_slo.py +134 -0
- pulumi_harness/platform/get_splunk_connector.py +270 -0
- pulumi_harness/platform/get_spot_connector.py +215 -0
- pulumi_harness/platform/get_sumologic_connector.py +256 -0
- pulumi_harness/platform/get_tas_connector.py +243 -0
- pulumi_harness/platform/get_template.py +386 -0
- pulumi_harness/platform/get_template_filters.py +221 -0
- pulumi_harness/platform/get_terraform_cloud_connector.py +233 -0
- pulumi_harness/platform/get_token.py +430 -0
- pulumi_harness/platform/get_triggers.py +260 -0
- pulumi_harness/platform/get_user.py +222 -0
- pulumi_harness/platform/get_usergroup.py +340 -0
- pulumi_harness/platform/get_variables.py +209 -0
- pulumi_harness/platform/get_vault_connector.py +574 -0
- pulumi_harness/platform/get_workspace.py +411 -0
- pulumi_harness/platform/get_workspace_output_value.py +168 -0
- pulumi_harness/platform/git_connector.py +713 -0
- pulumi_harness/platform/git_ops_agent.py +727 -0
- pulumi_harness/platform/git_ops_applications.py +1090 -0
- pulumi_harness/platform/git_ops_cluster.py +438 -0
- pulumi_harness/platform/git_ops_gnupg.py +453 -0
- pulumi_harness/platform/git_ops_repo_cert.py +437 -0
- pulumi_harness/platform/git_ops_repo_cred.py +533 -0
- pulumi_harness/platform/git_ops_repository.py +831 -0
- pulumi_harness/platform/github_connector.py +807 -0
- pulumi_harness/platform/gitlab_connector.py +713 -0
- pulumi_harness/platform/gitops_app_project.py +485 -0
- pulumi_harness/platform/gitops_app_project_mapping.py +423 -0
- pulumi_harness/platform/gitx_webhook.py +616 -0
- pulumi_harness/platform/helm_connector.py +617 -0
- pulumi_harness/platform/iacm_default_pipeline.py +343 -0
- pulumi_harness/platform/infra_module.py +755 -0
- pulumi_harness/platform/infrastructure.py +937 -0
- pulumi_harness/platform/input_set.py +689 -0
- pulumi_harness/platform/jenkins_connector.py +566 -0
- pulumi_harness/platform/jira_connector.py +714 -0
- pulumi_harness/platform/kubernetes_cloud_cost_connector.py +558 -0
- pulumi_harness/platform/kubernetes_connector.py +895 -0
- pulumi_harness/platform/manual_freeze.py +835 -0
- pulumi_harness/platform/monitored_service.py +1984 -0
- pulumi_harness/platform/newrelic_connector.py +651 -0
- pulumi_harness/platform/nexus_connector.py +622 -0
- pulumi_harness/platform/notification_rule.py +526 -0
- pulumi_harness/platform/oci_helm_connector.py +617 -0
- pulumi_harness/platform/organization.py +336 -0
- pulumi_harness/platform/outputs.py +23361 -0
- pulumi_harness/platform/overrides.py +669 -0
- pulumi_harness/platform/pagerduty_connector.py +547 -0
- pulumi_harness/platform/pipeline.py +991 -0
- pulumi_harness/platform/pipeline_filters.py +711 -0
- pulumi_harness/platform/policy.py +944 -0
- pulumi_harness/platform/policy_set.py +594 -0
- pulumi_harness/platform/project.py +453 -0
- pulumi_harness/platform/prometheus_connector.py +710 -0
- pulumi_harness/platform/provider.py +349 -0
- pulumi_harness/platform/repo.py +737 -0
- pulumi_harness/platform/repo_rule_branch.py +645 -0
- pulumi_harness/platform/repo_webhook.py +664 -0
- pulumi_harness/platform/resource_group.py +718 -0
- pulumi_harness/platform/role_assignments.py +524 -0
- pulumi_harness/platform/roles.py +546 -0
- pulumi_harness/platform/secret_file.py +548 -0
- pulumi_harness/platform/secret_sshkey.py +569 -0
- pulumi_harness/platform/secret_text.py +620 -0
- pulumi_harness/platform/service.py +1195 -0
- pulumi_harness/platform/service_account.py +548 -0
- pulumi_harness/platform/service_now_connector.py +714 -0
- pulumi_harness/platform/service_overrides_v2.py +915 -0
- pulumi_harness/platform/slo.py +462 -0
- pulumi_harness/platform/splunk_connector.py +701 -0
- pulumi_harness/platform/spot_connector.py +452 -0
- pulumi_harness/platform/sumologic_connector.py +651 -0
- pulumi_harness/platform/tas_connector.py +570 -0
- pulumi_harness/platform/template.py +861 -0
- pulumi_harness/platform/template_filters.py +515 -0
- pulumi_harness/platform/terraform_cloud_connector.py +545 -0
- pulumi_harness/platform/token.py +977 -0
- pulumi_harness/platform/triggers.py +680 -0
- pulumi_harness/platform/user.py +522 -0
- pulumi_harness/platform/usergroup.py +1104 -0
- pulumi_harness/platform/variables.py +509 -0
- pulumi_harness/platform/vault_connector.py +1919 -0
- pulumi_harness/platform/workspace.py +1145 -0
- pulumi_harness/platform_api_key.py +617 -0
- pulumi_harness/platform_ccm_filters.py +515 -0
- pulumi_harness/provider.py +227 -0
- pulumi_harness/pulumi-plugin.json +6 -0
- pulumi_harness/py.typed +0 -0
- pulumi_harness/service/__init__.py +18 -0
- pulumi_harness/service/_inputs.py +660 -0
- pulumi_harness/service/ami.py +336 -0
- pulumi_harness/service/codedeploy.py +336 -0
- pulumi_harness/service/ecs.py +336 -0
- pulumi_harness/service/helm.py +336 -0
- pulumi_harness/service/kubernetes.py +409 -0
- pulumi_harness/service/lambda_.py +336 -0
- pulumi_harness/service/outputs.py +388 -0
- pulumi_harness/service/ssh.py +386 -0
- pulumi_harness/service/tanzu.py +336 -0
- pulumi_harness/service/winrm.py +386 -0
- pulumi_harness/ssh_credential.py +361 -0
- pulumi_harness/user.py +423 -0
- pulumi_harness/user_group.py +713 -0
- pulumi_harness/user_group_permissions.py +247 -0
- pulumi_harness/yaml_config.py +336 -0
- pulumi_harness-0.5.0a1736833425.dist-info/METADATA +69 -0
- pulumi_harness-0.5.0a1736833425.dist-info/RECORD +311 -0
- pulumi_harness-0.5.0a1736833425.dist-info/WHEEL +5 -0
- pulumi_harness-0.5.0a1736833425.dist-info/top_level.txt +1 -0
|
@@ -0,0 +1,2688 @@
|
|
|
1
|
+
# coding=utf-8
|
|
2
|
+
# *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. ***
|
|
3
|
+
# *** Do not edit by hand unless you're certain you know what you are doing! ***
|
|
4
|
+
|
|
5
|
+
import copy
|
|
6
|
+
import warnings
|
|
7
|
+
import sys
|
|
8
|
+
import pulumi
|
|
9
|
+
import pulumi.runtime
|
|
10
|
+
from typing import Any, Mapping, Optional, Sequence, Union, overload
|
|
11
|
+
if sys.version_info >= (3, 11):
|
|
12
|
+
from typing import NotRequired, TypedDict, TypeAlias
|
|
13
|
+
else:
|
|
14
|
+
from typing_extensions import NotRequired, TypedDict, TypeAlias
|
|
15
|
+
from .. import _utilities
|
|
16
|
+
|
|
17
|
+
__all__ = [
|
|
18
|
+
'AwsProxyCertificatesArgs',
|
|
19
|
+
'AwsProxyCertificatesArgsDict',
|
|
20
|
+
'AzureProxyCertificatesArgs',
|
|
21
|
+
'AzureProxyCertificatesArgsDict',
|
|
22
|
+
'GcpProxyCertificatesArgs',
|
|
23
|
+
'GcpProxyCertificatesArgsDict',
|
|
24
|
+
'RuleEcsContainerArgs',
|
|
25
|
+
'RuleEcsContainerArgsDict',
|
|
26
|
+
'RuleEcsDependArgs',
|
|
27
|
+
'RuleEcsDependArgsDict',
|
|
28
|
+
'RuleEcsHttpArgs',
|
|
29
|
+
'RuleEcsHttpArgsDict',
|
|
30
|
+
'RuleRdsDatabaseArgs',
|
|
31
|
+
'RuleRdsDatabaseArgsDict',
|
|
32
|
+
'RuleRdsDependArgs',
|
|
33
|
+
'RuleRdsDependArgsDict',
|
|
34
|
+
'RuleRdsTcpArgs',
|
|
35
|
+
'RuleRdsTcpArgsDict',
|
|
36
|
+
'RuleRdsTcpForwardRuleArgs',
|
|
37
|
+
'RuleRdsTcpForwardRuleArgsDict',
|
|
38
|
+
'RuleVmDependArgs',
|
|
39
|
+
'RuleVmDependArgsDict',
|
|
40
|
+
'RuleVmFilterArgs',
|
|
41
|
+
'RuleVmFilterArgsDict',
|
|
42
|
+
'RuleVmFilterTagArgs',
|
|
43
|
+
'RuleVmFilterTagArgsDict',
|
|
44
|
+
'RuleVmHttpArgs',
|
|
45
|
+
'RuleVmHttpArgsDict',
|
|
46
|
+
'RuleVmHttpHealthArgs',
|
|
47
|
+
'RuleVmHttpHealthArgsDict',
|
|
48
|
+
'RuleVmHttpRoutingArgs',
|
|
49
|
+
'RuleVmHttpRoutingArgsDict',
|
|
50
|
+
'RuleVmTcpArgs',
|
|
51
|
+
'RuleVmTcpArgsDict',
|
|
52
|
+
'RuleVmTcpForwardRuleArgs',
|
|
53
|
+
'RuleVmTcpForwardRuleArgsDict',
|
|
54
|
+
'RuleVmTcpRdpArgs',
|
|
55
|
+
'RuleVmTcpRdpArgsDict',
|
|
56
|
+
'RuleVmTcpSshArgs',
|
|
57
|
+
'RuleVmTcpSshArgsDict',
|
|
58
|
+
'ScheduleRepeatArgs',
|
|
59
|
+
'ScheduleRepeatArgsDict',
|
|
60
|
+
'GetAwsProxyCertificatesArgs',
|
|
61
|
+
'GetAwsProxyCertificatesArgsDict',
|
|
62
|
+
'GetAzureProxyCertificatesArgs',
|
|
63
|
+
'GetAzureProxyCertificatesArgsDict',
|
|
64
|
+
'GetGcpProxyCertificatesArgs',
|
|
65
|
+
'GetGcpProxyCertificatesArgsDict',
|
|
66
|
+
'GetRuleEcsContainerArgs',
|
|
67
|
+
'GetRuleEcsContainerArgsDict',
|
|
68
|
+
'GetRuleEcsDependArgs',
|
|
69
|
+
'GetRuleEcsDependArgsDict',
|
|
70
|
+
'GetRuleEcsHttpArgs',
|
|
71
|
+
'GetRuleEcsHttpArgsDict',
|
|
72
|
+
'GetRuleRdsDatabaseArgs',
|
|
73
|
+
'GetRuleRdsDatabaseArgsDict',
|
|
74
|
+
'GetRuleRdsDependArgs',
|
|
75
|
+
'GetRuleRdsDependArgsDict',
|
|
76
|
+
'GetRuleRdsTcpArgs',
|
|
77
|
+
'GetRuleRdsTcpArgsDict',
|
|
78
|
+
'GetRuleRdsTcpForwardRuleArgs',
|
|
79
|
+
'GetRuleRdsTcpForwardRuleArgsDict',
|
|
80
|
+
'GetRuleVmDependArgs',
|
|
81
|
+
'GetRuleVmDependArgsDict',
|
|
82
|
+
'GetRuleVmFilterArgs',
|
|
83
|
+
'GetRuleVmFilterArgsDict',
|
|
84
|
+
'GetRuleVmFilterTagArgs',
|
|
85
|
+
'GetRuleVmFilterTagArgsDict',
|
|
86
|
+
'GetRuleVmHttpArgs',
|
|
87
|
+
'GetRuleVmHttpArgsDict',
|
|
88
|
+
'GetRuleVmHttpHealthArgs',
|
|
89
|
+
'GetRuleVmHttpHealthArgsDict',
|
|
90
|
+
'GetRuleVmHttpRoutingArgs',
|
|
91
|
+
'GetRuleVmHttpRoutingArgsDict',
|
|
92
|
+
'GetRuleVmTcpArgs',
|
|
93
|
+
'GetRuleVmTcpArgsDict',
|
|
94
|
+
'GetRuleVmTcpForwardRuleArgs',
|
|
95
|
+
'GetRuleVmTcpForwardRuleArgsDict',
|
|
96
|
+
'GetRuleVmTcpRdpArgs',
|
|
97
|
+
'GetRuleVmTcpRdpArgsDict',
|
|
98
|
+
'GetRuleVmTcpSshArgs',
|
|
99
|
+
'GetRuleVmTcpSshArgsDict',
|
|
100
|
+
]
|
|
101
|
+
|
|
102
|
+
MYPY = False
|
|
103
|
+
|
|
104
|
+
if not MYPY:
|
|
105
|
+
class AwsProxyCertificatesArgsDict(TypedDict):
|
|
106
|
+
cert_secret_id: pulumi.Input[str]
|
|
107
|
+
"""
|
|
108
|
+
Certificate secret ID
|
|
109
|
+
"""
|
|
110
|
+
key_secret_id: pulumi.Input[str]
|
|
111
|
+
"""
|
|
112
|
+
Private key secret ID
|
|
113
|
+
"""
|
|
114
|
+
elif False:
|
|
115
|
+
AwsProxyCertificatesArgsDict: TypeAlias = Mapping[str, Any]
|
|
116
|
+
|
|
117
|
+
@pulumi.input_type
|
|
118
|
+
class AwsProxyCertificatesArgs:
|
|
119
|
+
def __init__(__self__, *,
|
|
120
|
+
cert_secret_id: pulumi.Input[str],
|
|
121
|
+
key_secret_id: pulumi.Input[str]):
|
|
122
|
+
"""
|
|
123
|
+
:param pulumi.Input[str] cert_secret_id: Certificate secret ID
|
|
124
|
+
:param pulumi.Input[str] key_secret_id: Private key secret ID
|
|
125
|
+
"""
|
|
126
|
+
pulumi.set(__self__, "cert_secret_id", cert_secret_id)
|
|
127
|
+
pulumi.set(__self__, "key_secret_id", key_secret_id)
|
|
128
|
+
|
|
129
|
+
@property
|
|
130
|
+
@pulumi.getter(name="certSecretId")
|
|
131
|
+
def cert_secret_id(self) -> pulumi.Input[str]:
|
|
132
|
+
"""
|
|
133
|
+
Certificate secret ID
|
|
134
|
+
"""
|
|
135
|
+
return pulumi.get(self, "cert_secret_id")
|
|
136
|
+
|
|
137
|
+
@cert_secret_id.setter
|
|
138
|
+
def cert_secret_id(self, value: pulumi.Input[str]):
|
|
139
|
+
pulumi.set(self, "cert_secret_id", value)
|
|
140
|
+
|
|
141
|
+
@property
|
|
142
|
+
@pulumi.getter(name="keySecretId")
|
|
143
|
+
def key_secret_id(self) -> pulumi.Input[str]:
|
|
144
|
+
"""
|
|
145
|
+
Private key secret ID
|
|
146
|
+
"""
|
|
147
|
+
return pulumi.get(self, "key_secret_id")
|
|
148
|
+
|
|
149
|
+
@key_secret_id.setter
|
|
150
|
+
def key_secret_id(self, value: pulumi.Input[str]):
|
|
151
|
+
pulumi.set(self, "key_secret_id", value)
|
|
152
|
+
|
|
153
|
+
|
|
154
|
+
if not MYPY:
|
|
155
|
+
class AzureProxyCertificatesArgsDict(TypedDict):
|
|
156
|
+
cert_secret_id: pulumi.Input[str]
|
|
157
|
+
"""
|
|
158
|
+
ID of certificate secret uploaded to vault
|
|
159
|
+
"""
|
|
160
|
+
key_secret_id: pulumi.Input[str]
|
|
161
|
+
"""
|
|
162
|
+
ID of certificate key uploaded to vault
|
|
163
|
+
"""
|
|
164
|
+
elif False:
|
|
165
|
+
AzureProxyCertificatesArgsDict: TypeAlias = Mapping[str, Any]
|
|
166
|
+
|
|
167
|
+
@pulumi.input_type
|
|
168
|
+
class AzureProxyCertificatesArgs:
|
|
169
|
+
def __init__(__self__, *,
|
|
170
|
+
cert_secret_id: pulumi.Input[str],
|
|
171
|
+
key_secret_id: pulumi.Input[str]):
|
|
172
|
+
"""
|
|
173
|
+
:param pulumi.Input[str] cert_secret_id: ID of certificate secret uploaded to vault
|
|
174
|
+
:param pulumi.Input[str] key_secret_id: ID of certificate key uploaded to vault
|
|
175
|
+
"""
|
|
176
|
+
pulumi.set(__self__, "cert_secret_id", cert_secret_id)
|
|
177
|
+
pulumi.set(__self__, "key_secret_id", key_secret_id)
|
|
178
|
+
|
|
179
|
+
@property
|
|
180
|
+
@pulumi.getter(name="certSecretId")
|
|
181
|
+
def cert_secret_id(self) -> pulumi.Input[str]:
|
|
182
|
+
"""
|
|
183
|
+
ID of certificate secret uploaded to vault
|
|
184
|
+
"""
|
|
185
|
+
return pulumi.get(self, "cert_secret_id")
|
|
186
|
+
|
|
187
|
+
@cert_secret_id.setter
|
|
188
|
+
def cert_secret_id(self, value: pulumi.Input[str]):
|
|
189
|
+
pulumi.set(self, "cert_secret_id", value)
|
|
190
|
+
|
|
191
|
+
@property
|
|
192
|
+
@pulumi.getter(name="keySecretId")
|
|
193
|
+
def key_secret_id(self) -> pulumi.Input[str]:
|
|
194
|
+
"""
|
|
195
|
+
ID of certificate key uploaded to vault
|
|
196
|
+
"""
|
|
197
|
+
return pulumi.get(self, "key_secret_id")
|
|
198
|
+
|
|
199
|
+
@key_secret_id.setter
|
|
200
|
+
def key_secret_id(self, value: pulumi.Input[str]):
|
|
201
|
+
pulumi.set(self, "key_secret_id", value)
|
|
202
|
+
|
|
203
|
+
|
|
204
|
+
if not MYPY:
|
|
205
|
+
class GcpProxyCertificatesArgsDict(TypedDict):
|
|
206
|
+
cert_secret_id: pulumi.Input[str]
|
|
207
|
+
"""
|
|
208
|
+
Certificate secret ID
|
|
209
|
+
"""
|
|
210
|
+
key_secret_id: pulumi.Input[str]
|
|
211
|
+
"""
|
|
212
|
+
Private key secret ID
|
|
213
|
+
"""
|
|
214
|
+
elif False:
|
|
215
|
+
GcpProxyCertificatesArgsDict: TypeAlias = Mapping[str, Any]
|
|
216
|
+
|
|
217
|
+
@pulumi.input_type
|
|
218
|
+
class GcpProxyCertificatesArgs:
|
|
219
|
+
def __init__(__self__, *,
|
|
220
|
+
cert_secret_id: pulumi.Input[str],
|
|
221
|
+
key_secret_id: pulumi.Input[str]):
|
|
222
|
+
"""
|
|
223
|
+
:param pulumi.Input[str] cert_secret_id: Certificate secret ID
|
|
224
|
+
:param pulumi.Input[str] key_secret_id: Private key secret ID
|
|
225
|
+
"""
|
|
226
|
+
pulumi.set(__self__, "cert_secret_id", cert_secret_id)
|
|
227
|
+
pulumi.set(__self__, "key_secret_id", key_secret_id)
|
|
228
|
+
|
|
229
|
+
@property
|
|
230
|
+
@pulumi.getter(name="certSecretId")
|
|
231
|
+
def cert_secret_id(self) -> pulumi.Input[str]:
|
|
232
|
+
"""
|
|
233
|
+
Certificate secret ID
|
|
234
|
+
"""
|
|
235
|
+
return pulumi.get(self, "cert_secret_id")
|
|
236
|
+
|
|
237
|
+
@cert_secret_id.setter
|
|
238
|
+
def cert_secret_id(self, value: pulumi.Input[str]):
|
|
239
|
+
pulumi.set(self, "cert_secret_id", value)
|
|
240
|
+
|
|
241
|
+
@property
|
|
242
|
+
@pulumi.getter(name="keySecretId")
|
|
243
|
+
def key_secret_id(self) -> pulumi.Input[str]:
|
|
244
|
+
"""
|
|
245
|
+
Private key secret ID
|
|
246
|
+
"""
|
|
247
|
+
return pulumi.get(self, "key_secret_id")
|
|
248
|
+
|
|
249
|
+
@key_secret_id.setter
|
|
250
|
+
def key_secret_id(self, value: pulumi.Input[str]):
|
|
251
|
+
pulumi.set(self, "key_secret_id", value)
|
|
252
|
+
|
|
253
|
+
|
|
254
|
+
if not MYPY:
|
|
255
|
+
class RuleEcsContainerArgsDict(TypedDict):
|
|
256
|
+
cluster: pulumi.Input[str]
|
|
257
|
+
"""
|
|
258
|
+
Name of cluster in which service belong to
|
|
259
|
+
"""
|
|
260
|
+
region: pulumi.Input[str]
|
|
261
|
+
"""
|
|
262
|
+
Region of cluster
|
|
263
|
+
"""
|
|
264
|
+
service: pulumi.Input[str]
|
|
265
|
+
"""
|
|
266
|
+
Name of service to be onboarded
|
|
267
|
+
"""
|
|
268
|
+
task_count: NotRequired[pulumi.Input[int]]
|
|
269
|
+
"""
|
|
270
|
+
Desired number of tasks on warming up a rule
|
|
271
|
+
"""
|
|
272
|
+
elif False:
|
|
273
|
+
RuleEcsContainerArgsDict: TypeAlias = Mapping[str, Any]
|
|
274
|
+
|
|
275
|
+
@pulumi.input_type
|
|
276
|
+
class RuleEcsContainerArgs:
|
|
277
|
+
def __init__(__self__, *,
|
|
278
|
+
cluster: pulumi.Input[str],
|
|
279
|
+
region: pulumi.Input[str],
|
|
280
|
+
service: pulumi.Input[str],
|
|
281
|
+
task_count: Optional[pulumi.Input[int]] = None):
|
|
282
|
+
"""
|
|
283
|
+
:param pulumi.Input[str] cluster: Name of cluster in which service belong to
|
|
284
|
+
:param pulumi.Input[str] region: Region of cluster
|
|
285
|
+
:param pulumi.Input[str] service: Name of service to be onboarded
|
|
286
|
+
:param pulumi.Input[int] task_count: Desired number of tasks on warming up a rule
|
|
287
|
+
"""
|
|
288
|
+
pulumi.set(__self__, "cluster", cluster)
|
|
289
|
+
pulumi.set(__self__, "region", region)
|
|
290
|
+
pulumi.set(__self__, "service", service)
|
|
291
|
+
if task_count is not None:
|
|
292
|
+
pulumi.set(__self__, "task_count", task_count)
|
|
293
|
+
|
|
294
|
+
@property
|
|
295
|
+
@pulumi.getter
|
|
296
|
+
def cluster(self) -> pulumi.Input[str]:
|
|
297
|
+
"""
|
|
298
|
+
Name of cluster in which service belong to
|
|
299
|
+
"""
|
|
300
|
+
return pulumi.get(self, "cluster")
|
|
301
|
+
|
|
302
|
+
@cluster.setter
|
|
303
|
+
def cluster(self, value: pulumi.Input[str]):
|
|
304
|
+
pulumi.set(self, "cluster", value)
|
|
305
|
+
|
|
306
|
+
@property
|
|
307
|
+
@pulumi.getter
|
|
308
|
+
def region(self) -> pulumi.Input[str]:
|
|
309
|
+
"""
|
|
310
|
+
Region of cluster
|
|
311
|
+
"""
|
|
312
|
+
return pulumi.get(self, "region")
|
|
313
|
+
|
|
314
|
+
@region.setter
|
|
315
|
+
def region(self, value: pulumi.Input[str]):
|
|
316
|
+
pulumi.set(self, "region", value)
|
|
317
|
+
|
|
318
|
+
@property
|
|
319
|
+
@pulumi.getter
|
|
320
|
+
def service(self) -> pulumi.Input[str]:
|
|
321
|
+
"""
|
|
322
|
+
Name of service to be onboarded
|
|
323
|
+
"""
|
|
324
|
+
return pulumi.get(self, "service")
|
|
325
|
+
|
|
326
|
+
@service.setter
|
|
327
|
+
def service(self, value: pulumi.Input[str]):
|
|
328
|
+
pulumi.set(self, "service", value)
|
|
329
|
+
|
|
330
|
+
@property
|
|
331
|
+
@pulumi.getter(name="taskCount")
|
|
332
|
+
def task_count(self) -> Optional[pulumi.Input[int]]:
|
|
333
|
+
"""
|
|
334
|
+
Desired number of tasks on warming up a rule
|
|
335
|
+
"""
|
|
336
|
+
return pulumi.get(self, "task_count")
|
|
337
|
+
|
|
338
|
+
@task_count.setter
|
|
339
|
+
def task_count(self, value: Optional[pulumi.Input[int]]):
|
|
340
|
+
pulumi.set(self, "task_count", value)
|
|
341
|
+
|
|
342
|
+
|
|
343
|
+
if not MYPY:
|
|
344
|
+
class RuleEcsDependArgsDict(TypedDict):
|
|
345
|
+
rule_id: pulumi.Input[int]
|
|
346
|
+
"""
|
|
347
|
+
Rule id of the dependent rule
|
|
348
|
+
"""
|
|
349
|
+
delay_in_sec: NotRequired[pulumi.Input[int]]
|
|
350
|
+
"""
|
|
351
|
+
Number of seconds the rule should wait after warming up the dependent rule
|
|
352
|
+
"""
|
|
353
|
+
elif False:
|
|
354
|
+
RuleEcsDependArgsDict: TypeAlias = Mapping[str, Any]
|
|
355
|
+
|
|
356
|
+
@pulumi.input_type
|
|
357
|
+
class RuleEcsDependArgs:
|
|
358
|
+
def __init__(__self__, *,
|
|
359
|
+
rule_id: pulumi.Input[int],
|
|
360
|
+
delay_in_sec: Optional[pulumi.Input[int]] = None):
|
|
361
|
+
"""
|
|
362
|
+
:param pulumi.Input[int] rule_id: Rule id of the dependent rule
|
|
363
|
+
:param pulumi.Input[int] delay_in_sec: Number of seconds the rule should wait after warming up the dependent rule
|
|
364
|
+
"""
|
|
365
|
+
pulumi.set(__self__, "rule_id", rule_id)
|
|
366
|
+
if delay_in_sec is not None:
|
|
367
|
+
pulumi.set(__self__, "delay_in_sec", delay_in_sec)
|
|
368
|
+
|
|
369
|
+
@property
|
|
370
|
+
@pulumi.getter(name="ruleId")
|
|
371
|
+
def rule_id(self) -> pulumi.Input[int]:
|
|
372
|
+
"""
|
|
373
|
+
Rule id of the dependent rule
|
|
374
|
+
"""
|
|
375
|
+
return pulumi.get(self, "rule_id")
|
|
376
|
+
|
|
377
|
+
@rule_id.setter
|
|
378
|
+
def rule_id(self, value: pulumi.Input[int]):
|
|
379
|
+
pulumi.set(self, "rule_id", value)
|
|
380
|
+
|
|
381
|
+
@property
|
|
382
|
+
@pulumi.getter(name="delayInSec")
|
|
383
|
+
def delay_in_sec(self) -> Optional[pulumi.Input[int]]:
|
|
384
|
+
"""
|
|
385
|
+
Number of seconds the rule should wait after warming up the dependent rule
|
|
386
|
+
"""
|
|
387
|
+
return pulumi.get(self, "delay_in_sec")
|
|
388
|
+
|
|
389
|
+
@delay_in_sec.setter
|
|
390
|
+
def delay_in_sec(self, value: Optional[pulumi.Input[int]]):
|
|
391
|
+
pulumi.set(self, "delay_in_sec", value)
|
|
392
|
+
|
|
393
|
+
|
|
394
|
+
if not MYPY:
|
|
395
|
+
class RuleEcsHttpArgsDict(TypedDict):
|
|
396
|
+
proxy_id: pulumi.Input[str]
|
|
397
|
+
"""
|
|
398
|
+
Id of the proxy
|
|
399
|
+
"""
|
|
400
|
+
elif False:
|
|
401
|
+
RuleEcsHttpArgsDict: TypeAlias = Mapping[str, Any]
|
|
402
|
+
|
|
403
|
+
@pulumi.input_type
|
|
404
|
+
class RuleEcsHttpArgs:
|
|
405
|
+
def __init__(__self__, *,
|
|
406
|
+
proxy_id: pulumi.Input[str]):
|
|
407
|
+
"""
|
|
408
|
+
:param pulumi.Input[str] proxy_id: Id of the proxy
|
|
409
|
+
"""
|
|
410
|
+
pulumi.set(__self__, "proxy_id", proxy_id)
|
|
411
|
+
|
|
412
|
+
@property
|
|
413
|
+
@pulumi.getter(name="proxyId")
|
|
414
|
+
def proxy_id(self) -> pulumi.Input[str]:
|
|
415
|
+
"""
|
|
416
|
+
Id of the proxy
|
|
417
|
+
"""
|
|
418
|
+
return pulumi.get(self, "proxy_id")
|
|
419
|
+
|
|
420
|
+
@proxy_id.setter
|
|
421
|
+
def proxy_id(self, value: pulumi.Input[str]):
|
|
422
|
+
pulumi.set(self, "proxy_id", value)
|
|
423
|
+
|
|
424
|
+
|
|
425
|
+
if not MYPY:
|
|
426
|
+
class RuleRdsDatabaseArgsDict(TypedDict):
|
|
427
|
+
id: pulumi.Input[str]
|
|
428
|
+
"""
|
|
429
|
+
ID of the database
|
|
430
|
+
"""
|
|
431
|
+
region: pulumi.Input[str]
|
|
432
|
+
"""
|
|
433
|
+
Region to which database belong to
|
|
434
|
+
"""
|
|
435
|
+
elif False:
|
|
436
|
+
RuleRdsDatabaseArgsDict: TypeAlias = Mapping[str, Any]
|
|
437
|
+
|
|
438
|
+
@pulumi.input_type
|
|
439
|
+
class RuleRdsDatabaseArgs:
|
|
440
|
+
def __init__(__self__, *,
|
|
441
|
+
id: pulumi.Input[str],
|
|
442
|
+
region: pulumi.Input[str]):
|
|
443
|
+
"""
|
|
444
|
+
:param pulumi.Input[str] id: ID of the database
|
|
445
|
+
:param pulumi.Input[str] region: Region to which database belong to
|
|
446
|
+
"""
|
|
447
|
+
pulumi.set(__self__, "id", id)
|
|
448
|
+
pulumi.set(__self__, "region", region)
|
|
449
|
+
|
|
450
|
+
@property
|
|
451
|
+
@pulumi.getter
|
|
452
|
+
def id(self) -> pulumi.Input[str]:
|
|
453
|
+
"""
|
|
454
|
+
ID of the database
|
|
455
|
+
"""
|
|
456
|
+
return pulumi.get(self, "id")
|
|
457
|
+
|
|
458
|
+
@id.setter
|
|
459
|
+
def id(self, value: pulumi.Input[str]):
|
|
460
|
+
pulumi.set(self, "id", value)
|
|
461
|
+
|
|
462
|
+
@property
|
|
463
|
+
@pulumi.getter
|
|
464
|
+
def region(self) -> pulumi.Input[str]:
|
|
465
|
+
"""
|
|
466
|
+
Region to which database belong to
|
|
467
|
+
"""
|
|
468
|
+
return pulumi.get(self, "region")
|
|
469
|
+
|
|
470
|
+
@region.setter
|
|
471
|
+
def region(self, value: pulumi.Input[str]):
|
|
472
|
+
pulumi.set(self, "region", value)
|
|
473
|
+
|
|
474
|
+
|
|
475
|
+
if not MYPY:
|
|
476
|
+
class RuleRdsDependArgsDict(TypedDict):
|
|
477
|
+
rule_id: pulumi.Input[int]
|
|
478
|
+
"""
|
|
479
|
+
Rule id of the dependent rule
|
|
480
|
+
"""
|
|
481
|
+
delay_in_sec: NotRequired[pulumi.Input[int]]
|
|
482
|
+
"""
|
|
483
|
+
Number of seconds the rule should wait after warming up the dependent rule
|
|
484
|
+
"""
|
|
485
|
+
elif False:
|
|
486
|
+
RuleRdsDependArgsDict: TypeAlias = Mapping[str, Any]
|
|
487
|
+
|
|
488
|
+
@pulumi.input_type
|
|
489
|
+
class RuleRdsDependArgs:
|
|
490
|
+
def __init__(__self__, *,
|
|
491
|
+
rule_id: pulumi.Input[int],
|
|
492
|
+
delay_in_sec: Optional[pulumi.Input[int]] = None):
|
|
493
|
+
"""
|
|
494
|
+
:param pulumi.Input[int] rule_id: Rule id of the dependent rule
|
|
495
|
+
:param pulumi.Input[int] delay_in_sec: Number of seconds the rule should wait after warming up the dependent rule
|
|
496
|
+
"""
|
|
497
|
+
pulumi.set(__self__, "rule_id", rule_id)
|
|
498
|
+
if delay_in_sec is not None:
|
|
499
|
+
pulumi.set(__self__, "delay_in_sec", delay_in_sec)
|
|
500
|
+
|
|
501
|
+
@property
|
|
502
|
+
@pulumi.getter(name="ruleId")
|
|
503
|
+
def rule_id(self) -> pulumi.Input[int]:
|
|
504
|
+
"""
|
|
505
|
+
Rule id of the dependent rule
|
|
506
|
+
"""
|
|
507
|
+
return pulumi.get(self, "rule_id")
|
|
508
|
+
|
|
509
|
+
@rule_id.setter
|
|
510
|
+
def rule_id(self, value: pulumi.Input[int]):
|
|
511
|
+
pulumi.set(self, "rule_id", value)
|
|
512
|
+
|
|
513
|
+
@property
|
|
514
|
+
@pulumi.getter(name="delayInSec")
|
|
515
|
+
def delay_in_sec(self) -> Optional[pulumi.Input[int]]:
|
|
516
|
+
"""
|
|
517
|
+
Number of seconds the rule should wait after warming up the dependent rule
|
|
518
|
+
"""
|
|
519
|
+
return pulumi.get(self, "delay_in_sec")
|
|
520
|
+
|
|
521
|
+
@delay_in_sec.setter
|
|
522
|
+
def delay_in_sec(self, value: Optional[pulumi.Input[int]]):
|
|
523
|
+
pulumi.set(self, "delay_in_sec", value)
|
|
524
|
+
|
|
525
|
+
|
|
526
|
+
if not MYPY:
|
|
527
|
+
class RuleRdsTcpArgsDict(TypedDict):
|
|
528
|
+
proxy_id: pulumi.Input[str]
|
|
529
|
+
"""
|
|
530
|
+
Id of the Proxy
|
|
531
|
+
"""
|
|
532
|
+
forward_rules: NotRequired[pulumi.Input[Sequence[pulumi.Input['RuleRdsTcpForwardRuleArgsDict']]]]
|
|
533
|
+
"""
|
|
534
|
+
Additional tcp forwarding rules
|
|
535
|
+
"""
|
|
536
|
+
elif False:
|
|
537
|
+
RuleRdsTcpArgsDict: TypeAlias = Mapping[str, Any]
|
|
538
|
+
|
|
539
|
+
@pulumi.input_type
|
|
540
|
+
class RuleRdsTcpArgs:
|
|
541
|
+
def __init__(__self__, *,
|
|
542
|
+
proxy_id: pulumi.Input[str],
|
|
543
|
+
forward_rules: Optional[pulumi.Input[Sequence[pulumi.Input['RuleRdsTcpForwardRuleArgs']]]] = None):
|
|
544
|
+
"""
|
|
545
|
+
:param pulumi.Input[str] proxy_id: Id of the Proxy
|
|
546
|
+
:param pulumi.Input[Sequence[pulumi.Input['RuleRdsTcpForwardRuleArgs']]] forward_rules: Additional tcp forwarding rules
|
|
547
|
+
"""
|
|
548
|
+
pulumi.set(__self__, "proxy_id", proxy_id)
|
|
549
|
+
if forward_rules is not None:
|
|
550
|
+
pulumi.set(__self__, "forward_rules", forward_rules)
|
|
551
|
+
|
|
552
|
+
@property
|
|
553
|
+
@pulumi.getter(name="proxyId")
|
|
554
|
+
def proxy_id(self) -> pulumi.Input[str]:
|
|
555
|
+
"""
|
|
556
|
+
Id of the Proxy
|
|
557
|
+
"""
|
|
558
|
+
return pulumi.get(self, "proxy_id")
|
|
559
|
+
|
|
560
|
+
@proxy_id.setter
|
|
561
|
+
def proxy_id(self, value: pulumi.Input[str]):
|
|
562
|
+
pulumi.set(self, "proxy_id", value)
|
|
563
|
+
|
|
564
|
+
@property
|
|
565
|
+
@pulumi.getter(name="forwardRules")
|
|
566
|
+
def forward_rules(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['RuleRdsTcpForwardRuleArgs']]]]:
|
|
567
|
+
"""
|
|
568
|
+
Additional tcp forwarding rules
|
|
569
|
+
"""
|
|
570
|
+
return pulumi.get(self, "forward_rules")
|
|
571
|
+
|
|
572
|
+
@forward_rules.setter
|
|
573
|
+
def forward_rules(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['RuleRdsTcpForwardRuleArgs']]]]):
|
|
574
|
+
pulumi.set(self, "forward_rules", value)
|
|
575
|
+
|
|
576
|
+
|
|
577
|
+
if not MYPY:
|
|
578
|
+
class RuleRdsTcpForwardRuleArgsDict(TypedDict):
|
|
579
|
+
port: pulumi.Input[int]
|
|
580
|
+
"""
|
|
581
|
+
Port to listen on the vm
|
|
582
|
+
"""
|
|
583
|
+
connect_on: NotRequired[pulumi.Input[int]]
|
|
584
|
+
"""
|
|
585
|
+
Port to listen on the proxy
|
|
586
|
+
"""
|
|
587
|
+
elif False:
|
|
588
|
+
RuleRdsTcpForwardRuleArgsDict: TypeAlias = Mapping[str, Any]
|
|
589
|
+
|
|
590
|
+
@pulumi.input_type
|
|
591
|
+
class RuleRdsTcpForwardRuleArgs:
|
|
592
|
+
def __init__(__self__, *,
|
|
593
|
+
port: pulumi.Input[int],
|
|
594
|
+
connect_on: Optional[pulumi.Input[int]] = None):
|
|
595
|
+
"""
|
|
596
|
+
:param pulumi.Input[int] port: Port to listen on the vm
|
|
597
|
+
:param pulumi.Input[int] connect_on: Port to listen on the proxy
|
|
598
|
+
"""
|
|
599
|
+
pulumi.set(__self__, "port", port)
|
|
600
|
+
if connect_on is not None:
|
|
601
|
+
pulumi.set(__self__, "connect_on", connect_on)
|
|
602
|
+
|
|
603
|
+
@property
|
|
604
|
+
@pulumi.getter
|
|
605
|
+
def port(self) -> pulumi.Input[int]:
|
|
606
|
+
"""
|
|
607
|
+
Port to listen on the vm
|
|
608
|
+
"""
|
|
609
|
+
return pulumi.get(self, "port")
|
|
610
|
+
|
|
611
|
+
@port.setter
|
|
612
|
+
def port(self, value: pulumi.Input[int]):
|
|
613
|
+
pulumi.set(self, "port", value)
|
|
614
|
+
|
|
615
|
+
@property
|
|
616
|
+
@pulumi.getter(name="connectOn")
|
|
617
|
+
def connect_on(self) -> Optional[pulumi.Input[int]]:
|
|
618
|
+
"""
|
|
619
|
+
Port to listen on the proxy
|
|
620
|
+
"""
|
|
621
|
+
return pulumi.get(self, "connect_on")
|
|
622
|
+
|
|
623
|
+
@connect_on.setter
|
|
624
|
+
def connect_on(self, value: Optional[pulumi.Input[int]]):
|
|
625
|
+
pulumi.set(self, "connect_on", value)
|
|
626
|
+
|
|
627
|
+
|
|
628
|
+
if not MYPY:
|
|
629
|
+
class RuleVmDependArgsDict(TypedDict):
|
|
630
|
+
rule_id: pulumi.Input[int]
|
|
631
|
+
"""
|
|
632
|
+
Rule id of the dependent rule
|
|
633
|
+
"""
|
|
634
|
+
delay_in_sec: NotRequired[pulumi.Input[int]]
|
|
635
|
+
"""
|
|
636
|
+
Number of seconds the rule should wait after warming up the dependent rule
|
|
637
|
+
"""
|
|
638
|
+
elif False:
|
|
639
|
+
RuleVmDependArgsDict: TypeAlias = Mapping[str, Any]
|
|
640
|
+
|
|
641
|
+
@pulumi.input_type
|
|
642
|
+
class RuleVmDependArgs:
|
|
643
|
+
def __init__(__self__, *,
|
|
644
|
+
rule_id: pulumi.Input[int],
|
|
645
|
+
delay_in_sec: Optional[pulumi.Input[int]] = None):
|
|
646
|
+
"""
|
|
647
|
+
:param pulumi.Input[int] rule_id: Rule id of the dependent rule
|
|
648
|
+
:param pulumi.Input[int] delay_in_sec: Number of seconds the rule should wait after warming up the dependent rule
|
|
649
|
+
"""
|
|
650
|
+
pulumi.set(__self__, "rule_id", rule_id)
|
|
651
|
+
if delay_in_sec is not None:
|
|
652
|
+
pulumi.set(__self__, "delay_in_sec", delay_in_sec)
|
|
653
|
+
|
|
654
|
+
@property
|
|
655
|
+
@pulumi.getter(name="ruleId")
|
|
656
|
+
def rule_id(self) -> pulumi.Input[int]:
|
|
657
|
+
"""
|
|
658
|
+
Rule id of the dependent rule
|
|
659
|
+
"""
|
|
660
|
+
return pulumi.get(self, "rule_id")
|
|
661
|
+
|
|
662
|
+
@rule_id.setter
|
|
663
|
+
def rule_id(self, value: pulumi.Input[int]):
|
|
664
|
+
pulumi.set(self, "rule_id", value)
|
|
665
|
+
|
|
666
|
+
@property
|
|
667
|
+
@pulumi.getter(name="delayInSec")
|
|
668
|
+
def delay_in_sec(self) -> Optional[pulumi.Input[int]]:
|
|
669
|
+
"""
|
|
670
|
+
Number of seconds the rule should wait after warming up the dependent rule
|
|
671
|
+
"""
|
|
672
|
+
return pulumi.get(self, "delay_in_sec")
|
|
673
|
+
|
|
674
|
+
@delay_in_sec.setter
|
|
675
|
+
def delay_in_sec(self, value: Optional[pulumi.Input[int]]):
|
|
676
|
+
pulumi.set(self, "delay_in_sec", value)
|
|
677
|
+
|
|
678
|
+
|
|
679
|
+
if not MYPY:
|
|
680
|
+
class RuleVmFilterArgsDict(TypedDict):
|
|
681
|
+
vm_ids: pulumi.Input[Sequence[pulumi.Input[str]]]
|
|
682
|
+
"""
|
|
683
|
+
Ids of instances that needs to be managed using the AutoStopping rules
|
|
684
|
+
"""
|
|
685
|
+
regions: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
686
|
+
"""
|
|
687
|
+
Regions of instances that needs to be managed using the AutoStopping rules
|
|
688
|
+
"""
|
|
689
|
+
tags: NotRequired[pulumi.Input[Sequence[pulumi.Input['RuleVmFilterTagArgsDict']]]]
|
|
690
|
+
"""
|
|
691
|
+
Tags of instances that needs to be managed using the AutoStopping rules
|
|
692
|
+
"""
|
|
693
|
+
zones: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
694
|
+
"""
|
|
695
|
+
Zones of instances that needs to be managed using the AutoStopping rules
|
|
696
|
+
"""
|
|
697
|
+
elif False:
|
|
698
|
+
RuleVmFilterArgsDict: TypeAlias = Mapping[str, Any]
|
|
699
|
+
|
|
700
|
+
@pulumi.input_type
|
|
701
|
+
class RuleVmFilterArgs:
|
|
702
|
+
def __init__(__self__, *,
|
|
703
|
+
vm_ids: pulumi.Input[Sequence[pulumi.Input[str]]],
|
|
704
|
+
regions: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
705
|
+
tags: Optional[pulumi.Input[Sequence[pulumi.Input['RuleVmFilterTagArgs']]]] = None,
|
|
706
|
+
zones: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
|
|
707
|
+
"""
|
|
708
|
+
:param pulumi.Input[Sequence[pulumi.Input[str]]] vm_ids: Ids of instances that needs to be managed using the AutoStopping rules
|
|
709
|
+
:param pulumi.Input[Sequence[pulumi.Input[str]]] regions: Regions of instances that needs to be managed using the AutoStopping rules
|
|
710
|
+
:param pulumi.Input[Sequence[pulumi.Input['RuleVmFilterTagArgs']]] tags: Tags of instances that needs to be managed using the AutoStopping rules
|
|
711
|
+
:param pulumi.Input[Sequence[pulumi.Input[str]]] zones: Zones of instances that needs to be managed using the AutoStopping rules
|
|
712
|
+
"""
|
|
713
|
+
pulumi.set(__self__, "vm_ids", vm_ids)
|
|
714
|
+
if regions is not None:
|
|
715
|
+
pulumi.set(__self__, "regions", regions)
|
|
716
|
+
if tags is not None:
|
|
717
|
+
pulumi.set(__self__, "tags", tags)
|
|
718
|
+
if zones is not None:
|
|
719
|
+
pulumi.set(__self__, "zones", zones)
|
|
720
|
+
|
|
721
|
+
@property
|
|
722
|
+
@pulumi.getter(name="vmIds")
|
|
723
|
+
def vm_ids(self) -> pulumi.Input[Sequence[pulumi.Input[str]]]:
|
|
724
|
+
"""
|
|
725
|
+
Ids of instances that needs to be managed using the AutoStopping rules
|
|
726
|
+
"""
|
|
727
|
+
return pulumi.get(self, "vm_ids")
|
|
728
|
+
|
|
729
|
+
@vm_ids.setter
|
|
730
|
+
def vm_ids(self, value: pulumi.Input[Sequence[pulumi.Input[str]]]):
|
|
731
|
+
pulumi.set(self, "vm_ids", value)
|
|
732
|
+
|
|
733
|
+
@property
|
|
734
|
+
@pulumi.getter
|
|
735
|
+
def regions(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
736
|
+
"""
|
|
737
|
+
Regions of instances that needs to be managed using the AutoStopping rules
|
|
738
|
+
"""
|
|
739
|
+
return pulumi.get(self, "regions")
|
|
740
|
+
|
|
741
|
+
@regions.setter
|
|
742
|
+
def regions(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
743
|
+
pulumi.set(self, "regions", value)
|
|
744
|
+
|
|
745
|
+
@property
|
|
746
|
+
@pulumi.getter
|
|
747
|
+
def tags(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['RuleVmFilterTagArgs']]]]:
|
|
748
|
+
"""
|
|
749
|
+
Tags of instances that needs to be managed using the AutoStopping rules
|
|
750
|
+
"""
|
|
751
|
+
return pulumi.get(self, "tags")
|
|
752
|
+
|
|
753
|
+
@tags.setter
|
|
754
|
+
def tags(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['RuleVmFilterTagArgs']]]]):
|
|
755
|
+
pulumi.set(self, "tags", value)
|
|
756
|
+
|
|
757
|
+
@property
|
|
758
|
+
@pulumi.getter
|
|
759
|
+
def zones(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
760
|
+
"""
|
|
761
|
+
Zones of instances that needs to be managed using the AutoStopping rules
|
|
762
|
+
"""
|
|
763
|
+
return pulumi.get(self, "zones")
|
|
764
|
+
|
|
765
|
+
@zones.setter
|
|
766
|
+
def zones(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
767
|
+
pulumi.set(self, "zones", value)
|
|
768
|
+
|
|
769
|
+
|
|
770
|
+
if not MYPY:
|
|
771
|
+
class RuleVmFilterTagArgsDict(TypedDict):
|
|
772
|
+
key: pulumi.Input[str]
|
|
773
|
+
value: pulumi.Input[str]
|
|
774
|
+
elif False:
|
|
775
|
+
RuleVmFilterTagArgsDict: TypeAlias = Mapping[str, Any]
|
|
776
|
+
|
|
777
|
+
@pulumi.input_type
|
|
778
|
+
class RuleVmFilterTagArgs:
|
|
779
|
+
def __init__(__self__, *,
|
|
780
|
+
key: pulumi.Input[str],
|
|
781
|
+
value: pulumi.Input[str]):
|
|
782
|
+
pulumi.set(__self__, "key", key)
|
|
783
|
+
pulumi.set(__self__, "value", value)
|
|
784
|
+
|
|
785
|
+
@property
|
|
786
|
+
@pulumi.getter
|
|
787
|
+
def key(self) -> pulumi.Input[str]:
|
|
788
|
+
return pulumi.get(self, "key")
|
|
789
|
+
|
|
790
|
+
@key.setter
|
|
791
|
+
def key(self, value: pulumi.Input[str]):
|
|
792
|
+
pulumi.set(self, "key", value)
|
|
793
|
+
|
|
794
|
+
@property
|
|
795
|
+
@pulumi.getter
|
|
796
|
+
def value(self) -> pulumi.Input[str]:
|
|
797
|
+
return pulumi.get(self, "value")
|
|
798
|
+
|
|
799
|
+
@value.setter
|
|
800
|
+
def value(self, value: pulumi.Input[str]):
|
|
801
|
+
pulumi.set(self, "value", value)
|
|
802
|
+
|
|
803
|
+
|
|
804
|
+
if not MYPY:
|
|
805
|
+
class RuleVmHttpArgsDict(TypedDict):
|
|
806
|
+
proxy_id: pulumi.Input[str]
|
|
807
|
+
"""
|
|
808
|
+
Id of the proxy
|
|
809
|
+
"""
|
|
810
|
+
healths: NotRequired[pulumi.Input[Sequence[pulumi.Input['RuleVmHttpHealthArgsDict']]]]
|
|
811
|
+
"""
|
|
812
|
+
Health Check Details
|
|
813
|
+
"""
|
|
814
|
+
routings: NotRequired[pulumi.Input[Sequence[pulumi.Input['RuleVmHttpRoutingArgsDict']]]]
|
|
815
|
+
"""
|
|
816
|
+
Routing configuration used to access the instances
|
|
817
|
+
"""
|
|
818
|
+
elif False:
|
|
819
|
+
RuleVmHttpArgsDict: TypeAlias = Mapping[str, Any]
|
|
820
|
+
|
|
821
|
+
@pulumi.input_type
|
|
822
|
+
class RuleVmHttpArgs:
|
|
823
|
+
def __init__(__self__, *,
|
|
824
|
+
proxy_id: pulumi.Input[str],
|
|
825
|
+
healths: Optional[pulumi.Input[Sequence[pulumi.Input['RuleVmHttpHealthArgs']]]] = None,
|
|
826
|
+
routings: Optional[pulumi.Input[Sequence[pulumi.Input['RuleVmHttpRoutingArgs']]]] = None):
|
|
827
|
+
"""
|
|
828
|
+
:param pulumi.Input[str] proxy_id: Id of the proxy
|
|
829
|
+
:param pulumi.Input[Sequence[pulumi.Input['RuleVmHttpHealthArgs']]] healths: Health Check Details
|
|
830
|
+
:param pulumi.Input[Sequence[pulumi.Input['RuleVmHttpRoutingArgs']]] routings: Routing configuration used to access the instances
|
|
831
|
+
"""
|
|
832
|
+
pulumi.set(__self__, "proxy_id", proxy_id)
|
|
833
|
+
if healths is not None:
|
|
834
|
+
pulumi.set(__self__, "healths", healths)
|
|
835
|
+
if routings is not None:
|
|
836
|
+
pulumi.set(__self__, "routings", routings)
|
|
837
|
+
|
|
838
|
+
@property
|
|
839
|
+
@pulumi.getter(name="proxyId")
|
|
840
|
+
def proxy_id(self) -> pulumi.Input[str]:
|
|
841
|
+
"""
|
|
842
|
+
Id of the proxy
|
|
843
|
+
"""
|
|
844
|
+
return pulumi.get(self, "proxy_id")
|
|
845
|
+
|
|
846
|
+
@proxy_id.setter
|
|
847
|
+
def proxy_id(self, value: pulumi.Input[str]):
|
|
848
|
+
pulumi.set(self, "proxy_id", value)
|
|
849
|
+
|
|
850
|
+
@property
|
|
851
|
+
@pulumi.getter
|
|
852
|
+
def healths(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['RuleVmHttpHealthArgs']]]]:
|
|
853
|
+
"""
|
|
854
|
+
Health Check Details
|
|
855
|
+
"""
|
|
856
|
+
return pulumi.get(self, "healths")
|
|
857
|
+
|
|
858
|
+
@healths.setter
|
|
859
|
+
def healths(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['RuleVmHttpHealthArgs']]]]):
|
|
860
|
+
pulumi.set(self, "healths", value)
|
|
861
|
+
|
|
862
|
+
@property
|
|
863
|
+
@pulumi.getter
|
|
864
|
+
def routings(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['RuleVmHttpRoutingArgs']]]]:
|
|
865
|
+
"""
|
|
866
|
+
Routing configuration used to access the instances
|
|
867
|
+
"""
|
|
868
|
+
return pulumi.get(self, "routings")
|
|
869
|
+
|
|
870
|
+
@routings.setter
|
|
871
|
+
def routings(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['RuleVmHttpRoutingArgs']]]]):
|
|
872
|
+
pulumi.set(self, "routings", value)
|
|
873
|
+
|
|
874
|
+
|
|
875
|
+
if not MYPY:
|
|
876
|
+
class RuleVmHttpHealthArgsDict(TypedDict):
|
|
877
|
+
port: pulumi.Input[int]
|
|
878
|
+
"""
|
|
879
|
+
Health check port on the VM
|
|
880
|
+
"""
|
|
881
|
+
protocol: pulumi.Input[str]
|
|
882
|
+
"""
|
|
883
|
+
Protocol can be http or https
|
|
884
|
+
"""
|
|
885
|
+
path: NotRequired[pulumi.Input[str]]
|
|
886
|
+
"""
|
|
887
|
+
API path to use for health check
|
|
888
|
+
"""
|
|
889
|
+
status_code_from: NotRequired[pulumi.Input[int]]
|
|
890
|
+
"""
|
|
891
|
+
Lower limit for acceptable status code
|
|
892
|
+
"""
|
|
893
|
+
status_code_to: NotRequired[pulumi.Input[int]]
|
|
894
|
+
"""
|
|
895
|
+
Upper limit for acceptable status code
|
|
896
|
+
"""
|
|
897
|
+
timeout: NotRequired[pulumi.Input[int]]
|
|
898
|
+
"""
|
|
899
|
+
Health check timeout
|
|
900
|
+
"""
|
|
901
|
+
elif False:
|
|
902
|
+
RuleVmHttpHealthArgsDict: TypeAlias = Mapping[str, Any]
|
|
903
|
+
|
|
904
|
+
@pulumi.input_type
|
|
905
|
+
class RuleVmHttpHealthArgs:
|
|
906
|
+
def __init__(__self__, *,
|
|
907
|
+
port: pulumi.Input[int],
|
|
908
|
+
protocol: pulumi.Input[str],
|
|
909
|
+
path: Optional[pulumi.Input[str]] = None,
|
|
910
|
+
status_code_from: Optional[pulumi.Input[int]] = None,
|
|
911
|
+
status_code_to: Optional[pulumi.Input[int]] = None,
|
|
912
|
+
timeout: Optional[pulumi.Input[int]] = None):
|
|
913
|
+
"""
|
|
914
|
+
:param pulumi.Input[int] port: Health check port on the VM
|
|
915
|
+
:param pulumi.Input[str] protocol: Protocol can be http or https
|
|
916
|
+
:param pulumi.Input[str] path: API path to use for health check
|
|
917
|
+
:param pulumi.Input[int] status_code_from: Lower limit for acceptable status code
|
|
918
|
+
:param pulumi.Input[int] status_code_to: Upper limit for acceptable status code
|
|
919
|
+
:param pulumi.Input[int] timeout: Health check timeout
|
|
920
|
+
"""
|
|
921
|
+
pulumi.set(__self__, "port", port)
|
|
922
|
+
pulumi.set(__self__, "protocol", protocol)
|
|
923
|
+
if path is not None:
|
|
924
|
+
pulumi.set(__self__, "path", path)
|
|
925
|
+
if status_code_from is not None:
|
|
926
|
+
pulumi.set(__self__, "status_code_from", status_code_from)
|
|
927
|
+
if status_code_to is not None:
|
|
928
|
+
pulumi.set(__self__, "status_code_to", status_code_to)
|
|
929
|
+
if timeout is not None:
|
|
930
|
+
pulumi.set(__self__, "timeout", timeout)
|
|
931
|
+
|
|
932
|
+
@property
|
|
933
|
+
@pulumi.getter
|
|
934
|
+
def port(self) -> pulumi.Input[int]:
|
|
935
|
+
"""
|
|
936
|
+
Health check port on the VM
|
|
937
|
+
"""
|
|
938
|
+
return pulumi.get(self, "port")
|
|
939
|
+
|
|
940
|
+
@port.setter
|
|
941
|
+
def port(self, value: pulumi.Input[int]):
|
|
942
|
+
pulumi.set(self, "port", value)
|
|
943
|
+
|
|
944
|
+
@property
|
|
945
|
+
@pulumi.getter
|
|
946
|
+
def protocol(self) -> pulumi.Input[str]:
|
|
947
|
+
"""
|
|
948
|
+
Protocol can be http or https
|
|
949
|
+
"""
|
|
950
|
+
return pulumi.get(self, "protocol")
|
|
951
|
+
|
|
952
|
+
@protocol.setter
|
|
953
|
+
def protocol(self, value: pulumi.Input[str]):
|
|
954
|
+
pulumi.set(self, "protocol", value)
|
|
955
|
+
|
|
956
|
+
@property
|
|
957
|
+
@pulumi.getter
|
|
958
|
+
def path(self) -> Optional[pulumi.Input[str]]:
|
|
959
|
+
"""
|
|
960
|
+
API path to use for health check
|
|
961
|
+
"""
|
|
962
|
+
return pulumi.get(self, "path")
|
|
963
|
+
|
|
964
|
+
@path.setter
|
|
965
|
+
def path(self, value: Optional[pulumi.Input[str]]):
|
|
966
|
+
pulumi.set(self, "path", value)
|
|
967
|
+
|
|
968
|
+
@property
|
|
969
|
+
@pulumi.getter(name="statusCodeFrom")
|
|
970
|
+
def status_code_from(self) -> Optional[pulumi.Input[int]]:
|
|
971
|
+
"""
|
|
972
|
+
Lower limit for acceptable status code
|
|
973
|
+
"""
|
|
974
|
+
return pulumi.get(self, "status_code_from")
|
|
975
|
+
|
|
976
|
+
@status_code_from.setter
|
|
977
|
+
def status_code_from(self, value: Optional[pulumi.Input[int]]):
|
|
978
|
+
pulumi.set(self, "status_code_from", value)
|
|
979
|
+
|
|
980
|
+
@property
|
|
981
|
+
@pulumi.getter(name="statusCodeTo")
|
|
982
|
+
def status_code_to(self) -> Optional[pulumi.Input[int]]:
|
|
983
|
+
"""
|
|
984
|
+
Upper limit for acceptable status code
|
|
985
|
+
"""
|
|
986
|
+
return pulumi.get(self, "status_code_to")
|
|
987
|
+
|
|
988
|
+
@status_code_to.setter
|
|
989
|
+
def status_code_to(self, value: Optional[pulumi.Input[int]]):
|
|
990
|
+
pulumi.set(self, "status_code_to", value)
|
|
991
|
+
|
|
992
|
+
@property
|
|
993
|
+
@pulumi.getter
|
|
994
|
+
def timeout(self) -> Optional[pulumi.Input[int]]:
|
|
995
|
+
"""
|
|
996
|
+
Health check timeout
|
|
997
|
+
"""
|
|
998
|
+
return pulumi.get(self, "timeout")
|
|
999
|
+
|
|
1000
|
+
@timeout.setter
|
|
1001
|
+
def timeout(self, value: Optional[pulumi.Input[int]]):
|
|
1002
|
+
pulumi.set(self, "timeout", value)
|
|
1003
|
+
|
|
1004
|
+
|
|
1005
|
+
if not MYPY:
|
|
1006
|
+
class RuleVmHttpRoutingArgsDict(TypedDict):
|
|
1007
|
+
source_protocol: pulumi.Input[str]
|
|
1008
|
+
"""
|
|
1009
|
+
Source protocol of the proxy can be http or https
|
|
1010
|
+
"""
|
|
1011
|
+
target_protocol: pulumi.Input[str]
|
|
1012
|
+
"""
|
|
1013
|
+
Target protocol of the instance can be http or https
|
|
1014
|
+
"""
|
|
1015
|
+
action: NotRequired[pulumi.Input[str]]
|
|
1016
|
+
"""
|
|
1017
|
+
Organization Identifier for the Entity
|
|
1018
|
+
"""
|
|
1019
|
+
source_port: NotRequired[pulumi.Input[int]]
|
|
1020
|
+
"""
|
|
1021
|
+
Port on the proxy
|
|
1022
|
+
"""
|
|
1023
|
+
target_port: NotRequired[pulumi.Input[int]]
|
|
1024
|
+
"""
|
|
1025
|
+
Port on the VM
|
|
1026
|
+
"""
|
|
1027
|
+
elif False:
|
|
1028
|
+
RuleVmHttpRoutingArgsDict: TypeAlias = Mapping[str, Any]
|
|
1029
|
+
|
|
1030
|
+
@pulumi.input_type
|
|
1031
|
+
class RuleVmHttpRoutingArgs:
|
|
1032
|
+
def __init__(__self__, *,
|
|
1033
|
+
source_protocol: pulumi.Input[str],
|
|
1034
|
+
target_protocol: pulumi.Input[str],
|
|
1035
|
+
action: Optional[pulumi.Input[str]] = None,
|
|
1036
|
+
source_port: Optional[pulumi.Input[int]] = None,
|
|
1037
|
+
target_port: Optional[pulumi.Input[int]] = None):
|
|
1038
|
+
"""
|
|
1039
|
+
:param pulumi.Input[str] source_protocol: Source protocol of the proxy can be http or https
|
|
1040
|
+
:param pulumi.Input[str] target_protocol: Target protocol of the instance can be http or https
|
|
1041
|
+
:param pulumi.Input[str] action: Organization Identifier for the Entity
|
|
1042
|
+
:param pulumi.Input[int] source_port: Port on the proxy
|
|
1043
|
+
:param pulumi.Input[int] target_port: Port on the VM
|
|
1044
|
+
"""
|
|
1045
|
+
pulumi.set(__self__, "source_protocol", source_protocol)
|
|
1046
|
+
pulumi.set(__self__, "target_protocol", target_protocol)
|
|
1047
|
+
if action is not None:
|
|
1048
|
+
pulumi.set(__self__, "action", action)
|
|
1049
|
+
if source_port is not None:
|
|
1050
|
+
pulumi.set(__self__, "source_port", source_port)
|
|
1051
|
+
if target_port is not None:
|
|
1052
|
+
pulumi.set(__self__, "target_port", target_port)
|
|
1053
|
+
|
|
1054
|
+
@property
|
|
1055
|
+
@pulumi.getter(name="sourceProtocol")
|
|
1056
|
+
def source_protocol(self) -> pulumi.Input[str]:
|
|
1057
|
+
"""
|
|
1058
|
+
Source protocol of the proxy can be http or https
|
|
1059
|
+
"""
|
|
1060
|
+
return pulumi.get(self, "source_protocol")
|
|
1061
|
+
|
|
1062
|
+
@source_protocol.setter
|
|
1063
|
+
def source_protocol(self, value: pulumi.Input[str]):
|
|
1064
|
+
pulumi.set(self, "source_protocol", value)
|
|
1065
|
+
|
|
1066
|
+
@property
|
|
1067
|
+
@pulumi.getter(name="targetProtocol")
|
|
1068
|
+
def target_protocol(self) -> pulumi.Input[str]:
|
|
1069
|
+
"""
|
|
1070
|
+
Target protocol of the instance can be http or https
|
|
1071
|
+
"""
|
|
1072
|
+
return pulumi.get(self, "target_protocol")
|
|
1073
|
+
|
|
1074
|
+
@target_protocol.setter
|
|
1075
|
+
def target_protocol(self, value: pulumi.Input[str]):
|
|
1076
|
+
pulumi.set(self, "target_protocol", value)
|
|
1077
|
+
|
|
1078
|
+
@property
|
|
1079
|
+
@pulumi.getter
|
|
1080
|
+
def action(self) -> Optional[pulumi.Input[str]]:
|
|
1081
|
+
"""
|
|
1082
|
+
Organization Identifier for the Entity
|
|
1083
|
+
"""
|
|
1084
|
+
return pulumi.get(self, "action")
|
|
1085
|
+
|
|
1086
|
+
@action.setter
|
|
1087
|
+
def action(self, value: Optional[pulumi.Input[str]]):
|
|
1088
|
+
pulumi.set(self, "action", value)
|
|
1089
|
+
|
|
1090
|
+
@property
|
|
1091
|
+
@pulumi.getter(name="sourcePort")
|
|
1092
|
+
def source_port(self) -> Optional[pulumi.Input[int]]:
|
|
1093
|
+
"""
|
|
1094
|
+
Port on the proxy
|
|
1095
|
+
"""
|
|
1096
|
+
return pulumi.get(self, "source_port")
|
|
1097
|
+
|
|
1098
|
+
@source_port.setter
|
|
1099
|
+
def source_port(self, value: Optional[pulumi.Input[int]]):
|
|
1100
|
+
pulumi.set(self, "source_port", value)
|
|
1101
|
+
|
|
1102
|
+
@property
|
|
1103
|
+
@pulumi.getter(name="targetPort")
|
|
1104
|
+
def target_port(self) -> Optional[pulumi.Input[int]]:
|
|
1105
|
+
"""
|
|
1106
|
+
Port on the VM
|
|
1107
|
+
"""
|
|
1108
|
+
return pulumi.get(self, "target_port")
|
|
1109
|
+
|
|
1110
|
+
@target_port.setter
|
|
1111
|
+
def target_port(self, value: Optional[pulumi.Input[int]]):
|
|
1112
|
+
pulumi.set(self, "target_port", value)
|
|
1113
|
+
|
|
1114
|
+
|
|
1115
|
+
if not MYPY:
|
|
1116
|
+
class RuleVmTcpArgsDict(TypedDict):
|
|
1117
|
+
proxy_id: pulumi.Input[str]
|
|
1118
|
+
"""
|
|
1119
|
+
Id of the Proxy
|
|
1120
|
+
"""
|
|
1121
|
+
forward_rules: NotRequired[pulumi.Input[Sequence[pulumi.Input['RuleVmTcpForwardRuleArgsDict']]]]
|
|
1122
|
+
"""
|
|
1123
|
+
Additional tcp forwarding rules
|
|
1124
|
+
"""
|
|
1125
|
+
rdps: NotRequired[pulumi.Input[Sequence[pulumi.Input['RuleVmTcpRdpArgsDict']]]]
|
|
1126
|
+
"""
|
|
1127
|
+
RDP configuration
|
|
1128
|
+
"""
|
|
1129
|
+
sshes: NotRequired[pulumi.Input[Sequence[pulumi.Input['RuleVmTcpSshArgsDict']]]]
|
|
1130
|
+
"""
|
|
1131
|
+
SSH configuration
|
|
1132
|
+
"""
|
|
1133
|
+
elif False:
|
|
1134
|
+
RuleVmTcpArgsDict: TypeAlias = Mapping[str, Any]
|
|
1135
|
+
|
|
1136
|
+
@pulumi.input_type
|
|
1137
|
+
class RuleVmTcpArgs:
|
|
1138
|
+
def __init__(__self__, *,
|
|
1139
|
+
proxy_id: pulumi.Input[str],
|
|
1140
|
+
forward_rules: Optional[pulumi.Input[Sequence[pulumi.Input['RuleVmTcpForwardRuleArgs']]]] = None,
|
|
1141
|
+
rdps: Optional[pulumi.Input[Sequence[pulumi.Input['RuleVmTcpRdpArgs']]]] = None,
|
|
1142
|
+
sshes: Optional[pulumi.Input[Sequence[pulumi.Input['RuleVmTcpSshArgs']]]] = None):
|
|
1143
|
+
"""
|
|
1144
|
+
:param pulumi.Input[str] proxy_id: Id of the Proxy
|
|
1145
|
+
:param pulumi.Input[Sequence[pulumi.Input['RuleVmTcpForwardRuleArgs']]] forward_rules: Additional tcp forwarding rules
|
|
1146
|
+
:param pulumi.Input[Sequence[pulumi.Input['RuleVmTcpRdpArgs']]] rdps: RDP configuration
|
|
1147
|
+
:param pulumi.Input[Sequence[pulumi.Input['RuleVmTcpSshArgs']]] sshes: SSH configuration
|
|
1148
|
+
"""
|
|
1149
|
+
pulumi.set(__self__, "proxy_id", proxy_id)
|
|
1150
|
+
if forward_rules is not None:
|
|
1151
|
+
pulumi.set(__self__, "forward_rules", forward_rules)
|
|
1152
|
+
if rdps is not None:
|
|
1153
|
+
pulumi.set(__self__, "rdps", rdps)
|
|
1154
|
+
if sshes is not None:
|
|
1155
|
+
pulumi.set(__self__, "sshes", sshes)
|
|
1156
|
+
|
|
1157
|
+
@property
|
|
1158
|
+
@pulumi.getter(name="proxyId")
|
|
1159
|
+
def proxy_id(self) -> pulumi.Input[str]:
|
|
1160
|
+
"""
|
|
1161
|
+
Id of the Proxy
|
|
1162
|
+
"""
|
|
1163
|
+
return pulumi.get(self, "proxy_id")
|
|
1164
|
+
|
|
1165
|
+
@proxy_id.setter
|
|
1166
|
+
def proxy_id(self, value: pulumi.Input[str]):
|
|
1167
|
+
pulumi.set(self, "proxy_id", value)
|
|
1168
|
+
|
|
1169
|
+
@property
|
|
1170
|
+
@pulumi.getter(name="forwardRules")
|
|
1171
|
+
def forward_rules(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['RuleVmTcpForwardRuleArgs']]]]:
|
|
1172
|
+
"""
|
|
1173
|
+
Additional tcp forwarding rules
|
|
1174
|
+
"""
|
|
1175
|
+
return pulumi.get(self, "forward_rules")
|
|
1176
|
+
|
|
1177
|
+
@forward_rules.setter
|
|
1178
|
+
def forward_rules(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['RuleVmTcpForwardRuleArgs']]]]):
|
|
1179
|
+
pulumi.set(self, "forward_rules", value)
|
|
1180
|
+
|
|
1181
|
+
@property
|
|
1182
|
+
@pulumi.getter
|
|
1183
|
+
def rdps(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['RuleVmTcpRdpArgs']]]]:
|
|
1184
|
+
"""
|
|
1185
|
+
RDP configuration
|
|
1186
|
+
"""
|
|
1187
|
+
return pulumi.get(self, "rdps")
|
|
1188
|
+
|
|
1189
|
+
@rdps.setter
|
|
1190
|
+
def rdps(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['RuleVmTcpRdpArgs']]]]):
|
|
1191
|
+
pulumi.set(self, "rdps", value)
|
|
1192
|
+
|
|
1193
|
+
@property
|
|
1194
|
+
@pulumi.getter
|
|
1195
|
+
def sshes(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['RuleVmTcpSshArgs']]]]:
|
|
1196
|
+
"""
|
|
1197
|
+
SSH configuration
|
|
1198
|
+
"""
|
|
1199
|
+
return pulumi.get(self, "sshes")
|
|
1200
|
+
|
|
1201
|
+
@sshes.setter
|
|
1202
|
+
def sshes(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['RuleVmTcpSshArgs']]]]):
|
|
1203
|
+
pulumi.set(self, "sshes", value)
|
|
1204
|
+
|
|
1205
|
+
|
|
1206
|
+
if not MYPY:
|
|
1207
|
+
class RuleVmTcpForwardRuleArgsDict(TypedDict):
|
|
1208
|
+
port: pulumi.Input[int]
|
|
1209
|
+
"""
|
|
1210
|
+
Port to listen on the vm
|
|
1211
|
+
"""
|
|
1212
|
+
connect_on: NotRequired[pulumi.Input[int]]
|
|
1213
|
+
"""
|
|
1214
|
+
Port to listen on the proxy
|
|
1215
|
+
"""
|
|
1216
|
+
elif False:
|
|
1217
|
+
RuleVmTcpForwardRuleArgsDict: TypeAlias = Mapping[str, Any]
|
|
1218
|
+
|
|
1219
|
+
@pulumi.input_type
|
|
1220
|
+
class RuleVmTcpForwardRuleArgs:
|
|
1221
|
+
def __init__(__self__, *,
|
|
1222
|
+
port: pulumi.Input[int],
|
|
1223
|
+
connect_on: Optional[pulumi.Input[int]] = None):
|
|
1224
|
+
"""
|
|
1225
|
+
:param pulumi.Input[int] port: Port to listen on the vm
|
|
1226
|
+
:param pulumi.Input[int] connect_on: Port to listen on the proxy
|
|
1227
|
+
"""
|
|
1228
|
+
pulumi.set(__self__, "port", port)
|
|
1229
|
+
if connect_on is not None:
|
|
1230
|
+
pulumi.set(__self__, "connect_on", connect_on)
|
|
1231
|
+
|
|
1232
|
+
@property
|
|
1233
|
+
@pulumi.getter
|
|
1234
|
+
def port(self) -> pulumi.Input[int]:
|
|
1235
|
+
"""
|
|
1236
|
+
Port to listen on the vm
|
|
1237
|
+
"""
|
|
1238
|
+
return pulumi.get(self, "port")
|
|
1239
|
+
|
|
1240
|
+
@port.setter
|
|
1241
|
+
def port(self, value: pulumi.Input[int]):
|
|
1242
|
+
pulumi.set(self, "port", value)
|
|
1243
|
+
|
|
1244
|
+
@property
|
|
1245
|
+
@pulumi.getter(name="connectOn")
|
|
1246
|
+
def connect_on(self) -> Optional[pulumi.Input[int]]:
|
|
1247
|
+
"""
|
|
1248
|
+
Port to listen on the proxy
|
|
1249
|
+
"""
|
|
1250
|
+
return pulumi.get(self, "connect_on")
|
|
1251
|
+
|
|
1252
|
+
@connect_on.setter
|
|
1253
|
+
def connect_on(self, value: Optional[pulumi.Input[int]]):
|
|
1254
|
+
pulumi.set(self, "connect_on", value)
|
|
1255
|
+
|
|
1256
|
+
|
|
1257
|
+
if not MYPY:
|
|
1258
|
+
class RuleVmTcpRdpArgsDict(TypedDict):
|
|
1259
|
+
connect_on: NotRequired[pulumi.Input[int]]
|
|
1260
|
+
"""
|
|
1261
|
+
Port to listen on the proxy
|
|
1262
|
+
"""
|
|
1263
|
+
port: NotRequired[pulumi.Input[int]]
|
|
1264
|
+
"""
|
|
1265
|
+
Port to listen on the vm
|
|
1266
|
+
"""
|
|
1267
|
+
elif False:
|
|
1268
|
+
RuleVmTcpRdpArgsDict: TypeAlias = Mapping[str, Any]
|
|
1269
|
+
|
|
1270
|
+
@pulumi.input_type
|
|
1271
|
+
class RuleVmTcpRdpArgs:
|
|
1272
|
+
def __init__(__self__, *,
|
|
1273
|
+
connect_on: Optional[pulumi.Input[int]] = None,
|
|
1274
|
+
port: Optional[pulumi.Input[int]] = None):
|
|
1275
|
+
"""
|
|
1276
|
+
:param pulumi.Input[int] connect_on: Port to listen on the proxy
|
|
1277
|
+
:param pulumi.Input[int] port: Port to listen on the vm
|
|
1278
|
+
"""
|
|
1279
|
+
if connect_on is not None:
|
|
1280
|
+
pulumi.set(__self__, "connect_on", connect_on)
|
|
1281
|
+
if port is not None:
|
|
1282
|
+
pulumi.set(__self__, "port", port)
|
|
1283
|
+
|
|
1284
|
+
@property
|
|
1285
|
+
@pulumi.getter(name="connectOn")
|
|
1286
|
+
def connect_on(self) -> Optional[pulumi.Input[int]]:
|
|
1287
|
+
"""
|
|
1288
|
+
Port to listen on the proxy
|
|
1289
|
+
"""
|
|
1290
|
+
return pulumi.get(self, "connect_on")
|
|
1291
|
+
|
|
1292
|
+
@connect_on.setter
|
|
1293
|
+
def connect_on(self, value: Optional[pulumi.Input[int]]):
|
|
1294
|
+
pulumi.set(self, "connect_on", value)
|
|
1295
|
+
|
|
1296
|
+
@property
|
|
1297
|
+
@pulumi.getter
|
|
1298
|
+
def port(self) -> Optional[pulumi.Input[int]]:
|
|
1299
|
+
"""
|
|
1300
|
+
Port to listen on the vm
|
|
1301
|
+
"""
|
|
1302
|
+
return pulumi.get(self, "port")
|
|
1303
|
+
|
|
1304
|
+
@port.setter
|
|
1305
|
+
def port(self, value: Optional[pulumi.Input[int]]):
|
|
1306
|
+
pulumi.set(self, "port", value)
|
|
1307
|
+
|
|
1308
|
+
|
|
1309
|
+
if not MYPY:
|
|
1310
|
+
class RuleVmTcpSshArgsDict(TypedDict):
|
|
1311
|
+
connect_on: NotRequired[pulumi.Input[int]]
|
|
1312
|
+
"""
|
|
1313
|
+
Port to listen on the proxy
|
|
1314
|
+
"""
|
|
1315
|
+
port: NotRequired[pulumi.Input[int]]
|
|
1316
|
+
"""
|
|
1317
|
+
Port to listen on the vm
|
|
1318
|
+
"""
|
|
1319
|
+
elif False:
|
|
1320
|
+
RuleVmTcpSshArgsDict: TypeAlias = Mapping[str, Any]
|
|
1321
|
+
|
|
1322
|
+
@pulumi.input_type
|
|
1323
|
+
class RuleVmTcpSshArgs:
|
|
1324
|
+
def __init__(__self__, *,
|
|
1325
|
+
connect_on: Optional[pulumi.Input[int]] = None,
|
|
1326
|
+
port: Optional[pulumi.Input[int]] = None):
|
|
1327
|
+
"""
|
|
1328
|
+
:param pulumi.Input[int] connect_on: Port to listen on the proxy
|
|
1329
|
+
:param pulumi.Input[int] port: Port to listen on the vm
|
|
1330
|
+
"""
|
|
1331
|
+
if connect_on is not None:
|
|
1332
|
+
pulumi.set(__self__, "connect_on", connect_on)
|
|
1333
|
+
if port is not None:
|
|
1334
|
+
pulumi.set(__self__, "port", port)
|
|
1335
|
+
|
|
1336
|
+
@property
|
|
1337
|
+
@pulumi.getter(name="connectOn")
|
|
1338
|
+
def connect_on(self) -> Optional[pulumi.Input[int]]:
|
|
1339
|
+
"""
|
|
1340
|
+
Port to listen on the proxy
|
|
1341
|
+
"""
|
|
1342
|
+
return pulumi.get(self, "connect_on")
|
|
1343
|
+
|
|
1344
|
+
@connect_on.setter
|
|
1345
|
+
def connect_on(self, value: Optional[pulumi.Input[int]]):
|
|
1346
|
+
pulumi.set(self, "connect_on", value)
|
|
1347
|
+
|
|
1348
|
+
@property
|
|
1349
|
+
@pulumi.getter
|
|
1350
|
+
def port(self) -> Optional[pulumi.Input[int]]:
|
|
1351
|
+
"""
|
|
1352
|
+
Port to listen on the vm
|
|
1353
|
+
"""
|
|
1354
|
+
return pulumi.get(self, "port")
|
|
1355
|
+
|
|
1356
|
+
@port.setter
|
|
1357
|
+
def port(self, value: Optional[pulumi.Input[int]]):
|
|
1358
|
+
pulumi.set(self, "port", value)
|
|
1359
|
+
|
|
1360
|
+
|
|
1361
|
+
if not MYPY:
|
|
1362
|
+
class ScheduleRepeatArgsDict(TypedDict):
|
|
1363
|
+
days: pulumi.Input[Sequence[pulumi.Input[str]]]
|
|
1364
|
+
"""
|
|
1365
|
+
List of days on which schedule need to be active. Valid values are SUN, MON, TUE, WED, THU, FRI and SAT.
|
|
1366
|
+
"""
|
|
1367
|
+
end_time: NotRequired[pulumi.Input[str]]
|
|
1368
|
+
"""
|
|
1369
|
+
Ending time of schedule action on the day. Defaults to 24:00Hrs unless specified. Accepted format is HH:MM. Eg : 20:00 for 8pm
|
|
1370
|
+
"""
|
|
1371
|
+
start_time: NotRequired[pulumi.Input[str]]
|
|
1372
|
+
"""
|
|
1373
|
+
Starting time of schedule action on the day. Defaults to 00:00Hrs unless specified. Accepted format is HH:MM. Eg : 13:15 for 01:15pm
|
|
1374
|
+
"""
|
|
1375
|
+
elif False:
|
|
1376
|
+
ScheduleRepeatArgsDict: TypeAlias = Mapping[str, Any]
|
|
1377
|
+
|
|
1378
|
+
@pulumi.input_type
|
|
1379
|
+
class ScheduleRepeatArgs:
|
|
1380
|
+
def __init__(__self__, *,
|
|
1381
|
+
days: pulumi.Input[Sequence[pulumi.Input[str]]],
|
|
1382
|
+
end_time: Optional[pulumi.Input[str]] = None,
|
|
1383
|
+
start_time: Optional[pulumi.Input[str]] = None):
|
|
1384
|
+
"""
|
|
1385
|
+
:param pulumi.Input[Sequence[pulumi.Input[str]]] days: List of days on which schedule need to be active. Valid values are SUN, MON, TUE, WED, THU, FRI and SAT.
|
|
1386
|
+
:param pulumi.Input[str] end_time: Ending time of schedule action on the day. Defaults to 24:00Hrs unless specified. Accepted format is HH:MM. Eg : 20:00 for 8pm
|
|
1387
|
+
:param pulumi.Input[str] start_time: Starting time of schedule action on the day. Defaults to 00:00Hrs unless specified. Accepted format is HH:MM. Eg : 13:15 for 01:15pm
|
|
1388
|
+
"""
|
|
1389
|
+
pulumi.set(__self__, "days", days)
|
|
1390
|
+
if end_time is not None:
|
|
1391
|
+
pulumi.set(__self__, "end_time", end_time)
|
|
1392
|
+
if start_time is not None:
|
|
1393
|
+
pulumi.set(__self__, "start_time", start_time)
|
|
1394
|
+
|
|
1395
|
+
@property
|
|
1396
|
+
@pulumi.getter
|
|
1397
|
+
def days(self) -> pulumi.Input[Sequence[pulumi.Input[str]]]:
|
|
1398
|
+
"""
|
|
1399
|
+
List of days on which schedule need to be active. Valid values are SUN, MON, TUE, WED, THU, FRI and SAT.
|
|
1400
|
+
"""
|
|
1401
|
+
return pulumi.get(self, "days")
|
|
1402
|
+
|
|
1403
|
+
@days.setter
|
|
1404
|
+
def days(self, value: pulumi.Input[Sequence[pulumi.Input[str]]]):
|
|
1405
|
+
pulumi.set(self, "days", value)
|
|
1406
|
+
|
|
1407
|
+
@property
|
|
1408
|
+
@pulumi.getter(name="endTime")
|
|
1409
|
+
def end_time(self) -> Optional[pulumi.Input[str]]:
|
|
1410
|
+
"""
|
|
1411
|
+
Ending time of schedule action on the day. Defaults to 24:00Hrs unless specified. Accepted format is HH:MM. Eg : 20:00 for 8pm
|
|
1412
|
+
"""
|
|
1413
|
+
return pulumi.get(self, "end_time")
|
|
1414
|
+
|
|
1415
|
+
@end_time.setter
|
|
1416
|
+
def end_time(self, value: Optional[pulumi.Input[str]]):
|
|
1417
|
+
pulumi.set(self, "end_time", value)
|
|
1418
|
+
|
|
1419
|
+
@property
|
|
1420
|
+
@pulumi.getter(name="startTime")
|
|
1421
|
+
def start_time(self) -> Optional[pulumi.Input[str]]:
|
|
1422
|
+
"""
|
|
1423
|
+
Starting time of schedule action on the day. Defaults to 00:00Hrs unless specified. Accepted format is HH:MM. Eg : 13:15 for 01:15pm
|
|
1424
|
+
"""
|
|
1425
|
+
return pulumi.get(self, "start_time")
|
|
1426
|
+
|
|
1427
|
+
@start_time.setter
|
|
1428
|
+
def start_time(self, value: Optional[pulumi.Input[str]]):
|
|
1429
|
+
pulumi.set(self, "start_time", value)
|
|
1430
|
+
|
|
1431
|
+
|
|
1432
|
+
if not MYPY:
|
|
1433
|
+
class GetAwsProxyCertificatesArgsDict(TypedDict):
|
|
1434
|
+
cert_secret_id: str
|
|
1435
|
+
"""
|
|
1436
|
+
Certificate secret ID
|
|
1437
|
+
"""
|
|
1438
|
+
key_secret_id: str
|
|
1439
|
+
"""
|
|
1440
|
+
Private key secret ID
|
|
1441
|
+
"""
|
|
1442
|
+
elif False:
|
|
1443
|
+
GetAwsProxyCertificatesArgsDict: TypeAlias = Mapping[str, Any]
|
|
1444
|
+
|
|
1445
|
+
@pulumi.input_type
|
|
1446
|
+
class GetAwsProxyCertificatesArgs:
|
|
1447
|
+
def __init__(__self__, *,
|
|
1448
|
+
cert_secret_id: str,
|
|
1449
|
+
key_secret_id: str):
|
|
1450
|
+
"""
|
|
1451
|
+
:param str cert_secret_id: Certificate secret ID
|
|
1452
|
+
:param str key_secret_id: Private key secret ID
|
|
1453
|
+
"""
|
|
1454
|
+
pulumi.set(__self__, "cert_secret_id", cert_secret_id)
|
|
1455
|
+
pulumi.set(__self__, "key_secret_id", key_secret_id)
|
|
1456
|
+
|
|
1457
|
+
@property
|
|
1458
|
+
@pulumi.getter(name="certSecretId")
|
|
1459
|
+
def cert_secret_id(self) -> str:
|
|
1460
|
+
"""
|
|
1461
|
+
Certificate secret ID
|
|
1462
|
+
"""
|
|
1463
|
+
return pulumi.get(self, "cert_secret_id")
|
|
1464
|
+
|
|
1465
|
+
@cert_secret_id.setter
|
|
1466
|
+
def cert_secret_id(self, value: str):
|
|
1467
|
+
pulumi.set(self, "cert_secret_id", value)
|
|
1468
|
+
|
|
1469
|
+
@property
|
|
1470
|
+
@pulumi.getter(name="keySecretId")
|
|
1471
|
+
def key_secret_id(self) -> str:
|
|
1472
|
+
"""
|
|
1473
|
+
Private key secret ID
|
|
1474
|
+
"""
|
|
1475
|
+
return pulumi.get(self, "key_secret_id")
|
|
1476
|
+
|
|
1477
|
+
@key_secret_id.setter
|
|
1478
|
+
def key_secret_id(self, value: str):
|
|
1479
|
+
pulumi.set(self, "key_secret_id", value)
|
|
1480
|
+
|
|
1481
|
+
|
|
1482
|
+
if not MYPY:
|
|
1483
|
+
class GetAzureProxyCertificatesArgsDict(TypedDict):
|
|
1484
|
+
cert_secret_id: str
|
|
1485
|
+
"""
|
|
1486
|
+
ID of certificate secret uploaded to vault
|
|
1487
|
+
"""
|
|
1488
|
+
key_secret_id: str
|
|
1489
|
+
"""
|
|
1490
|
+
ID of certificate key uploaded to vault
|
|
1491
|
+
"""
|
|
1492
|
+
elif False:
|
|
1493
|
+
GetAzureProxyCertificatesArgsDict: TypeAlias = Mapping[str, Any]
|
|
1494
|
+
|
|
1495
|
+
@pulumi.input_type
|
|
1496
|
+
class GetAzureProxyCertificatesArgs:
|
|
1497
|
+
def __init__(__self__, *,
|
|
1498
|
+
cert_secret_id: str,
|
|
1499
|
+
key_secret_id: str):
|
|
1500
|
+
"""
|
|
1501
|
+
:param str cert_secret_id: ID of certificate secret uploaded to vault
|
|
1502
|
+
:param str key_secret_id: ID of certificate key uploaded to vault
|
|
1503
|
+
"""
|
|
1504
|
+
pulumi.set(__self__, "cert_secret_id", cert_secret_id)
|
|
1505
|
+
pulumi.set(__self__, "key_secret_id", key_secret_id)
|
|
1506
|
+
|
|
1507
|
+
@property
|
|
1508
|
+
@pulumi.getter(name="certSecretId")
|
|
1509
|
+
def cert_secret_id(self) -> str:
|
|
1510
|
+
"""
|
|
1511
|
+
ID of certificate secret uploaded to vault
|
|
1512
|
+
"""
|
|
1513
|
+
return pulumi.get(self, "cert_secret_id")
|
|
1514
|
+
|
|
1515
|
+
@cert_secret_id.setter
|
|
1516
|
+
def cert_secret_id(self, value: str):
|
|
1517
|
+
pulumi.set(self, "cert_secret_id", value)
|
|
1518
|
+
|
|
1519
|
+
@property
|
|
1520
|
+
@pulumi.getter(name="keySecretId")
|
|
1521
|
+
def key_secret_id(self) -> str:
|
|
1522
|
+
"""
|
|
1523
|
+
ID of certificate key uploaded to vault
|
|
1524
|
+
"""
|
|
1525
|
+
return pulumi.get(self, "key_secret_id")
|
|
1526
|
+
|
|
1527
|
+
@key_secret_id.setter
|
|
1528
|
+
def key_secret_id(self, value: str):
|
|
1529
|
+
pulumi.set(self, "key_secret_id", value)
|
|
1530
|
+
|
|
1531
|
+
|
|
1532
|
+
if not MYPY:
|
|
1533
|
+
class GetGcpProxyCertificatesArgsDict(TypedDict):
|
|
1534
|
+
cert_secret_id: str
|
|
1535
|
+
"""
|
|
1536
|
+
Certificate secret ID
|
|
1537
|
+
"""
|
|
1538
|
+
key_secret_id: str
|
|
1539
|
+
"""
|
|
1540
|
+
Private key secret ID
|
|
1541
|
+
"""
|
|
1542
|
+
elif False:
|
|
1543
|
+
GetGcpProxyCertificatesArgsDict: TypeAlias = Mapping[str, Any]
|
|
1544
|
+
|
|
1545
|
+
@pulumi.input_type
|
|
1546
|
+
class GetGcpProxyCertificatesArgs:
|
|
1547
|
+
def __init__(__self__, *,
|
|
1548
|
+
cert_secret_id: str,
|
|
1549
|
+
key_secret_id: str):
|
|
1550
|
+
"""
|
|
1551
|
+
:param str cert_secret_id: Certificate secret ID
|
|
1552
|
+
:param str key_secret_id: Private key secret ID
|
|
1553
|
+
"""
|
|
1554
|
+
pulumi.set(__self__, "cert_secret_id", cert_secret_id)
|
|
1555
|
+
pulumi.set(__self__, "key_secret_id", key_secret_id)
|
|
1556
|
+
|
|
1557
|
+
@property
|
|
1558
|
+
@pulumi.getter(name="certSecretId")
|
|
1559
|
+
def cert_secret_id(self) -> str:
|
|
1560
|
+
"""
|
|
1561
|
+
Certificate secret ID
|
|
1562
|
+
"""
|
|
1563
|
+
return pulumi.get(self, "cert_secret_id")
|
|
1564
|
+
|
|
1565
|
+
@cert_secret_id.setter
|
|
1566
|
+
def cert_secret_id(self, value: str):
|
|
1567
|
+
pulumi.set(self, "cert_secret_id", value)
|
|
1568
|
+
|
|
1569
|
+
@property
|
|
1570
|
+
@pulumi.getter(name="keySecretId")
|
|
1571
|
+
def key_secret_id(self) -> str:
|
|
1572
|
+
"""
|
|
1573
|
+
Private key secret ID
|
|
1574
|
+
"""
|
|
1575
|
+
return pulumi.get(self, "key_secret_id")
|
|
1576
|
+
|
|
1577
|
+
@key_secret_id.setter
|
|
1578
|
+
def key_secret_id(self, value: str):
|
|
1579
|
+
pulumi.set(self, "key_secret_id", value)
|
|
1580
|
+
|
|
1581
|
+
|
|
1582
|
+
if not MYPY:
|
|
1583
|
+
class GetRuleEcsContainerArgsDict(TypedDict):
|
|
1584
|
+
cluster: str
|
|
1585
|
+
"""
|
|
1586
|
+
Name of cluster in which service belong to
|
|
1587
|
+
"""
|
|
1588
|
+
region: str
|
|
1589
|
+
"""
|
|
1590
|
+
Region of cluster
|
|
1591
|
+
"""
|
|
1592
|
+
service: str
|
|
1593
|
+
"""
|
|
1594
|
+
Name of service to be onboarded
|
|
1595
|
+
"""
|
|
1596
|
+
task_count: NotRequired[int]
|
|
1597
|
+
"""
|
|
1598
|
+
Desired number of tasks on warming up a rule
|
|
1599
|
+
"""
|
|
1600
|
+
elif False:
|
|
1601
|
+
GetRuleEcsContainerArgsDict: TypeAlias = Mapping[str, Any]
|
|
1602
|
+
|
|
1603
|
+
@pulumi.input_type
|
|
1604
|
+
class GetRuleEcsContainerArgs:
|
|
1605
|
+
def __init__(__self__, *,
|
|
1606
|
+
cluster: str,
|
|
1607
|
+
region: str,
|
|
1608
|
+
service: str,
|
|
1609
|
+
task_count: Optional[int] = None):
|
|
1610
|
+
"""
|
|
1611
|
+
:param str cluster: Name of cluster in which service belong to
|
|
1612
|
+
:param str region: Region of cluster
|
|
1613
|
+
:param str service: Name of service to be onboarded
|
|
1614
|
+
:param int task_count: Desired number of tasks on warming up a rule
|
|
1615
|
+
"""
|
|
1616
|
+
pulumi.set(__self__, "cluster", cluster)
|
|
1617
|
+
pulumi.set(__self__, "region", region)
|
|
1618
|
+
pulumi.set(__self__, "service", service)
|
|
1619
|
+
if task_count is not None:
|
|
1620
|
+
pulumi.set(__self__, "task_count", task_count)
|
|
1621
|
+
|
|
1622
|
+
@property
|
|
1623
|
+
@pulumi.getter
|
|
1624
|
+
def cluster(self) -> str:
|
|
1625
|
+
"""
|
|
1626
|
+
Name of cluster in which service belong to
|
|
1627
|
+
"""
|
|
1628
|
+
return pulumi.get(self, "cluster")
|
|
1629
|
+
|
|
1630
|
+
@cluster.setter
|
|
1631
|
+
def cluster(self, value: str):
|
|
1632
|
+
pulumi.set(self, "cluster", value)
|
|
1633
|
+
|
|
1634
|
+
@property
|
|
1635
|
+
@pulumi.getter
|
|
1636
|
+
def region(self) -> str:
|
|
1637
|
+
"""
|
|
1638
|
+
Region of cluster
|
|
1639
|
+
"""
|
|
1640
|
+
return pulumi.get(self, "region")
|
|
1641
|
+
|
|
1642
|
+
@region.setter
|
|
1643
|
+
def region(self, value: str):
|
|
1644
|
+
pulumi.set(self, "region", value)
|
|
1645
|
+
|
|
1646
|
+
@property
|
|
1647
|
+
@pulumi.getter
|
|
1648
|
+
def service(self) -> str:
|
|
1649
|
+
"""
|
|
1650
|
+
Name of service to be onboarded
|
|
1651
|
+
"""
|
|
1652
|
+
return pulumi.get(self, "service")
|
|
1653
|
+
|
|
1654
|
+
@service.setter
|
|
1655
|
+
def service(self, value: str):
|
|
1656
|
+
pulumi.set(self, "service", value)
|
|
1657
|
+
|
|
1658
|
+
@property
|
|
1659
|
+
@pulumi.getter(name="taskCount")
|
|
1660
|
+
def task_count(self) -> Optional[int]:
|
|
1661
|
+
"""
|
|
1662
|
+
Desired number of tasks on warming up a rule
|
|
1663
|
+
"""
|
|
1664
|
+
return pulumi.get(self, "task_count")
|
|
1665
|
+
|
|
1666
|
+
@task_count.setter
|
|
1667
|
+
def task_count(self, value: Optional[int]):
|
|
1668
|
+
pulumi.set(self, "task_count", value)
|
|
1669
|
+
|
|
1670
|
+
|
|
1671
|
+
if not MYPY:
|
|
1672
|
+
class GetRuleEcsDependArgsDict(TypedDict):
|
|
1673
|
+
rule_id: int
|
|
1674
|
+
"""
|
|
1675
|
+
Rule id of the dependent rule
|
|
1676
|
+
"""
|
|
1677
|
+
delay_in_sec: NotRequired[int]
|
|
1678
|
+
"""
|
|
1679
|
+
Number of seconds the rule should wait after warming up the dependent rule
|
|
1680
|
+
"""
|
|
1681
|
+
elif False:
|
|
1682
|
+
GetRuleEcsDependArgsDict: TypeAlias = Mapping[str, Any]
|
|
1683
|
+
|
|
1684
|
+
@pulumi.input_type
|
|
1685
|
+
class GetRuleEcsDependArgs:
|
|
1686
|
+
def __init__(__self__, *,
|
|
1687
|
+
rule_id: int,
|
|
1688
|
+
delay_in_sec: Optional[int] = None):
|
|
1689
|
+
"""
|
|
1690
|
+
:param int rule_id: Rule id of the dependent rule
|
|
1691
|
+
:param int delay_in_sec: Number of seconds the rule should wait after warming up the dependent rule
|
|
1692
|
+
"""
|
|
1693
|
+
pulumi.set(__self__, "rule_id", rule_id)
|
|
1694
|
+
if delay_in_sec is not None:
|
|
1695
|
+
pulumi.set(__self__, "delay_in_sec", delay_in_sec)
|
|
1696
|
+
|
|
1697
|
+
@property
|
|
1698
|
+
@pulumi.getter(name="ruleId")
|
|
1699
|
+
def rule_id(self) -> int:
|
|
1700
|
+
"""
|
|
1701
|
+
Rule id of the dependent rule
|
|
1702
|
+
"""
|
|
1703
|
+
return pulumi.get(self, "rule_id")
|
|
1704
|
+
|
|
1705
|
+
@rule_id.setter
|
|
1706
|
+
def rule_id(self, value: int):
|
|
1707
|
+
pulumi.set(self, "rule_id", value)
|
|
1708
|
+
|
|
1709
|
+
@property
|
|
1710
|
+
@pulumi.getter(name="delayInSec")
|
|
1711
|
+
def delay_in_sec(self) -> Optional[int]:
|
|
1712
|
+
"""
|
|
1713
|
+
Number of seconds the rule should wait after warming up the dependent rule
|
|
1714
|
+
"""
|
|
1715
|
+
return pulumi.get(self, "delay_in_sec")
|
|
1716
|
+
|
|
1717
|
+
@delay_in_sec.setter
|
|
1718
|
+
def delay_in_sec(self, value: Optional[int]):
|
|
1719
|
+
pulumi.set(self, "delay_in_sec", value)
|
|
1720
|
+
|
|
1721
|
+
|
|
1722
|
+
if not MYPY:
|
|
1723
|
+
class GetRuleEcsHttpArgsDict(TypedDict):
|
|
1724
|
+
proxy_id: str
|
|
1725
|
+
"""
|
|
1726
|
+
Id of the proxy
|
|
1727
|
+
"""
|
|
1728
|
+
elif False:
|
|
1729
|
+
GetRuleEcsHttpArgsDict: TypeAlias = Mapping[str, Any]
|
|
1730
|
+
|
|
1731
|
+
@pulumi.input_type
|
|
1732
|
+
class GetRuleEcsHttpArgs:
|
|
1733
|
+
def __init__(__self__, *,
|
|
1734
|
+
proxy_id: str):
|
|
1735
|
+
"""
|
|
1736
|
+
:param str proxy_id: Id of the proxy
|
|
1737
|
+
"""
|
|
1738
|
+
pulumi.set(__self__, "proxy_id", proxy_id)
|
|
1739
|
+
|
|
1740
|
+
@property
|
|
1741
|
+
@pulumi.getter(name="proxyId")
|
|
1742
|
+
def proxy_id(self) -> str:
|
|
1743
|
+
"""
|
|
1744
|
+
Id of the proxy
|
|
1745
|
+
"""
|
|
1746
|
+
return pulumi.get(self, "proxy_id")
|
|
1747
|
+
|
|
1748
|
+
@proxy_id.setter
|
|
1749
|
+
def proxy_id(self, value: str):
|
|
1750
|
+
pulumi.set(self, "proxy_id", value)
|
|
1751
|
+
|
|
1752
|
+
|
|
1753
|
+
if not MYPY:
|
|
1754
|
+
class GetRuleRdsDatabaseArgsDict(TypedDict):
|
|
1755
|
+
id: str
|
|
1756
|
+
"""
|
|
1757
|
+
ID of the database
|
|
1758
|
+
"""
|
|
1759
|
+
region: str
|
|
1760
|
+
"""
|
|
1761
|
+
Region to which database belong to
|
|
1762
|
+
"""
|
|
1763
|
+
elif False:
|
|
1764
|
+
GetRuleRdsDatabaseArgsDict: TypeAlias = Mapping[str, Any]
|
|
1765
|
+
|
|
1766
|
+
@pulumi.input_type
|
|
1767
|
+
class GetRuleRdsDatabaseArgs:
|
|
1768
|
+
def __init__(__self__, *,
|
|
1769
|
+
id: str,
|
|
1770
|
+
region: str):
|
|
1771
|
+
"""
|
|
1772
|
+
:param str id: ID of the database
|
|
1773
|
+
:param str region: Region to which database belong to
|
|
1774
|
+
"""
|
|
1775
|
+
pulumi.set(__self__, "id", id)
|
|
1776
|
+
pulumi.set(__self__, "region", region)
|
|
1777
|
+
|
|
1778
|
+
@property
|
|
1779
|
+
@pulumi.getter
|
|
1780
|
+
def id(self) -> str:
|
|
1781
|
+
"""
|
|
1782
|
+
ID of the database
|
|
1783
|
+
"""
|
|
1784
|
+
return pulumi.get(self, "id")
|
|
1785
|
+
|
|
1786
|
+
@id.setter
|
|
1787
|
+
def id(self, value: str):
|
|
1788
|
+
pulumi.set(self, "id", value)
|
|
1789
|
+
|
|
1790
|
+
@property
|
|
1791
|
+
@pulumi.getter
|
|
1792
|
+
def region(self) -> str:
|
|
1793
|
+
"""
|
|
1794
|
+
Region to which database belong to
|
|
1795
|
+
"""
|
|
1796
|
+
return pulumi.get(self, "region")
|
|
1797
|
+
|
|
1798
|
+
@region.setter
|
|
1799
|
+
def region(self, value: str):
|
|
1800
|
+
pulumi.set(self, "region", value)
|
|
1801
|
+
|
|
1802
|
+
|
|
1803
|
+
if not MYPY:
|
|
1804
|
+
class GetRuleRdsDependArgsDict(TypedDict):
|
|
1805
|
+
rule_id: int
|
|
1806
|
+
"""
|
|
1807
|
+
Rule id of the dependent rule
|
|
1808
|
+
"""
|
|
1809
|
+
delay_in_sec: NotRequired[int]
|
|
1810
|
+
"""
|
|
1811
|
+
Number of seconds the rule should wait after warming up the dependent rule
|
|
1812
|
+
"""
|
|
1813
|
+
elif False:
|
|
1814
|
+
GetRuleRdsDependArgsDict: TypeAlias = Mapping[str, Any]
|
|
1815
|
+
|
|
1816
|
+
@pulumi.input_type
|
|
1817
|
+
class GetRuleRdsDependArgs:
|
|
1818
|
+
def __init__(__self__, *,
|
|
1819
|
+
rule_id: int,
|
|
1820
|
+
delay_in_sec: Optional[int] = None):
|
|
1821
|
+
"""
|
|
1822
|
+
:param int rule_id: Rule id of the dependent rule
|
|
1823
|
+
:param int delay_in_sec: Number of seconds the rule should wait after warming up the dependent rule
|
|
1824
|
+
"""
|
|
1825
|
+
pulumi.set(__self__, "rule_id", rule_id)
|
|
1826
|
+
if delay_in_sec is not None:
|
|
1827
|
+
pulumi.set(__self__, "delay_in_sec", delay_in_sec)
|
|
1828
|
+
|
|
1829
|
+
@property
|
|
1830
|
+
@pulumi.getter(name="ruleId")
|
|
1831
|
+
def rule_id(self) -> int:
|
|
1832
|
+
"""
|
|
1833
|
+
Rule id of the dependent rule
|
|
1834
|
+
"""
|
|
1835
|
+
return pulumi.get(self, "rule_id")
|
|
1836
|
+
|
|
1837
|
+
@rule_id.setter
|
|
1838
|
+
def rule_id(self, value: int):
|
|
1839
|
+
pulumi.set(self, "rule_id", value)
|
|
1840
|
+
|
|
1841
|
+
@property
|
|
1842
|
+
@pulumi.getter(name="delayInSec")
|
|
1843
|
+
def delay_in_sec(self) -> Optional[int]:
|
|
1844
|
+
"""
|
|
1845
|
+
Number of seconds the rule should wait after warming up the dependent rule
|
|
1846
|
+
"""
|
|
1847
|
+
return pulumi.get(self, "delay_in_sec")
|
|
1848
|
+
|
|
1849
|
+
@delay_in_sec.setter
|
|
1850
|
+
def delay_in_sec(self, value: Optional[int]):
|
|
1851
|
+
pulumi.set(self, "delay_in_sec", value)
|
|
1852
|
+
|
|
1853
|
+
|
|
1854
|
+
if not MYPY:
|
|
1855
|
+
class GetRuleRdsTcpArgsDict(TypedDict):
|
|
1856
|
+
proxy_id: str
|
|
1857
|
+
"""
|
|
1858
|
+
Id of the Proxy
|
|
1859
|
+
"""
|
|
1860
|
+
forward_rules: NotRequired[Sequence['GetRuleRdsTcpForwardRuleArgsDict']]
|
|
1861
|
+
"""
|
|
1862
|
+
Additional tcp forwarding rules
|
|
1863
|
+
"""
|
|
1864
|
+
elif False:
|
|
1865
|
+
GetRuleRdsTcpArgsDict: TypeAlias = Mapping[str, Any]
|
|
1866
|
+
|
|
1867
|
+
@pulumi.input_type
|
|
1868
|
+
class GetRuleRdsTcpArgs:
|
|
1869
|
+
def __init__(__self__, *,
|
|
1870
|
+
proxy_id: str,
|
|
1871
|
+
forward_rules: Optional[Sequence['GetRuleRdsTcpForwardRuleArgs']] = None):
|
|
1872
|
+
"""
|
|
1873
|
+
:param str proxy_id: Id of the Proxy
|
|
1874
|
+
:param Sequence['GetRuleRdsTcpForwardRuleArgs'] forward_rules: Additional tcp forwarding rules
|
|
1875
|
+
"""
|
|
1876
|
+
pulumi.set(__self__, "proxy_id", proxy_id)
|
|
1877
|
+
if forward_rules is not None:
|
|
1878
|
+
pulumi.set(__self__, "forward_rules", forward_rules)
|
|
1879
|
+
|
|
1880
|
+
@property
|
|
1881
|
+
@pulumi.getter(name="proxyId")
|
|
1882
|
+
def proxy_id(self) -> str:
|
|
1883
|
+
"""
|
|
1884
|
+
Id of the Proxy
|
|
1885
|
+
"""
|
|
1886
|
+
return pulumi.get(self, "proxy_id")
|
|
1887
|
+
|
|
1888
|
+
@proxy_id.setter
|
|
1889
|
+
def proxy_id(self, value: str):
|
|
1890
|
+
pulumi.set(self, "proxy_id", value)
|
|
1891
|
+
|
|
1892
|
+
@property
|
|
1893
|
+
@pulumi.getter(name="forwardRules")
|
|
1894
|
+
def forward_rules(self) -> Optional[Sequence['GetRuleRdsTcpForwardRuleArgs']]:
|
|
1895
|
+
"""
|
|
1896
|
+
Additional tcp forwarding rules
|
|
1897
|
+
"""
|
|
1898
|
+
return pulumi.get(self, "forward_rules")
|
|
1899
|
+
|
|
1900
|
+
@forward_rules.setter
|
|
1901
|
+
def forward_rules(self, value: Optional[Sequence['GetRuleRdsTcpForwardRuleArgs']]):
|
|
1902
|
+
pulumi.set(self, "forward_rules", value)
|
|
1903
|
+
|
|
1904
|
+
|
|
1905
|
+
if not MYPY:
|
|
1906
|
+
class GetRuleRdsTcpForwardRuleArgsDict(TypedDict):
|
|
1907
|
+
port: int
|
|
1908
|
+
"""
|
|
1909
|
+
Port to listen on the vm
|
|
1910
|
+
"""
|
|
1911
|
+
connect_on: NotRequired[int]
|
|
1912
|
+
"""
|
|
1913
|
+
Port to listen on the proxy
|
|
1914
|
+
"""
|
|
1915
|
+
elif False:
|
|
1916
|
+
GetRuleRdsTcpForwardRuleArgsDict: TypeAlias = Mapping[str, Any]
|
|
1917
|
+
|
|
1918
|
+
@pulumi.input_type
|
|
1919
|
+
class GetRuleRdsTcpForwardRuleArgs:
|
|
1920
|
+
def __init__(__self__, *,
|
|
1921
|
+
port: int,
|
|
1922
|
+
connect_on: Optional[int] = None):
|
|
1923
|
+
"""
|
|
1924
|
+
:param int port: Port to listen on the vm
|
|
1925
|
+
:param int connect_on: Port to listen on the proxy
|
|
1926
|
+
"""
|
|
1927
|
+
pulumi.set(__self__, "port", port)
|
|
1928
|
+
if connect_on is not None:
|
|
1929
|
+
pulumi.set(__self__, "connect_on", connect_on)
|
|
1930
|
+
|
|
1931
|
+
@property
|
|
1932
|
+
@pulumi.getter
|
|
1933
|
+
def port(self) -> int:
|
|
1934
|
+
"""
|
|
1935
|
+
Port to listen on the vm
|
|
1936
|
+
"""
|
|
1937
|
+
return pulumi.get(self, "port")
|
|
1938
|
+
|
|
1939
|
+
@port.setter
|
|
1940
|
+
def port(self, value: int):
|
|
1941
|
+
pulumi.set(self, "port", value)
|
|
1942
|
+
|
|
1943
|
+
@property
|
|
1944
|
+
@pulumi.getter(name="connectOn")
|
|
1945
|
+
def connect_on(self) -> Optional[int]:
|
|
1946
|
+
"""
|
|
1947
|
+
Port to listen on the proxy
|
|
1948
|
+
"""
|
|
1949
|
+
return pulumi.get(self, "connect_on")
|
|
1950
|
+
|
|
1951
|
+
@connect_on.setter
|
|
1952
|
+
def connect_on(self, value: Optional[int]):
|
|
1953
|
+
pulumi.set(self, "connect_on", value)
|
|
1954
|
+
|
|
1955
|
+
|
|
1956
|
+
if not MYPY:
|
|
1957
|
+
class GetRuleVmDependArgsDict(TypedDict):
|
|
1958
|
+
rule_id: int
|
|
1959
|
+
"""
|
|
1960
|
+
Rule id of the dependent rule
|
|
1961
|
+
"""
|
|
1962
|
+
delay_in_sec: NotRequired[int]
|
|
1963
|
+
"""
|
|
1964
|
+
Number of seconds the rule should wait after warming up the dependent rule
|
|
1965
|
+
"""
|
|
1966
|
+
elif False:
|
|
1967
|
+
GetRuleVmDependArgsDict: TypeAlias = Mapping[str, Any]
|
|
1968
|
+
|
|
1969
|
+
@pulumi.input_type
|
|
1970
|
+
class GetRuleVmDependArgs:
|
|
1971
|
+
def __init__(__self__, *,
|
|
1972
|
+
rule_id: int,
|
|
1973
|
+
delay_in_sec: Optional[int] = None):
|
|
1974
|
+
"""
|
|
1975
|
+
:param int rule_id: Rule id of the dependent rule
|
|
1976
|
+
:param int delay_in_sec: Number of seconds the rule should wait after warming up the dependent rule
|
|
1977
|
+
"""
|
|
1978
|
+
pulumi.set(__self__, "rule_id", rule_id)
|
|
1979
|
+
if delay_in_sec is not None:
|
|
1980
|
+
pulumi.set(__self__, "delay_in_sec", delay_in_sec)
|
|
1981
|
+
|
|
1982
|
+
@property
|
|
1983
|
+
@pulumi.getter(name="ruleId")
|
|
1984
|
+
def rule_id(self) -> int:
|
|
1985
|
+
"""
|
|
1986
|
+
Rule id of the dependent rule
|
|
1987
|
+
"""
|
|
1988
|
+
return pulumi.get(self, "rule_id")
|
|
1989
|
+
|
|
1990
|
+
@rule_id.setter
|
|
1991
|
+
def rule_id(self, value: int):
|
|
1992
|
+
pulumi.set(self, "rule_id", value)
|
|
1993
|
+
|
|
1994
|
+
@property
|
|
1995
|
+
@pulumi.getter(name="delayInSec")
|
|
1996
|
+
def delay_in_sec(self) -> Optional[int]:
|
|
1997
|
+
"""
|
|
1998
|
+
Number of seconds the rule should wait after warming up the dependent rule
|
|
1999
|
+
"""
|
|
2000
|
+
return pulumi.get(self, "delay_in_sec")
|
|
2001
|
+
|
|
2002
|
+
@delay_in_sec.setter
|
|
2003
|
+
def delay_in_sec(self, value: Optional[int]):
|
|
2004
|
+
pulumi.set(self, "delay_in_sec", value)
|
|
2005
|
+
|
|
2006
|
+
|
|
2007
|
+
if not MYPY:
|
|
2008
|
+
class GetRuleVmFilterArgsDict(TypedDict):
|
|
2009
|
+
vm_ids: Sequence[str]
|
|
2010
|
+
"""
|
|
2011
|
+
Ids of instances that needs to be managed using the AutoStopping rules
|
|
2012
|
+
"""
|
|
2013
|
+
regions: NotRequired[Sequence[str]]
|
|
2014
|
+
"""
|
|
2015
|
+
Regions of instances that needs to be managed using the AutoStopping rules
|
|
2016
|
+
"""
|
|
2017
|
+
tags: NotRequired[Sequence['GetRuleVmFilterTagArgsDict']]
|
|
2018
|
+
"""
|
|
2019
|
+
Tags of instances that needs to be managed using the AutoStopping rules
|
|
2020
|
+
"""
|
|
2021
|
+
zones: NotRequired[Sequence[str]]
|
|
2022
|
+
"""
|
|
2023
|
+
Zones of instances that needs to be managed using the AutoStopping rules
|
|
2024
|
+
"""
|
|
2025
|
+
elif False:
|
|
2026
|
+
GetRuleVmFilterArgsDict: TypeAlias = Mapping[str, Any]
|
|
2027
|
+
|
|
2028
|
+
@pulumi.input_type
|
|
2029
|
+
class GetRuleVmFilterArgs:
|
|
2030
|
+
def __init__(__self__, *,
|
|
2031
|
+
vm_ids: Sequence[str],
|
|
2032
|
+
regions: Optional[Sequence[str]] = None,
|
|
2033
|
+
tags: Optional[Sequence['GetRuleVmFilterTagArgs']] = None,
|
|
2034
|
+
zones: Optional[Sequence[str]] = None):
|
|
2035
|
+
"""
|
|
2036
|
+
:param Sequence[str] vm_ids: Ids of instances that needs to be managed using the AutoStopping rules
|
|
2037
|
+
:param Sequence[str] regions: Regions of instances that needs to be managed using the AutoStopping rules
|
|
2038
|
+
:param Sequence['GetRuleVmFilterTagArgs'] tags: Tags of instances that needs to be managed using the AutoStopping rules
|
|
2039
|
+
:param Sequence[str] zones: Zones of instances that needs to be managed using the AutoStopping rules
|
|
2040
|
+
"""
|
|
2041
|
+
pulumi.set(__self__, "vm_ids", vm_ids)
|
|
2042
|
+
if regions is not None:
|
|
2043
|
+
pulumi.set(__self__, "regions", regions)
|
|
2044
|
+
if tags is not None:
|
|
2045
|
+
pulumi.set(__self__, "tags", tags)
|
|
2046
|
+
if zones is not None:
|
|
2047
|
+
pulumi.set(__self__, "zones", zones)
|
|
2048
|
+
|
|
2049
|
+
@property
|
|
2050
|
+
@pulumi.getter(name="vmIds")
|
|
2051
|
+
def vm_ids(self) -> Sequence[str]:
|
|
2052
|
+
"""
|
|
2053
|
+
Ids of instances that needs to be managed using the AutoStopping rules
|
|
2054
|
+
"""
|
|
2055
|
+
return pulumi.get(self, "vm_ids")
|
|
2056
|
+
|
|
2057
|
+
@vm_ids.setter
|
|
2058
|
+
def vm_ids(self, value: Sequence[str]):
|
|
2059
|
+
pulumi.set(self, "vm_ids", value)
|
|
2060
|
+
|
|
2061
|
+
@property
|
|
2062
|
+
@pulumi.getter
|
|
2063
|
+
def regions(self) -> Optional[Sequence[str]]:
|
|
2064
|
+
"""
|
|
2065
|
+
Regions of instances that needs to be managed using the AutoStopping rules
|
|
2066
|
+
"""
|
|
2067
|
+
return pulumi.get(self, "regions")
|
|
2068
|
+
|
|
2069
|
+
@regions.setter
|
|
2070
|
+
def regions(self, value: Optional[Sequence[str]]):
|
|
2071
|
+
pulumi.set(self, "regions", value)
|
|
2072
|
+
|
|
2073
|
+
@property
|
|
2074
|
+
@pulumi.getter
|
|
2075
|
+
def tags(self) -> Optional[Sequence['GetRuleVmFilterTagArgs']]:
|
|
2076
|
+
"""
|
|
2077
|
+
Tags of instances that needs to be managed using the AutoStopping rules
|
|
2078
|
+
"""
|
|
2079
|
+
return pulumi.get(self, "tags")
|
|
2080
|
+
|
|
2081
|
+
@tags.setter
|
|
2082
|
+
def tags(self, value: Optional[Sequence['GetRuleVmFilterTagArgs']]):
|
|
2083
|
+
pulumi.set(self, "tags", value)
|
|
2084
|
+
|
|
2085
|
+
@property
|
|
2086
|
+
@pulumi.getter
|
|
2087
|
+
def zones(self) -> Optional[Sequence[str]]:
|
|
2088
|
+
"""
|
|
2089
|
+
Zones of instances that needs to be managed using the AutoStopping rules
|
|
2090
|
+
"""
|
|
2091
|
+
return pulumi.get(self, "zones")
|
|
2092
|
+
|
|
2093
|
+
@zones.setter
|
|
2094
|
+
def zones(self, value: Optional[Sequence[str]]):
|
|
2095
|
+
pulumi.set(self, "zones", value)
|
|
2096
|
+
|
|
2097
|
+
|
|
2098
|
+
if not MYPY:
|
|
2099
|
+
class GetRuleVmFilterTagArgsDict(TypedDict):
|
|
2100
|
+
key: str
|
|
2101
|
+
value: str
|
|
2102
|
+
elif False:
|
|
2103
|
+
GetRuleVmFilterTagArgsDict: TypeAlias = Mapping[str, Any]
|
|
2104
|
+
|
|
2105
|
+
@pulumi.input_type
|
|
2106
|
+
class GetRuleVmFilterTagArgs:
|
|
2107
|
+
def __init__(__self__, *,
|
|
2108
|
+
key: str,
|
|
2109
|
+
value: str):
|
|
2110
|
+
pulumi.set(__self__, "key", key)
|
|
2111
|
+
pulumi.set(__self__, "value", value)
|
|
2112
|
+
|
|
2113
|
+
@property
|
|
2114
|
+
@pulumi.getter
|
|
2115
|
+
def key(self) -> str:
|
|
2116
|
+
return pulumi.get(self, "key")
|
|
2117
|
+
|
|
2118
|
+
@key.setter
|
|
2119
|
+
def key(self, value: str):
|
|
2120
|
+
pulumi.set(self, "key", value)
|
|
2121
|
+
|
|
2122
|
+
@property
|
|
2123
|
+
@pulumi.getter
|
|
2124
|
+
def value(self) -> str:
|
|
2125
|
+
return pulumi.get(self, "value")
|
|
2126
|
+
|
|
2127
|
+
@value.setter
|
|
2128
|
+
def value(self, value: str):
|
|
2129
|
+
pulumi.set(self, "value", value)
|
|
2130
|
+
|
|
2131
|
+
|
|
2132
|
+
if not MYPY:
|
|
2133
|
+
class GetRuleVmHttpArgsDict(TypedDict):
|
|
2134
|
+
proxy_id: str
|
|
2135
|
+
"""
|
|
2136
|
+
Id of the proxy
|
|
2137
|
+
"""
|
|
2138
|
+
healths: NotRequired[Sequence['GetRuleVmHttpHealthArgsDict']]
|
|
2139
|
+
"""
|
|
2140
|
+
Health Check Details
|
|
2141
|
+
"""
|
|
2142
|
+
routings: NotRequired[Sequence['GetRuleVmHttpRoutingArgsDict']]
|
|
2143
|
+
"""
|
|
2144
|
+
Routing configuration used to access the instances
|
|
2145
|
+
"""
|
|
2146
|
+
elif False:
|
|
2147
|
+
GetRuleVmHttpArgsDict: TypeAlias = Mapping[str, Any]
|
|
2148
|
+
|
|
2149
|
+
@pulumi.input_type
|
|
2150
|
+
class GetRuleVmHttpArgs:
|
|
2151
|
+
def __init__(__self__, *,
|
|
2152
|
+
proxy_id: str,
|
|
2153
|
+
healths: Optional[Sequence['GetRuleVmHttpHealthArgs']] = None,
|
|
2154
|
+
routings: Optional[Sequence['GetRuleVmHttpRoutingArgs']] = None):
|
|
2155
|
+
"""
|
|
2156
|
+
:param str proxy_id: Id of the proxy
|
|
2157
|
+
:param Sequence['GetRuleVmHttpHealthArgs'] healths: Health Check Details
|
|
2158
|
+
:param Sequence['GetRuleVmHttpRoutingArgs'] routings: Routing configuration used to access the instances
|
|
2159
|
+
"""
|
|
2160
|
+
pulumi.set(__self__, "proxy_id", proxy_id)
|
|
2161
|
+
if healths is not None:
|
|
2162
|
+
pulumi.set(__self__, "healths", healths)
|
|
2163
|
+
if routings is not None:
|
|
2164
|
+
pulumi.set(__self__, "routings", routings)
|
|
2165
|
+
|
|
2166
|
+
@property
|
|
2167
|
+
@pulumi.getter(name="proxyId")
|
|
2168
|
+
def proxy_id(self) -> str:
|
|
2169
|
+
"""
|
|
2170
|
+
Id of the proxy
|
|
2171
|
+
"""
|
|
2172
|
+
return pulumi.get(self, "proxy_id")
|
|
2173
|
+
|
|
2174
|
+
@proxy_id.setter
|
|
2175
|
+
def proxy_id(self, value: str):
|
|
2176
|
+
pulumi.set(self, "proxy_id", value)
|
|
2177
|
+
|
|
2178
|
+
@property
|
|
2179
|
+
@pulumi.getter
|
|
2180
|
+
def healths(self) -> Optional[Sequence['GetRuleVmHttpHealthArgs']]:
|
|
2181
|
+
"""
|
|
2182
|
+
Health Check Details
|
|
2183
|
+
"""
|
|
2184
|
+
return pulumi.get(self, "healths")
|
|
2185
|
+
|
|
2186
|
+
@healths.setter
|
|
2187
|
+
def healths(self, value: Optional[Sequence['GetRuleVmHttpHealthArgs']]):
|
|
2188
|
+
pulumi.set(self, "healths", value)
|
|
2189
|
+
|
|
2190
|
+
@property
|
|
2191
|
+
@pulumi.getter
|
|
2192
|
+
def routings(self) -> Optional[Sequence['GetRuleVmHttpRoutingArgs']]:
|
|
2193
|
+
"""
|
|
2194
|
+
Routing configuration used to access the instances
|
|
2195
|
+
"""
|
|
2196
|
+
return pulumi.get(self, "routings")
|
|
2197
|
+
|
|
2198
|
+
@routings.setter
|
|
2199
|
+
def routings(self, value: Optional[Sequence['GetRuleVmHttpRoutingArgs']]):
|
|
2200
|
+
pulumi.set(self, "routings", value)
|
|
2201
|
+
|
|
2202
|
+
|
|
2203
|
+
if not MYPY:
|
|
2204
|
+
class GetRuleVmHttpHealthArgsDict(TypedDict):
|
|
2205
|
+
port: int
|
|
2206
|
+
"""
|
|
2207
|
+
Health check port on the VM
|
|
2208
|
+
"""
|
|
2209
|
+
protocol: str
|
|
2210
|
+
"""
|
|
2211
|
+
Protocol can be http or https
|
|
2212
|
+
"""
|
|
2213
|
+
path: NotRequired[str]
|
|
2214
|
+
"""
|
|
2215
|
+
API path to use for health check
|
|
2216
|
+
"""
|
|
2217
|
+
status_code_from: NotRequired[int]
|
|
2218
|
+
"""
|
|
2219
|
+
Lower limit for acceptable status code
|
|
2220
|
+
"""
|
|
2221
|
+
status_code_to: NotRequired[int]
|
|
2222
|
+
"""
|
|
2223
|
+
Upper limit for acceptable status code
|
|
2224
|
+
"""
|
|
2225
|
+
timeout: NotRequired[int]
|
|
2226
|
+
"""
|
|
2227
|
+
Health check timeout
|
|
2228
|
+
"""
|
|
2229
|
+
elif False:
|
|
2230
|
+
GetRuleVmHttpHealthArgsDict: TypeAlias = Mapping[str, Any]
|
|
2231
|
+
|
|
2232
|
+
@pulumi.input_type
|
|
2233
|
+
class GetRuleVmHttpHealthArgs:
|
|
2234
|
+
def __init__(__self__, *,
|
|
2235
|
+
port: int,
|
|
2236
|
+
protocol: str,
|
|
2237
|
+
path: Optional[str] = None,
|
|
2238
|
+
status_code_from: Optional[int] = None,
|
|
2239
|
+
status_code_to: Optional[int] = None,
|
|
2240
|
+
timeout: Optional[int] = None):
|
|
2241
|
+
"""
|
|
2242
|
+
:param int port: Health check port on the VM
|
|
2243
|
+
:param str protocol: Protocol can be http or https
|
|
2244
|
+
:param str path: API path to use for health check
|
|
2245
|
+
:param int status_code_from: Lower limit for acceptable status code
|
|
2246
|
+
:param int status_code_to: Upper limit for acceptable status code
|
|
2247
|
+
:param int timeout: Health check timeout
|
|
2248
|
+
"""
|
|
2249
|
+
pulumi.set(__self__, "port", port)
|
|
2250
|
+
pulumi.set(__self__, "protocol", protocol)
|
|
2251
|
+
if path is not None:
|
|
2252
|
+
pulumi.set(__self__, "path", path)
|
|
2253
|
+
if status_code_from is not None:
|
|
2254
|
+
pulumi.set(__self__, "status_code_from", status_code_from)
|
|
2255
|
+
if status_code_to is not None:
|
|
2256
|
+
pulumi.set(__self__, "status_code_to", status_code_to)
|
|
2257
|
+
if timeout is not None:
|
|
2258
|
+
pulumi.set(__self__, "timeout", timeout)
|
|
2259
|
+
|
|
2260
|
+
@property
|
|
2261
|
+
@pulumi.getter
|
|
2262
|
+
def port(self) -> int:
|
|
2263
|
+
"""
|
|
2264
|
+
Health check port on the VM
|
|
2265
|
+
"""
|
|
2266
|
+
return pulumi.get(self, "port")
|
|
2267
|
+
|
|
2268
|
+
@port.setter
|
|
2269
|
+
def port(self, value: int):
|
|
2270
|
+
pulumi.set(self, "port", value)
|
|
2271
|
+
|
|
2272
|
+
@property
|
|
2273
|
+
@pulumi.getter
|
|
2274
|
+
def protocol(self) -> str:
|
|
2275
|
+
"""
|
|
2276
|
+
Protocol can be http or https
|
|
2277
|
+
"""
|
|
2278
|
+
return pulumi.get(self, "protocol")
|
|
2279
|
+
|
|
2280
|
+
@protocol.setter
|
|
2281
|
+
def protocol(self, value: str):
|
|
2282
|
+
pulumi.set(self, "protocol", value)
|
|
2283
|
+
|
|
2284
|
+
@property
|
|
2285
|
+
@pulumi.getter
|
|
2286
|
+
def path(self) -> Optional[str]:
|
|
2287
|
+
"""
|
|
2288
|
+
API path to use for health check
|
|
2289
|
+
"""
|
|
2290
|
+
return pulumi.get(self, "path")
|
|
2291
|
+
|
|
2292
|
+
@path.setter
|
|
2293
|
+
def path(self, value: Optional[str]):
|
|
2294
|
+
pulumi.set(self, "path", value)
|
|
2295
|
+
|
|
2296
|
+
@property
|
|
2297
|
+
@pulumi.getter(name="statusCodeFrom")
|
|
2298
|
+
def status_code_from(self) -> Optional[int]:
|
|
2299
|
+
"""
|
|
2300
|
+
Lower limit for acceptable status code
|
|
2301
|
+
"""
|
|
2302
|
+
return pulumi.get(self, "status_code_from")
|
|
2303
|
+
|
|
2304
|
+
@status_code_from.setter
|
|
2305
|
+
def status_code_from(self, value: Optional[int]):
|
|
2306
|
+
pulumi.set(self, "status_code_from", value)
|
|
2307
|
+
|
|
2308
|
+
@property
|
|
2309
|
+
@pulumi.getter(name="statusCodeTo")
|
|
2310
|
+
def status_code_to(self) -> Optional[int]:
|
|
2311
|
+
"""
|
|
2312
|
+
Upper limit for acceptable status code
|
|
2313
|
+
"""
|
|
2314
|
+
return pulumi.get(self, "status_code_to")
|
|
2315
|
+
|
|
2316
|
+
@status_code_to.setter
|
|
2317
|
+
def status_code_to(self, value: Optional[int]):
|
|
2318
|
+
pulumi.set(self, "status_code_to", value)
|
|
2319
|
+
|
|
2320
|
+
@property
|
|
2321
|
+
@pulumi.getter
|
|
2322
|
+
def timeout(self) -> Optional[int]:
|
|
2323
|
+
"""
|
|
2324
|
+
Health check timeout
|
|
2325
|
+
"""
|
|
2326
|
+
return pulumi.get(self, "timeout")
|
|
2327
|
+
|
|
2328
|
+
@timeout.setter
|
|
2329
|
+
def timeout(self, value: Optional[int]):
|
|
2330
|
+
pulumi.set(self, "timeout", value)
|
|
2331
|
+
|
|
2332
|
+
|
|
2333
|
+
if not MYPY:
|
|
2334
|
+
class GetRuleVmHttpRoutingArgsDict(TypedDict):
|
|
2335
|
+
source_protocol: str
|
|
2336
|
+
"""
|
|
2337
|
+
Source protocol of the proxy can be http or https
|
|
2338
|
+
"""
|
|
2339
|
+
target_protocol: str
|
|
2340
|
+
"""
|
|
2341
|
+
Target protocol of the instance can be http or https
|
|
2342
|
+
"""
|
|
2343
|
+
action: NotRequired[str]
|
|
2344
|
+
"""
|
|
2345
|
+
Organization Identifier for the Entity
|
|
2346
|
+
"""
|
|
2347
|
+
source_port: NotRequired[int]
|
|
2348
|
+
"""
|
|
2349
|
+
Port on the proxy
|
|
2350
|
+
"""
|
|
2351
|
+
target_port: NotRequired[int]
|
|
2352
|
+
"""
|
|
2353
|
+
Port on the VM
|
|
2354
|
+
"""
|
|
2355
|
+
elif False:
|
|
2356
|
+
GetRuleVmHttpRoutingArgsDict: TypeAlias = Mapping[str, Any]
|
|
2357
|
+
|
|
2358
|
+
@pulumi.input_type
|
|
2359
|
+
class GetRuleVmHttpRoutingArgs:
|
|
2360
|
+
def __init__(__self__, *,
|
|
2361
|
+
source_protocol: str,
|
|
2362
|
+
target_protocol: str,
|
|
2363
|
+
action: Optional[str] = None,
|
|
2364
|
+
source_port: Optional[int] = None,
|
|
2365
|
+
target_port: Optional[int] = None):
|
|
2366
|
+
"""
|
|
2367
|
+
:param str source_protocol: Source protocol of the proxy can be http or https
|
|
2368
|
+
:param str target_protocol: Target protocol of the instance can be http or https
|
|
2369
|
+
:param str action: Organization Identifier for the Entity
|
|
2370
|
+
:param int source_port: Port on the proxy
|
|
2371
|
+
:param int target_port: Port on the VM
|
|
2372
|
+
"""
|
|
2373
|
+
pulumi.set(__self__, "source_protocol", source_protocol)
|
|
2374
|
+
pulumi.set(__self__, "target_protocol", target_protocol)
|
|
2375
|
+
if action is not None:
|
|
2376
|
+
pulumi.set(__self__, "action", action)
|
|
2377
|
+
if source_port is not None:
|
|
2378
|
+
pulumi.set(__self__, "source_port", source_port)
|
|
2379
|
+
if target_port is not None:
|
|
2380
|
+
pulumi.set(__self__, "target_port", target_port)
|
|
2381
|
+
|
|
2382
|
+
@property
|
|
2383
|
+
@pulumi.getter(name="sourceProtocol")
|
|
2384
|
+
def source_protocol(self) -> str:
|
|
2385
|
+
"""
|
|
2386
|
+
Source protocol of the proxy can be http or https
|
|
2387
|
+
"""
|
|
2388
|
+
return pulumi.get(self, "source_protocol")
|
|
2389
|
+
|
|
2390
|
+
@source_protocol.setter
|
|
2391
|
+
def source_protocol(self, value: str):
|
|
2392
|
+
pulumi.set(self, "source_protocol", value)
|
|
2393
|
+
|
|
2394
|
+
@property
|
|
2395
|
+
@pulumi.getter(name="targetProtocol")
|
|
2396
|
+
def target_protocol(self) -> str:
|
|
2397
|
+
"""
|
|
2398
|
+
Target protocol of the instance can be http or https
|
|
2399
|
+
"""
|
|
2400
|
+
return pulumi.get(self, "target_protocol")
|
|
2401
|
+
|
|
2402
|
+
@target_protocol.setter
|
|
2403
|
+
def target_protocol(self, value: str):
|
|
2404
|
+
pulumi.set(self, "target_protocol", value)
|
|
2405
|
+
|
|
2406
|
+
@property
|
|
2407
|
+
@pulumi.getter
|
|
2408
|
+
def action(self) -> Optional[str]:
|
|
2409
|
+
"""
|
|
2410
|
+
Organization Identifier for the Entity
|
|
2411
|
+
"""
|
|
2412
|
+
return pulumi.get(self, "action")
|
|
2413
|
+
|
|
2414
|
+
@action.setter
|
|
2415
|
+
def action(self, value: Optional[str]):
|
|
2416
|
+
pulumi.set(self, "action", value)
|
|
2417
|
+
|
|
2418
|
+
@property
|
|
2419
|
+
@pulumi.getter(name="sourcePort")
|
|
2420
|
+
def source_port(self) -> Optional[int]:
|
|
2421
|
+
"""
|
|
2422
|
+
Port on the proxy
|
|
2423
|
+
"""
|
|
2424
|
+
return pulumi.get(self, "source_port")
|
|
2425
|
+
|
|
2426
|
+
@source_port.setter
|
|
2427
|
+
def source_port(self, value: Optional[int]):
|
|
2428
|
+
pulumi.set(self, "source_port", value)
|
|
2429
|
+
|
|
2430
|
+
@property
|
|
2431
|
+
@pulumi.getter(name="targetPort")
|
|
2432
|
+
def target_port(self) -> Optional[int]:
|
|
2433
|
+
"""
|
|
2434
|
+
Port on the VM
|
|
2435
|
+
"""
|
|
2436
|
+
return pulumi.get(self, "target_port")
|
|
2437
|
+
|
|
2438
|
+
@target_port.setter
|
|
2439
|
+
def target_port(self, value: Optional[int]):
|
|
2440
|
+
pulumi.set(self, "target_port", value)
|
|
2441
|
+
|
|
2442
|
+
|
|
2443
|
+
if not MYPY:
|
|
2444
|
+
class GetRuleVmTcpArgsDict(TypedDict):
|
|
2445
|
+
proxy_id: str
|
|
2446
|
+
"""
|
|
2447
|
+
Id of the Proxy
|
|
2448
|
+
"""
|
|
2449
|
+
forward_rules: NotRequired[Sequence['GetRuleVmTcpForwardRuleArgsDict']]
|
|
2450
|
+
"""
|
|
2451
|
+
Additional tcp forwarding rules
|
|
2452
|
+
"""
|
|
2453
|
+
rdps: NotRequired[Sequence['GetRuleVmTcpRdpArgsDict']]
|
|
2454
|
+
"""
|
|
2455
|
+
RDP configuration
|
|
2456
|
+
"""
|
|
2457
|
+
sshes: NotRequired[Sequence['GetRuleVmTcpSshArgsDict']]
|
|
2458
|
+
"""
|
|
2459
|
+
SSH configuration
|
|
2460
|
+
"""
|
|
2461
|
+
elif False:
|
|
2462
|
+
GetRuleVmTcpArgsDict: TypeAlias = Mapping[str, Any]
|
|
2463
|
+
|
|
2464
|
+
@pulumi.input_type
|
|
2465
|
+
class GetRuleVmTcpArgs:
|
|
2466
|
+
def __init__(__self__, *,
|
|
2467
|
+
proxy_id: str,
|
|
2468
|
+
forward_rules: Optional[Sequence['GetRuleVmTcpForwardRuleArgs']] = None,
|
|
2469
|
+
rdps: Optional[Sequence['GetRuleVmTcpRdpArgs']] = None,
|
|
2470
|
+
sshes: Optional[Sequence['GetRuleVmTcpSshArgs']] = None):
|
|
2471
|
+
"""
|
|
2472
|
+
:param str proxy_id: Id of the Proxy
|
|
2473
|
+
:param Sequence['GetRuleVmTcpForwardRuleArgs'] forward_rules: Additional tcp forwarding rules
|
|
2474
|
+
:param Sequence['GetRuleVmTcpRdpArgs'] rdps: RDP configuration
|
|
2475
|
+
:param Sequence['GetRuleVmTcpSshArgs'] sshes: SSH configuration
|
|
2476
|
+
"""
|
|
2477
|
+
pulumi.set(__self__, "proxy_id", proxy_id)
|
|
2478
|
+
if forward_rules is not None:
|
|
2479
|
+
pulumi.set(__self__, "forward_rules", forward_rules)
|
|
2480
|
+
if rdps is not None:
|
|
2481
|
+
pulumi.set(__self__, "rdps", rdps)
|
|
2482
|
+
if sshes is not None:
|
|
2483
|
+
pulumi.set(__self__, "sshes", sshes)
|
|
2484
|
+
|
|
2485
|
+
@property
|
|
2486
|
+
@pulumi.getter(name="proxyId")
|
|
2487
|
+
def proxy_id(self) -> str:
|
|
2488
|
+
"""
|
|
2489
|
+
Id of the Proxy
|
|
2490
|
+
"""
|
|
2491
|
+
return pulumi.get(self, "proxy_id")
|
|
2492
|
+
|
|
2493
|
+
@proxy_id.setter
|
|
2494
|
+
def proxy_id(self, value: str):
|
|
2495
|
+
pulumi.set(self, "proxy_id", value)
|
|
2496
|
+
|
|
2497
|
+
@property
|
|
2498
|
+
@pulumi.getter(name="forwardRules")
|
|
2499
|
+
def forward_rules(self) -> Optional[Sequence['GetRuleVmTcpForwardRuleArgs']]:
|
|
2500
|
+
"""
|
|
2501
|
+
Additional tcp forwarding rules
|
|
2502
|
+
"""
|
|
2503
|
+
return pulumi.get(self, "forward_rules")
|
|
2504
|
+
|
|
2505
|
+
@forward_rules.setter
|
|
2506
|
+
def forward_rules(self, value: Optional[Sequence['GetRuleVmTcpForwardRuleArgs']]):
|
|
2507
|
+
pulumi.set(self, "forward_rules", value)
|
|
2508
|
+
|
|
2509
|
+
@property
|
|
2510
|
+
@pulumi.getter
|
|
2511
|
+
def rdps(self) -> Optional[Sequence['GetRuleVmTcpRdpArgs']]:
|
|
2512
|
+
"""
|
|
2513
|
+
RDP configuration
|
|
2514
|
+
"""
|
|
2515
|
+
return pulumi.get(self, "rdps")
|
|
2516
|
+
|
|
2517
|
+
@rdps.setter
|
|
2518
|
+
def rdps(self, value: Optional[Sequence['GetRuleVmTcpRdpArgs']]):
|
|
2519
|
+
pulumi.set(self, "rdps", value)
|
|
2520
|
+
|
|
2521
|
+
@property
|
|
2522
|
+
@pulumi.getter
|
|
2523
|
+
def sshes(self) -> Optional[Sequence['GetRuleVmTcpSshArgs']]:
|
|
2524
|
+
"""
|
|
2525
|
+
SSH configuration
|
|
2526
|
+
"""
|
|
2527
|
+
return pulumi.get(self, "sshes")
|
|
2528
|
+
|
|
2529
|
+
@sshes.setter
|
|
2530
|
+
def sshes(self, value: Optional[Sequence['GetRuleVmTcpSshArgs']]):
|
|
2531
|
+
pulumi.set(self, "sshes", value)
|
|
2532
|
+
|
|
2533
|
+
|
|
2534
|
+
if not MYPY:
|
|
2535
|
+
class GetRuleVmTcpForwardRuleArgsDict(TypedDict):
|
|
2536
|
+
port: int
|
|
2537
|
+
"""
|
|
2538
|
+
Port to listen on the vm
|
|
2539
|
+
"""
|
|
2540
|
+
connect_on: NotRequired[int]
|
|
2541
|
+
"""
|
|
2542
|
+
Port to listen on the proxy
|
|
2543
|
+
"""
|
|
2544
|
+
elif False:
|
|
2545
|
+
GetRuleVmTcpForwardRuleArgsDict: TypeAlias = Mapping[str, Any]
|
|
2546
|
+
|
|
2547
|
+
@pulumi.input_type
|
|
2548
|
+
class GetRuleVmTcpForwardRuleArgs:
|
|
2549
|
+
def __init__(__self__, *,
|
|
2550
|
+
port: int,
|
|
2551
|
+
connect_on: Optional[int] = None):
|
|
2552
|
+
"""
|
|
2553
|
+
:param int port: Port to listen on the vm
|
|
2554
|
+
:param int connect_on: Port to listen on the proxy
|
|
2555
|
+
"""
|
|
2556
|
+
pulumi.set(__self__, "port", port)
|
|
2557
|
+
if connect_on is not None:
|
|
2558
|
+
pulumi.set(__self__, "connect_on", connect_on)
|
|
2559
|
+
|
|
2560
|
+
@property
|
|
2561
|
+
@pulumi.getter
|
|
2562
|
+
def port(self) -> int:
|
|
2563
|
+
"""
|
|
2564
|
+
Port to listen on the vm
|
|
2565
|
+
"""
|
|
2566
|
+
return pulumi.get(self, "port")
|
|
2567
|
+
|
|
2568
|
+
@port.setter
|
|
2569
|
+
def port(self, value: int):
|
|
2570
|
+
pulumi.set(self, "port", value)
|
|
2571
|
+
|
|
2572
|
+
@property
|
|
2573
|
+
@pulumi.getter(name="connectOn")
|
|
2574
|
+
def connect_on(self) -> Optional[int]:
|
|
2575
|
+
"""
|
|
2576
|
+
Port to listen on the proxy
|
|
2577
|
+
"""
|
|
2578
|
+
return pulumi.get(self, "connect_on")
|
|
2579
|
+
|
|
2580
|
+
@connect_on.setter
|
|
2581
|
+
def connect_on(self, value: Optional[int]):
|
|
2582
|
+
pulumi.set(self, "connect_on", value)
|
|
2583
|
+
|
|
2584
|
+
|
|
2585
|
+
if not MYPY:
|
|
2586
|
+
class GetRuleVmTcpRdpArgsDict(TypedDict):
|
|
2587
|
+
connect_on: NotRequired[int]
|
|
2588
|
+
"""
|
|
2589
|
+
Port to listen on the proxy
|
|
2590
|
+
"""
|
|
2591
|
+
port: NotRequired[int]
|
|
2592
|
+
"""
|
|
2593
|
+
Port to listen on the vm
|
|
2594
|
+
"""
|
|
2595
|
+
elif False:
|
|
2596
|
+
GetRuleVmTcpRdpArgsDict: TypeAlias = Mapping[str, Any]
|
|
2597
|
+
|
|
2598
|
+
@pulumi.input_type
|
|
2599
|
+
class GetRuleVmTcpRdpArgs:
|
|
2600
|
+
def __init__(__self__, *,
|
|
2601
|
+
connect_on: Optional[int] = None,
|
|
2602
|
+
port: Optional[int] = None):
|
|
2603
|
+
"""
|
|
2604
|
+
:param int connect_on: Port to listen on the proxy
|
|
2605
|
+
:param int port: Port to listen on the vm
|
|
2606
|
+
"""
|
|
2607
|
+
if connect_on is not None:
|
|
2608
|
+
pulumi.set(__self__, "connect_on", connect_on)
|
|
2609
|
+
if port is not None:
|
|
2610
|
+
pulumi.set(__self__, "port", port)
|
|
2611
|
+
|
|
2612
|
+
@property
|
|
2613
|
+
@pulumi.getter(name="connectOn")
|
|
2614
|
+
def connect_on(self) -> Optional[int]:
|
|
2615
|
+
"""
|
|
2616
|
+
Port to listen on the proxy
|
|
2617
|
+
"""
|
|
2618
|
+
return pulumi.get(self, "connect_on")
|
|
2619
|
+
|
|
2620
|
+
@connect_on.setter
|
|
2621
|
+
def connect_on(self, value: Optional[int]):
|
|
2622
|
+
pulumi.set(self, "connect_on", value)
|
|
2623
|
+
|
|
2624
|
+
@property
|
|
2625
|
+
@pulumi.getter
|
|
2626
|
+
def port(self) -> Optional[int]:
|
|
2627
|
+
"""
|
|
2628
|
+
Port to listen on the vm
|
|
2629
|
+
"""
|
|
2630
|
+
return pulumi.get(self, "port")
|
|
2631
|
+
|
|
2632
|
+
@port.setter
|
|
2633
|
+
def port(self, value: Optional[int]):
|
|
2634
|
+
pulumi.set(self, "port", value)
|
|
2635
|
+
|
|
2636
|
+
|
|
2637
|
+
if not MYPY:
|
|
2638
|
+
class GetRuleVmTcpSshArgsDict(TypedDict):
|
|
2639
|
+
connect_on: NotRequired[int]
|
|
2640
|
+
"""
|
|
2641
|
+
Port to listen on the proxy
|
|
2642
|
+
"""
|
|
2643
|
+
port: NotRequired[int]
|
|
2644
|
+
"""
|
|
2645
|
+
Port to listen on the vm
|
|
2646
|
+
"""
|
|
2647
|
+
elif False:
|
|
2648
|
+
GetRuleVmTcpSshArgsDict: TypeAlias = Mapping[str, Any]
|
|
2649
|
+
|
|
2650
|
+
@pulumi.input_type
|
|
2651
|
+
class GetRuleVmTcpSshArgs:
|
|
2652
|
+
def __init__(__self__, *,
|
|
2653
|
+
connect_on: Optional[int] = None,
|
|
2654
|
+
port: Optional[int] = None):
|
|
2655
|
+
"""
|
|
2656
|
+
:param int connect_on: Port to listen on the proxy
|
|
2657
|
+
:param int port: Port to listen on the vm
|
|
2658
|
+
"""
|
|
2659
|
+
if connect_on is not None:
|
|
2660
|
+
pulumi.set(__self__, "connect_on", connect_on)
|
|
2661
|
+
if port is not None:
|
|
2662
|
+
pulumi.set(__self__, "port", port)
|
|
2663
|
+
|
|
2664
|
+
@property
|
|
2665
|
+
@pulumi.getter(name="connectOn")
|
|
2666
|
+
def connect_on(self) -> Optional[int]:
|
|
2667
|
+
"""
|
|
2668
|
+
Port to listen on the proxy
|
|
2669
|
+
"""
|
|
2670
|
+
return pulumi.get(self, "connect_on")
|
|
2671
|
+
|
|
2672
|
+
@connect_on.setter
|
|
2673
|
+
def connect_on(self, value: Optional[int]):
|
|
2674
|
+
pulumi.set(self, "connect_on", value)
|
|
2675
|
+
|
|
2676
|
+
@property
|
|
2677
|
+
@pulumi.getter
|
|
2678
|
+
def port(self) -> Optional[int]:
|
|
2679
|
+
"""
|
|
2680
|
+
Port to listen on the vm
|
|
2681
|
+
"""
|
|
2682
|
+
return pulumi.get(self, "port")
|
|
2683
|
+
|
|
2684
|
+
@port.setter
|
|
2685
|
+
def port(self, value: Optional[int]):
|
|
2686
|
+
pulumi.set(self, "port", value)
|
|
2687
|
+
|
|
2688
|
+
|