# 选中多个策略为批量添加cc规则 - BatchCreateCcRule
#### 功能介绍
选中多个策略为这些策略批量添加cc规则
#### 调用方法
请参见[如何调用API](https://support.huaweicloud.com/api-waf/waf_02_0007.html)。
#### 授权信息
账号具备所有API的调用权限，如果使用账号下的IAM用户调用当前API，该IAM用户需具备调用API所需的权限。
- 如果使用角色与策略授权，具体权限要求请参见[权限和授权项](https://support.huaweicloud.com/api-waf/waf_02_0119.html)。
- 如果使用身份策略授权，当前API调用无需身份策略权限。
 
#### URI
POST /v1/{project_id}/waf/rule/cc
表1路径参数 
| 参数         | 是否必选 | 参数类型   | 描述                                                                                                                                                                                                                                                                                                                                                                             |
|:---|:---|:---|:---|
| project_id | 是    | String | **参数解释：** 项目ID，对应控制台用户名-\>我的凭证-\>项目列表-\>项目ID。 **约束限制：** 不涉及 **取值范围：** 只能由英文字母、数字组成，且长度为32个字符。 **默认取值：** 不涉及 |
   
表2Query参数 
| 参数                    | 是否必选 | 参数类型   | 描述                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
|:---|:---|:---|:---|
| policyids             | 否    | String | **参数解释：** 策略id列表。策略id从"查询防护策略列表"(ListPolicy)接口获取，多个策略之间用","隔开 **约束限制：** 不涉及 **取值范围：** 不涉及 **默认取值：** 不涉及                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| enterprise_project_id | 否    | String | **参数解释：** 您可以通过调用企业项目管理服务（EPS）的查询企业项目列表接口（ListEnterpriseProject）查询企业项目ID。若需要查询当前用户所有企业项目绑定的资源信息，请传参all_granted_eps。 **约束限制：** 不涉及 **取值范围：** - 0：代表default企业项目   - all_granted_eps：代表所有企业项目   - 其它企业项目ID：长度为36个字符    **默认取值：** 0 |
   
#### 请求参数
表3请求Header参数 
| 参数           | 是否必选 | 参数类型   | 描述                                                                                                                                                                                                                                                                                                                                                                              |
|:---|:---|:---|:---|
| X-Auth-Token | 否    | String | **参数解释：** 用户Token，通过调用IAM服务获取用户Token接口获取(响应消息头中X-Subject-Token的值)。 **约束限制：** 不涉及 **取值范围：** 不涉及 **默认取值：** 不涉及 |
| Content-Type | 是    | String | **参数解释：** 内容类型 **约束限制：** 不涉及 **取值范围：** 不涉及 **默认取值：** application/json;charset=utf8                           |
   
表4请求Body参数 
| 参数                 | 是否必选 | 参数类型                                                                    | 描述                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
|:---|:---|:---|:---|
| name               | 否    | String                                                                  | 规则名称                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| mode               | 是    | Integer                                                                 | cc规则防护模式，对应console上的mode，现在只支持创建高级cc规则防护模式。 - 0：标准，只支持对域名的防护路径做限制。   - 1：高级，支持对路径、IP、Cookie、Header、Params字段做限制。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| conditions         | 是    | Array of [CcCondition] objects | cc规则防护规则限速条件，当cc防护规则为高级模式（mode参数值为1）时，该参数必填。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| action             | 是    | [action] object                     | 请求次数限制到达后采取的防护动作                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| tag_type           | 是    | String                                                                  | **参数解释：** 限速模式标识，用于指定区分单个Web访问者的判断依据 **约束限制：** 不涉及 **取值范围：** - ip：IP限速，根据IP区分单个Web访问者   - cookie：用户限速，根据Cookie键值区分单个Web访问者   - header：用户限速，根据Header区分单个Web访问者   - other：根据Referer（自定义请求访问的来源）字段区分单个Web访问者   - policy：策略限速   - domain：域名限速   - url：url限速    **默认取值：** 不涉及 |
| tag_index          | 否    | String                                                                  | 用户标识，当限速模式为用户限速(cookie或header)时，需要传该参数。 - 选择cookie时，设置cookie字段名，即用户需要根据网站实际情况配置唯一可识别Web访问者的cookie中的某属性变量名。用户标识的cookie，不支持正则，必须完全匹配。例如：如果网站使用cookie中的某个字段name唯一标识用户，那么可以选取name字段来区分Web访问者。   - 选择header时，设置需要防护的自定义HTTP首部，即用户需要根据网站实际情况配置可识别Web访问者的HTTP首部。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| tag_condition      | 否    | [tag_condition] object       | 用户标识，当限速模式为other时，需要传该参数。根据Referer（自定义请求访问的来源）字段区分单个Web访问者                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| limit_num          | 是    | Integer                                                                 | 限制频率，单位为次，范围为1\~2147483647                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| limit_period       | 是    | Integer                                                                 | 限速周期，单位为秒，范围1\~3600                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| unlock_num         | 否    | Integer                                                                 | 放行频率，单位为次，范围为0\~2147483647。只有当防护动作类型为dynamic_block时，才需要传该参数。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| lock_time          | 否    | Integer                                                                 | 阻断时间，单位为秒，范围为0\~65535。当"防护动作"选择"阻断"时，可设置阻断后恢复正常访问页面的时间。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| domain_aggregation | 否    | Boolean                                                                 | 是否开启域名聚合统计。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| region_aggregation | 否    | Boolean                                                                 | 是否开启全局计数。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| description        | 否    | String                                                                  | 规则描述                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| policy_ids         | 是    | Array of strings                                                        | 添加规则的策略id列表。策略id从"查询防护策略列表"(ListPolicy)接口获取，多个策略之间用","隔开                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| priority           | 否    | Integer                                                                 | 执行该规则的优先级，值越小，优先级越高，值相同时，规则创建时间早，优先级越高。取值范围：1到100。 本字段仅在边缘安全场景生效                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| cc_priority        | 否    | Integer                                                                 | 执行该规则的优先级，值越小，优先级越高，值相同时，规则创建时间早，优先级越高。取值范围：0到65535。 本字段仅在非边缘安全场景生效                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
   
 表5CcCondition 
| 参数              | 是否必选 | 参数类型             | 描述                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
|:---|:---|:---|:---|
| category        | 是    | String           | **参数解释：** 字段类型 **约束限制：** 不涉及 **取值范围：** - url   - ip   - ipv6   - asn   - params   - cookie   - referer   - user-agent   - header   - response_code   - response_header   - response_body   - request_body   - method   - tls_fingerprint   - tls_ja3_fingerprint    **默认取值：** 不涉及 |
| logic_operation | 是    | String           | 条件列表匹配逻辑。 - 如果字段类型category是url， 匹配逻辑可以为：contain、 not_contain、 equal、 not_equal、 prefix、 not_prefix、 suffix、 not_suffix、 contain_any、 not_contain_all、 equal_any、 not_equal_all、 equal_any、 not_equal_all、 prefix_any、 not_prefix_all、 suffix_any、 not_suffix_all、 len_greater、 len_less、len_equal或者len_not_equal   - 如果字段类型category是ip或者ipv6，匹配逻辑可以为： equal、not_equal、equal_any或者not_equal_all   - 如果字段类型category是params、cookie或者header, 匹配逻辑可以为：contain、 not_contain、 equal、 not_equal、 prefix、 not_prefix、 suffix、 not_suffix、 contain_any、 not_contain_all、 equal_any、not_equal_all、 equal_any、 not_equal_all、 prefix_any、 not_prefix_all、 suffix_any、 not_suffix_all、 len_greater、 len_less、len_equal、len_not_equal、、num_greater、num_less、num_equal、num_not_equal、exist或者not_exist                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| contents        | 否    | Array of strings | 条件列表逻辑匹配内容。当logic_operation参数不以any或者all结尾时，需要传该参数。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| value_list_id   | 否    | String           | 引用表id。当logic_operation参数以any或者all结尾时，需要传该参数。此外，引用表类型要与category类型保持一致。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| index           | 否    | String           | 子字段，当字段类型（category）选择"params"、"cookie"、"header"时，请根据实际需求配置子字段且该参数必填。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
   
 表6action 
| 参数       | 是否必选 | 参数类型                                                | 描述                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
|:---|:---|:---|:---|
| category | 是    | String                                              | 动作类型： - captcha：人机验证，阻断后用户需要输入正确的验证码，恢复正确的访问页面。   - log: 仅记录   - dynamic_block: 上一个限速周期内，请求频率超过"限速频率"将被阻断，那么在下一个限速周期内，请求频率超过"放行频率"将被阻断。注：只有当cc防护规则模式为高级模式时才支持设置dynamic_block防护动作。    -block：阻断。 |
| detail   | 否    | [detail] object | 阻断页面信息。当防护动作（category）选择阻断（block）或者动态阻断（dynamic_block）时，需要设置返回的阻断页面。 - 如果需要返回的阻断页面为系统默认的阻断页面，不需要传该参数。   - 如果用户想防护自定义的阻断页面，可以通过此参数设置                                                                                                                                                                                                                                                                        |
   
 表7detail 
| 参数       | 是否必选 | 参数类型                                                    | 描述   |
|:---|:---|:---|:---|
| response | 否    | [response] object | 返回页面 |
   
 表8response 
| 参数           | 是否必选 | 参数类型   | 描述                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
|:---|:---|:---|:---|
| content_type | 否    | String | **参数解释：** 内容类型 **约束限制：** 不涉及 **取值范围：** - text/html   - text/xml   - application/json    **默认取值：** 不涉及 |
| content      | 否    | String | 防护页面内容                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
   
 表9tag_condition 
| 参数       | 是否必选 | 参数类型             | 描述                  |
|:---|:---|:---|:---|
| category | 否    | String           | 用户标识字段，其值固定为referer |
| contents | 否    | Array of strings | 用户标识字段内容            |
   
#### 响应参数
**状态码：200**
表10响应Body参数 
| 参数                 | 参数类型                                                                     | 描述                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
|:---|:---|:---|
| name               | String                                                                   | 规则名称                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| id                 | String                                                                   | Rule ID.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| policyid           | String                                                                   | Policy ID.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| url                | String                                                                   | 当mode值为0时，该参数有返回值。规则应用的URL链接。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| prefix             | Boolean                                                                  | 路径是否为前缀模式，当防护url以\*结束，则为前缀模式。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| mode               | Integer                                                                  | cc规则防护模式，对应console上的mode，现在只支持创建高级cc规则防护模式。 - 0：标准，只支持对域名的防护路径做限制。   - 1：高级，支持对路径、IP、Cookie、Header、Params字段做限制。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| status             | Integer                                                                  | **参数解释：** 规则状态标识，用于指定规则的启用或关闭状态 **取值范围：** - 0：关闭   - 1：开启                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| conditions         | Array of [CcCondition] objects | cc规则防护规则限速条件，当cc防护规则为高级模式（mode参数值为1）时，该参数必填。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| action             | [action] object                     | 请求次数限制到达后采取的防护动作                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| tag_type           | String                                                                   | **参数解释：** 限速模式标识，用于指定区分单个Web访问者的判断依据 **取值范围：** - ip：IP限速，根据IP区分单个Web访问者   - cookie：用户限速，根据Cookie键值区分单个Web访问者   - header：用户限速，根据Header区分单个Web访问者   - other：根据Referer（自定义请求访问的来源）字段区分单个Web访问者   - policy：策略限速   - domain：域名限速   - url：url限速    |
| tag_index          | String                                                                   | 用户标识，当限速模式为用户限速(cookie或header)时，需要传该参数。 - 选择cookie时，设置cookie字段名，即用户需要根据网站实际情况配置唯一可识别Web访问者的cookie中的某属性变量名。用户标识的cookie，不支持正则，必须完全匹配。例如：如果网站使用cookie中的某个字段name唯一标识用户，那么可以选取name字段来区分Web访问者。   - 选择header时，设置需要防护的自定义HTTP首部，即用户需要根据网站实际情况配置可识别Web访问者的HTTP首部。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| tag_condition      | [tag_condition] object       | 用户标识，当限速模式为other时，需要传该参数。根据Referer（自定义请求访问的来源）字段区分单个Web访问者                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| limit_num          | Integer                                                                  | 限制频率，单位为次，范围为1\~2147483647                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| limit_period       | Integer                                                                  | 限速周期，单位为秒，范围1\~3600                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| unlock_num         | Integer                                                                  | 放行频率，单位为次，范围为0\~2147483647。只有当防护动作类型为dynamic_block时，才需要传该参数。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| lock_time          | Integer                                                                  | 阻断时间，单位为秒，范围为0\~65535。当"防护动作"选择"阻断"时，可设置阻断后恢复正常访问页面的时间。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| domain_aggregation | Boolean                                                                  | 是否开启域名聚合统计。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| region_aggregation | Boolean                                                                  | 是否开启全局计数。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| description        | String                                                                   | 规则描述                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| total_num          | Integer                                                                  | 该参数为预留参数，用于后续功能扩展，当前请用户忽略该参数                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| unaggregation      | Boolean                                                                  | 该参数为预留参数，用于后续功能扩展，当前请用户忽略该参数                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| aging_time         | Integer                                                                  | 规则老化时间，该参数为预留参数，用于后续功能扩展，当前请用户忽略该参数                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| producer           | Integer                                                                  | 规则创建对象，该参数为预留参数，用于后续功能扩展，当前请用户忽略该参数                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| timestamp          | Long                                                                     | 创建规则时间戳                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| priority           | Integer                                                                  | 执行该规则的优先级，值越小，优先级越高，值相同时，规则创建时间早，优先级越高。取值范围：1到100。 本字段仅在边缘安全场景生效                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| cc_priority        | Integer                                                                  | 执行该规则的优先级，值越小，优先级越高，值相同时，规则创建时间早，优先级越高。取值范围：0到65535。 本字段仅在非边缘安全场景生效                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
   
 表11CcCondition 
| 参数              | 参数类型             | 描述                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
|:---|:---|:---|
| category        | String           | **参数解释：** 字段类型 **取值范围：** - url   - ip   - ipv6   - asn   - params   - cookie   - referer   - user-agent   - header   - response_code   - response_header   - response_body   - request_body   - method   - tls_fingerprint   - tls_ja3_fingerprint    |
| logic_operation | String           | 条件列表匹配逻辑。 - 如果字段类型category是url， 匹配逻辑可以为：contain、 not_contain、 equal、 not_equal、 prefix、 not_prefix、 suffix、 not_suffix、 contain_any、 not_contain_all、 equal_any、 not_equal_all、 equal_any、 not_equal_all、 prefix_any、 not_prefix_all、 suffix_any、 not_suffix_all、 len_greater、 len_less、len_equal或者len_not_equal   - 如果字段类型category是ip或者ipv6，匹配逻辑可以为： equal、not_equal、equal_any或者not_equal_all   - 如果字段类型category是params、cookie或者header, 匹配逻辑可以为：contain、 not_contain、 equal、 not_equal、 prefix、 not_prefix、 suffix、 not_suffix、 contain_any、 not_contain_all、 equal_any、not_equal_all、 equal_any、 not_equal_all、 prefix_any、 not_prefix_all、 suffix_any、 not_suffix_all、 len_greater、 len_less、len_equal、len_not_equal、、num_greater、num_less、num_equal、num_not_equal、exist或者not_exist                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| contents        | Array of strings | 条件列表逻辑匹配内容。当logic_operation参数不以any或者all结尾时，需要传该参数。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| value_list_id   | String           | 引用表id。当logic_operation参数以any或者all结尾时，需要传该参数。此外，引用表类型要与category类型保持一致。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| index           | String           | 子字段，当字段类型（category）选择"params"、"cookie"、"header"时，请根据实际需求配置子字段且该参数必填。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
   
 表12action 
| 参数       | 参数类型                                                 | 描述                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
|:---|:---|:---|
| category | String                                               | 动作类型： - captcha：人机验证，阻断后用户需要输入正确的验证码，恢复正确的访问页面。   - log: 仅记录   - dynamic_block: 上一个限速周期内，请求频率超过"限速频率"将被阻断，那么在下一个限速周期内，请求频率超过"放行频率"将被阻断。注：只有当cc防护规则模式为高级模式时才支持设置dynamic_block防护动作。    -block：阻断。 |
| detail   | [detail] object | 阻断页面信息。当防护动作（category）选择阻断（block）或者动态阻断（dynamic_block）时，需要设置返回的阻断页面。 - 如果需要返回的阻断页面为系统默认的阻断页面，不需要传该参数。   - 如果用户想防护自定义的阻断页面，可以通过此参数设置                                                                                                                                                                                                                                                                        |
   
 表13detail 
| 参数       | 参数类型                                                     | 描述   |
|:---|:---|:---|
| response | [response] object | 阻断页面 |
   
 表14response 
| 参数           | 参数类型   | 描述                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
|:---|:---|:---|
| content_type | String | **参数解释：** 内容类型 **取值范围：** - text/html   - text/xml   - application/json    |
| content      | String | 阻断页面内容                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
   
 表15tag_condition 
| 参数       | 参数类型             | 描述                  |
|:---|:---|:---|
| category | String           | 用户标识字段，其值固定为referer |
| contents | Array of strings | 用户标识字段内容            |
   
**状态码：400**
表16响应Body参数 
| 参数                            | 参数类型                                                                               | 描述                                                                                                 |
|:---|:---|:---|
| error_code                    | String                                                                             | 错误码                                                                                                |
| error_msg                     | String                                                                             | 错误信息                                                                                               |
| encoded_authorization_message | String                                                                             | 编码 (加密) 后的详细拒绝原因，用户可以自行调用 STS 服务的decode-authorization-message接口进行解码，可参考STS5联调自验证。IAM5鉴权错误时才会返回此字段。 |
| details                       | Array of [IAM5ErrorDetails] objects | 调用下游服务的报错信息集合，IAM5鉴权错误时才会返回此字段。                                                                    |
   
 表17IAM5ErrorDetails 
| 参数         | 参数类型   | 描述       |
|:---|:---|:---|
| error_code | String | 下游服务错误码  |
| error_msg  | String | 下游服务报错信息 |
   
**状态码：401**
表18响应Body参数 
| 参数                            | 参数类型                                                                                 | 描述                                                                                                 |
|:---|:---|:---|
| error_code                    | String                                                                               | 错误码                                                                                                |
| error_msg                     | String                                                                               | 错误信息                                                                                               |
| encoded_authorization_message | String                                                                               | 编码 (加密) 后的详细拒绝原因，用户可以自行调用 STS 服务的decode-authorization-message接口进行解码，可参考STS5联调自验证。IAM5鉴权错误时才会返回此字段。 |
| details                       | Array of [IAM5ErrorDetails] objects | 调用下游服务的报错信息集合，IAM5鉴权错误时才会返回此字段。                                                                    |
   
 表19IAM5ErrorDetails 
| 参数         | 参数类型   | 描述       |
|:---|:---|:---|
| error_code | String | 下游服务错误码  |
| error_msg  | String | 下游服务报错信息 |
   
**状态码：500**
表20响应Body参数 
| 参数                            | 参数类型                                                                                 | 描述                                                                                                 |
|:---|:---|:---|
| error_code                    | String                                                                               | 错误码                                                                                                |
| error_msg                     | String                                                                               | 错误信息                                                                                               |
| encoded_authorization_message | String                                                                               | 编码 (加密) 后的详细拒绝原因，用户可以自行调用 STS 服务的decode-authorization-message接口进行解码，可参考STS5联调自验证。IAM5鉴权错误时才会返回此字段。 |
| details                       | Array of [IAM5ErrorDetails] objects | 调用下游服务的报错信息集合，IAM5鉴权错误时才会返回此字段。                                                                    |
   
 表21IAM5ErrorDetails 
| 参数         | 参数类型   | 描述       |
|:---|:---|:---|
| error_code | String | 下游服务错误码  |
| error_msg  | String | 下游服务报错信息 |
   
#### 请求示例
选中多个策略为这些策略批量添加CC规则
```
POST https://{endpoint}/v1/{project_id}/waf/rule/cc?enterprise_project_id=0
{
  "name" : "test1",
  "description" : "aa",
  "limit_num" : 9,
  "limit_period" : 60,
  "action" : {
    "category" : "log"
  },
  "mode" : 1,
  "conditions" : [ {
    "category" : "header",
    "logic_operation" : "contain",
    "index" : "test",
    "contents" : [ "abcde" ]
  } ],
  "tag_index" : "da",
  "tag_type" : "cookie",
  "policy_ids" : [ "c467ec81836e4e9391102ad5e5949bb9" ]
}
```
#### 响应示例
**状态码：200**
```
{
  "policyid" : "c467ec81836e4e9391102ad5e5949bb9",
  "id" : "f88c5eabff9b4ff9ba6e7dd8e38128ba",
  "name" : "test1",
  "timestamp" : 1761113849039,
  "description" : "aa",
  "status" : 1,
  "mode" : 1,
  "conditions" : [ {
    "category" : "header",
    "contents" : [ "abcde" ],
    "logic_operation" : "contain",
    "index" : "test"
  } ],
  "action" : {
    "category" : "block",
    "detail" : {
      "response" : {
        "content" : "dddd",
        "content_type" : "text/html"
      }
    }
  },
  "producer" : 1,
  "unaggregation" : false,
  "total_num" : 0,
  "limit_num" : 9,
  "limit_period" : 60,
  "lock_time" : 0,
  "tag_type" : "cookie",
  "tag_index" : "da",
  "aging_time" : 0
}
```
#### SDK代码示例
SDK代码示例如下。
- [Java]
  选中多个策略为这些策略批量添加CC规则
  ```
  package com.huaweicloud.sdk.test;
  import com.huaweicloud.sdk.core.auth.ICredential;
  import com.huaweicloud.sdk.core.auth.BasicCredentials;
  import com.huaweicloud.sdk.core.exception.ConnectionException;
  import com.huaweicloud.sdk.core.exception.RequestTimeoutException;
  import com.huaweicloud.sdk.core.exception.ServiceResponseException;
  import com.huaweicloud.sdk.waf.v1.region.WafRegion;
  import com.huaweicloud.sdk.waf.v1.*;
  import com.huaweicloud.sdk.waf.v1.model.*;
  import java.util.List;
  import java.util.ArrayList;
  public class BatchCreateCcRuleSolution {
      public static void main(String[] args) {
          // The AK and SK used for authentication are hard-coded or stored in plaintext, which has great security risks. It is recommended that the AK and SK be stored in ciphertext in configuration files or environment variables and decrypted during use to ensure security.
          // In this example, AK and SK are stored in environment variables for authentication. Before running this example, set environment variables CLOUD_SDK_AK and CLOUD_SDK_SK in the local environment
          String ak = System.getenv("CLOUD_SDK_AK");
          String sk = System.getenv("CLOUD_SDK_SK");
          String projectId = "{project_id}";
          ICredential auth = new BasicCredentials()
                  .withProjectId(projectId)
                  .withAk(ak)
                  .withSk(sk);
          WafClient client = WafClient.newBuilder()
                  .withCredential(auth)
                  .withRegion(WafRegion.valueOf("<YOUR REGION>"))
                  .build();
          BatchCreateCcRuleRequest request = new BatchCreateCcRuleRequest();
          BatchCreateCcRuleRequestBody body = new BatchCreateCcRuleRequestBody();
          List<String> listbodyPolicyIds = new ArrayList<>();
          listbodyPolicyIds.add("c467ec81836e4e9391102ad5e5949bb9");
          BatchCreateCcRuleRequestBodyAction actionbody = new BatchCreateCcRuleRequestBodyAction();
          actionbody.withCategory(BatchCreateCcRuleRequestBodyAction.CategoryEnum.fromValue("log"));
          List<String> listConditionsContents = new ArrayList<>();
          listConditionsContents.add("abcde");
          List<CcCondition> listbodyConditions = new ArrayList<>();
          listbodyConditions.add(
              new CcCondition()
                  .withCategory(CcCondition.CategoryEnum.fromValue("header"))
                  .withLogicOperation("contain")
                  .withContents(listConditionsContents)
                  .withIndex("test")
          );
          body.withPolicyIds(listbodyPolicyIds);
          body.withDescription("aa");
          body.withLimitPeriod(60);
          body.withLimitNum(9);
          body.withTagIndex("da");
          body.withTagType(BatchCreateCcRuleRequestBody.BatchCreateCcRuleRequestBody.fromValue("cookie"));
          body.withAction(actionbody);
          body.withConditions(listbodyConditions);
          body.withMode(1);
          body.withName("test1");
          request.withBody(body);
          try {
              BatchCreateCcRuleResponse response = client.batchCreateCcRule(request);
              System.out.println(response.toString());
          } catch (ConnectionException e) {
              e.printStackTrace();
          } catch (RequestTimeoutException e) {
              e.printStackTrace();
          } catch (ServiceResponseException e) {
              e.printStackTrace();
              System.out.println(e.getHttpStatusCode());
              System.out.println(e.getRequestId());
              System.out.println(e.getErrorCode());
              System.out.println(e.getErrorMsg());
          }
      }
  }
  ```
- [Python]
  选中多个策略为这些策略批量添加CC规则
  ```
  # coding: utf-8
  import os
  from huaweicloudsdkcore.auth.credentials import BasicCredentials
  from huaweicloudsdkwaf.v1.region.waf_region import WafRegion
  from huaweicloudsdkcore.exceptions import exceptions
  from huaweicloudsdkwaf.v1 import *
  if __name__ == "__main__":
      # The AK and SK used for authentication are hard-coded or stored in plaintext, which has great security risks. It is recommended that the AK and SK be stored in ciphertext in configuration files or environment variables and decrypted during use to ensure security.
      # In this example, AK and SK are stored in environment variables for authentication. Before running this example, set environment variables CLOUD_SDK_AK and CLOUD_SDK_SK in the local environment
      ak = os.environ["CLOUD_SDK_AK"]
      sk = os.environ["CLOUD_SDK_SK"]
      projectId = "{project_id}"
      credentials = BasicCredentials(ak, sk, projectId)
      client = WafClient.new_builder() \
          .with_credentials(credentials) \
          .with_region(WafRegion.value_of("<YOUR REGION>")) \
          .build()
      try:
          request = BatchCreateCcRuleRequest()
          listPolicyIdsbody = [
              "c467ec81836e4e9391102ad5e5949bb9"
          ]
          actionbody = BatchCreateCcRuleRequestBodyAction(
              category="log"
          )
          listContentsConditions = [
              "abcde"
          ]
          listConditionsbody = [
              CcCondition(
                  category="header",
                  logic_operation="contain",
                  contents=listContentsConditions,
                  index="test"
              )
          ]
          request.body = BatchCreateCcRuleRequestBody(
              policy_ids=listPolicyIdsbody,
              description="aa",
              limit_period=60,
              limit_num=9,
              tag_index="da",
              tag_type="cookie",
              action=actionbody,
              conditions=listConditionsbody,
              mode=1,
              name="test1"
          )
          response = client.batch_create_cc_rule(request)
          print(response)
      except exceptions.ClientRequestException as e:
          print(e.status_code)
          print(e.request_id)
          print(e.error_code)
          print(e.error_msg)
  ```
- [Go]
  选中多个策略为这些策略批量添加CC规则
  ```
  package main
  import (
  "fmt"
  "github.com/huaweicloud/huaweicloud-sdk-go-v3/core/auth/basic"
      waf "github.com/huaweicloud/huaweicloud-sdk-go-v3/services/waf/v1"
  "github.com/huaweicloud/huaweicloud-sdk-go-v3/services/waf/v1/model"
      region "github.com/huaweicloud/huaweicloud-sdk-go-v3/services/waf/v1/region"
  )
  func main() {
      // The AK and SK used for authentication are hard-coded or stored in plaintext, which has great security risks. It is recommended that the AK and SK be stored in ciphertext in configuration files or environment variables and decrypted during use to ensure security.
      // In this example, AK and SK are stored in environment variables for authentication. Before running this example, set environment variables CLOUD_SDK_AK and CLOUD_SDK_SK in the local environment
      ak := os.Getenv("CLOUD_SDK_AK")
      sk := os.Getenv("CLOUD_SDK_SK")
      projectId := "{project_id}"
      auth, err := basic.NewCredentialsBuilder().
          WithAk(ak).
          WithSk(sk).
          WithProjectId(projectId).
          SafeBuild()
      if err != nil {
          fmt.Println(err)
          return
      }
      hcClient, err := waf.WafClientBuilder().
           WithRegion(region.ValueOf("<YOUR REGION>")).
           WithCredential(auth).
           SafeBuild()
      if err != nil {
          fmt.Println(err)
          return
      }
      client := waf.NewWafClient(hcClient)
      request := &model.BatchCreateCcRuleRequest{}
  var listPolicyIdsbody = []string{
          "c467ec81836e4e9391102ad5e5949bb9",
      }
  actionbody := &model.BatchCreateCcRuleRequestBodyAction{
  Category: model.GetBatchCreateCcRuleRequestBodyActionCategoryEnum().LOG,
  }
  var listContentsConditions = []string{
          "abcde",
      }
  indexConditions:= "test"
  var listConditionsbody = []model.CcCondition{
          {
              Category: model.GetCcConditionCategoryEnum().HEADER,
              LogicOperation: "contain",
              Contents: &listContentsConditions,
              Index: &indexConditions,
          },
      }
  descriptionBatchCreateCcRuleRequestBody:= "aa"
  tagIndexBatchCreateCcRuleRequestBody:= "da"
  nameBatchCreateCcRuleRequestBody:= "test1"
  request.Body = &model.BatchCreateCcRuleRequestBody{
  PolicyIds: listPolicyIdsbody,
  Description: &descriptionBatchCreateCcRuleRequestBody,
  LimitPeriod: int32(60),
  LimitNum: int32(9),
  TagIndex: &tagIndexBatchCreateCcRuleRequestBody,
  TagType: model.GetBatchCreateCcRuleRequestBodyTagTypeEnum().COOKIE,
  Action: actionbody,
  Conditions: listConditionsbody,
  Mode: int32(1),
  Name: &nameBatchCreateCcRuleRequestBody,
  }
  response, err := client.BatchCreateCcRule(request)
  if err == nil {
          fmt.Printf("%+v\n", response)
      } else {
          fmt.Println(err)
      }
  }
  ```
- [更多]
  更多编程语言的SDK代码示例，请参见[API Explorer](https://console.huaweicloud.com/apiexplorer/#/openapi/WAF/sdk?api=BatchCreateCcRule)的代码示例页签，可生成自动对应的SDK代码示例。
#### 状态码
| 状态码 | 描述                                                                                                                                                                                                                                                                                                                               |
|:---|:---|
| 200 | **参数解释：** OK **约束限制：** 不涉及 **取值范围：** 不涉及 **默认取值：** 不涉及        |
| 400 | **参数解释：** 请求失败 **约束限制：** 不涉及 **取值范围：** 不涉及 **默认取值：** 不涉及      |
| 401 | **参数解释：** token权限不足 **约束限制：** 不涉及 **取值范围：** 不涉及 **默认取值：** 不涉及 |
| 500 | **参数解释：** 服务器内部错误 **约束限制：** 不涉及 **取值范围：** 不涉及 **默认取值：** 不涉及   |
   
#### 错误码
请参见[错误码](https://support.huaweicloud.com/api-waf/ErrorCode.html)。
