BGP Route Map¶

The BgpRouteMap class manages BGP route map objects in Palo Alto Networks' Strata Cloud Manager. It extends from BaseObject and offers methods to create, retrieve, update, list, fetch, and delete BGP route maps. Route maps provide import/export policy control for BGP, defining ordered entries with match criteria and set actions. Each entry has a sequence number, a permit/deny action, optional match conditions, and optional set modifications.

Note

The API uses the spelling substract (not subtract) for the metric action type. This typo is preserved in the SDK to match the API exactly.

Class Overview¶

from scm.client import Scm

# Initialize client
client = Scm(
   client_id="your_client_id",
   client_secret="your_client_secret",
   tsg_id="your_tsg_id"
)

# Access the BGP Route Map service directly through the client
bgp_route_maps = client.bgp_route_map

Method	Description	Parameters	Return Type
`create()`	Creates a new BGP route map	`data: Dict[str, Any]`	`BgpRouteMapResponseModel`
`get()`	Retrieves a BGP route map by its unique ID	`object_id: str`	`BgpRouteMapResponseModel`
`update()`	Updates an existing BGP route map	`route_map: BgpRouteMapUpdateModel`	`BgpRouteMapResponseModel`
`list()`	Lists BGP route maps with optional filtering	`folder: Optional[str]`, `snippet: Optional[str]`, `device: Optional[str]`, `exact_match: bool = False`, plus additional filters	`List[BgpRouteMapResponseModel]`
`fetch()`	Fetches a single BGP route map by name within a container	`name: str`, `folder: Optional[str]`, `snippet: Optional[str]`, `device: Optional[str]`	`BgpRouteMapResponseModel`
`delete()`	Deletes a BGP route map by its ID	`object_id: str`	`None`

BGP Route Map Model Attributes¶

Attribute	Type	Required	Default	Description
`name`	str	Yes	None	Route map name
`id`	UUID	Yes*	None	Unique identifier (*response/update only)
`route_map`	List[BgpRouteMapEntry]	No	None	List of route map entries
`folder`	str	No**	None	Folder location. Max 64 chars
`snippet`	str	No**	None	Snippet location. Max 64 chars
`device`	str	No**	None	Device location. Max 64 chars

* Only required for update and response models ** Exactly one container (folder/snippet/device) must be provided for create operations

Route Map Entry Configuration¶

The route_map attribute holds a list of entries, each with a sequence number, action, match criteria, and set actions.

BgpRouteMapEntry¶

Attribute	Type	Required	Description
`name`	int	Yes	Sequence number (1-65535)
`description`	str	No	Entry description
`action`	str	No	Action: "permit" or "deny"
`match`	BgpRouteMapMatch	No	Match criteria
`set`	BgpRouteMapSet	No	Set actions

BgpRouteMapMatch¶

Attribute	Type	Required	Description
`as_path_access_list`	str	No	AS path access list name
`interface`	str	No	Interface name to match
`regular_community`	str	No	Regular community to match
`origin`	str	No	Origin to match
`large_community`	str	No	Large community to match
`tag`	int	No	Tag value to match
`extended_community`	str	No	Extended community to match
`local_preference`	int	No	Local preference to match
`metric`	int	No	Metric value to match
`peer`	str	No	Peer type: "local" or "none"
`ipv4`	BgpRouteMapMatchIpv4	No	IPv4 match criteria

BgpRouteMapMatchIpv4¶

Attribute	Type	Required	Description
`address`	str	No	IPv4 address prefix list to match
`next_hop`	str	No	IPv4 next-hop prefix list to match
`route_source`	str	No	IPv4 route source to match

BgpRouteMapSet¶

Attribute	Type	Required	Description
`atomic_aggregate`	bool	No	Set atomic aggregate
`local_preference`	int	No	Local preference value to set
`tag`	int	No	Tag value to set
`metric`	BgpRouteMapSetMetric	No	Metric action
`weight`	int	No	Weight value to set
`origin`	str	No	Origin: "none", "egp", "igp", "incomplete"
`remove_regular_community`	str	No	Regular community to remove
`remove_large_community`	str	No	Large community to remove
`originator_id`	str	No	Originator ID to set
`aggregator`	BgpRouteMapSetAggregator	No	Aggregator configuration
`ipv4`	BgpRouteMapSetIpv4	No	IPv4 set configuration
`aspath_exclude`	str	No	AS path to exclude
`aspath_prepend`	str	No	AS path to prepend
`regular_community`	List[str]	No	Regular communities to set
`overwrite_regular_community`	bool	No	Overwrite existing communities
`large_community`	List[str]	No	Large communities to set
`overwrite_large_community`	bool	No	Overwrite existing large communities

BgpRouteMapSetMetric¶

Attribute	Type	Required	Description
`action`	str	No	Metric action: "set", "add", or "substract" (API spelling)
`value`	int	No	Metric value

BgpRouteMapSetAggregator¶

Attribute	Type	Required	Description
`as`	int	No	Aggregator AS number
`router_id`	str	No	Aggregator router ID

BgpRouteMapSetIpv4¶

Attribute	Type	Required	Description
`source_address`	str	No	Source address to set
`next_hop`	str	No	Next-hop address to set

Exceptions¶

Exception	HTTP Code	Description
`InvalidObjectError`	400	Thrown when provided data or parameters are invalid
`MissingQueryParameterError`	400	Thrown when required query parameters (e.g., `name` or `folder`) are missing
`NameNotUniqueError`	409	Route map name already exists
`ObjectNotPresentError`	404	Route map not found
`ReferenceNotZeroError`	409	Route map still referenced
`AuthenticationError`	401	Authentication failed
`ServerError`	500	Internal server error

Methods¶

List BGP Route Maps¶

# List all route maps in a folder
route_maps = client.bgp_route_map.list(
   folder="Texas"
)

# Process results
for rm in route_maps:
   entry_count = len(rm.route_map) if rm.route_map else 0
   print(f"Name: {rm.name} ({entry_count} entries)")

Filtering Responses¶

The list() method supports additional parameters to refine your query results even further. Alongside basic filters, you can leverage the exact_match, exclude_folders, exclude_snippets, and exclude_devices parameters to control which objects are included or excluded after the initial API response is fetched.

Parameters:

exact_match (bool): When True, only objects defined exactly in the specified container (folder, snippet, or device) are returned. Inherited or propagated objects are filtered out.
exclude_folders (List[str]): Provide a list of folder names that you do not want included in the results.
exclude_snippets (List[str]): Provide a list of snippet values to exclude from the results.
exclude_devices (List[str]): Provide a list of device values to exclude from the results.

Examples:

# Only return route maps defined exactly in 'Texas'
exact_maps = client.bgp_route_map.list(
   folder='Texas',
   exact_match=True
)

for rm in exact_maps:
   print(f"Exact match: {rm.name} in {rm.folder}")

# Exclude all route maps from the 'All' folder
no_all_maps = client.bgp_route_map.list(
   folder='Texas',
   exclude_folders=['All']
)

for rm in no_all_maps:
   assert rm.folder != 'All'
   print(f"Filtered out 'All': {rm.name}")

Controlling Pagination with max_limit¶

The SDK supports pagination through the max_limit parameter, which defines how many objects are retrieved per API call. By default, max_limit is set to 2500. The API itself imposes a maximum allowed value of 5000. If you set max_limit higher than 5000, it will be capped to the API's maximum. The list() method will continue to iterate through all objects until all results have been retrieved. Adjusting max_limit can help manage retrieval performance and memory usage when working with large datasets.

Example:

from scm.client import Scm

# Initialize client
client = Scm(
   client_id="your_client_id",
   client_secret="your_client_secret",
   tsg_id="your_tsg_id"
)

# Configure max_limit using the property setter
client.bgp_route_map.max_limit = 4000

# List all route maps - auto-paginates through results
all_maps = client.bgp_route_map.list(folder='Texas')

Fetch a BGP Route Map¶

# Fetch by name and folder
route_map = client.bgp_route_map.fetch(
   name="inbound-policy",
   folder="Texas"
)
print(f"Found route map: {route_map.name}")
if route_map.route_map:
   for entry in route_map.route_map:
      print(f"  Seq {entry.name}: {entry.action}")
      if entry.description:
         print(f"    Description: {entry.description}")

# Get by ID
route_map_by_id = client.bgp_route_map.get(route_map.id)
print(f"Retrieved route map: {route_map_by_id.name}")

Create a BGP Route Map¶

from scm.client import Scm

# Initialize client
client = Scm(
   client_id="your_client_id",
   client_secret="your_client_secret",
   tsg_id="your_tsg_id"
)

# Create a route map for inbound policy
inbound_map_data = {
   "name": "inbound-policy",
   "route_map": [
      {
         "name": 10,
         "description": "Accept internal prefixes with higher local-pref",
         "action": "permit",
         "match": {
            "ipv4": {
               "address": "internal-prefixes"
            }
         },
         "set": {
            "local_preference": 200,
            "weight": 100
         }
      },
      {
         "name": 20,
         "description": "Accept all other routes with default local-pref",
         "action": "permit",
         "set": {
            "local_preference": 100
         }
      }
   ],
   "folder": "Texas"
}

new_map = client.bgp_route_map.create(inbound_map_data)
print(f"Created route map with ID: {new_map.id}")

# Create a route map with community manipulation
community_map_data = {
   "name": "set-communities",
   "route_map": [
      {
         "name": 10,
         "action": "permit",
         "match": {
            "as_path_access_list": "customer-as-paths"
         },
         "set": {
            "regular_community": ["65000:100", "65000:200"],
            "overwrite_regular_community": True
         }
      }
   ],
   "folder": "Texas"
}

community_map = client.bgp_route_map.create(community_map_data)
print(f"Created community route map with ID: {community_map.id}")

# Create a route map with AS path prepending
prepend_map_data = {
   "name": "as-prepend-outbound",
   "route_map": [
      {
         "name": 10,
         "description": "Prepend AS path to de-prefer this path",
         "action": "permit",
         "match": {
            "ipv4": {
               "address": "backup-prefixes"
            }
         },
         "set": {
            "aspath_prepend": "65000 65000 65000",
            "metric": {
               "action": "set",
               "value": 200
            }
         }
      },
      {
         "name": 100,
         "action": "permit"
      }
   ],
   "folder": "Texas"
}

prepend_map = client.bgp_route_map.create(prepend_map_data)
print(f"Created AS-prepend route map with ID: {prepend_map.id}")

Update a BGP Route Map¶

# Fetch existing route map
existing_map = client.bgp_route_map.fetch(
   name="inbound-policy",
   folder="Texas"
)

# Add a deny entry for bogon prefixes at the beginning
existing_map.route_map.insert(0, {
   "name": 5,
   "description": "Deny bogon prefixes",
   "action": "deny",
   "match": {
      "ipv4": {
         "address": "bogon-prefixes"
      }
   }
})

# Perform update
updated_map = client.bgp_route_map.update(existing_map)

Delete a BGP Route Map¶

# Delete by ID
route_map_id = "123e4567-e89b-12d3-a456-426655440000"
client.bgp_route_map.delete(route_map_id)

Use Cases¶

Performing Commits¶

# Prepare commit parameters
commit_params = {
   "folders": ["Texas"],
   "description": "Updated BGP route map configurations",
   "sync": True,
   "timeout": 300  # 5 minute timeout
}

# Commit the changes directly on the client
result = client.commit(**commit_params)

print(f"Commit job ID: {result.job_id}")

Monitoring Jobs¶

# Get status of specific job directly from the client
job_status = client.get_job_status(result.job_id)
print(f"Job status: {job_status.data[0].status_str}")

# List recent jobs directly from the client
recent_jobs = client.list_jobs(limit=10)
for job in recent_jobs.data:
   print(f"Job {job.id}: {job.type_str} - {job.status_str}")

Error Handling¶

from scm.client import Scm
from scm.exceptions import (
   InvalidObjectError,
   MissingQueryParameterError,
   NameNotUniqueError,
   ObjectNotPresentError,
   ReferenceNotZeroError
)

# Initialize client
client = Scm(
   client_id="your_client_id",
   client_secret="your_client_secret",
   tsg_id="your_tsg_id"
)

try:
   # Create BGP route map
   map_config = {
      "name": "test-route-map",
      "route_map": [
         {
            "name": 10,
            "action": "permit",
            "set": {
               "local_preference": 150
            }
         }
      ],
      "folder": "Texas"
   }

   new_map = client.bgp_route_map.create(map_config)

   # Commit changes
   result = client.commit(
      folders=["Texas"],
      description="Added BGP route map",
      sync=True
   )

   # Check job status
   status = client.get_job_status(result.job_id)

except InvalidObjectError as e:
   print(f"Invalid route map data: {e.message}")
except NameNotUniqueError as e:
   print(f"Route map name already exists: {e.message}")
except ObjectNotPresentError as e:
   print(f"Route map not found: {e.message}")
except ReferenceNotZeroError as e:
   print(f"Route map still in use: {e.message}")
except MissingQueryParameterError as e:
   print(f"Missing parameter: {e.message}")