Connect a VBR to a VPC that belongs to the same region and Alibaba Cloud account

This topic describes how to use Alibaba Cloud SDK for Python to connect a virtual border router (VBR) to a virtual private cloud (VPC).

1. In the downloaded SDK directory, open the $aliyun-openapi-python-sdk-examples\sdk_examples\examples\ec folder.
2. Open the eip_add_cbwp.py file in your text editor. Set the required parameters, save the configurations, and then exit the editor.
   The code sample includes the following operations:

   1. Create a VBR.
   2. Create an initiator router interface.
   3. Create a receiver router interface.
   4. Modify the information about the initiator router interface.
   5. Modify the information about the receiver router interface.
   6. Query the information about the initiator router interface.
   7. Query the information about the receiver router interface.
   8. The route table ID of the VBR that you want to query.
   9. Connect the initiator router interface to the receiver router interface.
   10. Create a route whose next hop is the initiator router interface.
   11. Create a route whose next hop is the receiver router interface.
   12. Delete the route whose next hop is the receiver router interface.
   13. Delete the route whose next hop is the initiator router interface.
   14. Disable the initiator router interface.
   15. Disable the receiver router interface.
   16. Delete the initiator router interface.
   17. Delete the receiver router interface.
   18. Delete the VBR.

   #encoding=utf-8
   import sys
   import json
   from aliyunsdkcore.acs_exception.exceptions import ServerException, ClientException
   from aliyunsdkvpc.request.v20160428 import CreateRouterInterfaceRequest
   from aliyunsdkvpc.request.v20160428 import DeleteRouterInterfaceRequest
   from aliyunsdkvpc.request.v20160428 import DescribeRouterInterfacesRequest
   from aliyunsdkvpc.request.v20160428 import ConnectRouterInterfaceRequest
   from aliyunsdkvpc.request.v20160428 import DeactivateRouterInterfaceRequest
   from aliyunsdkvpc.request.v20160428 import ModifyRouterInterfaceAttributeRequest
   from aliyunsdkvpc.request.v20160428 import CreateVirtualBorderRouterRequest
   from aliyunsdkvpc.request.v20160428 import DescribeVirtualBorderRoutersRequest
   from aliyunsdkvpc.request.v20160428 import DescribeRouteTablesRequest
   from aliyunsdkvpc.request.v20160428 import DeleteVirtualBorderRouterRequest
   from sdk_lib.sdk_route_entry import RouteEntry
   from sdk_lib.exception import ExceptionHandler
   from sdk_lib.common_util import CommonUtil
   from sdk_lib.check_status import CheckStatus
   from sdk_lib.consts import *
   
   client = AcsClient(
               '<your-access-key-id>',     # Your AccessKey ID.
               '<your-access-key-secret>', # Your AccessKey secret.
               '<your-region-id>')         # Your region ID.
   
   class RouterInterface(object):
       def __init__(self, client):
           self.client = client
   
       def create_router_interface(self, params):
           """
           create_router_interface: Create a router interface.
           """
           try:
               request = CreateRouterInterfaceRequest.CreateRouterInterfaceRequest()
               # The specifications of the router interface.
               request.set_Spec(params['spec'])
               # The role of the router interface.
               request.set_Role(params['role'])
               # The ID of the router that is associated with the router interface.
               request.set_RouterId(params['router_id'])
               # The type of router that is associated with the router interface.
               request.set_RouterType(params['router_type'])
               # The ID of the region where the receiver is deployed.
               request.set_OppositeRegionId(params['opposite_region_id'])
               # The type of router that is associated with the peer router interface.
               request.set_OppositeRouterType(params['opposite_router_type'])
               # The ID of the access point to which the peer belongs.
               request.set_OppositeAccessPointId(params['opposite_access_point_id'])
               # The ID of the access point to which the VBR belongs.
               #request.set_AccessPointId(params['access_point_id'])
   
               response = self.client.do_action_with_exception(request)
               response_json = json.loads(response)
               # Check whether the router interface is in the Available state.
               if CheckStatus.check_status(TIME_DEFAULT_OUT, DEFAULT_TIME,
                                           self.describe_ri_status,
                                           'Idle', response_json['RouterInterfaceId']):
                   return response_json
           except ServerException as e:
               ExceptionHandler.server_exception(e)
           except ClientException as e:
               ExceptionHandler.client_exception(e)
   
       def create_router_interface_vbr(self, params):
           """
           create_router_interface: Create a router interface.
           """
           try:
               request = CreateRouterInterfaceRequest.CreateRouterInterfaceRequest()
               # The specification of the router interface.
               request.set_Spec(params['spec'])
               # The role of the router interface.
               request.set_Role(params['role'])
               # The ID of the router that is associated with the router interface.
               request.set_RouterId(params['router_id'])
               # The type of router that is associated with the router interface.
               request.set_RouterType(params['router_type'])
               # The ID of the region where the receiver is deployed.
               request.set_OppositeRegionId(params['opposite_region_id'])
               # The type of router that is associated with the peer router interface.
               request.set_OppositeRouterType(params['opposite_router_type'])
               # The ID of the access point to which the VBR belongs.
               request.set_AccessPointId(params['access_point_id'])
   
               response = self.client.do_action_with_exception(request)
               response_json = json.loads(response)
               # Check whether the router interface is in the Available state.
               if CheckStatus.check_status(TIME_DEFAULT_OUT, DEFAULT_TIME,
                                           self.describe_ri_status,
                                           'Idle', response_json['RouterInterfaceId']):
                   return response_json
           except ServerException as e:
               ExceptionHandler.server_exception(e)
           except ClientException as e:
               ExceptionHandler.client_exception(e)
   
       def connect_router_interface(self, params):
           """
           connect_router_interface: A connection request is sent from the initiator router interface to the receiver router interface.
           """
           try:
               request = ConnectRouterInterfaceRequest.ConnectRouterInterfaceRequest()
               # The ID of the initiator router interface that initiates the connection request.
               request.set_RouterInterfaceId(params['router_interface_id'])
               response = self.client.do_action_with_exception(request)
               response_json = json.loads(response)
               if CheckStatus.check_status(TIME_DEFAULT_OUT * 5, DEFAULT_TIME * 5,
                                           self.describe_ri_status,
                                           'Active', params['router_interface_id']):
                   return response_json
           except ServerException as e:
               ExceptionHandler.server_exception(e)
           except ClientException as e:
               ExceptionHandler.client_exception(e)
   
       def deactivate_router_interface(self, params):
           """
           deactivate_router_interface: Disable the router interface.
           """
           try:
               request = DeactivateRouterInterfaceRequest.DeactivateRouterInterfaceRequest()
               # The ID of the router interface.
               request.set_RouterInterfaceId(params['router_interface_id'])
               response = self.client.do_action_with_exception(request)
               response_json = json.loads(response)
               # Check whether the router interface is in the Available state.
               if CheckStatus.check_status(TIME_DEFAULT_OUT * 5, DEFAULT_TIME * 5,
                                           self.describe_ri_status,
                                           'Inactive', params['router_interface_id']):
                   return response_json
           except ServerException as e:
               ExceptionHandler.server_exception(e)
           except ClientException as e:
               ExceptionHandler.client_exception(e)
   
       def modify_router_interface_attribute(self, params):
           """
           modify_router_interface_attribute: Modify the configurations of the router interface.
           """
           try:
               request = ModifyRouterInterfaceAttributeRequest.ModifyRouterInterfaceAttributeRequest()
               # The ID of the router interface.
               request.set_RouterInterfaceId(params['router_interface_id'])
               # The ID of the peer router interface.
               request.set_OppositeInterfaceId(params['opposite_interface_id'])
               # The ID of the peer router.
               request.set_OppositeRouterId(params['opposite_router_id'])
               # The type of peer router.
               request.set_OppositeRouterType(params['opposite_router_type'])
               response = self.client.do_action_with_exception(request)
               response_json = json.loads(response)
               # Check whether the router interface is in the Available state.
               if CheckStatus.check_status(TIME_DEFAULT_OUT, DEFAULT_TIME,
                                           self.describe_ri_status,
                                           'Idle', params['router_interface_id']):
                   return response_json
           except ServerException as e:
               ExceptionHandler.server_exception(e)
           except ClientException as e:
               ExceptionHandler.client_exception(e)
   
   
   
       def describe_router_interface(self, instance_id):
           """
           describe_router_interface: Query the router interface in a specific region.
           """
           try:
               request = DescribeRouterInterfacesRequest.DescribeRouterInterfacesRequest()
               # The type of filter condition that is used to query a router interface.
               request.add_query_param('Filter.1.Key', "RouterInterfaceId")
               # The ID of the router interface to be queried.
               request.add_query_param('Filter.1.Value.1', instance_id)
               response = self.client.do_action_with_exception(request)
               response_json = json.loads(response)
               return response_json
           except ServerException as e:
               ExceptionHandler.server_exception(e)
           except ClientException as e:
               ExceptionHandler.client_exception(e)
   
       def describe_ri_status(self, instance_id):
           """
           describe_ri_status: Query the state of a router interface in a specific region.
           """
           response = self.describe_router_interface(instance_id)
           if len(response['RouterInterfaceSet']['RouterInterfaceType']) == 0:
               return ''
           return response['RouterInterfaceSet']['RouterInterfaceType'][0]['Status']
   
       def delete_router_interface(self, params):
           """
           delete_router_interface: Delete the router interface.
           """
           try:
               request = DeleteRouterInterfaceRequest.DeleteRouterInterfaceRequest()
               # The ID of the router interface.
               request.set_RouterInterfaceId(params['instance_id'])
               response = self.client.do_action_with_exception(request)
               response_json = json.loads(response)
               # Check whether the router interface is in the Available state.
               if CheckStatus.check_status(TIME_DEFAULT_OUT, DEFAULT_TIME * 5,
                                           self.describe_ri_status,
                                           '', params['instance_id']):
                   return response_json
           except ServerException as e:
               ExceptionHandler.server_exception(e)
           except ClientException as e:
               ExceptionHandler.client_exception(e)
   
       def create_virtual_border_router(self, params):
           """
           create_virtual_border_router: Create a VBR.
           """
           try:
               request = CreateVirtualBorderRouterRequest.CreateVirtualBorderRouterRequest()
               # The ID of the physical connection.
               request.set_PhysicalConnectionId(params['physical_connection_id'])
               # The IP address of the local VBR on the Alibaba Cloud side.
               request.set_LocalGatewayIp(params['local_gateway_ip'])
               # The IP address of the peer router interface of the VBR.
               request.set_PeerGatewayIp(params['peer_gateway_ip'])
               # The subnet mask for the IP addresses on the Alibaba Cloud side and on the client side.
               request.set_PeeringSubnetMask(params['peering_subnet_mask'])
               # The VLAN ID of the VBR.
               request.set_VlanId(params['vlan_id'])
   
               response = self.client.do_action_with_exception(request)
               response_json = json.loads(response)
               # Check whether the VBR is in the Available state.
               if CheckStatus.check_status(TIME_DEFAULT_OUT, DEFAULT_TIME,
                                           self.describe_vbr_status,
                                           'active', response_json['VbrId']):
                   return response_json
           except ServerException as e:
               ExceptionHandler.server_exception(e)
           except ClientException as e:
               ExceptionHandler.client_exception(e)
   
       def delete_virtual_border_router(self, params):
           """
           delete_virtual_border_router: Delete a VBR.
           """
           try:
               request = DeleteVirtualBorderRouterRequest.DeleteVirtualBorderRouterRequest()
               request.set_VbrId(params['vbr_id'])
               response = self.client.do_action_with_exception(request)
               response_json = json.loads(response)
               if CheckStatus.check_status(TIME_DEFAULT_OUT, DEFAULT_TIME,
                                           self.describe_vbr_status,
                                           '', params['vbr_id']):
                   return response_json
           except ServerException as e:
               ExceptionHandler.server_exception(e)
           except ClientException as e:
               ExceptionHandler.client_exception(e)
   
       def describe_virtual_border_router(self, instance_id):
           """
           describe_virtual_border_router: Query a VBR.
           """
           try:
               request = DescribeVirtualBorderRoutersRequest.DescribeVirtualBorderRoutersRequest()
               # The type of filter condition that is used to query a router interface.
               request.add_query_param('Filter.1.Key', "VbrId")
               # The ID of the router interface to be queried.
               request.add_query_param('Filter.1.Value.1', instance_id)
               response = self.client.do_action_with_exception(request)
               response_json = json.loads(response)
               return response_json
           except ServerException as e:
               ExceptionHandler.server_exception(e)
           except ClientException as e:
               ExceptionHandler.client_exception(e)
   
       def describe_vbr_status(self, instance_id):
           """
           describe_virtual_border_router: Query a VBR.
           """
           response = self.describe_virtual_border_router(instance_id)
           if len(response['VirtualBorderRouterSet']['VirtualBorderRouterType']) == 0:
               return ''
           return response['VirtualBorderRouterSet']['VirtualBorderRouterType'][0]['Status']
   
       def describe_route_table(self, params):
           """
           describe_route_table: Query a route table.
           """
           try:
               request = DescribeRouteTablesRequest.DescribeRouteTablesRequest()
               # The ID of the router to which the route table belongs. The router can be a VBR or a vRouter.
               request.set_RouterId(params['router_id'])
               # The type of the router to which the route table belongs.
               request.set_RouterType(params['router_type'])
               response = self.client.do_action_with_exception(request)
               response_json = json.loads(response)
               return response_json
           except ServerException as e:
               ExceptionHandler.server_exception(e)
           except ClientException as e:
               ExceptionHandler.client_exception(e)
   
   
   def main():
       router_interface = RouterInterface(client)
       route_entry = RouteEntry(client)
   
       params = {}
       params['spec'] = "Large.2"
       params['role'] = "InitiatingSide"
       params['router_type'] = "VBR"
       params['opposite_region_id'] = "cn-hangzhou"
       params['opposite_router_type'] = "VRouter"
       params['access_point_id'] = "ap-cn-hangzhou-xx-x"
   
       # Create a VBR.
       params['physical_connection_id'] = PC_ID
       params['local_gateway_ip'] = "116.xx.xx.254"
       params['peer_gateway_ip'] = "116.xx.xx.254"
       params['peering_subnet_mask'] = "255.255.255.252"
       params['vlan_id'] = 30
       vbr_json = router_interface.create_virtual_border_router(params)
       CommonUtil.log("create_virtual_border_router", vbr_json)
   
       # Create an initiator router interface.
       params['router_id'] = vbr_json['VbrId']
       router_interface_json = router_interface.create_router_interface_vbr(params)
       CommonUtil.log("create_router_interface", router_interface_json)
   
       # Create a receiver router interface.
       params['router_type'] = "VRouter"
       params['spec'] = "Negative"
       params['role'] = "AcceptingSide"
       params['router_id'] = ROUTER_ID2
       params['opposite_router_type'] = 'VBR'
       params['opposite_access_point_id'] = params['access_point_id']
       router_interface_json2 = router_interface.create_router_interface(params)
       CommonUtil.log("create_router_interface", router_interface_json2)
   
       # Modify the information about the initiator router interface.
       params['router_interface_id'] = router_interface_json['RouterInterfaceId']
       params['opposite_interface_id'] = router_interface_json2['RouterInterfaceId']
       params['opposite_router_id'] = ROUTER_ID2
       params['opposite_router_type'] = "VRouter"
       modify_ri_json = router_interface.modify_router_interface_attribute(params)
       CommonUtil.log("modify_router_interface_attribute", modify_ri_json)
   
       # Modify the information about the receiver router interface.
       params['router_interface_id'] = router_interface_json2['RouterInterfaceId']
       params['opposite_interface_id'] = router_interface_json['RouterInterfaceId']
       params['opposite_router_id'] = vbr_json['VbrId']
       params['opposite_router_type'] = "VBR"
       modify_ri_json2 = router_interface.modify_router_interface_attribute(params)
       CommonUtil.log("modify_router_interface_attribute", modify_ri_json2)
   
       # Query information about the initiator router interface.
       describe_ri_json = router_interface.describe_router_interface(router_interface_json['RouterInterfaceId'])
       CommonUtil.log("describe_router_interface", describe_ri_json)
   
       # Query information about the receiver router interface.
       describe_ri_json2 = router_interface.describe_router_interface(router_interface_json2['RouterInterfaceId'])
       CommonUtil.log("describe_router_interface", describe_ri_json2)
   
       # Query the route table ID of the VBR.
       params['router_id'] = vbr_json['VbrId']
       params['router_type'] = 'VBR'
       route_table_json = router_interface.describe_route_table(params)
       CommonUtil.log("describe_route_table", route_table_json)
   
       # Initiate a connection.
       params['router_interface_id'] = router_interface_json['RouterInterfaceId']
       connect_ri_json = router_interface.connect_router_interface(params)
       CommonUtil.log("connect_router_interface", connect_ri_json)
   
       # Create a route whose next hop is the initiator router interface.
       params['route_table_id'] = route_table_json["RouteTables"]["RouteTable"][0]["RouteTableId"]
       params['destination_cidr_block'] = "0.0.0.0/0"
       params['nexthop_type'] = 'RouterInterface'
       params['nexthop_id'] = router_interface_json['RouterInterfaceId']
       route_entry_json = route_entry.create_route_entry(params)
       CommonUtil.log("create_route_entry", route_entry_json)
   
       # Create a route whose next hop is the receiver router interface.
       params['route_table_id'] = TABLE_ID2
       params['destination_cidr_block'] = "0.0.0.0/0"
       params['nexthop_type'] = 'RouterInterface'
       params['nexthop_id'] = router_interface_json2['RouterInterfaceId']
       route_entry_json2 = route_entry.create_route_entry(params)
       CommonUtil.log("create_route_entry", route_entry_json2)
   
       # Delete the route whose next hop is the receiver router interface.
       route_entry_json = route_entry.delete_route_entry(params)
       CommonUtil.log("delete_route_entry", route_entry_json)
   
       # Delete the route whose next hop is the initiator router interface.
       params['route_table_id'] = route_table_json["RouteTables"]["RouteTable"][0]["RouteTableId"]
       params['nexthop_id'] = router_interface_json['RouterInterfaceId']
       route_entry_json = route_entry.delete_route_entry(params)
       CommonUtil.log("delete_route_entry", route_entry_json)
   
       # Disable the initiator router interface.
       params['router_interface_id'] = router_interface_json['RouterInterfaceId']
       deactivate_ri_json = router_interface.deactivate_router_interface(params)
       CommonUtil.log("deactivate_router_interface", deactivate_ri_json)
   
       # Disable the receiver router interface.
       params['router_interface_id'] = router_interface_json2['RouterInterfaceId']
       deactivate_ri_json2 = router_interface.deactivate_router_interface(params)
       CommonUtil.log("deactivate_router_interface", deactivate_ri_json2)
   
       # Delete the initiator router interface.
       params['instance_id'] = router_interface_json['RouterInterfaceId']
       router_interface_json = router_interface.delete_router_interface(params)
       CommonUtil.log("delete_router_interface", router_interface_json)
   
       # Delete the receiver router interface.
       params['instance_id'] = router_interface_json2['RouterInterfaceId']
       router_interface_json2 = router_interface.delete_router_interface(params)
       CommonUtil.log("delete_router_interface", router_interface_json2)
   
       # Delete the VBR.
       params['vbr_id'] = vbr_json['VbrId']
       vbr_json = router_interface.delete_virtual_border_router(params)
       CommonUtil.log("delete_virtual_border_router", vbr_json)
   
   if __name__ == '__main__':
       sys.exit(main())
                           

3. Go to the directory where the ec_vbr_vpc.py file is stored and run the following command to create a peering connection between the VBR and VPC that belong to the same region and account.

   python ec_vbr_vpc.py

---------------------------create_virtual_border_router---------------------------
{
  "VbrId": "vbr-bp1vudncgk9jt****", 
  "RequestId": "0C4FABDB-FF18-4E70-9E43-6DC03197F0EA"
}
---------------------------create_router_interface---------------------------
{
  "RequestId": "11F14FA2-ECFA-4B27-A75D-7C6D5FECACDF", 
  "RouterInterfaceId": "ri-bp1vabte8nbde****"
}
---------------------------create_router_interface---------------------------
{
  "RequestId": "72FAB86D-470B-40E4-8476-F9223A911486", 
  "RouterInterfaceId": "ri-bp1mxkc61ly0n****"
}
---------------------------modify_router_interface_attribute---------------------------
{
  "RequestId": "93D5FFF7-6C05-41B1-92F0-AC8F1809BC98"
}
---------------------------modify_router_interface_attribute---------------------------
{
  "RequestId": "1C461452-42BD-4649-B318-2214222B4FCA"
}
---------------------------describe_router_interface---------------------------
{
  "TotalCount": 1, 
  "RouterInterfaceSet": {
    "RouterInterfaceType": [
      {
        "BusinessStatus": "Normal", 
        "CreationTime": "2019-04-30T02:54:22Z", 
        "AccessPointId": "ap-cn-hangzhou-xx-x", 
        "Role": "InitiatingSide", 
        "OppositeRouterId": "vrt-bp141no9pds2b****", 
        "Spec": "Large.2", 
        "Status": "Idle", 
        "EndTime": "2999-09-08T16:00:00Z", 
        "OppositeInterfaceSpec": "Negative", 
        "RouterInterfaceId": "ri-bp1vabte8nbde****", 
        "RouterType": "VBR", 
        "OppositeBandwidth": 0, 
        "OppositeVpcInstanceId": "vpc-bp1v31by9jix2****", 
        "HasReservationData": false, 
        "OppositeInterfaceBusinessStatus": "Normal", 
        "OppositeRouterType": "VRouter", 
        "OppositeRegionId": "cn-hangzhou", 
        "RouterId": "vbr-bp1vudncgk9jt****", 
        "CrossBorder": false, 
        "OppositeInterfaceOwnerId": "", 
        "Bandwidth": 2048, 
        "OppositeInterfaceId": "ri-bp1mxkc61ly0n****", 
        "ChargeType": "AfterPay"
      }
    ]
  }, 
  "PageNumber": 1, 
  "RequestId": "3553DB38-A4A0-4453-976C-542E96B1B5A9", 
  "PageSize": 10
}
---------------------------describe_router_interface---------------------------
{
  "TotalCount": 1, 
  "RouterInterfaceSet": {
    "RouterInterfaceType": [
      {
        "Status": "Idle", 
        "OppositeRegionId": "cn-hangzhou", 
        "BusinessStatus": "Normal", 
        "OppositeRouterId": "vbr-bp1vudncgk9jt****", 
        "VpcInstanceId": "vpc-bp1v31by9jix2****", 
        "RouterInterfaceId": "ri-bp1mxkc61ly0n****", 
        "CreationTime": "2019-04-30T02:54:24Z", 
        "RouterType": "VRouter", 
        "OppositeInterfaceOwnerId": "", 
        "RouterId": "vrt-bp141no9pds2b****", 
        "Bandwidth": 0, 
        "OppositeInterfaceId": "ri-bp1vabte8nbde****", 
        "EndTime": "2999-09-08T16:00:00Z", 
        "ChargeType": "AfterPay", 
        "OppositeAccessPointId": "ap-cn-hangzhou-xx-x", 
        "HasReservationData": false, 
        "CrossBorder": false, 
        "OppositeInterfaceBusinessStatus": "Normal", 
        "Spec": "Negative", 
        "OppositeRouterType": "VBR", 
        "Role": "AcceptingSide"
      }
    ]
  }, 
  "PageNumber": 1, 
  "RequestId": "217D8D94-C508-4285-8101-7DE3B53A88A5", 
  "PageSize": 10
}
---------------------------describe_route_table---------------------------
{
  "TotalCount": 1, 
  "PageNumber": 1, 
  "RequestId": "CA6BBE52-DF5E-496A-93CF-9857AF22D2AC", 
  "PageSize": 10, 
  "RouteTables": {
    "RouteTable": [
      {
        "RouteTableId": "vtb-bp1s126yz0swp****", 
        "RouteEntrys": {
          "RouteEntry": []
        }, 
        "CreationTime": "2019-04-30T02:54:19Z", 
        "VSwitchIds": {
          "VSwitchId": []
        }, 
        "ResourceGroupId": "", 
        "VRouterId": "vbr-bp1vudncgk9jt****", 
        "RouteTableType": "System"
      }
    ]
  }
}
---------------------------connect_router_interface---------------------------
{
  "RequestId": "93476D4E-6C08-44B8-83E4-5759E1A08F29"
}
---------------------------create_route_entry---------------------------
{
  "RequestId": "66D4F46B-5E0F-4565-8740-845EC26EBE00"
}
---------------------------create_route_entry---------------------------
{
  "RequestId": "E1F99FEF-2499-40A7-84ED-6F9D440D4FF8"
}
---------------------------delete_route_entry---------------------------
{
  "RequestId": "8C983886-F058-4234-A6D7-ECDEE2C2D945"
}
---------------------------delete_route_entry---------------------------
{
  "RequestId": "DDEC56B9-CDD4-4D0A-B460-040B85B97FE9"
}
---------------------------deactivate_router_interface---------------------------
{
  "RequestId": "04069B7C-6A42-43F2-A086-50F802940045"
}
---------------------------deactivate_router_interface---------------------------
{
  "RequestId": "B2EBF829-E1C0-43E5-9BAD-DFFCBFA301F7"
}
---------------------------delete_router_interface---------------------------
{
  "RequestId": "20EEC4A6-E468-4F3C-A743-89193F7504E1"
}
---------------------------delete_router_interface---------------------------
{
  "RequestId": "59DCE168-B9CC-43A3-A54F-0D8C194BABE0"
}
---------------------------delete_virtual_border_router---------------------------
{
  "RequestId": "E1D71EEC-FE9F-4834-8780-19EBBD91A638"
}