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，供后续使用

# 参数

# 返回值

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 应用

# 参数

# 返回值

返回 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 应用的基本信息

# 参数

# 返回值

修改成功返回 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 应用的配置。

# 参数

# 返回值

修改成功返回 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 应用的配置

# 参数

# 返回值

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 应用

# 参数

# 返回值

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 应用

# 参数

# 返回值

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 应用

# 参数

# 返回值

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 搜索上游。

# 参数

# 返回值

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 搜索上游。

# 参数

# 返回值

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)

# 说明

以名称搜索上游。

# 参数

# 返回值

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)

# 说明

以名称搜索上游。

# 参数

# 返回值

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 上游。

# 参数

# 返回值

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上游。

# 参数

# 返回值

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 为 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

# 参数

# servers

# 返回值

返回值为创建上游节点的 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)

# 说明

修改上游节点信息

# 参数

# servers

# 例

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

# 说明

获取上游节点的信息

# 参数

# 例

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

# 说明

删除上游节点

# 参数

# 返回值

删除成功的时返回 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

# 参数

# 返回值

返回值为创建上游节点的 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

# 例

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

# 说明

修改上游节点信息

# 参数

k8s_services

# 例

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

# 说明

获取上游节点的信息

# 参数

# 例

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

# 说明

删除上游节点

# 参数

# 返回值

删除成功的时返回 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 规则，缓存规则。还可以指定规则执行的前提条件。

# 参数

# 返回值

返回创建规则的 rule_id

# condition

# conseq

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 数组的描述：

# 例

创建自定义的 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

对参数中 upstreams 与 backup_upstreams 数组的描述

# 例

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

# 例

当访问来源 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 文件，并在访问 /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)

# 说明

修改页面规则

# 参数

# 返回值

修改成功返回 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 获取页面规则

# 参数

# 返回值

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 对应的页面规则

# 参数

# 返回值

删除成功返回 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) 对应的所有页面规则

# 参数

# 返回值

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)

# 说明

调整规则的顺序。

# 参数

# 返回值

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)

# 说明

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

# 参数

# 例

"""
初始化客户端：
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 来获取对应的页面规则

# 参数

# 例

"""
初始化客户端：
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 规则

# 参数

# 例

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

# 参数

# 返回值

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 证书，手动上传证书

# 参数

# 例

"""
初始化客户端：
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 证书

# 参数

# 返回值

创建 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 证书（手动上传）

# 参数

# 例

"""
初始化客户端：
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 证书

# 参数

# 例

"""
初始化客户端：
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 证书签发状态

# 参数

# 返回值

data

# 例

"""
初始化客户端：
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 证书内容

# 参数

# 返回值

证书的内容，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 删除对应的证书信息

# 参数

# 例

"""
初始化客户端：
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 语言代码

# 参数

# 返回值

创建成功返回 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)

# 说明

新增应用级用户

# 参数

# 返回值

返回值为新增用户的 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)

# 说明

修改应用级用户

# 参数

# 返回值

修改成功返回 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)

# 说明

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

# 参数

# 返回值

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)

# 说明

删除应用级用户

# 参数

# 返回值

如果删除用户成功则返回 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 指定应用）的用户

# 参数

# 返回值

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)

# 说明

为所有应用添加用户

# 参数

# 例

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

# 说明

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

# 参数

# 返回值

若添加成功返回 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)

# 说明

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

# 参数

# 返回值

刷新任务 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 查询任务详情

# 参数

# 例

"""
初始化客户端：
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 的刷新任务

# 参数

# 返回值

删除刷新任务成功时返回 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 白名单规则

# 参数

# WAF Condition

# 例

# 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 白名单规则

# 参数

# 例

# 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 列表

# 参数

# items

# 例

# 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 列表

# 参数

# items

# 例

# 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 列表

# 参数

# 例

# 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 列表

# 参数

# 例

# 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 和内存相关的负载信息。

# 参数

更改当前实例操作的 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 应用

# 返回值

如果执行成功返回 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 应用

# 参数

# 例

"""
初始化客户端：
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 为 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 应用的信息

# 参数

# 例

"""
初始化客户端：
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 应用的信息

# 返回值

删除成功的时返回 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 记录

# 参数

# 返回值

返回值为 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 记录

# 参数

# 返回值

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 为 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 记录

# 参数

# 例

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

# 参数

# 返回值

返回值为创建上游节点的 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)

# 说明

修改上游节点信息

# 参数

# 例

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

# 说明

获取上游节点的信息

# 参数

# 例

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

# 说明

删除上游节点

# 参数

# 返回值

删除成功的时返回 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

# 参数

# k8s_services

# 返回值

返回值为创建上游节点的 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)

# 说明

修改上游节点信息

# 参数

# 例

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

# 说明

获取上游节点的信息

# 参数

# 例

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

# 说明

删除上游节点

# 参数

# 返回值

删除成功的时返回 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 证书

# 参数

# 返回值

全局证书的 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 证书

# 参数

# 返回值

修改成功返回 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 证书信息

# 参数

# 返回值

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 证书

# 参数

# 返回值

删除成功时返回 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)

# 说明

新增全局用户

# 参数

# 返回值

返回值为全局用户的 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)

# 说明

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

# 参数

# 返回值

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)

# 说明

新增全局规则

# 参数

# 返回值

返回值为创建成功的全局规则的 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)

# 说明

修改全局规则

# 参数

# 例

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

# 说明

获取全局规则信息

# 参数

# 例

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

# 说明

删除全局规则

# 参数

# 例

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

# 说明

新增全局变量

# 参数

# 返回值

创建成功时返回变量 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)

# 说明

修改全局变量

# 返回值

修改成功时返回 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)

# 说明

获取全局变量

# 例

"""
初始化客户端：
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_formats

# 例

"""
初始化客户端：
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 规则

# 参数

# 例

"""
初始化客户端：
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 规则

# 参数

# 例

"""
初始化客户端：
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 规则

# 参数

# 例

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

# 说明

新增全局自定义动作

# 参数

# 例

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

# 说明

修改全局自定义动作

# 参数

# 例

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

# 说明

获取全局自定义动作

# 参数

# 例

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

# 说明

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

# 参数

# 例

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

# 说明

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

# 参数

# 例

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

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

data = client.get_all_global_actions()

回到目录

# STATIC-FILE

# upload_static_file

file_id = upload_static_file(**kwargs)

# 说明

上传静态文件

# 参数

# 例

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

# 说明

获取静态文件配置

# 参数

# 例

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

# 说明

删除已上传静态文件

# 参数

# 例

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

# 说明

新增集群组

# 参数

# 例

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

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

group_id = client.new_cluster_group('foo')

回到目录

# put_cluster_group

ok = put_cluster_group(**kwargs)

# 说明

修改集群组

# 参数

# 例

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

# 说明

获取集群组信息

# 参数

# 例

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

# 说明

删除集群组信息

# 参数

# 例

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

# 说明

修改上游代理规则

# 参数

# 例

"""
初始化客户端：
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 集群连接参数

# 参数

# 例

"""
初始化客户端：
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 集群连接参数

# 参数

# 例

"""
初始化客户端：
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 集群连接参数信息

# 参数

# 例

"""
初始化客户端：
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 集群中定义的服务相关信息

# 参数

# 例

"""
初始化客户端：
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 集群连接参数

# 参数

# 例

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

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

ok = client.del_global_k8s(k8s_id = 1)

回到目录

# put_proxy_rule

ok = put_proxy_rule(**kwargs)

# 说明

修改上游代理规则

# 参数

# 例

"""
初始化客户端：
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 列表

# 参数

# items

# 例

# 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 列表

# 参数

# items

# 例

# 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 列表

# 参数

# 例

# 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 列表

# 参数

# 例

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

# 说明

新增用户级别变量

# 参数

# 例

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

# 说明

修改用户级别变量

# 参数

# 例

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

# 说明

获取用户级别变量

# 参数

# 例

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

# 说明

删除用户级别变量

# 参数

# 例

"""
初始化客户端：
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 日志。

# 参数

# 例

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

# 参数

# 例

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

# 参数

# 例

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

# 参数

# 例

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

# 说明

新建一个网关集群。

# 参数

# 返回值

类型：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)

# 说明

删除一个网关集群。

# 参数

# 返回值

类型：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 获取节点信息。

# 参数

# 例

"""
初始化客户端：
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 获取节点信息。

# 参数

# 返回值

类型：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)

# 说明

更新节点信息。

# 参数

# 例

"""
初始化客户端：
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 删除节点。

# 参数

# 返回值

类型：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)

# 说明

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

# 参数

# 例

"""
初始化客户端：
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 模块。

# 参数

# 例

"""
初始化客户端：
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 模块。

# 参数

# 例

"""
初始化客户端：
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 模块到指定分区。

# 参数

# 返回值

类型: 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 模块。

# 参数

# 返回值

类型: 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 模块。

# 参数

# 例

"""
初始化客户端：
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模块

# 参数

# 例

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 指定的网关集群。

# 参数

# 返回值

类型: 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

回到目录