pulumi-sdwan 0.2.0a1726034734__py3-none-any.whl → 0.2.0a1726207515__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-sdwan might be problematic. Click here for more details.
- pulumi_sdwan/__init__.py +520 -129
- pulumi_sdwan/_inputs.py +19584 -8750
- pulumi_sdwan/{application_priority_qos_policy_profile_parcel.py → application_priority_qos_policy.py} +52 -52
- pulumi_sdwan/{cli_config_profile_parcel.py → cli_config_feature.py} +36 -36
- pulumi_sdwan/custom_control_topology_policy_definition.py +18 -19
- pulumi_sdwan/dns_security_policy_definition.py +2 -2
- pulumi_sdwan/{get_application_priority_qos_policy_profile_parcel.py → get_application_priority_qos_policy.py} +28 -28
- pulumi_sdwan/{get_cli_config_profile_parcel.py → get_cli_config_feature.py} +23 -23
- pulumi_sdwan/get_device.py +2 -2
- pulumi_sdwan/get_other_feature_profile.py +117 -0
- pulumi_sdwan/get_other_thousandeyes_feature.py +164 -0
- pulumi_sdwan/get_other_ucse_feature.py +327 -0
- pulumi_sdwan/get_policy_object_class_map.py +164 -0
- pulumi_sdwan/get_policy_object_color_list.py +164 -0
- pulumi_sdwan/get_policy_object_data_ipv4_prefix_list.py +164 -0
- pulumi_sdwan/get_policy_object_data_ipv6_prefix_list.py +164 -0
- pulumi_sdwan/get_policy_object_expanded_community_list.py +176 -0
- pulumi_sdwan/get_policy_object_extended_community_list.py +164 -0
- pulumi_sdwan/get_policy_object_feature_profile.py +90 -0
- pulumi_sdwan/get_policy_object_ipv4_prefix_list.py +164 -0
- pulumi_sdwan/get_policy_object_ipv6_prefix_list.py +164 -0
- pulumi_sdwan/get_policy_object_mirror.py +164 -0
- pulumi_sdwan/get_policy_object_policer.py +164 -0
- pulumi_sdwan/get_policy_object_tloc_list.py +164 -0
- pulumi_sdwan/{get_service_lan_vpn_profile_parcel.py → get_service_lan_vpn_feature.py} +47 -47
- pulumi_sdwan/{get_service_lan_vpn_interface_ethernet_profile_parcel.py → get_service_lan_vpn_interface_ethernet_feature.py} +75 -75
- pulumi_sdwan/get_service_lan_vpn_interface_gre_feature.py +528 -0
- pulumi_sdwan/get_service_lan_vpn_interface_ipsec_feature.py +919 -0
- pulumi_sdwan/get_service_lan_vpn_interface_svi_feature.py +613 -0
- pulumi_sdwan/get_service_object_tracker_feature.py +293 -0
- pulumi_sdwan/get_service_object_tracker_group_feature.py +216 -0
- pulumi_sdwan/get_service_route_policy_feature.py +177 -0
- pulumi_sdwan/get_service_routing_bgp_feature.py +795 -0
- pulumi_sdwan/get_service_routing_ospf_feature.py +525 -0
- pulumi_sdwan/get_service_routing_ospfv3_ipv4_feature.py +603 -0
- pulumi_sdwan/get_service_routing_ospfv3_ipv6_feature.py +603 -0
- pulumi_sdwan/get_service_switchport_feature.py +203 -0
- pulumi_sdwan/{get_service_tracker_profile_parcel.py → get_service_tracker_feature.py} +27 -27
- pulumi_sdwan/get_service_tracker_group_feature.py +190 -0
- pulumi_sdwan/{get_system_aaa_profile_parcel.py → get_system_aaa_feature.py} +32 -32
- pulumi_sdwan/{get_system_banner_profile_parcel.py → get_system_banner_feature.py} +27 -27
- pulumi_sdwan/{get_system_basic_profile_parcel.py → get_system_basic_feature.py} +35 -35
- pulumi_sdwan/{get_system_bfd_profile_parcel.py → get_system_bfd_feature.py} +28 -28
- pulumi_sdwan/{get_system_flexible_port_speed_profile_parcel.py → get_system_flexible_port_speed_feature.py} +27 -27
- pulumi_sdwan/{get_system_global_profile_parcel.py → get_system_global_feature.py} +27 -27
- pulumi_sdwan/get_system_ipv4_device_access_feature.py +177 -0
- pulumi_sdwan/get_system_ipv6_device_access_feature.py +177 -0
- pulumi_sdwan/{get_system_logging_profile_parcel.py → get_system_logging_feature.py} +30 -30
- pulumi_sdwan/{get_system_mrf_profile_parcel.py → get_system_mrf_feature.py} +27 -27
- pulumi_sdwan/{get_system_ntp_profile_parcel.py → get_system_ntp_feature.py} +29 -29
- pulumi_sdwan/{get_system_omp_profile_parcel.py → get_system_omp_feature.py} +27 -27
- pulumi_sdwan/{get_system_performance_monitoring_profile_parcel.py → get_system_performance_monitoring_feature.py} +27 -27
- pulumi_sdwan/{get_system_remote_access_profile_parcel.py → get_system_remote_access_feature.py} +76 -122
- pulumi_sdwan/{get_system_security_profile_parcel.py → get_system_security_feature.py} +29 -29
- pulumi_sdwan/{get_system_snmp_profile_parcel.py → get_system_snmp_feature.py} +32 -32
- pulumi_sdwan/get_transport_gps_feature.py +306 -0
- pulumi_sdwan/{get_transport_ipv6_tracker_profile_parcel.py → get_transport_ipv6_tracker_feature.py} +27 -27
- pulumi_sdwan/get_transport_ipv6_tracker_group_feature.py +216 -0
- pulumi_sdwan/{get_transport_management_vpn_profile_parcel.py → get_transport_management_vpn_feature.py} +59 -59
- pulumi_sdwan/{get_transport_management_vpn_interface_ethernet_profile_parcel.py → get_transport_management_vpn_interface_ethernet_feature.py} +69 -69
- pulumi_sdwan/get_transport_route_policy_feature.py +177 -0
- pulumi_sdwan/{get_transport_routing_bgp_profile_parcel.py → get_transport_routing_bgp_feature.py} +36 -36
- pulumi_sdwan/get_transport_routing_ospf_feature.py +525 -0
- pulumi_sdwan/get_transport_routing_ospfv3_ipv4_feature.py +603 -0
- pulumi_sdwan/get_transport_routing_ospfv3_ipv6_feature.py +603 -0
- pulumi_sdwan/get_transport_tracker_feature.py +384 -0
- pulumi_sdwan/get_transport_tracker_group_feature.py +190 -0
- pulumi_sdwan/{get_transport_wan_vpn_profile_parcel.py → get_transport_wan_vpn_feature.py} +32 -32
- pulumi_sdwan/get_transport_wan_vpn_interface_cellular_feature.py +1774 -0
- pulumi_sdwan/{get_transport_wan_vpn_interface_ethernet_profile_parcel.py → get_transport_wan_vpn_interface_ethernet_feature.py} +133 -133
- pulumi_sdwan/get_transport_wan_vpn_interface_gre_feature.py +528 -0
- pulumi_sdwan/get_transport_wan_vpn_interface_ipsec_feature.py +919 -0
- pulumi_sdwan/get_transport_wan_vpn_interface_t1_e1_serial_feature.py +1465 -0
- pulumi_sdwan/get_zone_based_firewall_policy_definition.py +177 -0
- pulumi_sdwan/other_feature_profile.py +227 -0
- pulumi_sdwan/other_thousandeyes_feature.py +331 -0
- pulumi_sdwan/other_ucse_feature.py +948 -0
- pulumi_sdwan/outputs.py +46733 -29015
- pulumi_sdwan/policy_object_class_map.py +362 -0
- pulumi_sdwan/policy_object_color_list.py +362 -0
- pulumi_sdwan/policy_object_data_ipv4_prefix_list.py +332 -0
- pulumi_sdwan/policy_object_data_ipv6_prefix_list.py +332 -0
- pulumi_sdwan/policy_object_expanded_community_list.py +403 -0
- pulumi_sdwan/policy_object_extended_community_list.py +332 -0
- pulumi_sdwan/policy_object_feature_profile.py +227 -0
- pulumi_sdwan/policy_object_ipv4_prefix_list.py +332 -0
- pulumi_sdwan/policy_object_ipv6_prefix_list.py +332 -0
- pulumi_sdwan/policy_object_mirror.py +332 -0
- pulumi_sdwan/policy_object_policer.py +332 -0
- pulumi_sdwan/policy_object_tloc_list.py +332 -0
- pulumi_sdwan/pulumi-plugin.json +1 -1
- pulumi_sdwan/security_policy.py +8 -8
- pulumi_sdwan/{service_lan_vpn_profile_parcel.py → service_lan_vpn_feature.py} +298 -298
- pulumi_sdwan/{service_lan_vpn_interface_ethernet_profile_parcel.py → service_lan_vpn_interface_ethernet_feature.py} +264 -264
- pulumi_sdwan/service_lan_vpn_interface_gre_feature.py +1712 -0
- pulumi_sdwan/service_lan_vpn_interface_ipsec_feature.py +3269 -0
- pulumi_sdwan/service_lan_vpn_interface_svi_feature.py +1960 -0
- pulumi_sdwan/service_object_tracker_feature.py +858 -0
- pulumi_sdwan/service_object_tracker_group_feature.py +519 -0
- pulumi_sdwan/service_route_policy_feature.py +378 -0
- pulumi_sdwan/service_routing_bgp_feature.py +2614 -0
- pulumi_sdwan/service_routing_ospf_feature.py +1634 -0
- pulumi_sdwan/service_routing_ospfv3_ipv4_feature.py +1916 -0
- pulumi_sdwan/service_routing_ospfv3_ipv6_feature.py +1916 -0
- pulumi_sdwan/service_switchport_feature.py +472 -0
- pulumi_sdwan/{service_tracker_profile_parcel.py → service_tracker_feature.py} +57 -58
- pulumi_sdwan/service_tracker_group_feature.py +425 -0
- pulumi_sdwan/{system_aaa_profile_parcel.py → system_aaa_feature.py} +108 -108
- pulumi_sdwan/{system_banner_profile_parcel.py → system_banner_feature.py} +40 -40
- pulumi_sdwan/{system_basic_profile_parcel.py → system_basic_feature.py} +94 -94
- pulumi_sdwan/{system_bfd_profile_parcel.py → system_bfd_feature.py} +52 -52
- pulumi_sdwan/{system_flexible_port_speed_profile_parcel.py → system_flexible_port_speed_feature.py} +40 -40
- pulumi_sdwan/{system_global_profile_parcel.py → system_global_feature.py} +40 -40
- pulumi_sdwan/system_ipv4_device_access_feature.py +378 -0
- pulumi_sdwan/system_ipv6_device_access_feature.py +378 -0
- pulumi_sdwan/{system_logging_profile_parcel.py → system_logging_feature.py} +80 -80
- pulumi_sdwan/{system_mrf_profile_parcel.py → system_mrf_feature.py} +40 -40
- pulumi_sdwan/{system_ntp_profile_parcel.py → system_ntp_feature.py} +66 -66
- pulumi_sdwan/{system_omp_profile_parcel.py → system_omp_feature.py} +40 -40
- pulumi_sdwan/{system_performance_monitoring_profile_parcel.py → system_performance_monitoring_feature.py} +40 -40
- pulumi_sdwan/{system_remote_access_profile_parcel.py → system_remote_access_feature.py} +368 -470
- pulumi_sdwan/{system_security_profile_parcel.py → system_security_feature.py} +66 -66
- pulumi_sdwan/{system_snmp_profile_parcel.py → system_snmp_feature.py} +107 -107
- pulumi_sdwan/transport_gps_feature.py +882 -0
- pulumi_sdwan/{transport_ipv6_tracker_profile_parcel.py → transport_ipv6_tracker_feature.py} +57 -58
- pulumi_sdwan/transport_ipv6_tracker_group_feature.py +520 -0
- pulumi_sdwan/{transport_management_vpn_profile_parcel.py → transport_management_vpn_feature.py} +172 -172
- pulumi_sdwan/{transport_management_vpn_interface_ethernet_profile_parcel.py → transport_management_vpn_interface_ethernet_feature.py} +193 -194
- pulumi_sdwan/transport_route_policy_feature.py +378 -0
- pulumi_sdwan/{transport_routing_bgp_profile_parcel.py → transport_routing_bgp_feature.py} +181 -182
- pulumi_sdwan/transport_routing_ospf_feature.py +1634 -0
- pulumi_sdwan/transport_routing_ospfv3_ipv4_feature.py +1916 -0
- pulumi_sdwan/transport_routing_ospfv3_ipv6_feature.py +1916 -0
- pulumi_sdwan/transport_tracker_feature.py +1170 -0
- pulumi_sdwan/transport_tracker_group_feature.py +425 -0
- pulumi_sdwan/{transport_wan_vpn_profile_parcel.py → transport_wan_vpn_feature.py} +104 -104
- pulumi_sdwan/transport_wan_vpn_interface_cellular_feature.py +6168 -0
- pulumi_sdwan/{transport_wan_vpn_interface_ethernet_profile_parcel.py → transport_wan_vpn_interface_ethernet_feature.py} +483 -483
- pulumi_sdwan/transport_wan_vpn_interface_gre_feature.py +1708 -0
- pulumi_sdwan/transport_wan_vpn_interface_ipsec_feature.py +3259 -0
- pulumi_sdwan/transport_wan_vpn_interface_t1_e1_serial_feature.py +5215 -0
- pulumi_sdwan/zone_based_firewall_policy_definition.py +401 -0
- {pulumi_sdwan-0.2.0a1726034734.dist-info → pulumi_sdwan-0.2.0a1726207515.dist-info}/METADATA +1 -1
- {pulumi_sdwan-0.2.0a1726034734.dist-info → pulumi_sdwan-0.2.0a1726207515.dist-info}/RECORD +146 -67
- pulumi_sdwan/configuration_group_deploy.py +0 -224
- pulumi_sdwan/configuration_group_device_variables.py +0 -293
- pulumi_sdwan/configuration_group_devices.py +0 -236
- pulumi_sdwan/get_configuration_group_device_variables.py +0 -144
- pulumi_sdwan/get_configuration_group_devices.py +0 -118
- {pulumi_sdwan-0.2.0a1726034734.dist-info → pulumi_sdwan-0.2.0a1726207515.dist-info}/WHEEL +0 -0
- {pulumi_sdwan-0.2.0a1726034734.dist-info → pulumi_sdwan-0.2.0a1726207515.dist-info}/top_level.txt +0 -0
|
@@ -0,0 +1,2614 @@
|
|
|
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 pulumi
|
|
8
|
+
import pulumi.runtime
|
|
9
|
+
from typing import Any, Mapping, Optional, Sequence, Union, overload
|
|
10
|
+
from . import _utilities
|
|
11
|
+
from . import outputs
|
|
12
|
+
from ._inputs import *
|
|
13
|
+
|
|
14
|
+
__all__ = ['ServiceRoutingBgpFeatureArgs', 'ServiceRoutingBgpFeature']
|
|
15
|
+
|
|
16
|
+
@pulumi.input_type
|
|
17
|
+
class ServiceRoutingBgpFeatureArgs:
|
|
18
|
+
def __init__(__self__, *,
|
|
19
|
+
always_compare_med: Optional[pulumi.Input[bool]] = None,
|
|
20
|
+
always_compare_med_variable: Optional[pulumi.Input[str]] = None,
|
|
21
|
+
as_number: Optional[pulumi.Input[int]] = None,
|
|
22
|
+
as_number_variable: Optional[pulumi.Input[str]] = None,
|
|
23
|
+
compare_router_id: Optional[pulumi.Input[bool]] = None,
|
|
24
|
+
compare_router_id_variable: Optional[pulumi.Input[str]] = None,
|
|
25
|
+
description: Optional[pulumi.Input[str]] = None,
|
|
26
|
+
deterministic_med: Optional[pulumi.Input[bool]] = None,
|
|
27
|
+
deterministic_med_variable: Optional[pulumi.Input[str]] = None,
|
|
28
|
+
external_routes_distance: Optional[pulumi.Input[int]] = None,
|
|
29
|
+
external_routes_distance_variable: Optional[pulumi.Input[str]] = None,
|
|
30
|
+
feature_profile_id: Optional[pulumi.Input[str]] = None,
|
|
31
|
+
hold_time: Optional[pulumi.Input[int]] = None,
|
|
32
|
+
hold_time_variable: Optional[pulumi.Input[str]] = None,
|
|
33
|
+
internal_routes_distance: Optional[pulumi.Input[int]] = None,
|
|
34
|
+
internal_routes_distance_variable: Optional[pulumi.Input[str]] = None,
|
|
35
|
+
ipv4_aggregate_addresses: Optional[pulumi.Input[Sequence[pulumi.Input['ServiceRoutingBgpFeatureIpv4AggregateAddressArgs']]]] = None,
|
|
36
|
+
ipv4_eibgp_maximum_paths: Optional[pulumi.Input[int]] = None,
|
|
37
|
+
ipv4_eibgp_maximum_paths_variable: Optional[pulumi.Input[str]] = None,
|
|
38
|
+
ipv4_neighbors: Optional[pulumi.Input[Sequence[pulumi.Input['ServiceRoutingBgpFeatureIpv4NeighborArgs']]]] = None,
|
|
39
|
+
ipv4_networks: Optional[pulumi.Input[Sequence[pulumi.Input['ServiceRoutingBgpFeatureIpv4NetworkArgs']]]] = None,
|
|
40
|
+
ipv4_originate: Optional[pulumi.Input[bool]] = None,
|
|
41
|
+
ipv4_originate_variable: Optional[pulumi.Input[str]] = None,
|
|
42
|
+
ipv4_redistributes: Optional[pulumi.Input[Sequence[pulumi.Input['ServiceRoutingBgpFeatureIpv4RedistributeArgs']]]] = None,
|
|
43
|
+
ipv4_table_map_filter: Optional[pulumi.Input[bool]] = None,
|
|
44
|
+
ipv4_table_map_filter_variable: Optional[pulumi.Input[str]] = None,
|
|
45
|
+
ipv4_table_map_route_policy_id: Optional[pulumi.Input[str]] = None,
|
|
46
|
+
ipv6_aggregate_addresses: Optional[pulumi.Input[Sequence[pulumi.Input['ServiceRoutingBgpFeatureIpv6AggregateAddressArgs']]]] = None,
|
|
47
|
+
ipv6_eibgp_maximum_paths: Optional[pulumi.Input[int]] = None,
|
|
48
|
+
ipv6_eibgp_maximum_paths_variable: Optional[pulumi.Input[str]] = None,
|
|
49
|
+
ipv6_neighbors: Optional[pulumi.Input[Sequence[pulumi.Input['ServiceRoutingBgpFeatureIpv6NeighborArgs']]]] = None,
|
|
50
|
+
ipv6_networks: Optional[pulumi.Input[Sequence[pulumi.Input['ServiceRoutingBgpFeatureIpv6NetworkArgs']]]] = None,
|
|
51
|
+
ipv6_originate: Optional[pulumi.Input[bool]] = None,
|
|
52
|
+
ipv6_originate_variable: Optional[pulumi.Input[str]] = None,
|
|
53
|
+
ipv6_redistributes: Optional[pulumi.Input[Sequence[pulumi.Input['ServiceRoutingBgpFeatureIpv6RedistributeArgs']]]] = None,
|
|
54
|
+
ipv6_table_map_filter: Optional[pulumi.Input[bool]] = None,
|
|
55
|
+
ipv6_table_map_filter_variable: Optional[pulumi.Input[str]] = None,
|
|
56
|
+
ipv6_table_map_route_policy_id: Optional[pulumi.Input[str]] = None,
|
|
57
|
+
keepalive_time: Optional[pulumi.Input[int]] = None,
|
|
58
|
+
keepalive_time_variable: Optional[pulumi.Input[str]] = None,
|
|
59
|
+
local_routes_distance: Optional[pulumi.Input[int]] = None,
|
|
60
|
+
local_routes_distance_variable: Optional[pulumi.Input[str]] = None,
|
|
61
|
+
missing_med_as_worst: Optional[pulumi.Input[bool]] = None,
|
|
62
|
+
missing_med_as_worst_variable: Optional[pulumi.Input[str]] = None,
|
|
63
|
+
multipath_relax: Optional[pulumi.Input[bool]] = None,
|
|
64
|
+
multipath_relax_variable: Optional[pulumi.Input[str]] = None,
|
|
65
|
+
name: Optional[pulumi.Input[str]] = None,
|
|
66
|
+
propagate_as_path: Optional[pulumi.Input[bool]] = None,
|
|
67
|
+
propagate_as_path_variable: Optional[pulumi.Input[str]] = None,
|
|
68
|
+
propagate_community: Optional[pulumi.Input[bool]] = None,
|
|
69
|
+
propagate_community_variable: Optional[pulumi.Input[str]] = None,
|
|
70
|
+
router_id: Optional[pulumi.Input[str]] = None,
|
|
71
|
+
router_id_variable: Optional[pulumi.Input[str]] = None):
|
|
72
|
+
"""
|
|
73
|
+
The set of arguments for constructing a ServiceRoutingBgpFeature resource.
|
|
74
|
+
:param pulumi.Input[bool] always_compare_med: Compare MEDs from all ASs when selecting active BGP paths - Default value: `false`
|
|
75
|
+
:param pulumi.Input[str] always_compare_med_variable: Variable name
|
|
76
|
+
:param pulumi.Input[int] as_number: Set autonomous system number <1..4294967295> or <XX.YY>
|
|
77
|
+
:param pulumi.Input[str] as_number_variable: Variable name
|
|
78
|
+
:param pulumi.Input[bool] compare_router_id: Compare router IDs when selecting active BGP paths - Default value: `false`
|
|
79
|
+
:param pulumi.Input[str] compare_router_id_variable: Variable name
|
|
80
|
+
:param pulumi.Input[str] description: The description of the Feature
|
|
81
|
+
:param pulumi.Input[bool] deterministic_med: Compare MEDs from all routes from same AS when selecting active BGP paths - Default value: `false`
|
|
82
|
+
:param pulumi.Input[str] deterministic_med_variable: Variable name
|
|
83
|
+
:param pulumi.Input[int] external_routes_distance: Set administrative distance for external BGP routes - Range: `1`-`255` - Default value: `20`
|
|
84
|
+
:param pulumi.Input[str] external_routes_distance_variable: Variable name
|
|
85
|
+
:param pulumi.Input[str] feature_profile_id: Feature Profile ID
|
|
86
|
+
:param pulumi.Input[int] hold_time: Interval (seconds) not receiving a keepalive message declares a BGP peer down - Range: `0`-`65535` - Default value:
|
|
87
|
+
`180`
|
|
88
|
+
:param pulumi.Input[str] hold_time_variable: Variable name
|
|
89
|
+
:param pulumi.Input[int] internal_routes_distance: Set administrative distance for internal BGP routes - Range: `1`-`255` - Default value: `200`
|
|
90
|
+
:param pulumi.Input[str] internal_routes_distance_variable: Variable name
|
|
91
|
+
:param pulumi.Input[Sequence[pulumi.Input['ServiceRoutingBgpFeatureIpv4AggregateAddressArgs']]] ipv4_aggregate_addresses: Aggregate prefixes in specific range
|
|
92
|
+
:param pulumi.Input[int] ipv4_eibgp_maximum_paths: Set maximum number of parallel IBGP paths for multipath load sharing - Range: `1`-`32`
|
|
93
|
+
:param pulumi.Input[str] ipv4_eibgp_maximum_paths_variable: Variable name
|
|
94
|
+
:param pulumi.Input[Sequence[pulumi.Input['ServiceRoutingBgpFeatureIpv4NeighborArgs']]] ipv4_neighbors: Set BGP IPv4 neighbors
|
|
95
|
+
:param pulumi.Input[Sequence[pulumi.Input['ServiceRoutingBgpFeatureIpv4NetworkArgs']]] ipv4_networks: Configure the networks for BGP to advertise
|
|
96
|
+
:param pulumi.Input[bool] ipv4_originate: BGP Default Information Originate - Default value: `false`
|
|
97
|
+
:param pulumi.Input[str] ipv4_originate_variable: Variable name
|
|
98
|
+
:param pulumi.Input[Sequence[pulumi.Input['ServiceRoutingBgpFeatureIpv4RedistributeArgs']]] ipv4_redistributes: Redistribute routes into BGP
|
|
99
|
+
:param pulumi.Input[bool] ipv4_table_map_filter: Table map filtered or not - Default value: `false`
|
|
100
|
+
:param pulumi.Input[str] ipv4_table_map_filter_variable: Variable name
|
|
101
|
+
:param pulumi.Input[Sequence[pulumi.Input['ServiceRoutingBgpFeatureIpv6AggregateAddressArgs']]] ipv6_aggregate_addresses: IPv6 Aggregate prefixes in specific range
|
|
102
|
+
:param pulumi.Input[int] ipv6_eibgp_maximum_paths: Set maximum number of parallel IBGP paths for multipath load sharing - Range: `1`-`32`
|
|
103
|
+
:param pulumi.Input[str] ipv6_eibgp_maximum_paths_variable: Variable name
|
|
104
|
+
:param pulumi.Input[Sequence[pulumi.Input['ServiceRoutingBgpFeatureIpv6NeighborArgs']]] ipv6_neighbors: Set BGP IPv6 neighbors
|
|
105
|
+
:param pulumi.Input[Sequence[pulumi.Input['ServiceRoutingBgpFeatureIpv6NetworkArgs']]] ipv6_networks: Configure the networks for BGP to advertise
|
|
106
|
+
:param pulumi.Input[bool] ipv6_originate: BGP Default Information Originate - Default value: `false`
|
|
107
|
+
:param pulumi.Input[str] ipv6_originate_variable: Variable name
|
|
108
|
+
:param pulumi.Input[Sequence[pulumi.Input['ServiceRoutingBgpFeatureIpv6RedistributeArgs']]] ipv6_redistributes: Redistribute routes into BGP
|
|
109
|
+
:param pulumi.Input[bool] ipv6_table_map_filter: Table map filtered or not - Default value: `false`
|
|
110
|
+
:param pulumi.Input[str] ipv6_table_map_filter_variable: Variable name
|
|
111
|
+
:param pulumi.Input[int] keepalive_time: Interval (seconds) of keepalive messages sent to its BGP peer - Range: `0`-`65535` - Default value: `60`
|
|
112
|
+
:param pulumi.Input[str] keepalive_time_variable: Variable name
|
|
113
|
+
:param pulumi.Input[int] local_routes_distance: Set administrative distance for local BGP routes - Range: `1`-`255` - Default value: `20`
|
|
114
|
+
:param pulumi.Input[str] local_routes_distance_variable: Variable name
|
|
115
|
+
:param pulumi.Input[bool] missing_med_as_worst: If path has no MED, consider it to be worst path when selecting active BGP paths - Default value: `false`
|
|
116
|
+
:param pulumi.Input[str] missing_med_as_worst_variable: Variable name
|
|
117
|
+
:param pulumi.Input[bool] multipath_relax: Ignore AS for multipath selection - Default value: `false`
|
|
118
|
+
:param pulumi.Input[str] multipath_relax_variable: Variable name
|
|
119
|
+
:param pulumi.Input[str] name: The name of the Feature
|
|
120
|
+
:param pulumi.Input[bool] propagate_as_path: Propagate AS Path - Default value: `false`
|
|
121
|
+
:param pulumi.Input[str] propagate_as_path_variable: Variable name
|
|
122
|
+
:param pulumi.Input[bool] propagate_community: Propagate Community - Default value: `false`
|
|
123
|
+
:param pulumi.Input[str] propagate_community_variable: Variable name
|
|
124
|
+
:param pulumi.Input[str] router_id: Configure BGP router identifier
|
|
125
|
+
:param pulumi.Input[str] router_id_variable: Variable name
|
|
126
|
+
"""
|
|
127
|
+
if always_compare_med is not None:
|
|
128
|
+
pulumi.set(__self__, "always_compare_med", always_compare_med)
|
|
129
|
+
if always_compare_med_variable is not None:
|
|
130
|
+
pulumi.set(__self__, "always_compare_med_variable", always_compare_med_variable)
|
|
131
|
+
if as_number is not None:
|
|
132
|
+
pulumi.set(__self__, "as_number", as_number)
|
|
133
|
+
if as_number_variable is not None:
|
|
134
|
+
pulumi.set(__self__, "as_number_variable", as_number_variable)
|
|
135
|
+
if compare_router_id is not None:
|
|
136
|
+
pulumi.set(__self__, "compare_router_id", compare_router_id)
|
|
137
|
+
if compare_router_id_variable is not None:
|
|
138
|
+
pulumi.set(__self__, "compare_router_id_variable", compare_router_id_variable)
|
|
139
|
+
if description is not None:
|
|
140
|
+
pulumi.set(__self__, "description", description)
|
|
141
|
+
if deterministic_med is not None:
|
|
142
|
+
pulumi.set(__self__, "deterministic_med", deterministic_med)
|
|
143
|
+
if deterministic_med_variable is not None:
|
|
144
|
+
pulumi.set(__self__, "deterministic_med_variable", deterministic_med_variable)
|
|
145
|
+
if external_routes_distance is not None:
|
|
146
|
+
pulumi.set(__self__, "external_routes_distance", external_routes_distance)
|
|
147
|
+
if external_routes_distance_variable is not None:
|
|
148
|
+
pulumi.set(__self__, "external_routes_distance_variable", external_routes_distance_variable)
|
|
149
|
+
if feature_profile_id is not None:
|
|
150
|
+
pulumi.set(__self__, "feature_profile_id", feature_profile_id)
|
|
151
|
+
if hold_time is not None:
|
|
152
|
+
pulumi.set(__self__, "hold_time", hold_time)
|
|
153
|
+
if hold_time_variable is not None:
|
|
154
|
+
pulumi.set(__self__, "hold_time_variable", hold_time_variable)
|
|
155
|
+
if internal_routes_distance is not None:
|
|
156
|
+
pulumi.set(__self__, "internal_routes_distance", internal_routes_distance)
|
|
157
|
+
if internal_routes_distance_variable is not None:
|
|
158
|
+
pulumi.set(__self__, "internal_routes_distance_variable", internal_routes_distance_variable)
|
|
159
|
+
if ipv4_aggregate_addresses is not None:
|
|
160
|
+
pulumi.set(__self__, "ipv4_aggregate_addresses", ipv4_aggregate_addresses)
|
|
161
|
+
if ipv4_eibgp_maximum_paths is not None:
|
|
162
|
+
pulumi.set(__self__, "ipv4_eibgp_maximum_paths", ipv4_eibgp_maximum_paths)
|
|
163
|
+
if ipv4_eibgp_maximum_paths_variable is not None:
|
|
164
|
+
pulumi.set(__self__, "ipv4_eibgp_maximum_paths_variable", ipv4_eibgp_maximum_paths_variable)
|
|
165
|
+
if ipv4_neighbors is not None:
|
|
166
|
+
pulumi.set(__self__, "ipv4_neighbors", ipv4_neighbors)
|
|
167
|
+
if ipv4_networks is not None:
|
|
168
|
+
pulumi.set(__self__, "ipv4_networks", ipv4_networks)
|
|
169
|
+
if ipv4_originate is not None:
|
|
170
|
+
pulumi.set(__self__, "ipv4_originate", ipv4_originate)
|
|
171
|
+
if ipv4_originate_variable is not None:
|
|
172
|
+
pulumi.set(__self__, "ipv4_originate_variable", ipv4_originate_variable)
|
|
173
|
+
if ipv4_redistributes is not None:
|
|
174
|
+
pulumi.set(__self__, "ipv4_redistributes", ipv4_redistributes)
|
|
175
|
+
if ipv4_table_map_filter is not None:
|
|
176
|
+
pulumi.set(__self__, "ipv4_table_map_filter", ipv4_table_map_filter)
|
|
177
|
+
if ipv4_table_map_filter_variable is not None:
|
|
178
|
+
pulumi.set(__self__, "ipv4_table_map_filter_variable", ipv4_table_map_filter_variable)
|
|
179
|
+
if ipv4_table_map_route_policy_id is not None:
|
|
180
|
+
pulumi.set(__self__, "ipv4_table_map_route_policy_id", ipv4_table_map_route_policy_id)
|
|
181
|
+
if ipv6_aggregate_addresses is not None:
|
|
182
|
+
pulumi.set(__self__, "ipv6_aggregate_addresses", ipv6_aggregate_addresses)
|
|
183
|
+
if ipv6_eibgp_maximum_paths is not None:
|
|
184
|
+
pulumi.set(__self__, "ipv6_eibgp_maximum_paths", ipv6_eibgp_maximum_paths)
|
|
185
|
+
if ipv6_eibgp_maximum_paths_variable is not None:
|
|
186
|
+
pulumi.set(__self__, "ipv6_eibgp_maximum_paths_variable", ipv6_eibgp_maximum_paths_variable)
|
|
187
|
+
if ipv6_neighbors is not None:
|
|
188
|
+
pulumi.set(__self__, "ipv6_neighbors", ipv6_neighbors)
|
|
189
|
+
if ipv6_networks is not None:
|
|
190
|
+
pulumi.set(__self__, "ipv6_networks", ipv6_networks)
|
|
191
|
+
if ipv6_originate is not None:
|
|
192
|
+
pulumi.set(__self__, "ipv6_originate", ipv6_originate)
|
|
193
|
+
if ipv6_originate_variable is not None:
|
|
194
|
+
pulumi.set(__self__, "ipv6_originate_variable", ipv6_originate_variable)
|
|
195
|
+
if ipv6_redistributes is not None:
|
|
196
|
+
pulumi.set(__self__, "ipv6_redistributes", ipv6_redistributes)
|
|
197
|
+
if ipv6_table_map_filter is not None:
|
|
198
|
+
pulumi.set(__self__, "ipv6_table_map_filter", ipv6_table_map_filter)
|
|
199
|
+
if ipv6_table_map_filter_variable is not None:
|
|
200
|
+
pulumi.set(__self__, "ipv6_table_map_filter_variable", ipv6_table_map_filter_variable)
|
|
201
|
+
if ipv6_table_map_route_policy_id is not None:
|
|
202
|
+
pulumi.set(__self__, "ipv6_table_map_route_policy_id", ipv6_table_map_route_policy_id)
|
|
203
|
+
if keepalive_time is not None:
|
|
204
|
+
pulumi.set(__self__, "keepalive_time", keepalive_time)
|
|
205
|
+
if keepalive_time_variable is not None:
|
|
206
|
+
pulumi.set(__self__, "keepalive_time_variable", keepalive_time_variable)
|
|
207
|
+
if local_routes_distance is not None:
|
|
208
|
+
pulumi.set(__self__, "local_routes_distance", local_routes_distance)
|
|
209
|
+
if local_routes_distance_variable is not None:
|
|
210
|
+
pulumi.set(__self__, "local_routes_distance_variable", local_routes_distance_variable)
|
|
211
|
+
if missing_med_as_worst is not None:
|
|
212
|
+
pulumi.set(__self__, "missing_med_as_worst", missing_med_as_worst)
|
|
213
|
+
if missing_med_as_worst_variable is not None:
|
|
214
|
+
pulumi.set(__self__, "missing_med_as_worst_variable", missing_med_as_worst_variable)
|
|
215
|
+
if multipath_relax is not None:
|
|
216
|
+
pulumi.set(__self__, "multipath_relax", multipath_relax)
|
|
217
|
+
if multipath_relax_variable is not None:
|
|
218
|
+
pulumi.set(__self__, "multipath_relax_variable", multipath_relax_variable)
|
|
219
|
+
if name is not None:
|
|
220
|
+
pulumi.set(__self__, "name", name)
|
|
221
|
+
if propagate_as_path is not None:
|
|
222
|
+
pulumi.set(__self__, "propagate_as_path", propagate_as_path)
|
|
223
|
+
if propagate_as_path_variable is not None:
|
|
224
|
+
pulumi.set(__self__, "propagate_as_path_variable", propagate_as_path_variable)
|
|
225
|
+
if propagate_community is not None:
|
|
226
|
+
pulumi.set(__self__, "propagate_community", propagate_community)
|
|
227
|
+
if propagate_community_variable is not None:
|
|
228
|
+
pulumi.set(__self__, "propagate_community_variable", propagate_community_variable)
|
|
229
|
+
if router_id is not None:
|
|
230
|
+
pulumi.set(__self__, "router_id", router_id)
|
|
231
|
+
if router_id_variable is not None:
|
|
232
|
+
pulumi.set(__self__, "router_id_variable", router_id_variable)
|
|
233
|
+
|
|
234
|
+
@property
|
|
235
|
+
@pulumi.getter(name="alwaysCompareMed")
|
|
236
|
+
def always_compare_med(self) -> Optional[pulumi.Input[bool]]:
|
|
237
|
+
"""
|
|
238
|
+
Compare MEDs from all ASs when selecting active BGP paths - Default value: `false`
|
|
239
|
+
"""
|
|
240
|
+
return pulumi.get(self, "always_compare_med")
|
|
241
|
+
|
|
242
|
+
@always_compare_med.setter
|
|
243
|
+
def always_compare_med(self, value: Optional[pulumi.Input[bool]]):
|
|
244
|
+
pulumi.set(self, "always_compare_med", value)
|
|
245
|
+
|
|
246
|
+
@property
|
|
247
|
+
@pulumi.getter(name="alwaysCompareMedVariable")
|
|
248
|
+
def always_compare_med_variable(self) -> Optional[pulumi.Input[str]]:
|
|
249
|
+
"""
|
|
250
|
+
Variable name
|
|
251
|
+
"""
|
|
252
|
+
return pulumi.get(self, "always_compare_med_variable")
|
|
253
|
+
|
|
254
|
+
@always_compare_med_variable.setter
|
|
255
|
+
def always_compare_med_variable(self, value: Optional[pulumi.Input[str]]):
|
|
256
|
+
pulumi.set(self, "always_compare_med_variable", value)
|
|
257
|
+
|
|
258
|
+
@property
|
|
259
|
+
@pulumi.getter(name="asNumber")
|
|
260
|
+
def as_number(self) -> Optional[pulumi.Input[int]]:
|
|
261
|
+
"""
|
|
262
|
+
Set autonomous system number <1..4294967295> or <XX.YY>
|
|
263
|
+
"""
|
|
264
|
+
return pulumi.get(self, "as_number")
|
|
265
|
+
|
|
266
|
+
@as_number.setter
|
|
267
|
+
def as_number(self, value: Optional[pulumi.Input[int]]):
|
|
268
|
+
pulumi.set(self, "as_number", value)
|
|
269
|
+
|
|
270
|
+
@property
|
|
271
|
+
@pulumi.getter(name="asNumberVariable")
|
|
272
|
+
def as_number_variable(self) -> Optional[pulumi.Input[str]]:
|
|
273
|
+
"""
|
|
274
|
+
Variable name
|
|
275
|
+
"""
|
|
276
|
+
return pulumi.get(self, "as_number_variable")
|
|
277
|
+
|
|
278
|
+
@as_number_variable.setter
|
|
279
|
+
def as_number_variable(self, value: Optional[pulumi.Input[str]]):
|
|
280
|
+
pulumi.set(self, "as_number_variable", value)
|
|
281
|
+
|
|
282
|
+
@property
|
|
283
|
+
@pulumi.getter(name="compareRouterId")
|
|
284
|
+
def compare_router_id(self) -> Optional[pulumi.Input[bool]]:
|
|
285
|
+
"""
|
|
286
|
+
Compare router IDs when selecting active BGP paths - Default value: `false`
|
|
287
|
+
"""
|
|
288
|
+
return pulumi.get(self, "compare_router_id")
|
|
289
|
+
|
|
290
|
+
@compare_router_id.setter
|
|
291
|
+
def compare_router_id(self, value: Optional[pulumi.Input[bool]]):
|
|
292
|
+
pulumi.set(self, "compare_router_id", value)
|
|
293
|
+
|
|
294
|
+
@property
|
|
295
|
+
@pulumi.getter(name="compareRouterIdVariable")
|
|
296
|
+
def compare_router_id_variable(self) -> Optional[pulumi.Input[str]]:
|
|
297
|
+
"""
|
|
298
|
+
Variable name
|
|
299
|
+
"""
|
|
300
|
+
return pulumi.get(self, "compare_router_id_variable")
|
|
301
|
+
|
|
302
|
+
@compare_router_id_variable.setter
|
|
303
|
+
def compare_router_id_variable(self, value: Optional[pulumi.Input[str]]):
|
|
304
|
+
pulumi.set(self, "compare_router_id_variable", value)
|
|
305
|
+
|
|
306
|
+
@property
|
|
307
|
+
@pulumi.getter
|
|
308
|
+
def description(self) -> Optional[pulumi.Input[str]]:
|
|
309
|
+
"""
|
|
310
|
+
The description of the Feature
|
|
311
|
+
"""
|
|
312
|
+
return pulumi.get(self, "description")
|
|
313
|
+
|
|
314
|
+
@description.setter
|
|
315
|
+
def description(self, value: Optional[pulumi.Input[str]]):
|
|
316
|
+
pulumi.set(self, "description", value)
|
|
317
|
+
|
|
318
|
+
@property
|
|
319
|
+
@pulumi.getter(name="deterministicMed")
|
|
320
|
+
def deterministic_med(self) -> Optional[pulumi.Input[bool]]:
|
|
321
|
+
"""
|
|
322
|
+
Compare MEDs from all routes from same AS when selecting active BGP paths - Default value: `false`
|
|
323
|
+
"""
|
|
324
|
+
return pulumi.get(self, "deterministic_med")
|
|
325
|
+
|
|
326
|
+
@deterministic_med.setter
|
|
327
|
+
def deterministic_med(self, value: Optional[pulumi.Input[bool]]):
|
|
328
|
+
pulumi.set(self, "deterministic_med", value)
|
|
329
|
+
|
|
330
|
+
@property
|
|
331
|
+
@pulumi.getter(name="deterministicMedVariable")
|
|
332
|
+
def deterministic_med_variable(self) -> Optional[pulumi.Input[str]]:
|
|
333
|
+
"""
|
|
334
|
+
Variable name
|
|
335
|
+
"""
|
|
336
|
+
return pulumi.get(self, "deterministic_med_variable")
|
|
337
|
+
|
|
338
|
+
@deterministic_med_variable.setter
|
|
339
|
+
def deterministic_med_variable(self, value: Optional[pulumi.Input[str]]):
|
|
340
|
+
pulumi.set(self, "deterministic_med_variable", value)
|
|
341
|
+
|
|
342
|
+
@property
|
|
343
|
+
@pulumi.getter(name="externalRoutesDistance")
|
|
344
|
+
def external_routes_distance(self) -> Optional[pulumi.Input[int]]:
|
|
345
|
+
"""
|
|
346
|
+
Set administrative distance for external BGP routes - Range: `1`-`255` - Default value: `20`
|
|
347
|
+
"""
|
|
348
|
+
return pulumi.get(self, "external_routes_distance")
|
|
349
|
+
|
|
350
|
+
@external_routes_distance.setter
|
|
351
|
+
def external_routes_distance(self, value: Optional[pulumi.Input[int]]):
|
|
352
|
+
pulumi.set(self, "external_routes_distance", value)
|
|
353
|
+
|
|
354
|
+
@property
|
|
355
|
+
@pulumi.getter(name="externalRoutesDistanceVariable")
|
|
356
|
+
def external_routes_distance_variable(self) -> Optional[pulumi.Input[str]]:
|
|
357
|
+
"""
|
|
358
|
+
Variable name
|
|
359
|
+
"""
|
|
360
|
+
return pulumi.get(self, "external_routes_distance_variable")
|
|
361
|
+
|
|
362
|
+
@external_routes_distance_variable.setter
|
|
363
|
+
def external_routes_distance_variable(self, value: Optional[pulumi.Input[str]]):
|
|
364
|
+
pulumi.set(self, "external_routes_distance_variable", value)
|
|
365
|
+
|
|
366
|
+
@property
|
|
367
|
+
@pulumi.getter(name="featureProfileId")
|
|
368
|
+
def feature_profile_id(self) -> Optional[pulumi.Input[str]]:
|
|
369
|
+
"""
|
|
370
|
+
Feature Profile ID
|
|
371
|
+
"""
|
|
372
|
+
return pulumi.get(self, "feature_profile_id")
|
|
373
|
+
|
|
374
|
+
@feature_profile_id.setter
|
|
375
|
+
def feature_profile_id(self, value: Optional[pulumi.Input[str]]):
|
|
376
|
+
pulumi.set(self, "feature_profile_id", value)
|
|
377
|
+
|
|
378
|
+
@property
|
|
379
|
+
@pulumi.getter(name="holdTime")
|
|
380
|
+
def hold_time(self) -> Optional[pulumi.Input[int]]:
|
|
381
|
+
"""
|
|
382
|
+
Interval (seconds) not receiving a keepalive message declares a BGP peer down - Range: `0`-`65535` - Default value:
|
|
383
|
+
`180`
|
|
384
|
+
"""
|
|
385
|
+
return pulumi.get(self, "hold_time")
|
|
386
|
+
|
|
387
|
+
@hold_time.setter
|
|
388
|
+
def hold_time(self, value: Optional[pulumi.Input[int]]):
|
|
389
|
+
pulumi.set(self, "hold_time", value)
|
|
390
|
+
|
|
391
|
+
@property
|
|
392
|
+
@pulumi.getter(name="holdTimeVariable")
|
|
393
|
+
def hold_time_variable(self) -> Optional[pulumi.Input[str]]:
|
|
394
|
+
"""
|
|
395
|
+
Variable name
|
|
396
|
+
"""
|
|
397
|
+
return pulumi.get(self, "hold_time_variable")
|
|
398
|
+
|
|
399
|
+
@hold_time_variable.setter
|
|
400
|
+
def hold_time_variable(self, value: Optional[pulumi.Input[str]]):
|
|
401
|
+
pulumi.set(self, "hold_time_variable", value)
|
|
402
|
+
|
|
403
|
+
@property
|
|
404
|
+
@pulumi.getter(name="internalRoutesDistance")
|
|
405
|
+
def internal_routes_distance(self) -> Optional[pulumi.Input[int]]:
|
|
406
|
+
"""
|
|
407
|
+
Set administrative distance for internal BGP routes - Range: `1`-`255` - Default value: `200`
|
|
408
|
+
"""
|
|
409
|
+
return pulumi.get(self, "internal_routes_distance")
|
|
410
|
+
|
|
411
|
+
@internal_routes_distance.setter
|
|
412
|
+
def internal_routes_distance(self, value: Optional[pulumi.Input[int]]):
|
|
413
|
+
pulumi.set(self, "internal_routes_distance", value)
|
|
414
|
+
|
|
415
|
+
@property
|
|
416
|
+
@pulumi.getter(name="internalRoutesDistanceVariable")
|
|
417
|
+
def internal_routes_distance_variable(self) -> Optional[pulumi.Input[str]]:
|
|
418
|
+
"""
|
|
419
|
+
Variable name
|
|
420
|
+
"""
|
|
421
|
+
return pulumi.get(self, "internal_routes_distance_variable")
|
|
422
|
+
|
|
423
|
+
@internal_routes_distance_variable.setter
|
|
424
|
+
def internal_routes_distance_variable(self, value: Optional[pulumi.Input[str]]):
|
|
425
|
+
pulumi.set(self, "internal_routes_distance_variable", value)
|
|
426
|
+
|
|
427
|
+
@property
|
|
428
|
+
@pulumi.getter(name="ipv4AggregateAddresses")
|
|
429
|
+
def ipv4_aggregate_addresses(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ServiceRoutingBgpFeatureIpv4AggregateAddressArgs']]]]:
|
|
430
|
+
"""
|
|
431
|
+
Aggregate prefixes in specific range
|
|
432
|
+
"""
|
|
433
|
+
return pulumi.get(self, "ipv4_aggregate_addresses")
|
|
434
|
+
|
|
435
|
+
@ipv4_aggregate_addresses.setter
|
|
436
|
+
def ipv4_aggregate_addresses(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ServiceRoutingBgpFeatureIpv4AggregateAddressArgs']]]]):
|
|
437
|
+
pulumi.set(self, "ipv4_aggregate_addresses", value)
|
|
438
|
+
|
|
439
|
+
@property
|
|
440
|
+
@pulumi.getter(name="ipv4EibgpMaximumPaths")
|
|
441
|
+
def ipv4_eibgp_maximum_paths(self) -> Optional[pulumi.Input[int]]:
|
|
442
|
+
"""
|
|
443
|
+
Set maximum number of parallel IBGP paths for multipath load sharing - Range: `1`-`32`
|
|
444
|
+
"""
|
|
445
|
+
return pulumi.get(self, "ipv4_eibgp_maximum_paths")
|
|
446
|
+
|
|
447
|
+
@ipv4_eibgp_maximum_paths.setter
|
|
448
|
+
def ipv4_eibgp_maximum_paths(self, value: Optional[pulumi.Input[int]]):
|
|
449
|
+
pulumi.set(self, "ipv4_eibgp_maximum_paths", value)
|
|
450
|
+
|
|
451
|
+
@property
|
|
452
|
+
@pulumi.getter(name="ipv4EibgpMaximumPathsVariable")
|
|
453
|
+
def ipv4_eibgp_maximum_paths_variable(self) -> Optional[pulumi.Input[str]]:
|
|
454
|
+
"""
|
|
455
|
+
Variable name
|
|
456
|
+
"""
|
|
457
|
+
return pulumi.get(self, "ipv4_eibgp_maximum_paths_variable")
|
|
458
|
+
|
|
459
|
+
@ipv4_eibgp_maximum_paths_variable.setter
|
|
460
|
+
def ipv4_eibgp_maximum_paths_variable(self, value: Optional[pulumi.Input[str]]):
|
|
461
|
+
pulumi.set(self, "ipv4_eibgp_maximum_paths_variable", value)
|
|
462
|
+
|
|
463
|
+
@property
|
|
464
|
+
@pulumi.getter(name="ipv4Neighbors")
|
|
465
|
+
def ipv4_neighbors(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ServiceRoutingBgpFeatureIpv4NeighborArgs']]]]:
|
|
466
|
+
"""
|
|
467
|
+
Set BGP IPv4 neighbors
|
|
468
|
+
"""
|
|
469
|
+
return pulumi.get(self, "ipv4_neighbors")
|
|
470
|
+
|
|
471
|
+
@ipv4_neighbors.setter
|
|
472
|
+
def ipv4_neighbors(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ServiceRoutingBgpFeatureIpv4NeighborArgs']]]]):
|
|
473
|
+
pulumi.set(self, "ipv4_neighbors", value)
|
|
474
|
+
|
|
475
|
+
@property
|
|
476
|
+
@pulumi.getter(name="ipv4Networks")
|
|
477
|
+
def ipv4_networks(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ServiceRoutingBgpFeatureIpv4NetworkArgs']]]]:
|
|
478
|
+
"""
|
|
479
|
+
Configure the networks for BGP to advertise
|
|
480
|
+
"""
|
|
481
|
+
return pulumi.get(self, "ipv4_networks")
|
|
482
|
+
|
|
483
|
+
@ipv4_networks.setter
|
|
484
|
+
def ipv4_networks(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ServiceRoutingBgpFeatureIpv4NetworkArgs']]]]):
|
|
485
|
+
pulumi.set(self, "ipv4_networks", value)
|
|
486
|
+
|
|
487
|
+
@property
|
|
488
|
+
@pulumi.getter(name="ipv4Originate")
|
|
489
|
+
def ipv4_originate(self) -> Optional[pulumi.Input[bool]]:
|
|
490
|
+
"""
|
|
491
|
+
BGP Default Information Originate - Default value: `false`
|
|
492
|
+
"""
|
|
493
|
+
return pulumi.get(self, "ipv4_originate")
|
|
494
|
+
|
|
495
|
+
@ipv4_originate.setter
|
|
496
|
+
def ipv4_originate(self, value: Optional[pulumi.Input[bool]]):
|
|
497
|
+
pulumi.set(self, "ipv4_originate", value)
|
|
498
|
+
|
|
499
|
+
@property
|
|
500
|
+
@pulumi.getter(name="ipv4OriginateVariable")
|
|
501
|
+
def ipv4_originate_variable(self) -> Optional[pulumi.Input[str]]:
|
|
502
|
+
"""
|
|
503
|
+
Variable name
|
|
504
|
+
"""
|
|
505
|
+
return pulumi.get(self, "ipv4_originate_variable")
|
|
506
|
+
|
|
507
|
+
@ipv4_originate_variable.setter
|
|
508
|
+
def ipv4_originate_variable(self, value: Optional[pulumi.Input[str]]):
|
|
509
|
+
pulumi.set(self, "ipv4_originate_variable", value)
|
|
510
|
+
|
|
511
|
+
@property
|
|
512
|
+
@pulumi.getter(name="ipv4Redistributes")
|
|
513
|
+
def ipv4_redistributes(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ServiceRoutingBgpFeatureIpv4RedistributeArgs']]]]:
|
|
514
|
+
"""
|
|
515
|
+
Redistribute routes into BGP
|
|
516
|
+
"""
|
|
517
|
+
return pulumi.get(self, "ipv4_redistributes")
|
|
518
|
+
|
|
519
|
+
@ipv4_redistributes.setter
|
|
520
|
+
def ipv4_redistributes(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ServiceRoutingBgpFeatureIpv4RedistributeArgs']]]]):
|
|
521
|
+
pulumi.set(self, "ipv4_redistributes", value)
|
|
522
|
+
|
|
523
|
+
@property
|
|
524
|
+
@pulumi.getter(name="ipv4TableMapFilter")
|
|
525
|
+
def ipv4_table_map_filter(self) -> Optional[pulumi.Input[bool]]:
|
|
526
|
+
"""
|
|
527
|
+
Table map filtered or not - Default value: `false`
|
|
528
|
+
"""
|
|
529
|
+
return pulumi.get(self, "ipv4_table_map_filter")
|
|
530
|
+
|
|
531
|
+
@ipv4_table_map_filter.setter
|
|
532
|
+
def ipv4_table_map_filter(self, value: Optional[pulumi.Input[bool]]):
|
|
533
|
+
pulumi.set(self, "ipv4_table_map_filter", value)
|
|
534
|
+
|
|
535
|
+
@property
|
|
536
|
+
@pulumi.getter(name="ipv4TableMapFilterVariable")
|
|
537
|
+
def ipv4_table_map_filter_variable(self) -> Optional[pulumi.Input[str]]:
|
|
538
|
+
"""
|
|
539
|
+
Variable name
|
|
540
|
+
"""
|
|
541
|
+
return pulumi.get(self, "ipv4_table_map_filter_variable")
|
|
542
|
+
|
|
543
|
+
@ipv4_table_map_filter_variable.setter
|
|
544
|
+
def ipv4_table_map_filter_variable(self, value: Optional[pulumi.Input[str]]):
|
|
545
|
+
pulumi.set(self, "ipv4_table_map_filter_variable", value)
|
|
546
|
+
|
|
547
|
+
@property
|
|
548
|
+
@pulumi.getter(name="ipv4TableMapRoutePolicyId")
|
|
549
|
+
def ipv4_table_map_route_policy_id(self) -> Optional[pulumi.Input[str]]:
|
|
550
|
+
return pulumi.get(self, "ipv4_table_map_route_policy_id")
|
|
551
|
+
|
|
552
|
+
@ipv4_table_map_route_policy_id.setter
|
|
553
|
+
def ipv4_table_map_route_policy_id(self, value: Optional[pulumi.Input[str]]):
|
|
554
|
+
pulumi.set(self, "ipv4_table_map_route_policy_id", value)
|
|
555
|
+
|
|
556
|
+
@property
|
|
557
|
+
@pulumi.getter(name="ipv6AggregateAddresses")
|
|
558
|
+
def ipv6_aggregate_addresses(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ServiceRoutingBgpFeatureIpv6AggregateAddressArgs']]]]:
|
|
559
|
+
"""
|
|
560
|
+
IPv6 Aggregate prefixes in specific range
|
|
561
|
+
"""
|
|
562
|
+
return pulumi.get(self, "ipv6_aggregate_addresses")
|
|
563
|
+
|
|
564
|
+
@ipv6_aggregate_addresses.setter
|
|
565
|
+
def ipv6_aggregate_addresses(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ServiceRoutingBgpFeatureIpv6AggregateAddressArgs']]]]):
|
|
566
|
+
pulumi.set(self, "ipv6_aggregate_addresses", value)
|
|
567
|
+
|
|
568
|
+
@property
|
|
569
|
+
@pulumi.getter(name="ipv6EibgpMaximumPaths")
|
|
570
|
+
def ipv6_eibgp_maximum_paths(self) -> Optional[pulumi.Input[int]]:
|
|
571
|
+
"""
|
|
572
|
+
Set maximum number of parallel IBGP paths for multipath load sharing - Range: `1`-`32`
|
|
573
|
+
"""
|
|
574
|
+
return pulumi.get(self, "ipv6_eibgp_maximum_paths")
|
|
575
|
+
|
|
576
|
+
@ipv6_eibgp_maximum_paths.setter
|
|
577
|
+
def ipv6_eibgp_maximum_paths(self, value: Optional[pulumi.Input[int]]):
|
|
578
|
+
pulumi.set(self, "ipv6_eibgp_maximum_paths", value)
|
|
579
|
+
|
|
580
|
+
@property
|
|
581
|
+
@pulumi.getter(name="ipv6EibgpMaximumPathsVariable")
|
|
582
|
+
def ipv6_eibgp_maximum_paths_variable(self) -> Optional[pulumi.Input[str]]:
|
|
583
|
+
"""
|
|
584
|
+
Variable name
|
|
585
|
+
"""
|
|
586
|
+
return pulumi.get(self, "ipv6_eibgp_maximum_paths_variable")
|
|
587
|
+
|
|
588
|
+
@ipv6_eibgp_maximum_paths_variable.setter
|
|
589
|
+
def ipv6_eibgp_maximum_paths_variable(self, value: Optional[pulumi.Input[str]]):
|
|
590
|
+
pulumi.set(self, "ipv6_eibgp_maximum_paths_variable", value)
|
|
591
|
+
|
|
592
|
+
@property
|
|
593
|
+
@pulumi.getter(name="ipv6Neighbors")
|
|
594
|
+
def ipv6_neighbors(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ServiceRoutingBgpFeatureIpv6NeighborArgs']]]]:
|
|
595
|
+
"""
|
|
596
|
+
Set BGP IPv6 neighbors
|
|
597
|
+
"""
|
|
598
|
+
return pulumi.get(self, "ipv6_neighbors")
|
|
599
|
+
|
|
600
|
+
@ipv6_neighbors.setter
|
|
601
|
+
def ipv6_neighbors(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ServiceRoutingBgpFeatureIpv6NeighborArgs']]]]):
|
|
602
|
+
pulumi.set(self, "ipv6_neighbors", value)
|
|
603
|
+
|
|
604
|
+
@property
|
|
605
|
+
@pulumi.getter(name="ipv6Networks")
|
|
606
|
+
def ipv6_networks(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ServiceRoutingBgpFeatureIpv6NetworkArgs']]]]:
|
|
607
|
+
"""
|
|
608
|
+
Configure the networks for BGP to advertise
|
|
609
|
+
"""
|
|
610
|
+
return pulumi.get(self, "ipv6_networks")
|
|
611
|
+
|
|
612
|
+
@ipv6_networks.setter
|
|
613
|
+
def ipv6_networks(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ServiceRoutingBgpFeatureIpv6NetworkArgs']]]]):
|
|
614
|
+
pulumi.set(self, "ipv6_networks", value)
|
|
615
|
+
|
|
616
|
+
@property
|
|
617
|
+
@pulumi.getter(name="ipv6Originate")
|
|
618
|
+
def ipv6_originate(self) -> Optional[pulumi.Input[bool]]:
|
|
619
|
+
"""
|
|
620
|
+
BGP Default Information Originate - Default value: `false`
|
|
621
|
+
"""
|
|
622
|
+
return pulumi.get(self, "ipv6_originate")
|
|
623
|
+
|
|
624
|
+
@ipv6_originate.setter
|
|
625
|
+
def ipv6_originate(self, value: Optional[pulumi.Input[bool]]):
|
|
626
|
+
pulumi.set(self, "ipv6_originate", value)
|
|
627
|
+
|
|
628
|
+
@property
|
|
629
|
+
@pulumi.getter(name="ipv6OriginateVariable")
|
|
630
|
+
def ipv6_originate_variable(self) -> Optional[pulumi.Input[str]]:
|
|
631
|
+
"""
|
|
632
|
+
Variable name
|
|
633
|
+
"""
|
|
634
|
+
return pulumi.get(self, "ipv6_originate_variable")
|
|
635
|
+
|
|
636
|
+
@ipv6_originate_variable.setter
|
|
637
|
+
def ipv6_originate_variable(self, value: Optional[pulumi.Input[str]]):
|
|
638
|
+
pulumi.set(self, "ipv6_originate_variable", value)
|
|
639
|
+
|
|
640
|
+
@property
|
|
641
|
+
@pulumi.getter(name="ipv6Redistributes")
|
|
642
|
+
def ipv6_redistributes(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ServiceRoutingBgpFeatureIpv6RedistributeArgs']]]]:
|
|
643
|
+
"""
|
|
644
|
+
Redistribute routes into BGP
|
|
645
|
+
"""
|
|
646
|
+
return pulumi.get(self, "ipv6_redistributes")
|
|
647
|
+
|
|
648
|
+
@ipv6_redistributes.setter
|
|
649
|
+
def ipv6_redistributes(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ServiceRoutingBgpFeatureIpv6RedistributeArgs']]]]):
|
|
650
|
+
pulumi.set(self, "ipv6_redistributes", value)
|
|
651
|
+
|
|
652
|
+
@property
|
|
653
|
+
@pulumi.getter(name="ipv6TableMapFilter")
|
|
654
|
+
def ipv6_table_map_filter(self) -> Optional[pulumi.Input[bool]]:
|
|
655
|
+
"""
|
|
656
|
+
Table map filtered or not - Default value: `false`
|
|
657
|
+
"""
|
|
658
|
+
return pulumi.get(self, "ipv6_table_map_filter")
|
|
659
|
+
|
|
660
|
+
@ipv6_table_map_filter.setter
|
|
661
|
+
def ipv6_table_map_filter(self, value: Optional[pulumi.Input[bool]]):
|
|
662
|
+
pulumi.set(self, "ipv6_table_map_filter", value)
|
|
663
|
+
|
|
664
|
+
@property
|
|
665
|
+
@pulumi.getter(name="ipv6TableMapFilterVariable")
|
|
666
|
+
def ipv6_table_map_filter_variable(self) -> Optional[pulumi.Input[str]]:
|
|
667
|
+
"""
|
|
668
|
+
Variable name
|
|
669
|
+
"""
|
|
670
|
+
return pulumi.get(self, "ipv6_table_map_filter_variable")
|
|
671
|
+
|
|
672
|
+
@ipv6_table_map_filter_variable.setter
|
|
673
|
+
def ipv6_table_map_filter_variable(self, value: Optional[pulumi.Input[str]]):
|
|
674
|
+
pulumi.set(self, "ipv6_table_map_filter_variable", value)
|
|
675
|
+
|
|
676
|
+
@property
|
|
677
|
+
@pulumi.getter(name="ipv6TableMapRoutePolicyId")
|
|
678
|
+
def ipv6_table_map_route_policy_id(self) -> Optional[pulumi.Input[str]]:
|
|
679
|
+
return pulumi.get(self, "ipv6_table_map_route_policy_id")
|
|
680
|
+
|
|
681
|
+
@ipv6_table_map_route_policy_id.setter
|
|
682
|
+
def ipv6_table_map_route_policy_id(self, value: Optional[pulumi.Input[str]]):
|
|
683
|
+
pulumi.set(self, "ipv6_table_map_route_policy_id", value)
|
|
684
|
+
|
|
685
|
+
@property
|
|
686
|
+
@pulumi.getter(name="keepaliveTime")
|
|
687
|
+
def keepalive_time(self) -> Optional[pulumi.Input[int]]:
|
|
688
|
+
"""
|
|
689
|
+
Interval (seconds) of keepalive messages sent to its BGP peer - Range: `0`-`65535` - Default value: `60`
|
|
690
|
+
"""
|
|
691
|
+
return pulumi.get(self, "keepalive_time")
|
|
692
|
+
|
|
693
|
+
@keepalive_time.setter
|
|
694
|
+
def keepalive_time(self, value: Optional[pulumi.Input[int]]):
|
|
695
|
+
pulumi.set(self, "keepalive_time", value)
|
|
696
|
+
|
|
697
|
+
@property
|
|
698
|
+
@pulumi.getter(name="keepaliveTimeVariable")
|
|
699
|
+
def keepalive_time_variable(self) -> Optional[pulumi.Input[str]]:
|
|
700
|
+
"""
|
|
701
|
+
Variable name
|
|
702
|
+
"""
|
|
703
|
+
return pulumi.get(self, "keepalive_time_variable")
|
|
704
|
+
|
|
705
|
+
@keepalive_time_variable.setter
|
|
706
|
+
def keepalive_time_variable(self, value: Optional[pulumi.Input[str]]):
|
|
707
|
+
pulumi.set(self, "keepalive_time_variable", value)
|
|
708
|
+
|
|
709
|
+
@property
|
|
710
|
+
@pulumi.getter(name="localRoutesDistance")
|
|
711
|
+
def local_routes_distance(self) -> Optional[pulumi.Input[int]]:
|
|
712
|
+
"""
|
|
713
|
+
Set administrative distance for local BGP routes - Range: `1`-`255` - Default value: `20`
|
|
714
|
+
"""
|
|
715
|
+
return pulumi.get(self, "local_routes_distance")
|
|
716
|
+
|
|
717
|
+
@local_routes_distance.setter
|
|
718
|
+
def local_routes_distance(self, value: Optional[pulumi.Input[int]]):
|
|
719
|
+
pulumi.set(self, "local_routes_distance", value)
|
|
720
|
+
|
|
721
|
+
@property
|
|
722
|
+
@pulumi.getter(name="localRoutesDistanceVariable")
|
|
723
|
+
def local_routes_distance_variable(self) -> Optional[pulumi.Input[str]]:
|
|
724
|
+
"""
|
|
725
|
+
Variable name
|
|
726
|
+
"""
|
|
727
|
+
return pulumi.get(self, "local_routes_distance_variable")
|
|
728
|
+
|
|
729
|
+
@local_routes_distance_variable.setter
|
|
730
|
+
def local_routes_distance_variable(self, value: Optional[pulumi.Input[str]]):
|
|
731
|
+
pulumi.set(self, "local_routes_distance_variable", value)
|
|
732
|
+
|
|
733
|
+
@property
|
|
734
|
+
@pulumi.getter(name="missingMedAsWorst")
|
|
735
|
+
def missing_med_as_worst(self) -> Optional[pulumi.Input[bool]]:
|
|
736
|
+
"""
|
|
737
|
+
If path has no MED, consider it to be worst path when selecting active BGP paths - Default value: `false`
|
|
738
|
+
"""
|
|
739
|
+
return pulumi.get(self, "missing_med_as_worst")
|
|
740
|
+
|
|
741
|
+
@missing_med_as_worst.setter
|
|
742
|
+
def missing_med_as_worst(self, value: Optional[pulumi.Input[bool]]):
|
|
743
|
+
pulumi.set(self, "missing_med_as_worst", value)
|
|
744
|
+
|
|
745
|
+
@property
|
|
746
|
+
@pulumi.getter(name="missingMedAsWorstVariable")
|
|
747
|
+
def missing_med_as_worst_variable(self) -> Optional[pulumi.Input[str]]:
|
|
748
|
+
"""
|
|
749
|
+
Variable name
|
|
750
|
+
"""
|
|
751
|
+
return pulumi.get(self, "missing_med_as_worst_variable")
|
|
752
|
+
|
|
753
|
+
@missing_med_as_worst_variable.setter
|
|
754
|
+
def missing_med_as_worst_variable(self, value: Optional[pulumi.Input[str]]):
|
|
755
|
+
pulumi.set(self, "missing_med_as_worst_variable", value)
|
|
756
|
+
|
|
757
|
+
@property
|
|
758
|
+
@pulumi.getter(name="multipathRelax")
|
|
759
|
+
def multipath_relax(self) -> Optional[pulumi.Input[bool]]:
|
|
760
|
+
"""
|
|
761
|
+
Ignore AS for multipath selection - Default value: `false`
|
|
762
|
+
"""
|
|
763
|
+
return pulumi.get(self, "multipath_relax")
|
|
764
|
+
|
|
765
|
+
@multipath_relax.setter
|
|
766
|
+
def multipath_relax(self, value: Optional[pulumi.Input[bool]]):
|
|
767
|
+
pulumi.set(self, "multipath_relax", value)
|
|
768
|
+
|
|
769
|
+
@property
|
|
770
|
+
@pulumi.getter(name="multipathRelaxVariable")
|
|
771
|
+
def multipath_relax_variable(self) -> Optional[pulumi.Input[str]]:
|
|
772
|
+
"""
|
|
773
|
+
Variable name
|
|
774
|
+
"""
|
|
775
|
+
return pulumi.get(self, "multipath_relax_variable")
|
|
776
|
+
|
|
777
|
+
@multipath_relax_variable.setter
|
|
778
|
+
def multipath_relax_variable(self, value: Optional[pulumi.Input[str]]):
|
|
779
|
+
pulumi.set(self, "multipath_relax_variable", value)
|
|
780
|
+
|
|
781
|
+
@property
|
|
782
|
+
@pulumi.getter
|
|
783
|
+
def name(self) -> Optional[pulumi.Input[str]]:
|
|
784
|
+
"""
|
|
785
|
+
The name of the Feature
|
|
786
|
+
"""
|
|
787
|
+
return pulumi.get(self, "name")
|
|
788
|
+
|
|
789
|
+
@name.setter
|
|
790
|
+
def name(self, value: Optional[pulumi.Input[str]]):
|
|
791
|
+
pulumi.set(self, "name", value)
|
|
792
|
+
|
|
793
|
+
@property
|
|
794
|
+
@pulumi.getter(name="propagateAsPath")
|
|
795
|
+
def propagate_as_path(self) -> Optional[pulumi.Input[bool]]:
|
|
796
|
+
"""
|
|
797
|
+
Propagate AS Path - Default value: `false`
|
|
798
|
+
"""
|
|
799
|
+
return pulumi.get(self, "propagate_as_path")
|
|
800
|
+
|
|
801
|
+
@propagate_as_path.setter
|
|
802
|
+
def propagate_as_path(self, value: Optional[pulumi.Input[bool]]):
|
|
803
|
+
pulumi.set(self, "propagate_as_path", value)
|
|
804
|
+
|
|
805
|
+
@property
|
|
806
|
+
@pulumi.getter(name="propagateAsPathVariable")
|
|
807
|
+
def propagate_as_path_variable(self) -> Optional[pulumi.Input[str]]:
|
|
808
|
+
"""
|
|
809
|
+
Variable name
|
|
810
|
+
"""
|
|
811
|
+
return pulumi.get(self, "propagate_as_path_variable")
|
|
812
|
+
|
|
813
|
+
@propagate_as_path_variable.setter
|
|
814
|
+
def propagate_as_path_variable(self, value: Optional[pulumi.Input[str]]):
|
|
815
|
+
pulumi.set(self, "propagate_as_path_variable", value)
|
|
816
|
+
|
|
817
|
+
@property
|
|
818
|
+
@pulumi.getter(name="propagateCommunity")
|
|
819
|
+
def propagate_community(self) -> Optional[pulumi.Input[bool]]:
|
|
820
|
+
"""
|
|
821
|
+
Propagate Community - Default value: `false`
|
|
822
|
+
"""
|
|
823
|
+
return pulumi.get(self, "propagate_community")
|
|
824
|
+
|
|
825
|
+
@propagate_community.setter
|
|
826
|
+
def propagate_community(self, value: Optional[pulumi.Input[bool]]):
|
|
827
|
+
pulumi.set(self, "propagate_community", value)
|
|
828
|
+
|
|
829
|
+
@property
|
|
830
|
+
@pulumi.getter(name="propagateCommunityVariable")
|
|
831
|
+
def propagate_community_variable(self) -> Optional[pulumi.Input[str]]:
|
|
832
|
+
"""
|
|
833
|
+
Variable name
|
|
834
|
+
"""
|
|
835
|
+
return pulumi.get(self, "propagate_community_variable")
|
|
836
|
+
|
|
837
|
+
@propagate_community_variable.setter
|
|
838
|
+
def propagate_community_variable(self, value: Optional[pulumi.Input[str]]):
|
|
839
|
+
pulumi.set(self, "propagate_community_variable", value)
|
|
840
|
+
|
|
841
|
+
@property
|
|
842
|
+
@pulumi.getter(name="routerId")
|
|
843
|
+
def router_id(self) -> Optional[pulumi.Input[str]]:
|
|
844
|
+
"""
|
|
845
|
+
Configure BGP router identifier
|
|
846
|
+
"""
|
|
847
|
+
return pulumi.get(self, "router_id")
|
|
848
|
+
|
|
849
|
+
@router_id.setter
|
|
850
|
+
def router_id(self, value: Optional[pulumi.Input[str]]):
|
|
851
|
+
pulumi.set(self, "router_id", value)
|
|
852
|
+
|
|
853
|
+
@property
|
|
854
|
+
@pulumi.getter(name="routerIdVariable")
|
|
855
|
+
def router_id_variable(self) -> Optional[pulumi.Input[str]]:
|
|
856
|
+
"""
|
|
857
|
+
Variable name
|
|
858
|
+
"""
|
|
859
|
+
return pulumi.get(self, "router_id_variable")
|
|
860
|
+
|
|
861
|
+
@router_id_variable.setter
|
|
862
|
+
def router_id_variable(self, value: Optional[pulumi.Input[str]]):
|
|
863
|
+
pulumi.set(self, "router_id_variable", value)
|
|
864
|
+
|
|
865
|
+
|
|
866
|
+
@pulumi.input_type
|
|
867
|
+
class _ServiceRoutingBgpFeatureState:
|
|
868
|
+
def __init__(__self__, *,
|
|
869
|
+
always_compare_med: Optional[pulumi.Input[bool]] = None,
|
|
870
|
+
always_compare_med_variable: Optional[pulumi.Input[str]] = None,
|
|
871
|
+
as_number: Optional[pulumi.Input[int]] = None,
|
|
872
|
+
as_number_variable: Optional[pulumi.Input[str]] = None,
|
|
873
|
+
compare_router_id: Optional[pulumi.Input[bool]] = None,
|
|
874
|
+
compare_router_id_variable: Optional[pulumi.Input[str]] = None,
|
|
875
|
+
description: Optional[pulumi.Input[str]] = None,
|
|
876
|
+
deterministic_med: Optional[pulumi.Input[bool]] = None,
|
|
877
|
+
deterministic_med_variable: Optional[pulumi.Input[str]] = None,
|
|
878
|
+
external_routes_distance: Optional[pulumi.Input[int]] = None,
|
|
879
|
+
external_routes_distance_variable: Optional[pulumi.Input[str]] = None,
|
|
880
|
+
feature_profile_id: Optional[pulumi.Input[str]] = None,
|
|
881
|
+
hold_time: Optional[pulumi.Input[int]] = None,
|
|
882
|
+
hold_time_variable: Optional[pulumi.Input[str]] = None,
|
|
883
|
+
internal_routes_distance: Optional[pulumi.Input[int]] = None,
|
|
884
|
+
internal_routes_distance_variable: Optional[pulumi.Input[str]] = None,
|
|
885
|
+
ipv4_aggregate_addresses: Optional[pulumi.Input[Sequence[pulumi.Input['ServiceRoutingBgpFeatureIpv4AggregateAddressArgs']]]] = None,
|
|
886
|
+
ipv4_eibgp_maximum_paths: Optional[pulumi.Input[int]] = None,
|
|
887
|
+
ipv4_eibgp_maximum_paths_variable: Optional[pulumi.Input[str]] = None,
|
|
888
|
+
ipv4_neighbors: Optional[pulumi.Input[Sequence[pulumi.Input['ServiceRoutingBgpFeatureIpv4NeighborArgs']]]] = None,
|
|
889
|
+
ipv4_networks: Optional[pulumi.Input[Sequence[pulumi.Input['ServiceRoutingBgpFeatureIpv4NetworkArgs']]]] = None,
|
|
890
|
+
ipv4_originate: Optional[pulumi.Input[bool]] = None,
|
|
891
|
+
ipv4_originate_variable: Optional[pulumi.Input[str]] = None,
|
|
892
|
+
ipv4_redistributes: Optional[pulumi.Input[Sequence[pulumi.Input['ServiceRoutingBgpFeatureIpv4RedistributeArgs']]]] = None,
|
|
893
|
+
ipv4_table_map_filter: Optional[pulumi.Input[bool]] = None,
|
|
894
|
+
ipv4_table_map_filter_variable: Optional[pulumi.Input[str]] = None,
|
|
895
|
+
ipv4_table_map_route_policy_id: Optional[pulumi.Input[str]] = None,
|
|
896
|
+
ipv6_aggregate_addresses: Optional[pulumi.Input[Sequence[pulumi.Input['ServiceRoutingBgpFeatureIpv6AggregateAddressArgs']]]] = None,
|
|
897
|
+
ipv6_eibgp_maximum_paths: Optional[pulumi.Input[int]] = None,
|
|
898
|
+
ipv6_eibgp_maximum_paths_variable: Optional[pulumi.Input[str]] = None,
|
|
899
|
+
ipv6_neighbors: Optional[pulumi.Input[Sequence[pulumi.Input['ServiceRoutingBgpFeatureIpv6NeighborArgs']]]] = None,
|
|
900
|
+
ipv6_networks: Optional[pulumi.Input[Sequence[pulumi.Input['ServiceRoutingBgpFeatureIpv6NetworkArgs']]]] = None,
|
|
901
|
+
ipv6_originate: Optional[pulumi.Input[bool]] = None,
|
|
902
|
+
ipv6_originate_variable: Optional[pulumi.Input[str]] = None,
|
|
903
|
+
ipv6_redistributes: Optional[pulumi.Input[Sequence[pulumi.Input['ServiceRoutingBgpFeatureIpv6RedistributeArgs']]]] = None,
|
|
904
|
+
ipv6_table_map_filter: Optional[pulumi.Input[bool]] = None,
|
|
905
|
+
ipv6_table_map_filter_variable: Optional[pulumi.Input[str]] = None,
|
|
906
|
+
ipv6_table_map_route_policy_id: Optional[pulumi.Input[str]] = None,
|
|
907
|
+
keepalive_time: Optional[pulumi.Input[int]] = None,
|
|
908
|
+
keepalive_time_variable: Optional[pulumi.Input[str]] = None,
|
|
909
|
+
local_routes_distance: Optional[pulumi.Input[int]] = None,
|
|
910
|
+
local_routes_distance_variable: Optional[pulumi.Input[str]] = None,
|
|
911
|
+
missing_med_as_worst: Optional[pulumi.Input[bool]] = None,
|
|
912
|
+
missing_med_as_worst_variable: Optional[pulumi.Input[str]] = None,
|
|
913
|
+
multipath_relax: Optional[pulumi.Input[bool]] = None,
|
|
914
|
+
multipath_relax_variable: Optional[pulumi.Input[str]] = None,
|
|
915
|
+
name: Optional[pulumi.Input[str]] = None,
|
|
916
|
+
propagate_as_path: Optional[pulumi.Input[bool]] = None,
|
|
917
|
+
propagate_as_path_variable: Optional[pulumi.Input[str]] = None,
|
|
918
|
+
propagate_community: Optional[pulumi.Input[bool]] = None,
|
|
919
|
+
propagate_community_variable: Optional[pulumi.Input[str]] = None,
|
|
920
|
+
router_id: Optional[pulumi.Input[str]] = None,
|
|
921
|
+
router_id_variable: Optional[pulumi.Input[str]] = None,
|
|
922
|
+
version: Optional[pulumi.Input[int]] = None):
|
|
923
|
+
"""
|
|
924
|
+
Input properties used for looking up and filtering ServiceRoutingBgpFeature resources.
|
|
925
|
+
:param pulumi.Input[bool] always_compare_med: Compare MEDs from all ASs when selecting active BGP paths - Default value: `false`
|
|
926
|
+
:param pulumi.Input[str] always_compare_med_variable: Variable name
|
|
927
|
+
:param pulumi.Input[int] as_number: Set autonomous system number <1..4294967295> or <XX.YY>
|
|
928
|
+
:param pulumi.Input[str] as_number_variable: Variable name
|
|
929
|
+
:param pulumi.Input[bool] compare_router_id: Compare router IDs when selecting active BGP paths - Default value: `false`
|
|
930
|
+
:param pulumi.Input[str] compare_router_id_variable: Variable name
|
|
931
|
+
:param pulumi.Input[str] description: The description of the Feature
|
|
932
|
+
:param pulumi.Input[bool] deterministic_med: Compare MEDs from all routes from same AS when selecting active BGP paths - Default value: `false`
|
|
933
|
+
:param pulumi.Input[str] deterministic_med_variable: Variable name
|
|
934
|
+
:param pulumi.Input[int] external_routes_distance: Set administrative distance for external BGP routes - Range: `1`-`255` - Default value: `20`
|
|
935
|
+
:param pulumi.Input[str] external_routes_distance_variable: Variable name
|
|
936
|
+
:param pulumi.Input[str] feature_profile_id: Feature Profile ID
|
|
937
|
+
:param pulumi.Input[int] hold_time: Interval (seconds) not receiving a keepalive message declares a BGP peer down - Range: `0`-`65535` - Default value:
|
|
938
|
+
`180`
|
|
939
|
+
:param pulumi.Input[str] hold_time_variable: Variable name
|
|
940
|
+
:param pulumi.Input[int] internal_routes_distance: Set administrative distance for internal BGP routes - Range: `1`-`255` - Default value: `200`
|
|
941
|
+
:param pulumi.Input[str] internal_routes_distance_variable: Variable name
|
|
942
|
+
:param pulumi.Input[Sequence[pulumi.Input['ServiceRoutingBgpFeatureIpv4AggregateAddressArgs']]] ipv4_aggregate_addresses: Aggregate prefixes in specific range
|
|
943
|
+
:param pulumi.Input[int] ipv4_eibgp_maximum_paths: Set maximum number of parallel IBGP paths for multipath load sharing - Range: `1`-`32`
|
|
944
|
+
:param pulumi.Input[str] ipv4_eibgp_maximum_paths_variable: Variable name
|
|
945
|
+
:param pulumi.Input[Sequence[pulumi.Input['ServiceRoutingBgpFeatureIpv4NeighborArgs']]] ipv4_neighbors: Set BGP IPv4 neighbors
|
|
946
|
+
:param pulumi.Input[Sequence[pulumi.Input['ServiceRoutingBgpFeatureIpv4NetworkArgs']]] ipv4_networks: Configure the networks for BGP to advertise
|
|
947
|
+
:param pulumi.Input[bool] ipv4_originate: BGP Default Information Originate - Default value: `false`
|
|
948
|
+
:param pulumi.Input[str] ipv4_originate_variable: Variable name
|
|
949
|
+
:param pulumi.Input[Sequence[pulumi.Input['ServiceRoutingBgpFeatureIpv4RedistributeArgs']]] ipv4_redistributes: Redistribute routes into BGP
|
|
950
|
+
:param pulumi.Input[bool] ipv4_table_map_filter: Table map filtered or not - Default value: `false`
|
|
951
|
+
:param pulumi.Input[str] ipv4_table_map_filter_variable: Variable name
|
|
952
|
+
:param pulumi.Input[Sequence[pulumi.Input['ServiceRoutingBgpFeatureIpv6AggregateAddressArgs']]] ipv6_aggregate_addresses: IPv6 Aggregate prefixes in specific range
|
|
953
|
+
:param pulumi.Input[int] ipv6_eibgp_maximum_paths: Set maximum number of parallel IBGP paths for multipath load sharing - Range: `1`-`32`
|
|
954
|
+
:param pulumi.Input[str] ipv6_eibgp_maximum_paths_variable: Variable name
|
|
955
|
+
:param pulumi.Input[Sequence[pulumi.Input['ServiceRoutingBgpFeatureIpv6NeighborArgs']]] ipv6_neighbors: Set BGP IPv6 neighbors
|
|
956
|
+
:param pulumi.Input[Sequence[pulumi.Input['ServiceRoutingBgpFeatureIpv6NetworkArgs']]] ipv6_networks: Configure the networks for BGP to advertise
|
|
957
|
+
:param pulumi.Input[bool] ipv6_originate: BGP Default Information Originate - Default value: `false`
|
|
958
|
+
:param pulumi.Input[str] ipv6_originate_variable: Variable name
|
|
959
|
+
:param pulumi.Input[Sequence[pulumi.Input['ServiceRoutingBgpFeatureIpv6RedistributeArgs']]] ipv6_redistributes: Redistribute routes into BGP
|
|
960
|
+
:param pulumi.Input[bool] ipv6_table_map_filter: Table map filtered or not - Default value: `false`
|
|
961
|
+
:param pulumi.Input[str] ipv6_table_map_filter_variable: Variable name
|
|
962
|
+
:param pulumi.Input[int] keepalive_time: Interval (seconds) of keepalive messages sent to its BGP peer - Range: `0`-`65535` - Default value: `60`
|
|
963
|
+
:param pulumi.Input[str] keepalive_time_variable: Variable name
|
|
964
|
+
:param pulumi.Input[int] local_routes_distance: Set administrative distance for local BGP routes - Range: `1`-`255` - Default value: `20`
|
|
965
|
+
:param pulumi.Input[str] local_routes_distance_variable: Variable name
|
|
966
|
+
:param pulumi.Input[bool] missing_med_as_worst: If path has no MED, consider it to be worst path when selecting active BGP paths - Default value: `false`
|
|
967
|
+
:param pulumi.Input[str] missing_med_as_worst_variable: Variable name
|
|
968
|
+
:param pulumi.Input[bool] multipath_relax: Ignore AS for multipath selection - Default value: `false`
|
|
969
|
+
:param pulumi.Input[str] multipath_relax_variable: Variable name
|
|
970
|
+
:param pulumi.Input[str] name: The name of the Feature
|
|
971
|
+
:param pulumi.Input[bool] propagate_as_path: Propagate AS Path - Default value: `false`
|
|
972
|
+
:param pulumi.Input[str] propagate_as_path_variable: Variable name
|
|
973
|
+
:param pulumi.Input[bool] propagate_community: Propagate Community - Default value: `false`
|
|
974
|
+
:param pulumi.Input[str] propagate_community_variable: Variable name
|
|
975
|
+
:param pulumi.Input[str] router_id: Configure BGP router identifier
|
|
976
|
+
:param pulumi.Input[str] router_id_variable: Variable name
|
|
977
|
+
:param pulumi.Input[int] version: The version of the Feature
|
|
978
|
+
"""
|
|
979
|
+
if always_compare_med is not None:
|
|
980
|
+
pulumi.set(__self__, "always_compare_med", always_compare_med)
|
|
981
|
+
if always_compare_med_variable is not None:
|
|
982
|
+
pulumi.set(__self__, "always_compare_med_variable", always_compare_med_variable)
|
|
983
|
+
if as_number is not None:
|
|
984
|
+
pulumi.set(__self__, "as_number", as_number)
|
|
985
|
+
if as_number_variable is not None:
|
|
986
|
+
pulumi.set(__self__, "as_number_variable", as_number_variable)
|
|
987
|
+
if compare_router_id is not None:
|
|
988
|
+
pulumi.set(__self__, "compare_router_id", compare_router_id)
|
|
989
|
+
if compare_router_id_variable is not None:
|
|
990
|
+
pulumi.set(__self__, "compare_router_id_variable", compare_router_id_variable)
|
|
991
|
+
if description is not None:
|
|
992
|
+
pulumi.set(__self__, "description", description)
|
|
993
|
+
if deterministic_med is not None:
|
|
994
|
+
pulumi.set(__self__, "deterministic_med", deterministic_med)
|
|
995
|
+
if deterministic_med_variable is not None:
|
|
996
|
+
pulumi.set(__self__, "deterministic_med_variable", deterministic_med_variable)
|
|
997
|
+
if external_routes_distance is not None:
|
|
998
|
+
pulumi.set(__self__, "external_routes_distance", external_routes_distance)
|
|
999
|
+
if external_routes_distance_variable is not None:
|
|
1000
|
+
pulumi.set(__self__, "external_routes_distance_variable", external_routes_distance_variable)
|
|
1001
|
+
if feature_profile_id is not None:
|
|
1002
|
+
pulumi.set(__self__, "feature_profile_id", feature_profile_id)
|
|
1003
|
+
if hold_time is not None:
|
|
1004
|
+
pulumi.set(__self__, "hold_time", hold_time)
|
|
1005
|
+
if hold_time_variable is not None:
|
|
1006
|
+
pulumi.set(__self__, "hold_time_variable", hold_time_variable)
|
|
1007
|
+
if internal_routes_distance is not None:
|
|
1008
|
+
pulumi.set(__self__, "internal_routes_distance", internal_routes_distance)
|
|
1009
|
+
if internal_routes_distance_variable is not None:
|
|
1010
|
+
pulumi.set(__self__, "internal_routes_distance_variable", internal_routes_distance_variable)
|
|
1011
|
+
if ipv4_aggregate_addresses is not None:
|
|
1012
|
+
pulumi.set(__self__, "ipv4_aggregate_addresses", ipv4_aggregate_addresses)
|
|
1013
|
+
if ipv4_eibgp_maximum_paths is not None:
|
|
1014
|
+
pulumi.set(__self__, "ipv4_eibgp_maximum_paths", ipv4_eibgp_maximum_paths)
|
|
1015
|
+
if ipv4_eibgp_maximum_paths_variable is not None:
|
|
1016
|
+
pulumi.set(__self__, "ipv4_eibgp_maximum_paths_variable", ipv4_eibgp_maximum_paths_variable)
|
|
1017
|
+
if ipv4_neighbors is not None:
|
|
1018
|
+
pulumi.set(__self__, "ipv4_neighbors", ipv4_neighbors)
|
|
1019
|
+
if ipv4_networks is not None:
|
|
1020
|
+
pulumi.set(__self__, "ipv4_networks", ipv4_networks)
|
|
1021
|
+
if ipv4_originate is not None:
|
|
1022
|
+
pulumi.set(__self__, "ipv4_originate", ipv4_originate)
|
|
1023
|
+
if ipv4_originate_variable is not None:
|
|
1024
|
+
pulumi.set(__self__, "ipv4_originate_variable", ipv4_originate_variable)
|
|
1025
|
+
if ipv4_redistributes is not None:
|
|
1026
|
+
pulumi.set(__self__, "ipv4_redistributes", ipv4_redistributes)
|
|
1027
|
+
if ipv4_table_map_filter is not None:
|
|
1028
|
+
pulumi.set(__self__, "ipv4_table_map_filter", ipv4_table_map_filter)
|
|
1029
|
+
if ipv4_table_map_filter_variable is not None:
|
|
1030
|
+
pulumi.set(__self__, "ipv4_table_map_filter_variable", ipv4_table_map_filter_variable)
|
|
1031
|
+
if ipv4_table_map_route_policy_id is not None:
|
|
1032
|
+
pulumi.set(__self__, "ipv4_table_map_route_policy_id", ipv4_table_map_route_policy_id)
|
|
1033
|
+
if ipv6_aggregate_addresses is not None:
|
|
1034
|
+
pulumi.set(__self__, "ipv6_aggregate_addresses", ipv6_aggregate_addresses)
|
|
1035
|
+
if ipv6_eibgp_maximum_paths is not None:
|
|
1036
|
+
pulumi.set(__self__, "ipv6_eibgp_maximum_paths", ipv6_eibgp_maximum_paths)
|
|
1037
|
+
if ipv6_eibgp_maximum_paths_variable is not None:
|
|
1038
|
+
pulumi.set(__self__, "ipv6_eibgp_maximum_paths_variable", ipv6_eibgp_maximum_paths_variable)
|
|
1039
|
+
if ipv6_neighbors is not None:
|
|
1040
|
+
pulumi.set(__self__, "ipv6_neighbors", ipv6_neighbors)
|
|
1041
|
+
if ipv6_networks is not None:
|
|
1042
|
+
pulumi.set(__self__, "ipv6_networks", ipv6_networks)
|
|
1043
|
+
if ipv6_originate is not None:
|
|
1044
|
+
pulumi.set(__self__, "ipv6_originate", ipv6_originate)
|
|
1045
|
+
if ipv6_originate_variable is not None:
|
|
1046
|
+
pulumi.set(__self__, "ipv6_originate_variable", ipv6_originate_variable)
|
|
1047
|
+
if ipv6_redistributes is not None:
|
|
1048
|
+
pulumi.set(__self__, "ipv6_redistributes", ipv6_redistributes)
|
|
1049
|
+
if ipv6_table_map_filter is not None:
|
|
1050
|
+
pulumi.set(__self__, "ipv6_table_map_filter", ipv6_table_map_filter)
|
|
1051
|
+
if ipv6_table_map_filter_variable is not None:
|
|
1052
|
+
pulumi.set(__self__, "ipv6_table_map_filter_variable", ipv6_table_map_filter_variable)
|
|
1053
|
+
if ipv6_table_map_route_policy_id is not None:
|
|
1054
|
+
pulumi.set(__self__, "ipv6_table_map_route_policy_id", ipv6_table_map_route_policy_id)
|
|
1055
|
+
if keepalive_time is not None:
|
|
1056
|
+
pulumi.set(__self__, "keepalive_time", keepalive_time)
|
|
1057
|
+
if keepalive_time_variable is not None:
|
|
1058
|
+
pulumi.set(__self__, "keepalive_time_variable", keepalive_time_variable)
|
|
1059
|
+
if local_routes_distance is not None:
|
|
1060
|
+
pulumi.set(__self__, "local_routes_distance", local_routes_distance)
|
|
1061
|
+
if local_routes_distance_variable is not None:
|
|
1062
|
+
pulumi.set(__self__, "local_routes_distance_variable", local_routes_distance_variable)
|
|
1063
|
+
if missing_med_as_worst is not None:
|
|
1064
|
+
pulumi.set(__self__, "missing_med_as_worst", missing_med_as_worst)
|
|
1065
|
+
if missing_med_as_worst_variable is not None:
|
|
1066
|
+
pulumi.set(__self__, "missing_med_as_worst_variable", missing_med_as_worst_variable)
|
|
1067
|
+
if multipath_relax is not None:
|
|
1068
|
+
pulumi.set(__self__, "multipath_relax", multipath_relax)
|
|
1069
|
+
if multipath_relax_variable is not None:
|
|
1070
|
+
pulumi.set(__self__, "multipath_relax_variable", multipath_relax_variable)
|
|
1071
|
+
if name is not None:
|
|
1072
|
+
pulumi.set(__self__, "name", name)
|
|
1073
|
+
if propagate_as_path is not None:
|
|
1074
|
+
pulumi.set(__self__, "propagate_as_path", propagate_as_path)
|
|
1075
|
+
if propagate_as_path_variable is not None:
|
|
1076
|
+
pulumi.set(__self__, "propagate_as_path_variable", propagate_as_path_variable)
|
|
1077
|
+
if propagate_community is not None:
|
|
1078
|
+
pulumi.set(__self__, "propagate_community", propagate_community)
|
|
1079
|
+
if propagate_community_variable is not None:
|
|
1080
|
+
pulumi.set(__self__, "propagate_community_variable", propagate_community_variable)
|
|
1081
|
+
if router_id is not None:
|
|
1082
|
+
pulumi.set(__self__, "router_id", router_id)
|
|
1083
|
+
if router_id_variable is not None:
|
|
1084
|
+
pulumi.set(__self__, "router_id_variable", router_id_variable)
|
|
1085
|
+
if version is not None:
|
|
1086
|
+
pulumi.set(__self__, "version", version)
|
|
1087
|
+
|
|
1088
|
+
@property
|
|
1089
|
+
@pulumi.getter(name="alwaysCompareMed")
|
|
1090
|
+
def always_compare_med(self) -> Optional[pulumi.Input[bool]]:
|
|
1091
|
+
"""
|
|
1092
|
+
Compare MEDs from all ASs when selecting active BGP paths - Default value: `false`
|
|
1093
|
+
"""
|
|
1094
|
+
return pulumi.get(self, "always_compare_med")
|
|
1095
|
+
|
|
1096
|
+
@always_compare_med.setter
|
|
1097
|
+
def always_compare_med(self, value: Optional[pulumi.Input[bool]]):
|
|
1098
|
+
pulumi.set(self, "always_compare_med", value)
|
|
1099
|
+
|
|
1100
|
+
@property
|
|
1101
|
+
@pulumi.getter(name="alwaysCompareMedVariable")
|
|
1102
|
+
def always_compare_med_variable(self) -> Optional[pulumi.Input[str]]:
|
|
1103
|
+
"""
|
|
1104
|
+
Variable name
|
|
1105
|
+
"""
|
|
1106
|
+
return pulumi.get(self, "always_compare_med_variable")
|
|
1107
|
+
|
|
1108
|
+
@always_compare_med_variable.setter
|
|
1109
|
+
def always_compare_med_variable(self, value: Optional[pulumi.Input[str]]):
|
|
1110
|
+
pulumi.set(self, "always_compare_med_variable", value)
|
|
1111
|
+
|
|
1112
|
+
@property
|
|
1113
|
+
@pulumi.getter(name="asNumber")
|
|
1114
|
+
def as_number(self) -> Optional[pulumi.Input[int]]:
|
|
1115
|
+
"""
|
|
1116
|
+
Set autonomous system number <1..4294967295> or <XX.YY>
|
|
1117
|
+
"""
|
|
1118
|
+
return pulumi.get(self, "as_number")
|
|
1119
|
+
|
|
1120
|
+
@as_number.setter
|
|
1121
|
+
def as_number(self, value: Optional[pulumi.Input[int]]):
|
|
1122
|
+
pulumi.set(self, "as_number", value)
|
|
1123
|
+
|
|
1124
|
+
@property
|
|
1125
|
+
@pulumi.getter(name="asNumberVariable")
|
|
1126
|
+
def as_number_variable(self) -> Optional[pulumi.Input[str]]:
|
|
1127
|
+
"""
|
|
1128
|
+
Variable name
|
|
1129
|
+
"""
|
|
1130
|
+
return pulumi.get(self, "as_number_variable")
|
|
1131
|
+
|
|
1132
|
+
@as_number_variable.setter
|
|
1133
|
+
def as_number_variable(self, value: Optional[pulumi.Input[str]]):
|
|
1134
|
+
pulumi.set(self, "as_number_variable", value)
|
|
1135
|
+
|
|
1136
|
+
@property
|
|
1137
|
+
@pulumi.getter(name="compareRouterId")
|
|
1138
|
+
def compare_router_id(self) -> Optional[pulumi.Input[bool]]:
|
|
1139
|
+
"""
|
|
1140
|
+
Compare router IDs when selecting active BGP paths - Default value: `false`
|
|
1141
|
+
"""
|
|
1142
|
+
return pulumi.get(self, "compare_router_id")
|
|
1143
|
+
|
|
1144
|
+
@compare_router_id.setter
|
|
1145
|
+
def compare_router_id(self, value: Optional[pulumi.Input[bool]]):
|
|
1146
|
+
pulumi.set(self, "compare_router_id", value)
|
|
1147
|
+
|
|
1148
|
+
@property
|
|
1149
|
+
@pulumi.getter(name="compareRouterIdVariable")
|
|
1150
|
+
def compare_router_id_variable(self) -> Optional[pulumi.Input[str]]:
|
|
1151
|
+
"""
|
|
1152
|
+
Variable name
|
|
1153
|
+
"""
|
|
1154
|
+
return pulumi.get(self, "compare_router_id_variable")
|
|
1155
|
+
|
|
1156
|
+
@compare_router_id_variable.setter
|
|
1157
|
+
def compare_router_id_variable(self, value: Optional[pulumi.Input[str]]):
|
|
1158
|
+
pulumi.set(self, "compare_router_id_variable", value)
|
|
1159
|
+
|
|
1160
|
+
@property
|
|
1161
|
+
@pulumi.getter
|
|
1162
|
+
def description(self) -> Optional[pulumi.Input[str]]:
|
|
1163
|
+
"""
|
|
1164
|
+
The description of the Feature
|
|
1165
|
+
"""
|
|
1166
|
+
return pulumi.get(self, "description")
|
|
1167
|
+
|
|
1168
|
+
@description.setter
|
|
1169
|
+
def description(self, value: Optional[pulumi.Input[str]]):
|
|
1170
|
+
pulumi.set(self, "description", value)
|
|
1171
|
+
|
|
1172
|
+
@property
|
|
1173
|
+
@pulumi.getter(name="deterministicMed")
|
|
1174
|
+
def deterministic_med(self) -> Optional[pulumi.Input[bool]]:
|
|
1175
|
+
"""
|
|
1176
|
+
Compare MEDs from all routes from same AS when selecting active BGP paths - Default value: `false`
|
|
1177
|
+
"""
|
|
1178
|
+
return pulumi.get(self, "deterministic_med")
|
|
1179
|
+
|
|
1180
|
+
@deterministic_med.setter
|
|
1181
|
+
def deterministic_med(self, value: Optional[pulumi.Input[bool]]):
|
|
1182
|
+
pulumi.set(self, "deterministic_med", value)
|
|
1183
|
+
|
|
1184
|
+
@property
|
|
1185
|
+
@pulumi.getter(name="deterministicMedVariable")
|
|
1186
|
+
def deterministic_med_variable(self) -> Optional[pulumi.Input[str]]:
|
|
1187
|
+
"""
|
|
1188
|
+
Variable name
|
|
1189
|
+
"""
|
|
1190
|
+
return pulumi.get(self, "deterministic_med_variable")
|
|
1191
|
+
|
|
1192
|
+
@deterministic_med_variable.setter
|
|
1193
|
+
def deterministic_med_variable(self, value: Optional[pulumi.Input[str]]):
|
|
1194
|
+
pulumi.set(self, "deterministic_med_variable", value)
|
|
1195
|
+
|
|
1196
|
+
@property
|
|
1197
|
+
@pulumi.getter(name="externalRoutesDistance")
|
|
1198
|
+
def external_routes_distance(self) -> Optional[pulumi.Input[int]]:
|
|
1199
|
+
"""
|
|
1200
|
+
Set administrative distance for external BGP routes - Range: `1`-`255` - Default value: `20`
|
|
1201
|
+
"""
|
|
1202
|
+
return pulumi.get(self, "external_routes_distance")
|
|
1203
|
+
|
|
1204
|
+
@external_routes_distance.setter
|
|
1205
|
+
def external_routes_distance(self, value: Optional[pulumi.Input[int]]):
|
|
1206
|
+
pulumi.set(self, "external_routes_distance", value)
|
|
1207
|
+
|
|
1208
|
+
@property
|
|
1209
|
+
@pulumi.getter(name="externalRoutesDistanceVariable")
|
|
1210
|
+
def external_routes_distance_variable(self) -> Optional[pulumi.Input[str]]:
|
|
1211
|
+
"""
|
|
1212
|
+
Variable name
|
|
1213
|
+
"""
|
|
1214
|
+
return pulumi.get(self, "external_routes_distance_variable")
|
|
1215
|
+
|
|
1216
|
+
@external_routes_distance_variable.setter
|
|
1217
|
+
def external_routes_distance_variable(self, value: Optional[pulumi.Input[str]]):
|
|
1218
|
+
pulumi.set(self, "external_routes_distance_variable", value)
|
|
1219
|
+
|
|
1220
|
+
@property
|
|
1221
|
+
@pulumi.getter(name="featureProfileId")
|
|
1222
|
+
def feature_profile_id(self) -> Optional[pulumi.Input[str]]:
|
|
1223
|
+
"""
|
|
1224
|
+
Feature Profile ID
|
|
1225
|
+
"""
|
|
1226
|
+
return pulumi.get(self, "feature_profile_id")
|
|
1227
|
+
|
|
1228
|
+
@feature_profile_id.setter
|
|
1229
|
+
def feature_profile_id(self, value: Optional[pulumi.Input[str]]):
|
|
1230
|
+
pulumi.set(self, "feature_profile_id", value)
|
|
1231
|
+
|
|
1232
|
+
@property
|
|
1233
|
+
@pulumi.getter(name="holdTime")
|
|
1234
|
+
def hold_time(self) -> Optional[pulumi.Input[int]]:
|
|
1235
|
+
"""
|
|
1236
|
+
Interval (seconds) not receiving a keepalive message declares a BGP peer down - Range: `0`-`65535` - Default value:
|
|
1237
|
+
`180`
|
|
1238
|
+
"""
|
|
1239
|
+
return pulumi.get(self, "hold_time")
|
|
1240
|
+
|
|
1241
|
+
@hold_time.setter
|
|
1242
|
+
def hold_time(self, value: Optional[pulumi.Input[int]]):
|
|
1243
|
+
pulumi.set(self, "hold_time", value)
|
|
1244
|
+
|
|
1245
|
+
@property
|
|
1246
|
+
@pulumi.getter(name="holdTimeVariable")
|
|
1247
|
+
def hold_time_variable(self) -> Optional[pulumi.Input[str]]:
|
|
1248
|
+
"""
|
|
1249
|
+
Variable name
|
|
1250
|
+
"""
|
|
1251
|
+
return pulumi.get(self, "hold_time_variable")
|
|
1252
|
+
|
|
1253
|
+
@hold_time_variable.setter
|
|
1254
|
+
def hold_time_variable(self, value: Optional[pulumi.Input[str]]):
|
|
1255
|
+
pulumi.set(self, "hold_time_variable", value)
|
|
1256
|
+
|
|
1257
|
+
@property
|
|
1258
|
+
@pulumi.getter(name="internalRoutesDistance")
|
|
1259
|
+
def internal_routes_distance(self) -> Optional[pulumi.Input[int]]:
|
|
1260
|
+
"""
|
|
1261
|
+
Set administrative distance for internal BGP routes - Range: `1`-`255` - Default value: `200`
|
|
1262
|
+
"""
|
|
1263
|
+
return pulumi.get(self, "internal_routes_distance")
|
|
1264
|
+
|
|
1265
|
+
@internal_routes_distance.setter
|
|
1266
|
+
def internal_routes_distance(self, value: Optional[pulumi.Input[int]]):
|
|
1267
|
+
pulumi.set(self, "internal_routes_distance", value)
|
|
1268
|
+
|
|
1269
|
+
@property
|
|
1270
|
+
@pulumi.getter(name="internalRoutesDistanceVariable")
|
|
1271
|
+
def internal_routes_distance_variable(self) -> Optional[pulumi.Input[str]]:
|
|
1272
|
+
"""
|
|
1273
|
+
Variable name
|
|
1274
|
+
"""
|
|
1275
|
+
return pulumi.get(self, "internal_routes_distance_variable")
|
|
1276
|
+
|
|
1277
|
+
@internal_routes_distance_variable.setter
|
|
1278
|
+
def internal_routes_distance_variable(self, value: Optional[pulumi.Input[str]]):
|
|
1279
|
+
pulumi.set(self, "internal_routes_distance_variable", value)
|
|
1280
|
+
|
|
1281
|
+
@property
|
|
1282
|
+
@pulumi.getter(name="ipv4AggregateAddresses")
|
|
1283
|
+
def ipv4_aggregate_addresses(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ServiceRoutingBgpFeatureIpv4AggregateAddressArgs']]]]:
|
|
1284
|
+
"""
|
|
1285
|
+
Aggregate prefixes in specific range
|
|
1286
|
+
"""
|
|
1287
|
+
return pulumi.get(self, "ipv4_aggregate_addresses")
|
|
1288
|
+
|
|
1289
|
+
@ipv4_aggregate_addresses.setter
|
|
1290
|
+
def ipv4_aggregate_addresses(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ServiceRoutingBgpFeatureIpv4AggregateAddressArgs']]]]):
|
|
1291
|
+
pulumi.set(self, "ipv4_aggregate_addresses", value)
|
|
1292
|
+
|
|
1293
|
+
@property
|
|
1294
|
+
@pulumi.getter(name="ipv4EibgpMaximumPaths")
|
|
1295
|
+
def ipv4_eibgp_maximum_paths(self) -> Optional[pulumi.Input[int]]:
|
|
1296
|
+
"""
|
|
1297
|
+
Set maximum number of parallel IBGP paths for multipath load sharing - Range: `1`-`32`
|
|
1298
|
+
"""
|
|
1299
|
+
return pulumi.get(self, "ipv4_eibgp_maximum_paths")
|
|
1300
|
+
|
|
1301
|
+
@ipv4_eibgp_maximum_paths.setter
|
|
1302
|
+
def ipv4_eibgp_maximum_paths(self, value: Optional[pulumi.Input[int]]):
|
|
1303
|
+
pulumi.set(self, "ipv4_eibgp_maximum_paths", value)
|
|
1304
|
+
|
|
1305
|
+
@property
|
|
1306
|
+
@pulumi.getter(name="ipv4EibgpMaximumPathsVariable")
|
|
1307
|
+
def ipv4_eibgp_maximum_paths_variable(self) -> Optional[pulumi.Input[str]]:
|
|
1308
|
+
"""
|
|
1309
|
+
Variable name
|
|
1310
|
+
"""
|
|
1311
|
+
return pulumi.get(self, "ipv4_eibgp_maximum_paths_variable")
|
|
1312
|
+
|
|
1313
|
+
@ipv4_eibgp_maximum_paths_variable.setter
|
|
1314
|
+
def ipv4_eibgp_maximum_paths_variable(self, value: Optional[pulumi.Input[str]]):
|
|
1315
|
+
pulumi.set(self, "ipv4_eibgp_maximum_paths_variable", value)
|
|
1316
|
+
|
|
1317
|
+
@property
|
|
1318
|
+
@pulumi.getter(name="ipv4Neighbors")
|
|
1319
|
+
def ipv4_neighbors(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ServiceRoutingBgpFeatureIpv4NeighborArgs']]]]:
|
|
1320
|
+
"""
|
|
1321
|
+
Set BGP IPv4 neighbors
|
|
1322
|
+
"""
|
|
1323
|
+
return pulumi.get(self, "ipv4_neighbors")
|
|
1324
|
+
|
|
1325
|
+
@ipv4_neighbors.setter
|
|
1326
|
+
def ipv4_neighbors(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ServiceRoutingBgpFeatureIpv4NeighborArgs']]]]):
|
|
1327
|
+
pulumi.set(self, "ipv4_neighbors", value)
|
|
1328
|
+
|
|
1329
|
+
@property
|
|
1330
|
+
@pulumi.getter(name="ipv4Networks")
|
|
1331
|
+
def ipv4_networks(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ServiceRoutingBgpFeatureIpv4NetworkArgs']]]]:
|
|
1332
|
+
"""
|
|
1333
|
+
Configure the networks for BGP to advertise
|
|
1334
|
+
"""
|
|
1335
|
+
return pulumi.get(self, "ipv4_networks")
|
|
1336
|
+
|
|
1337
|
+
@ipv4_networks.setter
|
|
1338
|
+
def ipv4_networks(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ServiceRoutingBgpFeatureIpv4NetworkArgs']]]]):
|
|
1339
|
+
pulumi.set(self, "ipv4_networks", value)
|
|
1340
|
+
|
|
1341
|
+
@property
|
|
1342
|
+
@pulumi.getter(name="ipv4Originate")
|
|
1343
|
+
def ipv4_originate(self) -> Optional[pulumi.Input[bool]]:
|
|
1344
|
+
"""
|
|
1345
|
+
BGP Default Information Originate - Default value: `false`
|
|
1346
|
+
"""
|
|
1347
|
+
return pulumi.get(self, "ipv4_originate")
|
|
1348
|
+
|
|
1349
|
+
@ipv4_originate.setter
|
|
1350
|
+
def ipv4_originate(self, value: Optional[pulumi.Input[bool]]):
|
|
1351
|
+
pulumi.set(self, "ipv4_originate", value)
|
|
1352
|
+
|
|
1353
|
+
@property
|
|
1354
|
+
@pulumi.getter(name="ipv4OriginateVariable")
|
|
1355
|
+
def ipv4_originate_variable(self) -> Optional[pulumi.Input[str]]:
|
|
1356
|
+
"""
|
|
1357
|
+
Variable name
|
|
1358
|
+
"""
|
|
1359
|
+
return pulumi.get(self, "ipv4_originate_variable")
|
|
1360
|
+
|
|
1361
|
+
@ipv4_originate_variable.setter
|
|
1362
|
+
def ipv4_originate_variable(self, value: Optional[pulumi.Input[str]]):
|
|
1363
|
+
pulumi.set(self, "ipv4_originate_variable", value)
|
|
1364
|
+
|
|
1365
|
+
@property
|
|
1366
|
+
@pulumi.getter(name="ipv4Redistributes")
|
|
1367
|
+
def ipv4_redistributes(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ServiceRoutingBgpFeatureIpv4RedistributeArgs']]]]:
|
|
1368
|
+
"""
|
|
1369
|
+
Redistribute routes into BGP
|
|
1370
|
+
"""
|
|
1371
|
+
return pulumi.get(self, "ipv4_redistributes")
|
|
1372
|
+
|
|
1373
|
+
@ipv4_redistributes.setter
|
|
1374
|
+
def ipv4_redistributes(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ServiceRoutingBgpFeatureIpv4RedistributeArgs']]]]):
|
|
1375
|
+
pulumi.set(self, "ipv4_redistributes", value)
|
|
1376
|
+
|
|
1377
|
+
@property
|
|
1378
|
+
@pulumi.getter(name="ipv4TableMapFilter")
|
|
1379
|
+
def ipv4_table_map_filter(self) -> Optional[pulumi.Input[bool]]:
|
|
1380
|
+
"""
|
|
1381
|
+
Table map filtered or not - Default value: `false`
|
|
1382
|
+
"""
|
|
1383
|
+
return pulumi.get(self, "ipv4_table_map_filter")
|
|
1384
|
+
|
|
1385
|
+
@ipv4_table_map_filter.setter
|
|
1386
|
+
def ipv4_table_map_filter(self, value: Optional[pulumi.Input[bool]]):
|
|
1387
|
+
pulumi.set(self, "ipv4_table_map_filter", value)
|
|
1388
|
+
|
|
1389
|
+
@property
|
|
1390
|
+
@pulumi.getter(name="ipv4TableMapFilterVariable")
|
|
1391
|
+
def ipv4_table_map_filter_variable(self) -> Optional[pulumi.Input[str]]:
|
|
1392
|
+
"""
|
|
1393
|
+
Variable name
|
|
1394
|
+
"""
|
|
1395
|
+
return pulumi.get(self, "ipv4_table_map_filter_variable")
|
|
1396
|
+
|
|
1397
|
+
@ipv4_table_map_filter_variable.setter
|
|
1398
|
+
def ipv4_table_map_filter_variable(self, value: Optional[pulumi.Input[str]]):
|
|
1399
|
+
pulumi.set(self, "ipv4_table_map_filter_variable", value)
|
|
1400
|
+
|
|
1401
|
+
@property
|
|
1402
|
+
@pulumi.getter(name="ipv4TableMapRoutePolicyId")
|
|
1403
|
+
def ipv4_table_map_route_policy_id(self) -> Optional[pulumi.Input[str]]:
|
|
1404
|
+
return pulumi.get(self, "ipv4_table_map_route_policy_id")
|
|
1405
|
+
|
|
1406
|
+
@ipv4_table_map_route_policy_id.setter
|
|
1407
|
+
def ipv4_table_map_route_policy_id(self, value: Optional[pulumi.Input[str]]):
|
|
1408
|
+
pulumi.set(self, "ipv4_table_map_route_policy_id", value)
|
|
1409
|
+
|
|
1410
|
+
@property
|
|
1411
|
+
@pulumi.getter(name="ipv6AggregateAddresses")
|
|
1412
|
+
def ipv6_aggregate_addresses(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ServiceRoutingBgpFeatureIpv6AggregateAddressArgs']]]]:
|
|
1413
|
+
"""
|
|
1414
|
+
IPv6 Aggregate prefixes in specific range
|
|
1415
|
+
"""
|
|
1416
|
+
return pulumi.get(self, "ipv6_aggregate_addresses")
|
|
1417
|
+
|
|
1418
|
+
@ipv6_aggregate_addresses.setter
|
|
1419
|
+
def ipv6_aggregate_addresses(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ServiceRoutingBgpFeatureIpv6AggregateAddressArgs']]]]):
|
|
1420
|
+
pulumi.set(self, "ipv6_aggregate_addresses", value)
|
|
1421
|
+
|
|
1422
|
+
@property
|
|
1423
|
+
@pulumi.getter(name="ipv6EibgpMaximumPaths")
|
|
1424
|
+
def ipv6_eibgp_maximum_paths(self) -> Optional[pulumi.Input[int]]:
|
|
1425
|
+
"""
|
|
1426
|
+
Set maximum number of parallel IBGP paths for multipath load sharing - Range: `1`-`32`
|
|
1427
|
+
"""
|
|
1428
|
+
return pulumi.get(self, "ipv6_eibgp_maximum_paths")
|
|
1429
|
+
|
|
1430
|
+
@ipv6_eibgp_maximum_paths.setter
|
|
1431
|
+
def ipv6_eibgp_maximum_paths(self, value: Optional[pulumi.Input[int]]):
|
|
1432
|
+
pulumi.set(self, "ipv6_eibgp_maximum_paths", value)
|
|
1433
|
+
|
|
1434
|
+
@property
|
|
1435
|
+
@pulumi.getter(name="ipv6EibgpMaximumPathsVariable")
|
|
1436
|
+
def ipv6_eibgp_maximum_paths_variable(self) -> Optional[pulumi.Input[str]]:
|
|
1437
|
+
"""
|
|
1438
|
+
Variable name
|
|
1439
|
+
"""
|
|
1440
|
+
return pulumi.get(self, "ipv6_eibgp_maximum_paths_variable")
|
|
1441
|
+
|
|
1442
|
+
@ipv6_eibgp_maximum_paths_variable.setter
|
|
1443
|
+
def ipv6_eibgp_maximum_paths_variable(self, value: Optional[pulumi.Input[str]]):
|
|
1444
|
+
pulumi.set(self, "ipv6_eibgp_maximum_paths_variable", value)
|
|
1445
|
+
|
|
1446
|
+
@property
|
|
1447
|
+
@pulumi.getter(name="ipv6Neighbors")
|
|
1448
|
+
def ipv6_neighbors(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ServiceRoutingBgpFeatureIpv6NeighborArgs']]]]:
|
|
1449
|
+
"""
|
|
1450
|
+
Set BGP IPv6 neighbors
|
|
1451
|
+
"""
|
|
1452
|
+
return pulumi.get(self, "ipv6_neighbors")
|
|
1453
|
+
|
|
1454
|
+
@ipv6_neighbors.setter
|
|
1455
|
+
def ipv6_neighbors(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ServiceRoutingBgpFeatureIpv6NeighborArgs']]]]):
|
|
1456
|
+
pulumi.set(self, "ipv6_neighbors", value)
|
|
1457
|
+
|
|
1458
|
+
@property
|
|
1459
|
+
@pulumi.getter(name="ipv6Networks")
|
|
1460
|
+
def ipv6_networks(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ServiceRoutingBgpFeatureIpv6NetworkArgs']]]]:
|
|
1461
|
+
"""
|
|
1462
|
+
Configure the networks for BGP to advertise
|
|
1463
|
+
"""
|
|
1464
|
+
return pulumi.get(self, "ipv6_networks")
|
|
1465
|
+
|
|
1466
|
+
@ipv6_networks.setter
|
|
1467
|
+
def ipv6_networks(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ServiceRoutingBgpFeatureIpv6NetworkArgs']]]]):
|
|
1468
|
+
pulumi.set(self, "ipv6_networks", value)
|
|
1469
|
+
|
|
1470
|
+
@property
|
|
1471
|
+
@pulumi.getter(name="ipv6Originate")
|
|
1472
|
+
def ipv6_originate(self) -> Optional[pulumi.Input[bool]]:
|
|
1473
|
+
"""
|
|
1474
|
+
BGP Default Information Originate - Default value: `false`
|
|
1475
|
+
"""
|
|
1476
|
+
return pulumi.get(self, "ipv6_originate")
|
|
1477
|
+
|
|
1478
|
+
@ipv6_originate.setter
|
|
1479
|
+
def ipv6_originate(self, value: Optional[pulumi.Input[bool]]):
|
|
1480
|
+
pulumi.set(self, "ipv6_originate", value)
|
|
1481
|
+
|
|
1482
|
+
@property
|
|
1483
|
+
@pulumi.getter(name="ipv6OriginateVariable")
|
|
1484
|
+
def ipv6_originate_variable(self) -> Optional[pulumi.Input[str]]:
|
|
1485
|
+
"""
|
|
1486
|
+
Variable name
|
|
1487
|
+
"""
|
|
1488
|
+
return pulumi.get(self, "ipv6_originate_variable")
|
|
1489
|
+
|
|
1490
|
+
@ipv6_originate_variable.setter
|
|
1491
|
+
def ipv6_originate_variable(self, value: Optional[pulumi.Input[str]]):
|
|
1492
|
+
pulumi.set(self, "ipv6_originate_variable", value)
|
|
1493
|
+
|
|
1494
|
+
@property
|
|
1495
|
+
@pulumi.getter(name="ipv6Redistributes")
|
|
1496
|
+
def ipv6_redistributes(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ServiceRoutingBgpFeatureIpv6RedistributeArgs']]]]:
|
|
1497
|
+
"""
|
|
1498
|
+
Redistribute routes into BGP
|
|
1499
|
+
"""
|
|
1500
|
+
return pulumi.get(self, "ipv6_redistributes")
|
|
1501
|
+
|
|
1502
|
+
@ipv6_redistributes.setter
|
|
1503
|
+
def ipv6_redistributes(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ServiceRoutingBgpFeatureIpv6RedistributeArgs']]]]):
|
|
1504
|
+
pulumi.set(self, "ipv6_redistributes", value)
|
|
1505
|
+
|
|
1506
|
+
@property
|
|
1507
|
+
@pulumi.getter(name="ipv6TableMapFilter")
|
|
1508
|
+
def ipv6_table_map_filter(self) -> Optional[pulumi.Input[bool]]:
|
|
1509
|
+
"""
|
|
1510
|
+
Table map filtered or not - Default value: `false`
|
|
1511
|
+
"""
|
|
1512
|
+
return pulumi.get(self, "ipv6_table_map_filter")
|
|
1513
|
+
|
|
1514
|
+
@ipv6_table_map_filter.setter
|
|
1515
|
+
def ipv6_table_map_filter(self, value: Optional[pulumi.Input[bool]]):
|
|
1516
|
+
pulumi.set(self, "ipv6_table_map_filter", value)
|
|
1517
|
+
|
|
1518
|
+
@property
|
|
1519
|
+
@pulumi.getter(name="ipv6TableMapFilterVariable")
|
|
1520
|
+
def ipv6_table_map_filter_variable(self) -> Optional[pulumi.Input[str]]:
|
|
1521
|
+
"""
|
|
1522
|
+
Variable name
|
|
1523
|
+
"""
|
|
1524
|
+
return pulumi.get(self, "ipv6_table_map_filter_variable")
|
|
1525
|
+
|
|
1526
|
+
@ipv6_table_map_filter_variable.setter
|
|
1527
|
+
def ipv6_table_map_filter_variable(self, value: Optional[pulumi.Input[str]]):
|
|
1528
|
+
pulumi.set(self, "ipv6_table_map_filter_variable", value)
|
|
1529
|
+
|
|
1530
|
+
@property
|
|
1531
|
+
@pulumi.getter(name="ipv6TableMapRoutePolicyId")
|
|
1532
|
+
def ipv6_table_map_route_policy_id(self) -> Optional[pulumi.Input[str]]:
|
|
1533
|
+
return pulumi.get(self, "ipv6_table_map_route_policy_id")
|
|
1534
|
+
|
|
1535
|
+
@ipv6_table_map_route_policy_id.setter
|
|
1536
|
+
def ipv6_table_map_route_policy_id(self, value: Optional[pulumi.Input[str]]):
|
|
1537
|
+
pulumi.set(self, "ipv6_table_map_route_policy_id", value)
|
|
1538
|
+
|
|
1539
|
+
@property
|
|
1540
|
+
@pulumi.getter(name="keepaliveTime")
|
|
1541
|
+
def keepalive_time(self) -> Optional[pulumi.Input[int]]:
|
|
1542
|
+
"""
|
|
1543
|
+
Interval (seconds) of keepalive messages sent to its BGP peer - Range: `0`-`65535` - Default value: `60`
|
|
1544
|
+
"""
|
|
1545
|
+
return pulumi.get(self, "keepalive_time")
|
|
1546
|
+
|
|
1547
|
+
@keepalive_time.setter
|
|
1548
|
+
def keepalive_time(self, value: Optional[pulumi.Input[int]]):
|
|
1549
|
+
pulumi.set(self, "keepalive_time", value)
|
|
1550
|
+
|
|
1551
|
+
@property
|
|
1552
|
+
@pulumi.getter(name="keepaliveTimeVariable")
|
|
1553
|
+
def keepalive_time_variable(self) -> Optional[pulumi.Input[str]]:
|
|
1554
|
+
"""
|
|
1555
|
+
Variable name
|
|
1556
|
+
"""
|
|
1557
|
+
return pulumi.get(self, "keepalive_time_variable")
|
|
1558
|
+
|
|
1559
|
+
@keepalive_time_variable.setter
|
|
1560
|
+
def keepalive_time_variable(self, value: Optional[pulumi.Input[str]]):
|
|
1561
|
+
pulumi.set(self, "keepalive_time_variable", value)
|
|
1562
|
+
|
|
1563
|
+
@property
|
|
1564
|
+
@pulumi.getter(name="localRoutesDistance")
|
|
1565
|
+
def local_routes_distance(self) -> Optional[pulumi.Input[int]]:
|
|
1566
|
+
"""
|
|
1567
|
+
Set administrative distance for local BGP routes - Range: `1`-`255` - Default value: `20`
|
|
1568
|
+
"""
|
|
1569
|
+
return pulumi.get(self, "local_routes_distance")
|
|
1570
|
+
|
|
1571
|
+
@local_routes_distance.setter
|
|
1572
|
+
def local_routes_distance(self, value: Optional[pulumi.Input[int]]):
|
|
1573
|
+
pulumi.set(self, "local_routes_distance", value)
|
|
1574
|
+
|
|
1575
|
+
@property
|
|
1576
|
+
@pulumi.getter(name="localRoutesDistanceVariable")
|
|
1577
|
+
def local_routes_distance_variable(self) -> Optional[pulumi.Input[str]]:
|
|
1578
|
+
"""
|
|
1579
|
+
Variable name
|
|
1580
|
+
"""
|
|
1581
|
+
return pulumi.get(self, "local_routes_distance_variable")
|
|
1582
|
+
|
|
1583
|
+
@local_routes_distance_variable.setter
|
|
1584
|
+
def local_routes_distance_variable(self, value: Optional[pulumi.Input[str]]):
|
|
1585
|
+
pulumi.set(self, "local_routes_distance_variable", value)
|
|
1586
|
+
|
|
1587
|
+
@property
|
|
1588
|
+
@pulumi.getter(name="missingMedAsWorst")
|
|
1589
|
+
def missing_med_as_worst(self) -> Optional[pulumi.Input[bool]]:
|
|
1590
|
+
"""
|
|
1591
|
+
If path has no MED, consider it to be worst path when selecting active BGP paths - Default value: `false`
|
|
1592
|
+
"""
|
|
1593
|
+
return pulumi.get(self, "missing_med_as_worst")
|
|
1594
|
+
|
|
1595
|
+
@missing_med_as_worst.setter
|
|
1596
|
+
def missing_med_as_worst(self, value: Optional[pulumi.Input[bool]]):
|
|
1597
|
+
pulumi.set(self, "missing_med_as_worst", value)
|
|
1598
|
+
|
|
1599
|
+
@property
|
|
1600
|
+
@pulumi.getter(name="missingMedAsWorstVariable")
|
|
1601
|
+
def missing_med_as_worst_variable(self) -> Optional[pulumi.Input[str]]:
|
|
1602
|
+
"""
|
|
1603
|
+
Variable name
|
|
1604
|
+
"""
|
|
1605
|
+
return pulumi.get(self, "missing_med_as_worst_variable")
|
|
1606
|
+
|
|
1607
|
+
@missing_med_as_worst_variable.setter
|
|
1608
|
+
def missing_med_as_worst_variable(self, value: Optional[pulumi.Input[str]]):
|
|
1609
|
+
pulumi.set(self, "missing_med_as_worst_variable", value)
|
|
1610
|
+
|
|
1611
|
+
@property
|
|
1612
|
+
@pulumi.getter(name="multipathRelax")
|
|
1613
|
+
def multipath_relax(self) -> Optional[pulumi.Input[bool]]:
|
|
1614
|
+
"""
|
|
1615
|
+
Ignore AS for multipath selection - Default value: `false`
|
|
1616
|
+
"""
|
|
1617
|
+
return pulumi.get(self, "multipath_relax")
|
|
1618
|
+
|
|
1619
|
+
@multipath_relax.setter
|
|
1620
|
+
def multipath_relax(self, value: Optional[pulumi.Input[bool]]):
|
|
1621
|
+
pulumi.set(self, "multipath_relax", value)
|
|
1622
|
+
|
|
1623
|
+
@property
|
|
1624
|
+
@pulumi.getter(name="multipathRelaxVariable")
|
|
1625
|
+
def multipath_relax_variable(self) -> Optional[pulumi.Input[str]]:
|
|
1626
|
+
"""
|
|
1627
|
+
Variable name
|
|
1628
|
+
"""
|
|
1629
|
+
return pulumi.get(self, "multipath_relax_variable")
|
|
1630
|
+
|
|
1631
|
+
@multipath_relax_variable.setter
|
|
1632
|
+
def multipath_relax_variable(self, value: Optional[pulumi.Input[str]]):
|
|
1633
|
+
pulumi.set(self, "multipath_relax_variable", value)
|
|
1634
|
+
|
|
1635
|
+
@property
|
|
1636
|
+
@pulumi.getter
|
|
1637
|
+
def name(self) -> Optional[pulumi.Input[str]]:
|
|
1638
|
+
"""
|
|
1639
|
+
The name of the Feature
|
|
1640
|
+
"""
|
|
1641
|
+
return pulumi.get(self, "name")
|
|
1642
|
+
|
|
1643
|
+
@name.setter
|
|
1644
|
+
def name(self, value: Optional[pulumi.Input[str]]):
|
|
1645
|
+
pulumi.set(self, "name", value)
|
|
1646
|
+
|
|
1647
|
+
@property
|
|
1648
|
+
@pulumi.getter(name="propagateAsPath")
|
|
1649
|
+
def propagate_as_path(self) -> Optional[pulumi.Input[bool]]:
|
|
1650
|
+
"""
|
|
1651
|
+
Propagate AS Path - Default value: `false`
|
|
1652
|
+
"""
|
|
1653
|
+
return pulumi.get(self, "propagate_as_path")
|
|
1654
|
+
|
|
1655
|
+
@propagate_as_path.setter
|
|
1656
|
+
def propagate_as_path(self, value: Optional[pulumi.Input[bool]]):
|
|
1657
|
+
pulumi.set(self, "propagate_as_path", value)
|
|
1658
|
+
|
|
1659
|
+
@property
|
|
1660
|
+
@pulumi.getter(name="propagateAsPathVariable")
|
|
1661
|
+
def propagate_as_path_variable(self) -> Optional[pulumi.Input[str]]:
|
|
1662
|
+
"""
|
|
1663
|
+
Variable name
|
|
1664
|
+
"""
|
|
1665
|
+
return pulumi.get(self, "propagate_as_path_variable")
|
|
1666
|
+
|
|
1667
|
+
@propagate_as_path_variable.setter
|
|
1668
|
+
def propagate_as_path_variable(self, value: Optional[pulumi.Input[str]]):
|
|
1669
|
+
pulumi.set(self, "propagate_as_path_variable", value)
|
|
1670
|
+
|
|
1671
|
+
@property
|
|
1672
|
+
@pulumi.getter(name="propagateCommunity")
|
|
1673
|
+
def propagate_community(self) -> Optional[pulumi.Input[bool]]:
|
|
1674
|
+
"""
|
|
1675
|
+
Propagate Community - Default value: `false`
|
|
1676
|
+
"""
|
|
1677
|
+
return pulumi.get(self, "propagate_community")
|
|
1678
|
+
|
|
1679
|
+
@propagate_community.setter
|
|
1680
|
+
def propagate_community(self, value: Optional[pulumi.Input[bool]]):
|
|
1681
|
+
pulumi.set(self, "propagate_community", value)
|
|
1682
|
+
|
|
1683
|
+
@property
|
|
1684
|
+
@pulumi.getter(name="propagateCommunityVariable")
|
|
1685
|
+
def propagate_community_variable(self) -> Optional[pulumi.Input[str]]:
|
|
1686
|
+
"""
|
|
1687
|
+
Variable name
|
|
1688
|
+
"""
|
|
1689
|
+
return pulumi.get(self, "propagate_community_variable")
|
|
1690
|
+
|
|
1691
|
+
@propagate_community_variable.setter
|
|
1692
|
+
def propagate_community_variable(self, value: Optional[pulumi.Input[str]]):
|
|
1693
|
+
pulumi.set(self, "propagate_community_variable", value)
|
|
1694
|
+
|
|
1695
|
+
@property
|
|
1696
|
+
@pulumi.getter(name="routerId")
|
|
1697
|
+
def router_id(self) -> Optional[pulumi.Input[str]]:
|
|
1698
|
+
"""
|
|
1699
|
+
Configure BGP router identifier
|
|
1700
|
+
"""
|
|
1701
|
+
return pulumi.get(self, "router_id")
|
|
1702
|
+
|
|
1703
|
+
@router_id.setter
|
|
1704
|
+
def router_id(self, value: Optional[pulumi.Input[str]]):
|
|
1705
|
+
pulumi.set(self, "router_id", value)
|
|
1706
|
+
|
|
1707
|
+
@property
|
|
1708
|
+
@pulumi.getter(name="routerIdVariable")
|
|
1709
|
+
def router_id_variable(self) -> Optional[pulumi.Input[str]]:
|
|
1710
|
+
"""
|
|
1711
|
+
Variable name
|
|
1712
|
+
"""
|
|
1713
|
+
return pulumi.get(self, "router_id_variable")
|
|
1714
|
+
|
|
1715
|
+
@router_id_variable.setter
|
|
1716
|
+
def router_id_variable(self, value: Optional[pulumi.Input[str]]):
|
|
1717
|
+
pulumi.set(self, "router_id_variable", value)
|
|
1718
|
+
|
|
1719
|
+
@property
|
|
1720
|
+
@pulumi.getter
|
|
1721
|
+
def version(self) -> Optional[pulumi.Input[int]]:
|
|
1722
|
+
"""
|
|
1723
|
+
The version of the Feature
|
|
1724
|
+
"""
|
|
1725
|
+
return pulumi.get(self, "version")
|
|
1726
|
+
|
|
1727
|
+
@version.setter
|
|
1728
|
+
def version(self, value: Optional[pulumi.Input[int]]):
|
|
1729
|
+
pulumi.set(self, "version", value)
|
|
1730
|
+
|
|
1731
|
+
|
|
1732
|
+
class ServiceRoutingBgpFeature(pulumi.CustomResource):
|
|
1733
|
+
@overload
|
|
1734
|
+
def __init__(__self__,
|
|
1735
|
+
resource_name: str,
|
|
1736
|
+
opts: Optional[pulumi.ResourceOptions] = None,
|
|
1737
|
+
always_compare_med: Optional[pulumi.Input[bool]] = None,
|
|
1738
|
+
always_compare_med_variable: Optional[pulumi.Input[str]] = None,
|
|
1739
|
+
as_number: Optional[pulumi.Input[int]] = None,
|
|
1740
|
+
as_number_variable: Optional[pulumi.Input[str]] = None,
|
|
1741
|
+
compare_router_id: Optional[pulumi.Input[bool]] = None,
|
|
1742
|
+
compare_router_id_variable: Optional[pulumi.Input[str]] = None,
|
|
1743
|
+
description: Optional[pulumi.Input[str]] = None,
|
|
1744
|
+
deterministic_med: Optional[pulumi.Input[bool]] = None,
|
|
1745
|
+
deterministic_med_variable: Optional[pulumi.Input[str]] = None,
|
|
1746
|
+
external_routes_distance: Optional[pulumi.Input[int]] = None,
|
|
1747
|
+
external_routes_distance_variable: Optional[pulumi.Input[str]] = None,
|
|
1748
|
+
feature_profile_id: Optional[pulumi.Input[str]] = None,
|
|
1749
|
+
hold_time: Optional[pulumi.Input[int]] = None,
|
|
1750
|
+
hold_time_variable: Optional[pulumi.Input[str]] = None,
|
|
1751
|
+
internal_routes_distance: Optional[pulumi.Input[int]] = None,
|
|
1752
|
+
internal_routes_distance_variable: Optional[pulumi.Input[str]] = None,
|
|
1753
|
+
ipv4_aggregate_addresses: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ServiceRoutingBgpFeatureIpv4AggregateAddressArgs', 'ServiceRoutingBgpFeatureIpv4AggregateAddressArgsDict']]]]] = None,
|
|
1754
|
+
ipv4_eibgp_maximum_paths: Optional[pulumi.Input[int]] = None,
|
|
1755
|
+
ipv4_eibgp_maximum_paths_variable: Optional[pulumi.Input[str]] = None,
|
|
1756
|
+
ipv4_neighbors: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ServiceRoutingBgpFeatureIpv4NeighborArgs', 'ServiceRoutingBgpFeatureIpv4NeighborArgsDict']]]]] = None,
|
|
1757
|
+
ipv4_networks: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ServiceRoutingBgpFeatureIpv4NetworkArgs', 'ServiceRoutingBgpFeatureIpv4NetworkArgsDict']]]]] = None,
|
|
1758
|
+
ipv4_originate: Optional[pulumi.Input[bool]] = None,
|
|
1759
|
+
ipv4_originate_variable: Optional[pulumi.Input[str]] = None,
|
|
1760
|
+
ipv4_redistributes: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ServiceRoutingBgpFeatureIpv4RedistributeArgs', 'ServiceRoutingBgpFeatureIpv4RedistributeArgsDict']]]]] = None,
|
|
1761
|
+
ipv4_table_map_filter: Optional[pulumi.Input[bool]] = None,
|
|
1762
|
+
ipv4_table_map_filter_variable: Optional[pulumi.Input[str]] = None,
|
|
1763
|
+
ipv4_table_map_route_policy_id: Optional[pulumi.Input[str]] = None,
|
|
1764
|
+
ipv6_aggregate_addresses: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ServiceRoutingBgpFeatureIpv6AggregateAddressArgs', 'ServiceRoutingBgpFeatureIpv6AggregateAddressArgsDict']]]]] = None,
|
|
1765
|
+
ipv6_eibgp_maximum_paths: Optional[pulumi.Input[int]] = None,
|
|
1766
|
+
ipv6_eibgp_maximum_paths_variable: Optional[pulumi.Input[str]] = None,
|
|
1767
|
+
ipv6_neighbors: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ServiceRoutingBgpFeatureIpv6NeighborArgs', 'ServiceRoutingBgpFeatureIpv6NeighborArgsDict']]]]] = None,
|
|
1768
|
+
ipv6_networks: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ServiceRoutingBgpFeatureIpv6NetworkArgs', 'ServiceRoutingBgpFeatureIpv6NetworkArgsDict']]]]] = None,
|
|
1769
|
+
ipv6_originate: Optional[pulumi.Input[bool]] = None,
|
|
1770
|
+
ipv6_originate_variable: Optional[pulumi.Input[str]] = None,
|
|
1771
|
+
ipv6_redistributes: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ServiceRoutingBgpFeatureIpv6RedistributeArgs', 'ServiceRoutingBgpFeatureIpv6RedistributeArgsDict']]]]] = None,
|
|
1772
|
+
ipv6_table_map_filter: Optional[pulumi.Input[bool]] = None,
|
|
1773
|
+
ipv6_table_map_filter_variable: Optional[pulumi.Input[str]] = None,
|
|
1774
|
+
ipv6_table_map_route_policy_id: Optional[pulumi.Input[str]] = None,
|
|
1775
|
+
keepalive_time: Optional[pulumi.Input[int]] = None,
|
|
1776
|
+
keepalive_time_variable: Optional[pulumi.Input[str]] = None,
|
|
1777
|
+
local_routes_distance: Optional[pulumi.Input[int]] = None,
|
|
1778
|
+
local_routes_distance_variable: Optional[pulumi.Input[str]] = None,
|
|
1779
|
+
missing_med_as_worst: Optional[pulumi.Input[bool]] = None,
|
|
1780
|
+
missing_med_as_worst_variable: Optional[pulumi.Input[str]] = None,
|
|
1781
|
+
multipath_relax: Optional[pulumi.Input[bool]] = None,
|
|
1782
|
+
multipath_relax_variable: Optional[pulumi.Input[str]] = None,
|
|
1783
|
+
name: Optional[pulumi.Input[str]] = None,
|
|
1784
|
+
propagate_as_path: Optional[pulumi.Input[bool]] = None,
|
|
1785
|
+
propagate_as_path_variable: Optional[pulumi.Input[str]] = None,
|
|
1786
|
+
propagate_community: Optional[pulumi.Input[bool]] = None,
|
|
1787
|
+
propagate_community_variable: Optional[pulumi.Input[str]] = None,
|
|
1788
|
+
router_id: Optional[pulumi.Input[str]] = None,
|
|
1789
|
+
router_id_variable: Optional[pulumi.Input[str]] = None,
|
|
1790
|
+
__props__=None):
|
|
1791
|
+
"""
|
|
1792
|
+
This resource can manage a Service Routing BGP Feature.
|
|
1793
|
+
- Minimum SD-WAN Manager version: `20.12.0`
|
|
1794
|
+
|
|
1795
|
+
## Import
|
|
1796
|
+
|
|
1797
|
+
```sh
|
|
1798
|
+
$ pulumi import sdwan:index/serviceRoutingBgpFeature:ServiceRoutingBgpFeature example "f6b2c44c-693c-4763-b010-895aa3d236bd"
|
|
1799
|
+
```
|
|
1800
|
+
|
|
1801
|
+
:param str resource_name: The name of the resource.
|
|
1802
|
+
:param pulumi.ResourceOptions opts: Options for the resource.
|
|
1803
|
+
:param pulumi.Input[bool] always_compare_med: Compare MEDs from all ASs when selecting active BGP paths - Default value: `false`
|
|
1804
|
+
:param pulumi.Input[str] always_compare_med_variable: Variable name
|
|
1805
|
+
:param pulumi.Input[int] as_number: Set autonomous system number <1..4294967295> or <XX.YY>
|
|
1806
|
+
:param pulumi.Input[str] as_number_variable: Variable name
|
|
1807
|
+
:param pulumi.Input[bool] compare_router_id: Compare router IDs when selecting active BGP paths - Default value: `false`
|
|
1808
|
+
:param pulumi.Input[str] compare_router_id_variable: Variable name
|
|
1809
|
+
:param pulumi.Input[str] description: The description of the Feature
|
|
1810
|
+
:param pulumi.Input[bool] deterministic_med: Compare MEDs from all routes from same AS when selecting active BGP paths - Default value: `false`
|
|
1811
|
+
:param pulumi.Input[str] deterministic_med_variable: Variable name
|
|
1812
|
+
:param pulumi.Input[int] external_routes_distance: Set administrative distance for external BGP routes - Range: `1`-`255` - Default value: `20`
|
|
1813
|
+
:param pulumi.Input[str] external_routes_distance_variable: Variable name
|
|
1814
|
+
:param pulumi.Input[str] feature_profile_id: Feature Profile ID
|
|
1815
|
+
:param pulumi.Input[int] hold_time: Interval (seconds) not receiving a keepalive message declares a BGP peer down - Range: `0`-`65535` - Default value:
|
|
1816
|
+
`180`
|
|
1817
|
+
:param pulumi.Input[str] hold_time_variable: Variable name
|
|
1818
|
+
:param pulumi.Input[int] internal_routes_distance: Set administrative distance for internal BGP routes - Range: `1`-`255` - Default value: `200`
|
|
1819
|
+
:param pulumi.Input[str] internal_routes_distance_variable: Variable name
|
|
1820
|
+
:param pulumi.Input[Sequence[pulumi.Input[Union['ServiceRoutingBgpFeatureIpv4AggregateAddressArgs', 'ServiceRoutingBgpFeatureIpv4AggregateAddressArgsDict']]]] ipv4_aggregate_addresses: Aggregate prefixes in specific range
|
|
1821
|
+
:param pulumi.Input[int] ipv4_eibgp_maximum_paths: Set maximum number of parallel IBGP paths for multipath load sharing - Range: `1`-`32`
|
|
1822
|
+
:param pulumi.Input[str] ipv4_eibgp_maximum_paths_variable: Variable name
|
|
1823
|
+
:param pulumi.Input[Sequence[pulumi.Input[Union['ServiceRoutingBgpFeatureIpv4NeighborArgs', 'ServiceRoutingBgpFeatureIpv4NeighborArgsDict']]]] ipv4_neighbors: Set BGP IPv4 neighbors
|
|
1824
|
+
:param pulumi.Input[Sequence[pulumi.Input[Union['ServiceRoutingBgpFeatureIpv4NetworkArgs', 'ServiceRoutingBgpFeatureIpv4NetworkArgsDict']]]] ipv4_networks: Configure the networks for BGP to advertise
|
|
1825
|
+
:param pulumi.Input[bool] ipv4_originate: BGP Default Information Originate - Default value: `false`
|
|
1826
|
+
:param pulumi.Input[str] ipv4_originate_variable: Variable name
|
|
1827
|
+
:param pulumi.Input[Sequence[pulumi.Input[Union['ServiceRoutingBgpFeatureIpv4RedistributeArgs', 'ServiceRoutingBgpFeatureIpv4RedistributeArgsDict']]]] ipv4_redistributes: Redistribute routes into BGP
|
|
1828
|
+
:param pulumi.Input[bool] ipv4_table_map_filter: Table map filtered or not - Default value: `false`
|
|
1829
|
+
:param pulumi.Input[str] ipv4_table_map_filter_variable: Variable name
|
|
1830
|
+
:param pulumi.Input[Sequence[pulumi.Input[Union['ServiceRoutingBgpFeatureIpv6AggregateAddressArgs', 'ServiceRoutingBgpFeatureIpv6AggregateAddressArgsDict']]]] ipv6_aggregate_addresses: IPv6 Aggregate prefixes in specific range
|
|
1831
|
+
:param pulumi.Input[int] ipv6_eibgp_maximum_paths: Set maximum number of parallel IBGP paths for multipath load sharing - Range: `1`-`32`
|
|
1832
|
+
:param pulumi.Input[str] ipv6_eibgp_maximum_paths_variable: Variable name
|
|
1833
|
+
:param pulumi.Input[Sequence[pulumi.Input[Union['ServiceRoutingBgpFeatureIpv6NeighborArgs', 'ServiceRoutingBgpFeatureIpv6NeighborArgsDict']]]] ipv6_neighbors: Set BGP IPv6 neighbors
|
|
1834
|
+
:param pulumi.Input[Sequence[pulumi.Input[Union['ServiceRoutingBgpFeatureIpv6NetworkArgs', 'ServiceRoutingBgpFeatureIpv6NetworkArgsDict']]]] ipv6_networks: Configure the networks for BGP to advertise
|
|
1835
|
+
:param pulumi.Input[bool] ipv6_originate: BGP Default Information Originate - Default value: `false`
|
|
1836
|
+
:param pulumi.Input[str] ipv6_originate_variable: Variable name
|
|
1837
|
+
:param pulumi.Input[Sequence[pulumi.Input[Union['ServiceRoutingBgpFeatureIpv6RedistributeArgs', 'ServiceRoutingBgpFeatureIpv6RedistributeArgsDict']]]] ipv6_redistributes: Redistribute routes into BGP
|
|
1838
|
+
:param pulumi.Input[bool] ipv6_table_map_filter: Table map filtered or not - Default value: `false`
|
|
1839
|
+
:param pulumi.Input[str] ipv6_table_map_filter_variable: Variable name
|
|
1840
|
+
:param pulumi.Input[int] keepalive_time: Interval (seconds) of keepalive messages sent to its BGP peer - Range: `0`-`65535` - Default value: `60`
|
|
1841
|
+
:param pulumi.Input[str] keepalive_time_variable: Variable name
|
|
1842
|
+
:param pulumi.Input[int] local_routes_distance: Set administrative distance for local BGP routes - Range: `1`-`255` - Default value: `20`
|
|
1843
|
+
:param pulumi.Input[str] local_routes_distance_variable: Variable name
|
|
1844
|
+
:param pulumi.Input[bool] missing_med_as_worst: If path has no MED, consider it to be worst path when selecting active BGP paths - Default value: `false`
|
|
1845
|
+
:param pulumi.Input[str] missing_med_as_worst_variable: Variable name
|
|
1846
|
+
:param pulumi.Input[bool] multipath_relax: Ignore AS for multipath selection - Default value: `false`
|
|
1847
|
+
:param pulumi.Input[str] multipath_relax_variable: Variable name
|
|
1848
|
+
:param pulumi.Input[str] name: The name of the Feature
|
|
1849
|
+
:param pulumi.Input[bool] propagate_as_path: Propagate AS Path - Default value: `false`
|
|
1850
|
+
:param pulumi.Input[str] propagate_as_path_variable: Variable name
|
|
1851
|
+
:param pulumi.Input[bool] propagate_community: Propagate Community - Default value: `false`
|
|
1852
|
+
:param pulumi.Input[str] propagate_community_variable: Variable name
|
|
1853
|
+
:param pulumi.Input[str] router_id: Configure BGP router identifier
|
|
1854
|
+
:param pulumi.Input[str] router_id_variable: Variable name
|
|
1855
|
+
"""
|
|
1856
|
+
...
|
|
1857
|
+
@overload
|
|
1858
|
+
def __init__(__self__,
|
|
1859
|
+
resource_name: str,
|
|
1860
|
+
args: Optional[ServiceRoutingBgpFeatureArgs] = None,
|
|
1861
|
+
opts: Optional[pulumi.ResourceOptions] = None):
|
|
1862
|
+
"""
|
|
1863
|
+
This resource can manage a Service Routing BGP Feature.
|
|
1864
|
+
- Minimum SD-WAN Manager version: `20.12.0`
|
|
1865
|
+
|
|
1866
|
+
## Import
|
|
1867
|
+
|
|
1868
|
+
```sh
|
|
1869
|
+
$ pulumi import sdwan:index/serviceRoutingBgpFeature:ServiceRoutingBgpFeature example "f6b2c44c-693c-4763-b010-895aa3d236bd"
|
|
1870
|
+
```
|
|
1871
|
+
|
|
1872
|
+
:param str resource_name: The name of the resource.
|
|
1873
|
+
:param ServiceRoutingBgpFeatureArgs args: The arguments to use to populate this resource's properties.
|
|
1874
|
+
:param pulumi.ResourceOptions opts: Options for the resource.
|
|
1875
|
+
"""
|
|
1876
|
+
...
|
|
1877
|
+
def __init__(__self__, resource_name: str, *args, **kwargs):
|
|
1878
|
+
resource_args, opts = _utilities.get_resource_args_opts(ServiceRoutingBgpFeatureArgs, pulumi.ResourceOptions, *args, **kwargs)
|
|
1879
|
+
if resource_args is not None:
|
|
1880
|
+
__self__._internal_init(resource_name, opts, **resource_args.__dict__)
|
|
1881
|
+
else:
|
|
1882
|
+
__self__._internal_init(resource_name, *args, **kwargs)
|
|
1883
|
+
|
|
1884
|
+
def _internal_init(__self__,
|
|
1885
|
+
resource_name: str,
|
|
1886
|
+
opts: Optional[pulumi.ResourceOptions] = None,
|
|
1887
|
+
always_compare_med: Optional[pulumi.Input[bool]] = None,
|
|
1888
|
+
always_compare_med_variable: Optional[pulumi.Input[str]] = None,
|
|
1889
|
+
as_number: Optional[pulumi.Input[int]] = None,
|
|
1890
|
+
as_number_variable: Optional[pulumi.Input[str]] = None,
|
|
1891
|
+
compare_router_id: Optional[pulumi.Input[bool]] = None,
|
|
1892
|
+
compare_router_id_variable: Optional[pulumi.Input[str]] = None,
|
|
1893
|
+
description: Optional[pulumi.Input[str]] = None,
|
|
1894
|
+
deterministic_med: Optional[pulumi.Input[bool]] = None,
|
|
1895
|
+
deterministic_med_variable: Optional[pulumi.Input[str]] = None,
|
|
1896
|
+
external_routes_distance: Optional[pulumi.Input[int]] = None,
|
|
1897
|
+
external_routes_distance_variable: Optional[pulumi.Input[str]] = None,
|
|
1898
|
+
feature_profile_id: Optional[pulumi.Input[str]] = None,
|
|
1899
|
+
hold_time: Optional[pulumi.Input[int]] = None,
|
|
1900
|
+
hold_time_variable: Optional[pulumi.Input[str]] = None,
|
|
1901
|
+
internal_routes_distance: Optional[pulumi.Input[int]] = None,
|
|
1902
|
+
internal_routes_distance_variable: Optional[pulumi.Input[str]] = None,
|
|
1903
|
+
ipv4_aggregate_addresses: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ServiceRoutingBgpFeatureIpv4AggregateAddressArgs', 'ServiceRoutingBgpFeatureIpv4AggregateAddressArgsDict']]]]] = None,
|
|
1904
|
+
ipv4_eibgp_maximum_paths: Optional[pulumi.Input[int]] = None,
|
|
1905
|
+
ipv4_eibgp_maximum_paths_variable: Optional[pulumi.Input[str]] = None,
|
|
1906
|
+
ipv4_neighbors: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ServiceRoutingBgpFeatureIpv4NeighborArgs', 'ServiceRoutingBgpFeatureIpv4NeighborArgsDict']]]]] = None,
|
|
1907
|
+
ipv4_networks: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ServiceRoutingBgpFeatureIpv4NetworkArgs', 'ServiceRoutingBgpFeatureIpv4NetworkArgsDict']]]]] = None,
|
|
1908
|
+
ipv4_originate: Optional[pulumi.Input[bool]] = None,
|
|
1909
|
+
ipv4_originate_variable: Optional[pulumi.Input[str]] = None,
|
|
1910
|
+
ipv4_redistributes: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ServiceRoutingBgpFeatureIpv4RedistributeArgs', 'ServiceRoutingBgpFeatureIpv4RedistributeArgsDict']]]]] = None,
|
|
1911
|
+
ipv4_table_map_filter: Optional[pulumi.Input[bool]] = None,
|
|
1912
|
+
ipv4_table_map_filter_variable: Optional[pulumi.Input[str]] = None,
|
|
1913
|
+
ipv4_table_map_route_policy_id: Optional[pulumi.Input[str]] = None,
|
|
1914
|
+
ipv6_aggregate_addresses: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ServiceRoutingBgpFeatureIpv6AggregateAddressArgs', 'ServiceRoutingBgpFeatureIpv6AggregateAddressArgsDict']]]]] = None,
|
|
1915
|
+
ipv6_eibgp_maximum_paths: Optional[pulumi.Input[int]] = None,
|
|
1916
|
+
ipv6_eibgp_maximum_paths_variable: Optional[pulumi.Input[str]] = None,
|
|
1917
|
+
ipv6_neighbors: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ServiceRoutingBgpFeatureIpv6NeighborArgs', 'ServiceRoutingBgpFeatureIpv6NeighborArgsDict']]]]] = None,
|
|
1918
|
+
ipv6_networks: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ServiceRoutingBgpFeatureIpv6NetworkArgs', 'ServiceRoutingBgpFeatureIpv6NetworkArgsDict']]]]] = None,
|
|
1919
|
+
ipv6_originate: Optional[pulumi.Input[bool]] = None,
|
|
1920
|
+
ipv6_originate_variable: Optional[pulumi.Input[str]] = None,
|
|
1921
|
+
ipv6_redistributes: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ServiceRoutingBgpFeatureIpv6RedistributeArgs', 'ServiceRoutingBgpFeatureIpv6RedistributeArgsDict']]]]] = None,
|
|
1922
|
+
ipv6_table_map_filter: Optional[pulumi.Input[bool]] = None,
|
|
1923
|
+
ipv6_table_map_filter_variable: Optional[pulumi.Input[str]] = None,
|
|
1924
|
+
ipv6_table_map_route_policy_id: Optional[pulumi.Input[str]] = None,
|
|
1925
|
+
keepalive_time: Optional[pulumi.Input[int]] = None,
|
|
1926
|
+
keepalive_time_variable: Optional[pulumi.Input[str]] = None,
|
|
1927
|
+
local_routes_distance: Optional[pulumi.Input[int]] = None,
|
|
1928
|
+
local_routes_distance_variable: Optional[pulumi.Input[str]] = None,
|
|
1929
|
+
missing_med_as_worst: Optional[pulumi.Input[bool]] = None,
|
|
1930
|
+
missing_med_as_worst_variable: Optional[pulumi.Input[str]] = None,
|
|
1931
|
+
multipath_relax: Optional[pulumi.Input[bool]] = None,
|
|
1932
|
+
multipath_relax_variable: Optional[pulumi.Input[str]] = None,
|
|
1933
|
+
name: Optional[pulumi.Input[str]] = None,
|
|
1934
|
+
propagate_as_path: Optional[pulumi.Input[bool]] = None,
|
|
1935
|
+
propagate_as_path_variable: Optional[pulumi.Input[str]] = None,
|
|
1936
|
+
propagate_community: Optional[pulumi.Input[bool]] = None,
|
|
1937
|
+
propagate_community_variable: Optional[pulumi.Input[str]] = None,
|
|
1938
|
+
router_id: Optional[pulumi.Input[str]] = None,
|
|
1939
|
+
router_id_variable: Optional[pulumi.Input[str]] = None,
|
|
1940
|
+
__props__=None):
|
|
1941
|
+
opts = pulumi.ResourceOptions.merge(_utilities.get_resource_opts_defaults(), opts)
|
|
1942
|
+
if not isinstance(opts, pulumi.ResourceOptions):
|
|
1943
|
+
raise TypeError('Expected resource options to be a ResourceOptions instance')
|
|
1944
|
+
if opts.id is None:
|
|
1945
|
+
if __props__ is not None:
|
|
1946
|
+
raise TypeError('__props__ is only valid when passed in combination with a valid opts.id to get an existing resource')
|
|
1947
|
+
__props__ = ServiceRoutingBgpFeatureArgs.__new__(ServiceRoutingBgpFeatureArgs)
|
|
1948
|
+
|
|
1949
|
+
__props__.__dict__["always_compare_med"] = always_compare_med
|
|
1950
|
+
__props__.__dict__["always_compare_med_variable"] = always_compare_med_variable
|
|
1951
|
+
__props__.__dict__["as_number"] = as_number
|
|
1952
|
+
__props__.__dict__["as_number_variable"] = as_number_variable
|
|
1953
|
+
__props__.__dict__["compare_router_id"] = compare_router_id
|
|
1954
|
+
__props__.__dict__["compare_router_id_variable"] = compare_router_id_variable
|
|
1955
|
+
__props__.__dict__["description"] = description
|
|
1956
|
+
__props__.__dict__["deterministic_med"] = deterministic_med
|
|
1957
|
+
__props__.__dict__["deterministic_med_variable"] = deterministic_med_variable
|
|
1958
|
+
__props__.__dict__["external_routes_distance"] = external_routes_distance
|
|
1959
|
+
__props__.__dict__["external_routes_distance_variable"] = external_routes_distance_variable
|
|
1960
|
+
__props__.__dict__["feature_profile_id"] = feature_profile_id
|
|
1961
|
+
__props__.__dict__["hold_time"] = hold_time
|
|
1962
|
+
__props__.__dict__["hold_time_variable"] = hold_time_variable
|
|
1963
|
+
__props__.__dict__["internal_routes_distance"] = internal_routes_distance
|
|
1964
|
+
__props__.__dict__["internal_routes_distance_variable"] = internal_routes_distance_variable
|
|
1965
|
+
__props__.__dict__["ipv4_aggregate_addresses"] = ipv4_aggregate_addresses
|
|
1966
|
+
__props__.__dict__["ipv4_eibgp_maximum_paths"] = ipv4_eibgp_maximum_paths
|
|
1967
|
+
__props__.__dict__["ipv4_eibgp_maximum_paths_variable"] = ipv4_eibgp_maximum_paths_variable
|
|
1968
|
+
__props__.__dict__["ipv4_neighbors"] = ipv4_neighbors
|
|
1969
|
+
__props__.__dict__["ipv4_networks"] = ipv4_networks
|
|
1970
|
+
__props__.__dict__["ipv4_originate"] = ipv4_originate
|
|
1971
|
+
__props__.__dict__["ipv4_originate_variable"] = ipv4_originate_variable
|
|
1972
|
+
__props__.__dict__["ipv4_redistributes"] = ipv4_redistributes
|
|
1973
|
+
__props__.__dict__["ipv4_table_map_filter"] = ipv4_table_map_filter
|
|
1974
|
+
__props__.__dict__["ipv4_table_map_filter_variable"] = ipv4_table_map_filter_variable
|
|
1975
|
+
__props__.__dict__["ipv4_table_map_route_policy_id"] = ipv4_table_map_route_policy_id
|
|
1976
|
+
__props__.__dict__["ipv6_aggregate_addresses"] = ipv6_aggregate_addresses
|
|
1977
|
+
__props__.__dict__["ipv6_eibgp_maximum_paths"] = ipv6_eibgp_maximum_paths
|
|
1978
|
+
__props__.__dict__["ipv6_eibgp_maximum_paths_variable"] = ipv6_eibgp_maximum_paths_variable
|
|
1979
|
+
__props__.__dict__["ipv6_neighbors"] = ipv6_neighbors
|
|
1980
|
+
__props__.__dict__["ipv6_networks"] = ipv6_networks
|
|
1981
|
+
__props__.__dict__["ipv6_originate"] = ipv6_originate
|
|
1982
|
+
__props__.__dict__["ipv6_originate_variable"] = ipv6_originate_variable
|
|
1983
|
+
__props__.__dict__["ipv6_redistributes"] = ipv6_redistributes
|
|
1984
|
+
__props__.__dict__["ipv6_table_map_filter"] = ipv6_table_map_filter
|
|
1985
|
+
__props__.__dict__["ipv6_table_map_filter_variable"] = ipv6_table_map_filter_variable
|
|
1986
|
+
__props__.__dict__["ipv6_table_map_route_policy_id"] = ipv6_table_map_route_policy_id
|
|
1987
|
+
__props__.__dict__["keepalive_time"] = keepalive_time
|
|
1988
|
+
__props__.__dict__["keepalive_time_variable"] = keepalive_time_variable
|
|
1989
|
+
__props__.__dict__["local_routes_distance"] = local_routes_distance
|
|
1990
|
+
__props__.__dict__["local_routes_distance_variable"] = local_routes_distance_variable
|
|
1991
|
+
__props__.__dict__["missing_med_as_worst"] = missing_med_as_worst
|
|
1992
|
+
__props__.__dict__["missing_med_as_worst_variable"] = missing_med_as_worst_variable
|
|
1993
|
+
__props__.__dict__["multipath_relax"] = multipath_relax
|
|
1994
|
+
__props__.__dict__["multipath_relax_variable"] = multipath_relax_variable
|
|
1995
|
+
__props__.__dict__["name"] = name
|
|
1996
|
+
__props__.__dict__["propagate_as_path"] = propagate_as_path
|
|
1997
|
+
__props__.__dict__["propagate_as_path_variable"] = propagate_as_path_variable
|
|
1998
|
+
__props__.__dict__["propagate_community"] = propagate_community
|
|
1999
|
+
__props__.__dict__["propagate_community_variable"] = propagate_community_variable
|
|
2000
|
+
__props__.__dict__["router_id"] = router_id
|
|
2001
|
+
__props__.__dict__["router_id_variable"] = router_id_variable
|
|
2002
|
+
__props__.__dict__["version"] = None
|
|
2003
|
+
super(ServiceRoutingBgpFeature, __self__).__init__(
|
|
2004
|
+
'sdwan:index/serviceRoutingBgpFeature:ServiceRoutingBgpFeature',
|
|
2005
|
+
resource_name,
|
|
2006
|
+
__props__,
|
|
2007
|
+
opts)
|
|
2008
|
+
|
|
2009
|
+
@staticmethod
|
|
2010
|
+
def get(resource_name: str,
|
|
2011
|
+
id: pulumi.Input[str],
|
|
2012
|
+
opts: Optional[pulumi.ResourceOptions] = None,
|
|
2013
|
+
always_compare_med: Optional[pulumi.Input[bool]] = None,
|
|
2014
|
+
always_compare_med_variable: Optional[pulumi.Input[str]] = None,
|
|
2015
|
+
as_number: Optional[pulumi.Input[int]] = None,
|
|
2016
|
+
as_number_variable: Optional[pulumi.Input[str]] = None,
|
|
2017
|
+
compare_router_id: Optional[pulumi.Input[bool]] = None,
|
|
2018
|
+
compare_router_id_variable: Optional[pulumi.Input[str]] = None,
|
|
2019
|
+
description: Optional[pulumi.Input[str]] = None,
|
|
2020
|
+
deterministic_med: Optional[pulumi.Input[bool]] = None,
|
|
2021
|
+
deterministic_med_variable: Optional[pulumi.Input[str]] = None,
|
|
2022
|
+
external_routes_distance: Optional[pulumi.Input[int]] = None,
|
|
2023
|
+
external_routes_distance_variable: Optional[pulumi.Input[str]] = None,
|
|
2024
|
+
feature_profile_id: Optional[pulumi.Input[str]] = None,
|
|
2025
|
+
hold_time: Optional[pulumi.Input[int]] = None,
|
|
2026
|
+
hold_time_variable: Optional[pulumi.Input[str]] = None,
|
|
2027
|
+
internal_routes_distance: Optional[pulumi.Input[int]] = None,
|
|
2028
|
+
internal_routes_distance_variable: Optional[pulumi.Input[str]] = None,
|
|
2029
|
+
ipv4_aggregate_addresses: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ServiceRoutingBgpFeatureIpv4AggregateAddressArgs', 'ServiceRoutingBgpFeatureIpv4AggregateAddressArgsDict']]]]] = None,
|
|
2030
|
+
ipv4_eibgp_maximum_paths: Optional[pulumi.Input[int]] = None,
|
|
2031
|
+
ipv4_eibgp_maximum_paths_variable: Optional[pulumi.Input[str]] = None,
|
|
2032
|
+
ipv4_neighbors: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ServiceRoutingBgpFeatureIpv4NeighborArgs', 'ServiceRoutingBgpFeatureIpv4NeighborArgsDict']]]]] = None,
|
|
2033
|
+
ipv4_networks: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ServiceRoutingBgpFeatureIpv4NetworkArgs', 'ServiceRoutingBgpFeatureIpv4NetworkArgsDict']]]]] = None,
|
|
2034
|
+
ipv4_originate: Optional[pulumi.Input[bool]] = None,
|
|
2035
|
+
ipv4_originate_variable: Optional[pulumi.Input[str]] = None,
|
|
2036
|
+
ipv4_redistributes: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ServiceRoutingBgpFeatureIpv4RedistributeArgs', 'ServiceRoutingBgpFeatureIpv4RedistributeArgsDict']]]]] = None,
|
|
2037
|
+
ipv4_table_map_filter: Optional[pulumi.Input[bool]] = None,
|
|
2038
|
+
ipv4_table_map_filter_variable: Optional[pulumi.Input[str]] = None,
|
|
2039
|
+
ipv4_table_map_route_policy_id: Optional[pulumi.Input[str]] = None,
|
|
2040
|
+
ipv6_aggregate_addresses: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ServiceRoutingBgpFeatureIpv6AggregateAddressArgs', 'ServiceRoutingBgpFeatureIpv6AggregateAddressArgsDict']]]]] = None,
|
|
2041
|
+
ipv6_eibgp_maximum_paths: Optional[pulumi.Input[int]] = None,
|
|
2042
|
+
ipv6_eibgp_maximum_paths_variable: Optional[pulumi.Input[str]] = None,
|
|
2043
|
+
ipv6_neighbors: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ServiceRoutingBgpFeatureIpv6NeighborArgs', 'ServiceRoutingBgpFeatureIpv6NeighborArgsDict']]]]] = None,
|
|
2044
|
+
ipv6_networks: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ServiceRoutingBgpFeatureIpv6NetworkArgs', 'ServiceRoutingBgpFeatureIpv6NetworkArgsDict']]]]] = None,
|
|
2045
|
+
ipv6_originate: Optional[pulumi.Input[bool]] = None,
|
|
2046
|
+
ipv6_originate_variable: Optional[pulumi.Input[str]] = None,
|
|
2047
|
+
ipv6_redistributes: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ServiceRoutingBgpFeatureIpv6RedistributeArgs', 'ServiceRoutingBgpFeatureIpv6RedistributeArgsDict']]]]] = None,
|
|
2048
|
+
ipv6_table_map_filter: Optional[pulumi.Input[bool]] = None,
|
|
2049
|
+
ipv6_table_map_filter_variable: Optional[pulumi.Input[str]] = None,
|
|
2050
|
+
ipv6_table_map_route_policy_id: Optional[pulumi.Input[str]] = None,
|
|
2051
|
+
keepalive_time: Optional[pulumi.Input[int]] = None,
|
|
2052
|
+
keepalive_time_variable: Optional[pulumi.Input[str]] = None,
|
|
2053
|
+
local_routes_distance: Optional[pulumi.Input[int]] = None,
|
|
2054
|
+
local_routes_distance_variable: Optional[pulumi.Input[str]] = None,
|
|
2055
|
+
missing_med_as_worst: Optional[pulumi.Input[bool]] = None,
|
|
2056
|
+
missing_med_as_worst_variable: Optional[pulumi.Input[str]] = None,
|
|
2057
|
+
multipath_relax: Optional[pulumi.Input[bool]] = None,
|
|
2058
|
+
multipath_relax_variable: Optional[pulumi.Input[str]] = None,
|
|
2059
|
+
name: Optional[pulumi.Input[str]] = None,
|
|
2060
|
+
propagate_as_path: Optional[pulumi.Input[bool]] = None,
|
|
2061
|
+
propagate_as_path_variable: Optional[pulumi.Input[str]] = None,
|
|
2062
|
+
propagate_community: Optional[pulumi.Input[bool]] = None,
|
|
2063
|
+
propagate_community_variable: Optional[pulumi.Input[str]] = None,
|
|
2064
|
+
router_id: Optional[pulumi.Input[str]] = None,
|
|
2065
|
+
router_id_variable: Optional[pulumi.Input[str]] = None,
|
|
2066
|
+
version: Optional[pulumi.Input[int]] = None) -> 'ServiceRoutingBgpFeature':
|
|
2067
|
+
"""
|
|
2068
|
+
Get an existing ServiceRoutingBgpFeature resource's state with the given name, id, and optional extra
|
|
2069
|
+
properties used to qualify the lookup.
|
|
2070
|
+
|
|
2071
|
+
:param str resource_name: The unique name of the resulting resource.
|
|
2072
|
+
:param pulumi.Input[str] id: The unique provider ID of the resource to lookup.
|
|
2073
|
+
:param pulumi.ResourceOptions opts: Options for the resource.
|
|
2074
|
+
:param pulumi.Input[bool] always_compare_med: Compare MEDs from all ASs when selecting active BGP paths - Default value: `false`
|
|
2075
|
+
:param pulumi.Input[str] always_compare_med_variable: Variable name
|
|
2076
|
+
:param pulumi.Input[int] as_number: Set autonomous system number <1..4294967295> or <XX.YY>
|
|
2077
|
+
:param pulumi.Input[str] as_number_variable: Variable name
|
|
2078
|
+
:param pulumi.Input[bool] compare_router_id: Compare router IDs when selecting active BGP paths - Default value: `false`
|
|
2079
|
+
:param pulumi.Input[str] compare_router_id_variable: Variable name
|
|
2080
|
+
:param pulumi.Input[str] description: The description of the Feature
|
|
2081
|
+
:param pulumi.Input[bool] deterministic_med: Compare MEDs from all routes from same AS when selecting active BGP paths - Default value: `false`
|
|
2082
|
+
:param pulumi.Input[str] deterministic_med_variable: Variable name
|
|
2083
|
+
:param pulumi.Input[int] external_routes_distance: Set administrative distance for external BGP routes - Range: `1`-`255` - Default value: `20`
|
|
2084
|
+
:param pulumi.Input[str] external_routes_distance_variable: Variable name
|
|
2085
|
+
:param pulumi.Input[str] feature_profile_id: Feature Profile ID
|
|
2086
|
+
:param pulumi.Input[int] hold_time: Interval (seconds) not receiving a keepalive message declares a BGP peer down - Range: `0`-`65535` - Default value:
|
|
2087
|
+
`180`
|
|
2088
|
+
:param pulumi.Input[str] hold_time_variable: Variable name
|
|
2089
|
+
:param pulumi.Input[int] internal_routes_distance: Set administrative distance for internal BGP routes - Range: `1`-`255` - Default value: `200`
|
|
2090
|
+
:param pulumi.Input[str] internal_routes_distance_variable: Variable name
|
|
2091
|
+
:param pulumi.Input[Sequence[pulumi.Input[Union['ServiceRoutingBgpFeatureIpv4AggregateAddressArgs', 'ServiceRoutingBgpFeatureIpv4AggregateAddressArgsDict']]]] ipv4_aggregate_addresses: Aggregate prefixes in specific range
|
|
2092
|
+
:param pulumi.Input[int] ipv4_eibgp_maximum_paths: Set maximum number of parallel IBGP paths for multipath load sharing - Range: `1`-`32`
|
|
2093
|
+
:param pulumi.Input[str] ipv4_eibgp_maximum_paths_variable: Variable name
|
|
2094
|
+
:param pulumi.Input[Sequence[pulumi.Input[Union['ServiceRoutingBgpFeatureIpv4NeighborArgs', 'ServiceRoutingBgpFeatureIpv4NeighborArgsDict']]]] ipv4_neighbors: Set BGP IPv4 neighbors
|
|
2095
|
+
:param pulumi.Input[Sequence[pulumi.Input[Union['ServiceRoutingBgpFeatureIpv4NetworkArgs', 'ServiceRoutingBgpFeatureIpv4NetworkArgsDict']]]] ipv4_networks: Configure the networks for BGP to advertise
|
|
2096
|
+
:param pulumi.Input[bool] ipv4_originate: BGP Default Information Originate - Default value: `false`
|
|
2097
|
+
:param pulumi.Input[str] ipv4_originate_variable: Variable name
|
|
2098
|
+
:param pulumi.Input[Sequence[pulumi.Input[Union['ServiceRoutingBgpFeatureIpv4RedistributeArgs', 'ServiceRoutingBgpFeatureIpv4RedistributeArgsDict']]]] ipv4_redistributes: Redistribute routes into BGP
|
|
2099
|
+
:param pulumi.Input[bool] ipv4_table_map_filter: Table map filtered or not - Default value: `false`
|
|
2100
|
+
:param pulumi.Input[str] ipv4_table_map_filter_variable: Variable name
|
|
2101
|
+
:param pulumi.Input[Sequence[pulumi.Input[Union['ServiceRoutingBgpFeatureIpv6AggregateAddressArgs', 'ServiceRoutingBgpFeatureIpv6AggregateAddressArgsDict']]]] ipv6_aggregate_addresses: IPv6 Aggregate prefixes in specific range
|
|
2102
|
+
:param pulumi.Input[int] ipv6_eibgp_maximum_paths: Set maximum number of parallel IBGP paths for multipath load sharing - Range: `1`-`32`
|
|
2103
|
+
:param pulumi.Input[str] ipv6_eibgp_maximum_paths_variable: Variable name
|
|
2104
|
+
:param pulumi.Input[Sequence[pulumi.Input[Union['ServiceRoutingBgpFeatureIpv6NeighborArgs', 'ServiceRoutingBgpFeatureIpv6NeighborArgsDict']]]] ipv6_neighbors: Set BGP IPv6 neighbors
|
|
2105
|
+
:param pulumi.Input[Sequence[pulumi.Input[Union['ServiceRoutingBgpFeatureIpv6NetworkArgs', 'ServiceRoutingBgpFeatureIpv6NetworkArgsDict']]]] ipv6_networks: Configure the networks for BGP to advertise
|
|
2106
|
+
:param pulumi.Input[bool] ipv6_originate: BGP Default Information Originate - Default value: `false`
|
|
2107
|
+
:param pulumi.Input[str] ipv6_originate_variable: Variable name
|
|
2108
|
+
:param pulumi.Input[Sequence[pulumi.Input[Union['ServiceRoutingBgpFeatureIpv6RedistributeArgs', 'ServiceRoutingBgpFeatureIpv6RedistributeArgsDict']]]] ipv6_redistributes: Redistribute routes into BGP
|
|
2109
|
+
:param pulumi.Input[bool] ipv6_table_map_filter: Table map filtered or not - Default value: `false`
|
|
2110
|
+
:param pulumi.Input[str] ipv6_table_map_filter_variable: Variable name
|
|
2111
|
+
:param pulumi.Input[int] keepalive_time: Interval (seconds) of keepalive messages sent to its BGP peer - Range: `0`-`65535` - Default value: `60`
|
|
2112
|
+
:param pulumi.Input[str] keepalive_time_variable: Variable name
|
|
2113
|
+
:param pulumi.Input[int] local_routes_distance: Set administrative distance for local BGP routes - Range: `1`-`255` - Default value: `20`
|
|
2114
|
+
:param pulumi.Input[str] local_routes_distance_variable: Variable name
|
|
2115
|
+
:param pulumi.Input[bool] missing_med_as_worst: If path has no MED, consider it to be worst path when selecting active BGP paths - Default value: `false`
|
|
2116
|
+
:param pulumi.Input[str] missing_med_as_worst_variable: Variable name
|
|
2117
|
+
:param pulumi.Input[bool] multipath_relax: Ignore AS for multipath selection - Default value: `false`
|
|
2118
|
+
:param pulumi.Input[str] multipath_relax_variable: Variable name
|
|
2119
|
+
:param pulumi.Input[str] name: The name of the Feature
|
|
2120
|
+
:param pulumi.Input[bool] propagate_as_path: Propagate AS Path - Default value: `false`
|
|
2121
|
+
:param pulumi.Input[str] propagate_as_path_variable: Variable name
|
|
2122
|
+
:param pulumi.Input[bool] propagate_community: Propagate Community - Default value: `false`
|
|
2123
|
+
:param pulumi.Input[str] propagate_community_variable: Variable name
|
|
2124
|
+
:param pulumi.Input[str] router_id: Configure BGP router identifier
|
|
2125
|
+
:param pulumi.Input[str] router_id_variable: Variable name
|
|
2126
|
+
:param pulumi.Input[int] version: The version of the Feature
|
|
2127
|
+
"""
|
|
2128
|
+
opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id))
|
|
2129
|
+
|
|
2130
|
+
__props__ = _ServiceRoutingBgpFeatureState.__new__(_ServiceRoutingBgpFeatureState)
|
|
2131
|
+
|
|
2132
|
+
__props__.__dict__["always_compare_med"] = always_compare_med
|
|
2133
|
+
__props__.__dict__["always_compare_med_variable"] = always_compare_med_variable
|
|
2134
|
+
__props__.__dict__["as_number"] = as_number
|
|
2135
|
+
__props__.__dict__["as_number_variable"] = as_number_variable
|
|
2136
|
+
__props__.__dict__["compare_router_id"] = compare_router_id
|
|
2137
|
+
__props__.__dict__["compare_router_id_variable"] = compare_router_id_variable
|
|
2138
|
+
__props__.__dict__["description"] = description
|
|
2139
|
+
__props__.__dict__["deterministic_med"] = deterministic_med
|
|
2140
|
+
__props__.__dict__["deterministic_med_variable"] = deterministic_med_variable
|
|
2141
|
+
__props__.__dict__["external_routes_distance"] = external_routes_distance
|
|
2142
|
+
__props__.__dict__["external_routes_distance_variable"] = external_routes_distance_variable
|
|
2143
|
+
__props__.__dict__["feature_profile_id"] = feature_profile_id
|
|
2144
|
+
__props__.__dict__["hold_time"] = hold_time
|
|
2145
|
+
__props__.__dict__["hold_time_variable"] = hold_time_variable
|
|
2146
|
+
__props__.__dict__["internal_routes_distance"] = internal_routes_distance
|
|
2147
|
+
__props__.__dict__["internal_routes_distance_variable"] = internal_routes_distance_variable
|
|
2148
|
+
__props__.__dict__["ipv4_aggregate_addresses"] = ipv4_aggregate_addresses
|
|
2149
|
+
__props__.__dict__["ipv4_eibgp_maximum_paths"] = ipv4_eibgp_maximum_paths
|
|
2150
|
+
__props__.__dict__["ipv4_eibgp_maximum_paths_variable"] = ipv4_eibgp_maximum_paths_variable
|
|
2151
|
+
__props__.__dict__["ipv4_neighbors"] = ipv4_neighbors
|
|
2152
|
+
__props__.__dict__["ipv4_networks"] = ipv4_networks
|
|
2153
|
+
__props__.__dict__["ipv4_originate"] = ipv4_originate
|
|
2154
|
+
__props__.__dict__["ipv4_originate_variable"] = ipv4_originate_variable
|
|
2155
|
+
__props__.__dict__["ipv4_redistributes"] = ipv4_redistributes
|
|
2156
|
+
__props__.__dict__["ipv4_table_map_filter"] = ipv4_table_map_filter
|
|
2157
|
+
__props__.__dict__["ipv4_table_map_filter_variable"] = ipv4_table_map_filter_variable
|
|
2158
|
+
__props__.__dict__["ipv4_table_map_route_policy_id"] = ipv4_table_map_route_policy_id
|
|
2159
|
+
__props__.__dict__["ipv6_aggregate_addresses"] = ipv6_aggregate_addresses
|
|
2160
|
+
__props__.__dict__["ipv6_eibgp_maximum_paths"] = ipv6_eibgp_maximum_paths
|
|
2161
|
+
__props__.__dict__["ipv6_eibgp_maximum_paths_variable"] = ipv6_eibgp_maximum_paths_variable
|
|
2162
|
+
__props__.__dict__["ipv6_neighbors"] = ipv6_neighbors
|
|
2163
|
+
__props__.__dict__["ipv6_networks"] = ipv6_networks
|
|
2164
|
+
__props__.__dict__["ipv6_originate"] = ipv6_originate
|
|
2165
|
+
__props__.__dict__["ipv6_originate_variable"] = ipv6_originate_variable
|
|
2166
|
+
__props__.__dict__["ipv6_redistributes"] = ipv6_redistributes
|
|
2167
|
+
__props__.__dict__["ipv6_table_map_filter"] = ipv6_table_map_filter
|
|
2168
|
+
__props__.__dict__["ipv6_table_map_filter_variable"] = ipv6_table_map_filter_variable
|
|
2169
|
+
__props__.__dict__["ipv6_table_map_route_policy_id"] = ipv6_table_map_route_policy_id
|
|
2170
|
+
__props__.__dict__["keepalive_time"] = keepalive_time
|
|
2171
|
+
__props__.__dict__["keepalive_time_variable"] = keepalive_time_variable
|
|
2172
|
+
__props__.__dict__["local_routes_distance"] = local_routes_distance
|
|
2173
|
+
__props__.__dict__["local_routes_distance_variable"] = local_routes_distance_variable
|
|
2174
|
+
__props__.__dict__["missing_med_as_worst"] = missing_med_as_worst
|
|
2175
|
+
__props__.__dict__["missing_med_as_worst_variable"] = missing_med_as_worst_variable
|
|
2176
|
+
__props__.__dict__["multipath_relax"] = multipath_relax
|
|
2177
|
+
__props__.__dict__["multipath_relax_variable"] = multipath_relax_variable
|
|
2178
|
+
__props__.__dict__["name"] = name
|
|
2179
|
+
__props__.__dict__["propagate_as_path"] = propagate_as_path
|
|
2180
|
+
__props__.__dict__["propagate_as_path_variable"] = propagate_as_path_variable
|
|
2181
|
+
__props__.__dict__["propagate_community"] = propagate_community
|
|
2182
|
+
__props__.__dict__["propagate_community_variable"] = propagate_community_variable
|
|
2183
|
+
__props__.__dict__["router_id"] = router_id
|
|
2184
|
+
__props__.__dict__["router_id_variable"] = router_id_variable
|
|
2185
|
+
__props__.__dict__["version"] = version
|
|
2186
|
+
return ServiceRoutingBgpFeature(resource_name, opts=opts, __props__=__props__)
|
|
2187
|
+
|
|
2188
|
+
@property
|
|
2189
|
+
@pulumi.getter(name="alwaysCompareMed")
|
|
2190
|
+
def always_compare_med(self) -> pulumi.Output[Optional[bool]]:
|
|
2191
|
+
"""
|
|
2192
|
+
Compare MEDs from all ASs when selecting active BGP paths - Default value: `false`
|
|
2193
|
+
"""
|
|
2194
|
+
return pulumi.get(self, "always_compare_med")
|
|
2195
|
+
|
|
2196
|
+
@property
|
|
2197
|
+
@pulumi.getter(name="alwaysCompareMedVariable")
|
|
2198
|
+
def always_compare_med_variable(self) -> pulumi.Output[Optional[str]]:
|
|
2199
|
+
"""
|
|
2200
|
+
Variable name
|
|
2201
|
+
"""
|
|
2202
|
+
return pulumi.get(self, "always_compare_med_variable")
|
|
2203
|
+
|
|
2204
|
+
@property
|
|
2205
|
+
@pulumi.getter(name="asNumber")
|
|
2206
|
+
def as_number(self) -> pulumi.Output[Optional[int]]:
|
|
2207
|
+
"""
|
|
2208
|
+
Set autonomous system number <1..4294967295> or <XX.YY>
|
|
2209
|
+
"""
|
|
2210
|
+
return pulumi.get(self, "as_number")
|
|
2211
|
+
|
|
2212
|
+
@property
|
|
2213
|
+
@pulumi.getter(name="asNumberVariable")
|
|
2214
|
+
def as_number_variable(self) -> pulumi.Output[Optional[str]]:
|
|
2215
|
+
"""
|
|
2216
|
+
Variable name
|
|
2217
|
+
"""
|
|
2218
|
+
return pulumi.get(self, "as_number_variable")
|
|
2219
|
+
|
|
2220
|
+
@property
|
|
2221
|
+
@pulumi.getter(name="compareRouterId")
|
|
2222
|
+
def compare_router_id(self) -> pulumi.Output[Optional[bool]]:
|
|
2223
|
+
"""
|
|
2224
|
+
Compare router IDs when selecting active BGP paths - Default value: `false`
|
|
2225
|
+
"""
|
|
2226
|
+
return pulumi.get(self, "compare_router_id")
|
|
2227
|
+
|
|
2228
|
+
@property
|
|
2229
|
+
@pulumi.getter(name="compareRouterIdVariable")
|
|
2230
|
+
def compare_router_id_variable(self) -> pulumi.Output[Optional[str]]:
|
|
2231
|
+
"""
|
|
2232
|
+
Variable name
|
|
2233
|
+
"""
|
|
2234
|
+
return pulumi.get(self, "compare_router_id_variable")
|
|
2235
|
+
|
|
2236
|
+
@property
|
|
2237
|
+
@pulumi.getter
|
|
2238
|
+
def description(self) -> pulumi.Output[Optional[str]]:
|
|
2239
|
+
"""
|
|
2240
|
+
The description of the Feature
|
|
2241
|
+
"""
|
|
2242
|
+
return pulumi.get(self, "description")
|
|
2243
|
+
|
|
2244
|
+
@property
|
|
2245
|
+
@pulumi.getter(name="deterministicMed")
|
|
2246
|
+
def deterministic_med(self) -> pulumi.Output[Optional[bool]]:
|
|
2247
|
+
"""
|
|
2248
|
+
Compare MEDs from all routes from same AS when selecting active BGP paths - Default value: `false`
|
|
2249
|
+
"""
|
|
2250
|
+
return pulumi.get(self, "deterministic_med")
|
|
2251
|
+
|
|
2252
|
+
@property
|
|
2253
|
+
@pulumi.getter(name="deterministicMedVariable")
|
|
2254
|
+
def deterministic_med_variable(self) -> pulumi.Output[Optional[str]]:
|
|
2255
|
+
"""
|
|
2256
|
+
Variable name
|
|
2257
|
+
"""
|
|
2258
|
+
return pulumi.get(self, "deterministic_med_variable")
|
|
2259
|
+
|
|
2260
|
+
@property
|
|
2261
|
+
@pulumi.getter(name="externalRoutesDistance")
|
|
2262
|
+
def external_routes_distance(self) -> pulumi.Output[Optional[int]]:
|
|
2263
|
+
"""
|
|
2264
|
+
Set administrative distance for external BGP routes - Range: `1`-`255` - Default value: `20`
|
|
2265
|
+
"""
|
|
2266
|
+
return pulumi.get(self, "external_routes_distance")
|
|
2267
|
+
|
|
2268
|
+
@property
|
|
2269
|
+
@pulumi.getter(name="externalRoutesDistanceVariable")
|
|
2270
|
+
def external_routes_distance_variable(self) -> pulumi.Output[Optional[str]]:
|
|
2271
|
+
"""
|
|
2272
|
+
Variable name
|
|
2273
|
+
"""
|
|
2274
|
+
return pulumi.get(self, "external_routes_distance_variable")
|
|
2275
|
+
|
|
2276
|
+
@property
|
|
2277
|
+
@pulumi.getter(name="featureProfileId")
|
|
2278
|
+
def feature_profile_id(self) -> pulumi.Output[Optional[str]]:
|
|
2279
|
+
"""
|
|
2280
|
+
Feature Profile ID
|
|
2281
|
+
"""
|
|
2282
|
+
return pulumi.get(self, "feature_profile_id")
|
|
2283
|
+
|
|
2284
|
+
@property
|
|
2285
|
+
@pulumi.getter(name="holdTime")
|
|
2286
|
+
def hold_time(self) -> pulumi.Output[Optional[int]]:
|
|
2287
|
+
"""
|
|
2288
|
+
Interval (seconds) not receiving a keepalive message declares a BGP peer down - Range: `0`-`65535` - Default value:
|
|
2289
|
+
`180`
|
|
2290
|
+
"""
|
|
2291
|
+
return pulumi.get(self, "hold_time")
|
|
2292
|
+
|
|
2293
|
+
@property
|
|
2294
|
+
@pulumi.getter(name="holdTimeVariable")
|
|
2295
|
+
def hold_time_variable(self) -> pulumi.Output[Optional[str]]:
|
|
2296
|
+
"""
|
|
2297
|
+
Variable name
|
|
2298
|
+
"""
|
|
2299
|
+
return pulumi.get(self, "hold_time_variable")
|
|
2300
|
+
|
|
2301
|
+
@property
|
|
2302
|
+
@pulumi.getter(name="internalRoutesDistance")
|
|
2303
|
+
def internal_routes_distance(self) -> pulumi.Output[Optional[int]]:
|
|
2304
|
+
"""
|
|
2305
|
+
Set administrative distance for internal BGP routes - Range: `1`-`255` - Default value: `200`
|
|
2306
|
+
"""
|
|
2307
|
+
return pulumi.get(self, "internal_routes_distance")
|
|
2308
|
+
|
|
2309
|
+
@property
|
|
2310
|
+
@pulumi.getter(name="internalRoutesDistanceVariable")
|
|
2311
|
+
def internal_routes_distance_variable(self) -> pulumi.Output[Optional[str]]:
|
|
2312
|
+
"""
|
|
2313
|
+
Variable name
|
|
2314
|
+
"""
|
|
2315
|
+
return pulumi.get(self, "internal_routes_distance_variable")
|
|
2316
|
+
|
|
2317
|
+
@property
|
|
2318
|
+
@pulumi.getter(name="ipv4AggregateAddresses")
|
|
2319
|
+
def ipv4_aggregate_addresses(self) -> pulumi.Output[Optional[Sequence['outputs.ServiceRoutingBgpFeatureIpv4AggregateAddress']]]:
|
|
2320
|
+
"""
|
|
2321
|
+
Aggregate prefixes in specific range
|
|
2322
|
+
"""
|
|
2323
|
+
return pulumi.get(self, "ipv4_aggregate_addresses")
|
|
2324
|
+
|
|
2325
|
+
@property
|
|
2326
|
+
@pulumi.getter(name="ipv4EibgpMaximumPaths")
|
|
2327
|
+
def ipv4_eibgp_maximum_paths(self) -> pulumi.Output[Optional[int]]:
|
|
2328
|
+
"""
|
|
2329
|
+
Set maximum number of parallel IBGP paths for multipath load sharing - Range: `1`-`32`
|
|
2330
|
+
"""
|
|
2331
|
+
return pulumi.get(self, "ipv4_eibgp_maximum_paths")
|
|
2332
|
+
|
|
2333
|
+
@property
|
|
2334
|
+
@pulumi.getter(name="ipv4EibgpMaximumPathsVariable")
|
|
2335
|
+
def ipv4_eibgp_maximum_paths_variable(self) -> pulumi.Output[Optional[str]]:
|
|
2336
|
+
"""
|
|
2337
|
+
Variable name
|
|
2338
|
+
"""
|
|
2339
|
+
return pulumi.get(self, "ipv4_eibgp_maximum_paths_variable")
|
|
2340
|
+
|
|
2341
|
+
@property
|
|
2342
|
+
@pulumi.getter(name="ipv4Neighbors")
|
|
2343
|
+
def ipv4_neighbors(self) -> pulumi.Output[Optional[Sequence['outputs.ServiceRoutingBgpFeatureIpv4Neighbor']]]:
|
|
2344
|
+
"""
|
|
2345
|
+
Set BGP IPv4 neighbors
|
|
2346
|
+
"""
|
|
2347
|
+
return pulumi.get(self, "ipv4_neighbors")
|
|
2348
|
+
|
|
2349
|
+
@property
|
|
2350
|
+
@pulumi.getter(name="ipv4Networks")
|
|
2351
|
+
def ipv4_networks(self) -> pulumi.Output[Optional[Sequence['outputs.ServiceRoutingBgpFeatureIpv4Network']]]:
|
|
2352
|
+
"""
|
|
2353
|
+
Configure the networks for BGP to advertise
|
|
2354
|
+
"""
|
|
2355
|
+
return pulumi.get(self, "ipv4_networks")
|
|
2356
|
+
|
|
2357
|
+
@property
|
|
2358
|
+
@pulumi.getter(name="ipv4Originate")
|
|
2359
|
+
def ipv4_originate(self) -> pulumi.Output[Optional[bool]]:
|
|
2360
|
+
"""
|
|
2361
|
+
BGP Default Information Originate - Default value: `false`
|
|
2362
|
+
"""
|
|
2363
|
+
return pulumi.get(self, "ipv4_originate")
|
|
2364
|
+
|
|
2365
|
+
@property
|
|
2366
|
+
@pulumi.getter(name="ipv4OriginateVariable")
|
|
2367
|
+
def ipv4_originate_variable(self) -> pulumi.Output[Optional[str]]:
|
|
2368
|
+
"""
|
|
2369
|
+
Variable name
|
|
2370
|
+
"""
|
|
2371
|
+
return pulumi.get(self, "ipv4_originate_variable")
|
|
2372
|
+
|
|
2373
|
+
@property
|
|
2374
|
+
@pulumi.getter(name="ipv4Redistributes")
|
|
2375
|
+
def ipv4_redistributes(self) -> pulumi.Output[Optional[Sequence['outputs.ServiceRoutingBgpFeatureIpv4Redistribute']]]:
|
|
2376
|
+
"""
|
|
2377
|
+
Redistribute routes into BGP
|
|
2378
|
+
"""
|
|
2379
|
+
return pulumi.get(self, "ipv4_redistributes")
|
|
2380
|
+
|
|
2381
|
+
@property
|
|
2382
|
+
@pulumi.getter(name="ipv4TableMapFilter")
|
|
2383
|
+
def ipv4_table_map_filter(self) -> pulumi.Output[Optional[bool]]:
|
|
2384
|
+
"""
|
|
2385
|
+
Table map filtered or not - Default value: `false`
|
|
2386
|
+
"""
|
|
2387
|
+
return pulumi.get(self, "ipv4_table_map_filter")
|
|
2388
|
+
|
|
2389
|
+
@property
|
|
2390
|
+
@pulumi.getter(name="ipv4TableMapFilterVariable")
|
|
2391
|
+
def ipv4_table_map_filter_variable(self) -> pulumi.Output[Optional[str]]:
|
|
2392
|
+
"""
|
|
2393
|
+
Variable name
|
|
2394
|
+
"""
|
|
2395
|
+
return pulumi.get(self, "ipv4_table_map_filter_variable")
|
|
2396
|
+
|
|
2397
|
+
@property
|
|
2398
|
+
@pulumi.getter(name="ipv4TableMapRoutePolicyId")
|
|
2399
|
+
def ipv4_table_map_route_policy_id(self) -> pulumi.Output[Optional[str]]:
|
|
2400
|
+
return pulumi.get(self, "ipv4_table_map_route_policy_id")
|
|
2401
|
+
|
|
2402
|
+
@property
|
|
2403
|
+
@pulumi.getter(name="ipv6AggregateAddresses")
|
|
2404
|
+
def ipv6_aggregate_addresses(self) -> pulumi.Output[Optional[Sequence['outputs.ServiceRoutingBgpFeatureIpv6AggregateAddress']]]:
|
|
2405
|
+
"""
|
|
2406
|
+
IPv6 Aggregate prefixes in specific range
|
|
2407
|
+
"""
|
|
2408
|
+
return pulumi.get(self, "ipv6_aggregate_addresses")
|
|
2409
|
+
|
|
2410
|
+
@property
|
|
2411
|
+
@pulumi.getter(name="ipv6EibgpMaximumPaths")
|
|
2412
|
+
def ipv6_eibgp_maximum_paths(self) -> pulumi.Output[Optional[int]]:
|
|
2413
|
+
"""
|
|
2414
|
+
Set maximum number of parallel IBGP paths for multipath load sharing - Range: `1`-`32`
|
|
2415
|
+
"""
|
|
2416
|
+
return pulumi.get(self, "ipv6_eibgp_maximum_paths")
|
|
2417
|
+
|
|
2418
|
+
@property
|
|
2419
|
+
@pulumi.getter(name="ipv6EibgpMaximumPathsVariable")
|
|
2420
|
+
def ipv6_eibgp_maximum_paths_variable(self) -> pulumi.Output[Optional[str]]:
|
|
2421
|
+
"""
|
|
2422
|
+
Variable name
|
|
2423
|
+
"""
|
|
2424
|
+
return pulumi.get(self, "ipv6_eibgp_maximum_paths_variable")
|
|
2425
|
+
|
|
2426
|
+
@property
|
|
2427
|
+
@pulumi.getter(name="ipv6Neighbors")
|
|
2428
|
+
def ipv6_neighbors(self) -> pulumi.Output[Optional[Sequence['outputs.ServiceRoutingBgpFeatureIpv6Neighbor']]]:
|
|
2429
|
+
"""
|
|
2430
|
+
Set BGP IPv6 neighbors
|
|
2431
|
+
"""
|
|
2432
|
+
return pulumi.get(self, "ipv6_neighbors")
|
|
2433
|
+
|
|
2434
|
+
@property
|
|
2435
|
+
@pulumi.getter(name="ipv6Networks")
|
|
2436
|
+
def ipv6_networks(self) -> pulumi.Output[Optional[Sequence['outputs.ServiceRoutingBgpFeatureIpv6Network']]]:
|
|
2437
|
+
"""
|
|
2438
|
+
Configure the networks for BGP to advertise
|
|
2439
|
+
"""
|
|
2440
|
+
return pulumi.get(self, "ipv6_networks")
|
|
2441
|
+
|
|
2442
|
+
@property
|
|
2443
|
+
@pulumi.getter(name="ipv6Originate")
|
|
2444
|
+
def ipv6_originate(self) -> pulumi.Output[Optional[bool]]:
|
|
2445
|
+
"""
|
|
2446
|
+
BGP Default Information Originate - Default value: `false`
|
|
2447
|
+
"""
|
|
2448
|
+
return pulumi.get(self, "ipv6_originate")
|
|
2449
|
+
|
|
2450
|
+
@property
|
|
2451
|
+
@pulumi.getter(name="ipv6OriginateVariable")
|
|
2452
|
+
def ipv6_originate_variable(self) -> pulumi.Output[Optional[str]]:
|
|
2453
|
+
"""
|
|
2454
|
+
Variable name
|
|
2455
|
+
"""
|
|
2456
|
+
return pulumi.get(self, "ipv6_originate_variable")
|
|
2457
|
+
|
|
2458
|
+
@property
|
|
2459
|
+
@pulumi.getter(name="ipv6Redistributes")
|
|
2460
|
+
def ipv6_redistributes(self) -> pulumi.Output[Optional[Sequence['outputs.ServiceRoutingBgpFeatureIpv6Redistribute']]]:
|
|
2461
|
+
"""
|
|
2462
|
+
Redistribute routes into BGP
|
|
2463
|
+
"""
|
|
2464
|
+
return pulumi.get(self, "ipv6_redistributes")
|
|
2465
|
+
|
|
2466
|
+
@property
|
|
2467
|
+
@pulumi.getter(name="ipv6TableMapFilter")
|
|
2468
|
+
def ipv6_table_map_filter(self) -> pulumi.Output[Optional[bool]]:
|
|
2469
|
+
"""
|
|
2470
|
+
Table map filtered or not - Default value: `false`
|
|
2471
|
+
"""
|
|
2472
|
+
return pulumi.get(self, "ipv6_table_map_filter")
|
|
2473
|
+
|
|
2474
|
+
@property
|
|
2475
|
+
@pulumi.getter(name="ipv6TableMapFilterVariable")
|
|
2476
|
+
def ipv6_table_map_filter_variable(self) -> pulumi.Output[Optional[str]]:
|
|
2477
|
+
"""
|
|
2478
|
+
Variable name
|
|
2479
|
+
"""
|
|
2480
|
+
return pulumi.get(self, "ipv6_table_map_filter_variable")
|
|
2481
|
+
|
|
2482
|
+
@property
|
|
2483
|
+
@pulumi.getter(name="ipv6TableMapRoutePolicyId")
|
|
2484
|
+
def ipv6_table_map_route_policy_id(self) -> pulumi.Output[Optional[str]]:
|
|
2485
|
+
return pulumi.get(self, "ipv6_table_map_route_policy_id")
|
|
2486
|
+
|
|
2487
|
+
@property
|
|
2488
|
+
@pulumi.getter(name="keepaliveTime")
|
|
2489
|
+
def keepalive_time(self) -> pulumi.Output[Optional[int]]:
|
|
2490
|
+
"""
|
|
2491
|
+
Interval (seconds) of keepalive messages sent to its BGP peer - Range: `0`-`65535` - Default value: `60`
|
|
2492
|
+
"""
|
|
2493
|
+
return pulumi.get(self, "keepalive_time")
|
|
2494
|
+
|
|
2495
|
+
@property
|
|
2496
|
+
@pulumi.getter(name="keepaliveTimeVariable")
|
|
2497
|
+
def keepalive_time_variable(self) -> pulumi.Output[Optional[str]]:
|
|
2498
|
+
"""
|
|
2499
|
+
Variable name
|
|
2500
|
+
"""
|
|
2501
|
+
return pulumi.get(self, "keepalive_time_variable")
|
|
2502
|
+
|
|
2503
|
+
@property
|
|
2504
|
+
@pulumi.getter(name="localRoutesDistance")
|
|
2505
|
+
def local_routes_distance(self) -> pulumi.Output[Optional[int]]:
|
|
2506
|
+
"""
|
|
2507
|
+
Set administrative distance for local BGP routes - Range: `1`-`255` - Default value: `20`
|
|
2508
|
+
"""
|
|
2509
|
+
return pulumi.get(self, "local_routes_distance")
|
|
2510
|
+
|
|
2511
|
+
@property
|
|
2512
|
+
@pulumi.getter(name="localRoutesDistanceVariable")
|
|
2513
|
+
def local_routes_distance_variable(self) -> pulumi.Output[Optional[str]]:
|
|
2514
|
+
"""
|
|
2515
|
+
Variable name
|
|
2516
|
+
"""
|
|
2517
|
+
return pulumi.get(self, "local_routes_distance_variable")
|
|
2518
|
+
|
|
2519
|
+
@property
|
|
2520
|
+
@pulumi.getter(name="missingMedAsWorst")
|
|
2521
|
+
def missing_med_as_worst(self) -> pulumi.Output[Optional[bool]]:
|
|
2522
|
+
"""
|
|
2523
|
+
If path has no MED, consider it to be worst path when selecting active BGP paths - Default value: `false`
|
|
2524
|
+
"""
|
|
2525
|
+
return pulumi.get(self, "missing_med_as_worst")
|
|
2526
|
+
|
|
2527
|
+
@property
|
|
2528
|
+
@pulumi.getter(name="missingMedAsWorstVariable")
|
|
2529
|
+
def missing_med_as_worst_variable(self) -> pulumi.Output[Optional[str]]:
|
|
2530
|
+
"""
|
|
2531
|
+
Variable name
|
|
2532
|
+
"""
|
|
2533
|
+
return pulumi.get(self, "missing_med_as_worst_variable")
|
|
2534
|
+
|
|
2535
|
+
@property
|
|
2536
|
+
@pulumi.getter(name="multipathRelax")
|
|
2537
|
+
def multipath_relax(self) -> pulumi.Output[Optional[bool]]:
|
|
2538
|
+
"""
|
|
2539
|
+
Ignore AS for multipath selection - Default value: `false`
|
|
2540
|
+
"""
|
|
2541
|
+
return pulumi.get(self, "multipath_relax")
|
|
2542
|
+
|
|
2543
|
+
@property
|
|
2544
|
+
@pulumi.getter(name="multipathRelaxVariable")
|
|
2545
|
+
def multipath_relax_variable(self) -> pulumi.Output[Optional[str]]:
|
|
2546
|
+
"""
|
|
2547
|
+
Variable name
|
|
2548
|
+
"""
|
|
2549
|
+
return pulumi.get(self, "multipath_relax_variable")
|
|
2550
|
+
|
|
2551
|
+
@property
|
|
2552
|
+
@pulumi.getter
|
|
2553
|
+
def name(self) -> pulumi.Output[str]:
|
|
2554
|
+
"""
|
|
2555
|
+
The name of the Feature
|
|
2556
|
+
"""
|
|
2557
|
+
return pulumi.get(self, "name")
|
|
2558
|
+
|
|
2559
|
+
@property
|
|
2560
|
+
@pulumi.getter(name="propagateAsPath")
|
|
2561
|
+
def propagate_as_path(self) -> pulumi.Output[Optional[bool]]:
|
|
2562
|
+
"""
|
|
2563
|
+
Propagate AS Path - Default value: `false`
|
|
2564
|
+
"""
|
|
2565
|
+
return pulumi.get(self, "propagate_as_path")
|
|
2566
|
+
|
|
2567
|
+
@property
|
|
2568
|
+
@pulumi.getter(name="propagateAsPathVariable")
|
|
2569
|
+
def propagate_as_path_variable(self) -> pulumi.Output[Optional[str]]:
|
|
2570
|
+
"""
|
|
2571
|
+
Variable name
|
|
2572
|
+
"""
|
|
2573
|
+
return pulumi.get(self, "propagate_as_path_variable")
|
|
2574
|
+
|
|
2575
|
+
@property
|
|
2576
|
+
@pulumi.getter(name="propagateCommunity")
|
|
2577
|
+
def propagate_community(self) -> pulumi.Output[Optional[bool]]:
|
|
2578
|
+
"""
|
|
2579
|
+
Propagate Community - Default value: `false`
|
|
2580
|
+
"""
|
|
2581
|
+
return pulumi.get(self, "propagate_community")
|
|
2582
|
+
|
|
2583
|
+
@property
|
|
2584
|
+
@pulumi.getter(name="propagateCommunityVariable")
|
|
2585
|
+
def propagate_community_variable(self) -> pulumi.Output[Optional[str]]:
|
|
2586
|
+
"""
|
|
2587
|
+
Variable name
|
|
2588
|
+
"""
|
|
2589
|
+
return pulumi.get(self, "propagate_community_variable")
|
|
2590
|
+
|
|
2591
|
+
@property
|
|
2592
|
+
@pulumi.getter(name="routerId")
|
|
2593
|
+
def router_id(self) -> pulumi.Output[Optional[str]]:
|
|
2594
|
+
"""
|
|
2595
|
+
Configure BGP router identifier
|
|
2596
|
+
"""
|
|
2597
|
+
return pulumi.get(self, "router_id")
|
|
2598
|
+
|
|
2599
|
+
@property
|
|
2600
|
+
@pulumi.getter(name="routerIdVariable")
|
|
2601
|
+
def router_id_variable(self) -> pulumi.Output[Optional[str]]:
|
|
2602
|
+
"""
|
|
2603
|
+
Variable name
|
|
2604
|
+
"""
|
|
2605
|
+
return pulumi.get(self, "router_id_variable")
|
|
2606
|
+
|
|
2607
|
+
@property
|
|
2608
|
+
@pulumi.getter
|
|
2609
|
+
def version(self) -> pulumi.Output[int]:
|
|
2610
|
+
"""
|
|
2611
|
+
The version of the Feature
|
|
2612
|
+
"""
|
|
2613
|
+
return pulumi.get(self, "version")
|
|
2614
|
+
|