cloudflare 域名脚本

这是一个用于管理 Cloudflare DNS 双栈（IPv4+IPv6）记录的 Bash 脚本，主要功能是自动检测本机公网 IP 并同步到 Cloudflare 域名解析，支持多种操作模式，具体介绍如下：

核心功能#

DNS 记录管理：支持 A 记录（IPv4）和 AAAA 记录（IPv6）的自动添加、更新和删除#

多模式操作：#

自动适配模式（默认）：根据检测到的 IP 类型（IPv4/IPv6）自动管理对应记录
仅 IPv4模式：只处理 A 记录
仅 IPv6模式：只处理 AAAA 记录
删除所有模式：删除指定域名的所有 A/AAAA 记录
增强错误处理：包含 API 重试机制、JSON 响应验证、网络连通性检测等

主要组件#

配置区：需手动设置 Cloudflare 账号邮箱、API 令牌、TTL 和代理状态等参数#

工具函数：#

依赖检查与自动安装（curl、jq、ping6等）
网络连通性验证（特别是 IPv6）
Cloudflare API 调用封装（带重试机制）
日志输出格式化（错误 / 信息 / 警告分类）

核心逻辑：#

获取公网 IP（同时检测 IPv4和 IPv6）
查询 Cloudflare 域名 Zone ID 和现有 DNS 记录
根据操作模式执行相应的 DNS 记录管理（添加 / 更新 / 删除）

使用方法#

1
# 自动适配模式
2
bash cloudflare2026.sh 域名
3

4
# 单独操作模式
5
bash cloudflare2026.sh 域名 4   # 仅IPv4
6
bash cloudflare2026.sh 域名 6   # 仅IPv6
7
bash cloudflare2026.sh 域名 1   # 删除所有记录

特点

自动检测并安装缺失的依赖工具
对 IPv6连通性进行多重验证
API 调用包含重试机制，提高稳定性
详细的日志输出，便于排查问题
自动清理无效记录（如仅 IPv4模式下会删除 IPv6记录）

使用前需确保已在 Cloudflare 上添加域名，并配置正确的 API 令牌（需包含 DNS 权限）。

申请 CloudFlare API#

前往 https://dash.cloudflare.com/profile/api-tokens 登录后，右上角选择个人资料，点击创建令牌

为了安全，用自定义令牌，没有用全局令牌。如你非要用全局令牌，请修改脚本 Authorization 全部替换为 X-Auth-Key

编辑 cloudFlare.sh 内的参数(API 与 Email)后。运行脚本添加/更新域名的解析

其他问题#

官方 API 文档

脚本开源#

1
#!/usr/bin/env bash
2
# 功能: Cloudflare DNS 双栈管理（IPv4+IPv6）+ 增强错误处理
3
# 使用方法:
4
#   1. 自动适配：bash script.sh 域名
5
#   2. 单独操作：bash script.sh 域名 操作类型（4=仅IPv4 6=仅IPv6 1=删除所有 0=自动）
6

7
# -------------------------- 配置区（必改）--------------------------
8
AUTH_EMAIL="你的参数"       # Cloudflare账号邮箱
9
AUTH_TOKEN="你的参数"  # Bearer令牌（需DNS:Edit权限）
10
TTL=1                                  # DNS缓存时间（1=自动）
11
PROXIED=false                          # 是否启用Cloudflare代理（true/false）
12
# IPv6连通性验证节点
13
IPV6_PING_NODES=(
14
    "2606:4700:4700::1111"  # Cloudflare DNS IPv6
15
    "2001:4860:4860::8888"  # Google DNS IPv6
16
    "2400:3200::1"          # Alibaba DNS IPv6
17
)
18
# -------------------------------------------------------------------
19

20
# 初始化核心变量
21
RECORD_NAME="$1"
22
OPERATION="${2:-0}"
23
ZONE_NAME="${RECORD_NAME#*.}"
24
IPV4=""
25
IPV6=""
26
ZONE_ID=""
27
API_BASE="https://api.cloudflare.com/client/v4/zones"
28
EXISTING_IDS=()
29
EXISTING_TYPES=()
30
EXISTING_CONTENTS=()
31

32
# -------------------------- 工具函数 --------------------------
33
# 错误处理（红色）
34
error_exit() {
35
    echo -e "\033[31m错误：$1\033[0m" >&2
36
    exit 1
37
}
38

39
# 日志输出（绿色）
40
log_info() {
41
    echo -e "\033[32m$1\033[0m"
42
}
43

44
# 警告输出（黄色）
45
log_warn() {
46
    echo -e "\033[33m警告：$1\033[0m"
47
}
48

49
# 安装依赖
50
install_dependency() {
51
    local dep=$1
52
    log_info "正在安装依赖: $dep"
53

54
    if command -v apt-get &> /dev/null; then
55
        sudo apt-get update -qq > /dev/null
56
        sudo apt-get install -qq -y "$dep" > /dev/null
57
    elif command -v yum &> /dev/null; then
58
        sudo yum install -y "$dep" > /dev/null
59
    elif command -v dnf &> /dev/null; then
60
        sudo dnf install -y "$dep" > /dev/null
61
    elif command -v pacman &> /dev/null; then
62
        sudo pacman -S --noconfirm "$dep" > /dev/null
63
    else
64
        error_exit "不支持的操作系统，无法自动安装依赖 $dep，请手动安装"
65
    fi
66

67
    if ! command -v "$dep" &> /dev/null; then
68
        error_exit "依赖 $dep 安装失败，请手动安装"
69
    fi
70
}
71

72
# 检查并安装依赖
73
check_deps() {
74
    local missing=0
75
    local deps=()
76

77
    if ! command -v curl &> /dev/null; then
78
        echo "缺少依赖：curl" >&2
79
        deps+=("curl")
80
        missing=1
81
    fi
82
    if ! command -v jq &> /dev/null; then
83
        echo "缺少依赖：jq" >&2
84
        deps+=("jq")
85
        missing=1
86
    fi
87

88
    # 检查IPv6 ping工具
89
    local ping6_available=0
90
    if command -v ping6 &> /dev/null; then
91
        ping6_available=1
92
    elif ping -6 -c 1 -W 1 ::1 &> /dev/null; then
93
        ping6_available=1
94
    fi
95
    if [ $ping6_available -eq 0 ]; then
96
        echo "缺少依赖：IPv6 ping工具" >&2
97
        # 根据不同系统添加对应的iputils包
98
        if command -v apt-get &> /dev/null; then
99
            deps+=("iputils-ping")
100
        elif command -v yum &> /dev/null || command -v dnf &> /dev/null; then
101
            deps+=("iputils")
102
        elif command -v pacman &> /dev/null; then
103
            deps+=("iputils")
104
        fi
105
        missing=1
106
    fi
107

108
    if [ $missing -eq 1 ]; then
109
        log_info "开始安装缺失的依赖..."
110
        for dep in "${deps[@]}"; do
111
            install_dependency "$dep"
112
        done
113
        log_info "所有依赖安装完成"
114
    fi
115
}
116

117
# 验证响应是否为JSON（修复HTML响应问题）
118
is_valid_json() {
119
    local input="$1"
120
    # 检查是否包含HTML标签（常见错误情况）
121
    if echo "$input" | grep -qi '<html>\|<body>\|<doctype'; then
122
        return 1
123
    fi
124
    # 使用jq验证JSON格式
125
    echo "$input" | jq . >/dev/null 2>&1
126
    return $?
127
}
128

129
# IPv6网络连通性验证
130
verify_ipv6_connectivity() {
131
    log_info "正在验证IPv6网络连通性..."
132
    local ping_success=0
133
    local ping_cmd="ping6"
134
    if ! command -v ping6 &> /dev/null; then
135
        ping_cmd="ping -6"
136
    fi
137

138
    for node in "${IPV6_PING_NODES[@]}"; do
139
        log_info "正在ping IPv6节点：$node..."
140
        if $ping_cmd -c 1 -W 3 "$node" &> /dev/null; then
141
            log_info "✅ IPv6节点[$node] ping通"
142
            ping_success=1
143
            break
144
        fi
145
    done
146

147
    if [ "$ping_success" -eq 0 ]; then
148
        error_exit "❌ 所有IPv6节点均无法连通，取消IPv6操作"
149
    fi
150
}
151

152
# 获取本机公网IP
153
get_public_ips() {
154
    log_info "正在检测本机公网IP..."
155

156
    # 获取IPv4（带错误处理）
157
    IPV4=$(curl -4 -s --max-time 5 --retry 2 api64.ipify.org)
158
    if [ -z "$IPV4" ]; then
159
        IPV4=$(curl -4 -s --max-time 5 --retry 2 ipv4.ip.sb)
160
    fi
161

162
    # 获取IPv6（带错误处理）
163
    IPV6=$(curl -6 -s --max-time 5 --retry 2 api64.ipify.org)
164
    if [ -z "$IPV6" ]; then
165
        IPV6=$(curl -6 -s --max-time 5 --retry 2 ipv6.ip.sb)
166
    fi
167

168
    # 验证并输出结果
169
    if [ -n "$IPV6" ]; then
170
        verify_ipv6_connectivity
171
        log_info "✅ 检测到IPv6：$IPV6"
172
    fi
173
    if [ -n "$IPV4" ]; then
174
        log_info "✅ 检测到IPv4：$IPV4"
175
    fi
176
    if [ -z "$IPV4" ] && [ -z "$IPV6" ]; then
177
        error_exit "❌ 未检测到任何公网IP"
178
    fi
179
}
180

181
# 调用Cloudflare API（增强版）
182
call_api() {
183
    local method="$1"
184
    local endpoint="$2"
185
    local data="${3:-}"
186

187
    # 执行API请求（增加重试机制）
188
    for ((attempt=1; attempt<=3; attempt++)); do
189
        response=$(curl -s -w "\n%{http_code}" -X "$method" \
190
            -H "X-Auth-Email: $AUTH_EMAIL" \
191
            -H "Authorization: Bearer $AUTH_TOKEN" \
192
            -H "Content-Type: application/json" \
193
            ${data:+-d "$data"} \
194
            "$API_BASE$endpoint")
195

196
        http_code=$(echo "$response" | tail -n1)
197
        response_body=$(echo "$response" | head -n -1)
198

199
        # 检查HTTP状态码
200
        if [ "$http_code" -ge 200 ] && [ "$http_code" -lt 300 ]; then
201
            # 检查是否为有效JSON
202
            if is_valid_json "$response_body"; then
203
                # 检查API成功状态
204
                if echo "$response_body" | jq -e '.success' > /dev/null; then
205
                    echo "$response_body"
206
                    return 0
207
                fi
208
            fi
209
        fi
210

211
        # 重试提示
212
        if [ $attempt -lt 3 ]; then
213
            log_warn "API请求尝试$attempt失败，正在重试..."
214
            sleep 2
215
        fi
216
    done
217

218
    # 详细错误信息
219
    error_exit "API请求失败：
220
    方法: $method
221
    地址: $API_BASE$endpoint
222
    状态码: $http_code
223
    响应: $(echo "$response_body" | head -n 10)  # 显示前10行"
224
}
225

226
# 获取Cloudflare Zone ID
227
get_zone_id() {
228
    log_info "正在获取Zone ID（$ZONE_NAME）..."
229
    response=$(call_api "GET" "?name=$ZONE_NAME")
230
    ZONE_ID=$(echo "$response" | jq -r '.result[0].id')
231

232
    if [ -z "$ZONE_ID" ] || [ "$ZONE_ID" = "null" ]; then
233
        error_exit "未找到域名$ZONE_NAME，请检查：
234
        1. 域名是否已添加到Cloudflare
235
        2. 认证信息是否正确
236
        3. API令牌是否有足够权限"
237
    fi
238
    log_info "✅ 成功获取Zone ID：$ZONE_ID"
239
}
240

241
# 获取现有DNS记录
242
get_existing_records() {
243
    log_info "正在查询现有DNS记录（$RECORD_NAME）..."
244
    response=$(call_api "GET" "/$ZONE_ID/dns_records?name=$RECORD_NAME")
245

246
    local record_count=$(echo "$response" | jq '.result | length')
247
    if [ "$record_count" -eq 0 ]; then
248
        log_info "ℹ️ 未查询到任何DNS记录"
249
        return
250
    fi
251

252
    # 提取A/AAAA记录
253
    for ((i=0; i<record_count; i++)); do
254
        local type=$(echo "$response" | jq -r ".result[$i].type")
255
        if [ "$type" = "A" ] || [ "$type" = "AAAA" ]; then
256
            EXISTING_IDS+=($(echo "$response" | jq -r ".result[$i].id"))
257
            EXISTING_TYPES+=("$type")
258
            EXISTING_CONTENTS+=($(echo "$response" | jq -r ".result[$i].content"))
259
        fi
260
    done
261

262
    # 显示记录
263
    log_info "✅ 查询到${#EXISTING_TYPES[@]}条有效记录："
264
    for ((i=0; i<${#EXISTING_TYPES[@]}; i++)); do
265
        echo "  - ${EXISTING_TYPES[$i]}: ${EXISTING_CONTENTS[$i]}"
266
    done
267
}
268

269
# -------------------------- DNS操作函数 --------------------------
270
add_record() {
271
    local type="$1"
272
    local content="$2"
273

274
    log_info "正在添加$type记录：$RECORD_NAME → $content"
275
    local data=$(jq -n \
276
        --arg type "$type" \
277
        --arg name "$RECORD_NAME" \
278
        --arg content "$content" \
279
        --argjson ttl "$TTL" \
280
        --argjson proxied "$PROXIED" \
281
        '{type: $type, name: $name, content: $content, ttl: $ttl, proxied: $proxied}')
282

283
    call_api "POST" "/$ZONE_ID/dns_records" "$data"
284
    log_info "✅ $type记录添加成功"
285
}
286

287
update_record() {
288
    local record_id="$1"
289
    local type="$2"
290
    local old_ip="$3"
291
    local new_ip="$4"
292

293
    log_info "正在更新$type记录：$old_ip → $new_ip"
294
    local data=$(jq -n \
295
        --arg type "$type" \
296
        --arg name "$RECORD_NAME" \
297
        --arg content "$new_ip" \
298
        --argjson ttl "$TTL" \
299
        --argjson proxied "$PROXIED" \
300
        '{type: $type, name: $name, content: $content, ttl: $ttl, proxied: $proxied}')
301

302
    call_api "PUT" "/$ZONE_ID/dns_records/$record_id" "$data"
303
    log_info "✅ $type记录更新成功"
304
}
305

306
delete_record() {
307
    local record_id="$1"
308
    local type="$2"
309
    local content="$3"
310

311
    log_info "正在删除$type记录：$content"
312
    call_api "DELETE" "/$ZONE_ID/dns_records/$record_id"
313
    log_info "✅ $type记录删除成功"
314
}
315

316
# -------------------------- 主逻辑函数 --------------------------
317
manage_ipv4() {
318
    local has_a_record=0
319
    local a_record_id=""
320
    local a_old_ip=""
321

322
    # 检查现有A记录
323
    for ((i=0; i<${#EXISTING_TYPES[@]}; i++)); do
324
        if [ "${EXISTING_TYPES[$i]}" = "A" ]; then
325
            has_a_record=1
326
            a_record_id="${EXISTING_IDS[$i]}"
327
            a_old_ip="${EXISTING_CONTENTS[$i]}"
328
            break
329
        fi
330
    done
331

332
    # 处理A记录
333
    if [ "$has_a_record" -eq 1 ]; then
334
        if [ "$a_old_ip" = "$IPV4" ]; then
335
            log_info "ℹ️ A记录已为最新：$IPV4"
336
        else
337
            update_record "$a_record_id" "A" "$a_old_ip" "$IPV4"
338
        fi
339
    else
340
        add_record "A" "$IPV4"
341
    fi
342

343
    # 清理残留IPv6记录
344
    if [ -z "$IPV6" ] && [ "$OPERATION" -ne 6 ]; then
345
        for ((i=0; i<${#EXISTING_TYPES[@]}; i++)); do
346
            if [ "${EXISTING_TYPES[$i]}" = "AAAA" ]; then
347
                delete_record "${EXISTING_IDS[$i]}" "AAAA" "${EXISTING_CONTENTS[$i]}"
348
            fi
349
        done
350
    fi
351
}
352

353
manage_ipv6() {
354
    # 二次验证IPv6连通性
355
    verify_ipv6_connectivity
356

357
    local has_aaaa_record=0
358
    local aaaa_record_id=""
359
    local aaaa_old_ip=""
360

361
    # 检查现有AAAA记录
362
    for ((i=0; i<${#EXISTING_TYPES[@]}; i++)); do
363
        if [ "${EXISTING_TYPES[$i]}" = "AAAA" ]; then
364
            has_aaaa_record=1
365
            aaaa_record_id="${EXISTING_IDS[$i]}"
366
            aaaa_old_ip="${EXISTING_CONTENTS[$i]}"
367
            break
368
        fi
369
    done
370

371
    # 处理AAAA记录
372
    if [ "$has_aaaa_record" -eq 1 ]; then
373
        if [ "$aaaa_old_ip" = "$IPV6" ]; then
374
            log_info "ℹ️ AAAA记录已为最新：$IPV6"
375
        else
376
            update_record "$aaaa_record_id" "AAAA" "$aaaa_old_ip" "$IPV6"
377
        fi
378
    else
379
        add_record "AAAA" "$IPV6"
380
    fi
381

382
    # 清理残留IPv4记录
383
    if [ -z "$IPV4" ] && [ "$OPERATION" -ne 4 ]; then
384
        for ((i=0; i<${#EXISTING_TYPES[@]}; i++)); do
385
            if [ "${EXISTING_TYPES[$i]}" = "A" ]; then
386
                delete_record "${EXISTING_IDS[$i]}" "A" "${EXISTING_CONTENTS[$i]}"
387
            fi
388
        done
389
    fi
390
}
391

392
delete_all_records() {
393
    if [ ${#EXISTING_TYPES[@]} -eq 0 ]; then
394
        log_info "ℹ️ 没有记录可删除"
395
        return
396
    fi
397

398
    log_info "正在删除所有记录（共${#EXISTING_TYPES[@]}条）..."
399
    for ((i=0; i<${#EXISTING_TYPES[@]}; i++)); do
400
        delete_record "${EXISTING_IDS[$i]}" "${EXISTING_TYPES[$i]}" "${EXISTING_CONTENTS[$i]}"
401
    done
402
}
403

404
# -------------------------- 主流程 --------------------------
405
main() {
406
    # 参数检查
407
    if [ -z "$RECORD_NAME" ]; then
408
        error_exit "请指定域名！使用方法：
409
  自动适配：$0 域名
410
  单独操作：$0 域名 [4/6/1]"
411
    fi
412

413
    # 环境检查
414
    check_deps
415

416
    # 主逻辑执行
417
    echo -e "\n===== Cloudflare DNS 双栈管理工具 ====="
418
    get_public_ips
419
    get_zone_id
420
    get_existing_records
421

422
    echo -e "\n----------------------------------------"
423
    case "$OPERATION" in
424
        0)  # 自动适配
425
            log_info "执行自动适配模式"
426
            [ -n "$IPV4" ] && manage_ipv4
427
            [ -n "$IPV6" ] && manage_ipv6
428
            ;;
429
        4)  # 仅IPv4
430
            [ -z "$IPV4" ] && error_exit "未检测到IPv4地址"
431
            log_info "执行仅IPv4模式"
432
            manage_ipv4
433
            ;;
434
        6)  # 仅IPv6
435
            [ -z "$IPV6" ] && error_exit "未检测到IPv6地址"
436
            log_info "执行仅IPv6模式"
437
            manage_ipv6
438
            ;;
439
        1)  # 删除所有
440
            log_info "执行删除所有记录模式"
441
            delete_all_records
442
            ;;
443
        *)  # 无效操作
444
            error_exit "无效操作类型！可选值：0=自动 4=仅IPv4 6=仅IPv6 1=删除所有"
445
            ;;
446
    esac
447

448
    echo -e "\n----------------------------------------"
449
    log_info "操作完成"
450
}
451

452
# 启动主程序
453
main