# FlashData वर्कलोड को परिनियोजित करें

अपने ऐप या एजेंट के CLI कार्यों को Linux या Docker पर चलाएं, फिर एक पुनरारंभ के बाद एक्सेस और परिणाम का पुन: उपयोग सत्यापित करें।

कैनोनिकल संदर्भ: https://flashdata.dev/hi/docs/guides/production-deployment
समीक्षित: 2026-11-05 द्वारा FlashData

<a id="prepare"></a>

## 1. रनटाइम चुनें

Bash और jq के साथ एक Linux होस्ट का उपयोग करें और google_search अनुमति के साथ एक मालिक API कुंजी का उपयोग करें। OS उपयोगकर्ता के रूप में सेटअप करें जो कार्य को निष्पादित करेगा। चरणों 1–4 के लिए इस निजी कार्य फ़ोल्डर को बनाएं; फ़ाइल लेबल किसी भी सबफ़ोल्डर्स को दिखाते हैं।

### कार्य फ़ोल्डर बनाएँ

```bash
umask 077
mkdir -p "$HOME/flashdata-tasks/deployment-check"
cd "$HOME/flashdata-tasks/deployment-check"
```

### Linux सर्वर

पहले मूल CLI स्थापित करें। अपने पूर्ण पथ को खोजने के लिए कमांड-वी फ्लैशडाटा चलाएं, फिर FLASHDATA_BIN को runtime.sh में उस पथ पर सेट करें। एक बार यहां प्रोफ़ाइल नाम और लगातार स्टेट पथ सेट करें, फिर फ़ाइल को सहेज लें।

#### runtime.sh

```bash
# runtime.sh — edit the executable and persistent state paths.
export FLASHDATA_BIN=/usr/local/bin/flashdata
export FLASHDATA_PROFILE=research
export FLASHDATA_STATE_DIR="$HOME/.local/state/flashdata-research"

run_flashdata() {
  env -u FLASHDATA_API_KEY "$FLASHDATA_BIN" "$@" \
    --profile "$FLASHDATA_PROFILE" \
    --state-dir "$FLASHDATA_STATE_DIR"
}
```


### Docker

एक Linux Docker होस्ट पर curl, टार और sha256sum के साथ, मेजबान CPU के लिए pinned CLI डाउनलोड करें। नीचे image/Dockerfile और image/.dockerignore को सहेजें, छवि का निर्माण, फिर runtime.sh को बचाओ। सहायक अपने UID/GID के रूप में चलता है और प्रत्येक नए कंटेनर में राज्य और कार्य फ़ोल्डरों को माउंट करता है।

#### Linux CLI को डाउनलोड और सत्यापित करें

```bash
(
  set -euo pipefail
  case "$(uname -m)" in
    x86_64) arch=amd64 ;;
    aarch64|arm64) arch=arm64 ;;
    *) echo 'Use a Linux amd64 or arm64 host.' >&2; exit 1 ;;
  esac
  mkdir -p image
  cd image
  archive="flashdata_1.2.1_linux_$arch.tar.gz"
  base='https://github.com/flashdatadev/flashdata-cli/releases/download/v1.2.1'
  curl --fail --show-error --location "$base/$archive" -o "$archive"
  curl --fail --show-error --location "$base/SHA256SUMS" -o SHA256SUMS
  awk -v file="$archive" '$2 == file { print }' SHA256SUMS | sha256sum -c -
  tar -xzf "$archive" flashdata
)
```

#### image/Dockerfile

```dockerfile
FROM debian:bookworm-slim
RUN apt-get update \
    && apt-get install -y --no-install-recommends ca-certificates \
    && rm -rf /var/lib/apt/lists/*
COPY --chmod=0755 flashdata /usr/local/bin/flashdata
USER 10001:10001
ENTRYPOINT ["/usr/local/bin/flashdata"]
```

#### image/.dockerignore

```text
*
!Dockerfile
!flashdata
```

#### स्थानीय छवि बनाएं · कोई क्रेडेंशियल की जरूरत नहीं है

```bash
docker build --tag flashdata-runtime:1.2.1 ./image
docker run --rm flashdata-runtime:1.2.1 --version
```

#### runtime.sh

```bash
# runtime.sh — use the local image built above.
export FLASHDATA_IMAGE='flashdata-runtime:1.2.1'
export FLASHDATA_PROFILE=research
export FLASHDATA_STATE_DIR="$HOME/.local/state/flashdata-research"

run_flashdata() {
  docker run --rm -i --user "$(id -u):$(id -g)" \
    --env FLASHDATA_API_KEY= \
    --mount "type=bind,src=$FLASHDATA_STATE_DIR,dst=/state" \
    --mount "type=bind,src=$PWD,dst=/work" --workdir /work \
    --entrypoint /usr/local/bin/flashdata "$FLASHDATA_IMAGE" \
    "$@" --profile "$FLASHDATA_PROFILE" --state-dir /state
}
```

- [CLI रिलीज 1.2.1](https://github.com/flashdatadev/flashdata-cli/releases/tag/v1.2.1)
- [Docker बाइंडिंग माउंट](https://docs.docker.com/engine/storage/bind-mounts/)

- [देशी CLI स्थापित करें](https://flashdata.dev/hi/docs/guides/flashdata-cli/reference.md#install)
- [मालिक कुंजी और अनुमतियां](https://flashdata.dev/hi/docs/guides/api-keys-and-permissions/reference.md)

<a id="runtime-check"></a>

### चयनित रनटाइम की जाँच करें

कार्य फ़ोल्डर से भागो। run_flashdata runtime.sh में बचाया सहायक है; बाद में सभी आदेश अपनी प्रोफ़ाइल और राज्य निर्देशिका का उपयोग करते हैं। यह FLASHDATA_API_KEY को अनदेखा करता है ताकि एक पर्यावरण कुंजी बचाया प्रोफ़ाइल को प्रतिस्थापित नहीं कर सके। CLI और jq संस्करण का अन्वेषण करें।

#### लगातार राज्य तैयार करना · कोई API क्वेरी नहीं

```bash
set -euo pipefail
umask 077
. ./runtime.sh
mkdir -p "$FLASHDATA_STATE_DIR"
chmod 700 "$FLASHDATA_STATE_DIR"
run_flashdata --version
jq --version
```


<a id="secrets"></a>

## 2. एक बार मालिक पहुँच स्थापित करें

यदि प्रोफ़ाइल पहले से ही मालिक पहुँच है, तो आयात को छोड़ दें और नीचे की जाँच करें। अन्यथा, सेवा उपयोगकर्ता द्वारा पढ़ने योग्य मालिक कुंजी गुप्त फ़ाइल को माउंट करें और इसके स्थान के साथ उदाहरण पथ को प्रतिस्थापित करें। आयात ने इसे stdin के माध्यम से पढ़ा; Docker इसे छवि में कॉपी नहीं करता है।

### तैनात गुप्त फ़ाइल को इंगित करें

```bash
export FLASHDATA_KEY_FILE='/run/secrets/flashdata_api_key'
```

### चयनित रनटाइम में आयात और सत्यापित करें

```bash
set -euo pipefail
. ./runtime.sh
: "${FLASHDATA_KEY_FILE:?Set the path to your mounted owner-key secret}"
run_flashdata auth login --api-key-stdin --non-interactive \
  < "$FLASHDATA_KEY_FILE"
run_flashdata auth status --json --non-interactive
```

- [पुनरावर्ती उपयोग से पहले एक परीक्षण का दावा करें](https://flashdata.dev/hi/docs/guides/agent-onboarding/reference.md#claim)

<a id="access-check"></a>

### खाता और अनुमति की पुष्टि करें

चेक प्रिंट करता है खाता ID, अनुमति स्रोतों और क्रेडेंशियल प्रोटेक्शन, फिर true. खाते की पुष्टि करें ID जारी रखने से पहले इरादा मालिक है। access.json निरीक्षण के लिए कार्य फ़ोल्डर में रहता है।

#### सहेजा गया मालिक पहुँच · मुफ्त चेक

```bash
set -euo pipefail
umask 077
. ./runtime.sh
run_flashdata auth status --json --non-interactive > access.json
jq '{accountId: .data.identity.identity.accountId,
     sources: .data.identity.permittedSources,
     credentialProtection: .data.credentialProtection}' access.json
jq -e '.ok and .data.accessVerified
  and (.data.identity.identity.recurringAllowed == true)
  and (.data.identity.permittedSources | index("google_search") != null)' access.json
```


<a id="protection"></a>

### क्रेडेंशियल स्टोरेज और लगातार फ़ाइलों

auth status में data.credentialProtection का निरीक्षण करें। Linux एक खुला गुप्त सेवा का उपयोग कर सकते हैं; एक हेडलेस होस्ट या ऊपर के कंटेनर एक मालिक-केवल सादेटेक्स्ट फ़ाइल का उपयोग कर सकते हैं। राज्य निर्देशिका निजी और लगातार रखें। अपने लैपटॉप के एन्क्रिप्टेड प्रोफाइल से अलग से तैनात उपयोगकर्ता को प्रोविजन करें।

| रखना | स्थान |
| --- | --- |
| क्रेडेंशियल और रन जर्नल | FLASHDATA_STATE_DIR |
| इनपुट, रसीद और परिणाम | कार्य फ़ोल्डर; Docker में /work के रूप में माउंट किया गया। |

- [प्रावधान और चलती पहुँच](https://flashdata.dev/hi/docs/guides/agent-access/reference.md)

<a id="operate"></a>

## 3. अनुरोध और लागत को मान्य करें

request.json को runtime.sh के बगल में सहेजें। निम्नलिखित चेक आवर्ती पहुंच और अनुरोध को मान्य करता है, वर्तमान मूल्य निर्धारण को पढ़ता है और इसे उपलब्ध शेष राशि के साथ तुलना करता है। यह कोई खोज नहीं जमा करता है और क्रेडिट को आरक्षित नहीं करता है। जब फ़िल्टर true को प्रिंट करता है तो जारी रखें।

### request.json

```json
{
  "source": "google_search",
  "query": "battery recycling research",
  "params": {
    "num": 5
  }
}
```

### पहले भुगतान कार्य से पहले चेक करें

```bash
set -euo pipefail
umask 077
. ./runtime.sh
run_flashdata account balance --json --non-interactive > balance.json
run_flashdata query --input request.json --mode realtime --dry-run --recurring \
  --run-id deployment-first-task --json --non-interactive > preflight.json
jq -e --slurpfile balance balance.json '
  .ok and .data.dryRun and .data.estimateAvailable
  and ($balance[0].ok == true)
  and any(.data.estimate.prices[]?;
    .source == "google_search" and .available == true
    and (.estimatedCredits | type == "number")
    and ($balance[0].data.availableCredits | type == "number")
    and .estimatedCredits <= $balance[0].data.availableCredits)
' preflight.json
```


<a id="restart-check"></a>

## 4. एक बार रन करें और पुनः उपयोग करें सत्यापित करें

नीचे deployment-check.sh सहेजें। एक नई तैनाती-पहली-टास्क रन ID के साथ, पहला निष्पादन एक भुगतान खोज प्रस्तुत करता है; दूसरा एक नई प्रक्रिया शुरू करता है और सहेजे गए परिणाम को पढ़ता है। यदि यह ID पहले से ही उसी प्रोफ़ाइल में पूरा हो गया है, तो दोनों ने इसका पुन: उपयोग करने का प्रयास किया।


<a id="check-script"></a>

### बचाओ deployment-check.sh

मेजबान पर निजी कार्य फ़ोल्डर में deployment-check.sh और request.json के बगल में runtime.sh बनाया गया है। नीचे दिए गए संपूर्ण स्क्रिप्ट को कॉपी करें और इसे सहेजें।

#### deployment-check.sh

```bash
#!/usr/bin/env bash
set -euo pipefail
umask 077
cd -- "$(dirname -- "$0")"
. ./runtime.sh
attempt=$(mktemp -d ./deployment-check.XXXXXX)
printf 'Attempt files: %s\n' "$attempt" >&2
cp -- request.json "$attempt/request.json"
if ! run_flashdata query --input "$attempt/request.json" --mode realtime --recurring \
  --run-id deployment-first-task --timeout 2m --json --non-interactive \
  --output "$attempt/result.json" \
  > "$attempt/receipt.json" 2> "$attempt/error.json"; then
  cat "$attempt/error.json" >&2
  exit 1
fi
jq -e '.ok == true' "$attempt/receipt.json" >/dev/null
jq -e '.source == "google_search" and .status == "done"
  and (.results[0].organic | type == "array")' "$attempt/result.json" >/dev/null
jq '{runId, cached, usage}' "$attempt/receipt.json"
printf 'Saved result: %s\n' "$attempt/result.json"
```


<a id="run-check"></a>

### सेव्ड चेक दो बार चलाएं

उसी सेवा उपयोगकर्ता के रूप में उस होस्ट टास्क फ़ोल्डर से चलाएं। दोनों प्रक्रियाएं runtime.sh को चरण 1 में बचाया लोड करती हैं।

#### रन, फिर प्रक्रिया को फिर से शुरू करें

```bash
# A new run ID submits one paid search; a completed ID reuses its result.
bash deployment-check.sh

# New process; Docker uses a new container with the same mounts.
# Same account, input and state: cached: true, no new search.
bash deployment-check.sh
```


<a id="restart-result"></a>

### दूसरी रसीद सत्यापित करें

एक नए रन के लिए, cached: false की उम्मीद है, फिर cached: true। प्रत्येक प्रयास अपने deployment-check.XXXXXX फ़ोल्डर को प्रिंट करता है और request.json, receipt.json और error.json, प्लस result.json को सफलता पर बचाता है। कैश्ड रसीद मूल उपयोग की रिपोर्ट करती है। एक असफल प्रयास वसूली के लिए अपनी फ़ाइलों को रखता है।

#### दूसरा रसीद · अंश

```json
{
  "ok": true,
  "runId": "deployment-first-task",
  "cached": true
}
```

- [एक बाधित रन को पुनर्प्राप्त करें](https://flashdata.dev/hi/docs/guides/agent-recovery/reference.md)

<a id="read-result"></a>

### सहेजे गए खोज परिणाम पढ़ें

ऊपर मुद्रित दूसरे सफल फ़ोल्डर में ATTEMPT_DIR सेट करें, उदाहरण के लिए ATTEMPT_DIR='./deployment-check.ABC123 निर्यात करें। इन कमांडों ने केवल स्थानीय फ़ाइलों को पढ़ा।

#### रसीद और स्रोत लिंक

```bash
# Use one attempt folder printed by deployment-check.sh.
: "${ATTEMPT_DIR:?Set a saved deployment-check.XXXXXX folder}"
jq '{runId, cached, usage}' "$ATTEMPT_DIR/receipt.json"
jq '.results[0].organic[] | {title, link, snippet}' "$ATTEMPT_DIR/result.json"
```


<a id="schedule"></a>

### एक परिनियोजन की जांच से एक आवर्ती कार्य की जांच करें

इस जाँच में एक निश्चित रन ID है। आवर्ती कार्य के लिए, प्रत्येक उद्देश्य को अपनी खुद की ID घटना दें और चयनित रनटाइम, खाता, इनपुट स्नैपशॉट और स्टेट माउंट को बनाए रखें। run_flashdata का उपयोग करने के लिए आवर्ती धावक के क्वेरी कमांड को अनुकूलित करें ताकि Docker कार्य कंटेनर के अंदर रहें।

- [Recurring IDs, रसीदें और शेड्यूलिंग](https://flashdata.dev/hi/docs/guides/recurring-tasks/reference.md)

<a id="ci"></a>

## GitHub कार्रवाई से पहुंच की जाँच करें

Bash, jq और CLI प्रोफाइल के साथ पहले से ही धावक के OS उपयोगकर्ता के तहत स्थापित एक विश्वसनीय, लगातार Linux धावक का उपयोग करें। इस कार्यप्रवाह को अपने आवेदन के भंडार में सहेजें। यह एक भुगतान कार्य को चलाने के बिना मेजबान CLI की जाँच करता है।

1. उस धावक को फ़्लैशडाटा-अनुसंधान लेबल सौंपना।
2. सेटअप चर FLASHDATA_BIN और FLASHDATA_STATE_DIR को अपने पूर्ण पथों में सेट करें, और स्थापित प्रोफ़ाइल नाम के लिए FLASHDATA_PROFILE।

### .github/workflows/flashdata-check.yml

```yaml
name: FlashData access check
on: workflow_dispatch
permissions: {}
concurrency:
  group: flashdata-research
  cancel-in-progress: false
jobs:
  verify:
    runs-on: [self-hosted, linux, flashdata-research]
    timeout-minutes: 5
    steps:
      - name: Verify the installed profile without a paid query
        shell: bash
        env:
          FLASHDATA_BIN: ${{ vars.FLASHDATA_BIN }}
          FLASHDATA_STATE_DIR: ${{ vars.FLASHDATA_STATE_DIR }}
          FLASHDATA_PROFILE: ${{ vars.FLASHDATA_PROFILE }}
          FLASHDATA_API_KEY: ""
        run: |
          set -euo pipefail
          : "${FLASHDATA_BIN:?Set the absolute CLI path}"
          : "${FLASHDATA_STATE_DIR:?Set the existing absolute state directory}"
          : "${FLASHDATA_PROFILE:?Set the installed profile name}"
          test -d "$FLASHDATA_STATE_DIR"
          "$FLASHDATA_BIN" auth status --profile "$FLASHDATA_PROFILE" \
            --state-dir "$FLASHDATA_STATE_DIR" --json --non-interactive |
            jq -e '.ok and .data.accessVerified
              and (.data.identity.identity.recurringAllowed == true)
              and (.data.identity.permittedSources | index("google_search") != null)'
```

- [GitHub धावक लेबल](https://docs.github.com/en/actions/how-tos/write-workflows/choose-where-workflows-run/choose-the-runner-for-a-job)

<a id="ci-run"></a>

### एक्सेस चेक चलाएं

रिपॉज़िटरी की डिफ़ॉल्ट शाखा पर वर्कफ़्लो को बचाने के बाद, ओपन एक्शन → FlashData एक्सेस चेक → रन वर्कफ़्लो। true और एक सफल चेक का अन्वेषण करें। मिसिंग एक्सेस या अनुमति किसी खोज को प्रस्तुत किए बिना नौकरी विफल हो जाती है।


<a id="ci-state"></a>

### नौकरियों में निष्पादन स्थिति रखें

एक ephemeral धावक मूल पत्रिका के बिना शुरू होता है। भुगतान किए गए आवर्ती कार्य के लिए टिकाऊ आवेदन राज्य या एक लगातार धावक का उपयोग करें। केवल कुंजी की स्थापना पिछले काम की प्रस्तुति की पहचान नहीं की जा सकती है। राज्य निर्देशिका और कार्य आउटपुट निजी रखें; उन्हें सीआई कलाकृतियों के रूप में अपलोड न करें।


<a id="maintain"></a>

## रोटोटेट या रद्दी हुई पहुँच

भुगतान। कार्य फ़ोल्डर में, उसी खाते और आवश्यक स्रोतों के लिए प्रतिस्थापन कुंजी पर FLASHDATA_KEY_FILE को इंगित करें, फिर नीचे दिए गए आदेशों को चलाएं। एक्सेस चेक और deployment-check.sh को दोहराएं; cached: true की उम्मीद करें। सत्यापन के बाद पुरानी कुंजी को रद्द करें और प्रोफ़ाइल और राज्य निर्देशिका को बनाए रखें।

### stdin के माध्यम से कुंजी बदलें

```bash
set -euo pipefail
. ./runtime.sh
: "${FLASHDATA_KEY_FILE:?Point to the mounted replacement key for the same account}"
run_flashdata auth login --replace --api-key-stdin --non-interactive \
  < "$FLASHDATA_KEY_FILE"
run_flashdata auth status --json --non-interactive
```

- [API कुंजियों का प्रबंधन](https://flashdata.dev/hi/docs/guides/api-keys-and-permissions/reference.md#rotate)
- [Connected apps](https://flashdata.dev/app/settings/connections)

<a id="revoke"></a>

### पूरी तरह से पहुंच बंद करें

शेड्यूलर को रोकें, कंसोल में कुंजी या एजेंट कनेक्शन को रद्द करें, फिर मुफ्त एक्सेस चेक दोहराएं। यह असफल होना चाहिए। अकेले स्थानीय लॉगआउट सर्वर क्रेडेंशियल को रद्द नहीं करता है; पहले से ही निर्यात की गई फाइलें डिस्क पर बनी रहती हैं।


<a id="help"></a>

## तैनाती की जांच जो विफल हो गई

| लक्षण | फिक्स |
| --- | --- |
| कमांड नहीं मिला / गलत CLI संस्करण | runtime.sh में कमांड -v flashdata और FLASHDATA_BIN की जाँच करें। Docker के लिए, छवि के --version चेक को पुनर्निर्माण और चलाने के लिए। |
| मिसिंग माउंट या अनुमति इनकार कर दिया | Docker होस्ट पर राज्य और कार्य फ़ोल्डर बनाएं, जिसका स्वामित्व सेवा UID/GID. है। अपने पथ को स्थिर रखें। |
| replacement_requires_flag | प्रोफ़ाइल में एक अलग बचाया कुंजी है। पहले मौजूदा पहुंच को सत्यापित करें; एक इच्छित प्रतिस्थापन के लिए घूर्णन प्रक्रिया का उपयोग करें। |
| सहेजे गए एक्सेस को डिक्रिप्ट नहीं कर सकते | उपयोगकर्ता के रूप में चलाएं, जो इसे उसी क्रेडेंशियल स्टोर पर्यावरण में नियुक्त करता है। एक एन्क्रिप्टेड लैपटॉप प्रोफ़ाइल की प्रतिलिपि बनाने के बजाय एक नए गंतव्य पर प्रावधान पहुंच। |
| कॉस्ट चेक रिटर्न false | निरीक्षण balance.json और preflight.json। प्रस्तुत करने से पहले उपलब्ध मूल्य, स्रोत अनुमति और पर्याप्त संतुलन की आवश्यकता होती है। |
| run_account_mismatch | चयनित खाते और API मूल की जाँच करें। मूल पहुंच को पुनर्स्थापित करें; वसूली को बायपास करने के लिए रन का नाम न बदलें। |
| run_id_input_conflict | प्रयास के request.json से मूल अनुरोध को पुनर्स्थापित करें। केवल एक निश्चित नए भुगतान कार्य के लिए एक नए रन ID का उपयोग करें। |
| CI ठहरना क्वाउड | जाँच करें कि धावक ऑनलाइन है और हर रन-ऑन लेबल है। इस कार्यप्रवाह को लगातार स्व-होस्टेड Linux धावक की आवश्यकता होती है। |

- [एक बचाया रन को पुनर्प्राप्त करें](https://flashdata.dev/hi/docs/guides/agent-recovery/reference.md)
