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,供后续使用
参数
参数 | 数据类型 | 必选 | 描述 |
---|---|---|---|
host | string | yes | edge-admin 的地址,包含协议与端口 |
username | string | yes | edge-admin 的用户名 |
password | string | yes | edge-admin 的密码 |
api_token | string | no | access 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 应用
参数
参数 | 数据类型 | 必选 | 描述 |
---|---|---|---|
domains | list | yes | 应用的域名 |
label | string | yes | 应用的名称 |
cluster_groups | list | no | 应用所在的集群组 |
返回值
返回 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_id | number | yes | 应用的 id |
domains | list | yes | 应用的域名 |
label | string | yes | 应用的名称 |
cluster_groups | list | no | 应用所在的集群组 |
offline | bool | no | 应用是否下线 |
返回值
修改成功返回 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_id | number | yes | 应用的 id |
limiter | dict | yes | 应用的 limiter 配置 |
enable_websocket | bool | no | 开启 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_id | number | yes | 应用的 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_id | number | yes | 应用的 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_domain | string | yes | 搜索的域名 |
page | number | no | 返回结果的页码,默认值为 1 |
pagesize | number | no | 返回结果的条目数,默认值为 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 应用
参数
参数 | 数据类型 | 必选 | 描述 |
---|---|---|---|
keyword | string | yes | 搜索的关键字,同时搜索域名和名称 |
page | number | no | 返回结果的页码,默认值为 1 |
pagesize | number | no | 返回结果的条目数,默认值为 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 搜索上游。
参数
参数 | 数据类型 | 必选 | 描述 |
---|---|---|---|
ip | string | yes | 搜索的 IP |
page | number | no | 返回结果的页码,默认值为 1 |
pagesize | number | no | 返回结果的条目数,默认值为 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 搜索上游。
参数
参数 | 数据类型 | 必选 | 描述 |
---|---|---|---|
ip | string | yes | 搜索的 IP |
page | number | no | 返回结果的页码,默认值为 1 |
pagesize | number | no | 返回结果的条目数,默认值为 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)
说明
以名称搜索上游。
参数
参数 | 数据类型 | 必选 | 描述 |
---|---|---|---|
name | string | yes | 搜索的名称 |
page | number | no | 返回结果的页码,默认值为 1 |
pagesize | number | no | 返回结果的条目数,默认值为 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)
说明
以名称搜索上游。
参数
参数 | 数据类型 | 必选 | 描述 |
---|---|---|---|
name | string | yes | 搜索的名称 |
page | number | no | 返回结果的页码,默认值为 1 |
pagesize | number | no | 返回结果的条目数,默认值为 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 上游。
参数
参数 | 数据类型 | 必选 | 描述 |
---|---|---|---|
namespace | string | no | 搜索的命名空间 |
service | string | no | 搜索的服务名称 |
port | number | no | 搜索的端口号 |
page | number | no | 返回结果的页码,默认值为 1 |
pagesize | number | no | 返回结果的条目数,默认值为 20 |
type_list | list | no | 搜索的上游类型列表, 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上游。
参数
参数 | 数据类型 | 必选 | 描述 |
---|---|---|---|
page | number | no | 返回结果的页码,默认值为 1 |
pagesize | number | no | 返回结果的条目数,默认值为 20 |
start_time | number | no | 开始时间戳 |
end_time | number | no | 结束时间戳 |
返回值
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)
说明
获取所有的应用信息
参数
参数 | 数据类型 | 必选 | 描述 |
---|---|---|---|
detail | bool | no | 是否返回应用的详情,默认为 False |
返回值
当 detail
为 False
时,返回值 data
类型为 list
当 detail
为 True
时,返回值 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
参数
参数 | 数据类型 | 必选 | 描述 |
---|---|---|---|
name | string | yes | 上游名称 |
servers | list | yes | 上游节点信息 |
ssl | bool | no | 是否使用 HTTPS 协议,默认为 False |
health_checker | dict | no | 对健康检查的详细配置,默认为 None |
gid | array | yes | 用户组 id 列表, 比如[1] |
servers
参数 | 数据类型 | 必选 | 描述 |
---|---|---|---|
domain | string | no | 上游的域名 |
ip | string | no | 上游的 IP 。其中 domain 和 IP 两者至少需要填一项 |
port | string | yes | 上游的端口 |
weight | number | no | 上游的权重,默认为 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)
说明
修改上游节点信息
参数
参数 | 数据类型 | 必选 | 描述 |
---|---|---|---|
name | string | yes | 上游名称 |
servers | list | yes | 上游节点信息 |
ssl | bool | no | 是否使用 HTTPS 协议,默认为 False |
health_checker | dict | no | 对健康检查的详细配置,默认为 None |
gid | array | yes | 用户组 id 列表, 比如[1] |
servers
参数 | 数据类型 | 必选 | 描述 |
---|---|---|---|
domain | string | no | 上游的域名 |
ip | string | no | 上游的 IP 。其中 domain 和 IP 两者至少需要填一项 |
port | string | yes | 上游的端口 |
weight | number | no | 上游的权重,默认为 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_id | string | no | 上游的 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_id | string | no | 上游的 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
参数
参数 | 数据类型 | 必选 | 描述 |
---|---|---|---|
name | string | yes | 上游名称 |
k8s_services (见下表) | list | yes | 上游节点是k8s服务时的信息 |
ssl | bool | no | 是否使用 HTTPS 协议,默认为 False |
health_checker | dict | no | 对健康检查的详细配置,默认为 None |
gid | array | yes | 用户组id列表, 比如[1] |
k8s_services 参数 | 数据类型 | 必选 | 描述 |
---|---|---|---|
k8s | number | yes | k8s集群id |
k8s_namespace | string | yes | k8s集群命名空间 |
k8s_service | string | yes | k8s集群服务 |
k8s_service_port | number | yes | k8s集群服务端口 |
返回值
返回值为创建上游节点的 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_id | string | yes | 被复制的上游的 ID |
k8s_services (见下表) | list | yes | 上游节点是 k8s 服务时的信息 |
rules | array | no | 遍历 rules 中的规则,凡是使用到原上游的都迁移到 k8s 上游,如果不提供这个参数,函数会查出本 app 的所有规则来做遍历, 使用这个参数可防止函数多次自动查询所有的规则 |
k8s_services 参数 | 数据类型 | 必选 | 描述 |
---|---|---|---|
k8s | number | yes | k8s集群id |
k8s_namespace | string | yes | k8s集群命名空间 |
k8s_service | string | yes | k8s集群服务 |
k8s_service_port | number | yes | k8s集群服务端口 |
返回值
返回值为创建上游节点的 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)
说明
修改上游节点信息
参数
参数 | 数据类型 | 必选 | 描述 |
---|---|---|---|
name | string | yes | 上游名称 |
k8s_services (见下表) | list | yes | 上游节点是 k8s 服务时的信息 |
ssl | bool | no | 是否使用 HTTPS 协议,默认为 False |
health_checker | dict | no | 对健康检查的详细配置,默认为 None |
gid | array | yes | 用户组 ID 列表, 比如[1] |
k8s_services
k8s_services 参数 | 数据类型 | 必选 | 描述 |
---|---|---|---|
k8s | number | yes | k8s集群id |
k8s_namespace | string | yes | k8s集群命名空间 |
k8s_service | string | yes | k8s集群服务 |
k8s_service_port | number | yes | k8s集群服务端口 |
例
"""
初始化客户端:
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_id | string | yes | 上游的 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_id | string | yes | 上游的 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 规则,缓存规则。还可以指定规则执行的前提条件。
参数
参数 | 数据类型 | 必选 | 描述 |
---|---|---|---|
condition | list | no | 条件 |
conseq | dict or list | no | 动作 |
waf | list | no | WAF 规则 |
proxy | list | no | 代理规则 |
cache | list | no | 缓存规则 |
content | list | no | 内容规则 |
top | number | no | 1:置顶规则,-1:置底规则 |
order | number | no | 规则顺序,优先级低于 top 参数 |
last | boolean | no | 如果命中此条规则的话跳过所有余下的页面规则,默认为 False |
reorder | boolean | no | 是否重建 order 的值,默认为 False |
返回值
返回创建规则的 rule_id
condition
参数 | 数据类型 | 必选 | 描述 |
---|---|---|---|
var | string or array | yes | 如果是 string 类型,则填写变量名 name (此时为字符串类型)。若是 array 类型则需要填写 变量名 name 和参数 args (此时为数组类型,详见用例) |
op | string | no | 操作符,默认为 eq ,即字符串相等 (equal) |
val | string | either val or vals | string 类型或者 array 类型, 需要指定为正则或者通配类型时,传 [正则表达式, 'rx'] , [通配表达式, 'wc'] |
vals | list | either val or vals | val 的集合 |
conseq
参数 | 数据类型 | 必选 | 描述 |
---|---|---|---|
edge 语言内建函数 | string | yes | edge 语言内建函数 |
edge 语言内建函数的参数 | list | yes | edge 语言的内建函数 |
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_sets | list | no | 全局默认的用户规则集,默认值为一个空列表 |
robots | bool | no | 是否启用该规则,默认值为 False |
generic | bool | no | 是否启用该规则,默认值为 False |
inject | bool | no | 是否启用该规则,默认值为 False |
trojans | bool | no | 是否启用该规则,默认值为 False |
xss | bool | no | 是否启用该规则,默认值为 False |
action | string | yes | log , 403 Forbidden , edge-captcha , redirect 中的一个 |
threshold | string | yes | high , medium , low 中的一个 |
clearance | number | no | captcha 触发后的持续时间,默认值为 60 秒 |
redirect_url | string | no | 当动作为 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
数组的描述:
参数 | 数据类型 | 必选 | 描述 |
---|---|---|---|
upstreams | list | yes | 上游节点信息 |
backup_upstreams | list | yes | 上游备份节点信息 |
upstreams_el_code | str | yes | Edgelang设置上游 |
timeout | number | no | 代理超时时间,默认值为 3 秒 |
connect_timeout | number | no | 连接超时时间,默认值为 3 秒 |
read_timeout | number | no | 读超时时间,默认值为 3 秒 |
send_timeout | number | no | 发送超时时间,默认值为 3 秒 |
retries | number | no | 重试次数,默认值为 1 次 |
retry_condition | list | no | 重试条件,默认值为 [“error”, “timeout”, “invalid_header”, “http_500”, “http_502”, “http_504”]. 还有如下选项可选 http_503 , http_403 , http_404 , http_429 和 non_valueempotent (即方法可以是 POST, LOCK, PATCH) |
balancer_algorithm | string | no | 负载均衡算法,默认值为 roundrobin 。支持的算法还有 hash 和 chash |
balancer_vars | list | no | 负载均衡算法所依赖的变量,当负载均衡算法选择为 hash 或 chash 时需要填写该字段 |
multi_tier | number | no | 多层网络策略 ID |
upstreams
对参数中 upstreams
与 backup_upstreams
数组的描述
参数 | 数据类型 | 必选 | 描述 |
---|---|---|---|
upstream | number | yes | 上游的 ID |
global_upstream | number | yes | 全局上游的 ID |
k8s_upstream | number | yes | k8s上游的 id |
global_k8s_upstream | number | yes | 全局 k8s 上游的 ID |
weight | number | no | 上游的权重,默认值为 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_key | list | yes | 缓存 key |
default_ttls | list | no | 是否启用默认缓存,默认值为 None |
browser_ttl | number | no | 是否启用浏览器缓存,默认值为 None |
browser_ttl_unit | string | no | 浏览器缓存单位,只在 browser_ttl 设置后有效,默认值为 min |
enable_global | boolean | no | 是否启用跨域名缓存,默认值为 False |
enforce_cache | boolean | no | 是否启用始终缓存,默认值为 False |
cluster_hash | boolean | no | 是否启用集群缓存,默认值为 False |
disable_convert_head | boolean | no | 是否将 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
参数 | 数据类型 | 必选 | 描述 |
---|---|---|---|
favicon | number | 和 empty_gif 二选一 | 文件 id |
empty_gif | boolean | 和 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)
说明
修改页面规则
参数
参数 | 数据类型 | 必选 | 描述 |
---|---|---|---|
condition | list | no | 规则条件 |
conseq | dict or list | no | 规则动作 |
waf | list | no | WAF 规则 |
proxy | list | no | 代理规则 |
cache | list | no | 缓存规则 |
content | list | no | 内容规则 |
top | number | no | 1:置顶规则 -1:置底规则 |
order | number | no | 规则顺序,优先级低于 top 参数 |
last | boolean | no | 如果命中此条规则的话跳过所有余下的页面规则,默认为 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_id | number | yes | 规则的 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_id | number | yes | 规则的 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_id | number | no | 应用的 id,默认值为当前应用的 id |
返回值
list
类型的规则集,其中的每个元素值与 get_rule 返回值类型相同
例
"""
初始化客户端:
client = Edge2Client(host, username, password)
客户端登录:
client.login()
"""
# 假设已创建 app_id 为 1 的应用
# 假设在 app_id 为 1 的应用上新增了多个规则
data = client.get_all_rules()
reorder_rules
ok = reorder_rules(orders)
说明
调整规则的顺序。
参数
参数 | 数据类型 | 必选 | 描述 |
---|---|---|---|
orders | dict | yes | 新的规则顺序,key 表示规则 ID,value 表示规则顺序 |
返回值
True 表示成功,False 表示失败。
例
"""
初始化客户端:
client = Edge2Client(host, username, password)
客户端登录:
client.login()
"""
# 调换规则 ID 2 和 3 的顺序
new_orders = {
1: 1,
2: 3,
3: 2,
}
data = client.reorder_rules(new_orders)
*get_all_rules_by_app_domain
reorder_rulesreorder_rulesreorder_rules
rules = get_all_rules_by_app_domain(domain)
说明
根据应用规则获取相对应的页面规则
参数
参数 | 数据类型 | 必选 | 描述 |
---|---|---|---|
domain | string | yes | 应用的域名 |
例
"""
初始化客户端:
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_ip | string | yes | 上游的 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_id | number | no | 应用的 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_id | number | no | 应用的 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 证书,手动上传证书
参数
参数 | 数据类型 | 必选 | 描述 |
---|---|---|---|
key | string | yes | 私钥的内容 |
cert | string | no | 证书的内容 |
ca_chain | string | no | CA 链的内容 |
global_cert_id | number | no | 证书全局 id |
gid | list | no | 用户组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 证书
参数
参数 | 数据类型 | 必选 | 描述 |
---|---|---|---|
domains | string array | yes | 需要自动获取 LE 证书的域名 |
gid | list | no | 用户组 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_id | number | yes | 证书的 id |
key | string | yes | 私钥的内容 |
cert | string | no | 服务端证书的内容 |
ca_chain | string | no | CA 链的内容 |
global_cert_id | number | no | 证书的全局 id |
gid | list | no | 用户组 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 证书
参数
参数 | 数据类型 | 必选 | 描述 |
---|---|---|---|
domains | string array | yes | 需要自动获取 LE 证书的域名 |
gid | list | no | 用户组 id 列表 |
resign | boolean | no | 是否需要触发重新签发证书 |
例
"""
初始化客户端:
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_id | number | yes | 证书 ID |
返回值
data
参数 | 数据类型 | 描述 |
---|---|---|
status | string | 证书签发状态:valid / pending / invalid |
expdate | number | 证书过期时间 (Unix 时间戳) |
next_udpate | number | 证书下次更新时间 (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_id | number | yes | 证书的 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_id | number | yes | 证书的 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 语言代码
参数
参数 | 数据类型 | 必选 | 描述 |
---|---|---|---|
phase | string | yes | edge 语言执行阶段 |
code | string | yes | edge 语言代码 |
post | bool | yes | 值为 True 时将该段代码在所选阶段的后面执行,默认值为 False |
pre | bool | yes | 值为 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)
说明
新增应用级用户
参数
参数 | 数据类型 | 必选 | 描述 |
---|---|---|---|
name | string | yes | 用户名 |
read | bool | no | 是否有读权限,默认为 True |
write | bool | no | 是否有写权限,默认为 True |
release | bool | no | 是否有发布更动的权限,默认为 False |
dns_read | bool | no | 是否有读 DNS 的权限,默认为 False |
dns_write | bool | no | 是否有写 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)
说明
修改应用级用户
参数
参数 | 数据类型 | 必选 | 描述 |
---|---|---|---|
id | list | yes | 用户 id |
name | string | yes | 用户名 |
read | bool | no | 是否有读权限,默认为 True |
write | bool | no | 是否有写权限,默认为 True |
release | bool | no | 是否有发布更动的权限,默认为 False |
dns_read | bool | no | 是否有读 DNS 的权限,默认为 False |
dns_write | bool | no | 是否有写 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)
说明
获取应用级用户信息:包括用户名、权限等
参数
参数 | 数据类型 | 必选 | 描述 |
---|---|---|---|
id | list | no | 用户 id |
name | string | no | 用户名 |
app_id | number | no | 应用 id,默认为当前应用 id |
user_id | number | no | 全局用户 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)
说明
删除应用级用户
参数
参数 | 数据类型 | 必选 | 描述 |
---|---|---|---|
id | list | no | 用户 id |
name | string | no | 用户名 |
app_id | number | no | 应用 id,默认为当前应用 |
user_id | number | no | 全局用户 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_id | number | no | 应用 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)
说明
为所有应用添加用户
参数
参数 | 数据类型 | 必选 | 描述 |
---|---|---|---|
name | string | no | 全局的用户名 |
read | bool | no | 是否有读权限,默认为 True |
write | bool | no | 是否有写权限,默认为 True |
release | bool | no | 是否有发布更动的权限,默认为 False |
dns_read | bool | no | 是否有读 DNS 的权限,默认为 False |
dns_write | bool | no | 是否有写 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_id | number | no | 应用 id,默认为当前应用 id |
read | bool | no | 是否有读权限,默认为 True |
write | bool | no | 是否有写权限,默认为 True |
release | bool | no | 是否有发布更动的权限,默认为 False |
dns_read | bool | no | 是否有读 DNS 的权限,默认为 False |
dns_write | bool | no | 是否有写 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)
说明
新增条件刷新任务,条件参数为数组,可以输入多个条件。多个条件同时成立时,则触发刷新任务。
参数
参数 | 数据类型 | 必选 | 描述 |
---|---|---|---|
condition | list | no | 条件 |
返回值
刷新任务 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_id | number | yes | 刷新任务 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_id | number | yes | 刷新任务 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 白名单规则
参数
参数 | 数据类型 | 必选 | 描述 |
---|---|---|---|
condition | list | no | 规则执行的条件 |
rule_sets | list | yes | waf 规则的 id 列表 |
WAF Condition
参数 | 数据类型 | 必选 | 描述 |
---|---|---|---|
var | string or array | yes | edge 语言内置的函数名,当类型为 array 时,则在函数名后跟着该函数所需的参数 |
op | string | no | 操作符,默认为 eq |
val | string | val / vals 二选一 | 值 |
vals | list | val / 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_id | number | yes | 白名单的 id |
condition | list | no | 规则的执行条件 |
rule_sets | list | yes | waf 的 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 列表
参数
参数 | 数据类型 | 必选 | 描述 |
---|---|---|---|
name | string | yes | IP 列表的名字 |
type | string | no | IP 地址的类型,目前支持 ipv4 或 ipv6 (coming soon) |
items | array | no | IP 地址列表 |
items
参数 | 类型 | 必选 | 描述 |
---|---|---|---|
ip | string | yes | IP 地址 |
例
# 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_id | number | yes | 指定 IP 列表的 ID |
name | string | yes | IP 列表的名字 |
type | string | no | IP 地址的类型,目前支持 ‘ipv4’ 或 ‘ipv6’(coming soon) |
items | array | no | IP 地址列表 |
items
参数 | 类型 | 必选 | 描述 |
---|---|---|---|
ip | string | yes | IP 地址 |
例
# 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_id | number | yes | 指定 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_id | number | yes | 指定 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_id | number | yes | 网关 Node 的 ID |
start_time | number | no | 开始时间 |
end_time | number | no | 结束时间 |
step | number | no | 统计间隔 |
更改当前实例操作的 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_id | number | yes | DNS 应用的 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 应用
参数
参数 | 数据类型 | 必选 | 描述 |
---|---|---|---|
zone | string | yes | 域名 |
authority | list | yes | NS 记录 |
soa_email | string | no | SOA 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_id | number | yes | DNS 应用的 id |
zone | string | yes | DNS 的域名记录 |
authority | list | yes | DNS 的 NS 记录 |
soa_email | string | no | DNS 的 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_id | number | yes | DNS 应用的 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_id | number | yes | DNS 应用的 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_domain | string | yes | 子域名 |
line | string | yes | 线路, 同目录下的 Line.txt 为 |
record_type | string | yes | 记录的类型,[A, TXT, MX, CNAME, CAA] 可选 |
text | string | no | 当记录类型为 [TXT, CAA] 时,需要填写该字段 |
ip | string | no | 当响应为 IP 类型时,需要填写该字段 |
gateway | number | no | 当响应指定的网关集群时,需要填写该字段 |
domain | string | no | 当响应为域名类型时,需要填写该字段 |
priority | number | no | 当记录类型为 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_id | number | yes | DNS 记录的 id |
sub_domain | string | yes | 子域名 |
line | string | yes | 线路, 同目录下的 Line.txt 为 |
record_type | string | yes | 记录的类型,[A, TXT, MX, CNAME, CAA] 可选 |
text | string | no | 当记录类型为 [TXT, CAA] 时,需要填写该字段 |
ip | string | no | 当响应为 IP 类型时,需要填写该字段 |
domain | string | no | 当响应为域名类型时,需要填写该字段 |
priority | number | no | 当记录类型为 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_id | number | yes | DNS 记录的 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_id | number | yes | DNS 记录的 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
参数
参数 | 数据类型 | 必选 | 描述 |
---|---|---|---|
name | string | yes | 上游名称 |
servers (见下表) | list | yes | 上游节点信息 |
ssl | bool | no | 是否使用 HTTPS 协议,默认为 False |
health_checker | dict | no | 对健康检查的详细配置,默认为 None |
gid | array | yes | 用户组 id 列表, 比如[1] |
servers 参数 | 数据类型 | 必选 | 描述 |
---|---|---|---|
domain | string | no | 上游的域名 |
ip | string | no | 上游的 IP 。其中 domain 和 IP 两者至少需要填一项 |
port | string | yes | 上游的端口 |
weight | number | no | 上游的权重,默认为 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)
说明
修改上游节点信息
参数
参数 | 数据类型 | 必选 | 描述 |
---|---|---|---|
name | string | yes | 上游名称 |
servers (见下表) | list | yes | 上游节点信息 |
ssl | bool | no | 是否使用 HTTPS 协议,默认为 False |
health_checker | dict | no | 对健康检查的详细配置,默认为 None |
gid | array | yes | 用户组 id 列表, 比如[1] |
servers 参数 | 数据类型 | 必选 | 描述 |
---|---|---|---|
domain | string | no | 上游的域名 |
ip | string | no | 上游的 IP 。其中 domain 和 IP 两者至少需要填一项 |
port | string | yes | 上游的端口 |
weight | number | no | 上游的权重,默认为 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_id | string | no | 上游的 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_id | string | no | 上游的 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
参数
参数 | 数据类型 | 必选 | 描述 |
---|---|---|---|
name | string | yes | 上游名称 |
k8s_services | list | yes | 上游节点是k8s服务时的信息 |
ssl | bool | no | 是否使用 HTTPS 协议,默认为 False |
health_checker | dict | no | 对健康检查的详细配置,默认为 None |
gid | array | yes | 用户组id列表, 比如[1] |
k8s_services
参数 | 数据类型 | 必选 | 描述 |
---|---|---|---|
k8s | number | yes | k8s集群id |
k8s_namespace | string | yes | k8s集群命名空间 |
k8s_service | string | yes | k8s集群服务 |
k8s_service_port | number | yes | k8s集群服务端口 |
返回值
返回值为创建上游节点的 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)
说明
修改上游节点信息
参数
参数 | 数据类型 | 必选 | 描述 |
---|---|---|---|
name | string | yes | 上游名称 |
k8s_services (见下表) | list | yes | 上游节点是 k8s 服务时的信息 |
ssl | bool | no | 是否使用 HTTPS 协议,默认为 False |
health_checker | dict | no | 对健康检查的详细配置,默认为 None |
gid | array | yes | 用户组 id 列表, 比如[1] |
k8s_services 参数 | 数据类型 | 必选 | 描述 |
---|---|---|---|
k8s | number | yes | k8s 集群id |
k8s_namespace | string | yes | k8s 集群命名空间 |
k8s_service | string | yes | k8s 集群服务 |
k8s_service_port | number | yes | k8s 集群服务端口 |
例
"""
初始化客户端:
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_id | string | yes | 上游的 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_id | string | yes | 上游的 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 name | Type | Required | Description |
---|---|---|---|
key | string | yes | content of private key |
cert | string | no | content of server cert |
ca_chain | string | no | content of CA chain |
返回值
全局证书的 ID
例
上传本地的 key.pem
和 cert.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_id | number | yes | 证书的 id |
key | string | yes | 私钥的内容 |
cert | string | no | 证书的内容 |
ca_chain | string | no | CA 链的内容 |
返回值
修改成功返回 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_id | number | yes | 证书的 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_id | number | yes | 证书的 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)
说明
新增全局用户
参数
参数 | 数据类型 | 必选 | 描述 |
---|---|---|---|
name | string | yes | 全局用户的用户名 |
pwd | string | yes | 全局用户的密码 |
gid | array | yes | 用户组 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)
说明
根据用户名搜索全局用户信息
参数
参数 | 数据类型 | 必选 | 描述 |
---|---|---|---|
name | string | yes | 全局的用户名 |
返回值
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)
说明
新增全局规则
参数
参数 | 数据类型 | 必选 | 描述 |
---|---|---|---|
condition | list | no | 该规则触发的条件 |
conseq | dict or list | no | 该规则中包含的动作 |
gid | list | no | 用户组 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_id | number | yes | 规则 id |
condition | list | no | 规则的条件 |
conseq | dict or list | no | 规则的动作 |
gid | list | no | 用户组 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_id | number | yes | 规则 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_id | number | yes | 规则 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)
说明
新增全局变量
参数
参数 | 数据类型 | 必选 | 描述 |
---|---|---|---|
name | string | yes | 变量名 |
var_type | string | yes | 变量类型 |
default | string | yes | 默认值 |
gid | list | no | 用户组 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_id | number | yes | 变量 id |
name | string | yes | 变量名 |
var_type | string | yes | 变量类型 |
default | string | yes | 变量默认值 |
gid | list | no | 用户组 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_id | number | yes | 变量 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_buffer | number | no | 访问日志的 buffer 大小 |
access_log_buffer_unit | [‘k’, ’m’, ‘g’] | no | 访问日志的 buffer 大小的单位 |
access_log_flush | number | no | 访问日志在内存中保留的最大时长 |
enable_access_log | boolean | no | 是否启用访问日志 |
access_log_formats | dict | no | 访问日志格式 |
avoid_gen_error_log | boolean | no | 是否避免生成错误日志 |
client_body_timeout | number | no | 客户端请求体超时时间 |
client_body_timeout_unit | [’s’, ’m’] | no | 客户端请求体超时时间单位 |
client_header_timeout | number | no | 客户端请求头超时时间 |
client_header_timeout_unit | [’s’, ’m’] | no | 客户端请求头超时时间单位 |
client_max_body_size | number | no | 客户端请求体最大大小 |
client_max_body_size_unit | [‘k’, ’m’ ] | no | 客户端请求体最大大小单位 |
client_header_buffer_size | number | no | 客户端请求头 buffer 大小 |
client_header_buffer_size_unit | [‘k’, ’m’ ] | no | 客户端请求头 buffer 大小单位 |
max_client_request_line_size | number | no | 客户端请求行最大大小,单位为 k |
max_client_request_header_size | [‘k’, ’m’ ] | no | 客户端请求头最大大小,单位为 k |
access_log_formats
参数 | 数据类型 | 必选 | 描述 |
---|---|---|---|
default | boolean | no | 该日志格式是否为默认。注意:配置中至少有一个默认日志格式 |
name | string | yes | 该访问日志格式的名字,需要保持全局唯一 |
format | string | yes | 该访问日志的格式,参照 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 规则
参数
参数 | 数据类型 | 必选 | 描述 |
---|---|---|---|
name | string | yes | 规则名 |
code | string | yes | 规则的 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_id | number | yes | 规则 id |
name | string | yes | 规则名 |
code | string | yes | 规则的 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 规则
参数
参数 | 数据类型 | 必选 | 描述 |
---|---|---|---|
detail | bool | no | 是否显示规则的详细信息,默认值为 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)
说明
新增全局自定义动作
参数
参数 | 数据类型 | 必选 | 描述 |
---|---|---|---|
name | string | yes | 自定义动作的名称 |
condition | list | no | 自定义动作执行的条件 |
conseq | dict or list | yes | 自定义动作 |
gid | list | no | 用户组 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_id | number | yes | 自定义动作的 id |
name | string | no | 自定义动作的名称 |
condition | list | no | 自定义动作的执行条件 |
conseq | dict or list | no | 自定义动作 |
gid | list | no | 用户组 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_id | number | yes | 自定义动作的 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_id | number | yes | 自定义动作的 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()
说明
获取所有全局自定义动作。
参数
参数 | 数据类型 | 必选 | 描述 |
---|---|---|---|
page | number | no | 第几页 |
pagesize | number | no | 页大小 |
例
"""
初始化客户端:
client = Edge2Client(host, username, password)
客户端登录:
client.login()
"""
data = client.get_all_global_actions()
STATIC-FILE
upload_static_file
file_id = upload_static_file(**kwargs)
说明
上传静态文件
参数
参数 | 数据类型 | 必选 | 描述 |
---|---|---|---|
content | string | yes | 静态文件的内容 |
label | string | yes | 静态文件的标签 |
file_type | string | no | 静态文件的类型 |
gid | list | no | 用户组 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_id | number | yes | 静态文件的 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_id | number | yes | 静态文件的 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_name | string | yes | 集群组的名字 |
例
"""
初始化客户端:
client = Edge2Client(host, username, password)
客户端登录:
client.login()
"""
group_id = client.new_cluster_group('foo')
put_cluster_group
ok = put_cluster_group(**kwargs)
说明
修改集群组
参数
参数 | 数据类型 | 必选 | 描述 |
---|---|---|---|
group_id | number | yes | 集群组的 id |
group_name | string | yes | 集群组的名字 |
例
"""
初始化客户端:
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_id | number | yes | 集群组的 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_id | number | yes | 集群组的 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_id | number | yes | 规则 id |
proxy | list | yes | 代理的规则 |
例
"""
初始化客户端:
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 集群连接参数
参数
参数 | 数据类型 | 必选 | 描述 |
---|---|---|---|
name | string | yes | k8s 集群的名字 |
host | string | no | k8s 集群的地址 |
domain | string | no | k8s 集群的域名,host或 domain 需要一个,且只能填一个 |
port | number | yes | k8s 集群的端口 |
connect_timeout | number | no | k8s 集群的连接超时时间, 单位秒,默认 5 秒 |
read_timeout | number | no | k8s 集群的读数据超时时间, 单位秒,默认 5 秒 |
ssl_verify | bool | no | 是否需要 SSL 校验 |
token | string | yes | k8s 集群的 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_id | number | yes | k8s 集群id |
name | string | no | k8s 集群的名字 |
host | string | no | k8s 集群的地址 |
domain | string | no | k8s 集群的域名,host或 domain 需要一个,且只能填一个 |
port | number | no | k8s 集群的端口 |
connect_timeout | number | no | k8s 集群的连接超时时间, 单位秒 |
read_timeout | number | no | k8s 集群的读数据超时时间, 单位秒 |
ssl_verify | bool | no | 是否需要 SSL 校验 |
token | string | no | k8s 集群的 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_id | number | yes | k8s集群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_id | number | yes | k8s集群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_id | number | yes | k8s集群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_id | number | yes | 规则 id |
proxy | list | yes | 代理的规则 |
例
"""
初始化客户端:
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 列表
参数
参数 | 数据类型 | 必选 | 描述 |
---|---|---|---|
name | string | yes | 全局级别 IP 列表的名字 |
type | string | no | IP 地址的类型,目前支持 ipv4 或 ipv6 (coming soon) |
items | array | no | IP 地址列表 |
items
参数 | 类型 | 必选 | 描述 |
---|---|---|---|
ip | string | yes | IP 地址 |
例
# 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_id | number | yes | 指定全局级别 IP 列表的 ID |
name | string | yes | 全局级别 IP 列表的名字 |
type | string | no | IP 地址的类型,目前支持 ‘ipv4’ 或 ‘ipv6’(coming soon) |
items | array | no | IP 地址列表 |
items
参数 | 类型 | 必选 | 描述 |
---|---|---|---|
ip | string | yes | IP 地址 |
例
# 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_id | number | yes | 指定全局级别 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_id | number | yes | 指定全局级别 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)
说明
新增用户级别变量
参数
参数 | 数据类型 | 必选 | 描述 |
---|---|---|---|
name | string | yes | 变量名 |
var_type | string | yes | 变量类型 |
default | string | yes | 变量默认值 |
例
"""
初始化客户端:
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_id | number | yes | 变量 id |
name | string | yes | 变量名 |
var_type | string | yes | 变量类型 |
default | string | yes | 变量默认值 |
例
"""
初始化客户端:
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_id | number | yes | 变量 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_id | number | yes | 变量 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_id | string | yes | 请求 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
参数
参数 | 数据类型 | 必选 | 描述 |
---|---|---|---|
name | string | no | api token 名称 |
expire | number | no | api 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
参数
参数 | 数据类型 | 必选 | 描述 |
---|---|---|---|
id | number | no | api token 名称 |
limit | number | no | 数量限制 |
例
"""
初始化客户端:
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
参数
参数 | 数据类型 | 必选 | 描述 |
---|---|---|---|
id | number | no | api 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)
add_gateway
id = add_gateway(name, partition_id, tag=None)
说明
新建一个网关集群。
参数
参数 | 数据类型 | 必选 | 描述 |
---|---|---|---|
name | string | yes | 网关集群的名称 |
partition_id | string | yes | 网关集群所属的网关分区 ID |
tag | array | no | 网关集群的标签 |
返回值
类型:number
1
例
"""
初始化客户端:
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_id | string | yes | 网关集群的 ID |
返回值
类型:bool
true
例
"""
初始化客户端:
client = Edge2Client(host, username, password)
客户端登录:
client.login()
"""
gateway_id = 1
ok = client.del_gateway(gateway_id)
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_id | number | yes | 节点 ID |
gateway_id | number | no | 网关集群 ID,当不指定时,将通过遍历查找到对应的节点 |
例
"""
初始化客户端:
client = Edge2Client(host, username, password)
客户端登录:
client.login()
"""
node = client.get_node(1)
node = client.get_node(1, gateway_id=1)
get_node_by_mac_address
node = get_node_by_mac_address(mac_address)
说明
根据节点硬件 ID 获取节点信息。
参数
参数 | 数据类型 | 必选 | 描述 |
---|---|---|---|
mac_address | string | yes | 节点的其中一个 MAC 地址 |
返回值
类型: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
}
例
"""
初始化客户端:
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)
说明
更新节点信息。
参数
参数 | 数据类型 | 必选 | 描述 |
---|---|---|---|
node_id | number | yes | 节点 ID |
gateway_id | number | no | 网关集群 ID,当不指定时,将通过遍历查找到对应的节点 |
name | string | no | 节点名称 |
is_gray | bool | no | 设置/取消设置灰度节点 |
status | number | no | 0: 禁用 DNS,开启集群缓存, 1: 开启 DNS,开启集群缓存, 2: 关闭 DNS,关闭集群缓存 |
external_ip | string | no | 公网 IP |
external_ipv6 | string | no | 公网 IPv6 |
internal_ip | string | no | 内网 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')
del_node
node = del_node(node_id, gateway_id=None)
说明
根据节点 ID 删除节点。
参数
参数 | 数据类型 | 必选 | 描述 |
---|---|---|---|
node_id | number | yes | 节点 ID |
gateway_id | number | no | 网关集群 ID,当不指定时,将通过遍历查找到对应的节点 |
返回值
类型:bool
true
例
"""
初始化客户端:
client = Edge2Client(host, username, password)
客户端登录:
client.login()
"""
ok = client.del_node(1)
ok = client.del_node(1, gateway_id=1)
lmdb_backup
result = lmdb_backup()
说明
触发 LMDB 的备份,成功返回 True
,失败返回失败 Node 节点的 dict
,key 是 Node ID,value 是失败原因。
备份成功与否请使用 node_sync_status
接口获取,该接口中节点的 backup_time
大于 lmdb_backup() 调用时间,即可认为本次该节点备份成功。
例
"""
初始化客户端:
client = Edge2Client(host, username, password)
客户端登录:
client.login()
"""
result = self.client.lmdb_backup()
get_global_cert_referenced
result = get_global_cert_referenced(id)
说明
获取使用了指定全局证书的应用列表。
参数
参数 | 数据类型 | 必选 | 描述 |
---|---|---|---|
id | number | yes | 全局证书 ID |
例
"""
初始化客户端:
client = Edge2Client(host, username, password)
客户端登录:
client.login()
"""
global_cert_id = 1
result = self.client.get_global_cert_referenced(global_cert_id)
get_all_partition_lua_module
result = get_all_partition_lua_module(partition_id)
说明
获取指定分区的所有 lua 模块。
参数
参数 | 数据类型 | 必选 | 描述 |
---|---|---|---|
partition_id | number | yes | 分区 ID |
例
"""
初始化客户端:
client = Edge2Client(host, username, password)
客户端登录:
client.login()
"""
partition_id = 1
result = self.client.get_all_partition_lua_module(partition_id)
get_partition_lua_module
result = get_partition_lua_module(partition_id, module_id)
说明
获取指定分区的指定 lua 模块。
参数
参数 | 数据类型 | 必选 | 描述 |
---|---|---|---|
partition_id | number | yes | 分区 ID |
module_id | number | yes | 模块 ID |
例
"""
初始化客户端:
client = Edge2Client(host, username, password)
客户端登录:
client.login()
"""
partition_id = 1
module_id = 1
result = self.client.get_partition_lua_module(partition_id, module_id)
new_partition_lua_module
result = new_partition_lua_module(partition_id, name, code)
说明
新增一个 lua 模块到指定分区。
参数
参数 | 数据类型 | 必选 | 描述 |
---|---|---|---|
partition_id | number | yes | 分区 ID |
name | string | yes | 模块名称 |
code | string | yes | 模块代码 |
返回值
类型: dict
例如:
{'id': 412}
例
"""
初始化客户端:
client = Edge2Client(host, username, password)
客户端登录:
client.login()
"""
partition_id = 1
name = "example"
code = """
local _M = {}
return _M
"""
result = self.client.new_partition_lua_module(partition_id, name, code)
put_partition_lua_module
result = put_partition_lua_module(partition_id, module_id, name, code)
说明
编辑指定分区的指定 lua 模块。
参数
参数 | 数据类型 | 必选 | 描述 |
---|---|---|---|
partition_id | number | yes | 分区 ID |
module_id | number | yes | 模块 ID |
name | string | no | 模块名称 |
code | string | no | 模块代码 |
返回值
类型: bool
例如:
true
例
"""
初始化客户端:
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_id | number | yes | 分区 ID |
module_id | number | yes | 模块 ID |
例
"""
初始化客户端:
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
result = conv_crl_to_lua_module(crl_files)
说明
将 CRL 文件转换为 Lua模块
参数
参数 | 数据类型 | 必选 | 描述 |
---|---|---|---|
crl_files | array | yes | CRL files |
例
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"
# for the first time, we need to create the module first
result = client.new_partition_lua_module(partition_id, name, code)
mod_id = result["id"]
# for the second time, we need to update the module with mod_id from the first creation
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 接口批准这些节点加入到指定集群。
返回值
类型: array
例如:
[
{
"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": "..."
}
]
例
"""
初始化客户端:
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 的节点加入到 gateway_id 指定的网关集群。
参数
参数 | 数据类型 | 必选 | 描述 |
---|---|---|---|
gateway_id | number | yes | 网关集群 ID,当不指定时,将通过遍历查找到对应的节点 |
mac_address | string | yes | 节点的其中一个 MAC 地址 |
internal_ip | string | no | 节点的内部 IPv4 地址 |
external_ip | string | no | 节点的外部 IPv4 地址 |
name | string | no | 节点的名称,默认使用主机名 |
external_ipv6 | string | no | 节点的外部 IPv6 地址 |
status | string | no | 节点状态,0:禁用,1:启用,2:断开(禁用 DNS 和禁用集群内缓存共享) |
返回值
类型: bool
例如:
true
例
批准主机名称为 new-edge-node 的节点加入到 ID 为 1 的网关集群。
"""
初始化客户端:
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