OpenResty Edge™ Python SDK 用户手册

欢迎查阅 OpenResty Edge™ Python SDK 的用户手册。

安装

OpenResty Edge 的 Python SDK 依赖 Python3,请确保您已经安装好 3.6 及以上版本的 Python3。 您可以像安装其他 Python3 模块那样安装此 Python SDK:

  1. 打开 Linux 终端或 Windows 命令提示符窗口

  2. 输入以下命令安装 Python SDK:

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

如果您要安装特定版本的 Python SDK,则可以在模块名称后加上版本号:

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

安装命令执行成功后,您可以像下面这样验证是否已经正确安装:

$ 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()

键入在 client.login() 后,如果输出 True,则表示已经正确安装,如果您的 Edge Admin 使用的是自签名证书(默认是自签名证书),那么你还需要在 client.login() 之前调用 client.set_ssl_verify(False)。 接着你还可以使用 client.get_version() 来查看 OpenResty Edge 的版本信息。

此外,你可以在这里看到此 Python SDK 的变更日志

至此,安装已经全部完成,您可以参考本文档中后续的内容,以实现更为复杂的功能。

概述

import sys
import time
from edge2client import Edge2Client

def get_client():
    client = Edge2Client(host, username, password)
    # 如果是自签证书导致 SSL 校验失败,可以去掉下面的注释
    # 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)

方法列表

方法描述
Edge2Client此方法用于初始化 SDK 客户端。
set_ssl_verify设置访问 Edge Admin 时,是否进行 SSL 验证,默认会进行验证。
login此方法用于登录 OpenResty Edge,以便进行后续操作。
use_app此方法用于指定当前实例操作的应用 ID。
new_app此方法用于新增 HTTP 应用。
put_app此方法用于修改 HTTP 应用的基本信息。
get_app此方法用于获取 HTTP 应用的相关信息,包括域名、标签以及所属群组等。
put_app_config此方法用于修改 HTTP 应用的配置。
get_app_config此方法用于获取指定 HTTP 应用的配置信息。
del_app此方法根据提供的 app_id 删除指定的 HTTP 应用。
search_app此方法用于根据指定域名搜索 HTTP 应用。
search_http_app_by_keyword此方法用于根据域名或应用名称搜索 HTTP 应用。
search_upstream_by_ip此方法用于通过 IP 地址搜索上游信息。
search_k8s_upstream_by_ip这个方法用于根据 IP 搜索 Kubernetes 上游。
search_upstream_by_name此方法用于根据名称搜索上游。
search_k8s_upstream_by_name此方法用于通过指定名称搜索 Kubernetes 上游。
search_k8s_upstream此方法允许用户通过指定命名空间,服务名称和端口号来搜索 Kubernetes 上游。
search_k8s_upstream_history此方法根据命名空间、服务名称和端口号搜索 Kubernetes 上游历史。
get_all_apps此方法用于获取所有应用的信息。
new_upstream此方法用于新增上游,返回值为新增上游的 id。
put_upstream此方法用于修改上游信息。
get_upstream此方法用于获取上游信息。
del_upstream此方法用于删除上游。
get_all_upstreams此方法用于获取所有上游的详细信息。
new_k8s_upstream本函数用于新增全局 Kubernetes 上游,将返回新创建的 k8s 上游的 ID。
copy_upstream_to_k8s_upstream此方法用于将一个常规上游复制为一个 Kubernetes 上游。
put_k8s_upstream此方法用于修改 Kubernetes 上游信息。
get_k8s_upstream此方法用于获取 k8s 上游的信息。
del_k8s_upstream此方法用于删除 k8s(Kubernetes)上游。
get_all_k8s_upstreams此方法用于获取所有 Kubernetes 上游的信息。
new_rule此方法用于新建页面规则,包含各种规则类型,如:通用规则,代理规则,WAF 规则和缓存规则。你也可以指定规则执行的前提条件。
put_rule此方法用于修改页面规则。
get_rule此方法用于根据规则 ID 获取页面规则。
del_rule此方法用于删除与 rule_id 对应的页面规则。
get_all_rules此方法用于获取指定应用 ID (app_id) 的所有页面规则。
reorder_rules此方法用于调整规则的顺序。
get_all_rules_by_app_domain此方法用于根据指定的应用域名获取对应的页面规则。
get_all_rules_by_upstream_ip此方法用于根据上游 IP 地址来检索所有关联的页面规则。
get_all_waf_rules此方法用于根据特定的应用 id (app_id) 获取对应的 WAF 规则。
get_global_actions_used_in_app此方法用以获取与应用 ID (app_id) 相关联的自定义规则 ID。
set_cert_key此方法用于新增 SSL 证书并提供手动上传证书的选项。
set_le_cert此方法用于添加 Let’s Encrypt 证书。
put_cert_key此方法用于更新 SSL 证书(手动上传方式)。
put_le_cert此方法用于更新 Let’s Encrypt 证书。
get_le_cert此方法用于获取 Let’s Encrypt 证书的签发状态。
get_cert_key此方法用于获取 SSL 证书内容。
get_all_cert_keys此方法用于获取当前应用的全部证书信息。
delete_certificate_key删除与给定的 certificate_id 相关联的证书信息。
new_el此方法用于添加自定义的 edge 语言代码。
new_release此方法用于发布当前应用的更新。
pending_changes此方法用于查询待发布的更改数量。
sync_status发布新更动到所有节点。
node_sync_status此方法用于获取各节点的同步详情。
get_healthcheck_status这段代码用于获取各节点的健康检查信息。
add_app_user此方法用于新增应用级用户。
update_app_user此方法用于更新应用级的用户信息。
get_app_user此方法用于获取应用级别的用户信息,包括用户名、权限等。
del_app_user此方法用于删除特定应用的用户。
get_all_app_users此方法用于获取所有当前应用级别的用户,也可以通过指定 app_id 来获取特定应用的用户。
add_user_for_all_apps此方法用于为所有应用添加用户。
add_all_users_for_app此方法用于将所有全局用户添加到指定应用。
new_cache_purge_task此方法用于新增条件刷新任务。任务的触发条件以数组形式传递,支持设定多个触发条件。只有当所有设定的条件同时满足时,才会触发对应的刷新任务。
get_cache_purge_task此方法通过指定的刷新任务 id 来查询任务的详细信息。
get_all_cache_purge_tasks此方法用于获取所有缓存刷新任务的详细信息。
del_cache_purge_task此方法用于删除指定 ID 的刷新任务。
new_waf_whitelist此方法用于新增 WAF 白名单规则。
update_waf_whitelist此方法用于更新 WAF 白名单规则。
get_waf_whitelist此方法用于获取 WAF 的白名单规则。
del_waf_whitelist执行此操作会删除指定的 WAF 白名单规则。
get_all_waf_whitelists此方法用于获取所有的 WAF 白名单规则。
new_app_dymetrics创建新的应用动态指标。
put_app_dymetrics此方法用于修改应用的动态指标。
del_app_dymetrics此方法用于删除指定应用的动态指标。
get_app_dymetrics此方法用于获取指定应用的动态指标。
get_all_app_dymetrics此方法用于获取指定应用的全部动态指标信息。
get_app_dymetrics_data此方法用于获取应用的动态指标数据,默认返回最近 30 分钟的数据。
get_app_metrics此方法用于获取应用的 HTTP 请求状态指标和网络收发指标,默认情况下,它会获取最近 30 分钟的数据。
new_ip_list添加新的应用级 IP 列表。
put_ip_list此方法用于修改指定的 IP 列表。
del_ip_list此方法用于删除指定的 IP 列表。
get_ip_list此方法用于查看特定的 IP 列表。
node_monitor此方法用于获取网络节点的 CPU 和内存负载相关信息。
new_global_dymetrics此方法用于创建全局动态指标。
put_global_dymetrics此方法用于修改全局动态指标。
del_global_dymetrics此方法用于删除指定的全局动态指标。
get_global_dymetrics此方法用于获取指定的全局动态指标。
get_all_global_dymetrics此方法用于获取所有全球动态指标。
get_global_dymetrics_data此方法用于获取全球动态指标数据,默认范围为最近的 30 分钟。
use_dns_app此方法用于切换当前实例所操作的 DNS 应用。
new_dns_app此方法用于创建新的 DNS 应用。
put_dns_app此方法用于修改 DNS 应用的相关信息。
get_dns_app此方法用于获取 DNS 应用的相关信息。
del_dns_app此方法用于删除指定的 DNS 应用。
new_dns_record此方法用于新增 DNS 记录。
put_dns_record此方法用于修改 DNS 记录。
get_dns_record此方法用于获取 DNS 记录。
del_dns_record此方法用于删除 DNS 记录。
new_global_upstream此方法用于新增上游,并返回新创建的全局上游的 id。
update_global_upstream此方法用于更新全局上游信息。
get_global_upstream此方法用于获取全局上游信息。
del_global_upstream此方法用于删除全局上游。
get_all_global_upstreams此方法用于获取全部的上游信息。
new_global_k8s_upstream此方法用于创建新的全局 Kubernetes 上游,并返回新创建的上游的 ID。
put_global_k8s_upstream此方法用于修改全局 Kubernetes 上游的信息。
fetch_global_k8s_upstream此方法用于获取全球 Kubernetes 上游的信息。
del_global_k8s_upstream此方法用于删除全局 k8s 上游。
get_all_global_k8s_upstreams此方法用于获取所有的 Kubernetes 上游信息。
set_global_cert_key用于添加全局 SSL 证书。
put_global_cert_key此方法用于修改全局 SSL 证书。
get_global_cert_key此方法用于获取与 cert_id 相关联的 SSL 证书信息。
del_global_cert_key此方法用于删除指定的全局 SSL 证书。
add_global_user此方法用于新增全局用户。
search_global_user此方法用于根据用户名搜索全球用户信息。
get_all_global_users本函数用于获取所有全局用户的信息。
new_global_rule此方法用于新增全局规则。
put_global_rule此方法用于修改全局规则。
get_global_rule此方法用于获取全局规则信息。
get_global_action_by_name此方法用于根据给定的应用名来获取相应的全局自定义动作。
get_all_global_rules此方法用于获取所有的全局规则。
del_global_rule此方法用于删除全局规则。
new_global_var此方法用于新增全局变量。
put_global_var此方法用于修改全局变量。
get_global_var此方法用于获取全局变量。
get_all_global_vars此方法用于获取所有全局变量。
del_global_var此方法用于根据全局变量的 ID 进行删除操作。
get_global_ngx_config此方法用于获取全局的 nginx 配置信息。
set_global_ngx_config此方法设定全局的 nginx 配置信息。
get_global_misc_config此方法用于获取全局的杂项配置信息。
set_global_misc_config此方法用于设定全局杂项配置信息。
get_request_id_status此方法用于查询请求 id 的状态。
enable_request_id这个方法用于激活请求 id 功能。
disable_request_id此方法用于禁用请求 ID 功能。
new_global_waf_rule此方法用于新增全局 WAF 规则。
put_global_waf_rule此方法用于修改全局 WAF 规则。
get_global_waf_rule此方法通过提供的规则集 ID(rule_id)来获取全局的 WAF 规则集。
del_global_waf_rule此方法用于删除全局 WAF 规则。
get_all_global_waf_rules此方法用于获取所有全局 WAF 规则。
new_global_action此方法用于添加新的全局自定义动作。
put_global_action此方法用于修改全局自定义动作。
get_global_action此方法用于获取全局自定义动作。
del_global_action此方法用于删除指定的全局自定义动作。
count_global_actions此方法用于获取全局自定义动作的总数。
get_all_global_actions此方法用于获取所有全局自定义动作。
upload_static_file此方法用于上传静态文件。
get_static_file此方法用于获取指定的静态文件配置。
del_static_file此方法用于删除已上传的静态文件。
new_cluster_group此方法用于添加新的集群组。
put_cluster_group此方法用于修改集群组信息。
get_cluster_group此方法用于获取集群组的详细信息。
get_all_cluster_groups此方法用于获取所有集群组的信息。
del_cluster_group此方法用于删除集群组信息。
put_proxy_rule此方法用于修改上游代理规则。
new_global_k8s此方法用于添加新的 k8s 集群连接参数。
put_global_k8s此方法用于修改 Kubernetes 集群的连接参数。
get_global_k8s此方法用于获取 Kubernetes 集群的连接参数信息。
get_k8s_service_detail此方法用于获取 k8s 集群中定义的服务相关信息。
get_all_global_k8s此方法用于获取所有全球 Kubernetes 集群的 id。
del_global_k8s此方法用于删除 k8s 集群的连接参数。
update_proxy_rule更新指定的上游代理规则。
new_global_ip_list此方法用于创建新的全球 IP 列表。
put_global_ip_list此方法用于修改指定的全局级别 IP 列表。
del_global_ip_list此方法用于删除指定的全局 IP 列表。
get_global_ip_list此方法用于获取指定的全局 IP 列表。
new_user_var这是一个用于新增用户级别变量的函数。
put_user_var此方法用于修改用户级别的变量。
get_user_var此方法用于获取用户级别的变量。
del_user_var此方法用于删除用户级别的变量。
decode_request_id此方法用于解码 request_id 以获取诸如 app_id 等信息。
search_waf_log此方法用于通过请求 id 获取 WAF 日志。
get_version此方法用于获取 Admin、Admin DB、Log Server、Log Server DB 及 WAF 的版本信息。
add_api_token此方法用于生成 API Token。
get_api_token此方法用于获取 API 令牌。
del_api_token此方法用于删除一个指定的 API Token。
get_all_gateway_tag此方法用于获取所有网关集群的标签。
get_all_gateway此方法用于获取所有网关集群的信息。
add_gateway此方法用于创建新的网关集群。
del_gateway此方法用于删除指定的网关集群。
get_all_nodes此方法用于获取所有的网关节点。
get_node此方法根据提供的节点 ID 获取相应的节点信息。
get_node_by_mac_address此方法用于根据节点的硬件 ID 来检索节点的详细信息。
put_nodeThis method is used for updating node information. Parameters
del_node此方法用于根据节点 ID 删除指定节点。
lmdb_backup此方法用于触发 LMDB 的备份。如果备份成功,方法将返回 True。如果备份失败,则返回一个包含失败 Node 节点的 dict 信息,其中 key 是 Node ID,value 是失败的原因。您可以通过调用 node_sync_status 接口来确认备份是否成功。如果该接口中节点的 backup_time 大于 lmdb_backup() 方法的调用时间,那么可以认为该节点的备份已成功执行。
get_global_cert_referenced此方法用于获取使用了指定全局证书的应用列表。
get_all_partition_lua_module此方法用于获取指定分区的所有 Lua 模块。
get_partition_lua_module此方法用于获取指定分区中的指定 lua 模块。
new_partition_lua_module此方法用于向指定分区添加一个新的 Lua 模块。
put_partition_lua_module此方法用于编辑指定分区的特定 lua 模块。
del_partition_lua_module此方法用于删除指定分区内的特定 lua 模块。
conv_crl_to_lua_module此方法用于将 CRL 文件转换为 Lua 模块。
get_all_candidate_node此方法用于获取所有待批准的节点,随后可以通过调用 approve_candidate_node 接口来将这些节点批准加入到指定的集群。
approve_candidate_node此方法用于批准 MAC 地址为 mac_address 的节点加入到 ID 为 gateway_id 的网关集群。
get_waf_logs此方法用于获取指定应用的 WAF 日志。
get_dos_logs此方法用于检索指定应用的 CC 日志。
get_global_page_template此方法用于获取指定的全局页面模板。
get_all_global_page_templates此方法用于获取所有的全局页面模板。
del_global_page_template此方法用于删除指定的全局页面模板。
new_global_page_template此方法用于创建新的全局页面模板。
put_global_page_template此方法用于更新指定的全局页面模板。
get_app_basic_auth_user_group此方法用于获取指定应用中指定的 Basic Auth 用户组信息。
get_all_app_basic_auth_user_groups此方法用于获取指定应用中所有 Basic Auth 用户组信息。
del_app_basic_auth_user_group此方法用于删除指定应用中指定的 Basic Auth 用户组信息。
new_app_basic_auth_user_group此方法用于在指定应用中创建 Basic Auth 用户组。
put_app_basic_auth_user_group此方法用于更新指定应用中指定的 Basic Auth 用户组信息。
get_app_basic_auth_user此方法用于获取指定应用的 Basic Auth 用户组中指定的用户信息。
get_app_basic_auth_users_in_group此方法用于获取指定应用的 Basic Auth 用户组中所有用户信息。
del_app_basic_auth_user此方法用于删除指定应用的 Basic Auth 用户组中指定的用户信息。
new_app_basic_auth_user此方法用于在指定应用的 Basic Auth 用户组中创建用户。
put_app_basic_auth_user此方法用于更新指定应用的 Basic Auth 用户组中指定的用户信息。

方法详情


Edge2Client

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

此方法用于初始化 SDK 客户端。

参数

名称数据类型是否必需描述
hoststringedge-admin 的地址,需要包含协议和端口
usernamestring用于登录 edge-admin 的用户名
passwordstring用于登录 edge-admin 的密码
api_tokenstring访问令牌

返回值

  • 返回一个 edge2client.Edge2Client 对象。

示例

  1. 当 Edge Admin 的地址为 https://127.0.0.1:443,且使用用户名 username 和密码 password 初始化 Edge2Client 对象时:

    from edge2client import Edge2Client
    
    client = Edge2Client('https://127.0.0.1:443', 'username', 'password')
    
  2. 使用 API Token api_token 来初始化 Edge2Client 对象时:

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

set_ssl_verify

set_ssl_verify(verify)

设置访问 Edge Admin 时,是否进行 SSL 验证,默认会进行验证。 当您的 Edge Admin 使用的是自签名的证书时,那么需要把 SSL 验证关闭。

参数

名称数据类型是否必选描述信息
verifybool是非启用 SSL 验证

示例

from edge2client import Edge2Client

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

login

ok = login()

此方法用于登录 OpenResty Edge,以便进行后续操作。

返回值

  • True:表示登录成功。
  • False:表示登录失败。

示例

from edge2client import Edge2Client

client = Edge2Client(host, username, password)

ok = client.login()

use_app

ok = use_app(app_id)

此方法用于指定当前实例操作的应用 ID。

返回值

  • True:应用 ID 指定成功。
  • False:应用 ID 指定失败。

示例

下面的示例演示如何将当前实例操作的应用 ID 更改为 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)

此方法用于新增 HTTP 应用。

参数

名称数据类型是否必选描述信息
domainslist应用所需的域名
labelstring应用的标识名称
cluster_groupslist应用所处的集群组

返回值

  • app_id:返回新建应用的 ID,其数据类型为 number。

示例

以下示例展示了如何创建一个域名为 orig.foo.com,标签为 origin site for foo.com 的 HTTP 应用,且该应用所在的集群组为 [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)

此方法用于修改 HTTP 应用的基本信息。

参数

名称数据类型必选描述
app_idnumber应用的唯一标识符
domainslist应用的域名列表
labelstring应用的名称
cluster_groupslist应用所在的集群组列表
offlinebool应用的在线/离线状态,True 表示离线,False 表示在线

返回值

  • True:表示修改成功。
  • False:表示修改失败。

示例

以下示例展示了如何将已创建的应用(其域名为 orig.foo.com)的域名修改为 *.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()

此方法用于获取 HTTP 应用的相关信息,包括域名、标签以及所属群组等。

返回值

  • data:返回一个 dict 类型的数据。

示例

以下示例演示了如何获取 app_id 为 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)

此方法用于修改 HTTP 应用的配置。

参数

参数名数据类型是否必选描述
app_idnumber应用的 id
limiterdict应用的 limiter 配置
enable_websocketbool是否开启 websocket

返回值

  • True:配置修改成功。
  • False:配置修改失败。

示例

以下示例展示了如何修改 app_id 为 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)

此方法用于获取指定 HTTP 应用的配置信息。

参数

名称数据类型是否必填描述
app_idnumber待查询应用的 id

返回值

  • data:返回一个字典(dict)类型的数据。

示例

下例展示了如何获取 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)

此方法根据提供的 app_id 删除指定的 HTTP 应用。

参数

名称数据类型是否必须描述信息
app_idnumber待删除应用的唯一 id

返回值

  • True:表示应用删除成功。
  • False:表示应用删除失败。

示例

以下示例展示了如何删除 app_id 为 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)

此方法用于根据指定域名搜索 HTTP 应用。

参数

名称数据类型是否必须参数描述
app_domainstring需要搜索的应用域名
pagenumber返回结果的页码,默认为 1
pagesizenumber每页返回的结果数量,默认为 20

返回值

  • data:返回一个 list 类型的结果,其中每个元素都是应用的相关信息。

示例

以下示例以 orig.foo.com 为域名来搜索 HTTP 应用。

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)

此方法用于根据域名或应用名称搜索 HTTP 应用。

参数

参数名数据类型是否必选描述
keywordstring要搜索的关键词,将同时在域名和应用名称中进行搜索
pagenumber返回结果的页码序号,默认值为 1
pagesizenumber每页返回结果的条目数量,默认值为 20

返回值

  • data:此返回值为 list 类型,每个元素包含应用的相关信息。

示例

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)

此方法用于通过 IP 地址搜索上游信息。

参数

参数名数据类型是否必要描述
ipstring需要进行搜索的 IP 地址
pagenumber期望获取的结果页码,默认为第一页
pagesizenumber每页返回的结果数量,默认为 20 条

返回值

  • data:返回一个list类型的数据,列表中的每一个元素代表一个上游的详细信息。

示例

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)

这个方法用于根据 IP 搜索 Kubernetes 上游。

参数

名称数据类型是否必须描述
ipstring要搜索的 IP
pagenumber返回结果的页码,如果未指定,默认为 1
pagesizenumber每页返回结果的数量,如果未指定,默认为 20

返回值

  • data:一个list类型的变量,其中包含了 Kubernetes 上游的信息。

示例

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)

此方法用于根据名称搜索上游。

参数

参数名数据类型是否必填描述
namestring需要搜索的上游名称
pagenumber返回结果的页码,若未指定则默认为 1
pagesizenumber返回结果的每页条目数,若未指定则默认为 20

返回值

  • data:此为list 类型,每个元素都代表了一条上游信息。

示例

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)

此方法用于通过指定名称搜索 Kubernetes 上游。

参数

参数数据类型是否必须描述
namestring需要搜索的 Kubernetes 上游名称
pagenumber返回搜索结果的页码,默认值为 1
pagesizenumber单页返回的搜索结果条目数,默认值为 20

返回值

  • data:此为 list 类型,包含多个 Kubernetes 上游的信息。

示例

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)

此方法允许用户通过指定命名空间,服务名称和端口号来搜索 Kubernetes 上游。

参数

名称数据类型必选描述
namespacestringno搜索的命名空间名称
servicestringno搜索的服务的名称
portnumberno搜索的服务的端口号
pagenumberno返回结果的页码,默认值为 1
pagesizenumberno每一页返回结果的条目数,默认值为 20
type_listlistno搜索的上游类型列表,包括 k8s_http 和 k8s_global,默认情况下搜索所有类型

返回值

  • data:list 类型,列表中每个元素都是 Kubernetes 上游的信息。

示例

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)

此方法根据命名空间、服务名称和端口号搜索 Kubernetes 上游历史。

参数

名称数据类型是否必选描述
pagenumber返回结果的页码,若未指定,默认为 1
pagesizenumber返回结果的条目数,若未指定,默认为 20
start_timenumber搜索的起始时间戳
end_timenumber搜索的结束时间戳

返回值

  • data:返回值为 list 类型,每个元素代表一个 Kubernetes 上游的更新历史操作。

示例

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)

此方法用于获取所有应用的信息。

参数

参数名数据类型是否必须描述
detailbool是否需要返回每个应用的详细信息,默认为 False

返回值

  • detail 参数为 False 时,函数返回一个包含所有的 app id 的 list 类型的 Python 对象,包含所有应用的基本信息。
  • detail 参数为 True 时,函数返回一个以 app id 作为键值的 dict 类型的 Python 对象,包含所有应用的详细信息。

示例

from edge2client import Edge2Client

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

# 获取基本信息
apps = client.get_all_apps()

# 获取详细信息
apps = client.get_all_apps(detail=True)

new_upstream

up_id = new_upstream(**kwargs)

此方法用于新增上游,返回值为新增上游的 id。

参数

名称数据类型是否必选描述
namestring上游的名称
serverslist上游的信息
sslbool是否采用 HTTPS 协议,默认值为 False
health_checkerdict健康检查的详细配置,默认值为 None
gidarray用户组 id 列表,如 [1]

servers 参数

名称数据类型是否必选描述
domainstring上游的域名
ipstring上游的 IP 地址。注意,参数 domain 和 IP 至少需要填写一个
portstring上游的端口号
weightnumber上游的权重,默认值为 1

返回值

  • up_id:表示创建成功的上游的 ID。

示例

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)

此方法用于修改上游信息。

参数

名称数据类型是否必选描述
namestring定义上游的名称
serverslist详细定义上游信息
sslbool是否启用 HTTPS 协议,默认为 False
health_checkerdict用于配置健康检查的详细信息,默认为 None
gidarray用户组 id 列表,例如[1]

示例

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)

此方法用于获取上游信息。

参数

参数名数据类型是否必须参数描述
up_idstring上游的 ID

返回值

  • data:返回类型为 dict 的上游信息。

示例

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)

此方法用于删除上游。

参数

名称数据类型是否必选描述
up_idstring上游的唯一标识符

返回值

  • 返回 True:表示上游删除成功。
  • 返回 False:表示上游删除失败。

示例

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)

在这个示例中,我们首先导入了 Edge2Client,然后创建了一个 Edge2Client 对象,使用 hostusernamepassword 进行登录。然后,我们尝试用 del_upstream 方法删除标识符为 1 的上游。


get_all_upstreams

upstreams = client.get_all_upstreams()

此方法用于获取所有上游的详细信息。

返回值

  • upstreams:返回一组list类型的数据,包含所有上游信息。

示例

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)

本函数用于新增全局 Kubernetes 上游,将返回新创建的 k8s 上游的 ID。

参数

名称数据类型是否必选描述
namestring上游名称
k8s_serviceslist当上游是 k8s 服务时所需的信息
sslbool是否使用 HTTPS 协议,默认为 False
health_checkerdict对健康检查的详细配置,默认为 None
gidarray用户组 ID 列表,例如:[1]

k8s_services 参数

名称数据类型是否必选描述
k8snumberk8s 集群 ID
k8s_namespacestringk8s 集群命名空间
k8s_servicestringk8s 集群服务
k8s_service_portnumberk8s 集群服务端口

返回值

  • up_id:新创建的 k8s 上游的 ID。

示例

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)

此方法用于将一个常规上游复制为一个 Kubernetes 上游。

参数

名称数据类型是否必要描述
up_idstring待复制的上游的 ID
k8s_serviceslist当上游是 Kubernetes 服务时的信息
rulesarray遍历 rules 中的规则,使用原上游的规则将全部迁移到 Kubernetes 上游,如果不提供此参数,函数会默认查找本 app 的所有规则进行遍历。使用此参数可以防止函数多次自动查找所有规则

返回值

  • up_id:新创建的 Kubernetes 上游的 ID。

示例

示例一:

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,
                                }
                            ])

示例二:


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)

此方法用于修改 Kubernetes 上游信息。

参数

名称数据类型是否必填描述
namestring指定上游名称
k8s_serviceslist当上游是 k8s 服务时所需的详细信息
sslbool确定是否使用 HTTPS 协议,默认值为 False
health_checkerdict配置健康检查的具体参数,默认值为 None
gidarray用户组 ID 列表,例如[1]

返回值

  • True:表示修改成功。
  • False:表示修改失败。

示例

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)

此方法用于获取 k8s 上游的信息。

参数

参数名数据类型是否必选描述
up_idstring上游的 ID

返回值

  • data:返回一个 dict 类型的数据。

示例

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)

此方法用于删除 k8s(Kubernetes)上游。

参数

名称数据类型是否必须描述
upstream_idstring对应上游的唯一标识 ID

返回值

  • True:表示删除成功。
  • False:表示删除失败。

示例

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()

此方法用于获取所有 Kubernetes 上游的信息。

返回值

  • upstreams:返回一个 list 类型的 Kubernetes 上游列表。

示例

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)

此方法用于新建页面规则,包含各种规则类型,如:通用规则,代理规则,WAF 规则和缓存规则。你也可以指定规则执行的前提条件。

参数

名称数据类型是否必须描述
conditionlist规则条件
conseqdict 或 list规则行动
waflistWAF 规则
proxylist代理规则
cachelist缓存规则
contentlist内容规则
topnumber1:置顶规则,-1:置底规则
ordernumber规则顺序,优先级低于 top 参数
lastbool如果命中此条规则,则跳过所有余下的页面规则,默认为 False
reorderbool是否重建 order 的值,默认为 False
enablebool如果此选项被设为 False,则会禁用规则,默认为 True

condition 参数

名称数据类型是否必须描述
varstring 或 array如果是 string 类型,则填写变量名 name。如果是 array 类型则需要填写变量名 name和参数 args
opstring操作符,默认为 eq,即字符串相等 (equal)
valstringvals 二选一string 类型或者 array 类型,需要指定为正则或者通配类型时,传 [正则表达式, 'rx'], [通配表达式, 'wc']
valslistval 二选一val 的集合

conseq 参数

名称数据类型是否必须描述
edge 语言内建函数stringedge 语言内建函数
edge 语言内建函数的参数listedge 语言的内建函数参数

conseq 可以是 dict 类型或者 list 类型,如下是一个 dict 类型的例子。

waf 参数

名称数据类型是否必须描述
rule_setslist全局默认的用户规则集,默认值为空列表
actionstring可选 log, 403 Forbidden, edge-captcha, redirect 中的一个
thresholdstring可选 high, medium, lownone 中的一个,与 sensitivity 二选一,sensitivity 的优先级更高,高敏感级别对应低阈值级别,低敏感级别对应高阈值级别
sensitivitystring可选 high, medium, lownone 中的一个,与 threshold 二选一,sensitivity 的优先级更高,高敏感级别对应低阈值级别,低敏感级别对应高阈值级别
clearancenumbercaptcha 触发后的持续时间,默认值为 60 秒
redirect_urlstring当动作为 redirect (重定向) 时,指定的 url
cross_requestsbool当为 True 时,使用跨请求模式,默认为 True
rule_sets_thresholdlist单独设置每个规则集的敏感分数
scoreintegerthresholdsensitivity 选择 none时,可以自定义敏感分数

proxy 参数

proxy 数组的描述如下:

名称数据类型是否必须描述
upstreamslist上游信息
backup_upstreamslist上游备份节点信息
upstreams_el_codestrEdgelang 设置上游
timeoutnumber代理超时时间,默认值为 3 秒
connect_timeoutnumber连接超时时间,默认值为 3 秒
read_timeoutnumber读超时时间,默认值为 3 秒
send_timeoutnumber发送超时时间,默认值为 3 秒
retriesnumber重试次数,默认值为 1 次
retry_conditionlist重试条件,默认值为 [“error”, “timeout”, “invalid_header”, “http_500”, “http_502”, “http_504”]. 可选 http_503, http_403, http_404, http_429non_valueempotent (即方法可以是 POST, LOCK, PATCH)
balancer_algorithmstring负载均衡算法,默认值为 roundrobin。支持的算法还有 hashchash
balancer_varslist负载均衡算法所依赖的变量,当负载均衡算法选择为 hashchash 时需要填写该字段
multi_tiernumber多层网络策略 ID

upstreams 参数

upstreamsbackup_upstreams 数组的描述如下:

名称数据类型是否必须描述
upstreamnumber上游的 ID
global_upstreamnumber全局上游的 ID
k8s_upstreamnumberk8s 上游的 ID
global_k8s_upstreamnumber全局 k8s 上游的 ID
weightnumber上游的权重,默认值为 1

cache 参数

名称数据类型是否必须描述
cache_keylist缓存 key
default_ttlslist是否启用默认缓存,默认值为 None
browser_ttlnumber是否启用浏览器缓存,默认值为 None
browser_ttl_unitstring浏览器缓存单位,只在 browser_ttl 设置后有效,默认值为 min
enable_globalbool是否启用跨域名缓存,默认值为 False
enforce_cachebool是否启用始终缓存,默认值为 False
cluster_hashbool是否启用集群缓存,默认值为 False
disable_convert_headbool是否将 HEAD 请求方法转换为 GET,默认值为 True

返回值

  • rule_id:新规则的 ID。

示例

示例一:使用 dict 类型的条件和动作来新建规则。

from edge2client import Edge2Client

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

app_id = 1
client.use_app(app_id)

condition = [
    {
        'var': 'host',
        'val': 'test.openresty.com'
    },
    {
        '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)

由于 dict 类型不能自行排序,并且不能设置重复名称的动作, 所以推荐下面这种使用 list 类型代替 dict 类型的方式。

示例二:使用 list 类型的条件和动作来新建规则。

from edge2client import Edge2Client

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

app_id = 1
client.use_app(app_id)

condition = [
    {'var': 'host', 'val': 'test.openresty.com'},
    {'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)

示例三:启用 WAF 规则。

创建自定义的 WAF 规则,并在应用中使用该规则。

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)

示例四:启用代理规则。

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)

示例五:启用缓存。

在该示例中,当访问来源的 IP 位于中国(CN)时,将会实施缓存规则。具体的缓存 key 包含 URL、查询字符串以及客户端来源的城市。

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)

此方法用于修改页面规则。

参数

名称数据类型是否必选描述
conditionlist定义规则的条件
conseqdict or list定义规则的动作
waflist定义 WAF 规则
proxylist定义代理规则
cachelist定义缓存规则
contentlist定义内容规则
topnumber用于设定规则的位置,1 表示置顶规则,-1 表示置底规则
ordernumber用于设定规则的顺序,优先级低于 top 参数
lastbool如果此选项被设为 True,且这条规则被命中,则会跳过所有剩余的页面规则,默认为 False
enablebool如果此选项被设为 False,则会禁用规则,默认为 True

返回值

  • True:表示成功。
  • False:表示失败。

示例

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)

# 关闭页面规则中的条件
ok = client.put_rule(rule_id=rule_id, condition=OFF, conseq=conseq)

get_rule

data = get_rule(rule_id)

此方法用于根据规则 ID 获取页面规则。

参数

参数名数据类型是否必选描述
rule_idnumber页面规则的 id

返回值

  • data:返回一个 dict 类型的页面规则信息。

示例

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)

此方法用于删除与 rule_id 对应的页面规则。

参数

名称数据类型是否必选描述
rule_idnumber规则的唯一标识符

返回值

  • True:表示页面规则成功删除。
  • False:表示页面规则删除失败。

示例

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)

此方法用于获取指定应用 ID (app_id) 的所有页面规则。

参数

名称数据类型是否必选描述
app_idnumber指定的应用 id,若未提供,默认为当前应用 id

返回值

  • 返回一个规则列表,该列表中的每个元素的类型与 get_rule 函数的返回值类型一致。

示例

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)

此方法用于调整规则的顺序。

参数

名称数据类型必选描述
ordersdict此字典中的 key-value 对定义了新的规则顺序,其中 key 代表规则 ID,value 代表规则的顺序

返回值

  • True:如果成功调整规则顺序。
  • False:如果调整规则顺序失败。

示例

以下示例展示了如何调换规则 ID 2 和 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)

此方法用于根据指定的应用域名获取对应的页面规则。

参数

名称数据类型必选描述
domainstring应用的域名

返回值

  • rules:list 类型的规则列表。

示例

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)

此方法用于根据上游 IP 地址来检索所有关联的页面规则。

参数

名称数据类型是否必要描述
upstream_ipstring用于指定上游的 IP 地址

返回值

  • rules:这是一个包含所有相关规则的 list 类型列表。

示例

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)

此方法用于根据特定的应用 id (app_id) 获取对应的 WAF 规则。

参数

名称数据类型是否必选描述
app_idnumberno应用的 id,如未指定,则默认为当前应用的 id

返回值

  • rules:返回一种 list 类型的规则列表。

示例

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)

此方法用以获取与应用 ID (app_id) 相关联的自定义规则 ID。

参数

名称数据类型必需性描述
app_idnumber应用的唯一标识符

返回值

  • rule_ids:返回一个列表,其中元素为各自规则的唯一 ID。如果需要获取规则的详细信息,可以依据这些规则 ID 进行进一步查询,详情请参阅 get_global_rule() 方法。

示例

以下示例展示了如何获取所有全局规则的 ID。

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)

此方法用于新增 SSL 证书并提供手动上传证书的选项。

参数

名称数据类型是否必选描述信息
keystring私钥内容
certstring证书内容
ca_chainstringCA 链条内容
global_cert_idnumber证书的全局 ID
gidlist用户组 ID 列表

返回值

  • cert_id:返回新添加的证书的 ID。

示例

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)

此方法用于添加 Let’s Encrypt 证书。

参数

名称数据类型是否必选描述
domainsstring array用于自动获取 LE 证书的域名
gidlist用户组 ID 列表

返回值

  • cert_id:新创建的 Let’s Encrypt 证书的 ID

示例

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)

此方法用于更新 SSL 证书(手动上传方式)。

参数

名称数据类型是否必选参数描述
cert_idnumber证书的唯一标识符 id
keystring私钥的详细内容
certstring服务器端证书的详细内容
ca_chainstringCA 链的详细内容
global_cert_idnumber证书的全球唯一标识符 id
gidlist用户组 id 的列表形式

返回值

  • True:表示更新成功。
  • False:表示更新失败。

示例

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)

此方法用于更新 Let’s Encrypt 证书。

参数

名称数据类型是否必选描述
domainsstring array需要自动获取 LE 证书的域名
gidlist用户组 ID 列表
resignbool是否触发重新签发证书

返回值

  • True:表示成功。
  • False:表示失败。

示例

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)

此方法用于获取 Let’s Encrypt 证书的签发状态。

参数

名称数据类型是否必选描述
cert_idnumber证书 ID

返回值

  • data:返回一个 dict 类型的数据,包含以下字段:
字段名称数据类型描述
statusstring描述证书的签发状态,可能的值包括:valid / pending / invalid
expdatenumber证书的过期时间,使用 Unix 时间戳表示
next_udpatenumber证书的下次更新时间,使用 Unix 时间戳表示

示例

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)

此方法用于获取 SSL 证书内容。

参数

参数名数据类型是否必选描述
cert_idnumber代表证书的 id

返回值

  • 返回值为 cert_data,表示证书的内容,数据类型为 dict。

示例

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()

此方法用于获取当前应用的全部证书信息。

返回值

  • cert_data:以 dict 类型返回的证书数据。

示例

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()

delete_certificate_key

success = delete_certificate_key(certificate_id)

删除与给定的 certificate_id 相关联的证书信息。

参数

名称数据类型是否必选描述
certificate_idnumber证书的唯一标志

返回值

  • True:删除成功。
  • False:删除失败。

示例

from edge2client import Edge2Client

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

application_id = 1
client.use_application(application_id)

certificate_id = 1
success = client.delete_certificate_key(certificate_id)

new_el

ok = new_el(**kwargs)

此方法用于添加自定义的 edge 语言代码。

参数

名称数据类型必选描述
phasestring用于定义 edge 语言执行的阶段
codestring要执行的 edge 语言代码
postbool如果设为 True,则该段代码将在选择的阶段后面执行,默认值为 False
prebool如果设为 True,则该段代码将在选择的阶段前面执行,默认值为 False

返回值

  • True:表示成功。
  • False:表示失败。

示例

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()

此方法用于发布当前应用的更新。

返回值

  • True:表示更新成功。
  • False:表示更新失败。

示例

from edge2client import Edge2Client

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

app_id = 1
client.use_app(app_id)

ok = client.new_release()

此示例展示了如何使用 Edge2Client 的 new_release 方法来发布应用的更新。


pending_changes

changes = pending_changes()

此方法用于查询待发布的更改数量。

返回值

  • changes:这是一个整数,表示待发布的更改数量。

示例

from edge2client import Edge2Client

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

app_id = 1
client.use_app(app_id)

changes = client.pending_changes()

在上述示例中,首先创建了一个 Edge2Client 实例并完成登录。随后,将应用的 id 设置为 1,并通过 pending_changes 函数查询待发布的更改数量。


sync_status

total, synced = sync_status()

查询当前的同步状态。

返回值

  • total:Edge Node 服务器的总数量。
  • synced:已成功同步的 Edge Node 服务器的数量。

示例

创建多个规则,并确认它们是否已成功发布到全网。

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('新的发布已同步到所有节点')

node_sync_status

data = node_sync_status()

此方法用于获取各节点的同步详情。

返回值

  • data:dict 类型,它返回每个节点的 node_id 以及该节点上一次发布到现在的延迟时间。

示例

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('警告:节点 id {}: 落后 {}'
        .format(str(node_id), str(delay)))

get_healthcheck_status

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

这段代码用于获取各节点的健康检查信息。

返回值

  • data:这是一个dict类型的数据,它返回每个节点的 node_id 以及对应节点的健康状态。

示例

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)

此方法用于新增应用级用户。

参数

名称数据类型必选描述
namestring用户名
readbool是否拥有读权限,默认为 True
writebool是否拥有写权限,默认为 True
releasebool是否拥有发布更动的权限,默认为 False
dns_readbool是否拥有读取 DNS 的权限,默认为 False
dns_writebool是否拥有修改 DNS 的权限,默认为 False

返回值

  • user_id:新添加用户的 ID。

请注意:此处的 user_id 与全局用户的 user_id 不同。

示例

以下示例展示了如何新增一个应用级用户,用户名为 only_reader,并且没有写权限和发布更动权限。

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)

此方法用于更新应用级的用户信息。

参数

名称数据类型是否必要描述
idlistyes用户 id
namestringyes用户名
readboolno用户是否具有读取权限,默认值为 True
writeboolno用户是否具有写入权限,默认值为 True
releaseboolno用户是否具有发布更改的权限,默认值为 False
dns_readboolno用户是否具有读取 DNS 的权限,默认值为 False
dns_writeboolno用户是否具有写入 DNS 的权限,默认值为 False

返回值

  • True:用户信息更新成功。
  • False:用户信息更新失败。

示例

以下示例展示了如何使用此方法更新 id 为 1 的用户的权限,将用户名设置为 master,并赋予写入和发布更改的权限。

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)

此方法用于获取应用级别的用户信息,包括用户名、权限等。

参数

参数名数据类型是否必填描述
idlist用户的 id
namestring用户名
app_idnumber应用的 id,若未指定则默认为当前应用 id
user_idnumber全局的用户 id

返回值

  • data:返回一个字典类型的数据,包含用户名、权限等用户信息。

示例

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)

此方法用于删除特定应用的用户。

参数

名称数据类型是否必须描述
idlist用户 id
namestring用户名
app_idnumber应用 id,若未指定,则默认为当前应用
user_idnumber全局用户 id

返回值

  • 如果操作成功,则返回 True。
  • 如果操作失败,则返回 False。

示例

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)

在这个例子中,我们首先创建了一个 Edge2Client 实例并登录。然后,我们选择了一个应用,最后我们通过传入用户名来删除应用的用户。


get_all_app_users

data = get_all_app_users(app_id)

此方法用于获取所有当前应用级别的用户,也可以通过指定 app_id 来获取特定应用的用户。

参数

名称数据类型是否必选参数
app_idnumber应用 id,默认为当前应用 id

返回值

  • data:返回值为list类型,列表中的每个元素都是 dict 类型。

示例

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)

此方法用于为所有应用添加用户。

参数

名称数据类型是否必选描述
namestring用户名
readbool用户是否拥有读权限,默认为 True
writebool用户是否拥有写权限,默认为 True
releasebool用户是否拥有发布更改的权限,默认为 False
dns_readbool用户是否拥有读取 DNS 的权限,默认为 False
dns_writebool用户是否拥有编辑 DNS 的权限,默认为 False

示例

from edge2client import Edge2Client

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

# 利用 add_global_user() 函数创建名为 '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)

此方法用于将所有全局用户添加到指定应用。

参数

名称数据类型是否必选描述
app_idnumber应用的 ID,若未指定,则默认为当前应用的 ID
readbool用户是否拥有读权限,若未指定,则默认为 True
writebool用户是否拥有写权限,若未指定,则默认为 True
releasebool用户是否拥有发布更动的权限,若未指定,则默认为 False
dns_readbool用户是否有读取 DNS 的权限,若未指定,则默认为 False
dns_writebool用户是否有写入 DNS 的权限,若未指定,则默认为 False

返回值

  • True:表示添加成功。
  • False:表示添加失败。

示例

以下示例展示了如何为 ID 为 1 的应用添加用户,其中所有全局用户都将添加在该应用下,且 release (发布更动) 权限为 True,其他权限保持默认值。

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)

此方法用于新增条件刷新任务。任务的触发条件以数组形式传递,支持设定多个触发条件。只有当所有设定的条件同时满足时,才会触发对应的刷新任务。

参数

名称数据类型是否必须描述
conditionlist触发条件

返回值

  • task_id:返回已创建的刷新任务的 ID,可通过此 ID 查询刷新任务的执行详情。

示例

以下示例中,新建的条件刷新任务的触发条件设定为:“当访问的 Host 为 con.foo.com,并且请求头中 Referer 的值匹配到正则表达式 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)

此方法通过指定的刷新任务 id 来查询任务的详细信息。

参数

名称数据类型是否必须参数
task_idnumber刷新任务的唯一标识 id

返回值

  • data:返回的是一个包含任务详情的字典(dict)类型的数据。

示例

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()

此方法用于获取所有缓存刷新任务的详细信息。

返回值

  • data:返回一个包含所有刷新任务的列表。

示例

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)

此方法用于删除指定 ID 的刷新任务。

参数

名称数据类型是否必选描述
task_idnumber需要删除的刷新任务的 ID

返回值

  • True:表示成功删除。
  • False:表示删除失败。

示例

以下示例展示如何删除 ID 为 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)

此方法用于新增 WAF 白名单规则。

参数

参数名数据类型是否必选描述
conditionlist规则执行的条件
rule_setslistWAF 规则的 ID 列表

WAF Condition 参数

参数名数据类型是否必选描述
varstring or arrayEdge 语言内置的函数名。当数据类型为 array 时,需在函数名后添加此方法所需的参数
opstring操作符,默认为 eq
valstringval / vals 中的任选一项
valslistval / vals 中的任选一项一组值 (使用数组)

返回值

  • rule_id:新创建的 WAF 白名单规则的 ID。

示例

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)

此方法用于更新 WAF 白名单规则。

参数

名称数据类型是否必选描述信息
whitelist_idnumber待更新的白名单 id
conditionlist规则执行的条件集合
rule_setslist包含 waf id 的列表

返回值

  • 若成功,返回 True。
  • 若失败,返回 False。

示例

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)

此方法用于获取 WAF 的白名单规则。

参数

名称数据类型是否必须描述
whitelist_idnumber白名单规则的唯一标识符 id

返回值

  • data:返回一个 dict 类型,包含 WAF 白名单的规则数据。

示例

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)

执行此操作会删除指定的 WAF 白名单规则。

参数

名称数据类型是否必选描述信息
whitelist_idnumber白名单规则的 ID

返回值

  • True:表示删除成功。
  • False:表示删除失败。

示例

from edge2client import Edge2Client

# 初始化客户端并登录
client = Edge2Client(host, username, password)
client.login()

# 指定 APP ID
app_id = 1
client.use_app(app_id)

# 删除特定 WAF 白名单规则
ok = client.del_waf_whitelist(waf_whitelist_id)

get_all_waf_whitelists

data = get_all_waf_whitelists()

此方法用于获取所有的 WAF 白名单规则。

返回值

  • data:返回一个 list 类型的 WAF 白名单数据。

示例

from edge2client import Edge2Client

# 创建并登录客户端
client = Edge2Client(host, username, password)
client.login()

# 选择应用
app_id = 1
client.use_app(app_id)

# 获取所有的 WAF 白名单
data = client.get_all_waf_whitelists()

new_app_dymetrics

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

创建新的应用动态指标。如果想要开启 OpenResty Edge 的内置动态指标,可以从此文档获取内置动态指标的名称及 SQL。

参数

参数数据类型必选描述
app_idnumber应用的唯一标识符 id
namestring用于标识动态指标的名称
sqlstring用于生成动态指标的 SQL 语句
notestring对动态指标的附加说明或备注
intervalnumber动态指标的刷新时间间隔(以秒为单位)

返回值

  • id:新创建的动态指标的唯一标识符。

示例

from edge2client import Edge2Client

# 创建并登录客户端
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)

此方法用于修改应用的动态指标。

参数

参数数据类型是否必须描述
idnumber需要修改的动态指标的 id
app_idnumber应用的 id
namestring指标的名称
sqlstring定义指标的 SQL 语句
notestring备注信息
intervalnumber数据刷新间隔,单位为秒

返回值

  • True:表示修改成功。
  • False:表示修改失败。

示例

from edge2client import Edge2Client

# 创建并登录客户端
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

ok = del_app_dymetrics(app_id, id)

此方法用于删除指定应用的动态指标。

参数

参数数据类型是否必须描述
app_idnumber指定的应用的 ID
idnumber要删除的动态指标的 ID

返回值

  • True:表示删除成功。
  • False:表示删除失败。

示例

from edge2client import Edge2Client

# 创建并登录客户端
client = Edge2Client(host, username, password)
client.login()

ok = client.del_app_dymetrics(app_id, dymetrics_id)

get_app_dymetrics

data = get_app_dymetrics(app_id, id)

此方法用于获取指定应用的动态指标。

参数

参数数据类型必选描述
idnumber动态指标的 id
app_idnumber应用的 id

返回值

  • data:返回一个 dict 类型的动态指标数据。

示例

from edge2client import Edge2Client

# 创建并登录客户端
client = Edge2Client(host, username, password)
client.login()

data = client.get_app_dymetrics(app_id, dymetrics_id)

get_all_app_dymetrics

data = get_all_app_dymetrics(app_id)

此方法用于获取指定应用的全部动态指标信息。

参数

名称数据类型是否必选描述
app_idnumber表示应用的唯一标识 id

返回值

  • data:返回的数据为一个包含所有动态指标信息的 list 类型列表。

示例

from edge2client import Edge2Client

# 创建并登录客户端
client = Edge2Client(host, username, password)
client.login()

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)

此方法用于获取应用的动态指标数据,默认返回最近 30 分钟的数据。

参数

参数名数据类型是否必选描述
app_idnumber应用的 id
idnumber动态指标的 id
chart_typenumber图表类型
start_timenumber数据开始时间
end_timenumber数据结束时间
node_idnumberEdge Node 节点的 ID

返回数据

  • data:返回的动态指标数据,其数据类型为list

示例

from edge2client import Edge2Client

# 创建并登录客户端
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)

此方法用于获取应用的 HTTP 请求状态指标和网络收发指标,默认情况下,它会获取最近 30 分钟的数据。

参数

参数数据类型是否必须描述
idnumber指标的 id
start_timenumber指标获取的开始时间
end_timenumber指标获取的结束时间

返回值

  • data:这是一个包含指标数据的 list 类型。

示例

from edge2client import Edge2Client

# 创建并登录客户端
client = Edge2Client(host, username, password)
client.login()

data = client.get_app_metrics(app_id)

new_ip_list

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

添加新的应用级 IP 列表。

参数

名称数据类型是否必须描述
namestringIP 列表的名称
typestringIP 地址的类型,可以是 ipv4 或即将支持的 ipv6
itemsarrayIP 地址列表

items 参数

名称类型是否必须描述
ipstringIP 地址

返回值

  • id:新创建的 IP 列表的 ID。

示例

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'}
                        ])

put_ip_list

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

此方法用于修改指定的 IP 列表。

参数

名称数据类型是否必选描述
rule_idnumber用于指定需要修改的 IP 列表的 ID
namestring用于指定 IP 列表的名称
typestring用于指定 IP 地址的类型,目前仅支持 ‘ipv4’ ,‘ipv6’将在未来推出
itemsarray用于指定 IP 地址列表

返回值

  • True:表示成功修改指定的 IP 列表。
  • False:表示修改指定的 IP 列表失败。

示例

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)

此方法用于删除指定的 IP 列表。

参数

名称数据类型是否必须描述
rule_idnumber需要删除的 IP 列表的 ID

返回值

  • True:表示删除成功。
  • False:表示删除失败。

示例

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)

在此示例中,我们首先使用 Edge2Client 的实例登陆,然后选择应用程序,最后删除指定 ID 的 IP 列表。


get_ip_list

data = get_ip_list(rule_id=None)

此方法用于查看特定的 IP 列表。

参数

名称数据类型是否必选描述
rule_idnumber要查看的 IP 列表的唯一标识符 ID

返回值

  • data:返回一个字典类型的 IP 列表数据。

示例

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)

node_monitor

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

此方法用于获取网络节点的 CPU 和内存负载相关信息。

参数

参数名数据类型是否必须描述
node_id数值网关节点的 ID
start_time数值数据开始时间
end_time数值数据结束时间
step数值数据获取的时间间隔

返回值

  • data:返回一个包含监控数据的列表。

示例

from edge2client import Edge2Client

# 创建并登录客户端
client = Edge2Client(host, username, password)
client.login()

node_id = 1
data = client.node_monitor(node_id)

new_global_dymetrics

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

此方法用于创建全局动态指标。

参数

名称数据类型必选描述
namestring待创建的全局动态指标的名称
notestring对该全局动态指标的备注信息
intervalnumber统计的时间间隔
sqlstring用于收集指标的 SQL 语句

返回值

  • id:新创建的全局动态指标的唯一标识符 ID。

示例

from edge2client import Edge2Client

# 创建并登录客户端
client = Edge2Client(host, username, password)
client.login()

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)

此方法用于修改全局动态指标。

参数

名称数据类型必选描述
idnumber全局动态指标的 ID
namestring全局动态指标的名称
notestring备注信息
intervalnumber数据收集的时间间隔
sqlstring用于收集指标的 SQL 语句

返回值

  • True:表示成功。
  • False:表示失败。

示例

from edge2client import Edge2Client

# 创建并登录客户端
client = Edge2Client(host, username, password)
client.login()

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)

此方法用于删除指定的全局动态指标。

参数

参数名数据类型是否必需描述
idnumber需要删除的全局动态指标的 ID

返回值

  • True:表示成功删除全局动态指标。
  • False:表示删除全局动态指标失败。

示例

from edge2client import Edge2Client

# 创建并登录客户端
client = Edge2Client(host, username, password)
client.login()

ok = client.del_global_dymetrics(dymetrics_id)

get_global_dymetrics

data = get_global_dymetrics(id)

此方法用于获取指定的全局动态指标。

参数

参数名数据类型是否必选描述
idnumber全局动态指标的 ID

返回值

  • data:返回的是一个类型为 dict 的全局动态指标信息。

示例

from edge2client import Edge2Client

# 创建并登录客户端
client = Edge2Client(host, username, password)
client.login()

data = client.get_global_dymetrics(dymetrics_id)

get_all_global_dymetrics

data = get_all_global_dymetrics()

此方法用于获取所有全球动态指标。

返回值

  • data:返回一个包含全球动态指标信息的 list 类型数据。

示例

from edge2client import Edge2Client

# 创建并登录客户端
client = Edge2Client(host, username, password)
client.login()

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)

此方法用于获取全球动态指标数据,默认范围为最近的 30 分钟。

参数

名称数据类型是否必填描述
idnumber动态指标的 ID
chart_typestring图表类型,默认为 ’line’
start_timenumber开始时间,默认为 None
end_timenumber结束时间,默认为 None
node_idnumberEdge Node 节点的 ID,默认为 None

返回值

  • data:返回值是一个列表,包含全球动态指标数据。

示例

from edge2client import Edge2Client

# 创建并登录客户端
client = Edge2Client(host, username, password)
client.login()

dymetrics_id = 1
data = client.get_global_dymetrics_data(dymetrics_id)

use_dns_app

ok = use_dns_app(dns_id)

此方法用于切换当前实例所操作的 DNS 应用。

参数

参数名数据类型是否必选描述
dns_idnumber需要操作的 DNS 应用的 id

返回值

  • True:表示切换成功。
  • False:表示切换失败。

示例

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)

此方法用于创建新的 DNS 应用。

参数

名称数据类型是否必选参数描述
zonestring域名
authoritylistNS 记录
soa_emailstringSOA EMAIL 记录

返回内容

  • dns_id:返回新创建的 DNS 应用的 ID。

示例

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)

此方法用于修改 DNS 应用的相关信息。

参数

名称数据类型是否必填描述信息
dns_id数值型DNS 应用的唯一标识 id
zone字符串型DNS 的域名记录
authority列表型DNS 的 NS 记录
soa_email字符串型DNS 的 SOA EMAIL 记录

返回值

  • True:表示信息修改成功。
  • False:表示信息修改失败。

示例

以下示例展示如何修改 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)

此方法用于获取 DNS 应用的相关信息。

参数

参数名数据类型是否必须描述
dns_idnumber代表 DNS 应用的唯一 id

返回值描述

  • data:一个 dict 类型的数据,包含 DNS 应用的详细信息。

示例

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)

此方法用于删除指定的 DNS 应用。

参数

下表列出了此方法所需的参数。

名称数据类型是否必选描述
dns_idnumber需要删除的 DNS 应用的 id

返回值

  • True:表示成功删除了 DNS 应用。
  • False:表示删除 DNS 应用失败。

示例

以下示例展示了如何删除指定的 DNS 应用。

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)

此方法用于新增 DNS 记录。

参数

名称数据类型是否必填描述
sub_domainstring子域名
linestring线路,参照同目录下的 Line.txt 文件
record_typestring记录的类型,可选值为 [A, TXT, MX, CNAME, CAA]
textstring当记录类型为 [TXT, CAA] 时,需要填写此字段
ipstring当记录类型为 IP 时,需填写此字段
gatewaynumber当记录指向特定网关集群时,需填写此字段
domainstring当记录类型为域名时,需填写此字段
prioritynumber当记录类型为 MX 时,需填写此字段

返回值

  • record_id:新增的 DNS 记录的 ID。

示例

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)

此方法用于修改 DNS 记录。

参数

名称数据类型是否必需描述
record_idnumberDNS 记录的 id
sub_domainstring子域名
linestring线路,参考同目录下的 Line.txt 文件
record_typestring记录的类型,可选值包括 [A, TXT, MX, CNAME, CAA]
textstring当记录类型为 [TXT, CAA] 时,需填写该字段
ipstring当记录类型为 IP 时,需填写该字段
domainstring当记录类型为域名时,需填写该字段
prioritynumber当记录类型为 MX 时,需填写该字段

返回值

  • True:表示成功。
  • False:表示失败。

示例

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)

此方法用于获取 DNS 记录。

参数

名称数据类型是否必须描述
record_idnumberDNS 记录的 id

返回值

  • data:返回一个 dict 类型的 DNS 记录信息。

示例

如需获取 record_id 为 1 的 DNS 记录信息,可以参考以下步骤。

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)

此方法用于删除 DNS 记录。

参数

参数名数据类型是否必选描述
record_idnumber表示 DNS 记录的 id

返回值

  • 若成功删除,则返回 True。
  • 若删除失败,则返回 False。

示例

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)

在该示例中,我们首先创建了一个 Edge2Client 客户端,并用特定的主机,用户名和密码进行登录。然后,我们选择使用具有特定 id 的 DNS 应用。最后,我们尝试使用该客户端删除具有特定 id 的 DNS 记录,并将结果保存在 ok 中。


new_global_upstream

up_id = new_global_upstream(**kwargs)

此方法用于新增上游,并返回新创建的全局上游的 id。

参数

名称数据类型是否必须描述
namestring上游的名称
serverslist上游的详细信息
sslbool是否启用 HTTPS 协议,默认为 False
health_checkerdict健康检查的详细配置项,默认为 None
gidarray用户组的 id 列表,例如[1]

返回值

  • up_id:新建上游的 ID。

示例

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)

此方法用于更新全局上游信息。

参数

名称数据类型是否必须描述
namestring上游名称
serverslist上游信息列表
sslbool是否使用 HTTPS 协议,默认值为 False
health_checkerdict健康检查的详细配置,默认值为 None
gidarray用户组 id 列表,示例:[1]

返回值

  • True:操作成功。
  • False:操作失败。

示例

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)

此方法用于获取全局上游信息。

参数

名称数据类型是否必需描述
up_idstring上游的 ID

返回值

  • True:当获取信息成功时。
  • False:当获取信息失败时。

示例

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)

此方法用于删除全局上游。

参数

名称数据类型是否必选描述
up_idstring上游的唯一识别 ID

返回值

  • True:表示删除成功。
  • False:表示删除失败。

示例

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()

此方法用于获取全部的上游信息。

返回值

  • upstreams:返回一个包含所有全局上游信息的 list 类型变量。

示例

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)

此方法用于创建新的全局 Kubernetes 上游,并返回新创建的上游的 ID。

参数

名称数据类型是否必填参数描述
namestring定义上游的名称
k8s_serviceslist提供 k8s 服务的详细信息
sslbool定义是否使用 HTTPS 协议,默认值为 False
health_checkerdict对上游的健康状况进行检查的详细配置,默认值为 None
gidarray用户组 ID 列表,例如:[1]

返回值

  • up_id: 新创建的 k8s 上游的 ID。

示例

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)

此方法用于修改全局 Kubernetes 上游的信息。

参数

名称数据类型是否必选描述
namestring定义上游名称
k8s_serviceslist当上游是 Kubernetes 服务时的信息
sslbool是否采用 HTTPS 协议,默认值为 False
health_checkerdict对健康检查的详细配置,默认值为 None
gidarray用户组 id 列表,如 [1]

返回值

  • True:表示修改成功。
  • False:表示修改失败。

示例

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)

此方法用于获取全球 Kubernetes 上游的信息。

参数

名称数据类型是否必须描述
up_id字符串上游的唯一识别 ID

返回值

  • data:返回一个包含 Kubernetes 上游信息的字典类型值。

示例

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)

此方法用于删除全局 k8s 上游。

参数

名称数据类型是否必选参数描述
up_idstring上游的唯一标识 ID

返回值

  • 如果删除成功,返回 True。
  • 如果删除失败,返回 False。

示例

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()

此方法用于获取所有的 Kubernetes 上游信息。

返回值

  • upstreams:返回 Kubernetes 上游信息的列表。

示例

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)

用于添加全局 SSL 证书。

参数

参数名类型是否必需描述
key字符串私钥内容
cert字符串服务器证书内容
ca_chain字符串CA 链证书内容

返回值

  • cert_id:新建全局证书的 ID。

示例

以下示例展示了如何上传本地的 key.pemcert.pem 文件以创建全局证书。

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)

此方法用于修改全局 SSL 证书。

参数

参数名类型是否必要描述
cert_id数字证书的 id
key字符串私钥的内容
cert字符串证书的内容
ca_chain字符串CA 链的内容

返回值

  • True:表示成功。
  • False:表示失败。

示例

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)

此方法用于获取与 cert_id 相关联的 SSL 证书信息。

参数

名称类型是否必需描述
cert_idnumber证书的唯一标识符 id

返回值

  • data:返回一个 dict 类型数据,其中包含了全局证书的所有信息。

示例

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)

此方法用于删除指定的全局 SSL 证书。

参数

名称数据类型是否必选描述信息
cert_idnumber将被删除的证书的 id

返回值

  • True:表示删除成功。
  • False:表示删除失败。

示例

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)

此方法用于新增全局用户。

参数

名称数据类型是否必须描述
namestring需要新增的全局用户名
pwdstring对应的全局用户密码
gidarray包含用户组 id 的列表,如 [1]

返回值

  • uid:新增的全局用户的唯一识别 ID。

注意:全局用户的 ID 与应用级别的用户 ID 需要区分。

示例

以下示例展示了如何创建一个名为 global_demo_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)

此方法用于根据用户名搜索全球用户信息。

参数

参数名数据类型是否必选描述
namestring全球的用户名

返回值

  • user_info:dict 类型,包含搜索到的用户信息及其相关权限信息。

示例

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)

本函数用于获取所有全局用户的信息。

参数

名称数据类型是否必填描述
detailnumber取值为 0 或 1,用于指示是否返回用户的详细信息

返回值

  • data:返回一个 list 类型的数据,其每一个元素均为 dict 类型,包含对应全局用户的信息。

示例

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)

此方法用于新增全局规则。

参数

名称数据类型是否必选描述
condition列表规则触发的条件
conseq字典 或 列表规则所包含的动作
gid列表用户组的 ID 列表

返回值

  • rule_id:成功创建的全局规则的 ID。

示例

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)

此方法用于修改全局规则。

参数

参数名数据类型是否必选描述
rule_idnumber规则的唯一标识
conditionlist定义规则的条件
conseqdict or list规定规则的行动
gidlist用户组的 id 列表

返回值

  • True:表示成功。
  • False:表示失败。

示例

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)

此方法用于获取全局规则信息。

参数

名称数据类型是否必选描述
rule_idnumber规则的唯一标识符 id

返回值

  • data:返回值是一个dict类型,包含全局规则的详细信息。

示例

from edge2client import Edge2Client

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

rule_id = 1

data = client.get_global_rule(rule_id)

这个示例展示了如何使用 Edge2Client 的实例获取特定 id 的全局规则信息。


get_global_action_by_name

rule_id = get_global_action_by_name(name)

此方法用于根据给定的应用名来获取相应的全局自定义动作。

参数

参数名数据类型是否必须描述
namestring规则名称

返回值

  • data:返回一个包含全局规则信息的 dict 类型数据。

示例

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()

此方法用于获取所有的全局规则。

返回值

  • data:这是一个 list 类型的全局规则信息列表。

示例

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)

此方法用于删除全局规则。

参数

参数名数据类型是否必选描述
rule_idnumber规则的唯一标识符

返回值

  • 返回 True:表示规则成功删除。
  • 返回 False:表示规则删除失败。

示例

from edge2client import Edge2Client

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

rule_id = 1

ok = client.del_global_rule(rule_id)

此示例展示了如何使用 Edge2Client 对象的 del_global_rule 方法来删除指定的全局规则。


new_global_var

var_id = new_global_var(**kwargs)

此方法用于新增全局变量。

参数

名称数据类型是否必须描述
namestring定义的变量名称
var_typestring指定的变量类型
defaultstring设置的默认值
gidlist用户组 id 数组

返回值

  • var_id:若创建成功,则返回新建变量的 ID。

示例

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)

此方法用于修改全局变量。

名称数据类型是否必须描述
var_idnumber变量的唯一标识符
namestring变量的名称
var_typestring变量的数据类型
defaultstring变量的默认值
gidlist用户组的 ID 列表

返回值

  • True:表示全局变量修改成功。
  • False:表示全局变量修改失败。

示例

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])

在此示例中,我们首先创建了一个 Edge2Client 对象并进行登录。然后,使用 put_global_var() 函数,通过指定对应的参数,修改 ID 为 1 的全局变量名称为’is-whitelist’,类型为’string’,默认值为’yes’,并将其关联到 ID 为 1 的用户组。


get_global_var

data = get_global_var(var_id)

此方法用于获取全局变量。

参数

参数名数据类型是否必须描述
var_idnumber全局变量 id

返回值

  • data:返回值为一个 dict 类型,包含全局变量的信息。

示例

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()

此方法用于获取所有全局变量。

返回值

  • data:此为一个 list 类型的对象,其中每一个元素都是一个 dict 类型,包含了全局变量的相关信息。

示例

from edge2client import Edge2Client

client = Edge2Client(host, username, password) # 创建一个 Edge2Client 实例
client.login() # 登陆

data = client.get_all_global_vars() # 获取所有全局变量

del_global_var

ok = del_global_var(var_id)

此方法用于根据全局变量的 ID 进行删除操作。

参数

| 名称 | 数据类型 | 是否必须 | 描述信息 | | var_id | number | 是 | 指定需要删除的全局变量的 ID |

返回值

  • True:表示删除成功。
  • False:表示删除失败。

示例

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()

此方法用于获取全局的 nginx 配置信息。

返回值

  • data:返回一个dict类型的全局 ngx 配置信息。

示例

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)

此方法设定全局的 nginx 配置信息。

参数

名称数据类型是否必选描述
access_log_buffernumber访问日志的缓冲区大小
access_log_buffer_unit[‘k’, ’m’, ‘g’]访问日志缓冲区大小的单位
access_log_flushnumber访问日志在内存中的最大保留时间
enable_access_logbool是否启用访问日志
access_log_formatsdict访问日志的格式
avoid_gen_error_logbool是否避免生成错误日志
client_body_timeoutnumber客户端请求体的超时时间
client_body_timeout_unit[’s’, ’m’]客户端请求体超时时间的单位
client_header_timeoutnumber客户端请求头的超时时间
client_header_timeout_unit[’s’, ’m’]客户端请求头超时时间的单位
client_max_body_sizenumber客户端请求体的最大尺寸
client_max_body_size_unit[‘k’, ’m’]客户端请求体最大尺寸的单位
client_header_buffer_sizenumber客户端请求头缓冲区的大小
client_header_buffer_size_unit[‘k’, ’m’]客户端请求头缓冲区大小的单位
max_client_request_line_sizenumber客户端请求行的最大尺寸
max_client_request_header_size[‘k’, ’m’]客户端请求头的最大尺寸

access_log_formats 参数

名称数据类型是否必选描述
defaultbool设置该日志格式是否为默认格式。注意:配置中至少需要一个默认的日志格式
namestring该访问日志格式的名称,需要全局唯一
formatstring该访问日志的格式,需按照 nginx log_format 指令设定

返回值

  • True:设定成功。
  • False:设定失败。

示例

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()

此方法用于获取全局的杂项配置信息。

返回值

  • data:返回一个 dict 类型,其中包含了杂项的配置信息。

示例

from edge2client import Edge2Client

# 创建客户端并登陆
client = Edge2Client(host, username, password)
client.login()

# 获取全局杂项配置信息
data = client.get_global_misc_config()

set_global_misc_config

ok = set_global_misc_config(opts)

此方法用于设定全局杂项配置信息。

参数

| 参数名 | 数据类型 | 是否必须 | 描述 | | opts | 字典类型(dict) | 否 | 杂项(misc)配置项 |

返回值

  • True:表示设定成功。
  • False:表示设定失败。

示例

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()

此方法用于查询请求 id 的状态。

返回值

  • True:表示请求 id 已启用。
  • False:表示请求 id 已禁用。

示例

from edge2client import Edge2Client

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

status = client.get_request_id_status()

enable_request_id

ok = enable_request_id()

这个方法用于激活请求 id 功能。

返回值

  • True:表示激活成功。
  • False:表示激活失败。

示例

from edge2client import Edge2Client

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

ok = client.enable_request_id()

disable_request_id

ok = disable_request_id()

此方法用于禁用请求 ID 功能。

返回值

  • True:表示请求 ID 功能成功被禁用。
  • False:表示请求 ID 功能禁用失败。

示例

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)

此方法用于新增全局 WAF 规则。

参数

参数名数据类型是否必填描述
namestring指定的规则名称
codestring对应规则的 edge 语言代码

返回值

  • rule_id:返回新创建的全局 WAF 规则集的唯一 ID。

示例

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');")

在这个例子中,我们首先创建了一个 Edge2Client 实例,然后使用 new_global_waf_rule 方法创建了一个新的全局 WAF 规则,并将其规则 ID 存储在 waf_rule_id 中。规则名称为 ‘foo’,edge 语言代码为 “uri-arg(‘foo’) => waf-mark-risk(level: ‘definite’, msg: ‘found foo’);"。


put_global_waf_rule

ok = put_global_waf_rule(**kwargs)

此方法用于修改全局 WAF 规则。

参数

名称数据类型是否必选描述
rule_idnumber规则的唯一标识符 id
namestring规则的名称
codestring规则的 edge 语言脚本

返回值

  • True:表示修改成功。
  • False:表示修改失败。

示例

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');")

在此示例中,我们通过 put_global_waf_rule 函数修改了 id 为 1 的全局 WAF 规则。


get_global_waf_rule

data = get_global_waf_rule(rule_id)

此方法通过提供的规则集 ID(rule_id)来获取全局的 WAF 规则集。

参数

| 名称 | 数据类型 | 是否必选 | 描述信息 | | rule_id | number | 是 | WAF 规则集的唯一标识符 |

返回值

  • data:返回一个包含 WAF 规则集详细信息的字典。

示例

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)

此方法用于删除全局 WAF 规则。

参数

| 名称 | 数据类型 | 是否必选 | 描述 | | rule_id | number | 是 | 规则集的 ID |

返回值

  • True:删除成功。
  • False:删除失败。

示例

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)

此方法用于获取所有全局 WAF 规则。

参数

名称数据类型是否必选描述
detailbool表示是否展示规则的详细信息,默认值为 False

返回值

  • data:返回一个 list 类型的 WAF 规则集信息。

示例

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)

此方法用于添加新的全局自定义动作。

参数

名称数据类型是否必填描述
namestring自定义动作的名称
conditionlist自定义动作执行的条件
conseqdict or list执行的自定义动作
gidlist用户组的 id 列表

返回值

  • rule_id:返回新创建的全局自定义动作的 ID。

示例

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)

此方法用于修改全局自定义动作。

参数

参数数据类型是否必选描述
action_idnumber自定义动作的 id
namestring自定义动作的名称
conditionlist自定义动作的执行条件
conseqdict or list自定义动作的结果
gidlist用户组 id 列表

返回值

  • True:代表操作成功。
  • False:代表操作失败。

示例

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)

此方法用于获取全局自定义动作。

参数

名称数据类型是否必选描述信息
action_idnumber自定义动作的 id

返回值

  • data:返回的数据为字典类型,包含全局自定义动作的相关信息。

示例

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)

此方法用于删除指定的全局自定义动作。

参数

名称数据类型是否必选描述信息
action_idnumber自定义动作的 id

返回值

  • 返回 True:表示删除成功。
  • 返回 False:表示删除失败。

示例

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()

此方法用于获取全局自定义动作的总数。

返回值

  • count:返回全局自定义动作的总数。

示例

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()

此方法用于获取所有全局自定义动作。

参数

名称数据类型是否必选描述信息
pagenumber表示页数
pagesizenumber表示每页显示的条目数量

返回值

  • data:返回一个包含所有全局自定义动作信息的列表。

示例

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)

此方法用于上传静态文件。

参数

名称数据类型是否必选描述
contentstring静态文件的内容
labelstring静态文件的标签
file_typestring静态文件的类型
gidlist用户组 id 列表

返回值

  • file_id:返回新上传的静态文件的 ID。

示例

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)

此方法用于获取指定的静态文件配置。

参数

参数名数据类型是否必需描述
file_idnumber需要获取的静态文件的 ID

返回值

  • data:返回一个 dict 类型的对象,包含所获取的静态文件的信息。

示例

from edge2client import Edge2Client

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

file_id = 1

data = client.get_static_file(file_id)

在这个示例中,我们首先从 edge2client 模块导入了 Edge2Client 类,然后创建了一个 Edge2Client 对象并进行登录。之后,我们调用了其 get_static_file 方法,获取了 ID 为 1 的静态文件的配置信息,并将其存储在 data 变量中。


del_static_file

ok = del_static_file(file_id)

此方法用于删除已上传的静态文件。

参数

名称数据类型是否必选描述
file_idnumberyes待删除的静态文件的 ID

返回值

  • True:表示文件删除成功。
  • False:表示文件删除失败。

示例

from edge2client import Edge2Client

# 创建 Edge2Client 实例
client = Edge2Client(host, username, password)

# 登录
client.login()

# 设定要删除的文件 ID
file_id = 1

# 删除指定 ID 的静态文件
ok = client.del_static_file(file_id)

new_cluster_group

group_id = new_cluster_group(group_name)

此方法用于添加新的集群组。

参数

名称数据类型是否必须详细描述
group_namestring新增集群组的名称

返回值

  • id:返回新建的集群组的唯一标识符 ID。

示例

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)

此方法用于修改集群组信息。

参数

参数名数据类型必选描述
group_idnumber集群组的唯一标识符
group_namestring需要更改的集群组名称

返回值

  • True:表示成功修改集群组信息。
  • False:表示修改集群组信息失败。

示例

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')

此示例演示了如何使用 put_cluster_group 函数来修改具有指定 group_id 的集群组名称为 ‘bar’。


get_cluster_group

data = get_cluster_group(group_id)

此方法用于获取集群组的详细信息。

参数

名称数据类型是否必须描述
group_id数值型集群组的唯一标识符

返回值

  • data:返回一个dict类型的集群组详细信息。

示例

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()

此方法用于获取所有集群组的信息。

返回值

  • data:这是一个 list 类型,包含了所有集群组的信息。

示例

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)

此方法用于删除集群组信息。

参数

参数名数据类型是否必填描述信息
group_idnumber需要删除的集群组的编号

返回值

  • 返回 True:表示集群组信息删除成功。
  • 返回 False:表示集群组信息删除失败。

示例

from edge2client import Edge2Client

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

group_id = 1

ok = client.del_cluster_group(group_id)

在以上示例中,首先初始化一个 Edge2Client 对象并登陆,然后指定要删除的集群组的编号,并调用 del_cluster_group 方法进行删除操作。


put_proxy_rule

ok = put_proxy_rule(**kwargs)

此方法用于修改上游代理规则。

参数

名称数据类型是否必需描述
rule_idnumber规则的唯一标识符
proxylist用于定义代理规则的列表

返回值

  • True:表示规则修改成功。
  • False:表示规则修改失败。

示例

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)

此方法用于添加新的 k8s 集群连接参数。

参数

名称数据类型是否必须描述
namestringk8s 集群的名称
hoststringk8s 集群的地址
domainstringk8s 集群的域名,host 或 domain 两者必填一项且只能填一项
portnumberk8s 集群的端口
connect_timeoutnumberk8s 集群的连接超时时间,单位为秒,默认为 5 秒
read_timeoutnumberk8s 集群的读取数据超时时间,单位为秒,默认为 5 秒
ssl_verifybool是否需要进行 SSL 校验
tokenstringk8s 集群的 api token

返回值

  • k8s_id:新建立的 k8s 集群的 ID。

示例

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)

此方法用于修改 Kubernetes 集群的连接参数。

参数

名称数据类型是否必选描述
k8s_idnumberKubernetes 集群的唯一标识符
namestringKubernetes 集群的名称
hoststringKubernetes 集群的主机地址
domainstringKubernetes 集群的域名,host 或 domain 中至少需要一个,且不能同时填写
portnumberKubernetes 集群的连接端口
connect_timeoutnumberKubernetes 集群的连接超时时间,单位为秒
read_timeoutnumberKubernetes 集群的数据读取超时时间,单位为秒
ssl_verifybool是否需要进行 SSL 校验
tokenstringKubernetes 集群的 API 令牌

返回值

  • 返回 True:表示成功。
  • 返回 False:表示失败。

示例

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)

此方法用于获取 Kubernetes 集群的连接参数信息。

参数

名称数据类型是否必选描述
k8s_idnumberKubernetes 集群的唯一标识符

返回值

  • data:返回一个 dict 类型的数据,包含 Kubernetes 集群的详细信息。

示例

from edge2client import Edge2Client

# 创建一个 Edge2Client 实例
client = Edge2Client(host, username, password)

# 登录客户端
client.login()

# 使用 get_global_k8s 方法获取 Kubernetes 集群信息
data = client.get_global_k8s(k8s_id = 1)

get_k8s_service_detail

data = get_k8s_service_detail()

此方法用于获取 k8s 集群中定义的服务相关信息。

参数

名称数据类型是否必选详细描述
k8s_idnumberk8s 集群的唯一标识符

返回值

  • 返回一个 dict 类型的数据,包含 k8s 集群的详细信息。

示例

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()

此方法用于获取所有全球 Kubernetes 集群的 id。

返回值

  • data:返回一个 list 类型的 Kubernetes 集群信息。

应用示例

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)

此方法用于删除 k8s 集群的连接参数。

参数

参数名数据类型是否必选描述
k8s_idnumberk8s 集群的唯一标识符

返回值

  • True:表示删除成功。
  • False:表示删除失败。

示例

from edge2client import Edge2Client

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

ok = client.del_global_k8s(k8s_id = 1)

以上代码展示了如何使用 Edge2Client 删除特定的 k8s 集群连接参数。


update_proxy_rule

result = update_proxy_rule(**kwargs)

更新指定的上游代理规则。

参数

名称数据类型是否必选描述
rule_idnumber规则的唯一标识符
proxylist代理规则的详细信息

返回值

  • True:代表成功更新代理规则。
  • False:代表更新代理规则失败。

示例

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)

此方法用于更新全局级别的 IP 规则列表。


new_global_ip_list

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

此方法用于创建新的全球 IP 列表。

参数

名称数据类型是否必选描述
namestring要创建的全球 IP 列表的名称
typestringIP 地址的类型,当前支持 ipv4ipv6(即将推出)
itemsarray包含的 IP 地址列表

items 参数

名称数据类型是否必选描述
ipstringIP 地址

返回值

  • id:新创建的全球 IP 列表的唯一标识 ID。

示例

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'}
                               ])

put_global_ip_list

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

此方法用于修改指定的全局级别 IP 列表。

参数

名称数据类型是否必选描述
rule_idnumber指定的全局级别 IP 列表的 ID
namestring需要修改的全局级别 IP 列表的名称
typestringIP 地址的类型,目前支持 ‘ipv4’ 和即将支持的 ‘ipv6’
itemsarray待修改的 IP 地址列表

返回值

  • True:表明修改成功。
  • False:表明修改失败。

示例

from edge2client import Edge2Client

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

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

del_global_ip_list

ok = del_global_ip_list(rule_id=None)

此方法用于删除指定的全局 IP 列表。

参数

参数名数据类型是否必选描述
rule_idnumber需要删除的全局 IP 列表的 ID

返回值

  • True:表示删除成功。
  • False:表示删除失败。

示例

from edge2client import Edge2Client

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

ok = client.del_global_ip_list(rule_id=1)

get_global_ip_list

data = get_global_ip_list(rule_id=None)

此方法用于获取指定的全局 IP 列表。

参数

名称数据类型是否必选描述
rule_idnumber用于指定全局级别 IP 列表的 ID

返回值

  • data:返回一个dict 类型的 IP 列表信息。

示例

from edge2client import Edge2Client

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

data = client.get_global_ip_list(rule_id=1)

new_user_var

var_id = new_user_var(**kwargs)

这是一个用于新增用户级别变量的函数。

参数

名称数据类型是否必选描述信息
namestring变量的名称
var_typestring变量的类型
defaultstring变量的默认值

返回值

  • id:返回新建的用户级别变量的唯一 ID。

示例

from edge2client import Edge2Client

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

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

put_user_var

ok = put_user_var(**kwargs)

此方法用于修改用户级别的变量。

参数

名称数据类型是否必选详细描述
var_idnumber表示变量的唯一标识
namestring代表变量的名称
var_typestring描述变量的类型
defaultstring定义变量的默认值

返回值

  • True:表示成功修改用户级别的变量。
  • False:表示修改用户级别的变量失败。

示例

from edge2client import Edge2Client

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

var_id = 1

ok = client.put_user_var(var_id=var_id,
                         name='is-whitelist',
                         var_type='string',
                         default='yes')

请注意,此示例会将名为 ‘is-whitelist’ 的变量的值设置为 ‘yes’。


get_user_var

data = get_user_var(var_id)

此方法用于获取用户级别的变量。

参数

名称数据类型是否必选描述
var_idnumber变量的唯一标识符

返回值

  • data:返回一个dict 类型,包含用户变量的详细信息。

示例

from edge2client import Edge2Client

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

var_id = 1

data = client.get_user_var(var_id)

del_user_var

ok = del_user_var(var_id)

此方法用于删除用户级别的变量。

参数

名称数据类型是否必填描述信息
var_idnumber要删除的变量 id

返回值

  • True:删除变量成功。
  • False:删除变量失败。

示例

from edge2client import Edge2Client

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

var_id = 1

ok = client.del_user_var(var_id)

在这个示例中,我们首先从 edge2client 模块导入 Edge2Client。然后,我们创建一个 Edge2Client 实例,并用它登录。最后,我们试图删除 var_id 为 1 的用户级别变量。


decode_request_id

data = decode_request_id(request_id)

此方法用于解码 request_id 以获取诸如 app_id 等信息。

参数

| 名称 | 数据类型 | 是否必选 | 描述 | | request_id | 字符串 | 是 | 请求 ID |

返回值

  • data:返回一个 字典 类型的数据,其中包含处理请求的网关、应用等信息。

示例

from edge2client import Edge2Client

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

data = client.decode_request_id('00000a00000c0826c9803222')

print(data)

search_waf_log

data = search_waf_log(request_id)

此方法用于通过请求 id 获取 WAF 日志。

参数

参数数据类型必选描述
request_idstring请求的唯一标识符

返回值

  • data:返回一个 dict 类型的 WAF 日志信息。

示例

from edge2client import Edge2Client

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

request_id = "0000008000042c421ea80011"

data = client.search_waf_log(request_id)

这个示例展示了如何使用 Edge2Client 实例来调用 search_waf_log 函数并获取 WAF 日志。


get_version

data = get_version()

此方法用于获取 Admin、Admin DB、Log Server、Log Server DB 及 WAF 的版本信息。

返回值

  • data:返回一个dict 类型,包含了版本信息。

示例

from edge2client import Edge2Client

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

data = client.get_version()

add_api_token

data = add_api_token(name=None, expire=0)

此方法用于生成 API Token。

参数

名称数据类型是否必选描述
namestringAPI Token 的名称
expirenumberAPI Token 的过期时间

返回值

  • data:返回一个 dict 类型,包含 API Token 的详细信息。

示例

from edge2client import Edge2Client

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

data = client.add_api_token("name", 0)

get_api_token

data = get_api_token(id=None, limit=20)

此方法用于获取 API 令牌。

参数

参数名数据类型是否必需描述
idnumberAPI 令牌的标识
limitnumber返回结果的数量限制

返回值

  • data:以 dict 类型返回 API 令牌的信息。

示例

from edge2client import Edge2Client

# 创建客户端并登录
client = Edge2Client(host, username, password)
client.login()

# 获取指定 id 的 API 令牌
data = client.get_api_token(id)

# 获取数量限制在 100 以内的 API 令牌
data = client.get_api_token(None, 100)

del_api_token

ok = del_api_token(id)

此方法用于删除一个指定的 API Token。

参数

参数数据类型是否必选描述
idnumberapi token 的标识

返回值

  • 返回 True:表示 API Token 删除成功。
  • 返回 False:表示 API Token 删除失败。

示例

from edge2client import Edge2Client

# 创建 Edge2Client 实例
client = Edge2Client(host, username, password)

# 登录
client.login()

# 删除指定的 API Token
data = client.del_api_token(id)

get_all_gateway_tag

tags = get_all_gateway_tag()

此方法用于获取所有网关集群的标签。

返回值

  • data:返回一个包含所有网关标签信息的 list 类型。

示例

from edge2client import Edge2Client

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

tags = client.get_all_gateway_tag()

for i, tag in enumerate(tags):
    print(i, tag)

get_all_gateway

gateways = get_all_gateway()

此方法用于获取所有网关集群的信息。

返回值

  • data:返回一个 list 类型,包含所有网关的详细信息。

示例

from edge2client import Edge2Client

client = Edge2Client(host, username, password)  # 创建并初始化 Edge2Client 实例
client.login()  # 登录到服务器

gateways = client.get_all_gateway()  # 获取所有网关集群信息

# 循环打印所有网关信息
for i, gateway in enumerate(gateways):
    print(i, gateway)

add_gateway

id = add_gateway(name, partition_id, tag=None)

此方法用于创建新的网关集群。

参数

参数数据类型是否必选描述
namestring网关集群的名称
partition_idstring所创建的网关集群所属的网关分区 ID
tagarray用于标记所创建网关集群的标签

返回值

  • id:返回新创建的网关集群的唯一 ID。

示例

from edge2client import Edge2Client

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

default_partition_id = 1
id = client.add_gateway('my-cluster', default_partition_id)

del_gateway

ok = del_gateway(gateway_id)

此方法用于删除指定的网关集群。

参数

参数数据类型是否必选描述
gateway_idstring要删除的网关集群的唯一标识符

返回值

  • True:表示网关集群删除成功。
  • False:表示网关集群删除失败。
true

示例

from edge2client import Edge2Client

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

gateway_id = 1
ok = client.del_gateway(gateway_id)

在这个示例中,我们首先使用 Edge2Client 创建了一个客户端,然后登录。接着,我们尝试删除 ID 为 1 的网关集群,并将结果存储在变量 ok 中。


get_all_nodes

nodes = get_all_nodes()

此方法用于获取所有的网关节点。

返回值

  • data:此返回值是一个list类型,包含了所有网关节点(服务器)的相关信息。

示例

from edge2client import Edge2Client

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

nodes = client.get_all_nodes()

for i, node in enumerate(nodes):
    print(i, node)

get_node

node = get_node(node_id, gateway_id=None)

此方法根据提供的节点 ID 获取相应的节点信息。

参数

名称数据类型是否必选描述
node_idnumber节点的唯一标识符 (ID)
gateway_idnumber网关集群的唯一标识符 (ID),未指定时,将通过遍历来查找对应的节点

返回值

  • 返回值为 dict 类型,包含了网关节点的相关信息。

示例

from edge2client import Edge2Client

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

node = client.get_node(1)  # 获取节点 ID 为 1 的节点信息
node = client.get_node(1, gateway_id=1)  # 在网关集群 ID 为 1 的范围内,获取节点 ID 为 1 的节点信息

get_node_by_mac_address

node = get_node_by_mac_address(mac_address)

此方法用于根据节点的硬件 ID 来检索节点的详细信息。

参数

参数名数据类型是否必选描述内容
mac_addressstring该节点的特定 MAC 地址

返回值

  • node:返回一个 dict 类型的网关节点详细信息。
{
    "mac_address": "46:b1:5f:1d:fa:ea",
    "serial": "2655388572",
    "is_limited": false,
    "config": {
        "enable_qat": false
    },
    "name": "test-edge-node-75c5bf6969-65tgg\n",
    "id": 11,
    "external_ip": "172.20.0.2",
    "sync_status_utime": 0,
    "online_status": true,
    "internal_ip": "10.244.0.6",
    "hardware_id": "a11abe66fe25be7941bda81c3f358344",
    "is_healthy": true,
    "status": 1,
    "gateway_id": 14
}

示例

from edge2client import Edge2Client

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

node = client.get_node_by_mac_address("e2:d1:d9:e0:c4:6e")

put_node

ok = put_node(node_id, gateway_id=None, **kwargs)

This method is used for updating node information.

Parameters

NameData TypeRequiredDescription
node_idnumberYesID of the node
gateway_idnumberNoCluster ID of the gateway. If not specified, the corresponding node will be located by traversing
namestringNoName of the node
is_grayboolNoSet/unset the node as a gray node
statusnumberNo0: Disable DNS, enable cluster cache, 1: Enable DNS, enable cluster cache, 2: Disable DNS, disable cluster cache
external_ipstringNoPublic IP address
external_ipv6stringNoPublic IPv6 address
internal_ipstringNoInternal IP address

Return Value

  • True: If the operation is successful.
  • False: If the operation fails.

Example

from edge2client import Edge2Client

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

node_id=1
gateway_id=1
ok = self.client.put_node(node_id, \
    gateway_id=gateway_id, name='test', \
    is_gray=False, status=1, external_ip='127.0.0.1', \
    external_ipv6='::1', internal_ip='127.0.0.1')

del_node

node = del_node(node_id, gateway_id=None)

此方法用于根据节点 ID 删除指定节点。

参数

参数名数据类型是否必选描述
node_idnumber要删除的节点的 ID
gateway_idnumber网关集群的 ID。如果未指定,系统将遍历查找对应的节点

返回值

  • True:表示删除成功。
  • False:表示删除失败。
true

示例

from edge2client import Edge2Client

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

success = client.del_node(1)
success = client.del_node(1, gateway_id=1)

lmdb_backup

ok = lmdb_backup()

此方法用于触发 LMDB 的备份。如果备份成功,方法将返回 True。如果备份失败,则返回一个包含失败 Node 节点的 dict 信息,其中 key 是 Node ID,value 是失败的原因。

您可以通过调用 node_sync_status 接口来确认备份是否成功。如果该接口中节点的 backup_time 大于 lmdb_backup() 方法的调用时间,那么可以认为该节点的备份已成功执行。

返回值

  • True:表示备份成功。
  • False:表示备份失败。

示例

from edge2client import Edge2Client

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

result = self.client.lmdb_backup()

get_global_cert_referenced

result = get_global_cert_referenced(id)

此方法用于获取使用了指定全局证书的应用列表。

参数

名称数据类型是否必选描述
idnumber全局证书 ID

返回值

  • data:返回一个包含应用信息的list类型。

示例

from edge2client import Edge2Client

client = Edge2Client(host, username, password)
client.login()
global_cert_id = 1
result = client.get_global_cert_referenced(global_cert_id)

get_all_partition_lua_module

data = get_all_partition_lua_module(partition_id)

此方法用于获取指定分区的所有 Lua 模块。

参数

名称数据类型是否必选描述
partition_idnumber分区的唯一标识符 ID

返回值

  • data:返回一个列表(list),包含了所查询分区的全部 Lua 模块信息。

示例

from edge2client import Edge2Client

client = Edge2Client(host, username, password)
client.login()
partition_id = 1
result = client.get_all_partition_lua_module(partition_id)

get_partition_lua_module

data = get_partition_lua_module(partition_id, module_id)

此方法用于获取指定分区中的指定 lua 模块。

参数

参数名数据类型是否必需描述
partition_idnumber分区 ID
module_idnumber模块 ID

返回值

  • data:返回一个 dict 类型的全局 Lua 模块信息。

示例

from edge2client import Edge2Client

client = Edge2Client(host, username, password)
client.login()
partition_id = 1
module_id = 1
result = client.get_partition_lua_module(partition_id, module_id)

new_partition_lua_module

data = new_partition_lua_module(partition_id, name, code)

此方法用于向指定分区添加一个新的 Lua 模块。

参数

名称数据类型是否必选描述
partition_idnumber分区 ID
namestring模块名称
codestring模块代码

返回值

  • data:返回一个字典类型的数据,包含新建的 Lua 模块的 ID。

示例

from edge2client import Edge2Client

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

partition_id = 1
name = "example"
code = """
local _M = {}
return _M
"""
result = client.new_partition_lua_module(partition_id, name, code)

put_partition_lua_module

ok = put_partition_lua_module(partition_id, module_id, name, code)

此方法用于编辑指定分区的特定 lua 模块。

参数

名称数据类型是否必须详细描述
partition_idnumber分区的 ID
module_idnumber模块的 ID
namestring模块的名称
codestring模块的代码

返回值

  • True:表示操作成功。
  • False:表示操作失败。

例如:

true

示例

from edge2client import Edge2Client

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

partition_id = 1
module_id = 1
name = "example"
code = """
local _M = {}
return _M
"""
result = self.client.put_partition_lua_module(partition_id, module_id, name, code)

del_partition_lua_module

result = del_partition_lua_module(partition_id, module_id)

此方法用于删除指定分区内的特定 lua 模块。

参数

名称数据类型是否必要描述
partition_idnumber分区 ID
module_idnumber模块 ID

返回值

  • 若成功则返回 True。
  • 若失败则返回 False。

示例

from edge2client import Edge2Client

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

partition_id = 1
module_id = 1
result = self.client.del_partition_lua_module(partition_id, module_id)

conv_crl_to_lua_module

code = conv_crl_to_lua_module(crl_files)

此方法用于将 CRL 文件转换为 Lua 模块。

参数

参数名数据类型是否必须描述
crl_filesarrayCRL 文件数组

返回值

  • code:转换完成后的 Lua 模块代码。

示例

import sys

from edge2client import Edge2Client

client = Edge2Client('https://your-admin-addr', 'your-admin-user', 'your-admin-password')

crl_files = ["~/test.crl"]
code = client. conv_crl_to_lua_module(crl_files)

client.login()

partition_id = 1
name = "crl_test.com"

result = client.new_partition_lua_module(partition_id, name, code)
mod_id = result["id"]

result = client.put_partition_lua_module(partition_id, mod_id, name, code)
print(result)

get_all_candidate_node

nodes = get_all_candidate_node()

此方法用于获取所有待批准的节点,随后可以通过调用 approve_candidate_node 接口来将这些节点批准加入到指定的集群。

返回值

  • nodes:返回的是一个 list 类型,包含所有候选网关节点的详细信息。

例如:

[
    {
        "priv_hash": "0ab3a37cfea7d044c93a46712053a081",
        "external_ipv6": "",
        "external_ip": "172.20.0.2",
        "hostname": "test-edge-node-75c5bf6969-65tgg\n",
        "client_city": "/",
        "internal_ip": "10.244.0.3",
        "os": "Linux\n3.10.0-1127.19.1.el7.x86_64\n",
        "hardware_id": "3e20ff1b92ca06e03b2ab0d877687662",
        "mac_address": "9e:18:28:f5:1b:d5",
        "csr": "..."
    }
]

示例

from edge2client import Edge2Client

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

nodes = client.get_all_candidate_node()

approve_candidate_node

ok = approve_candidate_node(gateway_id, mac_address, internal_ip=None, external_ip=None, name=None, external_ipv6=None, status=1)

此方法用于批准 MAC 地址为 mac_address 的节点加入到 ID 为 gateway_id 的网关集群。

参数

参数名数据类型是否必需描述
gateway_idnumber网关集群的 ID,未指定时将通过遍历方式查找对应节点
mac_addressstring节点的 MAC 地址
internal_ipstring节点的内部 IPv4 地址
external_ipstring节点的外部 IPv4 地址
namestring节点的名称,若未命名则默认使用主机名
external_ipv6string节点的外部 IPv6 地址
statusstring节点状态,0 代表禁用,1 代表启用,2 代表断开(禁用 DNS 和禁用集群内缓存共享)

返回值

  • True:批准成功。
  • False:批准失败。

示例

以下示例说明如何批准主机名称为 “new-edge-node” 的节点加入到 ID 为 1 的网关集群。

from edge2client import Edge2Client

client = Edge2Client(host, username, password)
client.login()
def first_address(addrs):
    return addrs.split(' ')[0]

gateway_id=1
nodes = client.get_all_candidate_node()
for i, node in enumerate(nodes):
    if nodes.get('hostname') == "new-edge-node":
        ok = client.approve_candidate_node(gateway_id, first_address(nodes.get('mac_address')))
        break

get_waf_logs

data, count = get_waf_logs(app_id, page=1, pagesize=20, request_id=None,
                  start_time=None, end_time=None, host=None, header=None,
                  rule_set_id=None, resp_status=None, action=None,
                  remote_addr=None, show_all=False)

此方法用于检索指定应用的 WAF 日志。

参数

参数名数据类型是否必需描述
app_idnumberHTTP 应用的 ID
pagenumber指定要检索的页码
pagesizenumber指定每页的日志数量
request_idstring根据特定的请求 ID 检索日志
start_timenumber根据特定的时间范围检索日志,开始时间为 Unix 时间戳,单位是秒
end_timenumber根据特定的时间范围检索日志,结束时间为 Unix 时间戳,单位是秒
hoststring根据特定的 host 检索日志
headerstring根据特定的请求头信息检索日志
rule_set_idnumber根据特定的规则集 ID 检索日志
resp_statusnumber根据特定的 HTTP 响应状态码检索日志
actionstring根据特定的动作检索日志,取值 log, block, edge-captcha, hcaptcha, redirect, page-template, close-connection, redirect-validate, js-challenge
remote_addrstring根据特定的客户端地址检索日志
show_allbool标识是否获取所有日志,当为 False 时,不返回未达到阈值的日志,为 True 时,无论阈值大小均返回

返回值

  • data: 此次检索到的日志列表,list 类型。
  • count: 日志的总数量,注意这不是此次检索到的日志数量。

示例

from edge2client import Edge2Client

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

page = 1
while True:
    logs, count = get_waf_logs(app_id, page=page, pagesize=10,
                                start_time=1698888000,
                                end_time=1699988000)

    if logs is None:
        break

    if len(logs) <= 0:
        break

    for log in logs:
        print(log)

    page = page + 1

get_dos_logs

data, count = get_dos_logs(app_id, page=1, pagesize=20, request_id=None,
                     start_time=None, end_time=None, host=None, uri=None,
                     user_agent=None, action=None, remote_addr=None):

此方法用于检索指定应用的 CC 日志。

参数

参数名数据类型是否必需描述
app_idnumberHTTP 应用的 ID
pagenumber指定要检索的页码
pagesizenumber指定每页的日志数量
request_idstring根据特定的请求 ID 检索日志
start_timenumber根据特定的时间范围检索日志,开始时间为 Unix 时间戳,单位是秒
end_timenumber根据特定的时间范围检索日志,结束时间为 Unix 时间戳,单位是秒
hoststring根据特定的 host 检索日志
uristring根据特定的 URI 信息检索日志
user_agentnumber根据特定的 User Agent 检索日志
actionstring根据特定的动作检索日志,取值 close_connection, error_page, enable_hcaptcha, enable_edge_captcha, redirect_validate, js_challenge, delay
remote_addrstring根据特定的客户端地址检索日志

返回值

  • data: 此次检索到的日志列表,list 类型。
  • count: 日志的总数量,注意这不是此次检索到的日志数量。

示例

from edge2client import Edge2Client

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

page = 1
while True:
    logs, count = get_dos_logs(app_id, page=page, pagesize=10,
                                start_time=1698888000,
                                end_time=1699988000)

    if logs is None:
        break

    if len(logs) <= 0:
        break

    for log in logs:
        print(log)

    page = page + 1

get_global_page_template

data = get_global_page_template(id)

此方法用于获取指定的全局页面模板。

参数

参数名数据类型是否必需描述
idnumber全局页面模板的 ID

返回值

  • data: 此次检索到的全局页面模板,dict 类型。

示例

from edge2client import Edge2Client

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

data = client.get_global_page_template(id)

get_all_global_page_templates

data = get_all_global_page_templates()

此方法用于获取所有的全局页面模板。

返回值

  • data: 此次检索到的全局页面模板列表,list 类型。

示例

from edge2client import Edge2Client

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

templates = client.get_all_global_page_templates()
for t in templates:
    print(t)

del_global_page_template

ok = del_global_page_template(id)

此方法用于删除指定的全局页面模板。

参数

参数名数据类型是否必需描述
idnumber全局页面模板的 ID

返回值

  • True:删除成功。
  • False:删除失败。

示例

from edge2client import Edge2Client

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

ok = client.del_global_page_template(id)

new_global_page_template

id = new_global_page_template(name, content)

此方法用于创建新的全局页面模板。

参数

参数名数据类型是否必需描述
namestring全局页面模板的名称
contentstring全局页面模板的内容

返回值

  • id:返回新建的全局页面模板的唯一 ID。

示例

from edge2client import Edge2Client

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

name = "default"
content = """
<!doctype html>
<html>
<head>
  <title>404 NOT FOUND</title>
</head>
<body>
  ::CLIENT_IP::
</body>
</html>
"""
id = client.new_global_page_template(name=name, content=content)

put_global_page_template

ok = put_global_page_template(id, name=None, content=None)

此方法用于更新指定的全局页面模板。

参数

参数名数据类型是否必需描述
idnumber全局页面模板的 ID
namestring全局页面模板的名称
contentstring全局页面模板的内容

至少需指定 namecontent 的其中一个。

返回值

  • True:更新成功。
  • False:更新失败。

示例

from edge2client import Edge2Client

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

name = "newname"
ok = client.put_global_page_template(name=name, content=content)

get_app_basic_auth_user_group

data = get_app_basic_auth_user_group(id, app_id=None)

此方法用于获取指定应用中指定的 Basic Auth 用户组信息。

参数

参数名数据类型是否必需描述
idnumberBasic Auth 用户组的 ID
app_idnumberHTTP 应用的 ID,使用 use_app 指定后可以不传这个参数

返回值

  • data: 此次检索到的 Basic Auth 用户组信息,dict 类型。

示例

from edge2client import Edge2Client

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

app_id = 1
client.use_app(app_id)

group_id = 1
data = client.get_app_basic_auth_user_group(group_id)

get_all_app_basic_auth_user_groups

data = get_all_app_basic_auth_user_groups(app_id=None)

此方法用于获取指定应用中所有 Basic Auth 用户组信息。

参数

参数名数据类型是否必需描述
app_idnumberHTTP 应用的 ID,使用 use_app 指定后可以不传这个参数

返回值

  • data: 此次检索到的 Basic Auth 用户组列表,list 类型。

示例

from edge2client import Edge2Client

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

app_id = 1
# client.use_app(app_id)

groups = client.get_all_app_basic_auth_user_groups(app_id)
for g in groups:
    print(g)

del_app_basic_auth_user_group

ok = del_app_basic_auth_user_group(id, app_id=None)

此方法用于删除指定应用中指定的 Basic Auth 用户组信息。

参数

参数名数据类型是否必需描述
idnumberBasic Auth 用户组的 ID
app_idnumberHTTP 应用的 ID,使用 use_app 指定后可以不传这个参数

返回值

  • True:删除成功。
  • False:删除失败。

示例

from edge2client import Edge2Client

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

app_id = 1
client.use_app(app_id)

group_id = 1
ok = client.del_app_basic_auth_user_group(group_id)

new_app_basic_auth_user_group

id = new_app_basic_auth_user_group(name, label=None, app_id=None)

此方法用于在指定应用中创建 Basic Auth 用户组。

参数

参数名数据类型是否必需描述
namestringBasic Auth 用户组的名称
labelstringBasic Auth 用户组的标签
app_idnumberHTTP 应用的 ID,使用 use_app 指定后可以不传这个参数

返回值

  • id:返回新建的 Basic Auth 用户组的唯一 ID。

示例

from edge2client import Edge2Client

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

app_id = 1
client.use_app(app_id)

name = "default"
label = "default label"
id = client.new_app_basic_auth_user_group(name, label)

put_app_basic_auth_user_group

ok = put_app_basic_auth_user_group(id, name=None, label=None, app_id=None)

此方法用于更新指定应用中指定的 Basic Auth 用户组信息。

参数

参数名数据类型是否必需描述
idnumberBasic Auth 用户组的 ID
namestringBasic Auth 用户组的名称
labelstringBasic Auth 用户组的标签
app_idnumberHTTP 应用的 ID,使用 use_app 指定后可以不传这个参数

至少需指定 namelabel 的其中一个。

返回值

  • True:更新成功。
  • False:更新失败。

示例

from edge2client import Edge2Client

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

app_id = 1
client.use_app(app_id)

group_id = 1
name = "new-name"
label = "new-label"
ok = client.put_app_basic_auth_user_group(group_id, name=name, label=label)

get_app_basic_auth_user

data = get_app_basic_auth_user(id, group_id, app_id=None)

此方法用于获取指定应用的 Basic Auth 用户组中的指定的用户信息。

参数

参数名数据类型是否必需描述
idnumberBasic Auth 用户的 ID
group_idnumberBasic Auth 用户组的 ID
app_idnumberHTTP 应用的 ID,使用 use_app 指定后可以不传这个参数

返回值

  • data: 此次检索到的 Basic Auth 用户组信息,dict 类型。

示例

from edge2client import Edge2Client

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

app_id = 1
client.use_app(app_id)

user_id = 1
group_id = 1
data = client.get_app_basic_auth_user(user_id, group_id)

get_app_basic_auth_users_in_group

data = get_app_basic_auth_users_in_group(group_id, app_id=Nonee)

此方法用于获取指定应用的 Basic Auth 用户组中所有用户信息。

参数

参数名数据类型是否必需描述
group_idnumberBasic Auth 用户组的 ID
app_idnumberHTTP 应用的 ID,使用 use_app 指定后可以不传这个参数

返回值

  • data: 此次检索到的 Basic Auth 用户列表,list 类型。

示例

from edge2client import Edge2Client

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

app_id = 1
client.use_app(app_id)

group_id = 1
users = client.get_app_basic_auth_users_in_group(group_id)
for u in users:
    print(u)

del_app_basic_auth_user

ok = del_app_basic_auth_user(id, group_id, app_id=None)

此方法用于删除指定应用的 Basic Auth 用户组中指定的用户信息。

参数

参数名数据类型是否必需描述
idnumberBasic Auth 用户的 ID
group_idnumberBasic Auth 用户组的 ID
app_idnumberHTTP 应用的 ID,使用 use_app 指定后可以不传这个参数

返回值

  • True:删除成功。
  • False:删除失败。

示例

from edge2client import Edge2Client

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

app_id = 1
client.use_app(app_id)

user_id = 1
group_id = 1
ok = client.del_app_basic_auth_user(user_id, group_id)

new_app_basic_auth_user

id = new_app_basic_auth_user(group_id, username, password, app_id=None)

此方法用于在指定应用的 Basic Auth 用户组中创建用户。

参数

参数名数据类型是否必需描述
group_idnumberBasic Auth 用户所属的用户组的 ID
usernamestringBasic Auth 用户的名称
passwordstringBasic Auth 用户的密码
app_idnumberHTTP 应用的 ID,使用 use_app 指定后可以不传这个参数

返回值

  • id:返回新建的 Basic Auth 用户组的唯一 ID。

示例

from edge2client import Edge2Client

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

app_id = 1
client.use_app(app_id)

group_id = 1
username = "username1"
password = "password"
id = client.new_app_basic_auth_user(group_id, username, password)

put_app_basic_auth_user

ok = put_app_basic_auth_user(id, group_id, username, password, app_id=None)

此方法用于更新指定应用的 Basic Auth 用户组中指定的用户信息。

参数

参数名数据类型是否必需描述
idnumberBasic Auth 用户的 ID
group_idnumberBasic Auth 用户所属的用户组的 ID
usernamestringBasic Auth 用户的名称
passwordstringBasic Auth 用户的密码
app_idnumberHTTP 应用的 ID,使用 use_app 指定后可以不传这个参数

返回值

  • True:更新成功。
  • False:更新失败。

示例

from edge2client import Edge2Client

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

app_id = 1
client.use_app(app_id)

user_id = 1
group_id = 1
username = "new-username"
password = "new-password"
ok = client.put_app_basic_auth_user(user_id, group_id, username, password)