BedrockAgentCoreControl / Paginator / ListGatewayRules

ListGatewayRules¶

class BedrockAgentCoreControl.Paginator.ListGatewayRules¶

paginator = client.get_paginator('list_gateway_rules')

paginate(**kwargs)¶

Creates an iterator that will paginate through responses from BedrockAgentCoreControl.Client.list_gateway_rules().

Request Syntax

response_iterator = paginator.paginate(
    gatewayIdentifier='string',
    PaginationConfig={
        'MaxItems': 123,
        'PageSize': 123,
        'StartingToken': 'string'
    }
)

Parameters:

gatewayIdentifier (string) –
[REQUIRED]

The identifier of the gateway to list rules for.
PaginationConfig (dict) –
A dictionary that provides parameters to control pagination.
- MaxItems (integer) –
  
  The total number of items to return. If the total number of items available is more than the value specified in max-items then a NextToken will be provided in the output that you can use to resume pagination.
- PageSize (integer) –
  
  The size of each page.
- StartingToken (string) –
  
  A token to specify where to start paginating. This is the NextToken from a previous response.

Return type:

dict

Returns:

Response Syntax

{
    'gatewayRules': [
        {
            'ruleId': 'string',
            'gatewayArn': 'string',
            'priority': 123,
            'conditions': [
                {
                    'matchPrincipals': {
                        'anyOf': [
                            {
                                'iamPrincipal': {
                                    'arn': 'string',
                                    'operator': 'StringEquals'|'StringLike'
                                }
                            },
                        ]
                    },
                    'matchPaths': {
                        'anyOf': [
                            'string',
                        ]
                    }
                },
            ],
            'actions': [
                {
                    'configurationBundle': {
                        'staticOverride': {
                            'bundleArn': 'string',
                            'bundleVersion': 'string'
                        },
                        'weightedOverride': {
                            'trafficSplit': [
                                {
                                    'name': 'string',
                                    'weight': 123,
                                    'configurationBundle': {
                                        'bundleArn': 'string',
                                        'bundleVersion': 'string'
                                    },
                                    'description': 'string',
                                    'metadata': {
                                        'string': 'string'
                                    }
                                },
                            ]
                        }
                    },
                    'routeToTarget': {
                        'staticRoute': {
                            'targetName': 'string'
                        },
                        'weightedRoute': {
                            'trafficSplit': [
                                {
                                    'name': 'string',
                                    'weight': 123,
                                    'targetName': 'string',
                                    'description': 'string',
                                    'metadata': {
                                        'string': 'string'
                                    }
                                },
                            ]
                        }
                    }
                },
            ],
            'description': 'string',
            'createdAt': datetime(2015, 1, 1),
            'status': 'CREATING'|'ACTIVE'|'UPDATING'|'DELETING',
            'system': {
                'managedBy': 'string'
            },
            'updatedAt': datetime(2015, 1, 1)
        },
    ],
    'NextToken': 'string'
}

Response Structure

(dict) –
- gatewayRules (list) –
  
  The list of gateway rules.
  - (dict) –
    
    Detailed information about a gateway rule.
    - ruleId (string) –
      
      The unique identifier of the gateway rule.
    - gatewayArn (string) –
      
      The Amazon Resource Name (ARN) of the gateway that the rule belongs to.
    - priority (integer) –
      
      The priority of the rule. Rules are evaluated in order of priority, with lower numbers evaluated first.
    - conditions (list) –
      
      The conditions that must be met for the rule to apply.
      - (dict) –
        
        A condition that determines when a gateway rule applies. Conditions can match on principals or request paths.
        
        Note
        This is a Tagged Union structure. Only one of the following top level keys will be set: matchPrincipals, matchPaths. If a client receives an unknown member it will set SDK_UNKNOWN_MEMBER as the top level key, which maps to the name or tag of the unknown member. The structure of SDK_UNKNOWN_MEMBER is as follows:
        
        'SDK_UNKNOWN_MEMBER': {'name': 'UnknownMemberName'}
        
        matchPrincipals (dict) –
        
        A condition that matches on the identity of the caller making the request.
        
        anyOf (list) –
        
        A list of principal entries. The condition is met if any of the entries match the caller’s identity.
        
        (dict) –
        
        Union for principal matching. Currently supports IAM principal ARN glob matching.
        
        Note
        This is a Tagged Union structure. Only one of the following top level keys will be set: iamPrincipal. If a client receives an unknown member it will set SDK_UNKNOWN_MEMBER as the top level key, which maps to the name or tag of the unknown member. The structure of SDK_UNKNOWN_MEMBER is as follows:
        
        'SDK_UNKNOWN_MEMBER': {'name': 'UnknownMemberName'}
        
        iamPrincipal (dict) –
        
        An IAM principal to match against, specified by ARN.
        
        arn (string) –
        
        The Amazon Resource Name (ARN) of the IAM principal. Supports user, role, and assumed-role ARNs. Wildcards can be used with the StringLike operator.
        
        operator (string) –
        
        The match operator. StringEquals requires an exact match. StringLike supports wildcard patterns using * and ?.
        
        matchPaths (dict) –
        
        A condition that matches on the request path.
        
        anyOf (list) –
        
        A list of path patterns. The condition is met if the request path matches any of the patterns.
        
        (string) –
    - actions (list) –
      
      The actions to take when the rule conditions are met.
      - (dict) –
        
        An action to take when a gateway rule’s conditions are met.
        
        Note
        This is a Tagged Union structure. Only one of the following top level keys will be set: configurationBundle, routeToTarget. If a client receives an unknown member it will set SDK_UNKNOWN_MEMBER as the top level key, which maps to the name or tag of the unknown member. The structure of SDK_UNKNOWN_MEMBER is as follows:
        
        'SDK_UNKNOWN_MEMBER': {'name': 'UnknownMemberName'}
        
        configurationBundle (dict) –
        
        An action that applies a configuration bundle override to the request.
        
        Note
        This is a Tagged Union structure. Only one of the following top level keys will be set: staticOverride, weightedOverride. If a client receives an unknown member it will set SDK_UNKNOWN_MEMBER as the top level key, which maps to the name or tag of the unknown member. The structure of SDK_UNKNOWN_MEMBER is as follows:
        
        'SDK_UNKNOWN_MEMBER': {'name': 'UnknownMemberName'}
        
        staticOverride (dict) –
        
        A static configuration bundle override that applies a single bundle version to all matching requests.
        
        bundleArn (string) –
        
        The Amazon Resource Name (ARN) of the configuration bundle to apply.
        
        bundleVersion (string) –
        
        The version of the configuration bundle to apply.
        
        weightedOverride (dict) –
        
        A weighted configuration bundle override that splits traffic between multiple bundle versions based on configured weights.
        
        trafficSplit (list) –
        
        The traffic split entries defining how traffic is distributed between configuration bundle versions.
        
        (dict) –
        
        An entry in a traffic split configuration, defining a named variant with a weight and configuration bundle reference.
        
        name (string) –
        
        The name of this traffic split variant.
        
        weight (integer) –
        
        The percentage of traffic to route to this variant. Weights across all entries must sum to 100.
        
        configurationBundle (dict) –
        
        The configuration bundle reference for this variant.
        
        bundleArn (string) –
        
        The Amazon Resource Name (ARN) of the configuration bundle.
        
        bundleVersion (string) –
        
        The version of the configuration bundle.
        
        description (string) –
        
        The description of this traffic split variant.
        
        metadata (dict) –
        
        Key-value metadata associated with this traffic split variant.
        
        (string) –
        
        (string) –
        
        routeToTarget (dict) –
        
        An action that routes the request to a specific target.
        
        Note
        This is a Tagged Union structure. Only one of the following top level keys will be set: staticRoute, weightedRoute. If a client receives an unknown member it will set SDK_UNKNOWN_MEMBER as the top level key, which maps to the name or tag of the unknown member. The structure of SDK_UNKNOWN_MEMBER is as follows:
        
        'SDK_UNKNOWN_MEMBER': {'name': 'UnknownMemberName'}
        
        staticRoute (dict) –
        
        A static route that sends all matching requests to a single target.
        
        targetName (string) –
        
        The name of the target to route requests to.
        
        weightedRoute (dict) –
        
        A weighted route that splits traffic between multiple targets.
        
        trafficSplit (list) –
        
        The traffic split entries defining how traffic is distributed between targets.
        
        (dict) –
        
        An entry in a target traffic split configuration.
        
        name (string) –
        
        The name of this traffic split variant.
        
        weight (integer) –
        
        The percentage of traffic to route to this variant.
        
        targetName (string) –
        
        The name of the target to route traffic to.
        
        description (string) –
        
        The description of this traffic split variant.
        
        metadata (dict) –
        
        Key-value metadata associated with this traffic split variant.
        
        (string) –
        
        (string) –
    - description (string) –
      
      The description of the gateway rule.
    - createdAt (datetime) –
      
      The timestamp when the rule was created.
    - status (string) –
      
      The current status of the rule.
    - system (dict) –
      
      System-managed metadata for rules created by automated processes.
      - managedBy (string) –
        
        The identifier of the system or process that manages this rule.
    - updatedAt (datetime) –
      
      The timestamp when the rule was last updated.
- NextToken (string) –
  
  A token to resume pagination.