预计阅读时间:76分钟|最后更新时间: Invalid Date

# OpenResty Edge SDK

==================

Python SDK for OpenResty Edge

# Table of Content

# overview

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

回到目录

# edge-app

# 概览

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

回到目录

# edge-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,数据类型为 int

#

创建域名为 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 int 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 int 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 int 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 int 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_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')

回到目录

# get_all_apps


data = get_all_apps(detail)

# 说明

获取所有的应用信息

# 参数

参数 数据类型 必选 描述
detail bool no 是否返回应用的详情,默认为 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)

回到目录

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

回到目录

# edge-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_namesapce 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_namesapce 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 number yes k8s集群id
k8s_namesapce 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()

回到目录

# edge-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 int no 1:置顶规则,-1:置底规则
order int no 规则顺序,优先级低于 top 参数
last boolean no 如果命中此条规则的话跳过所有余下的页面规则,默认为 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。支持的算法还有 hashchash
balancer_vars list no 负载均衡算法所依赖的变量,当负载均衡算法选择为 hashchash 时需要填写该字段
multi_tier number no 多层网络策略 ID

# upstreams

对参数中 upstreamsbackup_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 int no 1:置顶规则 -1:置底规则
order int 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 int 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 int 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()

回到目录

# get_all_rules_by_app_domain


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

回到目录

# edge-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 int 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 int yes 证书的 id
key string yes 私钥的内容
cert string no 服务端证书的内容
ca_chain string no CA 链的内容
global_cert_id int 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列表

#

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

回到目录

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

回到目录

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

# 说明

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

# 返回值

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)

回到目录

# edge-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)

[回到目录](#table-of-content)

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

回到目录

# edge-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)

回到目录

# edge-waf-whitelist

# new_waf_whitelist


rule_id = new_waf_whitelist(**kwargs)

新增 WAF 白名单规则

# 参数

参数 数据类型 必选 描述
condition list no 规则执行的条件
rule_sets list yes waf 规则的 id 列表

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

回到目录

# edge-app-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)

回到目录

# edge-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)

# edge-dashboard

# 概览

提供控制面板相关的接口

回到目录

# edge-node-monitor

# node_monitor


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

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

#


data = client.node_monitor()

回到目录

# edge-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)

回到目录

# edge-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类型时,需要填写该字段
domain string no 当响应为域名类型时,需要填写该字段
priority int 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 int 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)

回到目录

# edge-global

# 概览

提供全局级别的操作接口

回到目录

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

回到目录

# edge-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_namesapce 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_namesapce 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()

回到目录

# edge-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.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_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)

回到目录

# edge-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)

回到目录

# edge-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)

回到目录

# edge-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)

回到目录

# edge-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 int no 访问日志的 buffer 大小
access_log_buffer_unit ['k', 'm', 'g'] no 访问日志的 buffer 大小的单位
access_log_flush int no 访问日志在内存中保留的最大时长
enable_access_log boolean no 是否启用访问日志
access_log_formats dict no 访问日志格式
avoid_gen_error_log boolean no 是否避免生成错误日志
client_body_timeout int no 客户端请求体超时时间
client_body_timeout_unit ['s', 'm'] no 客户端请求体超时时间单位
client_header_timeout int no 客户端请求头超时时间
client_header_timeout_unit ['s', 'm'] no 客户端请求头超时时间单位
client_max_body_size int no 客户端请求体最大大小
client_max_body_size_unit ['k', 'm' ] no 客户端请求体最大大小单位
client_header_buffer_size int no 客户端请求头 buffer 大小
client_header_buffer_size_unit ['k', 'm' ] no 客户端请求头 buffer 大小单位
max_client_request_line_size int 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()

回到目录

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

回到目录

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

回到目录

# edge-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 int 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 int yes 静态文件的 ID

#

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

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

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

ok = client.del_static_file(file_id)

回到目录

# edge-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)

回到目录

# edge-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)

回到目录

# edge-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)

# edge-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)

回到目录