डेमो

यह गाइड आपको API का उपयोग करके F5 Distributed Cloud पर एक संपूर्ण Client-Side Defense अभ्यास के माध्यम से ले जाती है — जो चार चरणों में संरचित है जिन्हें एक AI सहायक या मानव ऑपरेटर शुरू से अंत तक निष्पादित कर सकता है। प्रत्येक चरण में एक रेडी-टू-रन curl कमांड शामिल है जिसमें प्लेसहोल्डर मान हैं जिन्हें आप पृष्ठ के शीर्ष पर दिए गए फॉर्म, .env फाइल, या किसी भी ऑटोमेशन टूल का उपयोग करके अनुकूलित कर सकते हैं।

सावधानी

प्लेसहोल्डर फॉर्म मान — जिसमें आपका API टोकन भी शामिल है — ब्राउज़र के localStorage में संग्रहीत करता है। साझा या सार्वजनिक मशीनों पर प्रोडक्शन टोकन का उपयोग न करें।

अभ्यास चरण

चरण	लक्ष्य	स्टेप्स
चरण 1 — बिल्ड	पूर्ण CSD इन्फ्रास्ट्रक्चर को डिप्लॉय और वैलिडेट करें	स्टेप्स 1–7
चरण 2 — अटैक	सिमुलेटेड अटैक ट्रैफिक जनरेट करें और CSD द्वारा इसकी पहचान की पुष्टि करें	स्टेप्स 8–9
चरण 3 — मिटिगेट	मिटिगेशन से पहले/बाद का प्रमाण — अटैक चलाएं, मिटिगेशन लागू करें, अटैक पुनः चलाएं, तुलना करें	स्टेप्स 1–6
चरण 4 — टियरडाउन	स्पष्ट पुष्टि के बाद सभी डिप्लॉयमेंट ऑब्जेक्ट्स हटाएं	टियरडाउन

प्री-फ्लाइट जांच

चरण 1 शुरू करने से पहले, सत्यापित करें कि वातावरण साफ है। यह निर्धारित करने के लिए ये API जांचें चलाएं कि पिछले रन से बचे हुए ऑब्जेक्ट्स मौजूद हैं या नहीं:

# Check all Phase 1 objects and compute environment status
HTTP_LB=$(curl -s -o /dev/null -w '%\{http_code\}' \
  -H "Authorization: APIToken xF5XC_API_TOKENx" \
  "xF5XC_API_URLx/api/config/namespaces/xF5XC_NAMESPACEx/http_loadbalancers/xF5XC_LB_NAMEx-http")
HTTPS_LB=$(curl -s -o /dev/null -w '%\{http_code\}' \
  -H "Authorization: APIToken xF5XC_API_TOKENx" \
  "xF5XC_API_URLx/api/config/namespaces/xF5XC_NAMESPACEx/http_loadbalancers/xF5XC_LB_NAMEx-https")
ORIGIN=$(curl -s -o /dev/null -w '%\{http_code\}' \
  -H "Authorization: APIToken xF5XC_API_TOKENx" \
  "xF5XC_API_URLx/api/config/namespaces/xF5XC_NAMESPACEx/origin_pools/xF5XC_ORIGIN_POOLx")
HC=$(curl -s -o /dev/null -w '%\{http_code\}' \
  -H "Authorization: APIToken xF5XC_API_TOKENx" \
  "xF5XC_API_URLx/api/config/namespaces/xF5XC_NAMESPACEx/healthchecks/xF5XC_HC_NAMEx")
PD_COUNT=$(curl -s -H "Authorization: APIToken xF5XC_API_TOKENx" \
  "xF5XC_API_URLx/api/shape/csd/namespaces/xF5XC_NAMESPACEx/protected_domains" \
  | jq '[.items // [] | .[] | select(.metadata.name != null)] | length')
MD_COUNT=$(curl -s -H "Authorization: APIToken xF5XC_API_TOKENx" \
  "xF5XC_API_URLx/api/shape/csd/namespaces/xF5XC_NAMESPACEx/mitigated_domains" \
  | jq '[.items // [] | .[] | select(.metadata.name != null)] | length')

# If HTTPS LB exists, fetch body to detect skeleton state
HTTPS_IS_SKELETON="false"
if [ "$HTTPS_LB" = "200" ]; then
  HTTPS_LB_BODY=$(curl -s \
    -H "Authorization: APIToken xF5XC_API_TOKENx" \
    "xF5XC_API_URLx/api/config/namespaces/xF5XC_NAMESPACEx/http_loadbalancers/xF5XC_LB_NAMEx-https")
  HTTPS_IS_SKELETON=$(echo "$HTTPS_LB_BODY" | jq '
    ((.spec.default_route_pools // []) | length == 0) and
    (.spec.client_side_defense == null)
  ')
fi

# Compute deterministic environment status
jq -n \
  --argjson http_lb "$HTTP_LB" \
  --argjson https_lb "$HTTPS_LB" \
  --argjson origin "$ORIGIN" \
  --argjson hc "$HC" \
  --argjson pd "$PD_COUNT" \
  --argjson md "$MD_COUNT" \
  --argjson https_skeleton "$HTTPS_IS_SKELETON" \
'{
  objects: [
    { name: "http_lb",           http_code: $http_lb, exists: ($http_lb == 200) },
    { name: "https_lb",          http_code: $https_lb, exists: ($https_lb == 200), is_skeleton: $https_skeleton },
    { name: "origin_pool",       http_code: $origin, exists: ($origin == 200) },
    { name: "healthcheck",       http_code: $hc, exists: ($hc == 200) },
    { name: "protected_domains", count: $pd, exists: ($pd > 0) },
    { name: "mitigated_domains", count: $md, exists: ($md > 0) }
  ],
  any_infra_exists: ($http_lb == 200 or ($https_lb == 200 and ($https_skeleton | not)) or $origin == 200 or $hc == 200),
  any_csd_exists: ($pd > 0 or $md > 0),
  status: (
    if ($http_lb == 404 and $https_lb == 404 and $origin == 404 and $hc == 404 and $pd == 0 and $md == 0) then "CLEAN"
    elif ($https_lb == 200 and $https_skeleton and $http_lb == 404 and $origin == 404 and $hc == 404 and $pd == 0 and $md == 0) then "HTTPS_SKELETON"
    elif ($http_lb == 200 and $origin == 200) then "ALL_EXIST"
    elif ($http_lb == 200 or ($https_lb == 200 and ($https_skeleton | not)) or $origin == 200 or $hc == 200) then "TEARDOWN_NEEDED"
    elif ($md > 0 and $http_lb == 404 and ($https_lb == 404 or ($https_lb == 200 and $https_skeleton)) and $origin == 404 and $hc == 404) then "MITIGATIONS_ONLY"
    else "TEARDOWN_NEEDED"
    end
  ),
  action: (
    if ($http_lb == 404 and $https_lb == 404 and $origin == 404 and $hc == 404 and $pd == 0 and $md == 0) then "Proceed to Phase 1"
    elif ($https_lb == 200 and $https_skeleton and $http_lb == 404 and $origin == 404 and $hc == 404 and $pd == 0 and $md == 0) then "Proceed to Phase 1 (HTTPS LB skeleton will be restored via PUT)"
    elif ($http_lb == 200 and $origin == 200) then "All Phase 1 objects exist — verify health, optionally skip to Phase 2"
    elif ($http_lb == 200 or ($https_lb == 200 and ($https_skeleton | not)) or $origin == 200 or $hc == 200) then "Run Phase 4 Teardown first, then re-check"
    elif ($md > 0 and $http_lb == 404 and ($https_lb == 404 or ($https_lb == 200 and $https_skeleton)) and $origin == 404 and $hc == 404) then "Delete mitigated domains inline, then proceed"
    else "Run Phase 4 Teardown first, then re-check"
    end
  )
}'

स्किप-अहेड सत्यापन

जब सभी चरण 1 ऑब्जेक्ट्स मौजूद हों (200) और आप चरण 2 पर जाने की योजना बना रहे हों, तो स्किप करने से पहले इन्फ्रास्ट्रक्चर स्वास्थ्य की पुष्टि करने के लिए चरण 1 स्टेप 7 सत्यापन कमांड चलाएं। चरण 1 — स्टेप 7: सत्यापन से सटीक कमांड का उपयोग करें:

1. DNS रिज़ॉल्यूशन: dig +short xF5XC_DOMAINNAMEx A
2. HTTP LB स्थिति: GET .../http_loadbalancers/xF5XC_LB_NAMEx-http को jq '{state: .spec.state}' में पाइप करें — VIRTUAL_HOST_READY दिखना चाहिए
3. CSD JS कॉन्फ़िगरेशन: GET .../js_configuration — इसमें scriptTag होना चाहिए
4. CSD स्थिति: GET .../status को jq '{configured: .isConfigured, enabled: .isEnabled}' में पाइप करें — दोनों true होने चाहिए

चरण 2 पर जाने से पहले सभी आवश्यक जांचें (DNS-1, LB-1, CSD-1, CSD-2) PASS होनी चाहिए। यदि कोई जांच विफल होती है, तो विफल स्टेप से चरण 1 निष्पादित करें।

टिप्पणी

मिटिगेटेड डोमेन सूची 1 की गिनती लौटा सकती है जिसमें null मेटाडेटा हो, भले ही कोई वास्तविक मिटिगेशन मौजूद न हो। यह एक बैकेंड आर्टिफैक्ट है। निर्णय नियम: यदि एकल आइटम में null मेटाडेटा है (name null या खाली है), तो इसे 0 मानें। यदि इसमें वास्तविक मेटाडेटा है, तो आगे बढ़ने से पहले प्रत्येक आइटम को name से हटाएं।

टिप्पणी

CSD डिटेक्शन इन्फ्रास्ट्रक्चर टियरडाउन/रीबिल्ड के बाद भी बने रहते हैं जब वही प्रोटेक्टेड डोमेन उसी टेनेंट पर पुनः रजिस्टर किया जाता है। टियरडाउन और रीबिल्ड के बाद, एक बार /detected_domains क्वेरी करें। यदि प्रतिक्रिया में आइटम हैं, तो तुरंत आगे बढ़ें — प्रतीक्षा की आवश्यकता नहीं है। यदि प्रतिक्रिया खाली है, तो 30 सेकंड प्रतीक्षा करें और एक बार फिर क्वेरी करें। यदि दूसरी क्वेरी के बाद भी खाली है, तो वैसे भी आगे बढ़ें — सिमुलेशन चलने पर डिटेक्शन दिखाई देंगे।

तत्परता सत्यापन मैट्रिक्स

ऊपर दी गई प्री-फ्लाइट जांच सत्यापित करती है कि वातावरण साफ है। नीचे दिया गया तत्परता मैट्रिक्स सत्यापित करता है कि वातावरण सक्षम है — कि एक सफल डेमो के लिए सभी पूर्वापेक्षाएं, कोटा, कनेक्टिविटी, और प्लेटफॉर्म सेवाएं उपलब्ध हैं। तैयारी चरण के हिस्से के रूप में हर मीटिंग से पहले इस मैट्रिक्स को चलाएं।

प्रत्येक जांच में एक टेस्ट ID, एक टियर (T0–T5), PASS/FAIL/WARN मानदंड, और एक उपचार पथ है। टियर अनुक्रमिक हैं — पहले के टियर में FAIL बाद के टियर को चलने से रोकता है।

टियर सारांश

टियर	श्रेणी	डेमो ब्लॉक करता है?	उद्देश्य
T0	कनेक्टिविटी और प्रमाणीकरण	हां	क्या हम प्लेटफॉर्म तक पहुंच सकते हैं और प्रमाणित हो सकते हैं?
T1	कोटा और क्षमता	हां (यदि सीमा पर)	क्या डेमो ऑब्जेक्ट्स बनाने के लिए जगह है?
T2	प्लेटफॉर्म पूर्वापेक्षाएं	हां	क्या टेनेंट-स्तरीय सेवाएं कॉन्फ़िगर हैं?
T3	ऑरिजिन स्वास्थ्य	चेतावनी	क्या बैकेंड एप्लिकेशन प्रतिक्रिया दे रहा है?
T4	वातावरण साफ	स्वतः-उपचार	क्या पिछले रन से बचे हुए ऑब्जेक्ट्स हैं?
T5	प्रमाणपत्र तत्परता	सूचनात्मक	क्या HTTPS काम करेगा, या हमें केवल-HTTP की योजना बनानी चाहिए?

T0: कनेक्टिविटी और प्रमाणीकरण

ये जांचें पुष्टि करती हैं कि निष्पादन होस्ट F5 XC API तक पहुंच सकता है और क्रेडेंशियल वैध हैं।

PF-T0-1: API कनेक्टिविटी

HTTP_CODE=$(curl -s -o /dev/null -w '%\{http_code\}' --connect-timeout 10 --max-time 15 \
  -H "Authorization: APIToken xF5XC_API_TOKENx" \
  "xF5XC_API_URLx/api/web/namespaces")
echo "{\"http_code\": $HTTP_CODE}" | jq '{
  check: "PF-T0-1",
  http_code: .http_code,
  status: (
    if .http_code == 200 then "PASS"
    elif .http_code == 401 then "FAIL"
    else "FAIL"
    end
  ),
  detail: (
    if .http_code == 200 then "API reachable, token valid"
    elif .http_code == 401 then "Token expired or invalid — regenerate under Administration > Credentials > API Credentials"
    elif .http_code == 0 then "Network unreachable — check connectivity, VPN, or TLS compatibility (try --tlsv1.2 --tls-max 1.2)"
    else "Unexpected HTTP \(.http_code)"
    end
  )
}'

PF-T0-2: नेमस्पेस एक्सेस

HTTP_CODE=$(curl -s -o /dev/null -w '%\{http_code\}' \
  -H "Authorization: APIToken xF5XC_API_TOKENx" \
  "xF5XC_API_URLx/api/config/namespaces/xF5XC_NAMESPACEx/http_loadbalancers")
echo "{\"http_code\": $HTTP_CODE}" | jq '{
  check: "PF-T0-2",
  http_code: .http_code,
  status: (
    if .http_code == 200 then "PASS"
    elif .http_code == 404 then "WARN"
    else "FAIL"
    end
  ),
  detail: (
    if .http_code == 200 then "Token has namespace access"
    elif .http_code == 403 then "Token lacks permissions for namespace — check role bindings"
    elif .http_code == 404 then "Namespace does not exist — will be created in Phase 1 Step 0"
    else "Unexpected HTTP \(.http_code)"
    end
  )
}'

PF-T0-3: CSD API एक्सेस

HTTP_CODE=$(curl -s -o /dev/null -w '%\{http_code\}' \
  -H "Authorization: APIToken xF5XC_API_TOKENx" \
  "xF5XC_API_URLx/api/shape/csd/namespaces/xF5XC_NAMESPACEx/status")
echo "{\"http_code\": $HTTP_CODE}" | jq '{
  check: "PF-T0-3",
  http_code: .http_code,
  status: (
    if .http_code == 200 then "PASS"
    elif .http_code == 404 then "WARN"
    else "FAIL"
    end
  ),
  detail: (
    if .http_code == 200 then "Token has CSD/Shape API permissions"
    elif .http_code == 403 then "Token lacks CSD role binding — contact tenant administrator"
    elif .http_code == 404 then "Namespace does not exist — CSD access will be verified after namespace creation in Phase 1"
    else "Unexpected HTTP \(.http_code)"
    end
  )
}'

PF-T0-4: RBAC अनुमति मैट्रिक्स

गैर-विनाशकारी प्रोब डेमो के लिए आवश्यक प्रत्येक ऑब्जेक्ट प्रकार के लिए रीड और राइट अनुमतियों का परीक्षण करते हैं। रीड का परीक्षण लिस्ट एंडपॉइंट पर GET के माध्यम से किया जाता है। राइट का परीक्षण ज्ञात-अस्तित्वहीन ऑब्जेक्ट्स पर DELETE के माध्यम से किया जाता है — API 403 लौटाता है यदि RBAC ऑपरेशन को अस्वीकार करता है, या 404 यदि ऑपरेशन की अनुमति है लेकिन ऑब्जेक्ट मौजूद नहीं है। यह शून्य-साइड-इफेक्ट तकनीक अस्थायी प्रोब ऑब्जेक्ट्स बनाने से बचाती है।

PROBE_NAME="rbac-probe-nonexistent"

# Read probes
NS_R=$(curl -s -o /dev/null -w '%\{http_code\}' --max-time 10 \
  -H "Authorization: APIToken xF5XC_API_TOKENx" \
  "xF5XC_API_URLx/api/web/namespaces/xF5XC_NAMESPACEx")
HC_R=$(curl -s -o /dev/null -w '%\{http_code\}' --max-time 10 \
  -H "Authorization: APIToken xF5XC_API_TOKENx" \
  "xF5XC_API_URLx/api/config/namespaces/xF5XC_NAMESPACEx/healthchecks")
OP_R=$(curl -s -o /dev/null -w '%\{http_code\}' --max-time 10 \
  -H "Authorization: APIToken xF5XC_API_TOKENx" \
  "xF5XC_API_URLx/api/config/namespaces/xF5XC_NAMESPACEx/origin_pools")
LB_R=$(curl -s -o /dev/null -w '%\{http_code\}' --max-time 10 \
  -H "Authorization: APIToken xF5XC_API_TOKENx" \
  "xF5XC_API_URLx/api/config/namespaces/xF5XC_NAMESPACEx/http_loadbalancers")
CSD_R=$(curl -s -o /dev/null -w '%\{http_code\}' --max-time 10 \
  -H "Authorization: APIToken xF5XC_API_TOKENx" \
  "xF5XC_API_URLx/api/shape/csd/namespaces/xF5XC_NAMESPACEx/status")
PD_R=$(curl -s -o /dev/null -w '%\{http_code\}' --max-time 10 \
  -H "Authorization: APIToken xF5XC_API_TOKENx" \
  "xF5XC_API_URLx/api/shape/csd/namespaces/xF5XC_NAMESPACEx/protected_domains")
MD_R=$(curl -s -o /dev/null -w '%\{http_code\}' --max-time 10 \
  -H "Authorization: APIToken xF5XC_API_TOKENx" \
  "xF5XC_API_URLx/api/shape/csd/namespaces/xF5XC_NAMESPACEx/mitigated_domains")

# Write probes (non-destructive: DELETE/cascade_delete on non-existent objects)
NS_W=$(curl -s -o /dev/null -w '%\{http_code\}' --max-time 10 \
  -X POST -H "Authorization: APIToken xF5XC_API_TOKENx" \
  -H "Content-Type: application/json" \
  -d "{\"name\":\"$PROBE_NAME\"}" \
  "xF5XC_API_URLx/api/web/namespaces/$PROBE_NAME/cascade_delete")
HC_W=$(curl -s -o /dev/null -w '%\{http_code\}' --max-time 10 \
  -X DELETE -H "Authorization: APIToken xF5XC_API_TOKENx" \
  "xF5XC_API_URLx/api/config/namespaces/xF5XC_NAMESPACEx/healthchecks/$PROBE_NAME")
OP_W=$(curl -s -o /dev/null -w '%\{http_code\}' --max-time 10 \
  -X DELETE -H "Authorization: APIToken xF5XC_API_TOKENx" \
  "xF5XC_API_URLx/api/config/namespaces/xF5XC_NAMESPACEx/origin_pools/$PROBE_NAME")
LB_W=$(curl -s -o /dev/null -w '%\{http_code\}' --max-time 10 \
  -X DELETE -H "Authorization: APIToken xF5XC_API_TOKENx" \
  "xF5XC_API_URLx/api/config/namespaces/xF5XC_NAMESPACEx/http_loadbalancers/$PROBE_NAME")
PD_W=$(curl -s -o /dev/null -w '%\{http_code\}' --max-time 10 \
  -X DELETE -H "Authorization: APIToken xF5XC_API_TOKENx" \
  "xF5XC_API_URLx/api/shape/csd/namespaces/xF5XC_NAMESPACEx/protected_domains/$PROBE_NAME.example.com")
MD_W=$(curl -s -o /dev/null -w '%\{http_code\}' --max-time 10 \
  -X DELETE -H "Authorization: APIToken xF5XC_API_TOKENx" \
  "xF5XC_API_URLx/api/shape/csd/namespaces/xF5XC_NAMESPACEx/mitigated_domains/$PROBE_NAME.example.com")

# Compute deterministic permission matrix
jq -n \
  --argjson ns_r "$NS_R" --argjson ns_w "$NS_W" \
  --argjson hc_r "$HC_R" --argjson hc_w "$HC_W" \
  --argjson op_r "$OP_R" --argjson op_w "$OP_W" \
  --argjson lb_r "$LB_R" --argjson lb_w "$LB_W" \
  --argjson csd_r "$CSD_R" \
  --argjson pd_r "$PD_R" --argjson pd_w "$PD_W" \
  --argjson md_r "$MD_R" --argjson md_w "$MD_W" \
'{
  check: "PF-T0-4",
  permissions: [
    { object: "namespace",          read: ($ns_r != 403),  write: ($ns_w != 403),  required: false, note: "conditional — only if ns must be created" },
    { object: "healthcheck",        read: ($hc_r != 403),  write: ($hc_w != 403),  required: false, note: "optional for CSD" },
    { object: "origin_pool",        read: ($op_r != 403),  write: ($op_w != 403),  required: true,  note: "" },
    { object: "http_loadbalancer",  read: ($lb_r != 403),  write: ($lb_w != 403),  required: true,  note: "" },
    { object: "csd_status",         read: ($csd_r != 403), write: true,            required: true,  note: "read-only check" },
    { object: "protected_domain",   read: ($pd_r != 403),  write: ($pd_w != 403),  required: true,  note: "" },
    { object: "mitigated_domain",   read: ($md_r != 403),  write: ($md_w != 403),  required: false, note: "Phase 3 only" }
  ],
  status: (
    if [
      ($op_r == 403), ($op_w == 403),
      ($lb_r == 403), ($lb_w == 403),
      ($csd_r == 403),
      ($pd_r == 403), ($pd_w == 403)
    ] | any then "FAIL"
    elif ($ns_w == 403 or $hc_w == 403 or $md_w == 403) then "WARN"
    else "PASS"
    end
  ),
  detail: (
    [
      (if ($op_r == 403 or $op_w == 403) then "Origin pool: permission denied" else null end),
      (if ($lb_r == 403 or $lb_w == 403) then "Load balancer: permission denied" else null end),
      (if $csd_r == 403 then "CSD API: permission denied — CSD may not be enabled for this namespace" else null end),
      (if ($pd_r == 403 or $pd_w == 403) then "Protected domain: permission denied" else null end),
      (if $ns_w == 403 then "Namespace: write denied — namespace must already exist (cannot create)" else null end),
      (if $hc_w == 403 then "Healthcheck: write denied — will skip healthcheck creation" else null end),
      (if $md_w == 403 then "Mitigated domain: write denied — Phase 3 mitigation will be skipped" else null end)
    ] | map(select(. != null)) | join("; ")
  )
}'

टिप्पणी

नेमस्पेस + RBAC इंटरैक्शन। यदि PF-T0-2 ने 404 लौटाया (नेमस्पेस मौजूद नहीं है) और PF-T0-4 दिखाता है कि नेमस्पेस राइट अस्वीकृत है, तो डेमो आगे नहीं बढ़ सकता — नेमस्पेस न तो मौजूद है और न ही बनाया जा सकता है। यदि PF-T0-2 ने 200 लौटाया (नेमस्पेस मौजूद है) और नेमस्पेस राइट अस्वीकृत है, तो यह केवल एक चेतावनी है — डेमो पहले से मौजूद नेमस्पेस का उपयोग कर सकता है।

CSD + RBAC। यदि CSD एंडपॉइंट 403 लौटाते हैं, तो CSD सेवा इस नेमस्पेस या टेनेंट के लिए सक्षम नहीं हो सकती (प्लान-आधारित एक्सेस कंट्रोल)। चूंकि CSD प्रदर्शित की जा रही मुख्य सुविधा है, यह हमेशा FAIL है।

T1: कोटा और क्षमता

ये जांचें टेनेंट के Quota Usage API को क्वेरी करती हैं ताकि डेमो के लिए आवश्यक प्रत्येक ऑब्जेक्ट प्रकार की सीमाओं, वर्तमान उपयोग, और शेष क्षमता का निर्धारण किया जा सके। यह प्रोब-एंड-डिलीट परीक्षण को एक एकल रीड-ओनली API कॉल से बदलता है जो सटीक संख्या रिपोर्ट करता है।

PF-T1-0: कोटा उपयोग गेट

टेनेंट-व्यापी कोटा उपयोग एंडपॉइंट को क्वेरी करें और डेमो के लिए आवश्यक प्रत्येक ऑब्जेक्ट प्रकार के लिए एक नियतात्मक PASS/WARN/FAIL स्थिति की गणना करें। इस एंडपॉइंट को system नेमस्पेस की आवश्यकता है। एक एकल API कॉल सभी प्लेटफॉर्म-स्तरीय कोटा की एक साथ जांच करता है।

गेट एक demo_needs एरे परिभाषित करता है जो निर्दिष्ट करता है कि डेमो प्रत्येक ऑब्जेक्ट प्रकार का कितना उपभोग करेगा, क्या वह प्रकार आवश्यक है, और डेमो आगे बढ़ने के लिए न्यूनतम कितने की आवश्यकता है। jq फ़िल्टर remaining की तुलना needed से करता है और status फ़ील्ड की नियतात्मक रूप से गणना करता है — किसी ऑपरेटर व्याख्या की आवश्यकता नहीं है।

# Step 1: Fetch quota data
curl -s \
  -H "Authorization: APIToken xF5XC_API_TOKENx" \
  "xF5XC_API_URLx/api/web/namespaces/system/quota/usage?namespace=system" \
  > /tmp/quota.json

# Step 2: Compute gate status
jq '
  . as $data |
  [
    { kind: "healthcheck",       needed: 1, required: false, min_proceed: 0 },
    { kind: "origin_pool",       needed: 1, required: true,  min_proceed: 1 },
    { kind: "endpoint",          needed: 1, required: true,  min_proceed: 1 },
    { kind: "http_loadbalancer", needed: 2, required: true,  min_proceed: 1 }
  ] | map(
    . as $req |
    $data.objects[$req.kind] as $obj |
    $obj.limit.maximum as $limit |
    $obj.usage.current as $usage |
    (if $limit == -1 then null else ($limit - $usage) end) as $remaining |
    {
      kind:      $req.kind,
      limit:     (if $limit == -1 then "unlimited" else $limit end),
      usage:     $usage,
      remaining: (if $remaining == null then "unlimited" else $remaining end),
      needed:    $req.needed,
      status:    (
        if $remaining == null then "PASS"
        elif $remaining >= $req.needed then "PASS"
        elif $remaining >= $req.min_proceed then "WARN"
        else
          (if $req.required then "FAIL" else "WARN" end)
        end
      )
    }
  )
  | {
      checks: .,
      gate: (if any(.[]; .status == "FAIL") then "FAIL"
             elif any(.[]; .status == "WARN") then "WARN"
             else "PASS" end)
    }
' /tmp/quota.json

गेट आउटपुट — gate फ़ील्ड एकल नियतात्मक निर्णय है:

• PASS — सभी ऑब्जेक्ट प्रकारों में remaining >= needed है। डेमो आगे बढ़ सकता है।
• WARN — कम से कम एक प्रकार की क्षमता कम है लेकिन आगे बढ़ने के लिए न्यूनतम पूरा हो गया है (उदा., 2 के बजाय केवल 1 LB स्लॉट उपलब्ध, या हेल्थचेक कोटा समाप्त)। डेमो सीमाओं के साथ आगे बढ़ सकता है।
• FAIL — कम से कम एक आवश्यक प्रकार में remaining < min_proceed है। कोटा मुक्त होने तक डेमो आगे नहीं बढ़ सकता।

उदाहरण आउटपुट (WARN — endpoint क्षमता पर, healthcheck लगभग पूर्ण):

{
  "checks": [
    { "kind": "healthcheck",       "limit": 150,         "usage": 149, "remaining": 1,           "needed": 1, "status": "PASS" },
    { "kind": "origin_pool",       "limit": "unlimited", "usage": 420, "remaining": "unlimited", "needed": 1, "status": "PASS" },
    { "kind": "endpoint",          "limit": 500,         "usage": 500, "remaining": 0,           "needed": 1, "status": "FAIL" },
    { "kind": "http_loadbalancer", "limit": "unlimited", "usage": 116, "remaining": "unlimited", "needed": 2, "status": "PASS" }
  ],
  "gate": "FAIL"
}

gate मान	कार्रवाई
PASS	PF-T1-4 (प्रोटेक्टेड डोमेन जांच) पर आगे बढ़ें, फिर T2
WARN	तत्परता रिपोर्ट में सीमाओं को नोट करें, कम क्षमता के साथ आगे बढ़ें
FAIL	रुकें — रिपोर्ट करें कि कौन से प्रकार समाप्त हो गए हैं और नीचे दिए गए उपचार कदम

प्रकार के अनुसार उपचार:

प्रकार	उपचार
healthcheck	क्षमता मुक्त करने के लिए अप्रयुक्त हेल्थचेक हटाएं। हेल्थचेक के बिना डेमो आगे बढ़ता है (CSD को इसकी आवश्यकता नहीं है)।
origin_pool	अप्रयुक्त ऑरिजिन पूल हटाएं या टेनेंट सीमा बढ़ाने के लिए अपने व्यवस्थापक से संपर्क करें।
endpoint	endpoint क्षमता मुक्त करने के लिए अन्य नेमस्पेस में अप्रयुक्त ऑरिजिन पूल हटाएं (endpoints ऑरिजिन पूल के उप-ऑब्जेक्ट हैं), या अपने व्यवस्थापक से संपर्क करें।
http_loadbalancer	अप्रयुक्त लोड बैलेंसर हटाएं या अपने व्यवस्थापक से संपर्क करें। यदि केवल 1 स्लॉट उपलब्ध है, तो HTTP LB (प्राथमिक) बनाया जाएगा लेकिन HTTPS LB (द्वितीयक) छोड़ दिया जाएगा।

टिप्पणी

Quota Usage API सभी नेमस्पेस में टेनेंट-व्यापी कुल योग लौटाता है, प्रति-नेमस्पेस गणना नहीं। -1 का limit मान ("unlimited" के रूप में प्रदर्शित) का अर्थ है कि उस ऑब्जेक्ट प्रकार के लिए कोटा सीमित नहीं है। यदि API 403, 404, या अप्रत्याशित प्रारूप लौटाता है, तो नीचे दी गई प्रोब-आधारित जांचों पर वापस जाएं।

PF-T1-4: प्रोटेक्टेड डोमेन कोटा

CSD प्रोटेक्टेड डोमेन प्लेटफॉर्म Quota Usage API में दिखाई नहीं देते। प्रोब-आधारित जांच का उपयोग करें: एक प्रोब प्रोटेक्टेड डोमेन बनाएं और तुरंत हटाएं।

# Create probe and capture both HTTP code and response body
PROBE_BODY=$(curl -s -w '\n%\{http_code\}' -X POST \
  -H "Authorization: APIToken xF5XC_API_TOKENx" \
  -H "Content-Type: application/json" \
  -d '{
    "metadata": {
      "name": "preflight-probe.example.com",
      "namespace": "xF5XC_NAMESPACEx"
    },
    "spec": {
      "protected_domain": "example.com"
    }
  }' \
  "xF5XC_API_URLx/api/shape/csd/namespaces/xF5XC_NAMESPACEx/protected_domains")
PROBE_HTTP=$(echo "$PROBE_BODY" | tail -1)
PROBE_JSON=$(echo "$PROBE_BODY" | sed '$d')

# Compute status
echo "$PROBE_JSON" | jq --argjson http "$PROBE_HTTP" '{
  check: "PF-T1-4",
  http_code: $http,
  status: (
    if $http == 409 then "PASS"
    elif (.code // 0) == 8 then "FAIL"
    elif .metadata.name then "PASS"
    else "FAIL"
    end
  ),
  detail: (
    if $http == 409 then "example.com already registered — quota not exhausted"
    elif (.code // 0) == 8 then "Protected domain quota exhausted — delete unused protected domains"
    elif .metadata.name then "Probe created — quota available"
    else "Unexpected response"
    end
  )
}'

# Cleanup probe (404 is expected if 409 occurred)
curl -s -X DELETE \
  -H "Authorization: APIToken xF5XC_API_TOKENx" \
  "xF5XC_API_URLx/api/shape/csd/namespaces/xF5XC_NAMESPACEx/protected_domains/preflight-probe.example.com" \
  > /dev/null

टिप्पणी

प्रोब RFC 2606 आरक्षित डोमेन example.com का उपयोग करता है। 409 प्रतिक्रिया एक वैध PASS है — इसका अर्थ है कि डोमेन पहले से रजिस्टर है, जो साबित करता है कि कोटा समाप्त नहीं हुआ है। यदि 409 हुआ (प्रोब कभी नहीं बना) तो DELETE 404 लौटा सकता है, जो अपेक्षित है।

फॉलबैक: प्रोब-आधारित कोटा जांचें

यदि PF-T1-0 विफल होता है (Quota Usage API 403, 404, या अप्रत्याशित प्रारूप लौटाता है), तो healthcheck, origin pool, endpoint, और load balancer कोटा के लिए प्रोब-एंड-डिलीट जांचों पर वापस जाएं। ये जांचें एक अस्थायी ऑब्जेक्ट बनाती हैं और तुरंत हटाती हैं — यदि निर्माण त्रुटि कोड 8 के साथ “exhausted limits” लौटाता है, तो कोटा पूर्ण है।

सावधानी

प्रोब-आधारित जांचें टेनेंट पर वास्तविक ऑब्जेक्ट बनाती हैं और उन्हें तुरंत हटाती हैं। यदि विलोपन विफल होता है (उदा., नेटवर्क समस्या), तो बचे हुए प्रोब ऑब्जेक्ट रह सकते हैं। T4 बचे हुए प्रोब क्लीनअप अगले प्री-फ्लाइट रन में उन्हें पहचानेगा और हटाएगा।

प्रत्येक फॉलबैक प्रोब एक ही पैटर्न का उपयोग करता है: एक अस्थायी ऑब्जेक्ट बनाएं, प्रतिक्रिया से नियतात्मक स्थिति की गणना करें, फिर प्रोब हटाएं। status फ़ील्ड PASS है यदि ऑब्जेक्ट बनाया गया (.metadata.name मौजूद), WARN या FAIL यदि त्रुटि कोड 8 (exhausted limits), इस पर निर्भर करता है कि प्रकार आवश्यक है या नहीं।

Healthcheck प्रोब (समाप्त होने पर WARN — healthcheck CSD के लिए वैकल्पिक हैं):

RESULT=$(curl -s -X POST \
  -H "Authorization: APIToken xF5XC_API_TOKENx" \
  -H "Content-Type: application/json" \
  -d '{
    "metadata": {
      "name": "preflight-quota-probe",
      "namespace": "xF5XC_NAMESPACEx"
    },
    "spec": {
      "http_health_check": {
        "use_origin_server_name": {},
        "path": "/",
        "use_http2": false
      },
      "timeout": 3,
      "interval": 15,
      "unhealthy_threshold": 1,
      "healthy_threshold": 3
    }
  }' \
  "xF5XC_API_URLx/api/config/namespaces/xF5XC_NAMESPACEx/healthchecks")
echo "$RESULT" | jq '{
  check: "fallback-healthcheck",
  status: (if .metadata.name then "PASS" elif (.code // 0) == 8 then "WARN" else "FAIL" end),
  detail: (if .metadata.name then "Quota available" elif (.code // 0) == 8 then "Quota full — healthcheck optional, demo proceeds" else "Unexpected: \(.message // "unknown error")" end)
}'
curl -s -X DELETE -H "Authorization: APIToken xF5XC_API_TOKENx" \
  "xF5XC_API_URLx/api/config/namespaces/xF5XC_NAMESPACEx/healthchecks/preflight-quota-probe" \
  > /dev/null

Origin pool और endpoint प्रोब (समाप्त होने पर FAIL — दोनों आवश्यक हैं):

RESULT=$(curl -s -X POST \
  -H "Authorization: APIToken xF5XC_API_TOKENx" \
  -H "Content-Type: application/json" \
  -d '{
    "metadata": {
      "name": "preflight-origin-probe",
      "namespace": "xF5XC_NAMESPACEx"
    },
    "spec": {
      "origin_servers": [{
        "public_ip": { "ip": "192.0.2.1" },
        "labels": {}
      }],
      "no_tls": {},
      "port": 80,
      "same_as_endpoint_port": {},
      "healthcheck": [],
      "loadbalancer_algorithm": "LB_OVERRIDE",
      "endpoint_selection": "LOCAL_PREFERRED"
    }
  }' \
  "xF5XC_API_URLx/api/config/namespaces/xF5XC_NAMESPACEx/origin_pools")
echo "$RESULT" | jq '{
  check: "fallback-origin-pool",
  status: (if .metadata.name then "PASS" elif (.code // 0) == 8 then "FAIL" else "FAIL" end),
  detail: (if .metadata.name then "Quota available" elif (.code // 0) == 8 then "Quota exhausted — \(.message // "limit reached")" else "Unexpected: \(.message // "unknown error")" end)
}'
curl -s -X DELETE -H "Authorization: APIToken xF5XC_API_TOKENx" \
  "xF5XC_API_URLx/api/config/namespaces/xF5XC_NAMESPACEx/origin_pools/preflight-origin-probe" \
  > /dev/null

HTTP load balancer प्रोब (समाप्त होने पर FAIL — LB आवश्यक हैं):

RESULT=$(curl -s -X POST \
  -H "Authorization: APIToken xF5XC_API_TOKENx" \
  -H "Content-Type: application/json" \
  -d '{
    "metadata": {
      "name": "preflight-lb-probe",
      "namespace": "xF5XC_NAMESPACEx",
      "disable": false
    },
    "spec": {
      "domains": ["preflight-probe.example.com"],
      "http": {
        "dns_volterra_managed": false,
        "port": 80
      },
      "advertise_on_public_default_vip": {},
      "default_route_pools": [],
      "disable_rate_limit": {},
      "no_service_policies": {},
      "round_robin": {},
      "disable_waf": {},
      "no_challenge": {},
      "disable_bot_defense": {},
      "disable_api_definition": {},
      "disable_api_discovery": {},
      "disable_ip_reputation": {},
      "disable_malicious_user_detection": {},
      "single_lb_app": {
        "disable_discovery": {},
        "disable_ddos_detection": {},
        "disable_malicious_user_detection": {}
      },
      "disable_trust_client_ip_headers": {},
      "user_id_client_ip": {},
      "disable_threat_mesh": {},
      "l7_ddos_action_default": {},
      "system_default_timeouts": {},
      "default_sensitive_data_policy": {},
      "disable_malware_protection": {},
      "disable_api_testing": {}
    }
  }' \
  "xF5XC_API_URLx/api/config/namespaces/xF5XC_NAMESPACEx/http_loadbalancers")
echo "$RESULT" | jq '{
  check: "fallback-http-lb",
  status: (if .metadata.name then "PASS" elif (.code // 0) == 8 then "FAIL" else "FAIL" end),
  detail: (if .metadata.name then "Quota available" elif (.code // 0) == 8 then "Quota exhausted — \(.message // "limit reached")" else "Unexpected: \(.message // "unknown error")" end)
}'
curl -s -X DELETE -H "Authorization: APIToken xF5XC_API_TOKENx" \
  "xF5XC_API_URLx/api/config/namespaces/xF5XC_NAMESPACEx/http_loadbalancers/preflight-lb-probe" \
  > /dev/null

T2: प्लेटफॉर्म पूर्वापेक्षाएं

ये जांचें टेनेंट-स्तरीय सेवाओं को सत्यापित करती हैं जिन पर डेमो निर्भर है।

PF-T2-1: CSD टेनेंट स्थिति

curl -s \
  -H "Authorization: APIToken xF5XC_API_TOKENx" \
  "xF5XC_API_URLx/api/shape/csd/namespaces/xF5XC_NAMESPACEx/status" \
  | jq '{
    check: "PF-T2-1",
    configured: .isConfigured,
    enabled: .isEnabled,
    status: (if .isConfigured and .isEnabled then "PASS" else "FAIL" end),
    detail: (
      if .isConfigured and .isEnabled then "CSD is active"
      elif (.isConfigured | not) then "CSD not enabled at tenant level — contact F5 XC administrator"
      else "CSD configured but not active — contact administrator"
      end
    )
  }'

PF-T2-2: DNS ज़ोन मौजूद है

HTTP_CODE=$(curl -s -o /dev/null -w '%\{http_code\}' \
  -H "Authorization: APIToken xF5XC_API_TOKENx" \
  "xF5XC_API_URLx/api/config/dns/namespaces/system/dns_zones/xF5XC_ROOT_DOMAINx")
echo "{\"http_code\": $HTTP_CODE}" | jq '{
  check: "PF-T2-2",
  http_code: .http_code,
  status: (
    if .http_code == 200 then "PASS"
    elif .http_code == 404 then "WARN"
    elif .http_code == 403 then "WARN"
    else "FAIL"
    end
  ),
  detail: (
    if .http_code == 200 then "DNS zone exists in F5 XC"
    elif .http_code == 404 then "No F5 XC DNS zone — external DNS may be in use"
    elif .http_code == 403 then "Token lacks DNS zone read access (system namespace)"
    else "Unexpected HTTP \(.http_code)"
    end
  )
}'

PF-T2-3: DNS प्रबंधित रिकॉर्ड सक्षम

केवल तभी चलाएं जब PF-T2-2 ने 200 लौटाया हो (F5 XC DNS ज़ोन मौजूद है)।

वर्तमान स्थिति जांचें:

curl -s \
  -H "Authorization: APIToken xF5XC_API_TOKENx" \
  "xF5XC_API_URLx/api/config/dns/namespaces/system/dns_zones/xF5XC_ROOT_DOMAINx" \
  | jq '{
    check: "PF-T2-3",
    managed_records: (.spec.primary.allow_http_lb_managed_records // false),
    status: (if .spec.primary.allow_http_lb_managed_records == true then "PASS" else "WARN" end),
    detail: (if .spec.primary.allow_http_lb_managed_records == true then "LB-managed DNS records enabled" else "Managed records not enabled — auto-remediation may be needed" end)
  }'

आवश्यकता होने पर स्वतः-उपचार: यदि status WARN है और PF-T2-4 F5 XC नेमसर्वर (ns1.f5clouddns.com, ns2.f5clouddns.com) दिखाता है, तो GET+PUT का उपयोग करके प्रबंधित रिकॉर्ड स्वतः-सक्षम करें:

# Get current zone config
ZONE_CONFIG=$(curl -s \
  -H "Authorization: APIToken xF5XC_API_TOKENx" \
  "xF5XC_API_URLx/api/config/dns/namespaces/system/dns_zones/xF5XC_ROOT_DOMAINx")

# Update with managed records enabled
echo "$ZONE_CONFIG" \
  | jq '.spec.primary.allow_http_lb_managed_records = true' \
  | curl -s -X PUT \
    -H "Authorization: APIToken xF5XC_API_TOKENx" \
    -H "Content-Type: application/json" \
    -d @- \
    "xF5XC_API_URLx/api/config/dns/namespaces/system/dns_zones/xF5XC_ROOT_DOMAINx" \
  | jq .

फिर अपडेट प्रभावी होने की पुष्टि करने के लिए पुनः जांचें:

curl -s \
  -H "Authorization: APIToken xF5XC_API_TOKENx" \
  "xF5XC_API_URLx/api/config/dns/namespaces/system/dns_zones/xF5XC_ROOT_DOMAINx" \
  | jq '.spec.primary.allow_http_lb_managed_records'

सावधानी

ज़ोन spec में एक x-ves-io-managed rr_set_group होता है जिसमें प्लेटफॉर्म-प्रबंधित रिकॉर्ड होते हैं। PUT पेलोड को इस समूह को संरक्षित करना चाहिए — इसे हटाने से HTTP 403 “reserved for internal purposes” त्रुटि होती है। हमेशा पहले GET के साथ वर्तमान ज़ोन कॉन्फ़िगरेशन प्राप्त करें, केवल allow_http_lb_managed_records फ़ील्ड को संशोधित करें, और पूर्ण spec वापस भेजें।

परिणाम	DNS प्राधिकरण	स्थिति	उपचार
true	कोई भी	PASS	LB-प्रबंधित DNS रिकॉर्ड स्वतः बनाए जाएंगे
false/null	F5 XC	स्वतः-उपचार	GET+PUT के माध्यम से सक्षम करें, सत्यापित करें, परिणाम रिपोर्ट करें
false/null	बाहरी	INFO	बाहरी DNS के लिए प्रबंधित रिकॉर्ड लागू नहीं — चरण 1 स्टेप 4 विकल्प B (मैनुअल रिकॉर्ड निर्माण) का उपयोग करेगा
स्वतः-उपचार विफल	F5 XC	FAIL	टोकन में system नेमस्पेस राइट एक्सेस नहीं हो सकता — टेनेंट व्यवस्थापक से संपर्क करें

PF-T2-4: DNS नेमसर्वर प्राधिकरण

NS_RECORDS=$(dig +short NS xF5XC_ROOT_DOMAINx)
echo "$NS_RECORDS" | jq -Rs '{
  check: "PF-T2-4",
  nameservers: (split("\n") | map(select(length > 0))),
  status: (
    if (split("\n") | map(select(length > 0)) | length) == 0 then "FAIL"
    elif test("f5clouddns\\.com") then "PASS"
    else "INFO"
    end
  ),
  detail: (
    if (split("\n") | map(select(length > 0)) | length) == 0 then "No NS records — DNS is broken for this domain"
    elif test("f5clouddns\\.com") then "F5 XC is authoritative — automatic DNS management available"
    else "External DNS provider — Phase 1 Step 4 will use Option B (manual record creation)"
    end
  )
}'

T3: ऑरिजिन स्वास्थ्य

ये जांचें सत्यापित करती हैं कि बैकेंड एप्लिकेशन पहुंच योग्य है।

RFC 5737 TEST-NET पते

IP श्रेणियां 192.0.2.0/24 (TEST-NET-1), 198.51.100.0/24 (TEST-NET-2), और 203.0.113.0/24 (TEST-NET-3) RFC 5737 द्वारा दस्तावेज़ीकरण और उदाहरणों में उपयोग के लिए आरक्षित हैं। ये सार्वजनिक इंटरनेट पर रूटेबल नहीं हैं और कनेक्टिविटी परीक्षणों का कभी उत्तर नहीं देंगे। जब F5XC_ORIGIN_IP इनमें से किसी श्रेणी के पते पर सेट है, तो यह एक जानबूझकर किया गया दस्तावेज़ीकरण प्लेसहोल्डर है — गलत कॉन्फ़िगरेशन नहीं।

स्किप कंडीशन जांच: कनेक्टिविटी परीक्षण चलाने से पहले गणना करें कि ऑरिजिन IP एक RFC 5737 TEST-NET पता है या नहीं:

echo "xF5XC_ORIGIN_IPx" | jq -Rs '{
  check: "PF-T3-skip",
  origin_ip: (rtrimstr("\n")),
  is_test_net: (rtrimstr("\n") | test("^192\\.0\\.2\\.|^198\\.51\\.100\\.|^203\\.0\\.113\\.")),
  status: (if (rtrimstr("\n") | test("^192\\.0\\.2\\.|^198\\.51\\.100\\.|^203\\.0\\.113\\.")) then "SKIP" else "CONTINUE" end),
  detail: (if (rtrimstr("\n") | test("^192\\.0\\.2\\.|^198\\.51\\.100\\.|^203\\.0\\.113\\.")) then "RFC 5737 TEST-NET address — not routable, connectivity testing skipped" else "Routable IP — proceed with connectivity tests" end)
}'

यदि status SKIP है, तो PF-T3-1 और PF-T3-2 को SKIP के रूप में रिकॉर्ड करें और T4 पर जाएं। अन्यथा, नीचे दी गई जांचें चलाएं।

PF-T3-1: ऑरिजिन सर्वर कनेक्टिविटी

HTTP_CODE=$(curl -s -o /dev/null -w '%\{http_code\}' --connect-timeout 10 --max-time 15 \
  "http://xF5XC_ORIGIN_IPx:xF5XC_ORIGIN_PORTx/")
echo "{\"http_code\": $HTTP_CODE}" | jq '{
  check: "PF-T3-1",
  http_code: .http_code,
  status: (if .http_code >= 200 and .http_code < 600 then "PASS" elif .http_code == 0 then "WARN" else "WARN" end),
  detail: (
    if .http_code >= 200 and .http_code < 600 then "Origin responding with HTTP \(.http_code)"
    elif .http_code == 0 then "Origin unreachable from this network — LB may use a different path"
    else "Unexpected response code \(.http_code)"
    end
  )
}'

टिप्पणी

CSD डेमो के लिए डिफ़ॉल्ट ऑरिजिन 44.232.69.192:3000 पर Juice Shop एप्लिकेशन है। यदि आप कस्टम ऑरिजिन (F5XC_ORIGIN_IP / F5XC_ORIGIN_PORT) का उपयोग कर रहे हैं, तो सत्यापित करें कि यह फॉर्म फ़ील्ड वाला HTML पेज प्रदान करता है — CSD को डिटेक्शन क्षमताओं का प्रदर्शन करने के लिए फॉर्म तत्वों की आवश्यकता है।

PF-T3-2: ऑरिजिन HTML सामग्री प्रदान करता है

केवल तभी चलाएं जब PF-T3-1 ने एक वैध HTTP स्थिति लौटाई हो:

curl -s --max-time 10 "http://xF5XC_ORIGIN_IPx:xF5XC_ORIGIN_PORTx/" \
  | grep -qi '</html>' && echo "PASS: HTML content" || echo "WARN: No HTML detected"

परिणाम	स्थिति	उपचार
PASS: HTML content	PASS	ऑरिजिन HTML पेज प्रदान करता है (CSD JS इंजेक्शन के लिए आवश्यक)
WARN: No HTML detected	WARN	ऑरिजिन केवल-API सेवा हो सकता है या गैर-HTML लौटा रहा है — CSD JS इंजेक्शन के लिए HTML पेज प्रतिक्रियाओं की आवश्यकता है

T4: वातावरण साफ

ये जांचें सत्यापित करती हैं कि पिछले डेमो रन से कोई नामित F5 XC कॉन्फ़िगरेशन ऑब्जेक्ट नहीं बचे हैं — HTTP लोड बैलेंसर, HTTPS लोड बैलेंसर, ऑरिजिन पूल, हेल्थचेक, प्रोटेक्टेड डोमेन, और मिटिगेटेड डोमेन। T4 ऑब्जेक्ट-स्तरीय क्लीनअप के बारे में है: क्या API ऑब्जेक्ट जो चरण 1 निर्माण के साथ टकराव करेंगे अभी भी मौजूद हैं। यह IP पतों, नेटवर्क कनेक्टिविटी, या ऑरिजिन स्वास्थ्य का परीक्षण नहीं करता (वे चिंताएं T3 से संबंधित हैं)।

टिप्पणी

जब नेमस्पेस मौजूद नहीं है तो T4 छोड़ें। यदि PF-T0-2 ने 404 लौटाया (नेमस्पेस मौजूद नहीं है), तो T4 वातावरण जांच पूरी तरह से छोड़ें और स्थिति CLEAN के रूप में रिपोर्ट करें। एक गैर-मौजूद नेमस्पेस में बचे हुए ऑब्जेक्ट नहीं हो सकते। किसी भी ऑब्जेक्ट बनाने से पहले चरण 1 स्टेप 0 नेमस्पेस बनाएगा।

ऊपर प्री-फ्लाइट जांच अनुभाग से छह प्री-फ्लाइट कमांड चलाएं। अगले कदम निर्धारित करने के लिए निर्णय तर्क लागू करें। यदि ऑब्जेक्ट मौजूद हैं, तो तैयारी चरण के दौरान स्वतः-टियरडाउन किया जाता है (पुष्टि की आवश्यकता नहीं)।

पिछले बाधित प्री-फ्लाइट रन से बचे हुए प्रोब ऑब्जेक्ट्स की भी जांच करें और हटाएं। ये प्रोब केवल तब बनाए जाते हैं जब Quota Usage API अनुपलब्ध हो और फॉलबैक प्रोब-आधारित जांचों का उपयोग किया गया हो, या प्रोटेक्टेड डोमेन प्रोब (PF-T1-4) के लिए जो हमेशा प्रोब-आधारित जांच का उपयोग करता है:

# Stale probe cleanup (delete in any order — probes have no dependencies)
curl -s -X DELETE -H "Authorization: APIToken xF5XC_API_TOKENx" \
  "xF5XC_API_URLx/api/config/namespaces/xF5XC_NAMESPACEx/healthchecks/preflight-quota-probe" \
  > /dev/null

curl -s -X DELETE -H "Authorization: APIToken xF5XC_API_TOKENx" \
  "xF5XC_API_URLx/api/config/namespaces/xF5XC_NAMESPACEx/http_loadbalancers/preflight-lb-probe" \
  > /dev/null

curl -s -X DELETE -H "Authorization: APIToken xF5XC_API_TOKENx" \
  "xF5XC_API_URLx/api/config/namespaces/xF5XC_NAMESPACEx/origin_pools/preflight-origin-probe" \
  > /dev/null

curl -s -X DELETE -H "Authorization: APIToken xF5XC_API_TOKENx" \
  "xF5XC_API_URLx/api/shape/csd/namespaces/xF5XC_NAMESPACEx/protected_domains/preflight-probe.example.com" \
  > /dev/null

प्रत्येक DELETE 200 (खाली {}) लौटाता है यदि ऑब्जेक्ट मौजूद था, या 404 यदि नहीं था — दोनों अपेक्षित हैं।

T5: प्रमाणपत्र तत्परता

ये जांचें आकलन करती हैं कि HTTPS काम करेगा या डेमो को केवल-HTTP की योजना बनानी चाहिए।

PF-T5-1: हालिया प्रमाणपत्र जारी करने का इतिहास

जांचें कि डेमो डोमेन के लिए हाल ही में Let’s Encrypt प्रमाणपत्र जारी किया गया था या नहीं। बार-बार बनाने/नष्ट करने के चक्र साप्ताहिक दर सीमा (प्रति डोमेन प्रति सप्ताह 5 डुप्लिकेट प्रमाणपत्र) को समाप्त कर सकते हैं।

टिप्पणी

Let’s Encrypt दर सीमा स्थिति को सीधे क्वेरी करने के लिए कोई API नहीं है। यह जांच प्रॉक्सी के रूप में HTTPS LB cert state का उपयोग करती है। यदि अभी तक कोई HTTPS LB मौजूद नहीं है (साफ वातावरण), तो यह जांच छोड़ दी जाती है — हालिया डेमो आवृत्ति के आधार पर जोखिम सूचनात्मक के रूप में नोट किया जाता है।

PF-T5-2: मौजूदा HTTPS LB प्रमाणपत्र स्थिति

केवल तभी चलाएं जब पिछले रन से HTTPS LB मौजूद हो (PF-T4 ने ऑब्जेक्ट पाए):

CERT_BODY=$(curl -s -w '\n%\{http_code\}' \
  -H "Authorization: APIToken xF5XC_API_TOKENx" \
  "xF5XC_API_URLx/api/config/namespaces/xF5XC_NAMESPACEx/http_loadbalancers/xF5XC_LB_NAMEx-https")
CERT_HTTP=$(echo "$CERT_BODY" | tail -1)
CERT_JSON=$(echo "$CERT_BODY" | sed '$d')

if [ "$CERT_HTTP" = "404" ]; then
  echo '{"check":"PF-T5-2","cert_state":null,"status":"SKIP","detail":"No HTTPS LB — certificate state assessed after Phase 1 Step 3"}'
else
  echo "$CERT_JSON" | jq '{
    check: "PF-T5-2",
    cert_state: .spec.cert_state,
    status: (
      if .spec.cert_state == "CertificateValid" then "PASS"
      elif .spec.cert_state == "AutoCertDomainRateLimited" then "INFO"
      elif (.spec.cert_state | test("Pending|Started")) then "INFO"
      else "INFO"
      end
    ),
    detail: (
      if .spec.cert_state == "CertificateValid" then "Certificate healthy — HTTPS will work"
      elif .spec.cert_state == "AutoCertDomainRateLimited" then "Let'\''s Encrypt rate limit hit — plan for HTTP-only demo"
      elif (.spec.cert_state | test("Pending|Started")) then "Certificate provisioning in progress"
      else "Certificate state: \(.spec.cert_state // "unknown")"
      end
    )
  }'
fi

तत्परता रिपोर्ट प्रारूप

सभी टियर चलाने के बाद, एक समेकित तत्परता रिपोर्ट प्रस्तुत करें:

## डेमो तत्परता: तैयार / तैयार नहीं / चेतावनियों के साथ तैयार

### T0: कनेक्टिविटी और प्रमाणीकरण
| जांच | परिणाम | स्थिति |
|---|---|---|
| PF-T0-1: API कनेक्टिविटी | 200 | PASS |
| PF-T0-2: नेमस्पेस एक्सेस | 200 | PASS |
| PF-T0-3: CSD API एक्सेस | 200 | PASS |

### T1: कोटा और क्षमता
| जांच | प्रकार | सीमा | उपयोग | शेष | आवश्यक | स्थिति |
|---|---|---|---|---|---|---|
| PF-T1-0: कोटा उपयोग गेट | `healthcheck` | 150 | 148 | 2 | 1 | PASS |
| PF-T1-0: कोटा उपयोग गेट | `origin_pool` | unlimited | 420 | unlimited | 1 | PASS |
| PF-T1-0: कोटा उपयोग गेट | `endpoint` | 500 | 498 | 2 | 1 | PASS |
| PF-T1-0: कोटा उपयोग गेट | `http_loadbalancer` | unlimited | 116 | unlimited | 2 | PASS |
| PF-T1-0: कोटा उपयोग गेट | **gate** | — | — | — | — | **PASS** |
| PF-T1-4: प्रोटेक्टेड डोमेन | — | — | — | — | 1 | PASS (probe) |

### T2: प्लेटफॉर्म पूर्वापेक्षाएं
| जांच | परिणाम | स्थिति |
|---|---|---|
| PF-T2-1: CSD टेनेंट स्थिति | configured + enabled | PASS |
| PF-T2-2: DNS ज़ोन मौजूद है | 200 | PASS |
| PF-T2-3: DNS प्रबंधित रिकॉर्ड | true | PASS |
| PF-T2-4: DNS नेमसर्वर प्राधिकरण | f5clouddns.com | PASS |

### T3: ऑरिजिन स्वास्थ्य
| जांच | परिणाम | स्थिति |
|---|---|---|
| PF-T3-1: ऑरिजिन कनेक्टिविटी | TEST-NET पता (192.0.2.1) | SKIP |
| PF-T3-2: HTML सामग्री | TEST-NET पता | SKIP |

### T4: वातावरण साफ
| जांच | परिणाम | स्थिति |
|---|---|---|
| HTTP LB | 404 | PASS |
| HTTPS LB | 404 | PASS |
| Origin Pool | 404 | PASS |
| Healthcheck | 404 | PASS |
| Protected Domains | 0 | PASS |
| Mitigated Domains | 0 | PASS |

### T5: प्रमाणपत्र तत्परता
| जांच | परिणाम | स्थिति |
|---|---|---|
| PF-T5-2: प्रमाणपत्र स्थिति | SKIP (कोई HTTPS LB नहीं) | INFO |

### चेतावनियां
- (संदर्भ के साथ कोई भी WARN या INFO आइटम सूचीबद्ध करें)

समग्र स्थिति नियम:

शर्त	स्थिति
सभी T0–T4 जांचें PASS	तैयार
सभी T0–T4 जांचें PASS लेकिन T3 या T5 में WARN/INFO है	चेतावनियों के साथ तैयार
कोई भी T0, T1, या T2 जांच FAIL है	तैयार नहीं — आगे बढ़ने से पहले हल करें
T4 में बचे हुए ऑब्जेक्ट हैं	स्वतः-उपचार (टियरडाउन), फिर पुनः जांचें

AI सहायक निष्पादन प्रोटोकॉल

यह अनुभाग API ऑटोमेशन स्टेप्स निष्पादित करने वाले AI सहायकों (Claude Code, Copilot, आदि) के लिए एक नियतात्मक वर्कफ़्लो परिभाषित करता है। इस प्रोटोकॉल का पालन करने से अनुमान समाप्त हो जाता है — हर निर्णय बिंदु का एक परिभाषित समाधान पथ है।

वेरिएबल रिज़ॉल्यूशन प्रोटोकॉल

प्रत्येक वेरिएबल को इस सटीक क्रम में हल करें। पहले स्रोत पर रुकें जो गैर-प्लेसहोल्डर मान प्रदान करता है:

1. .env फाइल जांचें — रिपॉज़िटरी रूट में .env खोजें। यदि यह मौजूद है, तो सभी KEY=VALUE जोड़ियां पार्स करें।
2. शेल एनवायरनमेंट जांचें — वर्तमान सत्र में निर्यातित किसी भी मान को खोजने के लिए env | grep F5XC_ चलाएं।
3. अनुपलब्ध मान पहचानें — नीचे दी गई आवश्यक/वैकल्पिक तालिका के विरुद्ध हल किए गए मानों की तुलना करें। एक मान “अनुपलब्ध” है यदि यह अनुपस्थित है, खाली है, या अभी भी प्लेसहोल्डर डिफ़ॉल्ट पर सेट है (उदा., example-api-token, example-tenant, example-namespace, app.example.com, user@example.com)।
4. मानव ऑपरेटर से पूछें — प्रत्येक अनुपलब्ध आवश्यक वेरिएबल के लिए, ऑपरेटर से मान प्रदान करने के लिए कहें। जब तक सभी आवश्यक वेरिएबल हल नहीं हो जाते, आगे न बढ़ें।
5. डिफ़ॉल्ट लागू करें — प्रत्येक अनुपलब्ध वैकल्पिक वेरिएबल के लिए, बिना पूछे नीचे दी गई तालिका से डिफ़ॉल्ट का उपयोग करें।

खाली स्ट्रिंग = अनुपलब्ध: खाली मान के साथ निर्यातित वेरिएबल (उदा., F5XC_HC_NAME="") को अनसेट वेरिएबल के समान माना जाता है — डिफ़ॉल्ट लागू करें। एक चरण में डिफ़ॉल्ट लागू करने के लिए शेल पैरामीटर एक्सपैंशन (${F5XC_HC_NAME:-csd-hc}) का उपयोग करें।

6. पुष्टि प्रदर्शित करें — ऑपरेटर को अंतिम हल किए गए वेरिएबल तालिका दिखाएं और किसी भी API कॉल निष्पादित करने से पहले अनुमोदन की प्रतीक्षा करें।

तैयारी चरण ओवरराइड: स्टेज 1 तैयारी के दौरान, चरण 6 में प्रतीक्षा छोड़ें। रिकॉर्ड के लिए हल किए गए वेरिएबल तालिका प्रदर्शित करें, फिर तुरंत आगे बढ़ें। चरण 1–5 अभी भी लागू होते हैं — यदि .env और शेल जांचने के बाद कोई आवश्यक वेरिएबल अनुपलब्ध है, तो रुकें और अनुपलब्ध वेरिएबल रिपोर्ट करें।

आवश्यक बनाम वैकल्पिक वेरिएबल

वेरिएबल	आवश्यक	डिफ़ॉल्ट	प्लेसहोल्डर (अनुपलब्ध मानें)
F5XC_API_TOKEN	हां	—	example-api-token
F5XC_API_URL	हां	—	https://example-tenant.console.ves.volterra.io
F5XC_NAMESPACE	हां	—	example-namespace
F5XC_DOMAINNAME	हां	—	app.example.com
F5XC_ROOT_DOMAIN	हां	—	example.com
F5XC_LB_NAME	हां	—	example-lb-name, example-lb
F5XC_EMAIL	हां	—	user@example.com
F5XC_HC_NAME	वैकल्पिक	csd-hc	—
F5XC_ORIGIN_IP	वैकल्पिक	44.232.69.192	—
F5XC_ORIGIN_POOL	वैकल्पिक	csd-origin	—
F5XC_ORIGIN_PORT	वैकल्पिक	3000	—

निष्पादन मोड

AI सहायक डेमो के दौरान तीन मोड में से एक में कार्य करता है:

मोड	कब सक्रिय	व्यवहार
सामान्य	तैयारी, निष्पादन, टियरडाउन के दौरान डिफ़ॉल्ट	केवल प्रलेखित यथावत कमांड
डीबग	विफलता पर स्वतः-सक्रिय	रचनात्मक समस्या निवारण, दस्तावेज़ अपडेट
प्रश्नोत्तर	प्रश्नोत्तर चरण के दौरान	सुधारात्मक — दर्शकों के प्रश्नों का उत्तर देने के लिए तदर्थ कमांड की अनुमति

सामान्य मोड (डिफ़ॉल्ट):

• हर API कॉल, सत्यापन क्वेरी, और शेल कमांड चरण फाइलों (चरण 1–4) या ऊपर दिए गए प्री-फ्लाइट जांच अनुभाग से यथावत आना चाहिए
• केवल xTOKENx प्लेसहोल्डर को हल किए गए वेरिएबल मानों से बदलें
• सामान्य ज्ञान या अनुमान से API एंडपॉइंट, jq फ़िल्टर, या cURL कमांड न बनाएं
• यदि कोई आवश्यक कमांड प्रलेखित नहीं है, तो रुकें और ऑपरेटर को रिपोर्ट करें: “यह सत्यापन कदम चरण दस्तावेज़ीकरण द्वारा कवर नहीं है”

डीबग मोड (विफलता पर स्वतः-सक्रिय):

• जब कोई प्रलेखित कमांड अप्रत्याशित परिणाम उत्पन्न करता है तो स्वचालित रूप से सक्रिय होता है: गैर-2xx HTTP प्रतिक्रिया, jq पार्स त्रुटि, कमांड टाइमआउट, या प्रतिक्रिया बॉडी जो साक्ष्य तालिका का खंडन करती है
• डीबग मोड में, AI सहायक डायग्नोस्टिक कमांड बना सकता है, कच्ची API प्रतिक्रियाओं का निरीक्षण कर सकता है, एंडपॉइंट भिन्नताओं का परीक्षण कर सकता है, और मूल कारण खोजने के लिए रचनात्मक समस्या निवारण का उपयोग कर सकता है
• सभी डीबग आउटपुट को [DEBUG] के साथ उपसर्ग करें ताकि ऑपरेटर डायग्नोस्टिक गतिविधि को सामान्य निष्पादन से अलग कर सके
• जो सीखें उसे दस्तावेज़ित करें: किसी समस्या को हल करने के बाद, संबंधित चरण फाइल या समस्या निवारण अनुभाग को अपडेट करें:
  1. विफलता परिदृश्य (क्या गलत हुआ)
  2. क्या प्रयास किया गया और काम नहीं किया (ताकि भविष्य के रन इसे दोहराएं नहीं)
  3. कार्यशील समाधान (वह कमांड या फिक्स जिसने इसे हल किया)
• डीबग मोड का लक्ष्य स्वयं को समाप्त करना है — प्रत्येक डीबग सत्र को एक दस्तावेज़ अपडेट उत्पन्न करना चाहिए जो अगले निष्पादन को पूरी तरह नियतात्मक बनाए
• दस्तावेज़ अपडेट होने और समस्या हल होने के बाद, सामान्य मोड पर लौटें और अंतिम सफल प्रलेखित कदम से पुनः शुरू करें
• यदि डीबग मोड समस्या हल नहीं कर सकता, तो ऑपरेटर को निष्कर्ष रिपोर्ट करें और रुकें — अगले चरण पर न जाएं

प्रश्नोत्तर मोड (प्रश्नोत्तर चरण के दौरान):

• केवल प्रश्नोत्तर मीटिंग चरण के दौरान सक्रिय, डेमो निष्कर्ष के बाद
• AI सहायक तदर्थ API कॉल बना सकता है, डायग्नोस्टिक कमांड चला सकता है, अस्क्रिप्टेड पृष्ठों पर नेविगेट कर सकता है, और दर्शकों के प्रश्नों का उत्तर देने के लिए लाइव डेमो वातावरण को संशोधित कर सकता है
• कोई [DEBUG] उपसर्ग नहीं — यह जानबूझकर सुधारात्मक व्यवहार है, त्रुटि पुनर्प्राप्ति नहीं
• उत्पाद प्रश्नों के लिए ज्ञान आधार के रूप में DEMO_EXECUTOR.md में CSD उत्पाद विशेषज्ञता अनुभाग का उपयोग करता है

ब्राउज़र संदर्भ प्रबंधन

initScript संचय डेमो विफलताओं का एक सामान्य स्रोत है। initScript पैरामीटर के साथ प्रत्येक navigate_page कॉल स्क्रिप्ट को एक स्थायी सूची में जोड़ती है जो प्रत्येक बाद के दस्तावेज़ लोड पर चलती है। इन नियमों का पालन करें:

• पिछले रन से संचित स्क्रिप्ट को साफ करने के लिए initScript के साथ किसी भी नेविगेशन से पहले हमेशा about:blank पर नेविगेट करें
• डेमो चरणों (उदा., चरण 2 → चरण 3) के बीच स्विच करते समय पूरी तरह साफ ब्राउज़र स्थिति सुनिश्चित करने के लिए isolatedContext के साथ new_page का उपयोग करें
• अनुत्तरदायी पृष्ठों से पुनर्प्राप्ति — यदि take_screenshot या take_snapshot टाइमआउट होते हैं, तो ब्राउज़र संदर्भ संसाधन-समाप्त है। एक ताज़ा संदर्भ बनाने के लिए isolatedContext के साथ new_page का उपयोग करें, फिर about:blank नेविगेशन कदम से पुनः प्रयास करें
• क्षणिक ऑरिजिन विफलताओं और संसाधन समाप्ति पुनर्प्राप्ति पर विस्तृत मार्गदर्शन के लिए चरण 2 अटैक सिमुलेशन एसाइड देखें

साक्ष्य प्रदर्शन प्रोटोकॉल

प्रत्येक API कॉल के बाद, AI सहायक को इस प्रारूप का उपयोग करके मानव ऑपरेटर को संरचित साक्ष्य प्रस्तुत करना चाहिए:

निर्माण कदम (POST):

फ़ील्ड	मान	स्थिति
HTTP स्थिति	200	PASS
ऑब्जेक्ट नाम	csd-origin	—
मुख्य गुण	(jq के माध्यम से निकाला गया)	—

प्रत्येक निर्माण कदम के बाद, ऑब्जेक्ट की उपस्थिति की पुष्टि करने के लिए GET चलाएं और इसके मुख्य गुण प्रदर्शित करें। यदि GET 404 लौटाता है, तो FAIL रिपोर्ट करें और रुकें।

सत्यापन कदम (GET/dig):

परीक्षण	परिणाम	स्थिति
DNS-1: A रिकॉर्ड	198.51.100.10	PASS
LB-1: HTTP LB स्थिति	VIRTUAL_HOST_READY	PASS
LB-2: HTTPS LB स्थिति	VIRTUAL_HOST_READY	INFO (वैकल्पिक)
TLS-1: प्रमाणपत्र स्थिति	CertificateValid	INFO (वैकल्पिक)
CSD-1: JS टैग	scriptTag मौजूद	PASS

प्रत्येक परत के सत्यापन मानक के रूप में डायग्नोस्टिक्स और सत्यापन टेस्ट केस ID (DNS-1, TLS-1, LB-1, CSD-1, आदि) का संदर्भ लें।

निष्पादन प्रवाह सारांश

चरण निष्पादन अनुक्रमिक और गेटेड है: अगले चरण के शुरू होने से पहले प्रत्येक चरण को सभी आवश्यक जांचों पर PASS प्राप्त करना चाहिए। डेमो चार-चरणीय मीटिंग जीवनचक्र का अनुसरण करता है — ट्रिगर वाक्यांशों और व्यवहार नियमों के लिए DEMO_EXECUTOR.md में मीटिंग स्टेज अनुभाग देखें।

AI सहायक इस अनुक्रम का पालन करता है:

1. तैयारी — वेरिएबल हल करें, प्री-फ्लाइट जांचें चलाएं, साफ वातावरण की पुष्टि करें (मीटिंग से पहले अलग से चलाया जा सकता है)
2. परिचय — SE अपना परिचय देता है और परिणाम लक्ष्य बताता है (क्लाइंट-साइड खतरों में दृश्यता, PCI अनुपालन, रियल-टाइम डिटेक्शन)
3. चरण 1 निष्पादित करें (स्टेप्स 1–7) — इन्फ्रास्ट्रक्चर निर्माण और सत्यापन; आगे बढ़ने से पहले सभी चरण 1 जांचें PASS होनी चाहिए
4. चरण 2 निष्पादित करें (स्टेप्स 8–9) — ब्राउज़र में http:// URL का उपयोग करके अटैक सिमुलेशन, 5–10 मिनट प्रतीक्षा करें, API (/scripts, /detected_domains, /formFields) के माध्यम से डिटेक्शन सत्यापित करें; ब्राउज़र ऑटोमेशन वाले AI सहायक सीधे ब्राउज़र स्टेप्स निष्पादित करते हैं, ब्राउज़र टूल के बिना ऑपरेटर उन्हें मैन्युअल रूप से करते हैं
5. चरण 3 निष्पादित करें — सभी पहचाने गए डोमेन के लिए मिटिगेशन की पुष्टि करें, अटैक चलाएं (पहले का प्रमाण), प्रत्येक डोमेन को /mitigated_domains पर POST करें, मिटिगेशन लागू होने की पुष्टि करें, http:// URL का उपयोग करके अटैक पुनः चलाएं (बाद का प्रमाण), पहले/बाद की तुलना प्रस्तुत करें
6. निष्कर्ष — परिणाम लक्ष्यों को पुनः बताएं, प्रत्येक चरण से साक्ष्य सारांशित करें, प्रमुख डिटेक्शन और मिटिगेशन को हाइलाइट करें
7. प्रश्नोत्तर — सुधारात्मक चरण, डेमो लाइव रहता है, SE दर्शकों के प्रश्नों का उत्तर देता है और वापसी प्रश्न पूछता है
8. टियरडाउन (मीटिंग के बाद) — चरण 4, स्पष्ट ऑपरेटर पुष्टि आवश्यक, उल्टे निर्भरता क्रम में सभी ऑब्जेक्ट हटाएं, साफ वातावरण की पुष्टि करें

यदि कोई कदम FAIL लौटाता है, तो जारी रखने से पहले संबंधित समस्या निवारण अनुभाग लिंक के साथ विफलता रिपोर्ट करें और रुकें।

पूर्वापेक्षाएं

• एक F5 XC API टोकन — Administration → Credentials → API Credentials के अंतर्गत एक जनरेट करें
• स्थानीय रूप से curl और jq इंस्टॉल
• healthcheck, origin pool, और HTTP load balancer बनाने की अनुमतियों वाला एक नेमस्पेस

वातावरण सेटअप

अपने वातावरण मानों के साथ एक .env फाइल बनाएं। रिपॉज़िटरी में एक टेम्पलेट प्रदान किया गया है:

cp .env.example .env

.env को अपने वास्तविक मानों से संपादित करें:

.env

# Required — your environment
F5XC_API_TOKEN=example-api-token
F5XC_API_URL=https://example-tenant.console.ves.volterra.io
F5XC_DOMAINNAME=app.example.com
F5XC_EMAIL=user@example.com
F5XC_LB_NAME=example-lb-name
F5XC_NAMESPACE=example-namespace
F5XC_ROOT_DOMAIN=example.com

# Optional — Juice Shop demo defaults are used when not set
# F5XC_HC_NAME=csd-hc
# F5XC_ORIGIN_IP=44.232.69.192
# F5XC_ORIGIN_POOL=csd-origin
# F5XC_ORIGIN_PORT=3000

सावधानी

.env फाइल में आपका API टोकन होता है। यह .gitignore में सूचीबद्ध है और इसे कभी भी संस्करण नियंत्रण में कमिट नहीं किया जाना चाहिए।

अपने शेल सत्र में वेरिएबल लोड करने के लिए फाइल को सोर्स करें:

set -a && source .env && set +a

संकेत

यदि आपके API टोकन में / या = अक्षर हैं, तो शेल व्याख्या समस्याओं से बचने के लिए .env में मान को सिंगल कोट्स में रखें (उदा., F5XC_API_TOKEN='abc/def=')।

कुछ कंटेनर रनटाइम और सीक्रेट मैनेजर एनवायरनमेंट वेरिएबल मानों में शाब्दिक उद्धरण अक्षर इंजेक्ट करते हैं। यदि वैध टोकन के बावजूद API कॉल 401 Unauthorized लौटाते हैं, तो उपयोग से पहले भटके हुए उद्धरण हटाएं:

export F5XC_API_TOKEN=$(echo "$F5XC_API_TOKEN" | tr -d "'")

curl कमांड में प्रत्येक xTOKENx प्लेसहोल्डर सीधे एक एनवायरनमेंट वेरिएबल से मैप होता है — उदाहरण के लिए, xF5XC_API_TOKENx $F5XC_API_TOKEN से मेल खाता है। आप पृष्ठ के शीर्ष पर इंटरैक्टिव फॉर्म का उपयोग करके इन मानों को बदल सकते हैं, या Claude Code जैसे AI सहायक को अपनी .env पढ़ने और आपके लिए कमांड बनाने दे सकते हैं।

प्लेसहोल्डर टोकन

टोकन	डिफ़ॉल्ट	विवरण
xF5XC_API_URLx	https://example-tenant.console.ves.volterra.io	XC कंसोल API URL
xF5XC_API_TOKENx	example-api-token	API क्रेडेंशियल टोकन
xF5XC_EMAILx	user@example.com	CSD अधिसूचना ईमेल पता
xF5XC_NAMESPACEx	example-namespace	नेमस्पेस
xF5XC_LB_NAMEx	example-lb	HTTP लोड बैलेंसर बेस नाम (${name}-http और ${name}-https बनाता है)
xF5XC_DOMAINNAMEx	app.example.com	सुरक्षित करने के लिए FQDN
xF5XC_ROOT_DOMAINx	example.com	CSD प्रोटेक्टेड डोमेन के लिए रूट डोमेन (eTLD+1)
xF5XC_ORIGIN_POOLx	csd-origin	ऑरिजिन पूल नाम
xF5XC_ORIGIN_IPx	44.232.69.192	ऑरिजिन सर्वर IP
xF5XC_ORIGIN_PORTx	3000	ऑरिजिन सर्वर पोर्ट
xF5XC_HC_NAMEx	csd-hc	हेल्थचेक नाम

संकेत

टेनेंट स्वचालित है: टेनेंट पहचानकर्ता आपके API URL से व्युत्पन्न होता है (उदा., https://f5-amer-ent.console.ves.volterra.io से f5-amer-ent)। आपको इसे प्रदान करने की आवश्यकता नहीं है — ऑब्जेक्ट बनाते समय प्लेटफॉर्म स्वचालित रूप से टेनेंट संदर्भ भरता है।

ऑटोमेशन संदर्भ

यह अनुभाग स्क्रिप्टिंग या ऑटोमेशन के लिए पूर्ण अभ्यास वर्कफ़्लो को सारांशित करता है।

त्वरित प्रारंभ

1. रिपॉज़िटरी क्लोन करें और वातावरण टेम्पलेट कॉपी करें: cp .env.example .env
2. .env को अपने टेनेंट URL, API टोकन, नेमस्पेस, और डोमेन मानों से संपादित करें
3. वातावरण सोर्स करें: set -a && source .env && set +a
4. प्रत्येक चरण को क्रम में निष्पादित करें, अगले चरण पर जाने से पहले प्रत्येक साक्ष्य ब्लॉक पर PASS सत्यापित करें

वेरिएबल रिज़ॉल्यूशन

AI सहायक निष्पादन प्रोटोकॉल में परिभाषित नियतात्मक प्रोटोकॉल का उपयोग करके मान हल किए जाते हैं:

1. .env फाइल — रिपॉज़िटरी रूट से KEY=VALUE जोड़ियां पार्स करें
2. शेल एनवायरनमेंट — निर्यातित मानों के लिए env | grep F5XC_ जांचें
3. प्लेसहोल्डर पहचान — प्लेसहोल्डर डिफ़ॉल्ट (उदा., example-api-token, example-namespace) से मेल खाने वाले किसी भी मान को अनुपलब्ध के रूप में चिह्नित करें
4. ऑपरेटर से पूछें — प्रत्येक अनुपलब्ध आवश्यक वेरिएबल के लिए पूछें
5. डिफ़ॉल्ट लागू करें — अनुपलब्ध वैकल्पिक वेरिएबल के लिए अंतर्निहित डिफ़ॉल्ट का उपयोग करें
6. पुष्टि — हल किए गए वेरिएबल तालिका प्रदर्शित करें और ऑपरेटर अनुमोदन की प्रतीक्षा करें

निष्पादन क्रम

1. चरण 1 — बिल्ड: इन्फ्रास्ट्रक्चर डिप्लॉय करें (healthcheck, origin pool, HTTP LB + HTTPS LB), DNS कॉन्फ़िगर करें, CSD सक्षम करें, protected domain रजिस्टर करें, सभी घटकों को सत्यापित करें। HTTP LB प्राथमिक डेमो लक्ष्य है; HTTPS LB वैकल्पिक है।
2. चरण 2 — अटैक: http:// URL का उपयोग करके ब्राउज़र में अटैक सिमुलेशन चलाएं, 5–10 मिनट प्रतीक्षा करें, API (/scripts, /detected_domains, /formFields) के माध्यम से डिटेक्शन सत्यापित करें
3. चरण 3 — मिटिगेट: साफ बेसलाइन की पुष्टि करें, अटैक चलाएं (पहले का प्रमाण), प्रत्येक डोमेन को /mitigated_domains पर POST करें, मिटिगेशन लागू होने की पुष्टि करें, http:// URL का उपयोग करके अटैक पुनः चलाएं (बाद का प्रमाण), पहले/बाद की तुलना प्रस्तुत करें
4. चरण 4 — टियरडाउन (स्पष्ट मानव पुष्टि आवश्यक): HTTPS LB हटाएं → HTTP LB → origin pool → DNS ज़ोन क्लीनअप (केवल मैनुअल रिकॉर्ड) → healthcheck → protected domain। DNS ज़ोन न हटाएं।

वेरिएबल

टोकन	विवरण	डिफ़ॉल्ट
xF5XC_API_URLx	XC कंसोल API URL	https://example-tenant.console.ves.volterra.io
xF5XC_API_TOKENx	API क्रेडेंशियल टोकन	(उपयोगकर्ता-प्रदत्त)
xF5XC_EMAILx	CSD अधिसूचना ईमेल	user@example.com
xF5XC_NAMESPACEx	नेमस्पेस	example-namespace
xF5XC_LB_NAMEx	HTTP लोड बैलेंसर बेस नाम (${name}-http और ${name}-https बनाता है)	example-lb
xF5XC_DOMAINNAMEx	सुरक्षित करने के लिए FQDN	app.example.com
xF5XC_ROOT_DOMAINx	रूट डोमेन (eTLD+1)	example.com
xF5XC_ORIGIN_POOLx	ऑरिजिन पूल नाम	csd-origin
xF5XC_ORIGIN_IPx	ऑरिजिन सर्वर IP	44.232.69.192
xF5XC_ORIGIN_PORTx	ऑरिजिन सर्वर पोर्ट	3000
xF5XC_HC_NAMEx	हेल्थचेक नाम	csd-hc

oneOf चयन समूह

HTTP लोड बैलेंसर spec oneOf चयन समूहों का उपयोग करता है जहां प्रति समूह ठीक एक विकल्प सेट होना चाहिए। एक समूह में शून्य या एक से अधिक विकल्प सेट करने से 422 त्रुटि होती है।

प्रमुख CSD-संबंधित चयन:

चयन समूह	विकल्प	CSD डिफ़ॉल्ट
client_side_defense_choice	client_side_defense, disable_client_side_defense	client_side_defense
java_script_choice (CSD में नेस्टेड)	disable_js_insert, js_insert_all_pages, js_insert_all_pages_except, js_insertion_rules	js_insert_all_pages

लिसनर प्रकार चयन (HTTP बनाम HTTPS):

डेमो विभिन्न लिसनर कॉन्फ़िगरेशन के साथ दो LB बनाता है:

LB	लिसनर चयन	कॉन्फ़िग
${F5XC_LB_NAME}-http (प्राथमिक)	http	"http": { "dns_volterra_managed": true, "port": 80 }
${F5XC_LB_NAME}-https (द्वितीयक)	https_auto_cert	"https_auto_cert": { "http_redirect": true, "port": 443, ... }

http और https_auto_cert कुंजियां परस्पर अनन्य हैं — प्रत्येक LB ठीक एक का उपयोग करता है।

HTTPS auto-cert नेस्टेड चयन (केवल द्वितीयक LB):

चयन समूह	विकल्प	डिफ़ॉल्ट
port	port (संख्या)	443
server_header_choice	default_header, server_name, append_server_name	default_header
path_normalize_choice	enable_path_normalize, disable_path_normalize	enable_path_normalize
mtls_choice	no_mtls, use_mtls	no_mtls
default_loadbalancer_choice	default_loadbalancer, non_default_loadbalancer	default_loadbalancer

single_lb_app नेस्टेड चयन (ML कॉन्फ़िग):

single_lb_app ऑब्जेक्ट के अपने आवश्यक oneOf समूह हैं। इन नेस्टेड चयनों के बिना single_lb_app: \{\} सेट करने से 400 त्रुटि होती है।

चयन समूह	विकल्प	डिफ़ॉल्ट
api_discovery_choice	disable_discovery, enable_discovery	disable_discovery
ddos_detection_choice	disable_ddos_detection, enable_ddos_detection	disable_ddos_detection
malicious_user_detection_choice	disable_malicious_user_detection, enable_malicious_user_detection	disable_malicious_user_detection

अन्य LB-स्तरीय चयन (सभी disable/default पर सेट):

disable_rate_limit · no_service_policies · round_robin · disable_waf · no_challenge · disable_bot_defense · disable_api_definition · disable_api_discovery · disable_ip_reputation · disable_malicious_user_detection · single_lb_app · disable_trust_client_ip_headers · user_id_client_ip · disable_threat_mesh · l7_ddos_action_default · system_default_timeouts · default_sensitive_data_policy · disable_malware_protection · disable_api_testing

त्रुटि प्रबंधन

• 401 Unauthorized — API टोकन अमान्य या समाप्त है। Administration → Credentials के अंतर्गत पुनः जनरेट करें।
• 403 Forbidden — टोकन में नेमस्पेस के लिए अनुमतियां नहीं हैं। रोल बाइंडिंग जांचें।
• 404 Not Found — नेमस्पेस या ऑब्जेक्ट नाम गलत है। GET /api/config/namespaces/\{namespace\}/\{object_type\} के साथ ऑब्जेक्ट सूचीबद्ध करें।
• 409 Conflict — ऑब्जेक्ट पहले से मौजूद है। प्रोटेक्टेड डोमेन के लिए, “domain already exists (in uriList)” के साथ 409 का अर्थ है कि रूट डोमेन पहले से टेनेंट पर रजिस्टर है — यह सफलता की स्थिति है, त्रुटि नहीं। अन्य ऑब्जेक्ट्स के लिए, पहले हटाएं या अपडेट करने के लिए PUT का उपयोग करें।
• 422 Unprocessable Entity — JSON स्कीमा सत्यापन विफल। सामान्य कारण: अनुपलब्ध oneOf चयन, एक ही समूह में कई चयन सेट, गलत फ़ील्ड प्रकार। विशिष्ट फ़ील्ड के लिए त्रुटि संदेश जांचें।
• ऑब्जेक्ट सीमा समाप्त (त्रुटि कोड 8, संदेश "Object kind {kind} has exhausted limits({N})") — टेनेंट ने ऑब्जेक्ट कोटा सीमा तक पहुंच गया है। API "code": 8 युक्त JSON त्रुटि बॉडी के साथ HTTP 200 लौटाता है, HTTP 429 नहीं। इस त्रुटि का सामना करने से पहले आप Quota Usage API (GET /api/web/namespaces/system/quota/usage?namespace=system) का उपयोग करके सक्रिय रूप से कोटा क्षमता जांच सकते हैं। व्यवहार ऑब्जेक्ट प्रकार पर निर्भर करता है:
  • Healthcheck (सीमा ~150): गैर-अवरोधक — चरण 1 स्टेप 1 छोड़ें और healthcheck संदर्भ के बिना origin pool बनाएं। CSD स्वास्थ्य निगरानी पर निर्भर नहीं है।
  • Endpoint (सीमा ~500): अवरोधक — endpoints origin pool के अंदर बनाए गए उप-ऑब्जेक्ट हैं। यदि यह सीमा समाप्त हो जाती है, तो origin pool निर्माण विफल होता है। अप्रयुक्त origin pool हटाएं (जो उनके endpoint उप-ऑब्जेक्ट मुक्त करता है) या टेनेंट सीमा बढ़ाने के लिए अपने व्यवस्थापक से संपर्क करें।
  • Origin pool: अवरोधक — अप्रयुक्त origin pool हटाएं या अपने व्यवस्थापक से संपर्क करें।
  • HTTP load balancer: अवरोधक — अप्रयुक्त load balancer हटाएं या अपने व्यवस्थापक से संपर्क करें।
  • Protected domain: अवरोधक — अप्रयुक्त protected domain हटाएं या अपने व्यवस्थापक से संपर्क करें।

समस्या निवारण

Healthcheck ऑरिजिन पूल से लिंक नहीं है

यदि चरण 1 स्टेप 2 (Healthcheck लिंक होने की पुष्टि) एक खाली एरे [] दिखाता है:

1. origin pool हटाएं: DELETE /api/config/namespaces/{namespace}/origin_pools/{pool_name}
2. healthcheck मौजूद होने की पुष्टि करें: GET /api/config/namespaces/{namespace}/healthchecks/{hc_name}
3. सही healthcheck संदर्भ के साथ origin pool पुनः बनाएं

LB VIRTUAL_HOST_PENDING_A_RECORD में अटका हुआ है

यदि चरण 1 स्टेप 4 के बाद load balancer state VIRTUAL_HOST_PENDING_A_RECORD पर बना रहता है:

1. DNS ज़ोन मौजूद होने की पुष्टि करें (केवल F5 XC प्रबंधित DNS):

   curl -s \
     -H "Authorization: APIToken xF5XC_API_TOKENx" \
     "xF5XC_API_URLx/api/config/dns/namespaces/system/dns_zones/xF5XC_ROOT_DOMAINx" \
     | jq '.metadata.name'

   404 का अर्थ है कि DNS ज़ोन F5 XC में नहीं बनाया गया है।

2. allow_http_lb_managed_records जांचें — यदि ज़ोन मौजूद है लेकिन LB पेंडिंग है, तो प्रबंधित रिकॉर्ड अक्षम हो सकते हैं:

   curl -s \
     -H "Authorization: APIToken xF5XC_API_TOKENx" \
     "xF5XC_API_URLx/api/config/dns/namespaces/system/dns_zones/xF5XC_ROOT_DOMAINx" \
     | jq '.spec.primary.allow_http_lb_managed_records'

   यदि false या null है, तो इसे चरण 1 स्टेप 4, विकल्प A में PUT कमांड का उपयोग करके सक्षम करें।

3. बाहरी DNS — यदि F5 XC प्राधिकृत नहीं है, तो अपने DNS प्रदाता पर मैन्युअल रूप से A और ACME CNAME रिकॉर्ड बनाएं (देखें चरण 1 स्टेप 4, विकल्प B)।

4. रिज़ॉल्यूशन सत्यापित करें — DNS ठीक करने के बाद, पुष्टि करें:

   dig +short xF5XC_DOMAINNAMEx A

   यदि A रिकॉर्ड रिज़ॉल्व होता है, तो LB VIRTUAL_HOST_READY में संक्रमित होता है। हर 30 सेकंड पर पोल करें, 4 पुनरावृत्तियों तक (कुल 2 मिनट)। यदि 2 मिनट के बाद भी VIRTUAL_HOST_PENDING_A_RECORD है, तो DNS प्रसार पुनः जांचें और ऑपरेटर को रिपोर्ट करें।

CSD स्थिति isConfigured: false दिखाती है

CSD को टेनेंट स्तर पर सक्षम किया जाना चाहिए। अपने टेनेंट के लिए Client-Side Defense सक्षम करने के लिए अपने F5 XC व्यवस्थापक से संपर्क करें। यह एक टेनेंट-व्यापी सेटिंग है जिसे API के माध्यम से कॉन्फ़िगर नहीं किया जा सकता।

JS इंजेक्शन काम नहीं कर रहा

1. सत्यापित करें कि CSD टेनेंट स्तर पर सक्षम है (चरण 1 स्टेप 5)
2. पुष्टि करें कि load balancer के spec में client_side_defense सेट है
3. जांचें कि JS कॉन्फ़िगरेशन एंडपॉइंट scriptTag लौटाता है
4. प्रोटेक्टेड डोमेन को ब्राउज़र में विज़िट करें और पेज सोर्स देखें ताकि पुष्टि हो कि स्क्रिप्ट इंजेक्ट की गई है

प्रोटेक्टेड डोमेन रजिस्ट्रेशन 409 लौटाता है

“domain already exists (in uriList)” के साथ 409 का अर्थ है कि रूट डोमेन पहले से टेनेंट पर रजिस्टर है। प्रोटेक्टेड डोमेन टेनेंट-स्कोप्ड हैं — वे किसी एकल नेमस्पेस से संबंधित नहीं हैं। यह एक सफलता की स्थिति है: डोमेन पहले से सुरक्षित है और आगे कोई कार्रवाई आवश्यक नहीं है। चरण 1 स्टेप 7 पर जाएं।

AutoCertDomainRateLimited

यदि HTTPS LB cert_state AutoCertDomainRateLimited दिखाता है, तो इसका अर्थ है कि Let’s Encrypt ने इस डोमेन के लिए प्रमाणपत्र जारी करने को दर-सीमित कर दिया है। यह डेमो वातावरणों में अपेक्षित है जहां इन्फ्रास्ट्रक्चर बार-बार बनाया और नष्ट किया जाता है।

प्रभाव: HTTPS LB दर सीमा रीसेट होने तक ट्रैफिक प्रदान नहीं करेगा (आमतौर पर 1 घंटा)। HTTP LB पूरी तरह अप्रभावित है — सभी डेमो ट्रैफिक http:// पर सामान्य रूप से आगे बढ़ता है।

समाधान: डेमो प्रगति के लिए किसी कार्रवाई की आवश्यकता नहीं है। HTTP LB (${F5XC_LB_NAME}-http) प्राथमिक डेमो लक्ष्य है और प्रमाणपत्र प्रावधान पर निर्भर नहीं है। यदि HTTPS वांछित है, तो दर सीमा रीसेट होने तक प्रतीक्षा करें और प्रमाणपत्र स्वतः-प्रावधान हो जाएगा।

प्रमाणपत्र अटका — साफ पुनर्निर्माण (वैकल्पिक)

टिप्पणी

यह समस्या निवारण कदम केवल HTTPS LB (${F5XC_LB_NAME}-https) पर लागू होता है और डेमो प्रगति के लिए वैकल्पिक है। HTTP LB की प्रमाणपत्र निर्भरता नहीं है।

जब HTTPS LB प्रमाणपत्र 15 मिनट से अधिक समय तक DomainChallengePending या PreDomainChallengePending में अटका है, तो सबसे तेज़ पुनर्प्राप्ति पथ HTTPS LB को हटाना और पुनः बनाना है। DNS ज़ोन पहले से कॉन्फ़िगर होने के साथ (प्रबंधित रिकॉर्ड सक्षम), साफ पुनर्निर्माण आमतौर पर 5–7 मिनट में CertificateValid उत्पन्न करता है — जब तक कि दर-सीमित न हो।

1. HTTPS लोड बैलेंसर हटाएं: DELETE .../http_loadbalancers/${F5XC_LB_NAME}-https
2. प्लेटफॉर्म क्लीनअप के लिए 30 सेकंड प्रतीक्षा करें
3. HTTPS लोड बैलेंसर पुनः बनाएं (चरण 1 स्टेप 3)
4. प्रमाणपत्र स्थिति मॉनिटर करें (चरण 1 स्टेप 7) — 5–10 मिनट के भीतर CertificateValid की अपेक्षा करें

संकेत

आपको DNS ज़ोन पुनः कॉन्फ़िगर करने, protected domain पुनः रजिस्टर करने, या HTTP LB को छूने की आवश्यकता नहीं है। ये स्थायी संसाधन हैं जो HTTPS LB पुनर्निर्माण से अप्रभावित हैं।

OpenAPI संदर्भ

कैनोनिकल F5 Distributed Cloud API स्पेसिफिकेशन यहां उपलब्ध है:

https://docs.cloud.f5.com/docs-v2/downloads/f5-distributed-cloud-open-api.zip

इस ZIP में ves.io.schema.views.http_loadbalancer, ves.io.schema.healthcheck, ves.io.schema.origin_pool, और ves.io.schema.shape.csd सहित सभी API समूहों के लिए OpenAPI 3.0 specs हैं। JSON पेलोड को मान्य करने और अतिरिक्त फ़ील्ड खोजने के लिए इन specs का उपयोग करें।