OpenResty Edge™ Python SDK User Manual

Welcome to the user manual for OpenResty Edge™ Python SDK.

# Installation

The Python SDK for OpenResty Edge depends on Python3. Please make sure you have Python 3.6 or above installed.

You can install the Python SDK like any other Python module:

1. Open a Linux terminal or Windows command prompt window.

2. Enter the following command to install the Python SDK:

   pip3 install openresty-edge-sdk --index-url https://pypi.org/simple
   

If you want to install a specific version of the Python SDK, you can append the version number to the module name:

pip3 install openresty-edge-sdk==1.2.39 --index-url https://pypi.org/simple

After the installation command is successfully executed, you can verify whether it has been installed correctly as follows:

$ python3
>>> from edge2client import Edge2Client
>>> client = Edge2Client('https://EDGE_ADMIN_HOST:EDGE_ADMIN_PORT', 'USERNAME', 'PASSWORD')
>>> client.login()
True
>>> client.get_version()
{'waf': {'waf_version': '3.3.4-1' ...}
>>> exit()

After typing client.login(), if the output is True, it means it has been installed correctly. If your Edge Admin is using a self-signed certificate (which is the default), you also need to call client.set_ssl_verify(False) before client.login(). You can then use client.get_version() to view the version information of OpenResty Edge.

In addition, you can find the release notes of this Python SDK here.

So far the installation is complete, you can refer to the subsequent content in this document to realize more complex operations.

# Synopsis

import sys
import time
from edge2client import Edge2Client

def get_client():
    client = Edge2Client(host, username, password)
    # if a self-signed certificate is causing SSL verification failure, you can uncomment the following line.
    # client.set_ssl_verify(False)
    ok = client.login()

    return client

if __name__ == '__main__':
    try:
        client = get_client()
    except Exception as e:
        print("failed to get client: ", str(e))
        sys.exit(1)

    try:
        app_ids = client.get_all_apps()
    except Exception as e:
        print("failed to get all apps: ", str(e))
        sys.exit(1)

    for app_id in app_ids:
        client.use_app(app_id)
        if client.pending_changes() > 0:
            ret = client.new_release()
            if ret:
                print('release ok app id: ' + str(app_id))
            else:
                print('release failed: ' + str(app_id))
            time.sleep(1)

# Methods

# Method Documentation

# Edge2Client

client = Edge2Client(host, username, password, api_token=None)

This method is used to initialize the SDK client.

Parameters

Returns

• Returns an edge2client.Edge2Client object.

Examples

1. When the address of Edge Admin is https://127.0.0.1:443, and the Edge2Client object is initialized using the username username and password password:

   from edge2client import Edge2Client
   
   client = Edge2Client('https://127.0.0.1:443', 'username', 'password')
   

2. When initializing the Edge2Client object using the API Token api_token:

   from edge2client import Edge2Client
   
   client = Edge2Client('https://127.0.0.1:443', None, None, "api_token")
   

# set_ssl_verify

set_ssl_verify(verify)

Sets whether to perform SSL verification when accessing Edge Admin, verification is performed by default. When your Edge Admin is using a self-signed certificate, it is necessary to disable SSL verification.

Parameters

Examples

from edge2client import Edge2Client

client = Edge2Client(host, username, password)
client.set_ssl_verify(False)
ok = client.login()

# login

ok = login()

This method is used for logging into OpenResty Edge in order to perform subsequent operations.

Returns

• True: indicates a successful login.
• False: indicates a failed login.

Examples

from edge2client import Edge2Client

client = Edge2Client(host, username, password)

ok = client.login()

# use_app

ok = use_app(app_id)

This method is used to specify the application ID for the current instance operation.

Returns

• True: Application ID specification was successful.
• False: Application ID specification failed.

Examples

The following example demonstrates how to change the application ID for the current instance operation to 10.

from edge2client import Edge2Client

client = Edge2Client(host, username, password)
client.login()

app_id = 10
client.use_app(app_id)

# new_app

app_id = new_app(domains, label)

This method is used to add a new HTTP application.

Parameters

Returns

• app_id: Returns the ID of the newly created application, its data type is number.

Examples

The following example shows how to create an HTTP application with the domain orig.foo.com, the label origin site for foo.com, and the application is located in the cluster group [1].

from edge2client import Edge2Client

client = Edge2Client(host, username, password)
client.login()

app_id = client.new_app(
    domains=['orig.foo.com'],
    label='origin site for foo.com',
    cluster_groups = [1])

# put_app

ok = put_app(app_id, domains, label, cluster_groups=None, offline=None)

This method is used to modify the basic information of an HTTP application.

Parameters

Returns

• True: Indicates modification was successful.
• False: Indicates modification failed.

Examples

The following example demonstrates how to modify the domain of a previously created application (with domain orig.foo.com) to *.foo.com.

from edge2client import Edge2Client

client = Edge2Client(host, username, password)
client.login()

app_id = 10
client.use_app(app_id)

ok = client.put_app(app_id, domains=['*.foo.com'], label='foo.com')

# get_app

data = get_app()

This method is used to retrieve related information of the HTTP application, including domain, tags, and the group it belongs to, etc.

Returns

• data: Returns a dict type data.

Examples

The following example demonstrates how to retrieve the application information with an app_id of 1.

from edge2client import Edge2Client

client = Edge2Client(host, username, password)
client.login()

app_id = 1
client.use_app(app_id)

data = client.get_app()

# put_app_config

put_app_config(app_id, limiter)

This method is used to modify the configuration of the HTTP application.

Parameters

Returns

• True: The configuration was successfully modified.
• False: The configuration modification failed.

Examples

The following example shows how to modify the configuration of the application with an app_id of 1.

from edge2client import Edge2Client

client = Edge2Client(host, username, password)
client.login()

app_id = 1

res = client.put_app_config(app_id=app_id,
                            limiter={
                                        'max_uri_args': 130,
                                        'max_post_args': 140,
                                        'max_req_headers': 150,
                                        'check_post_args_type': True
                                    },
                            enable_websocket=True)

# get_app_config

data = get_app_config(app_id)

This method is used to obtain the configuration information of the specified HTTP application.

Parameters

Returns

• data: Returns a dictionary (dict) type of data.

Examples

The following example shows how to obtain the configuration information of the application with id 1:

from edge2client import Edge2Client

client = Edge2Client(host, username, password)
client.login()

app_id = 1

data = client.get_app_config(app_id)

# del_app

success = del_app(app_id)

This method deletes the specified HTTP application based on the provided app_id.

Parameters

Returns

• True: Indicates the application was deleted successfully.
• False: Indicates the application deletion failed.

Examples

The following example demonstrates how to delete an application with an app_id of 1.

from edge2client import Edge2Client

client = Edge2Client(host, username, password)
client.login()

app_id = 1

success = client.del_app(app_id)

# search_app

data = search_app(app_domain)

This method is used to search HTTP applications based on the specified domain.

Parameters

Returns

• data: Returns a list type of result, each element of which is related information about the application.

Examples

The following example searches for HTTP applications with orig.foo.com as the domain.

from edge2client import Edge2Client

client = Edge2Client(host, username, password)
client.login()

data = client.search_app(app_domain='orig.foo.com')

# search_http_app_by_keyword

data = search_http_app_by_keyword(keyword, page, pagesize)

This method is used to search for HTTP applications based on domain names or application names.

Parameters

Returns

• data: This return value is of list type, each element contains related information of the application.

Examples

from edge2client import Edge2Client

client = Edge2Client(host, username, password)
client.login()

data = client.search_http_app_by_keyword('orig.foo.com')
data = client.search_http_app_by_keyword('orig.foo.com', 1, 2)
data = client.search_http_app_by_keyword('origin')

# search_upstream_by_ip

data = search_upstream_by_ip(ip, page=1, pagesize=20)

This method is used to search upstream information through IP addresses.

Parameters

Returns

• data: Returns a list type of data, each element in the list represents detailed information of an upstream.

Examples

from edge2client import Edge2Client

client = Edge2Client(host, username, password)
client.login()

data = client.search_upstream_by_ip('1.1.1.1')

# search_k8s_upstream_by_ip

data = search_k8s_upstream_by_ip(ip, page, pagesize)

This method is used to search for upstream in Kubernetes by IP.

Parameters

Returns

• data: A list type variable, which contains information about upstream in Kubernetes.

Examples

from edge2client import Edge2Client

client = Edge2Client(host, username, password)
client.login()

data = client.search_k8s_upstream_by_ip('1.1.1.1')

# search_upstream_by_name

data = search_upstream_by_name(name, page, pagesize)

This method is used to search for upstream by name.

Parameters

Returns

• data: This is a list type, each element represents an upstream information.

Examples

from edge2client import Edge2Client

client = Edge2Client(host, username, password)
client.login()

data = client.search_upstream_by_name('test')

# search_k8s_upstream_by_name

data = search_k8s_upstream_by_name(name, page, pagesize)

This method is used to search for Kubernetes upstream by specifying names.

Parameters

Returns

• data: This is of list type, containing information of multiple Kubernetes upstreams.

Examples

from edge2client import Edge2Client

client = Edge2Client(host, username, password)
client.login()

data = client.search_k8s_upstream_by_name('test')

# search_k8s_upstream

data = search_k8s_upstream(namespace, service, port, page, pagesize, type_list)

This method allows users to search for upstream on Kubernetes by specifying the namespace, service name, and port number.

Parameters

Returns

• data: list type, each element in the list is the information of Kubernetes upstream.

Examples

from edge2client import Edge2Client

client = Edge2Client(host, username, password)
client.login()

data = self.client.search_k8s_upstream(port = 80, service = "test-hello", namespace = "default")

# search_k8s_upstream_history

data = search_k8s_upstream_history(page, pagesize, start_time, end_time)

This method searches the upstream history on Kubernetes based on the namespace, service name, and port number.

Parameters

Returns

• data: The return value is of list type, with each element representing an update operation of Kubernetes upstream history.

Examples

from edge2client import Edge2Client

client = Edge2Client(host, username, password)
client.login()

data = client.search_k8s_upstream_history(port = 80, service = "test-hello", namespace = "default")

# get_all_apps

data = get_all_apps(detail)

This method is used to get information of all applications.

Parameters

Returns

• When the detail parameter is False, the function returns a Python object of type list, containing the basic information of all applications.
• When the detail parameter is True, the function returns a Python object of type dict, keyed by the app id, containing all the app details.

Examples

from edge2client import Edge2Client

client = Edge2Client(host, username, password)
client.login()

# Get basic information
apps = client.get_all_apps()

# Get detailed information
apps = client.get_all_apps(detail=True)

# new_upstream

up_id = new_upstream(**kwargs)

This method is used to add a new upstream, and the return value is the id of the newly added upstream.

Parameters

Servers Parameter

Returns

• up_id：The ID of the successfully created upstream.

Examples

from edge2client import Edge2Client

client = Edge2Client(host, username, password)
client.login()

app_id = 1
client.use_app(app_id)

up_id = client.new_upstream(
    name='origin-upstream',
    servers=[
        {'ip': '172.22.31.1', 'port': 80},
        {'ip': '172.22.31.2', 'port': 80, 'weight': 2}
    ])

# put_upstream

ok = put_upstream(**kwargs)

This method is used to modify upstream information.

Parameters

Examples

from edge2client import Edge2Client

client = Edge2Client(host, username, password)
client.login()

app_id = 1
client.use_app(app_id)

up_id = 1
ok = client.put_upstream(up_id,
    name='origin-upstream',
    servers=[
        {'domain': 'test.com', 'port': 8080},
        {'ip': '172.22.31.2', 'port': 8080, 'weight': 1}
    ],
    health_checker={
        'type': 'http',
        'http_req_uri': '/status',
        'http_req_host': 'test.com',
        'interval': 3,
        'interval_unit': 'sec',
        'timeout': 1,
        'fall': 3,
        'rise': 2,
        'valid_statuses': [200, 302],
        'report_interval': 3,
        'report_interval_unit': 'min'
    })

# get_upstream

data = get_upstream(up_id)

This method is used to get upstream information.

Parameters

Returns

• data: Returns upstream information of type dict.

Examples

from edge2client import Edge2Client

client = Edge2Client(host, username, password)
client.login()

app_id = 1
client.use_app(app_id)

up_id = 1
data = client.get_upstream(up_id)

# del_upstream

del_upstream(up_id)

This method is used to delete an upstream.

Parameters

Returns

• Returns True: Indicates the upstream was deleted successfully.
• Returns False: Indicates the upstream deletion failed.

Examples

from edge2client import Edge2Client

client = Edge2Client(host, username, password)
client.login()

app_id = 1
client.use_app(app_id)

up_id = 1

ok = client.del_upstream(up_id)

In this example, we first import Edge2Client, then create an Edge2Client object, and log in with host, username, and password. Then, we try to delete the upstream with the identifier 1 using the del_upstream method.

# get_all_upstreams

upstreams = client.get_all_upstreams()

This method is used to acquire all detailed information about upstreams.

Returns

• upstreams: Returns a list type of data, which contains all upstream information.

Examples

from edge2client import Edge2Client

client = Edge2Client(host, username, password)
client.login()

app_id = 1
client.use_app(app_id)

upstreams = client.get_all_upstreams()

# new_k8s_upstream

up_id = new_k8s_upstream(**kwargs)

This method is used to add a new global Kubernetes upstream, and will return the ID of the newly created k8s upstream.

Parameters

k8s_services Parameters

Returns

• up_id: The ID of the newly created k8s upstream.

Examples

from edge2client import Edge2Client

client = Edge2Client(host, username, password)
client.login()

app_id = 1
client.use_app(app_id)

k8s_up_id = client.new_k8s_upstream(
    name = 'k8s-upstream',
    k8s_services = [
        {
            'k8s' : 1,
            'k8s_namespace' : 'default',
            'k8s_service' : 'foo',
            'k8s_service_port' : 80,
        }
    ])

# copy_upstream_to_k8s_upstream

k8s_up_id = copy_upstream_to_k8s_upstream(up_id, k8s_services, rules)

This method is used to copy a regular upstream to a Kubernetes upstream.

Parameters

Returns

• up_id: The ID of the newly created Kubernetes upstream.

Examples

Example 1:

from edge2client import Edge2Client

client = Edge2Client(host, username, password)
client.login()

app_id = client.new_app(domains = ['orig.foo.com'], label = 'origin site for foo.com')

up_id = client.new_upstream(name = 'origin-upstream',
                            servers = [
                                {'ip': '172.22.31.1', 'port': 80},
                                {'ip': '172.22.31.2', 'port': 80, 'weight': 2}
                            ])

k8s_up_id = client.copy_upstream_to_k8s_upstream(up_id,
                            k8s_services = [
                                {
                                    'k8s' : 1,
                                    'k8s_namespace' : 'default',
                                    'k8s_service' : 'foo',
                                    'k8s_service_port' : 80,
                                }
                            ])

Example 2:

client.use_app(app_id)

rules = client.get_all_rules()

k8s_up_id = client.copy_upstream_to_k8s_upstream(up_id = up_id,
                            k8s_services = [
                                {
                                    'k8s' : 1,
                                    'k8s_namespace' : 'default',
                                    'k8s_service' : 'foo',
                                    'k8s_service_port' : 80,
                                }
                            ],
                            rules = rules)

# put_k8s_upstream

ok = put_k8s_upstream(**kwargs)

This method is used to modify the upstream information on Kubernetes.

Parameters

Returns

• True: Indicates modification was successful.
• False: Indicates modification failed.

Examples

from edge2client import Edge2Client

client = Edge2Client(host, username, password)
client.login()

app_id = 1
client.use_app(app_id)

up_id = 1
ok = client.put_k8s_upstream(up_id,
    name='k8s-upstream',
    k8s_services = [
        {
            'k8s' : 1,
            'k8s_namespace' : 'default',
            'k8s_service' : 'foo',
            'k8s_service_port' : 80,
        }
    ],
    health_checker={
        'type': 'http',
        'http_req_uri': '/status',
        'http_req_host': 'test.com',
        'interval': 3,
        'interval_unit': 'sec',
        'timeout': 1,
        'fall': 3,
        'rise': 2,
        'valid_statuses': [200, 302],
        'report_interval': 3,
        'report_interval_unit': 'min'
    })

# get_k8s_upstream

data = get_k8s_upstream(up_id)

This method is used to obtain information on the k8s upstream.

Parameters

Returns

• data: Returns a dict type of data.

Examples

from edge2client import Edge2Client

client = Edge2Client(host, username, password)
client.login()

app_id = 1
client.use_app(app_id)

up_id = 1
data = client.get_k8s_upstream(up_id)

# del_k8s_upstream

success = del_k8s_upstream(upstream_id)

This method is used to delete the Kubernetes upstream.

Parameters

Returns

• True: Indicates successful deletion.
• False: Indicates failure of deletion.

Examples

from edge2client import Edge2Client

client = Edge2Client(host, username, password)
client.login()

app_id = 1
client.use_app(app_id)

upstream_id = '1'
success = client.del_k8s_upstream(upstream_id)

# get_all_k8s_upstreams

upstreams = client.get_all_k8s_upstreams()

This method is used to get information of all Kubernetes upstreams.

Returns

• upstreams: Returns a list type of Kubernetes upstreams list.

Examples

from edge2client import Edge2Client

client = Edge2Client(host, username, password)
client.login()

app_id = 1
client.use_app(app_id)

upstreams = client.get_all_k8s_upstreams()

# new_rule

rule_id = new_rule(**kwargs)

This method is used to create new page rules, including various types of rules, such as: General rules, Proxy rules, WAF rules, and Cache rules. You can also specify the prerequisite conditions for rule execution.

Parameters

condition Parameter

conseq Parameter

conseq can be dict type or list type, below is an example of a dict type.

waf Parameter

proxy Parameter

Description of proxy array:

upstreams Parameter

Description of upstreams and backup_upstreams array:

cache Parameter

Returns

• rule_id: ID of the new rule.

Examples

Example 1: Create a new rule using dict type condition and action.

from edge2client import Edge2Client

client = Edge2Client(host, username, password)
client.login()

app_id = 1
client.use_app(app_id)

condition = [
    {
        'var': 'host',
        'val': 'con.' + APEX
    },
    {
        'var': ['req-header', 'Referer'],
        'vals': [
            'foo.com',
            ['foo\d+', 'rx'],
            ['foo*', 'wc']
        ]
    }
]

conseq = {
    'enable-websocket': {},
    'redirect': {'url': '/cn/2017/', 'code': 302}
}

rule_id = client.new_rule(condition=condition, conseq=conseq)

Because dict type cannot sort itself and cannot set actions with duplicate names, so it is recommended to use the list type instead of the dict type as follows.

Example 2: Create a new rule using list type condition and action.

from edge2client import Edge2Client

client = Edge2Client(host, username, password)
client.login()

app_id = 1
client.use_app(app_id)

condition = [
    {'var': 'host', 'val': 'con.' + APEX},
    {'var': ['req-header', 'Referer'], 'vals': [['foo\d+', 'rx'], 'foo.com']}
]

conseq = [
    {'set-proxy-header': {
        'header': 'Foo',
        'value': 'default'
    }},
    {'set-proxy-header': {
        'header': 'Host',
        'value': "orig"
    }},
    {'print': {
        'msg': 'hello'
    }}
]

rule_id = client.new_rule(condition=condition, conseq=conseq)

Example three: Enable WAF rule.

Create a custom WAF rule, and use this rule in the application.

from edge2client import Edge2Client

client = Edge2Client(host, username, password)
client.login()

app_id = 1
client.use_app(app_id)

global_waf_rule_id = client.new_global_waf_rule(
    name='foo',
    code="uri-arg('foo') => waf-mark-risk(level: 'definite', msg: 'found foo');")

condition = [{'var': 'uri', 'op': 'prefix', 'val': '/foo'}]

waf_rule = {
    'rule_sets': [global_waf_rule_id],
    'action': '403 Forbidden', 'threshold': 'low'}

rule_id = client.new_rule(condition=condition, waf=waf_rule)

Example four: Enable proxy rule.

from edge2client import Edge2Client

client = Edge2Client(host, username, password)
client.login()

app_id = 1
client.use_app(app_id)

up_id = client.new_upstream(
    name='origin-upstream',
    servers=[
        {'ip': '172.22.31.1', 'port': 80},
        {'ip': '172.22.31.2', 'port': 80, 'weight': 2}
    ])

k8s_up_id = client.new_k8s_upstream(
    name='k8s-upstream',
    k8s_services = [
        {
            'k8s' : k8s_id,
            'k8s_namespace' : 'default',
            'k8s_service' : 'test-hello',
            'k8s_service_port' : 80,
        }
    ])

ok = client.put_upstream(up_id,
    name='origin-upstream',
    servers=[
      {'ip': '172.22.31.1', 'port': 8080},
      {'ip': '172.22.31.2', 'port': 8080, 'weight': 1}
    ])

backup_up_id = client.new_upstream(
    name='backup-upstream',
    servers=[
        {'ip': '172.22.31.3', 'port': 80},
        {'ip': '172.22.31.4', 'port': 80, 'weight': 3}
    ])

proxy_rule = {
    'upstreams': [{'upstream': up_id, 'weight': 2}],
    'backup_upstreams': [{'upstream': backup_up_id}],
    'upstream_el_code': '',
    'retries': 2,
    "retry_condition": ["invalid_header", "http_500"],
    "balancer_algorithm": "hash",
    "balancer_vars": [
        {"name":"uri"},
        {
            "name":"uri-arg",
            "args":"foo"
        }
    ]
}

rule_id = client.new_rule(proxy = proxy_rule)

k8s_proxy_rule = {
    'upstreams': [{'k8s_upstream': k8s_up_id, 'weight': 2}],
    'upstream_el_code': '',
    'retries': 2,
    "retry_condition": ["invalid_header", "http_500"],
    "balancer_algorithm": "hash",
    "balancer_vars": [
        {"name":"uri"},
        {
            "name":"uri-arg",
            "args":"foo"
        }
    ]
}

k8s_rule_id = client.new_rule(proxy = k8s_proxy_rule)

Example five: Enable caching.

In this example, when the source of access IP is located in China (CN), caching rules will be implemented. The specific cache key includes the URL, query string, and the client’s source city.

from edge2client import Edge2Client

client = Edge2Client(host, username, password)
client.login()

app_id = 1
client.use_app(app_id)

condition = [{'var': 'client-country', 'op': 'eq', 'val': 'CN'}]
# cache_key = ['uri', 'query-string', 'client-city']
# or
cache_key = [
    {'name': 'uri'},
    {'name':'query-string'},
    {'name': 'client-city', 'args': 'first-x-forwarded-addr'}
]

default_ttls = [
    {
        'ttl_unit': "min", 'status': 200, 'ttl': 1
    }, {
        'ttl_unit': "min", 'status': 301, 'ttl': 1
    }
]
cache_rule = {'cache_key': cache_key, 'default_ttls': default_ttls}

rule_id = client.new_rule(condition=condition, cache=cache_rule)

# put_rule

ok = put_rule(**kwargs)

This method is used to modify page rules.

Parameters

Returns

• True: Indicates success.
• False: Indicates failure.

Examples

from edge2client import Edge2Client
from edge2client.constants import OFF, ON

client = Edge2Client(host, username, password)
client.login()

app_id = 1
client.use_app(app_id)

conseq = {
    'enable-websocket': {},
    'redirect': {'url': '/cn/2017/', 'code': 302},
    'user-code': {'el': 'true => say(\"hello\");'}
}

conseq['redirect']['url'] = '/cn/2018/'

ok = client.put_rule(rule_id=rule_id, condition=condition, conseq=conseq)

# disable the conditions in the page rules
ok = client.put_rule(rule_id=rule_id, condition=OFF, conseq=conseq)

# get_rule

data = get_rule(rule_id)

This method is used to get page rules according to the rule ID.

Parameters

Returns

• data: Returns a dict type page rule information.

Examples

from edge2client import Edge2Client

client = Edge2Client(host, username, password)
client.login()

app_id = 1
client.use_app(app_id)

rule_id = 1
data = client.get_rule(rule_id)

# del_rule

success = del_rule(rule_id)

This method is used to delete the page rule corresponding to rule_id.

Parameters

Returns

• True: Indicates the page rule was successfully deleted.
• False: Indicates the deletion of the page rule failed.

Examples

from edge2client import Edge2Client

client = Edge2Client(host, username, password)
client.login()

app_id = 1
client.use_app(app_id)

rule_id = 1
success = client.del_rule(rule_id)

# get_all_rules

rules = get_all_rules(app_id)

This method is used to obtain all page rules for the specified application ID (app_id).

Parameters

Returns

• Returns a list of rules. The type of each element in this list is consistent with the return type of the get_rule function.

Examples

from edge2client import Edge2Client

client = Edge2Client(host, username, password)
client.login()

app_id = 1
client.use_app(app_id)

data = client.get_all_rules()

# reorder_rules

ok = reorder_rules(orders)

This method is used to adjust the order of the rules.

Parameters

Returns

• True: If the rule order is successfully adjusted.
• False: If the rule order adjustment fails.

Examples

The following example shows how to swap the order of rule ID 2 and 3.

from edge2client import Edge2Client

client = Edge2Client(host, username, password)
client.login()

app_id = 1
client.use_app(app_id)

new_orders = {
    1: 1,
    2: 3,
    3: 2,
}
data = client.reorder_rules(new_orders)

# get_all_rules_by_app_domain

rules = get_all_rules_by_app_domain(domain)

This method is used to get the corresponding page rules according to the specified application domain.

Parameters

Returns

• rules: A list type of rule sets.

Examples

from edge2client import Edge2Client

client = Edge2Client(host, username, password)
client.login()

app_id = 1
client.use_app(app_id)

data = client.get_all_rules_by_app_domain('orig.foo.com')

# get_all_rules_by_upstream_ip

rules = get_all_rules_by_upstream_ip(upstream_ip)

This method is used to retrieve all associated page rules based on the upstream IP address.

Parameters

Returns

• rules: This is a list type that contains all relevant rules.

Examples

from edge2client import Edge2Client

client = Edge2Client(host, username, password)
client.login()

app_id = 1
client.use_app(app_id)

upstream_ip = '1.2.3.4'
data = client.get_all_rules_by_upstream_ip(upstream_ip)

for app_id, rules in data.items():
    print(app_id)

# get_all_waf_rules

rules = get_all_waf_rules(app_id)

This method is used to get the corresponding WAF rules based on the specific application id (app_id).

Parameters

Returns

• rules: Return a list type of rule list.

Examples

from edge2client import Edge2Client

client = Edge2Client(host, username, password)
client.login()

app_id = 1
client.use_app(app_id)

data = client.get_all_waf_rules()

# get_global_actions_used_in_app

rule_ids = get_global_actions_used_in_app(app_id)

This method is used to get custom rule IDs associated with the application ID (app_id).

Parameters

Returns

• rule_ids: It returns a list, the elements of which are the unique IDs of each rule. If you need to get detailed information about the rules, you can query further based on these rule IDs. For details, please refer to the get_global_rule() method.

Examples

The following example shows how to get the IDs of all global rules.

from edge2client import Edge2Client

client = Edge2Client(host, username, password)
client.login()

app_id = 1
rule_ids = client.get_global_actions_used_in_app(app_id)

# set_cert_key

cert_id = set_cert_key(**kwargs)

This method is used to add a new SSL certificate and provides an option to manually upload the certificate.

Parameters

Returns

• cert_id：Returns the ID of the newly added certificate.

Examples

from edge2client import Edge2Client

client = Edge2Client(host, username, password)
client.login()

app_id = 1
client.use_app(app_id)

key_file = os.path.join('tests', 'key.pem')
cert_file = os.path.join('tests', 'cert.pem')

with open(key_file) as f:
    key = f.read()
with open(cert_file) as f:
    cert = f.read()

cert_id = client.set_cert_key(key=key, cert=cert)

# set_le_cert

cert_id = set_le_cert(**kwargs)

This method is used to add certificates from Let’s Encrypt or other certificate providers (such as ZeroSSL).

Parameters

Returns

• cert_id: ID of the newly created Let’s Encrypt certificate

Examples

from edge2client import Edge2Client

client = Edge2Client(host, username, password)
client.login()

app_id = 1
client.use_app(app_id)

cert_id = client.set_le_cert(domains=["orig.foo.com"])

# put_cert_key

ok = put_cert_key(**kwargs)

This method is used to update SSL certificate (manual upload method).

Parameters

Returns

• True: indicates that the update was successful.
• False: indicates that the update failed.

Examples

from edge2client import Edge2Client

client = Edge2Client(host, username, password)
client.login()

app_id = 1
client.use_app(app_id)

new_key_file = os.path.join('tests', 'new_key.pem')
new_cert_file = os.path.join('tests', 'new_cert.pem')
with open(new_key_file) as f:
    new_key = f.read()
with open(new_cert_file) as f:
    new_cert = f.read()

cert_id = 1
ok = client.put_cert_key(cert_id=cert_id, key=new_key, cert=new_cert)

# put_le_cert

ok = put_le_cert(**kwargs)

This method is used to update certificates from Let’s Encrypt or other certificate providers (such as ZeroSSL).

Parameters

Returns

• True: Indicates success.
• False: Indicates failure.

Examples

from edge2client import Edge2Client

client = Edge2Client(host, username, password)
client.login()

app_id = 1
client.use_app(app_id)

cert_id = 1
ok = client.put_le_cert(cert_id=cert_id, domains=["xx.foo.com"], resign=False)

# get_le_cert

data = get_le_cert(cert_id)

This method is used to obtain the issuance status of a Let’s Encrypt certificate.

Parameters

Returns

• data: Returns a dict type of data containing the following fields:

Examples

from edge2client import Edge2Client

client = Edge2Client(host, username, password)
client.login()

app_id = 1
client.use_app(app_id)

cert_id = 1
data = client.get_le_cert(cert_id)

# get_cert_key

cert_data = get_cert_key(cert_id)

This method is used to obtain the content of the SSL certificate.

Parameters

Returns

• The return value is cert_data, which represents the content of the certificate. The data type is dict.

Examples

from edge2client import Edge2Client

client = Edge2Client(host, username, password)
client.login()

app_id = 1
client.use_app(app_id)

cert_id = 1
data = client.get_cert_key(cert_id)

# get_all_cert_keys

cert_data = get_all_cert_keys()

This method is used to obtain all the certificate information of the current application.

Returns

• cert_data: The certificate data returned in the form of a dict.

Examples

from edge2client import Edge2Client

client = Edge2Client(host, username, password)
client.login()

app_id = 1
client.use_app(app_id)

data = client.get_all_cert_keys()

# del_cert_key

success = del_cert_key(certificate_id)

Deletes the certificate information associated with the given certificate_id.

Parameters

Returns

• True: Deletion successful.
• False: Deletion failed.

Examples

from edge2client import Edge2Client

client = Edge2Client(host, username, password)
client.login()

application_id = 1
client.use_application(application_id)

certificate_id = 1
success = client.del_cert_key(certificate_id)

# new_el

ok = new_el(**kwargs)

This method is used to add custom edge language code.

Parameters

Returns

• True: Indicates success.
• False: Indicates failure.

Examples

from edge2client import Edge2Client

client = Edge2Client(host, username, password)
client.login()

app_id = 1
client.use_app(app_id)

code = "true => print('hello, world');"

ok = client.new_el(phase='req-rewrite', code=code, pre=True)

# new_release

ok = new_release()

This method is used to release updates for the current application.

Returns

• True: Indicates the update was successful.
• False: Indicates the update failed.

Examples

from edge2client import Edge2Client

client = Edge2Client(host, username, password)
client.login()

app_id = 1
client.use_app(app_id)

ok = client.new_release()

This example demonstrates how to use the new_release method of Edge2Client to release updates for the application.

# pending_changes

changes = pending_changes()

This method is used to query the number of changes pending for release.

Returns

• changes: This is an integer that represents the number of changes pending for release.

Examples

from edge2client import Edge2Client

client = Edge2Client(host, username, password)
client.login()

app_id = 1
client.use_app(app_id)

changes = client.pending_changes()

In the above example, an Edge2Client instance is first created and logged in. Then, the id of the application is set to 1, and the pending_changes function is used to query the number of changes pending for release.

# sync_status

total, synced = sync_status()

Query Synchronization Status.

Returns

• total: The total number of Edge Node servers.
• synced: The number of Edge Node servers that have been successfully synchronized.

Examples

Create multiple rules and confirm whether they have been successfully published to the entire network.

from edge2client import Edge2Client

client = Edge2Client(host, username, password)
client.login()

app_id = 1
client.use_app(app_id)

total, synced = client.sync_status()
if total == synced:
    print('The new release has been synchronized to all nodes')

# node_sync_status

data = node_sync_status()

This method is used to get the synchronization details of each node.

Returns

• data: dict type, it returns the node_id of each node and the delay time from the last release to now on this node.

Examples

from edge2client import Edge2Client

client = Edge2Client(host, username, password)
client.login()

data = client.node_sync_status()
for node_id, delay in data.items():
    if delay > 0:
        print('Warning: Node id {}: Lag {}'
        .format(str(node_id), str(delay)))

# get_healthcheck_status

data = get_healthcheck_status(node_id, page=1, page_size=1000)

This piece of code is used to get health check information for each node.

Returns

• data: This is a dict type data, it returns the node_id and the corresponding health status of each node.

Examples

from edge2client import Edge2Client

client = Edge2Client(host, username, password)
client.login()

data = client.node_sync_status()

for node_id, node_info in data.items():
    node_id = int(node_id)
    data = client.get_healthcheck_status(node_id, 1, 1000)

# add_app_user

user_id = add_app_user(name, read, write, release, dns_read, dns_write)

This method is used to add application-level users.

Parameters

Returns

• user_id: The ID of the newly added user.

Please note: The user_id here is different from the user_id of the global user.

Examples

The following example shows how to add an application-level user named only_reader who does not have write and release permissions.

from edge2client import Edge2Client

client = Edge2Client(host, username, password)
client.login()

app_id = 1
client.use_app(app_id)

user_id = client.add_app_user(name='only_reader', write=False, release=False)

# update_app_user

success = update_app_user(id, name, read, write, release, dns_read, dns_write)

This method is used to update user information at the application level.

Parameters

Returns

• True: User information updated successfully.
• False: Failed to update user information.

Examples

The following example shows how to use This method to update the permissions of the user with id 1, set the username to master, and grant write and release permissions.

from edge2client import Edge2Client

client = Edge2Client(host, username, password)
client.login()

app_id = 1
client.use_app(app_id)

uid = 1
success = client.update_app_user(id=uid, name='master', write=True, release=True)

# get_app_user

data = get_app_user(id=None, name=None, app_id=None, user_id=None)

This method is used to get user information at the application level, including username, permissions, etc.

Parameters

Returns

• data: Returns a dictionary type data containing user information such as username, permissions, etc.

Examples

from edge2client import Edge2Client

client = Edge2Client(host, username, password)
client.login()

app_id = 1
client.use_app(app_id)

username = 'only_reader'
data = client.get_app_user(name=username)

# del_app_user

ok = del_app_user(id, name, app_id, user_id)

This method is used to delete a user from a specific application.

Parameters

Returns

• Returns True if the operation is successful.
• Returns False if the operation fails.

Examples

from edge2client import Edge2Client

client = Edge2Client(host, username, password)
client.login()

app_id = 1
client.use_app(app_id)

username = 'only_reader'
ok = client.del_app_user(name=username)

In this example, we first created an Edge2Client instance and logged in. Then, we selected an application, and finally, we deleted a user from the application by passing in the username.

# get_all_app_users

data = get_all_app_users(app_id)

This method is used to get all users at the current application level. Users of a specific application can also be obtained by specifying the app_id.

Parameters

Returns

• data: The return value is of list type, and each element in the list is of dict type.

Examples

from edge2client import Edge2Client

client = Edge2Client(host, username, password)
client.login()

app_id = 1
client.use_app(app_id)

data = client.get_all_app_users()

# add_user_for_all_apps

ok = add_user_for_all_apps(name, read, write, release, dns_read, dns_write)

This method is used to add a user for all applications.

Parameters

Examples

from edge2client import Edge2Client

client = Edge2Client(host, username, password)
client.login()

# Use add_global_user() function to create a user named 'write'.
username='write'

data = client.add_user_for_all_apps(name=username)

# add_all_users_for_app

ok = add_all_users_for_app(app_id, read, write, release, dns_read, dns_write)

This method is used to add all global users to the specified application.

Parameters

Returns

• True: Indicates the addition was successful.
• False: Indicates the addition failed.

Examples

The following example shows how to add users to the application with ID 1, where all global users will be added to this application, and the release (release changes) permission is True, other permissions remain default.

from edge2client import Edge2Client

client = Edge2Client(host, username, password)
client.login()

app_id = 1
client.use_app(app_id)

data = client.add_all_users_for_app(release=True)

# new_cache_purge_task

task_id = client.new_cache_purge_task(condition=condition)

This method is used to add a new condition purge task. The trigger conditions are passed in array format, and multiple trigger conditions can be set. Only when all set conditions are met at the same time, the corresponding purge task will be triggered.

Parameters

Returns

• task_id: Returns the ID of the created purge task. You can query the execution details of the purge task through this ID.

Examples

In the following example, the trigger condition of the new conditional purge task is set as: “When the accessed Host is con.foo.com, and the value of Referer in the request header matches the regular expression foo\d+.”

from edge2client import Edge2Client

client = Edge2Client(host, username, password)
client.login()

app_id = 1
client.use_app(app_id)

condition = [
    {'var': 'host', 'val': 'con.foo.com'},
    {'var': ['req-header', 'Referer'], 'vals': [['foo\d+', 'rx'], 'foo.com']}
]

rule_id = client.new_cache_purge_task(condition=condition)

# get_cache_purge_task

data = client.get_cache_purge_task(task_id)

This method retrieves the details of a task by specifying the refresh task id.

Parameters

Returns

• data: Returns a dictionary (dict) type of data containing the details of the task.

Examples

from edge2client import Edge2Client

client = Edge2Client(host, username, password)
client.login()

app_id = 1
client.use_app(app_id)

task_id = 1

data = client.get_cache_purge_task(task_id)

# get_all_cache_purge_tasks

data = client.get_all_cache_purge_tasks()

This method is used to obtain detailed information about all cache purge tasks.

Returns

• data: Returns a list containing all purge tasks.

Examples

from edge2client import Edge2Client

client = Edge2Client(host, username, password)
client.login()

app_id = 1
client.use_app(app_id)

data = client.get_all_cache_purge_tasks()

# del_cache_purge_task

ok = client.del_cache_purge_task(task_id)

This method is used to delete the refresh task of a specified ID.

Parameters

Returns

• True: Indicates successful deletion.
• False: Indicates deletion failure.

Examples

The following example demonstrates how to delete a cache refresh task with an ID of 1.

from edge2client import Edge2Client

client = Edge2Client(host, username, password)
client.login()

app_id = 1
client.use_app(app_id)

task_id = 1
ok = client.del_cache_purge_task(task_id)

# new_waf_whitelist

rule_id = new_waf_whitelist(**kwargs)

This method is used to add new WAF whitelist rules.

Parameters

WAF Condition Parameters

Returns

• rule_id: The ID of the newly created WAF whitelist rule.

Examples

from edge2client import Edge2Client

client = Edge2Client(host, username, password)
client.login()

app_id = 1
client.use_app(app_id)

condition = [
    {'var': 'host', 'val': 'con.foo.com'},
    {'var': ['req-header', 'Referer'], 'vals': [['foo\d+', 'rx'], 'foo.com']}
]

id = client.new_waf_whitelist(condition=condition, rule_sets=[1, 2])

# update_waf_whitelist

ok = update_waf_whitelist(**kwargs)

This method is used to update WAF whitelist rules.

Parameters

Returns

• Returns True if successful.
• Returns False if failed.

Examples

from edge2client import Edge2Client

client = Edge2Client(host, username, password)
client.login()

app_id = 1
client.use_app(app_id)

condition = [
    {'var': 'host', 'val': 'con.foo.com'},
    {'var': ['req-header', 'Referer'], 'vals': [['foo\d+', 'rx'], 'foo.com']}
]

waf_whitelist_id = 1
ok = client.update_waf_whitelist(
    whitelist_id=waf_whitelist_id, condition=condition, rule_sets=[1])

# get_waf_whitelist

data = get_waf_whitelist(whitelist_id)

This method is used to obtain the whitelist rules of WAF.

Parameters

Returns

• data: Returns a dict type, containing the rules data of WAF whitelist.

Examples

from edge2client import Edge2Client

client = Edge2Client(host, username, password)
client.login()

app_id = 1
client.use_app(app_id)

data = client.get_waf_whitelist(waf_whitelist_id)

# del_waf_whitelist

ok = del_waf_whitelist(whitelist_id)

Performing this operation will delete the specified WAF whitelist rule.

Parameters

Returns

• True: Indicates successful deletion.
• False: Indicates deletion failed.

Examples

from edge2client import Edge2Client

# Initialize client and log in
client = Edge2Client(host, username, password)
client.login()

# Specify APP ID
app_id = 1
client.use_app(app_id)

# Delete specific WAF whitelist rule
ok = client.del_waf_whitelist(waf_whitelist_id)

# get_all_waf_whitelists

data = get_all_waf_whitelists()

This method is used to get all WAF whitelist rules.

Returns

• data: Returns a list type of WAF whitelist data.

Examples

from edge2client import Edge2Client

# Create and log in to the client
client = Edge2Client(host, username, password)
client.login()

# Select application
app_id = 1
client.use_app(app_id)

# Get all WAF whitelists
data = client.get_all_waf_whitelists()

# new_app_dymetrics

id = new_app_dymetrics(app_id=None, name=None, note=None, interval=60, sql=None)

Creates a new application dynamic metric. If you want to enable the built-in dynamic indicators of OpenResty Edge, you can get the name and SQL of the built-in dynamic metrics from this document.

Parameters

Returns

• id: Unique identifier for the newly created dynamic metric.

Examples

from edge2client import Edge2Client

# Initialize client and log in
client = Edge2Client(host, username, password)
client.login()

sql = 'select status, count(*) from reqs group by status'

dymetrics_id = client.new_app_dymetrics(app_id=1, name='test', sql=sql)

# put_app_dymetrics

ok = put_app_dymetrics(app_id=None, id=None, name=None, note=None, interval=60, sql=None)

This method is used to modify the dynamic metrics of the application.

Parameters

Returns

• True: The modification was successful.
• False: The modification failed.

Examples

from edge2client import Edge2Client

# Initialize client and log in
client = Edge2Client(host, username, password)
client.login()

id=1
sql = 'select status, count(*) from reqs group by status'
data = client.put_app_dymetrics(app_id=1, id=id, name='test', sql=sql)

# del_app_dymetrics

from edge2client import Edge2Client

# Initialize client and log in
client = Edge2Client(host, username, password)
client.login()

app_id = 1

ok = del_app_dymetrics(app_id, id)

This method is used to delete the dynamic metrics of a specified application.

Parameters

Returns

• True: Indicates successful deletion.
• False: Indicates failure in deletion.

Examples

from edge2client import Edge2Client

# Initialize client and log in
client = Edge2Client(host, username, password)
client.login()

app_id = 1

ok = client.del_app_dymetrics(app_id, dymetrics_id)

# get_app_dymetrics

data = get_app_dymetrics(app_id, id)

This method is used to get the dynamic metrics of the specified application.

Parameters

Returns

• data: Returns a dict type of dynamic metrics data.

Examples

from edge2client import Edge2Client

# Initialize client and log in
client = Edge2Client(host, username, password)
client.login()

app_id = 1
data = client.get_app_dymetrics(app_id, dymetrics_id)

# get_all_app_dymetrics

data = get_all_app_dymetrics(app_id)

This method is used to obtain all the dynamic metric information of a specified application.

Parameters

Returns

• data: The returned data is a list type list that contains all dynamic metric information.

Examples

from edge2client import Edge2Client

# Initialize client and log in
client = Edge2Client(host, username, password)
client.login()

app_id = 1
data = client.get_all_app_dymetrics(app_id)

# get_app_dymetrics_data

data = get_app_dymetrics_data(app_id, id, chart_type='line', start_time=None, end_time=None, node_id=None)

This method is used to obtain the dynamic metrics data of the application, and it returns the data of the last 30 minutes by default.

Parameters

Returns

• data: The returned dynamic metrics data, with a data type of list.

Examples

from edge2client import Edge2Client

# Initialize client and log in
client = Edge2Client(host, username, password)
client.login()

app_id = 1
dymetrics_id = 1
data = client.get_app_dymetrics_data(app_id, dymetrics_id)

# get_app_metrics

data = get_app_metrics(id, start_time=None, end_time=None)

This method is used to get the HTTP request status metrics and network transmission and reception metrics of the application. By default, it will get data for the last 30 minutes.

Parameters

Returns

• data: This is a list type that contains metric data.

Examples

from edge2client import Edge2Client

# Initialize client and log in
client = Edge2Client(host, username, password)
client.login()

app_id = 1

data = client.get_app_metrics(app_id)

# new_ip_list

id = new_ip_list(name=None, type='ipv4', items=None)

Add a new application-level IP list.

Parameters

items Parameter

Returns

• id: ID of the newly created IP list.

Examples

from edge2client import Edge2Client

client = Edge2Client(host, username, password)
client.login()

app_id = 1
client.use_app(app_id)

ok = client.new_ip_list(name = 'ip-list-1',
                        type = 'ipv4',
                        items = [
                            {'ip': '127.0.0.0/24'},
                            {'ip': '192.168.1.0/24'},
                            {'ip': '192.168.2.0/24', 'exptime': 1725000000},
                            {'ip': '192.168.3.0/24', 'exptime': 1735000000}
                        ])

# put_ip_list

ok = put_ip_list(rule_id=None, name=None, type='ipv4', items=None)

This method is used to modify the specified IP list.

Parameters

Returns

• True: Indicates that the specified IP list was successfully modified.
• False: Indicates that the modification of the specified IP list failed.

Examples

from edge2client import Edge2Client

client = Edge2Client(host, username, password)
client.login()

app_id = 1
client.use_app(app_id)

ok = client.put_ip_list(rule_id = 1, items = [ {'ip': '127.0.0.2'} ])

# del_ip_list

ok = del_ip_list(rule_id=None)

This method is used to delete the specified IP list.

Parameters

Returns

• True: Indicates successful deletion.
• False: Indicates deletion failed.

Examples

from edge2client import Edge2Client

client = Edge2Client(host, username, password)
client.login()

app_id = 1
client.use_app(app_id)

ok = client.del_ip_list(rule_id=1)

In this example, we first log in using an instance of Edge2Client, then select an application, and finally delete the IP list with the specified ID.

# get_ip_list

data = get_ip_list(rule_id=None)

This method is used to view specific IP list.

Parameters

Returns

• data: Returns a dictionary type IP list data.

Examples

from edge2client import Edge2Client

client = Edge2Client(host, username, password)
client.login()

app_id = 1
client.use_app(app_id)

data = client.get_ip_list(rule_id=1)

# append_to_ip_list

ok = append_to_ip_list(rule_id=None, items=None)

This method is used to append IPs to specific IP list.

Parameters

Returns

• True: Indicates that the specified IP list was successfully modified.
• False: Indicates that the modification of the specified IP list failed.

Examples

from edge2client import Edge2Client

client = Edge2Client(host, username, password)
client.login()

app_id = 1
client.use_app(app_id)

ok = client.append_to_ip_list(rule_id = 1, items = [ {'ip': '127.0.0.3'} ])

ok = client.append_to_ip_list(rule_id = 1, items = [ {'ip': '127.0.0.3'} ], remove_expired = True)

# remove_from_ip_list

ok = remove_from_ip_list(rule_id=None, items=None)

This method is used to remove IPs from specific IP list.

Parameters

Returns

• True: Indicates that the specified IP list was successfully modified.
• False: Indicates that the modification of the specified IP list failed.

Examples

from edge2client import Edge2Client

client = Edge2Client(host, username, password)
client.login()

app_id = 1
client.use_app(app_id)

ok = client.remove_from_ip_list(rule_id = 1, items = [ {'ip': '127.0.0.3'} ])

# node_monitor

data = node_monitor(node_id, start_time=None, end_time=None, step=60)

This method is used to obtain CPU and memory load-related information of a network node.

Parameters

Returns

• data: returns a list containing monitoring data.

Examples

node_id = 1
data = client.node_monitor(node_id)

# new_global_dymetrics

id = new_global_dymetrics(name=None, note=None, interval=60, sql=None)

This method is used to create global dynamic metrics.

Parameters

Returns

• id: The unique identifier ID of the newly created global dynamic metric.

Examples

sql = 'select status, count(*) from reqs group by status'

dymetrics_id = client.new_global_dymetrics(name='test', sql=sql)

# put_global_dymetrics

ok = put_global_dymetrics(id=None, name=None, note=None, interval=60, sql=None)

This method is used to modify global dynamic indicators.

Parameters

Returns

• True: Indicates success.
• False: Indicates failure.

Examples

id=1
sql = 'select status, count(*) from reqs group by status'
data = client.put_global_dymetrics(id=id, name='test', sql=sql)

# del_global_dymetrics

ok = del_global_dymetrics(id)

This method is used to delete the specified global dynamic metric.

Parameters

Returns

• True: Represents successful deletion of the global dynamic metric.
• False: Represents failure in deleting the global dynamic metric.

Examples

ok = client.del_global_dymetrics(dymetrics_id)

# get_global_dymetrics

data = get_global_dymetrics(id)

This method is used to get the specified global dynamic metrics.

Parameters

Returns

• data: Returns a global dynamic metrics information of type dict.

Examples

data = client.get_global_dymetrics(dymetrics_id)

# get_all_global_dymetrics

data = get_all_global_dymetrics()

This method is used to get all global dynamic metrics.

Returns

• data: Returns a list type data containing global dynamic metrics information.

Examples

data = client.get_all_global_dymetrics()

# get_global_dymetrics_data

data = get_global_dymetrics_data(id, chart_type='line', start_time=None, end_time=None, node_id=None)

This method is used to get global dynamic metrics data, the default range is the most recent 30 minutes.

Parameters

Returns

• data: The return is a list containing global dynamic metrics data.

Examples

dymetrics_id = 1
data = client.get_global_dymetrics_data(dymetrics_id)

# use_dns_app

ok = use_dns_app(dns_id)

This method is used to switch the DNS application that the current instance operates.

Parameters

Returns

• True: Indicates the switch was successful.
• False: Indicates the switch failed.

Examples

from edge2client import Edge2Client

client = Edge2Client(host, username, password)
client.login()

dns_id = 1
client.use_dns_app(dns_id)

# new_dns_app

dns_id = new_dns_app(**kwargs)

This method is used to create a new DNS application.

Parameters

Returns

• dns_id: Returns the ID of the newly created DNS application.

Examples

from edge2client import Edge2Client

client = Edge2Client(host, username, password)
client.login()

authority = [
    {'domain': 'ns1.foo.com', 'ttl': '2 [hour]'},
    {'domain': 'ns2.foo.com', 'ttl': '1 [day]'}
]

soa_email = 'admin@foo.com'

dns_id = client.new_dns_app(
    authority=authority,
    soa_email=soa_email,
    zone='foo.com')

# put_dns_app

ok = put_dns_app(**kwargs)

This method is used to modify the relevant information of the DNS application.

Parameters

Returns

• True: Indicates that the information was modified successfully.
• False: Indicates that the information modification failed.

Examples

The following example shows how to modify the application with dns_id 1.

from edge2client import Edge2Client

client = Edge2Client(host, username, password)
client.login()

dns_id = 1

authority = [
    {'domain': 'ns1.foo.com', 'ttl': '4 [hour]'},
    {'domain': 'ns2.foo.com', 'ttl': '1 [day]'}
]

ok = client.put_dns_app(
    dns_id=dns_id,
    authority=authority,
    soa_email=soa_email,
    zone='foo.com')

# get_dns_app

data = get_dns_app(dns_id)

This method is used to get the relevant information of the DNS application.

Parameters

Returns

• data: A dict type of data, containing detailed information of the DNS application.

Examples

from edge2client import Edge2Client

client = Edge2Client(host, username, password)
client.login()

dns_id = 1

data = client.get_dns_app(dns_id)

# del_dns_app

ok = del_dns_app(dns_id)

This method is used to delete a specified DNS application.

Parameters

The following table lists the parameters required by This method.

Returns

• True: Indicates that the DNS application was successfully deleted.
• False: Indicates that the deletion of the DNS application failed.

Examples

The following example shows how to delete a specified DNS application.

from edge2client import Edge2Client

client = Edge2Client(host, username, password)
client.login()

dns_id = 1

data = client.del_dns_app(dns_id)

# new_dns_record

record_id = new_dns_record(**kwargs)

This method is used to add a DNS record.

Parameters

Returns

• record_id: The ID of the newly added DNS record.

Examples

from edge2client import Edge2Client

client = Edge2Client(host, username, password)
client.login()

dns_id = 1
use_dns_app(dns_id)

record_id = client.new_dns_record(
    sub_domain='bar', record_type='TXT', text='text string')
client.new_dns_record(
    sub_domain='bar', record_type='A', ip='127.0.0.1')
client.new_dns_record(
    sub_domain='bar', record_type='CNAME', domain='test.com')
client.new_dns_record(
    sub_domain='bar', record_type='MX', domain='test.com', priority=3)

# put_dns_record

ok = put_dns_record(**kwargs)

This method is used to modify DNS records.

Parameters

Returns

• True: Indicates success.
• False: Indicates failure.

Examples

from edge2client import Edge2Client

client = Edge2Client(host, username, password)
client.login()

dns_id = 1
use_dns_app(dns_id)

record_id = 1

ok = client.put_dns_record(
    record_id=record_id,
    sub_domain='a.bar',
    record_type='TXT',
    text='text string')

# get_dns_record

data = get_dns_record(record_id)

This method is used to obtain DNS records.

Parameters

Returns

• data: Returns a dict type DNS record information.

Examples

If you need to obtain DNS record information with record_id as 1, you can refer to the following steps.

from edge2client import Edge2Client

client = Edge2Client(host, username, password)
client.login()

dns_id = 1
use_dns_app(dns_id)

record_id = 1

data = client.get_dns_record(record_id)

# del_dns_record

ok = del_dns_record(record_id)

This method is used to delete a DNS record.

Parameters

Returns

• Returns True if the deletion is successful.
• Returns False if the deletion fails.

Examples

from edge2client import Edge2Client

client = Edge2Client(host, username, password)
client.login()

dns_id = 1
use_dns_app(dns_id)

record_id = 1

ok = client.del_dns_record(record_id)

In this example, we first create an Edge2Client client and log in with a specific host, username, and password. Then, we choose to use the DNS application with a specific id. Finally, we attempt to delete the DNS record with a specific id using this client, and save the result in ok.

# new_global_upstream

up_id = new_global_upstream(**kwargs)

This method is used to add a new upstream and returns the id of the newly created global upstream.

Parameters

Returns

• up_id: ID of the newly created upstream.

Examples

from edge2client import Edge2Client

client = Edge2Client(host, username, password)
client.login()

up_id = client.new_global_upstream(
    name='origin-upstream',
    servers=[
        {'ip': '172.22.31.1', 'port': 80},
        {'ip': '172.22.31.2', 'port': 80, 'weight': 2}
    ])

# update_global_upstream

ok = update_global_upstream(**kwargs)

This method is used to update global upstream information.

Parameters

Returns

• True: The operation was successful.
• False: The operation failed.

Examples

from edge2client import Edge2Client

client = Edge2Client(host, username, password)
client.login()

up_id = 1

ok = client.update_global_upstream(up_id,
    name='origin-upstream',
    servers=[
        {'domain': 'test.com', 'port': 8080},
        {'ip': '172.22.31.2', 'port': 8080, 'weight': 1}
    ],
    health_checker={
        'type': 'http',
        'http_req_uri': '/status',
        'http_req_host': 'test.com',
        'interval': 3,
        'interval_unit': 'sec',
        'timeout': 1,
        'fall': 3,
        'rise': 2,
        'valid_statuses': [200, 302],
        'report_interval': 3,
        'report_interval_unit': 'min'
    })

# get_global_upstream

data = get_global_upstream(up_id)

This method is used to retrieve global upstream information.

Parameters

Returns

• True: When the information is successfully retrieved.
• False: When the information retrieval fails.

Examples

from edge2client import Edge2Client

client = Edge2Client(host, username, password)
client.login()

up_id = 1

data = client.get_global_upstream(up_id)

# del_global_upstream

del_global_upstream(up_id)

This method is used to delete the global upstream.

Parameters

Returns

• True: Indicates successful deletion.
• False: Indicates failure in deletion.

Examples

from edge2client import Edge2Client

client = Edge2Client(host, username, password)
client.login()

up_id = 1

operation_status = client.del_global_upstream(up_id)

# get_all_global_upstreams

upstreams = client.get_all_global_upstreams()

This method is used to get all the upstream information.

Returns

• upstreams: Returns a list type variable containing all global upstream information.

Examples

from edge2client import Edge2Client

client = Edge2Client(host, username, password)
client.login()

upstreams = client.get_all_global_upstreams()

# new_global_k8s_upstream

up_id = new_global_k8s_upstream(**kwargs)

This method is used to create a new global Kubernetes upstream and returns the ID of the newly created upstream.

Parameters

Returns

• up_id: The ID of the newly created k8s upstream.

Examples

from edge2client import Edge2Client

client = Edge2Client(host, username, password)
client.login()

k8s_up_id = client.new_global_k8s_upstream(
    name = 'k8s-upstream',
    k8s_services = [
        {
            'k8s' : 1,
            'k8s_namespace' : 'default',
            'k8s_service' : 'foo',
            'k8s_service_port' : 80,
        }
    ])

# put_global_k8s_upstream

ok = put_global_k8s_upstream(**kwargs)

This method is used to modify the information of the global Kubernetes upstream.

Parameters

Returns

• True: Indicates modification was successful.
• False: Indicates modification failed.

Examples

from edge2client import Edge2Client

client = Edge2Client(host, username, password)
client.login()

up_id = 1

ok = client.put_global_k8s_upstream(up_id,
    name='k8s-upstream',
    k8s_services = [
        {
            'k8s' : 1,
            'k8s_namespace' : 'default',
            'k8s_service' : 'foo',
            'k8s_service_port' : 80,
        }
    ],
    health_checker={
        'type': 'http',
        'http_req_uri': '/status',
        'http_req_host': 'test.com',
        'interval': 3,
        'interval_unit': 'sec',
        'timeout': 1,
        'fall': 3,
        'rise': 2,
        'valid_statuses': [200, 302],
        'report_interval': 3,
        'report_interval_unit': 'min'
    })

# fetch_global_k8s_upstream

data = fetch_global_k8s_upstream(up_id)

This method is used to fetch global Kubernetes upstream information.

Parameters

Returns

• data: Returns a dictionary type value containing Kubernetes upstream information.

Examples

from edge2client import Edge2Client

client = Edge2Client(host, username, password)
client.login()

up_id = '1'

data = client.fetch_global_k8s_upstream(up_id)

# del_global_k8s_upstream

del_global_upstream(up_id)

This method is used to delete the global k8s upstream.

Parameters

Returns

• Returns True if the deletion is successful.
• Returns False if the deletion fails.

Examples

from edge2client import Edge2Client

client = Edge2Client(host, username, password)
client.login()

up_id = '1'

ok = client.del_global_k8s_upstream(up_id)

# get_all_global_k8s_upstreams

upstreams = client.get_all_global_k8s_upstreams()

This method is used to get all Kubernetes upstream information.

Returns

• upstreams: Returns a list of Kubernetes upstream information.

Examples

from edge2client import Edge2Client

client = Edge2Client(host, username, password)
client.login()

upstreams = client.get_all_global_k8s_upstreams()

# set_global_cert_key

cert_id = set_global_cert_key(**kwargs)

Used to add a global SSL certificate.

Parameters

Returns

• cert_id: The ID of the newly created global certificate.

Examples

The following example demonstrates how to upload local key.pem and cert.pem files to create a global certificate.

from edge2client import Edge2Client

client = Edge2Client(host, username, password)
client.login()

key_file = os.path.join('tests', 'key.pem')
cert_file = os.path.join('tests', 'cert.pem')
with open(key_file) as f:
    key = f.read()
with open(cert_file) as f:
    cert = f.read()

cert_id = client.set_global_cert_key(key=key, cert=cert)

# put_global_cert_key

ok = put_global_cert_key(**kwargs)

This method is used to modify the global SSL certificate.

Parameters

Returns

• True: Indicates success.
• False: Indicates failure.

Examples

from edge2client import Edge2Client

client = Edge2Client(host, username, password)
client.login()

cert_id = 1

new_key_file = os.path.join('tests', 'new_key.pem')
new_cert_file = os.path.join('tests', 'new_cert.pem')
with open(new_key_file) as f:
    new_key = f.read()
with open(new_cert_file) as f:
    new_cert = f.read()

ok = client.put_global_cert_key(cert_id=cert_id, key=new_key, cert=new_cert)

# get_global_cert_key

data = get_global_cert_key(cert_id)

This method is used to get the SSL certificate information associated with cert_id.

Parameters

Returns

• data: Returns a dict type data that contains all the information of the global certificate.

Examples

from edge2client import Edge2Client

client = Edge2Client(host, username, password)
client.login()

cert_id = 1

data = client.get_global_cert_key(cert_id)

# del_global_cert_key

ok = del_global_cert_key(cert_id)

This method is used to delete a specified global SSL certificate.

Parameters

Returns

• True: Indicates successful deletion.
• False: Indicates failed deletion.

Examples

from edge2client import Edge2Client

client = Edge2Client(host, username, password)
client.login()

cert_id = 1

ok = client.del_global_cert_key(cert_id)

# add_global_user

uid = add_global_user(name, pwd, gid)

This method is used to add a global user.

Parameters

Returns

• uid: The unique identification ID of the newly added global user.

Note: The ID of the global user needs to be distinguished from the user ID at application level.

Examples

The following example shows how to create a global user named global_demo_user, who has the permission to create a new application, and whose role is a regular user.

from edge2client import Edge2Client

client = Edge2Client(host, username, password)
client.login()

username='global_demo_user'

uid = client.add_global_user(name=username, pwd=pwd, gid=[1])

# search_global_user

user_info = search_global_user(name)

This method is used to search for global user information based on the username.

Parameters

Returns

• user_info: dict type, containing the searched user information and its related permission information.

Examples

from edge2client import Edge2Client

client = Edge2Client(host, username, password)
client.login()

username = 'global_demo_user'

data = client.search_global_user(username)
user_id = data.get('id')

# get_all_global_users

data = get_all_global_users(detail)

This method is used to get the information of all global users.

Parameters

Returns

• data: Returns a list type data, each element of which is a dict type, containing the information of the corresponding global user.

Examples

from edge2client import Edge2Client

client = Edge2Client(host, username, password)
client.login()

data = client.get_all_global_users()
data = client.get_all_global_users(True)

# new_global_rule

rule_id = new_global_rule(**kwargs)

This method is used to add new global rules.

Parameters

Returns

• rule_id: ID of the successfully created global rule.

Examples

from edge2client import Edge2Client

client = Edge2Client(host, username, password)
client.login()

condition = [
    {'var': 'host', 'val': 'con.' + APEX},
    {'var': ['req-header', 'Referer'], 'vals': [['foo\d+', 'rx'], 'foo.com']}
]

conseq = {
    'enable-websocket': {},
    'redirect': {'url': '/cn/2017/', 'code': 302}
}

rule_id = client.new_global_rule(condition=condition, conseq=conseq,gid=[1])

# put_global_rule

ok = put_global_rule(**kwargs)

This method is used to modify the global rule.

Parameters

Returns

• True: Indicates success.
• False: Indicates failure.

Examples

from edge2client import Edge2Client

client = Edge2Client(host, username, password)
client.login()

rule_id = 1

conseq['redirect']['url'] = '/cn/2018/'

ok = client.put_global_rule(
    rule_id=rule_id, condition=condition, conseq=conseq)

# get_global_rule

data = get_global_rule(rule_id)

This method is used to obtain global rule information.

Parameters

Returns

• data: The return value is a dict type, containing detailed information of the global rule.

Examples

from edge2client import Edge2Client

client = Edge2Client(host, username, password)
client.login()

rule_id = 1

data = client.get_global_rule(rule_id)

This example demonstrates how to use an instance of Edge2Client to obtain global rule information for a specific id.

# get_global_action_by_name

rule_id = get_global_action_by_name(name)

This method is used to obtain the corresponding global custom action based on the given application name.

Parameters

Returns

• data: Returns a dict type data containing global rule information.

Examples

from edge2client import Edge2Client

client = Edge2Client(host, username, password)
client.login()

rule_name = 'test-actions'

rule_id = client.get_global_action_by_name(rule_name)

# get_all_global_rules

data = get_all_global_rules()

This method is used to obtain all global rules.

Returns

• data: This is a list type of global rule information list.

Examples

from edge2client import Edge2Client

client = Edge2Client(host, username, password)
client.login()

data = client.get_all_global_rules()

# del_global_rule

ok = del_global_rule(rule_id)

This method is used to delete the global rule.

Parameters

Returns

• Returns True: The rule is successfully deleted.
• Returns False: The rule deletion failed.

Examples

from edge2client import Edge2Client

client = Edge2Client(host, username, password)
client.login()

rule_id = 1

ok = client.del_global_rule(rule_id)

This example shows how to use the del_global_rule method of the Edge2Client object to delete a specified global rule.

# new_global_var

var_id = new_global_var(**kwargs)

This method is used to create a new global variable.

Parameters

Returns

• var_id: If creation is successful, the ID of the newly created variable is returned.

Examples

from edge2client import Edge2Client

client = Edge2Client(host, username, password)
client.login()

var_id = client.new_global_var(
    name='is-whitelist', var_type='string', default='no')

# put_global_var

ok = put_global_var(**kwargs)

This method is used to modify global variables.

Returns

• True: Indicates that the global variable was modified successfully.
• False: Indicates that the modification of the global variable failed.

Examples

from edge2client import Edge2Client

client = Edge2Client(host, username, password)
client.login()

var_id = 1

ok = client.put_global_var(
    var_id=var_id,
    name='is-whitelist',
    var_type='string',
    default='yes',
    gid=[1])

In this example, we first create an Edge2Client object and log in. Then, using the put_global_var() function, we modify the global variable with ID 1 by specifying the corresponding parameters, changing its name to ‘is-whitelist’, its type to ‘string’, its default value to ‘yes’, and associating it with the user group with ID 1.

# get_global_var

data = get_global_var(var_id)

This method is used to get global variables.

Parameters

Returns

• data: The return value is a dict type, containing information about the global variable.

Examples

from edge2client import Edge2Client

client = Edge2Client(host, username, password)
client.login()

var_id = 1

data = client.get_global_var(var_id)

# get_all_global_vars

data = get_all_global_vars()

This method is used to get all global variables.

Returns

• data: This is a list-type object, each element of which is a dict-type that contains relevant information about the global variables.

Examples

from edge2client import Edge2Client

client = Edge2Client(host, username, password) # Create an Edge2Client instance
client.login() # Log in

data = client.get_all_global_vars() # Get all global variables

# del_global_var

ok = del_global_var(var_id)

This method is used to delete a global variable by its ID.

Parameters

| Name | Data Type | Required | Description | | var_id | number | Yes | Specifies the ID of the global variable to be deleted |

Returns

• True: Indicates successful deletion.
• False: Indicates deletion failure.

Examples

from edge2client import Edge2Client

client = Edge2Client(host, username, password)
client.login()

var_id = 1

ok = client.del_global_var(var_id)

# get_global_ngx_config

data = get_global_ngx_config()

This method is used to get global nginx configuration information.

Returns

• data: Returns a dict type of global ngx configuration information.

Examples

from edge2client import Edge2Client

client = Edge2Client(host, username, password)
client.login()

data = client.get_global_ngx_config()

# set_global_ngx_config

data = set_global_ngx_config(opts)

This method sets the global nginx configuration information.

Parameters

access_log_formats Parameter

Returns

• True: Setting successful.
• False: Setting failed.

Examples

from edge2client import Edge2Client

client = Edge2Client(host, username, password)
client.login()

opts = {'keepalive_timeout': 10, 'enable_open_file_cache': False}
ok = client.set_global_ngx_config(opts)

# get_global_misc_config

data = get_global_misc_config()

This method is used to obtain global miscellaneous configuration information.

Returns

• data: Returns a dict type, which includes miscellaneous configuration information.

Examples

from edge2client import Edge2Client

# Create client and login
client = Edge2Client(host, username, password)
client.login()

# Get global miscellaneous configuration information
data = client.get_global_misc_config()

# set_global_misc_config

ok = set_global_misc_config(opts)

This method is used to set global miscellaneous configuration information.

Parameters

Returns

• True: Indicates the setting is successful.
• False: Indicates the setting failed.

Examples

from edge2client import Edge2Client

client = Edge2Client(host, username, password)
client.login()

opts = {'enabled_req_id': True}
ok = client.set_global_misc_config(opts)

# get_request_id_status

status = get_request_id_status()

This method is used to query the status of the request id.

Returns

• True: The request id is enabled.
• False: The request id is disabled.

Examples

from edge2client import Edge2Client

client = Edge2Client(host, username, password)
client.login()

status = client.get_request_id_status()

# enable_request_id

ok = enable_request_id()

This method is used to activate the request id function.

Returns

• True: Indicates activation was successful.
• False: Indicates activation failed.

Examples

from edge2client import Edge2Client

client = Edge2Client(host, username, password)
client.login()

ok = client.enable_request_id()

# disable_request_id

ok = disable_request_id()

This method is used to disable the request ID feature.

Returns

• True: Represents that the request ID feature has been successfully disabled.
• False: Indicates that the request ID feature failed to be disabled.

Examples

from edge2client import Edge2Client

client = Edge2Client(host, username, password)
client.login()

ok = client.disable_request_id()

# new_global_waf_rule

rule_id = new_global_waf_rule(**kwargs)

This method is used to add a new global WAF rule.

Parameters

Returns

• rule_id: Returns the unique ID of the newly created global WAF rule set.

Examples

from edge2client import Edge2Client

client = Edge2Client(host, username, password)
client.login()

waf_rule_id = client.new_global_waf_rule(
    name='foo',
    code="uri-arg('foo') => waf-mark-risk(level: 'definite', msg: 'found foo');")

In this example, we first create an instance of Edge2Client, then use the new_global_waf_rule method to create a new global WAF rule and store its rule ID in waf_rule_id. The rule name is ‘foo’, and the edge language code is “uri-arg(‘foo’) => waf-mark-risk(level: ‘definite’, msg: ‘found foo’);”.

# put_global_waf_rule

ok = put_global_waf_rule(**kwargs)

This method is used to modify global WAF rules.

Parameters

Returns

• True: indicates modification is successful.
• False: indicates modification failed.

Examples

from edge2client import Edge2Client

client = Edge2Client(host, username, password)
client.login()

waf_rule_id = 1

ok = client.put_global_waf_rule(
    rule_id=waf_rule_id,
    name='bar',
    code="uri-arg('bar') => waf-mark-risk(level: 'definite', msg: 'found bar');")

In this example, we modify the global WAF rule with id 1 using the put_global_waf_rule function.

# get_global_waf_rule

data = get_global_waf_rule(rule_id)

This method retrieves a global WAF rule set by using the provided rule set ID (rule_id).

Parameters

| Name | Data Type | Required | Description | | rule_id | number | Yes | The unique identifier of the WAF rule set |

Returns

• data: Returns a dictionary containing detailed information about the WAF rule set.

Examples

from edge2client import Edge2Client

client = Edge2Client(host, username, password)
client.login()

waf_rule_id = 1

data = client.get_global_waf_rule(waf_rule_id)

# del_global_waf_rule

ok = del_global_waf_rule(rule_id)

This method is used to delete global WAF rules.

Parameters

| Name | Data Type | Required | Description | | rule_id | number | Yes | ID of the rule set |

Returns

• True: Deletion successful.
• False: Deletion failed.

Examples

from edge2client import Edge2Client

client = Edge2Client(host, username, password)
client.login()

waf_rule_id = 1

ok = client.del_global_waf_rule(waf_rule_id)

# get_all_global_waf_rules

data = get_all_global_waf_rules(detail=False)

This method is used to retrieve all global WAF rules.

Parameters

Returns

• data: Returns a list type of WAF rule set information.

Examples

from edge2client import Edge2Client

client = Edge2Client(host, username, password)
client.login()

data = client.get_all_global_waf_rules()

# new_global_action

rule_id = new_global_action(**kwargs)

This method is used to add a new global custom action.

Parameters

Returns

• rule_id: Returns the ID of the newly created global custom action.

Examples

from edge2client import Edge2Client

client = Edge2Client(host, username, password)
client.login()

name = 'test'
condition = [
    {'var': 'req-method', 'vals': ['GET', 'POST', 'HEAD']}
]

conseq = [
    {
        'exit': {'code': 403}
    }
]

action_id = client.new_global_action(
    name=name, condition=condition, conseq=conseq, gid=[1, 2])

# put_global_action

ok = put_global_action(**kwargs)

This method is used to modify the global custom action.

Parameters

Returns

• True: Represents the operation was successful.
• False: Represents the operation failed.

Examples

from edge2client import Edge2Client

client = Edge2Client(host, username, password)
client.login()

action_id = 1

ok = client.put_global_action(
    name=name,
    action_id=action_id,
    condition=condition,
    conseq=conseq,
    gid=[1])

# get_global_action

data = get_global_action(action_id)

This method is used to obtain the global custom action.

Parameters

Returns

• data: The returned data is a dictionary containing relevant information about the global custom action.

Examples

from edge2client import Edge2Client

client = Edge2Client(host, username, password)
client.login()

action_id = 1

data = client.get_global_action(action_id)

# del_global_action

ok = del_global_action(action_id)

This method is used to delete a specified global custom action.

Parameters

Returns

• Returns True: Indicates successful deletion.
• Returns False: Indicates deletion failed.

Examples

from edge2client import Edge2Client

client = Edge2Client(host, username, password)
client.login()

action_id = 1

ok = client.del_global_action(action_id)

# count_global_actions

count = count_global_actions()

This method is used to get the total number of global custom actions.

Returns

• count: Returns the total number of global custom actions.

Examples

from edge2client import Edge2Client

client = Edge2Client(host, username, password)
client.login()

count = client.count_global_actions()

# get_all_global_actions

data = get_all_global_actions()

This method is used to obtain all global custom actions.

Parameters

Returns

• data: Returns a list containing all global custom action information.

Examples

from edge2client import Edge2Client

client = Edge2Client(host, username, password)
client.login()

data = client.get_all_global_actions()

# upload_static_file

file_id = upload_static_file(**kwargs)

This method is used to upload static files.

Parameters

Returns

• file_id: Returns the ID of the newly uploaded static file.

Examples

from edge2client import Edge2Client

client = Edge2Client(host, username, password)
client.login()

file_id = client.upload_static_file(content='test_content', label='500.html', gid=[1])

# get_static_file

data = get_static_file(file_id)

This method is used to obtain the configuration of a specified static file.

Parameters

Returns

• data: Returns a dict type object, containing the information of the retrieved static file.

Examples

from edge2client import Edge2Client

client = Edge2Client(host, username, password)
client.login()

file_id = 1

data = client.get_static_file(file_id)

In this example, we first import the Edge2Client class from the edge2client module, then create an Edge2Client object and login. Afterwards, we call its get_static_file method to get the configuration information of the static file with ID 1, and store it in the data variable.

# del_static_file

ok = del_static_file(file_id)

This method is used to delete uploaded static files.

Parameters

Returns

• True: Indicates that the file was deleted successfully.
• False: Indicates that the file deletion failed.

Examples

from edge2client import Edge2Client

# Create an Edge2Client instance
client = Edge2Client(host, username, password)

# Log in
client.login()

# Set the ID of the file to be deleted
file_id = 1

# Delete the static file with the specified ID
ok = client.del_static_file(file_id)

# new_cluster_group

group_id = new_cluster_group(group_name)

This method is used to add a new cluster group.

Parameters

Returns

• id: Returns the unique identifier ID of the newly created cluster group.

Examples

from edge2client import Edge2Client

client = Edge2Client(host, username, password)
client.login()

group_id = client.new_cluster_group('foo')

# put_cluster_group

ok = put_cluster_group(**kwargs)

This method is used to modify cluster group information.

Parameters

Returns

• True: Indicates that the cluster group information was successfully modified.
• False: Indicates that the modification of cluster group information failed.

Examples

from edge2client import Edge2Client

client = Edge2Client(host, username, password)
client.login()

group_id = 1

ok = client.put_cluster_group(group_id=group_id, group_name='bar')

This example demonstrates how to use the put_cluster_group function to modify the name of the cluster group with the specified group_id to ‘bar’.

# get_cluster_group

data = get_cluster_group(group_id)

This method is used to obtain detailed information of the cluster group.

Parameters

Returns

• data: Returns a dict type of detailed information of the cluster group.

Examples

from edge2client import Edge2Client

client = Edge2Client(host, username, password)
client.login()

group_id = 1

data = client.get_cluster_group(group_id)

# get_all_cluster_groups

data = get_all_cluster_groups()

This method is used to obtain information on all cluster groups.

Returns

• data: This is a list type containing information on all cluster groups.

Examples

from edge2client import Edge2Client

client = Edge2Client(host, username, password)
client.login()

data = client.get_all_cluster_groups()

# del_cluster_group

ok = del_cluster_group(group_id)

This method is used to delete cluster group information.

Parameters

Returns

• Returns True: The cluster group information was successfully deleted.
• Returns False: The cluster group information failed to be deleted.

Examples

from edge2client import Edge2Client

client = Edge2Client(host, username, password)
client.login()

group_id = 1

ok = client.del_cluster_group(group_id)

In the example above, an Edge2Client object is initially initialized and logged in, then the ID of the cluster group to be deleted is specified, and the del_cluster_group method is invoked to perform the deletion operation.

# put_proxy_rule

ok = put_proxy_rule(**kwargs)

This method is used to modify upstream proxy rules.

Parameters

Returns

• True: Indicates that the rule modification was successful.
• False: Indicates that the rule modification failed.

Examples

from edge2client import Edge2Client

client = Edge2Client(host, username, password)
client.login()

rule_id = 1
proxy_rule = []

ok = client.put_proxy_rule(rule_id=rule_id, proxy=proxy_rule)

# new_global_k8s

k8s_id = new_global_k8s(name=None, host=None, port=None, ssl_verify=True, token=None)

This method is used to add new k8s cluster connection parameters.

Parameters

Returns

• k8s_id: ID of the newly established k8s cluster.

Examples

from edge2client import Edge2Client

client = Edge2Client(host, username, password)
client.login()

k8s_id = client.new_global_k8s(name = "k8s", host = "192.168.1.1", port = 443, token = "xxxxx")

# put_global_k8s

ok = put_global_k8s(**kwargs)

This method is used to modify the connection parameters of a Kubernetes cluster.

Parameters

Returns

• Returns True: Indicates success.
• Returns False: Indicates failure.

Examples

from edge2client import Edge2Client

client = Edge2Client(host, username, password)
client.login()

ok = client.put_global_k8s(k8s_id = 1, name = "k8s", host = "192.168.1.1", port = 443, token = "xxxxx")

# get_global_k8s

data = get_global_k8s(k8s_id)

This method is used to get the connection parameter information of a Kubernetes cluster.

Parameters

Returns

• data: Returns a dict type of data that contains detailed information about the Kubernetes cluster.

Examples

from edge2client import Edge2Client

# Create an Edge2Client instance
client = Edge2Client(host, username, password)

# Log into the client
client.login()

# Use the get_global_k8s method to get Kubernetes cluster information
data = client.get_global_k8s(k8s_id = 1)

# get_k8s_service_detail

data = get_k8s_service_detail()

This method is used to obtain the service-related information defined in the k8s cluster.

Parameters

Returns

• Returns a dict type of data, containing detailed information of the k8s cluster.

Examples

from edge2client import Edge2Client

client = Edge2Client(host, username, password)
client.login()

data = client.get_k8s_service_detail(k8s_id = 1)

# get_all_global_k8s

data = get_all_global_k8s()

This method is used to obtain the id of all global Kubernetes clusters.

Returns

• data: Returns a list type of Kubernetes cluster information.

Application Example

from edge2client import Edge2Client

client = Edge2Client(host, username, password)
client.login()

data = client.get_all_k8s()

# del_global_k8s

ok = del_global_k8s(k8s_id)

This method is used to delete the connection parameters of the k8s cluster.

Parameters

Returns

• True: Indicates successful deletion.
• False: Indicates deletion failure.

Examples

from edge2client import Edge2Client

client = Edge2Client(host, username, password)
client.login()

ok = client.del_global_k8s(k8s_id = 1)

The above code shows how to use Edge2Client to delete specific k8s cluster connection parameters.

# update_proxy_rule

result = update_proxy_rule(**kwargs)

Update the specified upstream proxy rule.

Parameters

Returns

• True: Represents the proxy rule was successfully updated.
• False: Represents the update of the proxy rule failed.

Examples

from edge2client import Edge2Client

client = Edge2Client(host, username, password)
client.login()

rule_id = 1
proxy_rule = [...]

result = client.update_proxy_rule(rule_id=rule_id, proxy=proxy_rule)

This method is used to update the global level IP rule list.

# new_global_ip_list

data = new_global_ip_list(name=None, type='ipv4', items=None)

This method is used to create a new global IP list.

Parameters

items Parameter

Returns

• id: The unique ID of the newly created global IP list.

Examples

from edge2client import Edge2Client

client = Edge2Client(host, username, password)
client.login()

ok = client.new_global_ip_list(name = 'ip-list-1',
                               type = 'ipv4',
                               items = [
                                   {'ip': '127.0.0.0/24'},
                                   {'ip': '192.168.1.0/24'},
                                   {'ip': '192.168.2.0/24', 'exptime': 1725000000},
                                   {'ip': '192.168.3.0/24', 'exptime': 1735000000}
                               ])

# put_global_ip_list

data = put_global_ip_list(rule_id=None, name=None, type='ipv4', items=None)

This method is used to modify the specified global-level IP list.

Parameters

Returns