OpenResty Edge™ Python SDK 手册

OpenResty Edge™ Python SDK 手册

目录

概览

Edge-SDK 分为四个部分,分别为:APP / DNS / GLOBAL / USER

每个部分相对独立,但可通过相关方法将其关联在一起。如:在 APP 中引用全局(GLOBAL)中定义的 WAF 规则。

对每个方法的说明分为四个部分:说明 / 参数 / 返回值 /

中会展示该方法的典型用法。该方法所需的上下文将会在注释中,以 说明 + python 伪代码的形式列出。如:

"""
初始化客户端:
client = Edge2Client(host, username, password)
"""

回到目录

Edge2Client

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

说明

初始化 SDK 客户端,并登录 edge-admin,供后续使用

参数

参数数据类型必选描述
hoststringyesedge-admin 的地址,包含协议与端口
usernamestringyesedge-admin 的用户名
passwordstringyesedge-admin 的密码
api_tokenstringnoaccess token

返回值

edge2client.Edge2Client 对象

edge-admin 的地址为 http://127.0.0.1:8080

使用用户名 username 、密码 password 初始化 Edge2Client 对象:

client = Edge2Client('http://127.0.0.1:8080', 'username', 'password')

使用 API Token api_token 初始化 Edge2Client 对象:

client = Edge2Client('http://127.0.0.1:8080', None, None, "api_token")

回到目录

APP

提供针对 HTTP 应用的操作接口,如应用的增删改查及应用相关的配置修改

APP-BASIC

提供针对 HTTP 应用的基础操作接口

login

ok = login()

说明

登录 Edge OpenResty,以进行其他操作

返回值

登录成功返回 True,否则返回 False

ok = client.login()

回到目录

use_app

ok = use_app(app_id)

说明

改变实例操作的应用 id

返回值

成功返回 True,否则返回 False

将当前实例操作的应用 ID 改为 10

"""
初始化客户端:
client = Edge2Client(host, username, password)

客户端登录:
client.login()
"""

app_id = 10
client.use_app(app_id)

回到目录

new_app

app_id = new_app(domains, label)

说明

新增 HTTP 应用

参数
参数数据类型必选描述
domainslistyes应用的域名
labelstringyes应用的名称
cluster_groupslistno应用所在的集群组
返回值

返回 app_id,数据类型为 number

创建域名为 orig.foo.com,标签为 origin site for foo.com 的 HTTP 应用。

其所在群组为 [1]

"""
初始化客户端:
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(domains, label)

说明

修改 HTTP 应用的基本信息

参数
参数数据类型必选描述
app_idnumberyes应用的 id
domainslistyes应用的域名
labelstringyes应用的名称
cluster_groupslistno应用所在的集群组
offlineboolno应用是否下线
返回值

修改成功返回 True,否则返回 False

将已创建的应用(域名为 orig.foo.com) 的域名修改为 *.foo.com

"""
初始化客户端:
client = Edge2Client(host, username, password)

客户端登录:
client.login()

新增 http 应用,域名为 orig.foo.com
app_id = client.new_app(
   domains=['orig.foo.com'],
   label='origin site for foo.com',
   cluster_groups = [1])
"""

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

回到目录

get_app

data = get_app()

说明

获取 HTTP 应用的信息:域名、标签、所在群组等

返回值

dict 类型

获取 app_id 为 1 的应用信息

"""
初始化客户端:
client = Edge2Client(host, username, password)

客户端登录:
client.login()
"""

# 假设已创建 id 为 1 的应用
app_id = 1

client.use_app(1)

data = client.get_app()

回到目录

put_app_config

put_app_config(app_id, limiter)

说明

修改 HTTP 应用的配置。

参数
参数数据类型必选描述
app_idnumberyes应用的 id
limiterdictyes应用的 limiter 配置
enable_websocketboolno开启 websocket
返回值

修改成功返回 True,否则返回 False

获取 app_id 为 1 的应用信息

"""
初始化客户端:
client = Edge2Client(host, username, password)

客户端登录:
client.login()
"""

# 假设已创建 id 为 1 的应用
app_id = 1

data = 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_idnumberyes应用的 id
返回值

dict 类型

获取 app_id 为 1 的配置

"""
初始化客户端:
client = Edge2Client(host, username, password)

客户端登录:
client.login()
"""

# 假设已创建 id 为 1 的应用
app_id = 1

data = client.get_app_config(app_id)

回到目录

del_app

ok = del_app(app_id)

说明

根据 app_id 删除 HTTP 应用

参数
参数数据类型必选描述
app_idnumberyes应用的 id
返回值

Boolean 类型

删除 app_id 为 1 的应用

"""
初始化客户端:
client = Edge2Client(host, username, password)

客户端登录:
client.login()
"""

# 假设已创建 id 为 1 的应用
app_id = 1

ok = client.del_app(app_id)

回到目录

search_app

data = search_app(app_domain)

说明

以域名搜索 HTTP 应用

参数
参数数据类型必选描述
app_domainstringyes搜索的域名
pagenumberno返回结果的页码,默认值为 1
pagesizenumberno返回结果的条目数,默认值为 20
返回值

list 类型,每个元素为应用的相关信息

orig.foo.com 来搜索 HTTP 应用

"""
初始化客户端:
client = Edge2Client(host, username, password)

客户端登录:
client.login()

新增 http 应用,域名为 orig.foo.com
app_id = client.new_app(
   domains=['orig.foo.com'],
   label='origin site for foo.com',
   cluster_groups = [1])
"""

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

回到目录

search_http_app_by_keyword

data = search_http_app_by_keyword(keyword, page, pagesize)

说明

通过域名或应用名称搜索 HTTP 应用

参数
参数数据类型必选描述
keywordstringyes搜索的关键字,同时搜索域名和名称
pagenumberno返回结果的页码,默认值为 1
pagesizenumberno返回结果的条目数,默认值为 20
返回值

list 类型,每个元素为应用的相关信息

"""
初始化客户端:
client = Edge2Client(host, username, password)

客户端登录:
client.login()

新增 http 应用,域名为 orig.foo.com
app_id = client.new_app(
   domains=['orig.foo.com'],
   label='origin site for foo.com',
   cluster_groups = [1])
"""

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, pagesize)

说明

以 IP 搜索上游。

参数
参数数据类型必选描述
ipstringyes搜索的 IP
pagenumberno返回结果的页码,默认值为 1
pagesizenumberno返回结果的条目数,默认值为 20
返回值

list 类型,每个元素为上游信息

"""
初始化客户端:
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 搜索上游。

参数
参数数据类型必选描述
ipstringyes搜索的 IP
pagenumberno返回结果的页码,默认值为 1
pagesizenumberno返回结果的条目数,默认值为 20
返回值

list 类型,每个元素为上游信息

"""
初始化客户端:
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)

说明

以名称搜索上游。

参数
参数数据类型必选描述
namestringyes搜索的名称
pagenumberno返回结果的页码,默认值为 1
pagesizenumberno返回结果的条目数,默认值为 20
返回值

list 类型,每个元素为上游信息

"""
初始化客户端:
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)

说明

以名称搜索上游。

参数
参数数据类型必选描述
namestringyes搜索的名称
pagenumberno返回结果的页码,默认值为 1
pagesizenumberno返回结果的条目数,默认值为 20
返回值

list 类型,每个元素为上游信息

"""
初始化客户端:
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)

说明

以命名空间,服务名称,端口号来搜索 k8s 上游。

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

list 类型,每个元素为 k8s 上游信息

"""
初始化客户端:
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)

说明

以命名空间,服务名称,端口号来搜索k8s上游。

参数
参数数据类型必选描述
pagenumberno返回结果的页码,默认值为 1
pagesizenumberno返回结果的条目数,默认值为 20
start_timenumberno开始时间戳
end_timenumberno结束时间戳
返回值

list 类型,每个元素为k8s upstream更新历史操作

"""
初始化客户端:
client = Edge2Client(host, username, password)
客户端登录:
client.login()
data = self.client.search_k8s_upstream(port = 80, service = "test-hello", namespace = "default")

回到目录

get_all_apps

data = get_all_apps(detail)

说明

获取所有的应用信息

参数
参数数据类型必选描述
detailboolno是否返回应用的详情,默认为 False
返回值

detailFalse 时,返回值 data 类型为 listdetailTrue 时,返回值 data 类型为 dict

"""
初始化客户端:
client = Edge2Client(host, username, password)

客户端登录:
client.login()
"""

# 假设已创建了多个应用

# list
apps = client.get_all_apps()

# dict
apps = client.get_all_apps(detail=True)

回到目录

UPSTREAM

new_upstream

up_id = new_upstream(**kwargs)

新增上游节点,返回结果为上游 id

参数
参数数据类型必选描述
namestringyes上游名称
serverslistyes上游节点信息
sslboolno是否使用 HTTPS 协议,默认为 False
health_checkerdictno对健康检查的详细配置,默认为 None
gidarrayyes用户组 id 列表, 比如[1]
servers
参数数据类型必选描述
domainstringno上游的域名
ipstringno上游的 IP 。其中 domain 和 IP 两者至少需要填一项
portstringyes上游的端口
weightnumberno上游的权重,默认为 1
返回值

返回值为创建上游节点的 up_id

"""
初始化客户端:
client = Edge2Client(host, username, password)

客户端登录:
client.login()
"""

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)

说明

修改上游节点信息

参数
参数数据类型必选描述
namestringyes上游名称
serverslistyes上游节点信息
sslboolno是否使用 HTTPS 协议,默认为 False
health_checkerdictno对健康检查的详细配置,默认为 None
gidarrayyes用户组 id 列表, 比如[1]
servers
参数数据类型必选描述
domainstringno上游的域名
ipstringno上游的 IP 。其中 domain 和 IP 两者至少需要填一项
portstringyes上游的端口
weightnumberno上游的权重,默认为 1
"""
初始化客户端:
client = Edge2Client(host, username, password)

客户端登录:
client.login()
"""

# 假设已创建了上游节点,up_id 为 1
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_idstringno上游的 ID
"""
初始化客户端:
client = Edge2Client(host, username, password)

客户端登录:
client.login()
"""

# 假设已创建了上游节点,up_id 为 1
up_id = 1

data = client.get_upstream(up_id)

回到目录

del_upstream

del_upstream(up_id)

说明

删除上游节点

参数
参数数据类型必选描述
up_idstringno上游的 ID
返回值

删除成功的时返回 True,否则返回 False

"""
初始化客户端:
client = Edge2Client(host, username, password)

客户端登录:
client.login()
"""

# 假设已创建了上游节点,up_id 为 1
up_id = 1

ok = client.del_upstream(up_id)

回到目录

get_all_upstreams

upstreams = client.get_all_upstreams()

获取所有上游节点的信息

"""
初始化客户端:
client = Edge2Client(host, username, password)

客户端登录:
client.login()
"""

# 假设已创建了多个上游节点

upstreams = client.get_all_upstreams()

回到目录

K8S-UPSTREAM

new_k8s_upstream

up_id = new_k8s_upstream(**kwargs)

新增全局k8s上游节点,返回结果为全局k8s上游 id

参数
参数数据类型必选描述
namestringyes上游名称
k8s_services (见下表)listyes上游节点是k8s服务时的信息
sslboolno是否使用 HTTPS 协议,默认为 False
health_checkerdictno对健康检查的详细配置,默认为 None
gidarrayyes用户组id列表, 比如[1]
k8s_services 参数数据类型必选描述
k8snumberyesk8s集群id
k8s_namespacestringyesk8s集群命名空间
k8s_servicestringyesk8s集群服务
k8s_service_portnumberyesk8s集群服务端口
返回值

返回值为创建上游节点的 up_id

"""
初始化客户端:
client = Edge2Client(host, username, password)

客户端登录:
client.login()
"""

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)

将一个普通的上游复制成为一个 k8s 上游

参数
参数数据类型必选描述
up_idstringyes被复制的上游的 ID
k8s_services (见下表)listyes上游节点是 k8s 服务时的信息
rulesarrayno遍历 rules 中的规则,凡是使用到原上游的都迁移到 k8s 上游,如果不提供这个参数,函数会查出本 app 的所有规则来做遍历, 使用这个参数可防止函数多次自动查询所有的规则
k8s_services 参数数据类型必选描述
k8snumberyesk8s集群id
k8s_namespacestringyesk8s集群命名空间
k8s_servicestringyesk8s集群服务
k8s_service_portnumberyesk8s集群服务端口
返回值

返回值为创建上游节点的 up_id

"""
初始化客户端:
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,
                                }
                            ])

例2

client.use_app(app_id)

rules = client.get_all_rules()

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

回到目录

put_k8s_upstream

ok = put_k8s_upstream(**kwargs)

说明

修改上游节点信息

参数
参数数据类型必选描述
namestringyes上游名称
k8s_services (见下表)listyes上游节点是 k8s 服务时的信息
sslboolno是否使用 HTTPS 协议,默认为 False
health_checkerdictno对健康检查的详细配置,默认为 None
gidarrayyes用户组 ID 列表, 比如[1]

k8s_services

k8s_services 参数数据类型必选描述
k8snumberyesk8s集群id
k8s_namespacestringyesk8s集群命名空间
k8s_servicestringyesk8s集群服务
k8s_service_portnumberyesk8s集群服务端口
"""
初始化客户端:
client = Edge2Client(host, username, password)

客户端登录:
client.login()
"""

# 假设已创建了上游节点,up_id 为 1
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)

说明

获取上游节点的信息

参数
参数数据类型必选描述
up_idstringyes上游的 ID
"""
初始化客户端:
client = Edge2Client(host, username, password)

客户端登录:
client.login()
"""

# 假设已创建了上游节点,up_id 为 1
up_id = 1

data = client.get_k8s_upstream(up_id)

回到目录

del_k8s_upstream

del_upstream(up_id)

说明

删除上游节点

参数
参数数据类型必选描述
up_idstringyes上游的 ID
返回值

删除成功的时返回 True,否则返回 False

"""
初始化客户端:
client = Edge2Client(host, username, password)

客户端登录:
client.login()
"""

# 假设已创建了上游节点,up_id 为 1
up_id = 1

ok = client.del_k8s_upstream(up_id)

回到目录

get_all_k8s_upstreams

upstreams = client.get_all_k8s_upstreams()

获取所有上游节点的信息

"""
初始化客户端:
client = Edge2Client(host, username, password)

客户端登录:
client.login()
"""

# 假设已创建了多个上游节点

upstreams = client.get_all_k8s_upstreams()

回到目录

APP-RULE

new_rule

rule_id = new_rule(**kwargs)

说明

新建页面规则,包括:通用规则,代理规则,WAF 规则,缓存规则。还可以指定规则执行的前提条件。

参数
参数数据类型必选描述
conditionlistno条件
conseqdict or listno动作
waflistnoWAF 规则
proxylistno代理规则
cachelistno缓存规则
contentlistno内容规则
topnumberno1:置顶规则,-1:置底规则
ordernumberno规则顺序,优先级低于 top 参数
lastbooleanno如果命中此条规则的话跳过所有余下的页面规则,默认为 False
返回值

返回创建规则的 rule_id

condition
参数数据类型必选描述
varstring or arrayyes如果是 string 类型,则填写变量名 name(此时为字符串类型)。若是 array 类型则需要填写 变量名 name和参数 args (此时为数组类型,详见用例)
opstringno操作符,默认为 eq,即字符串相等 (equal)
valstringeither val or valsstring 类型或者 array 类型, 需要指定为正则或者通配类型时,传 [正则表达式, 'rx'], [通配表达式, 'wc']
valslisteither val or valsval 的集合
conseq
参数数据类型必选描述
edge 语言内建函数stringyesedge 语言内建函数
edge 语言内建函数的参数listyesedge 语言的内建函数

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

例 1
"""
初始化客户端:
client = Edge2Client(host, username, password)

客户端登录:
client.login()
"""

# 假设已创建了域名为 orig.foo.com 的应用

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

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

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

因为 dict 类型不能认为的排序,并且也不能设置重复名称的动作。 所以推荐使用下面这种 list 类型来代替 dict 类型:

例 2
"""
初始化客户端:
client = Edge2Client(host, username, password)

客户端登录:
client.login()
"""

# 假设已创建了域名为 orig.foo.com 的应用

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

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

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

对参数中 waf 数组的描述:

参数数据类型必选描述
rule_setslistno全局默认的用户规则集,默认值为一个空列表
robotsboolno是否启用该规则,默认值为 False
genericboolno是否启用该规则,默认值为 False
injectboolno是否启用该规则,默认值为 False
trojansboolno是否启用该规则,默认值为 False
xssboolno是否启用该规则,默认值为 False
actionstringyeslog, 403 Forbidden, edge-captcha, redirect 中的一个
thresholdstringyeshigh, medium, low 中的一个
clearancenumbernocaptcha 触发后的持续时间,默认值为 60 秒
redirect_urlstringno当动作为 redirect (重定向) 时,指定 url

创建自定义的 waf 规则,并在应用中使用该规则,其中 new_global_waf_rule 方法的文档参见:new_global_waf_rule

"""
初始化客户端:
client = Edge2Client(host, username, password)

客户端登录:
client.login()
"""

# 假设已创建了域名为 orig.foo.com 的应用

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],
    'robots': True, 'generic': True, 'inject': True,
    'action': '403 Forbidden', 'threshold': 'low'}

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

对参数中 proxy 数组的描述:

参数数据类型必选描述
upstreamslistyes上游节点信息
backup_upstreamslistyes上游备份节点信息
upstreams_el_codestryesEdgelang设置上游
timeoutnumberno代理超时时间,默认值为 3 秒
connect_timeoutnumberno连接超时时间,默认值为 3 秒
read_timeoutnumberno读超时时间,默认值为 3 秒
send_timeoutnumberno发送超时时间,默认值为 3 秒
retriesnumberno重试次数,默认值为 1 次
retry_conditionlistno重试条件,默认值为 [“error”, “timeout”, “invalid_header”, “http_500”, “http_502”, “http_504”]. 还有如下选项可选 http_503, http_403, http_404, http_429non_valueempotent (即方法可以是 POST, LOCK, PATCH)
balancer_algorithmstringno负载均衡算法,默认值为 roundrobin。支持的算法还有 hashchash
balancer_varslistno负载均衡算法所依赖的变量,当负载均衡算法选择为 hashchash 时需要填写该字段
multi_tiernumberno多层网络策略 ID
upstreams

对参数中 upstreamsbackup_upstreams 数组的描述

参数数据类型必选描述
upstreamnumberyes上游的 ID
global_upstreamnumberyes全局上游的 ID
k8s_upstreamnumberyesk8s上游的 id
global_k8s_upstreamnumberyes全局 k8s 上游的 ID
weightnumberno上游的权重,默认值为 1
"""
初始化客户端:
client = Edge2Client(host, username, password)

客户端登录:
client.login()
"""

# 假设已创建了域名为 orig.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.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)

cache
参数数据类型必选描述
cache_keylistyes缓存 key
default_ttlslistno是否启用默认缓存,默认值为 None
browser_ttlnumberno是否启用浏览器缓存,默认值为 None
browser_ttl_unitstringno浏览器缓存单位,只在 browser_ttl 设置后有效,默认值为 min
enable_globalbooleanno是否启用跨域名缓存,默认值为 False
enforce_cachebooleanno是否启用始终缓存,默认值为 False
cluster_hashbooleanno是否启用集群缓存,默认值为 False
disable_convert_headbooleanno是否将 HEAD 请求方法转换为 GET,默认值为 True

当访问来源 IP 是中国 (CN)时,应用缓存规则:其中缓存 key 包括 URL 、查询字符串和客户端来源城市。

"""
初始化客户端:
client = Edge2Client(host, username, password)

客户端登录:
client.login()
"""

# 假设已创建了域名为 orig.foo.com 的应用

condition = [{'var': 'client-country', 'op': 'eq', 'val': 'CN'}]
# cache_key = ['uri', 'query-string', 'client-city']
# 或
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)
content
参数数据类型必选描述
faviconnumber和 empty_gif 二选一文件 id
empty_gifboolean和 favicon 二选一是否为空 gif

上传 favicon 文件,并在访问 /favicon.ico 时给出响应

"""
初始化客户端:
client = Edge2Client(host, username, password)

客户端登录:
client.login()
"""

# 假设已创建了域名为 orig.foo.com 的应用

condition = [{'var': 'uri', 'op': 'eq', 'val': '/favicon.ico'}]
file_id = client.upload_favicon(name='test', favicon_content='content', gid=[1])

rule_id = client.new_rule(condition=condition, content={'favicon': file_id})

回到目录

put_rule

ok = put_rule(**kwargs)

说明

修改页面规则

参数
参数数据类型必选描述
conditionlistno规则条件
conseqdict or listno规则动作
waflistnoWAF 规则
proxylistno代理规则
cachelistno缓存规则
contentlistno内容规则
topnumberno1:置顶规则 -1:置底规则
ordernumberno规则顺序,优先级低于 top 参数
lastbooleanno如果命中此条规则的话跳过所有余下的页面规则,默认为 False
返回值

修改成功返回 True,修改失败返回 False

"""
初始化客户端:
client = Edge2Client(host, username, password)

客户端登录:
client.login()
"""

# 假设已创建了域名为 orig.foo.com 的应用

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)

回到目录

get_rule

data = get_rule(rule_id)

说明

根据 rule_id 获取页面规则

参数
参数数据类型必选描述
rule_idnumberyes规则的 id
返回值

dict 类型的域名规则信息

"""
初始化客户端:
client = Edge2Client(host, username, password)

客户端登录:
client.login()
"""

# 假设已创建 app_id 为 1 的应用

# 假设在 app_id 为 1 的应用上新增了规则,rule_id 为 1
rule_id = 1

data = client.get_rule(rule_id)

回到目录

del_rule

ok = del_rule(rule_id)

说明

删除 rule_id 对应的页面规则

参数
参数数据类型必选描述
rule_idnumberyes规则的 id
返回值

删除成功返回 True,否则返回 False

"""
初始化客户端:
client = Edge2Client(host, username, password)

客户端登录:
client.login()
"""

# 假设已创建 app_id 为 1 的应用

# 假设在 app_id 为 1 的应用上新增了规则,rule_id 为 1
rule_id = 1

ok = client.del_rule(rule_id)

回到目录

get_all_rules

rules = get_all_rules(app_id)

说明

获取应用 id (app_id) 对应的所有页面规则

参数
参数数据类型必选描述
app_idnumberno应用的 id,默认值为当前应用的 id
返回值

list 类型的规则集,其中的每个元素值与 get_rule 返回值类型相同

"""
初始化客户端:
client = Edge2Client(host, username, password)

客户端登录:
client.login()
"""

# 假设已创建 app_id 为 1 的应用

# 假设在 app_id 为 1 的应用上新增了多个规则

data = client.get_all_rules()

回到目录

get_all_rules_by_app_domain

rules = get_all_rules_by_app_domain(domain)

说明

根据应用规则获取相对应的页面规则

参数
参数数据类型必选描述
domainstringyes应用的域名
"""
初始化客户端:
client = Edge2Client(host, username, password)

客户端登录:
client.login()
"""

# 假设已创建 app_id 为 1 的应用,域名为 orig.foo.com

# 假设在 app_id 为 1 的应用上新增了多个规则

# 获取 orig.foo.com 的所有规则
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_ipstringyes上游的 IP 地址
"""
初始化客户端:
client = Edge2Client(host, username, password)

客户端登录:
client.login()
"""

# 假设已创建 app_id 为 1 的应用,域名为 orig.foo.com

# 假设在 app_id 为 1 的应用上新增了多个规则

# 创建 ip 地址为 upstream_ip 的上游节点
upstream_ip = '1.2.3.4'

# 获取 upstream_ip 的所有规则
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
"""
初始化客户端:
client = Edge2Client(host, username, password)

客户端登录:
client.login()
"""

# 假设已创建 app_id 为 1 的应用,域名为 orig.foo.com

# 假设在 app_id 为 1 的应用上新增了多个 waf 规则

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_idnumberno应用的 id
返回值

list 类型,每个元素为该规则的 ID 。如需获取规则详细信息,则需根据规则 ID 来进行进一步查询,详见方法 get_global_rule()

获取所有全局规则的 id

"""
初始化客户端:
client = Edge2Client(host, username, password)

客户端登录:
client.login()
"""

# 假设已创建了多个全局规则
app_id = 1
rule_ids = client.get_global_actions_used_in_app(app_id)

回到目录

APP-CERT

set_cert_key

cert_id = set_cert_key(**kwargs)

说明

新增 SSL 证书,手动上传证书

参数
参数数据类型必选描述
keystringyes私钥的内容
certstringno证书的内容
ca_chainstringnoCA 链的内容
global_cert_idnumberno证书全局 id
gidlistno用户组id列表
"""
初始化客户端:
client = Edge2Client(host, username, password)

客户端登录:
client.login()
"""

# 假设已创建 app_id 为 1 的应用,域名为 orig.foo.com

# key.pem 文件为密钥
key_file = os.path.join('tests', 'key.pem')
# cert.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 arrayyes需要自动获取 LE 证书的域名
gidlistno用户组 ID 列表
返回值

创建 Let’s Encrypt 证书的 ID

"""
初始化客户端:
client = Edge2Client(host, username, password)

客户端登录:
client.login()
"""

# 假设已创建 app_id 为 1 的应用,域名为 orig.foo.com

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

回到目录

put_cert_key

cert_id = put_cert_key(**kwargs)

说明

修改 SSL 证书(手动上传)

参数
参数数据类型必选描述
cert_idnumberyes证书的 id
keystringyes私钥的内容
certstringno服务端证书的内容
ca_chainstringnoCA 链的内容
global_cert_idnumberno证书的全局 id
gidlistno用户组 id 列表
"""
初始化客户端:
client = Edge2Client(host, username, password)

客户端登录:
client.login()
"""

# 假设已创建 app_id 为 1 的应用,域名为 orig.foo.com

# 假设为 app_id 为 1 的应用上传了证书,证书 id 为 1
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_cert_key(cert_id=cert_id, key=new_key, cert=new_cert)

回到目录

put_le_cert

cert_id = put_le_cert(**kwargs)

说明

修改 Let’s Encrypt 证书

参数
参数数据类型必选描述
domainsstring arrayyes需要自动获取 LE 证书的域名
gidlistno用户组 id 列表
resignbooleanno是否需要触发重新签发证书
"""
初始化客户端:
client = Edge2Client(host, username, password)

客户端登录:
client.login()
"""

# 假设已创建 id 为 1 的应用,域名为 orig.foo.com

# 假设为 id 为 1 的应用创建了 Let's Encrypt 证书,证书的 CN 为 orig.foo.com,证书的 cert_id 为 1

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_idnumberyes证书 ID
返回值

data

参数数据类型描述
statusstring证书签发状态:valid / pending / invalid
expdatenumber证书过期时间 (Unix 时间戳)
next_udpatenumber证书下次更新时间 (Unix 时间戳)
"""
初始化客户端:
client = Edge2Client(host, username, password)

客户端登录:
client.login()
"""

# 假设已创建 id 为 1 的应用,域名为 orig.foo.com

# 假设为 id 为 1 的应用创建了 Let's Encrypt 证书,证书的 CN 为 orig.foo.com,证书的 cert_id 为 1

cert_id = 1

data = client.get_le_cert(cert_id)

# data: {'expdate': 1647402658, 'status': 'pending', 'next_update': 1644810658}

回到目录

get_cert_key

cert_data = get_cert_key(cert_id)

说明

获取 SSL 证书内容

参数
参数数据类型必选描述
cert_idnumberyes证书的 id
返回值

证书的内容,dict 类型

"""
初始化客户端:
client = Edge2Client(host, username, password)

客户端登录:
client.login()
"""

# 假设已创建 id 为 1 的应用

# 假设为 app_id 为 1 的应用创建证书,证书 cert_id 为 1
cert_id = 1

data = client.get_cert_key(cert_id)

回到目录

get_all_cert_keys

cert_data = get_all_cert_keys()

说明

获取当前应用的所有证书信息

"""
初始化客户端:
client = Edge2Client(host, username, password)

客户端登录:
client.login()
"""

# 假设已创建了 app_id 为 1 的应用

# 假设为 app_id 为 1 的应用创建了多个证书

data = client.get_all_cert_keys()

回到目录

del_cert_key

ok = del_cert_key(cert_id)

根据 cert_id 删除对应的证书信息

参数
参数数据类型必选描述
cert_idnumberyes证书的 id
"""
初始化客户端:
client = Edge2Client(host, username, password)

客户端登录:
client.login()
"""

# 假设在 app_id 为 1 的应用上新增了 cert_id 为 1 的证书
cert_id = 1

ok = client.del_cert_key(cert_id)

回到目录

APP-RELEASE

new_el

ok = new_el(**kwargs)

说明

新增自定义 edge 语言代码

参数
参数数据类型必选描述
phasestringyesedge 语言执行阶段
codestringyesedge 语言代码
postboolyes值为 True 时将该段代码在所选阶段的后面执行,默认值为 False
preboolyes值为 True 时将该段代码在所选阶段的靠前顺序执行,默认值为 False
返回值

创建成功返回 True,否则返回 False

"""
初始化客户端:
client = Edge2Client(host, username, password)

客户端登录:
client.login()
"""

# 假设已创建了应用

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

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

回到目录

new_release

ok = new_release()

说明

发布当前应用的更动

返回值

发布成功时返回 True,否则返回 False

"""
初始化客户端:
client = Edge2Client(host, username, password)

客户端登录:
client.login()
"""

# 创建了新的应用

# 为该应用创建了新的规则

# 发布这批新的规则
ok = client.new_release()

回到目录

pending_changes

changes = pending_changes()

说明

查询待发布更动条目数量

返回值

待更动条目数量

"""
初始化客户端:
client = Edge2Client(host, username, password)

客户端登录:
client.login()
"""

# 假设创建了应用,并创建或修改了多条规则

changes = client.pending_changes()

回到目录

sync_status

total, synced = sync_status()

说明

将更动发布到各个节点

返回值

第一个返回值为节点总数,第二个返回值为已同步节点数。 当两数相等时,则新增规则全网发布成功。

新建多条规则,并确认是否全网发布成功

"""
初始化客户端:
client = Edge2Client(host, username, password)

客户端登录:
client.login()
"""

# 假设创建了应用,并创建或修改了多条规则

# 使用 `new_release` 方法发布更动

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

回到目录

node_sync_status

data = node_sync_status()

说明

获取各节点的同步详情

返回值

dict 类型,返回每个节点的 node_id 及节点上次发布更动到目前的时长

"""
初始化客户端:
client = Edge2Client(host, username, password)

客户端登录:
client.login()
"""

data = client.node_sync_status()
for node_id, delay in data.items():
    if delay > 0:
        print('WARNING: node id {}: releases behind {}'
        .format(str(node_id), str(delay)))

回到目录

get_healthcheck_status

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

说明

获取各节点的健康检查信息

返回值

dict 类型,返回每个节点的 node_id 及对应节点的健康状态

"""
初始化客户端:
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)

回到目录

APP-USER

add_app_user

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

说明

新增应用级用户

参数
参数数据类型必选描述
namestringyes用户名
readboolno是否有读权限,默认为 True
writeboolno是否有写权限,默认为 True
releaseboolno是否有发布更动的权限,默认为 False
dns_readboolno是否有读 DNS 的权限,默认为 False
dns_writeboolno是否有写 DNS 的权限,默认为 False
返回值

返回值为新增用户的 uid 。

注意:这里有别与全局用户的 user_id

新增应用级用户,用户名为 only_reader,无写权限,无发布更动权限

"""
初始化客户端:
client = Edge2Client(host, username, password)

客户端登录:
client.login()
"""

# 假设已创建 app_id 为 1 的应用

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

回到目录

put_app_user

ok = put_app_user(id, name, read, write, release)

说明

修改应用级用户

参数
参数数据类型必选描述
idlistyes用户 id
namestringyes用户名
readboolno是否有读权限,默认为 True
writeboolno是否有写权限,默认为 True
releaseboolno是否有发布更动的权限,默认为 False
dns_readboolno是否有读 DNS 的权限,默认为 False
dns_writeboolno是否有写 DNS 的权限,默认为 False
返回值

修改成功返回 True,否则返回 False

将 uid 为 1 的用户,修改为:用户名为 master,有写权限,可以发布更动。

"""
初始化客户端:
client = Edge2Client(host, username, password)

客户端登录:
client.login()
"""

# 假设已创建 app_id 为 1 的应用

# 假设要修改的用户 uid 为 1
uid = 1

ok = client.put_app_user(id=uid, name='master', write=True, release=True)

回到目录

get_app_user

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

说明

获取应用级用户信息:包括用户名、权限等

参数
参数数据类型必选描述
idlistno用户 id
namestringno用户名
app_idnumberno应用 id,默认为当前应用 id
user_idnumberno全局用户 id
返回值

dict类型,用户信息:包括用户名、权限等

"""
初始化客户端:
client = Edge2Client(host, username, password)

客户端登录:
client.login()
"""

# 假设创建了应用级用户,用户名为 only_reader
username = 'only_reader'

data = client.get_app_user(name=username)

回到目录

del_app_user

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

说明

删除应用级用户

参数
参数数据类型必选描述
idlistno用户 id
namestringno用户名
app_idnumberno应用 id,默认为当前应用
user_idnumberno全局用户 id
返回值

如果删除用户成功则返回 True,否则返回 False

"""
初始化客户端:
client = Edge2Client(host, username, password)

客户端登录:
client.login()
"""

# 假设创建了应用级用户,用户名为 only_reader
username = 'only_reader'

ok = client.del_app_user(name=username)

回到目录

get_all_app_users

data = get_all_app_users(app_id)

说明

获取所有当前应用级别(也可以使用 app_id 指定应用)的用户

参数
参数数据类型必选描述
app_idnumberno应用 id,默认为当前应用 id
返回值

list 类型,每个元素为 dict 类型

"""
初始化客户端:
client = Edge2Client(host, username, password)

客户端登录:
client.login()
"""

# 假设在当前应用上创建了多个用户

data = client.get_all_app_users()

回到目录

add_user_for_all_apps

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

说明

为所有应用添加用户

参数
参数数据类型必选描述
namestringno全局的用户名
readboolno是否有读权限,默认为 True
writeboolno是否有写权限,默认为 True
releaseboolno是否有发布更动的权限,默认为 False
dns_readboolno是否有读 DNS 的权限,默认为 False
dns_writeboolno是否有写 DNS 的权限,默认为 False
"""
初始化客户端:
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)

说明

将所有全局用户添加到当前应用

参数
参数数据类型必选描述
app_idnumberno应用 id,默认为当前应用 id
readboolno是否有读权限,默认为 True
writeboolno是否有写权限,默认为 True
releaseboolno是否有发布更动的权限,默认为 False
dns_readboolno是否有读 DNS 的权限,默认为 False
dns_writeboolno是否有写 DNS 的权限,默认为 False
返回值

若添加成功返回 True,否则返回 False

为 app_id 为 1 的应用添加用户,所有的全局用户都添加在该应用下, release (发布更动) 权限为 True,其他权限为默认值

"""
初始化客户端:
client = Edge2Client(host, username, password)

客户端登录:
client.login()
"""

# 假设已创建了 app_id 为 1 的应用

data = client.add_all_users_for_app(release=True)

回到目录

PURGE-CACHE

new_cache_purge_task

task_id = client.new_cache_purge_task(condition=condition)

说明

新增条件刷新任务,条件参数为数组,可以输入多个条件。多个条件同时成立时,则触发刷新任务。

参数
参数数据类型必选描述
conditionlistno条件
返回值

刷新任务 task_id,可以据此查询刷新任务执行详情

新建条件刷新任务,触发条件为:访问 Host 为 con.foo.com 时,并且请求头中 Referer 的值匹配到正则 foo\d+

"""
初始化客户端:
client = Edge2Client(host, username, password)

客户端登录:
client.login()
"""

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_idnumberyes刷新任务 id
"""
初始化客户端:
client = Edge2Client(host, username, password)

客户端登录:
client.login()
"""

##### 假设创建了 task_id 为 1 的刷新任务
task_id = 1

data = client.get_cache_purge_task(task_id)

回到目录

get_all_cache_purge_tasks

data = client.get_all_cache_purge_tasks()

说明

获取所有刷新任务的详情

"""
初始化客户端:
client = Edge2Client(host, username, password)

客户端登录:
client.login()
"""

# 假设已创建多条刷新任务

data = client.get_all_cache_purge_tasks()

回到目录

del_cache_purge_task

ok = client.del_cache_purge_task(task_id)

说明

删除指定任务 id 的刷新任务

参数
参数数据类型必选描述
task_idnumberyes刷新任务 id
返回值

删除刷新任务成功时返回 True,否则返回 False

删除 task_id 为 1 的刷新缓存任务

"""
初始化客户端:
client = Edge2Client(host, username, password)

客户端登录:
client.login()
"""

# 假设已创建刷新任务,task_id 为 1
task_id = 1

ok = client.del_cache_purge_task(task_id)

回到目录

WAF-WHITELIST

new_waf_whitelist

rule_id = new_waf_whitelist(**kwargs)

新增 WAF 白名单规则

参数
参数数据类型必选描述
conditionlistno规则执行的条件
rule_setslistyeswaf 规则的 id 列表
WAF Condition
参数数据类型必选描述
varstring or arrayyesedge 语言内置的函数名,当类型为 array 时,则在函数名后跟着该函数所需的参数
opstringno操作符,默认为 eq
valstringval / vals 二选一
valslistval / vals 二选一一组值 (使用数组)
# do some prepare
# ...
# client login success

# ...
# created new app: orig.foo.com
# 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])

回到目录

put_waf_whitelist

ok = put_waf_whitelist(**kwargs)

修改 WAF 白名单规则

参数
参数数据类型必选描述
whitelist_idnumberyes白名单的 id
conditionlistno规则的执行条件
rule_setslistyeswaf 的 id 列表
# do some prepare
# ...
# client login success

# ...
# created new app: orig.foo.com
# app_id

# ...
# created new waf whitelist with waf_whitelist_id

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

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

回到目录

get_waf_whitelist

data = get_waf_whitelist(whitelist_id)

获取 WAF 白名单规则

# do some prepare
# ...
# client login success

# ...
# created new app: orig.foo.com
# app_id

# ...
# created new waf whitelist with waf_whitelist_id

data = client.get_waf_whitelist(waf_whitelist_id)

回到目录

del_waf_whitelist

ok = del_waf_whitelist(whitelist_id)

删除 WAF 白名单规则

# do some prepare
# ...
# client login success

# ...
# created new app: orig.foo.com
# app_id

# ...
# created new waf whitelist with waf_whitelist_id

ok = client.del_waf_whitelist(waf_whitelist_id)

回到目录

get_all_waf_whitelists

data = get_all_waf_whitelists()

获取所有的 WAF 白名单规则

# do some prepare
# ...
# client login success

# ...
# created new app: orig.foo.com
# app_id

# ...
# created new waf whitelist with waf_whitelist_id

data = client.get_all_waf_whitelists()

回到目录

METRICS

new_app_dymetrics

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

新建应用动态指标。

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, http_verb="PUT")

修改应用动态指标。

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)

删除应用动态指标。

ok = client.del_app_dymetrics(app_id, dymetrics_id)

回到目录

get_app_dymetrics

data = get_app_dymetrics(app_id, id)

获取指定的应用动态指标。

data = client.get_app_dymetrics(app_id, dymetrics_id)

回到目录

get_all_app_dymetrics

data = get_all_app_dymetrics(app_id)

获取应用的所有动态指标。

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 分钟的数据。

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 分钟的数据。


data = client.get_app_metrics(app_id)

回到目录

IP-LIST

new_ip_list

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

新增应用级别 IP 列表

参数
参数数据类型必选描述
namestringyesIP 列表的名字
typestringnoIP 地址的类型,目前支持 ipv4ipv6(coming soon)
itemsarraynoIP 地址列表
items
参数类型必选描述
ipstringyesIP 地址
# do some prepare
# ...
# client login success

# ...
# created new app: orig.foo.com
# 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

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

修改指定的 IP 列表

参数
参数数据类型必选描述
rule_idnumberyes指定 IP 列表的 ID
namestringyesIP 列表的名字
typestringnoIP 地址的类型,目前支持 ‘ipv4’ 或 ‘ipv6’(coming soon)
itemsarraynoIP 地址列表
items
参数类型必选描述
ipstringyesIP 地址
# do some prepare
# ...
# client login success

# ...
# created new app: orig.foo.com
# app_id

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

del_ip_list

data = del_ip_list(rule_id=None)

删除指定的 IP 列表

参数
参数数据类型必选描述
rule_idnumberyes指定 IP 列表的 ID
# do some prepare
# ...
# client login success

# ...
# created new app: orig.foo.com
# app_id

ok = client.del_ip_list(rule_id=1)

get_ip_list

data = get_ip_list(rule_id=None)

查看指定的 IP 列表

参数
参数数据类型必选描述
rule_idnumberyes指定 IP 列表的 ID
# do some prepare
# ...
# client login success

# ...
# created new app: orig.foo.com
# app_id

data = client.get_ip_list(rule_id=1)

DASHBOARD

提供控制面板相关的接口

node_monitor

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

获取网络节点的 CPU 和内存相关的负载信息。

参数

参数数据类型必选描述
node_idnumberyes网关 Node 的 ID
start_timenumberno开始时间
end_timenumberno结束时间
stepnumberno统计间隔

更改当前实例操作的 DNS 应用

node_id = 1
data = client.node_monitor(node_id)

回到目录

GLOBAL-DYMETRICS

全局动态指标。

new_global_dymetrics

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

新建全局动态指标。

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, http_verb="PUT")

修改全局动态指标。

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)

删除全局动态指标。

ok = client.del_global_dymetrics(dymetrics_id)

回到目录

get_global_dymetrics

data = get_global_dymetrics(id)

获取指定的全局动态指标。

data = client.get_global_dymetrics(dymetrics_id)

回到目录

get_all_global_dymetrics

data = get_all_global_dymetrics()

获取所有全局动态指标。

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 分钟的数据。

dymetrics_id = 1
data = client.get_global_dymetrics_data(dymetrics_id)

回到目录

DNS

提供 DNS 相关的操作接口

use_dns_app

ok = use_dns_app(dns_id)

参数

参数数据类型必选描述
dns_idnumberyesDNS 应用的 id

更改当前实例操作的 DNS 应用

返回值

如果执行成功返回 True, 否则返回 False

"""
初始化客户端:
client = Edge2Client(host, username, password)

客户端登录:
client.login()
"""

# 假设已创建了 dns_id 为 1 的应用
dns_id = 1

client.use_dns_app(dns_id)

回到目录

new_dns_app

dns_id = new_dns_app(**kwargs)

新建 DNS 应用

参数

参数数据类型必选描述
zonestringyes域名
authoritylistyesNS 记录
soa_emailstringnoSOA EMAIL 记录

"""
初始化客户端:
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_idnumberyesDNS 应用的 id
zonestringyesDNS 的域名记录
authoritylistyesDNS 的 NS 记录
soa_emailstringnoDNS 的 SOA EMAIL 记录

修改 dns_id 为 1 的应用

"""
初始化客户端:
client = Edge2Client(host, username, password)

客户端登录:
client.login()
"""

# 假设已创建了 dns_id 为 1 的 dns 应用
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_idnumberyesDNS 应用的 id

"""
初始化客户端:
client = Edge2Client(host, username, password)

客户端登录:
client.login()
"""

# 假设已创建 dns_id 为 1 的 dns 应用
dns_id = 1

data = client.get_dns_app(dns_id)

回到目录

del_dns_app

ok = del_dns_app(dns_id)

删除 DNS 应用的信息

参数

获取 DNS 应用的信息

参数数据类型必选描述
dns_idnumberyesDNS 应用的 id

返回值

删除成功的时返回 True,否则返回 False

"""
初始化客户端:
client = Edge2Client(host, username, password)

客户端登录:
client.login()
"""

# 假设待删除 dns 应用 dns_id 为 1
dns_id = 1

data = client.del_dns_app(dns_id)

回到目录

new_dns_record

record_id = new_dns_record(**kwargs)

新增 DNS 记录

参数

参数数据类型必选描述
sub_domainstringyes子域名
linestringyes线路, 同目录下的 Line.txt 为
record_typestringyes记录的类型,[A, TXT, MX, CNAME, CAA] 可选
textstringno当记录类型为 [TXT, CAA] 时,需要填写该字段
ipstringno当响应为 IP 类型时,需要填写该字段
gatewaynumberno当响应指定的网关集群时,需要填写该字段
domainstringno当响应为域名类型时,需要填写该字段
prioritynumberno当记录类型为 MX 时,需要填写该字段

返回值

返回值为 DNS 记录的 record_id

"""
初始化客户端:
client = Edge2Client(host, username, password)

客户端登录:
client.login()
"""

# 假设已创建了 dns_id 为 1 的应用

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_idnumberyesDNS 记录的 id
sub_domainstringyes子域名
linestringyes线路, 同目录下的 Line.txt 为
record_typestringyes记录的类型,[A, TXT, MX, CNAME, CAA] 可选
textstringno当记录类型为 [TXT, CAA] 时,需要填写该字段
ipstringno当响应为 IP 类型时,需要填写该字段
domainstringno当响应为域名类型时,需要填写该字段
prioritynumberno当记录类型为 MX 时,需要填写该字段

返回值

Bool 类型,当修改成功时返回 True,否则返回 False

"""
初始化客户端:
client = Edge2Client(host, username, password)

客户端登录:
client.login()
"""

# 假设已创建了 dns_id 为 1 的应用

# 在 dns_id 上创建了 record_id 为 1 的应用
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_idnumberyesDNS 记录的 id

获取 record_id 为 1 的 DNS 记录信息

"""
初始化客户端:
client = Edge2Client(host, username, password)

客户端登录:
client.login()
"""

# 假设已创建了 dns_id 为 1 的应用

# 在 dns_id 上创建了 record_id 为 1 的应用
record_id = 1

data = client.get_dns_record(record_id)

回到目录

del_dns_record

ok = del_dns_record(record_id)

删除 DNS 记录

参数

参数数据类型必选描述
record_idnumberyesDNS 记录的 id

"""
初始化客户端:
client = Edge2Client(host, username, password)

客户端登录:
client.login()
"""

# 假设已创建了 dns_id 为 1 的应用

# 在 dns_id 上创建了 record_id 为 1 的应用
record_id = 1

ok = client.del_dns_record(record_id)

回到目录

GLOBAL

提供全局级别的操作接口

GLOBAL-UPSTREAM

new_global_upstream

up_id = new_global_upstream(**kwargs)

新增上游节点,返回结果为上游 id

参数
参数数据类型必选描述
namestringyes上游名称
servers (见下表)listyes上游节点信息
sslboolno是否使用 HTTPS 协议,默认为 False
health_checkerdictno对健康检查的详细配置,默认为 None
gidarrayyes用户组 id 列表, 比如[1]
servers 参数数据类型必选描述
domainstringno上游的域名
ipstringno上游的 IP 。其中 domain 和 IP 两者至少需要填一项
portstringyes上游的端口
weightnumberno上游的权重,默认为 1
返回值

返回值为创建上游节点的 up_id

"""
初始化客户端:
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}
    ])

回到目录

put_global_upstream

ok = put_global_upstream(**kwargs)

说明

修改上游节点信息

参数
参数数据类型必选描述
namestringyes上游名称
servers (见下表)listyes上游节点信息
sslboolno是否使用 HTTPS 协议,默认为 False
health_checkerdictno对健康检查的详细配置,默认为 None
gidarrayyes用户组 id 列表, 比如[1]
servers 参数数据类型必选描述
domainstringno上游的域名
ipstringno上游的 IP 。其中 domain 和 IP 两者至少需要填一项
portstringyes上游的端口
weightnumberno上游的权重,默认为 1
"""
初始化客户端:
client = Edge2Client(host, username, password)

客户端登录:
client.login()
"""

# 假设已创建了上游节点,up_id 为 1
up_id = 1

ok = client.put_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_idstringno上游的 ID
"""
初始化客户端:
client = Edge2Client(host, username, password)

客户端登录:
client.login()
"""

# 假设已创建了上游节点,up_id 为 1
up_id = 1

data = client.get_global_upstream(up_id)

回到目录

del_global_upstream

del_global_upstream(up_id)

说明

删除上游节点

参数
参数数据类型必选描述
up_idstringno上游的 ID
返回值

删除成功的时返回 True,否则返回 False

"""
初始化客户端:
client = Edge2Client(host, username, password)

客户端登录:
client.login()
"""

# 假设已创建了上游节点,up_id 为 1
up_id = 1

ok = client.del_global_upstream(up_id)

回到目录

get_all_global_upstreams

upstreams = client.get_all_global_upstreams()

获取所有上游节点的信息

"""
初始化客户端:
client = Edge2Client(host, username, password)

客户端登录:
client.login()
"""

# 假设已创建了多个上游节点

upstreams = client.get_all_global_upstreams()

回到目录

GLOBAL-K8S-UPSTREAM

new_global_k8s_upstream

up_id = new_global_k8s_upstream(**kwargs)

新增全局k8s上游节点,返回结果为全局k8s上游 id

参数
参数数据类型必选描述
namestringyes上游名称
k8s_serviceslistyes上游节点是k8s服务时的信息
sslboolno是否使用 HTTPS 协议,默认为 False
health_checkerdictno对健康检查的详细配置,默认为 None
gidarrayyes用户组id列表, 比如[1]
k8s_services
参数数据类型必选描述
k8snumberyesk8s集群id
k8s_namespacestringyesk8s集群命名空间
k8s_servicestringyesk8s集群服务
k8s_service_portnumberyesk8s集群服务端口
返回值

返回值为创建上游节点的 up_id

"""
初始化客户端:
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)

说明

修改上游节点信息

参数
参数数据类型必选描述
namestringyes上游名称
k8s_services (见下表)listyes上游节点是 k8s 服务时的信息
sslboolno是否使用 HTTPS 协议,默认为 False
health_checkerdictno对健康检查的详细配置,默认为 None
gidarrayyes用户组 id 列表, 比如[1]
k8s_services 参数数据类型必选描述
k8snumberyesk8s 集群id
k8s_namespacestringyesk8s 集群命名空间
k8s_servicestringyesk8s 集群服务
k8s_service_portnumberyesk8s 集群服务端口
"""
初始化客户端:
client = Edge2Client(host, username, password)

客户端登录:
client.login()
"""

# 假设已创建了上游节点,up_id 为 1
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'
    })

回到目录

get_global_k8s_upstream

data = get_global_k8s_upstream(up_id)

说明

获取上游节点的信息

参数
参数数据类型必选描述
up_idstringyes上游的 ID
"""
初始化客户端:
client = Edge2Client(host, username, password)

客户端登录:
client.login()
"""

# 假设已创建了上游节点,up_id 为 1
up_id = 1

data = client.get_global_k8s_upstream(up_id)

回到目录

del_global_k8s_upstream

del_global_upstream(up_id)

说明

删除上游节点

参数
参数数据类型必选描述
up_idstringyes上游的 ID
返回值

删除成功的时返回 True,否则返回 False

"""
初始化客户端:
client = Edge2Client(host, username, password)

客户端登录:
client.login()
"""

# 假设已创建了上游节点,up_id 为 1
up_id = 1

ok = client.del_global_k8s_upstream(up_id)

回到目录

get_all_global_k8s_upstreams

upstreams = client.get_all_global_k8s_upstreams()

获取所有上游节点的信息

"""
初始化客户端:
client = Edge2Client(host, username, password)

客户端登录:
client.login()
"""

# 假设已创建了多个上游节点

upstreams = client.get_all_global_k8s_upstreams()

回到目录

GLOBAL-CERT

set_global_cert_key

cert_id = set_global_cert_key(**kwargs)

说明

新增全局 SSL 证书

参数
Key nameTypeRequiredDescription
keystringyescontent of private key
certstringnocontent of server cert
ca_chainstringnocontent of CA chain
返回值

全局证书的 ID

上传本地的 key.pemcert.pem 文件,创建全局证书

"""
初始化客户端:
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_idnumberyes证书的 id
keystringyes私钥的内容
certstringno证书的内容
ca_chainstringnoCA 链的内容
返回值

修改成功返回 True,否则返回 False

"""
初始化客户端:
client = Edge2Client(host, username, password)

客户端登录:
client.login()
"""

# 假设已创建证书,cert_id 为 1
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_idnumberyes证书的 id
返回值

dict 类型,全局证书的信息

"""
初始化客户端:
client = Edge2Client(host, username, password)

客户端登录:
client.login()
"""

# 假设已创建证书,cert_id 为 1
cert_id = 1

data = client.get_global_cert_key(cert_id)

回到目录

del_global_cert_key

ok = del_global_cert_key(cert_id)

说明

删除 cert_id 对应的全局 SSL 证书

参数
参数数据类型必选描述
cert_idnumberyes证书的 id
返回值

删除成功时返回 True,否则返回 False

"""
初始化客户端:
client = Edge2Client(host, username, password)

客户端登录:
client.login()
"""

# 假设已创建证书,cert_id 为 1
cert_id = 1

ok = client.del_global_cert_key(cert_id)

回到目录

GLOBAL-USER

提供全局用户的增删改查接口

add_global_user

uid = add_global_user(name, pwd, gid)

说明

新增全局用户

参数
参数数据类型必选描述
namestringyes全局用户的用户名
pwdstringyes全局用户的密码
gidarrayyes用户组 id 列表, 比如[1]
返回值

返回值为全局用户的 uid

注意这里要与应用级别的用户 user_id 区分开

创建一个用户名为 global_demo_user、可以创建新应用、角色为普通用户的全局用户

"""
初始化客户端:
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)

说明

根据用户名搜索全局用户信息

参数
参数数据类型必选描述
namestringyes全局的用户名
返回值

dict 类型,返回值为搜索到的用户信息及相关权限信息

"""
初始化客户端:
client = Edge2Client(host, username, password)

客户端登录:
client.login()
"""

# 假设创建了用户名为 `global_demo_user` 的用户
username = 'global_demo_user'

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

回到目录

get_all_global_users

data = get_all_global_users(detail)

说明

获取所有全局用户

返回值

list 类型,其中每一个元素为 dict 类型,内容为对应全局用户的信息

"""
初始化客户端:
client = Edge2Client(host, username, password)

客户端登录:
client.login()
"""

# 假设已创建多个全局用户

# 获取所有已创建的用户信息
data = client.get_all_global_users()
data = client.get_all_global_users(True)

回到目录

GLOBAL-RULE

提供对全局规则的增删改查接口

new_global_rule

rule_id = new_global_rule(**kwargs)

说明

新增全局规则

参数
参数数据类型必选描述
conditionlistno该规则触发的条件
conseqdict or listno该规则中包含的动作
gidlistno用户组 id 列表
返回值

返回值为创建成功的全局规则的 id

"""
初始化客户端:
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_idnumberyes规则 id
conditionlistno规则的条件
conseqdict or listno规则的动作
gidlistno用户组 id 列表
"""
初始化客户端:
client = Edge2Client(host, username, password)

客户端登录:
client.login()
"""

# 假设已创建了 rule_id 为 1 的全局规则
rule_id = 1

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

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

回到目录

get_global_rule

ok = get_global_rule(rule_id)

说明

获取全局规则信息

参数
参数数据类型必选描述
rule_idnumberyes规则 id
"""
初始化客户端:
client = Edge2Client(host, username, password)

客户端登录:
client.login()
"""

# 假设已创建了 rule_id 为 1 的全局规则
rule_id = 1

data = client.get_global_rule(rule_id)

回到目录

get_global_action_by_name

rule_id = get_global_action_by_name(name)

说明

根据应用名获取全局自定义动作

"""
初始化客户端:
client = Edge2Client(host, username, password)

客户端登录:
client.login()
"""

# 假设已创建了 rule_name 为 `test-actions` 的全局规则
rule_name = 'test-actions'

rule_id = client.get_global_action_by_name(rule_name)

回到目录

get_all_global_rules

ok = get_all_global_rules()

说明

获取所有全局规则

"""
初始化客户端:
client = Edge2Client(host, username, password)

客户端登录:
client.login()
"""

# 创建了多个全局规则

data = client.get_all_global_rules()

回到目录

del_global_rule

ok = del_global_rule(rule_id)

说明

删除全局规则

参数
参数数据类型必选描述
rule_idnumberyes规则 id
"""
初始化客户端:
client = Edge2Client(host, username, password)

客户端登录:
client.login()
"""

# 假设已创建了 rule_id 为 1 的全局规则
rule_id = 1

ok = client.del_global_rule(rule_id)

回到目录

GLOBAL-VAR

new_global_var

var_id = new_global_var(**kwargs)

说明

新增全局变量

参数
参数数据类型必选描述
namestringyes变量名
var_typestringyes变量类型
defaultstringyes默认值
gidlistno用户组 id 列表
返回值

创建成功时返回变量 id

"""
初始化客户端:
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_idnumberyes变量 id
namestringyes变量名
var_typestringyes变量类型
defaultstringyes变量默认值
gidlistno用户组 id 列表
返回值

修改成功时返回 True,否则返回 False

"""
初始化客户端:
client = Edge2Client(host, username, password)

客户端登录:
client.login()
"""

##### 假设创建了 var_id 为 1 的全局变量
var_id = 1

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

回到目录

get_global_var

data = get_global_var(var_id)

说明

获取全局变量

参数数据类型必选描述
var_idnumberyes变量 id
"""
初始化客户端:
client = Edge2Client(host, username, password)

客户端登录:
client.login()
"""

# 假设创建了 var_id 为 1 的全局变量
var_id = 1

data = client.get_global_var(var_id)

回到目录

get_all_global_vars

data = get_all_global_vars()

说明

获取所有全局变量

返回值

list 类型,其中每个元素为 dict 类型,内容为全局变量的信息

"""
初始化客户端:
client = Edge2Client(host, username, password)

客户端登录:
client.login()
"""

# 假设创建了多个全局变量

# 获取当前所有全局变量的信息
data = client.get_all_global_vars()

回到目录

del_global_var

ok = del_global_var(var_id)

说明

根据全局变量 id 删除全局变量

"""
初始化客户端:
client = Edge2Client(host, username, password)

客户端登录:
client.login()
"""

# 已创建了 var_id 为 1 的全局变量
var_id = 1

ok = client.del_global_var(var_id)

回到目录

GLOBAL-NGX-CONF

提供全局 nginx 配置增删改查的接口

get_global_ngx_config

data = get_global_ngx_config()

说明

获取全局 nginx 配置信息

"""
初始化客户端:
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_buffernumberno访问日志的 buffer 大小
access_log_buffer_unit[‘k’, ’m’, ‘g’]no访问日志的 buffer 大小的单位
access_log_flushnumberno访问日志在内存中保留的最大时长
enable_access_logbooleanno是否启用访问日志
access_log_formatsdictno访问日志格式
avoid_gen_error_logbooleanno是否避免生成错误日志
client_body_timeoutnumberno客户端请求体超时时间
client_body_timeout_unit[’s’, ’m’]no客户端请求体超时时间单位
client_header_timeoutnumberno客户端请求头超时时间
client_header_timeout_unit[’s’, ’m’]no客户端请求头超时时间单位
client_max_body_sizenumberno客户端请求体最大大小
client_max_body_size_unit[‘k’, ’m’ ]no客户端请求体最大大小单位
client_header_buffer_sizenumberno客户端请求头 buffer 大小
client_header_buffer_size_unit[‘k’, ’m’ ]no客户端请求头 buffer 大小单位
max_client_request_line_sizenumberno客户端请求行最大大小,单位为 k
max_client_request_header_size[‘k’, ’m’ ]no客户端请求头最大大小,单位为 k

access_log_formats

参数数据类型必选描述
defaultbooleanno该日志格式是否为默认。注意:配置中至少有一个默认日志格式
namestringyes该访问日志格式的名字,需要保持全局唯一
formatstringyes该访问日志的格式,参照 nginx log_format 指令
"""
初始化客户端:
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()

说明

获取全局杂项配置信息

"""
初始化客户端:
client = Edge2Client(host, username, password)

客户端登录:
client.login()
"""

data = client.get_global_misc_config()

回到目录

set_global_misc_config

data = set_global_misc_config(opts)

设定全局杂项配置信息

"""
初始化客户端:
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 是否开启

"""
初始化客户端:
client = Edge2Client(host, username, password)

客户端登录:
client.login()
"""

status = client.get_request_id_status()

回到目录

enable_request_id

ok = enable_request_id()

说明

开启请求 id 功能

"""
初始化客户端:
client = Edge2Client(host, username, password)

客户端登录:
client.login()
"""

ok = client.enable_request_id()

回到目录

disable_request_id

ok = disable_request_id()

说明

禁用请求 id 功能

"""
初始化客户端:
client = Edge2Client(host, username, password)

客户端登录:
client.login()
"""

ok = client.disable_request_id()

回到目录

GLOBAL-WAF

new_global_waf_rule

rule_id = new_global_waf_rule(**kwargs)

说明

新增全局 WAF 规则

参数
参数数据类型必选描述
namestringyes规则名
codestringyes规则的 edge 语言代码
"""
初始化客户端:
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');")

回到目录

put_global_waf_rule

ok = put_global_waf_rule(**kwargs)

说明

修改全局 WAF 规则

参数
参数数据类型必选描述
rule_idnumberyes规则 id
namestringyes规则名
codestringyes规则的 edge 语言代码
"""
初始化客户端:
client = Edge2Client(host, username, password)

客户端登录:
client.login()
"""

# 假设创建了 waf_rule_id 为 1 的全局 waf 规则
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');")

回到目录

get_global_waf_rule

data = get_global_waf_rule(rule_id)

说明

根据 rule_id 获取全局 WAF 规则

"""
初始化客户端:
client = Edge2Client(host, username, password)

客户端登录:
client.login()
"""

# 假设创建了 waf_rule_id 为 1 的全局 waf 规则
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 规则

"""
初始化客户端:
client = Edge2Client(host, username, password)

客户端登录:
client.login()
"""

# 假设创建了 waf_rule_id 为 1 的全局 waf 规则
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 规则

参数
参数数据类型必选描述
detailboolno是否显示规则的详细信息,默认值为 False
"""
初始化客户端:
client = Edge2Client(host, username, password)

客户端登录:
client.login()
"""

# 假设创建了多个全局 waf 规则

data = client.get_all_global_waf_rules()

回到目录

GLOBAL-ACTION

new_global_action

rule_id = new_global_action(**kwargs)

说明

新增全局自定义动作

参数
参数数据类型必选描述
namestringyes自定义动作的名称
conditionlistno自定义动作执行的条件
conseqdict or listyes自定义动作
gidlistno用户组 id 列表
"""
初始化客户端:
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_idnumberyes自定义动作的 id
namestringno自定义动作的名称
conditionlistno自定义动作的执行条件
conseqdict or listno自定义动作
gidlistno用户组 id 列表
"""
初始化客户端:
client = Edge2Client(host, username, password)

客户端登录:
client.login()
"""

# 假设已创建了 action_id 为 1 的全局自定义动作
action_id = 1

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

回到目录

get_global_action

ok = get_global_action(action_id)

说明

获取全局自定义动作

参数
参数数据类型必选描述
action_idnumberyes自定义动作的 id
"""
初始化客户端:
client = Edge2Client(host, username, password)

客户端登录:
client.login()
"""

# 假设已创建了 action_id 为 1 的全局自定义动作
action_id = 1

data = client.get_global_action(action_id)

回到目录

del_global_action

ok = del_global_action(action_id)

说明

删除指定的全局自定义动作

参数
参数数据类型必选描述
action_idnumberyes自定义动作的 id
"""
初始化客户端:
client = Edge2Client(host, username, password)

客户端登录:
client.login()
"""

# 假设已创建了 action_id 为 1 的全局自定义动作
action_id = 1

ok = client.del_global_action(action_id)

回到目录

count_global_actions

count = count_global_actions()

说明

获取全局自定义动作的数量。

"""
初始化客户端:
client = Edge2Client(host, username, password)

客户端登录:
client.login()
"""


count = client.count_global_actions()

回到目录

get_all_global_actions

data = get_all_global_actions()

说明

获取所有全局自定义动作。

参数
参数数据类型必选描述
pagenumberno第几页
pagesizenumberno页大小
"""
初始化客户端:
client = Edge2Client(host, username, password)

客户端登录:
client.login()
"""

data = client.get_all_global_actions()

回到目录

STATIC-FILE

upload_static_file

file_id = upload_static_file(**kwargs)

说明

上传静态文件

参数
参数数据类型必选描述
contentstringyes静态文件的内容
labelstringyes静态文件的标签
file_typestringno静态文件的类型
gidlistno用户组 id 列表
"""
初始化客户端:
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_idnumberyes静态文件的 ID
"""
初始化客户端:
client = Edge2Client(host, username, password)

客户端登录:
client.login()
"""

# 假设已上传了 file_id 为 1 的静态文件
file_id = 1

data = client.get_static_file(file_id)

回到目录

del_static_file

ok = del_static_file(file_id)

说明

删除已上传静态文件

参数
参数数据类型必选描述
file_idnumberyes静态文件的 ID
"""
初始化客户端:
client = Edge2Client(host, username, password)

客户端登录:
client.login()
"""

# 假设已上传了 file_id 为 1 的静态文件
file_id = 1

ok = client.del_static_file(file_id)

回到目录

CLUSTER-GROUP

new_cluster_group

group_id = new_cluster_group(group_name)

说明

新增集群组

参数
参数数据类型必选描述
group_namestringyes集群组的名字
"""
初始化客户端:
client = Edge2Client(host, username, password)

客户端登录:
client.login()
"""

group_id = client.new_cluster_group('foo')

回到目录

put_cluster_group

ok = put_cluster_group(**kwargs)

说明

修改集群组

参数
参数数据类型必选描述
group_idnumberyes集群组的 id
group_namestringyes集群组的名字
"""
初始化客户端:
client = Edge2Client(host, username, password)

客户端登录:
client.login()
"""

# 假设已创建 group_id 为 1 的集群组
group_id = 1

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

回到目录

get_cluster_group

data = get_cluster_group(group_id)

说明

获取集群组信息

参数
参数数据类型必选描述
group_idnumberyes集群组的 id
"""
初始化客户端:
client = Edge2Client(host, username, password)

客户端登录:
client.login()
"""

# 假设已创建 group_id 为 1 的集群组
group_id = 1

data = client.get_cluster_group(group_id)

回到目录

get_all_cluster_groups

data = get_all_cluster_groups()

说明

获取所有集群组信息

"""
初始化客户端:
client = Edge2Client(host, username, password)

客户端登录:
client.login()
"""

# 假设已创建了多个集群组

# 获取多个集群组信息
data = client.get_all_cluster_groups()

回到目录

del_cluster_group

ok = del_cluster_group(group_id)

说明

删除集群组信息

参数
参数数据类型必选描述
group_idnumberyes集群组的 id
"""
初始化客户端:
client = Edge2Client(host, username, password)

客户端登录:
client.login()
"""

# 假设已创建 group_id 为 1 的集群组
group_id = 1

ok = client.del_cluster_group(group_id)

回到目录

put_proxy_rule

ok = put_proxy_rule(**kwargs)

说明

修改上游代理规则

参数
参数数据类型必选描述
rule_idnumberyes规则 id
proxylistyes代理的规则
"""
初始化客户端:
client = Edge2Client(host, username, password)

客户端登录:
client.login()
"""

# 假设已创建了 rule_id 为 1 的代理规则
rule_id = 1

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

回到目录

GLOBAL-K8S

new_global_k8s

添加 k8s 集群连接参数,添加以后 admin 会有后台线程通过此设置的参数连接到 k8s 集群中监控 k8s 信息。

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

说明

新增 k8s 集群连接参数

参数
参数数据类型必选描述
namestringyesk8s 集群的名字
hoststringnok8s 集群的地址
domainstringnok8s 集群的域名,host或 domain 需要一个,且只能填一个
portnumberyesk8s 集群的端口
connect_timeoutnumbernok8s 集群的连接超时时间, 单位秒,默认 5 秒
read_timeoutnumbernok8s 集群的读数据超时时间, 单位秒,默认 5 秒
ssl_verifyboolno是否需要 SSL 校验
tokenstringyesk8s 集群的 api token
"""
初始化客户端:
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

修改 k8s 集群连接参数

ok = put_global_k8s(**kwargs)

说明

修改 k8s 集群连接参数

参数
参数数据类型必选描述
k8s_idnumberyesk8s 集群id
namestringnok8s 集群的名字
hoststringnok8s 集群的地址
domainstringnok8s 集群的域名,host或 domain 需要一个,且只能填一个
portnumbernok8s 集群的端口
connect_timeoutnumbernok8s 集群的连接超时时间, 单位秒
read_timeoutnumbernok8s 集群的读数据超时时间, 单位秒
ssl_verifyboolno是否需要 SSL 校验
tokenstringnok8s 集群的 api token
"""
初始化客户端:
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

获取 k8s 集群连接参数信息。

data = get_global_k8s(k8s_id)

说明

获取 k8s 集群连接参数信息

参数
参数数据类型必选描述
k8s_idnumberyesk8s集群id
"""
初始化客户端:
client = Edge2Client(host, username, password)

客户端登录:
client.login()
"""

data = client.get_global_k8s(k8s_id = 1)

回到目录

get_k8s_service_detail

获取 k8s 集群服务的详细信息

data = get_k8s_service_detail()

说明

获取 k8s 集群中定义的服务相关信息

参数
参数数据类型必选描述
k8s_idnumberyesk8s集群id
"""
初始化客户端:
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()

说明

获取所有的 k8s 集群id

"""
初始化客户端:
client = Edge2Client(host, username, password)

客户端登录:
client.login()
"""

data = client.get_all_k8s()

del_global_k8s

删除 k8s 集群连接信息

ok = del_global_k8s(k8s_id)

说明

删除 k8s 集群连接参数

参数
参数数据类型必选描述
k8s_idnumberyesk8s集群id
"""
初始化客户端:
client = Edge2Client(host, username, password)

客户端登录:
client.login()
"""

ok = client.del_global_k8s(k8s_id = 1)

回到目录

put_proxy_rule

ok = put_proxy_rule(**kwargs)

说明

修改上游代理规则

参数
参数数据类型必选描述
rule_idnumberyes规则 id
proxylistyes代理的规则
"""
初始化客户端:
client = Edge2Client(host, username, password)

客户端登录:
client.login()
"""

# 假设已创建了 rule_id 为 1 的代理规则
rule_id = 1

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

回到目录

GLOBAL-IP-LIST

提供全局级别的 IP 列表

new_global_ip_list

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

新增全局级别 IP 列表

参数
参数数据类型必选描述
namestringyes全局级别 IP 列表的名字
typestringnoIP 地址的类型,目前支持 ipv4ipv6(coming soon)
itemsarraynoIP 地址列表
items
参数类型必选描述
ipstringyesIP 地址
# do some prepare
# ...
# client login success

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_idnumberyes指定全局级别 IP 列表的 ID
namestringyes全局级别 IP 列表的名字
typestringnoIP 地址的类型,目前支持 ‘ipv4’ 或 ‘ipv6’(coming soon)
itemsarraynoIP 地址列表
items
参数类型必选描述
ipstringyesIP 地址
# do some prepare
# ...
# client login success

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

del_global_ip_list

data = del_global_ip_list(rule_id=None)

删除指定的全局级别 IP 列表

参数
参数数据类型必选描述
rule_idnumberyes指定全局级别 IP 列表的 ID
# do some prepare
# ...
# client login success

ok = client.del_global_ip_list(rule_id=1)

get_global_ip_list

data = get_global_ip_list(rule_id=None)

查看指定的全局 IP 列表

参数
参数数据类型必选描述
rule_idnumberyes指定全局级别 IP 列表的 ID
# do some prepare
# ...
# client login success

data = client.get_global_ip_list(rule_id=1)

USER-VAR

提供用户级别的一些操作接口

new_user_var

var_id = new_user_var(**kwargs)

说明

新增用户级别变量

参数

参数数据类型必选描述
namestringyes变量名
var_typestringyes变量类型
defaultstringyes变量默认值

"""
初始化客户端:
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_idnumberyes变量 id
namestringyes变量名
var_typestringyes变量类型
defaultstringyes变量默认值

"""
初始化客户端:
client = Edge2Client(host, username, password)

客户端登录:
client.login()
"""

# 假设已创建 var_id 为 1 的用户级别变量
var_id = 1

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

回到目录

get_user_var

data = get_user_var(var_id)

说明

获取用户级别变量

参数

参数数据类型必选描述
var_idnumberyes变量 id

"""
初始化客户端:
client = Edge2Client(host, username, password)

客户端登录:
client.login()
"""

# 假设已创建 var_id 为 1 的用户级别变量
var_id = 1

data = client.get_user_var(var_id)

回到目录

del_user_var

ok = del_user_var(var_id)

说明

删除用户级别变量

参数

参数数据类型必选描述
var_idnumberyes变量 id

"""
初始化客户端:
client = Edge2Client(host, username, password)

客户端登录:
client.login()
"""

# 假设已创建 var_id 为 1 的用户级别变量
var_id = 1

ok = client.del_user_var(var_id)

回到目录

UTILS

decode_request_id

说明

对 request_id 解析得到 app_id 等信息

"""
初始化客户端:
client = Edge2Client(host, username, password)

客户端登录:
client.login()

"""

data = client.decode_request_id('00000a00000c0826c9803222')

# {u'timestamp': 1531859760, u'node_id': 20, u'app_id': 3, u'is_stream': False, u'sequence': 12834}
print(data)

回到目录

search_waf_log

data = search_waf_log(request_id)

说明

根据请求 id 和应用 id 来获取 WAF 日志。

参数

参数数据类型必选描述
request_idstringyes请求 id

"""
初始化客户端:
client = Edge2Client(host, username, password)

客户端登录:
client.login()
"""

request_id = "0000008000042c421ea80011"

data = client.search_waf_log(request_id)

回到目录

get_version

data = get_version()

说明

获取 Admin 、 Admin DB 、Log Server、 Log Server DB 、 WAF 的版本。

"""
初始化客户端:
client = Edge2Client(host, username, password)

客户端登录:
client.login()
"""

data = client.get_version()

回到目录

API-TOKEN

add_api_token

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

说明

生成 API Token

参数

参数数据类型必选描述
namestringnoapi token 名称
expirenumbernoapi token 过期时间

"""
初始化客户端:
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 Token

参数

参数数据类型必选描述
idnumbernoapi token 名称
limitnumberno数量限制

"""
初始化客户端:
client = Edge2Client(host, username, password)

客户端登录:
client.login()
"""

data = client.get_api_token(id)

# 或

data = client.get_api_token(None, 100)

回到目录

del_api_token

data = del_api_token(id)

说明

删除一个 API Token

参数

参数数据类型必选描述
idnumbernoapi token 名称

"""
初始化客户端:
client = Edge2Client(host, username, password)

客户端登录:
client.login()
"""

data = client.del_api_token(id)

回到目录

GATEWAY

get_all_gateway_tag

tags = get_all_gateway_tag()

说明

获取所有网关集群的标签。

"""
初始化客户端:
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()

说明

获取所有网关集群。

"""
初始化客户端:
client = Edge2Client(host, username, password)

客户端登录:
client.login()
"""

gateways = client.get_all_gateway()

for i, gateway in enumerate(gateways):
    print(i, gateway)

回到目录

get_all_nodes

nodes = get_all_nodes()

说明

获取所有网关节点。

"""
初始化客户端:
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_idnumberyes节点 ID
gateway_idnumberno网关集群 ID,当不指定时,将通过遍历查找到对应的节点

"""
初始化客户端:
client = Edge2Client(host, username, password)

客户端登录:
client.login()
"""

node = client.get_node(1)
node = client.get_node(1, gateway_id=1)

回到目录

put_node

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

说明

更新节点信息。

参数

参数数据类型必选描述
node_idnumberyes节点 ID
gateway_idnumberno网关集群 ID,当不指定时,将通过遍历查找到对应的节点
namestringno节点名称
is_grayboolno设置/取消设置灰度节点
statusnumberno0: 禁用 DNS,开启集群缓存, 1: 开启 DNS,开启集群缓存, 2: 关闭 DNS,关闭集群缓存
external_ipstringno公网 IP
external_ipv6stringno公网 IPv6
internal_ipstringno内网 IP

"""
初始化客户端:
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')

回到目录