# สร้างกระบวนการส่งมอบสื่อ

ดาวน์โหลด MP4 ไปยังส่วนส่วนตัว S3 เก็บแฟ้ม, ทําการเริ่มการทํางานใหม่หลังจากเริ่มโปรแกรมใหม่อีกครั้ง และให้สิทธิ์ในการใช้งานแฟ้มตรวจสอบสิทธิ์ของคุณ

อ้างอิงทางคลอง: https://flashdata.dev/th/docs/guides/media-delivery-pipeline
Recorder: 2026-11-05 โดย FlashData

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

## สิ่ง ที่ คุณ จะ สร้าง

รายการแบบคงทนหนึ่งรายการย้ายจากวิดีโอ ID ไปเป็นแฟ้มที่เตรียมโปรแกรมแล้ว เก็บแต่ละขั้นตอนบนดิสก์เพื่อให้กระบวนการใหม่ สามารถดําเนินการต่อจากผลที่ได้รับการยืนยันล่าสุด

### บันทึกและบันทึกทางท่อName

```text
item.json
  ○ ส่งเมื่อบันทึกการทํางาน + งาน ID
  ○ กลับ มา ทํา งาน ได้ อีก delivery.json
  ○ ตรวจ สอบ S3 ไบต์ media.mp4 + ready.json
  ○ ใช้งานโปรแกรมแบบ Office (in อังกฤษ) แบบอายุสั้น URL
```

- [เลือกเพลง, วิดีโอ หรือคลิป](https://flashdata.dev/th/docs/guides/youtube-download-guide/reference.md#formats)

<a id="requirements"></a>

### ก่อนจะเริ่ม

เลือกเส้นทางหนึ่งตัวอย่างทั้งหกขั้น ทั้งคู่ใช้การติดตั้ง FlashData CLI ด้วยโพรไฟล์เจ้าของที่บันทึกไว้ youtube_download อนุญาต, ส่วนตัว S3 storage.json สําหรับการอัปโหลด และการแสดงตัวของ AWS ที่สามารถอ่านวัตถุได้

#### Python

ใช้ Python 3.10# ในตัวเธอ # Python สิ่งแวดล้อม สคริปต์เรียก CLI เพื่อรักษาบันทึกการทํางาน และโบโต3ที่จะอ่าน S3 และสัญลักษณ์เชื่อมโยง Bash, jq, Node.js และ AWS CLI ไม่จําเป็นหรอก ประมวลผลคําสั่งด้านล่างนี้ด้วย python หรือ pythaon3 ถ้านั่นคือชื่อล่ามของคุณ

##### ติดตั้ง Python การติดต่อ

```bash
python --version
flashdata --version
python -m pip install boto3
```


#### Bash / Node.js

ติดตั้ง Bash, jq, Node.js 22+ และ AWS CLI v2 เปิด Windowsวิ่ง Bash คําสั่งใน Git Bash. ติดตั้งโหนด S3 เซ็นกํากับแพกเกจในขั้นตอน 6.


- [ดาวน์โหลดครั้งแรก](https://flashdata.dev/th/docs/guides/download-video-recipe/reference.md)
- [ส่วนตัว storage.json ตั้งค่า](https://flashdata.dev/th/docs/guides/cli-automation/reference.md#storage)
- [บันทึกโพรไฟล์](https://flashdata.dev/th/docs/guides/cli-automation/reference.md#profiles)
- [Boto3 ใบรับรอง AWS](https://docs.aws.amazon.com/boto3/latest/guide/credentials.html)

<a id="environment"></a>

### บันทึกค่าเวลาทํางาน

สร้างโฟลเดอร์ส่วนตัวที่อยู่นอกการควบคุมแหล่ง บันทึกการตั้งค่าสําหรับพาธที่คุณเลือกไว้ และแก้ไขพาธและโพรไฟล์ได้ที่นี่ แต่ละโพรเซสจะใช้บัญชีผู้ใช้ที่บันทึกไว้ และประมวลผลบันทึกประจําวัน เก็บข้อมูลส่วนตัวใน storage.json ประมวลผล 1 รายการต่อรายการทีละครั้ง

#### Python

บันทึก pipeline.json เปิด Windowsส่งต่อเส้นทางเช่น C:/private/flashdata-state ทํางานใน JSON.

##### pipeline.json

```json
{
  "stateDir": "/absolute/path/to/flashdata-state",
  "storageConfig": "/absolute/path/to/private/storage.json",
  "profile": "default"
}
```


#### Bash

##### pipeline.env

```bash
# pipeline.env — edit these paths for your existing installation.
export FLASHDATA_STATE_DIR='/absolute/path/to/flashdata-state'
export FLASHDATA_STORAGE_CONFIG='/absolute/path/to/private/storage.json'
export FLASHDATA_PROFILE='default'
# Use the saved profile for every process.
unset FLASHDATA_API_KEY
```



<a id="design"></a>

## 1. บันทึกรายการที่ทนทานหนึ่งรายการ

บันทึก item.json ในโฟลเดอร์นั่น แทนที่วิดีโอและ S3 ปลายทาง; ตัวอย่างนี้เรียกร้องให้หนึ่ง MP4 ที่ถึง 720p. เก็บไว้เถอะ runId เพื่อการบูรณะ การแสดงผลรูปแบบต่าง ๆ ต้องการรายการใหม่ runId และวัตถุนําหน้า

### item.json

```json
{
  "runId": "media:clip-001:720p:v1",
  "request": {
    "source": "youtube_download",
    "video_id": "jNQXAC9IVRw",
    "params": {
      "download_type": "audio_video",
      "video_quality": "<=720",
      "output_format": "mp4"
    }
  },
  "destination": {
    "bucket": "your-media-bucket",
    "region": "us-east-1",
    "prefix": "media/clip-001-v1"
  }
}
```


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

## 2. บันทึกสคริปต์และตรวจสอบสิทธิ์ที่อนุญาต

สร้างแฟ้มด้านล่างนี้ก่อนที่จะทําการตรวจสอบ มันตรวจสอบปลายทาง S3 และเก็บใบเสร็จสําหรับทุกความพยายามที่ยอมจํานน


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

### สร้างสคริปต์สําหรับส่งเอกสาร

#### Python

สร้าง pipeline.py ในโฟลเดอร์เดียวกันกับ pipeline.json ถึง item.json. คัดลอกรหัสที่สมบูรณ์ด้านล่างเข้าไปในไฟล์ที่และบันทึกมัน คุณจะทําซ้ําอีกครั้งสําหรับการตรวจสอบ, การส่งและกู้คืนในขั้นตอน 2–4

##### pipeline.py

```python
# pipeline.py — Python 3.10+ and the FlashData CLI on PATH.
import argparse
import json
import os
import subprocess
import sys
import tempfile
from pathlib import Path

ROOT = Path(__file__).resolve().parent


def read_json(path):
    return json.loads(Path(path).read_text(encoding='utf-8-sig'))


def delivery_directory():
    # Recovery updates this pointer only after the delivery is saved successfully.
    return ROOT / (ROOT / 'delivery-dir.txt').read_text(encoding='utf-8').strip()


def main(action):
    os.umask(0o077)
    settings = read_json(ROOT / 'pipeline.json')
    for name in ['stateDir', 'storageConfig']:
        if not Path(settings[name]).is_absolute():
            raise ValueError('Set an absolute path for ' + name)
    item = read_json(ROOT / 'item.json')
    run_id = item['runId']
    env = dict(os.environ)
    env.pop('FLASHDATA_API_KEY', None)  # Reuse the saved owner profile.
    flags = ['--profile', settings['profile'], '--state-dir', settings['stateDir'],
             '--json', '--non-interactive']

    def cli(*args, payload=None, attempt=None):
        result = subprocess.run(['flashdata', *args, *flags], cwd=ROOT, env=env,
                                input=json.dumps(payload) if payload is not None else None,
                                capture_output=True, text=True, encoding='utf-8')
        if attempt:
            (attempt / 'receipt.json').write_text(result.stdout, encoding='utf-8')
            (attempt / 'error.json').write_text(result.stderr, encoding='utf-8')
        if result.returncode:
            if attempt:
                raise RuntimeError('Keep ' + str(attempt) + '; inspect its error and saved run.')
            raise RuntimeError(result.stderr.strip() or 'FlashData command failed.')
        response = json.loads(result.stdout)
        if not response.get('ok'):
            raise RuntimeError('Inspect the CLI response before continuing.')
        return response

    def new_attempt(stage):
        attempts = ROOT / 'attempts'
        attempts.mkdir(exist_ok=True)
        return Path(tempfile.mkdtemp(prefix=stage + '.', dir=attempts))

    if action == 'check':
        access = cli('auth', 'status')['data']
        identity = access['identity']
        if (not access.get('accessVerified')
                or identity['identity'].get('recurringAllowed') is not True
                or 'youtube_download' not in identity.get('permittedSources', [])):
            raise ValueError('Owner access with youtube_download is required.')
        print(json.dumps({'accountId': identity['identity']['accountId'],
                          'permittedSources': identity['permittedSources']}, indent=2))
        for args in [('account', 'balance'),
                     ('account', 'pricing', '--source', 'youtube_download', '--request-count', '1'),
                     ('account', 'limits')]:
            print(json.dumps(cli(*args)['data'], indent=2))
    elif action in ['dry-run', 'submit']:
        storage = read_json(settings['storageConfig'])
        destination = item['destination']
        if (item['request']['source'] != 'youtube_download'
                or storage.get('storage_type') != 's3'
                or storage.get('storage_url') != destination['bucket']
                or storage.get('region') != destination['region']):
            raise ValueError('Check item.json and the S3 destination in storage.json.')
        request = item['request']
        request['params']['storage'] = {**storage, 'object_prefix': destination['prefix']}
        args = ['query', '--input', '-', '--mode', 'async', '--run-id', run_id]
        if action == 'dry-run':
            response = cli(*args, '--dry-run', payload=request)
            if response['data'].get('dryRun') is not True:
                raise ValueError('Expected a dry-run result.')
            print(json.dumps({'ok': True, 'dryRun': True}))
        else:
            attempt = new_attempt('submit')
            response = cli(*args, '--output', str(attempt / 'submission.json'),
                           payload=request, attempt=attempt)
            print(json.dumps({'runId': run_id, 'cached': response.get('cached'),
                              'receipt': str(attempt / 'submission.json')}, indent=2))
    elif action == 'inspect':
        run = cli('runs', 'show', run_id)['data']
        print(json.dumps({'runId': run_id, 'status': run['status'], 'jobId': run.get('remoteId'),
                          'errorCode': run.get('errorCode'),
                          'candidateJobIds': run.get('candidateRemoteIds')}, indent=2))
    elif action == 'recover':
        attempt = new_attempt('recover')
        cli('runs', 'recover', run_id, '--timeout', '10m',
            '--output', str(attempt / 'delivery.json'), attempt=attempt)
        run = cli('runs', 'show', run_id)
        (attempt / 'run.json').write_text(json.dumps(run, indent=2), encoding='utf-8')
        delivery = read_json(attempt / 'delivery.json')
        if delivery.get('source') != 'youtube_download' or delivery.get('status') != 'done':
            raise ValueError('Inspect the saved delivery before verifying.')
        pointer = ROOT / 'delivery-dir.next'
        pointer.write_text(attempt.relative_to(ROOT).as_posix(), encoding='utf-8')
        pointer.replace(ROOT / 'delivery-dir.txt')
        print('Delivery files:', attempt)
    elif action == 'delivery':
        delivery = read_json(delivery_directory() / 'delivery.json')
        print(json.dumps({'status': delivery['status'], 'file': delivery['results'][0],
                          'usage': delivery.get('usage')}, indent=2))


if __name__ == '__main__':
    sys.stdout.reconfigure(encoding='utf-8')
    sys.stderr.reconfigure(encoding='utf-8')
    parser = argparse.ArgumentParser()
    parser.add_argument('action', choices=['check', 'dry-run', 'submit', 'inspect', 'recover', 'delivery'])
    try:
        main(parser.parse_args().action)
    except (OSError, ValueError, KeyError, RuntimeError) as error:
        print(str(error), file=sys.stderr)
        sys.exit(1)
```


#### Bash

สร้าง request-media.sh ในโฟลเดอร์เดียวกันกับ pipeline.env ถึง item.json. คัดลอกรหัสที่สมบูรณ์ด้านล่างเข้าไปในไฟล์ที่และบันทึกมัน

##### request-media.sh

```bash
#!/usr/bin/env bash
set -euo pipefail
umask 077
cd -- "$(dirname -- "$0")"
. ./pipeline.env
: "${FLASHDATA_STATE_DIR:?Set your existing absolute CLI state directory}"
: "${FLASHDATA_STORAGE_CONFIG:?Set the absolute path to private storage.json}"
action=${1:-dry-run}
[[ "$action" == dry-run || "$action" == submit ]] || exit 2
run_id=$(jq -er '.runId | select(type == "string" and length > 0)' item.json)
request() {
  jq -en --slurpfile item item.json --slurpfile storage "$FLASHDATA_STORAGE_CONFIG" '
    $item[0] as $i | $storage[0] as $s
    | if $i.request.source != "youtube_download"
        or $s.storage_type != "s3" or $s.storage_url != $i.destination.bucket
        or $s.region != $i.destination.region
      then error("Check item.json and the S3 destination in storage.json")
      else $i.request | .params.storage = ($s + {object_prefix: $i.destination.prefix}) end'
}
args=(query --input - --mode async --run-id "$run_id"
  --profile "${FLASHDATA_PROFILE:-default}" --state-dir "$FLASHDATA_STATE_DIR"
  --json --non-interactive)
if [[ "$action" == dry-run ]]; then
  request | flashdata "${args[@]}" --dry-run
else
  mkdir -p attempts
  attempt=$(mktemp -d attempts/submit.XXXXXX)
  if ! request | flashdata "${args[@]}" --output "$attempt/submission.json" \
    > "$attempt/receipt.json" 2> "$attempt/error.json"; then
    cat "$attempt/error.json" >&2
    printf 'Keep %s; inspect the saved run before retrying.\n' "$attempt" >&2
    exit 1
  fi
  jq '{runId, cached, data}' "$attempt/receipt.json"
  printf 'Saved receipt: %s/submission.json\n' "$attempt"
fi
```



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

### โปรดตรวจสอบบัญชีผู้ใช้ที่บันทึกไว้ของคุณ

เรียกใช้การตรวจสอบนี้ฟรีจากโฟลเดอร์รายการ หลังจากที่บันทึกสคริปต์แล้ว สิทธิ์ในการเป็นเจ้าของที่สูญหาย หรือสิทธิ์ youtube_download ที่จะหยุดการตรวจสอบ ยืนยันบัญชี ID, สมดุลต่อ TB rate และลิมิต ค่าใช้จ่ายสุดท้ายขึ้นอยู่กับการอัพโหลดไบท์

#### Python

##### ตรวจสอบสภาพแวดล้อมและบัญชีผู้ใช้

```bash
python pipeline.py check
```


#### Bash

##### ตรวจสอบสภาพแวดล้อมและบัญชีผู้ใช้

```bash
set -euo pipefail
. ./pipeline.env
: "${FLASHDATA_STATE_DIR:?Set your existing absolute CLI state directory}"
: "${FLASHDATA_STORAGE_CONFIG:?Set the absolute path to private storage.json}"
flashdata --version
jq --version
node --version
aws --version
flashdata auth status --profile "${FLASHDATA_PROFILE:-default}" \
  --state-dir "$FLASHDATA_STATE_DIR" --json --non-interactive |
  jq -e 'if .ok and .data.accessVerified
    and (.data.identity.identity.recurringAllowed == true)
    and (.data.identity.permittedSources | index("youtube_download") != null)
    then {accountId: .data.identity.identity.accountId,
          permittedSources: .data.identity.permittedSources}
    else error("Owner access with youtube_download is required.") end'
flashdata account balance --profile "${FLASHDATA_PROFILE:-default}" \
  --state-dir "$FLASHDATA_STATE_DIR" --json --non-interactive
flashdata account pricing --source youtube_download --request-count 1 \
  --profile "${FLASHDATA_PROFILE:-default}" --state-dir "$FLASHDATA_STATE_DIR" --json --non-interactive
flashdata account limits --profile "${FLASHDATA_PROFILE:-default}" \
  --state-dir "$FLASHDATA_STATE_DIR" --json --non-interactive
```


- [กลับไปยังแหล่งของสคริปต์](https://flashdata.dev/th/docs/guides/media-delivery-pipeline/reference.md#request-script)

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

### ตรวจสอบความถูกต้องโดยไม่มีการดาวน์โหลด

หลัง จาก ช่วย ผู้ ช่วย แล้ว ก็ รีบ วิ่ง ไป. Python การพิมพ์ ok: true ถึง dryRun: true; Bash การพิมพ์ true. นี้จะตรวจสอบการป้อนข้อมูลและการเข้าถึงโดยไม่ต้องรับงานสื่อ หรือเครดิตที่ยึดเหนี่ยว

#### Python

##### ประมวลผลแห้งว่าง

```bash
python pipeline.py dry-run
```


#### Bash

##### ประมวลผลแห้งว่าง

```bash
set -euo pipefail
bash request-media.sh dry-run | jq -e '.ok and .data.dryRun'
```



<a id="dispatch"></a>

## 3. ส่งและรักษางาน ID

นี้ส่งหนึ่งดาวน์โหลดพื้นหลังที่จ่าย คาด status: accepted และ jobId ในงานท้องถิ่น คงโพรไฟล์, ไดเร็กทอรีสถานะและ item.json เพื่อการฟื้นตัว สื่อพร้อมใช้งานเมื่อจบขั้นตอน 5 แล้ว

### Python

#### ส่งข้อมูลหนึ่งครั้ง

```bash
python pipeline.py submit
```

#### จําแนกสถานะท้องถิ่น

```bash
python pipeline.py inspect
```


### Bash

#### ส่งข้อมูลหนึ่งครั้ง

```bash
bash request-media.sh submit
```

#### จําแนกสถานะท้องถิ่น

```bash
set -euo pipefail
. ./pipeline.env
RUN_ID=$(jq -er '.runId' item.json)
flashdata runs show "$RUN_ID" --profile "${FLASHDATA_PROFILE:-default}" \
  --state-dir "$FLASHDATA_STATE_DIR" --json --non-interactive |
  jq '{runId, status: .data.status, jobId: .data.remoteId,
       errorCode: .data.errorCode, candidateJobIds: .data.candidateRemoteIds}'
```



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

### หากมีการบันทึกการทํางานหรือไม่แน่ใจอยู่แล้ว

| CLI สถานะ | การกระทํา |
| --- | --- |
| accepted + jobId | เรียกคืนการทํางานนี้ในขั้นตอน 4 ให้งาน ID หากโพรเซสยุติการทํางาน |
| succeeded | Recover/export การตอบรับที่บันทึกไว้ จากนั้นตรวจสอบการจัดเก็บ ไม่ต้องส่งรายการใหม่ |
| ไม่ทราบผลลัพธ์ / ไม่มีงานพิมพ์ที่ได้รับการยืนยัน ID | ให้ทํางาน ใบเสร็จและความผิดพลาด ขอบเขตสี History หรือผู้สมัคร IDs ก่อนที่จะตัดสินใจรับอีก |

- [ต้องการประวัติ](https://flashdata.dev/app/jobs)
- [การ กู้ การ ยอม รับ อย่าง ไม่ แน่นอน](https://flashdata.dev/th/docs/guides/agent-recovery/reference.md)

<a id="recover"></a>

## 4. ดึงข้อมูลบันทึกการส่งมอบ

ประมวลผลจากโฟลเดอร์ในเทอร์มินัลใหม่ใด ๆ การ กู้ คืน สู่ สภาพ เดิม คอย งาน เดิม และ ทํา การ พิมพ์ ไดเรกทอรี ที่ บรรจุ อยู่ delivery.json, run.json และใบเสร็จ A 10- ขอเวลาหนึ่งนาที หยุดการรอคอยในท้องถิ่น; ทําซ้ําการฟื้นตัวเพื่อกลับมาทํางานเดิม


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

### ทํางานที่บันทึกไว้ต่อ

#### Python

ใช้อีกครั้ง pipeline.py บันทึกในขั้นตอน 2. ไม่จําเป็นต้องมีสคริปต์เพิ่มเติม

##### เรียกคืนงานที่มีอยู่แล้ว ไม่มีการส่งข้อมูลใหม่

```bash
python pipeline.py recover
```


#### Bash

สร้างครั้งแรก recover-media.sh ข้าง item.json และวางในรหัสด้านล่าง บันทึกแฟ้มแล้วเรียกใช้คําสั่งการกู้คืนที่ด้านล่าง

##### recover-media.sh

```bash
#!/usr/bin/env bash
set -euo pipefail
umask 077
cd -- "$(dirname -- "$0")"
. ./pipeline.env
: "${FLASHDATA_STATE_DIR:?Set your existing absolute CLI state directory}"
RUN_ID=$(jq -er '.runId' item.json)
mkdir -p attempts
DELIVERY_DIR=$(mktemp -d attempts/recover.XXXXXX)
if ! flashdata runs recover "$RUN_ID" --timeout 10m \
  --profile "${FLASHDATA_PROFILE:-default}" --state-dir "$FLASHDATA_STATE_DIR" \
  --output "$DELIVERY_DIR/delivery.json" --json --non-interactive \
  > "$DELIVERY_DIR/receipt.json" 2> "$DELIVERY_DIR/error.json"; then
  cat "$DELIVERY_DIR/error.json" >&2
  printf 'Keep %s; recover the same run after resolving the error.\n' "$DELIVERY_DIR" >&2
  exit 1
fi
flashdata runs show "$RUN_ID" --profile "${FLASHDATA_PROFILE:-default}" \
  --state-dir "$FLASHDATA_STATE_DIR" --json --non-interactive > "$DELIVERY_DIR/run.json"
jq -e '.source == "youtube_download" and .status == "done"' \
  "$DELIVERY_DIR/delivery.json" >/dev/null
printf '%s\n' "$DELIVERY_DIR"
```

##### เรียกคืนงานที่มีอยู่แล้ว ไม่มีการส่งข้อมูลใหม่

```bash
set -euo pipefail
DELIVERY_DIR=$(bash recover-media.sh)
printf 'Delivery files: %s\n' "$DELIVERY_DIR"
```



<a id="delivery-record"></a>

### ตรวจหาวัตถุที่ส่งมาแล้ว

ผลลัพธ์ควรมี URL ของออบเจ็กต์ S3 หนึ่งรายการ ขนาดไฟล์มากกว่าศูนย์ และ MD5 ออบเจ็กต์ส่วนตัวต้องใช้ข้อมูลรับรอง AWS ที่มีสิทธิ์อ่าน Python บันทึกไดเรกทอรีที่สำเร็จไว้ใน delivery-dir.txt สำหรับสคริปต์ถัดไป ส่วน Bash เก็บไว้ใน DELIVERY_DIR หากเปิดเทอร์มินัลใหม่ ให้ตั้งค่านี้เป็นไดเรกทอรีที่แสดงไว้

#### Python

##### บันทึกการส่งมอบ

```bash
python pipeline.py delivery
```


#### Bash

##### บันทึกการส่งมอบ

```bash
jq '{status, file: .results[0], usage}' "$DELIVERY_DIR/delivery.json"
```



<a id="verify"></a>

## 5. ตรวจสอบไบต์ก่อนที่จะทําการทําการพิมพ์เสร็จ

เครื่องตรวจสอบค่านําเข้าดั้งเดิม S3 ถังและคํานําหน้า, ลําธารวัตถุเอกชนกับดิสก์และการเปรียบเทียบโดยนับ MD5. ผลิตแฟ้มที่เข้าคู่กันเท่านั้น verified/ready.json. Python อ่าน delivery-dir.txt; โหนดใช้ DELIVERY_DIR และทั้งยังไม่ส่ง FlashData สอบถามดู


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

### บันทึกสคริปต์ตรวจสอบ

ส่วนเสริมนี้ใช้จับมาตรฐาน Amazon S3 วัตถุ URLs. สําหรับผู้จัดทําหรือผู้ให้บริการอื่น ๆ ที่กําหนดเอง ให้ใช้อ่านวัตถุที่ยืนยันแล้ว และคงปลายทางเดิม โดยเพิ่มจํานวนและตรวจเช็ค

#### Python

สร้าง verify-media.py ข้าง pipeline.py และคัดลอกรหัสที่สมบูรณ์ ลงในมัน จัดเก็บแฟ้มทั้งสองไว้ในโฟลเดอร์รายการ

##### verify-media.py

```python
# verify-media.py — uses Boto3's configured AWS read identity.
import hashlib
import json
import os
import re
import sys
from contextlib import closing
from datetime import datetime, timezone
from urllib.parse import unquote, urlsplit

import boto3
from pipeline import ROOT, delivery_directory, read_json


def main():
    os.umask(0o077)
    directory = delivery_directory()
    item = read_json(ROOT / 'item.json')
    saved = read_json(directory / 'run.json')
    raw = (directory / 'delivery.json').read_bytes()
    delivery = json.loads(raw)
    run = saved.get('data', {})
    if (not saved.get('ok') or run.get('id') != item['runId']
            or run.get('status') != 'succeeded' or not run.get('remoteId')
            or delivery.get('source') != 'youtube_download' or delivery.get('status') != 'done'
            or not isinstance(delivery.get('results'), list) or len(delivery['results']) != 1):
        raise ValueError('Inspect the saved run and completed delivery before verifying.')
    file = delivery['results'][0]
    bucket, region, prefix = (item['destination'][key] for key in ['bucket', 'region', 'prefix'])
    original = run.get('input', {})
    storage = original.get('params', {}).get('storage', {})
    if (original.get('source') != 'youtube_download' or original.get('video_id') != item['request']['video_id']
            or any(original.get('params', {}).get(key) != item['request']['params'][key]
                   for key in ['download_type', 'video_quality', 'output_format'])
            or storage.get('storage_url') != bucket or storage.get('region') != region
            or storage.get('object_prefix') != prefix):
        raise ValueError('item.json changed after submission. Inspect the original run.')
    url = urlsplit(file['file_url'])
    hosts = [bucket + '.s3.' + region + '.amazonaws.com', bucket + '.s3.amazonaws.com']
    key = unquote(url.path[1:], errors='strict')
    if (url.scheme != 'https' or url.netloc not in hosts or url.query or url.fragment
            or not prefix or not key.startswith(prefix + '/')):
        raise ValueError('The delivery does not match the planned Amazon S3 destination.')
    if (type(file.get('file_size')) is not int or file['file_size'] <= 0
            or not re.fullmatch(r'[a-fA-F0-9]{32}', file.get('md5', ''))):
        raise ValueError('A positive file_size and MD5 are required. Keep the manifest.')
    verification = directory / 'verified'
    verification.mkdir(mode=0o700)  # Stop if an earlier verification already exists.
    local_file = verification / 'media.mp4'
    s3 = boto3.client('s3', region_name=region)
    response = s3.get_object(Bucket=bucket, Key=key)
    size, digest = 0, hashlib.md5(usedforsecurity=False)
    with closing(response['Body']) as stream, local_file.open('xb') as output:
        while chunk := stream.read(1024 * 1024):
            output.write(chunk)
            size += len(chunk)
            digest.update(chunk)
    md5 = digest.hexdigest()
    if size != file['file_size'] or md5 != file['md5'].lower():
        raise ValueError('Byte count or MD5 mismatch. Keep the file; do not mark it ready.')
    ready = {'runId': item['runId'], 'jobId': run['remoteId'], 'videoId': item['request']['video_id'],
             'bucket': bucket, 'region': region, 'objectKey': key,
             'storageVersionId': response.get('VersionId'), 'bytes': size, 'md5': md5,
             'verifiedAt': datetime.now(timezone.utc).isoformat(), 'localFile': str(local_file.resolve()),
             'deliverySha256': hashlib.sha256(raw).hexdigest(), 'usage': delivery.get('usage')}
    with (verification / 'ready.json').open('x', encoding='utf-8') as output:
        json.dump(ready, output, indent=2)
    print('Delivery verified:', verification / 'ready.json')
    print(json.dumps(ready, indent=2))


if __name__ == '__main__':
    sys.stdout.reconfigure(encoding='utf-8')
    sys.stderr.reconfigure(encoding='utf-8')
    try:
        main()
    except Exception as error:
        print(str(error), file=sys.stderr)
        sys.exit(1)
```


#### Node.js

สร้าง verify-media.mjs ข้าง item.json และคัดลอกรหัสที่สมบูรณ์ ลงในมัน

##### verify-media.mjs

```javascript
import { readFile, mkdir, writeFile } from 'node:fs/promises';
import { createReadStream } from 'node:fs';
import { createHash } from 'node:crypto';
import { execFileSync } from 'node:child_process';
import { resolve, join } from 'node:path';

try {
  const directory = process.argv[2];
  if (!directory) throw new Error('Pass the directory printed by the recovery step.');
  const readJson = async path => JSON.parse(await readFile(path, 'utf8'));
  const item = await readJson('item.json');
  const run = await readJson(join(directory, 'run.json'));
  const raw = await readFile(join(directory, 'delivery.json'));
  const delivery = JSON.parse(raw);
  if (!run.ok || run.data?.id !== item.runId || run.data?.status !== 'succeeded'
      || !run.data?.remoteId || delivery.source !== 'youtube_download'
      || delivery.status !== 'done' || delivery.results?.length !== 1) {
    throw new Error('Inspect the saved run and completed delivery before verifying.');
  }
  const file = delivery.results[0];
  const { bucket, region, prefix } = item.destination;
  const input = run.data.input;
  const storage = input?.params?.storage;
  if (input?.source !== 'youtube_download' || input.video_id !== item.request.video_id
      || ['download_type', 'video_quality', 'output_format'].some(
        key => input.params?.[key] !== item.request.params[key])
      || storage?.storage_url !== bucket || storage.region !== region
      || storage.object_prefix !== prefix) {
    throw new Error('item.json changed after submission. Inspect the original run.');
  }
  const url = new URL(file.file_url);
  const hosts = [bucket + '.s3.' + region + '.amazonaws.com', bucket + '.s3.amazonaws.com'];
  const objectKey = decodeURIComponent(url.pathname.slice(1));
  if (url.protocol !== 'https:' || !hosts.includes(url.host) || url.username
      || url.password || url.search || url.hash || !prefix
      || !objectKey.startsWith(prefix + '/')) {
    throw new Error('The delivery does not match the planned Amazon S3 destination.');
  }
  if (!Number.isSafeInteger(file.file_size) || file.file_size <= 0
      || !/^[a-f0-9]{32}$/i.test(file.md5 ?? '')) {
    throw new Error('A positive file_size and MD5 are required. Keep the manifest.');
  }
  const verification = join(directory, 'verified');
  await mkdir(verification, { mode: 0o700 }); // Existing attempt: stop without overwriting.
  const localFile = join(verification, 'media.mp4');
  let metadata;
  try {
    metadata = JSON.parse(execFileSync('aws', ['s3api', 'get-object',
      '--bucket', bucket, '--key', objectKey, '--region', region,
      '--output', 'json', '--no-cli-pager', '--no-cli-auto-prompt', localFile],
      { encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] }));
  } catch {
    throw new Error('S3 read failed. Keep this attempt and check the AWS read identity.');
  }
  let bytes = 0;
  const hash = createHash('md5');
  for await (const chunk of createReadStream(localFile)) {
    bytes += chunk.length;
    hash.update(chunk);
  }
  const md5 = hash.digest('hex');
  if (bytes !== file.file_size || md5 !== file.md5.toLowerCase()) {
    throw new Error('Byte count or MD5 mismatch. Keep the file; do not mark it ready.');
  }
  const ready = { runId: item.runId, jobId: run.data.remoteId,
    videoId: item.request.video_id, bucket, region, objectKey, storageVersionId: metadata.VersionId ?? null,
    bytes, md5, verifiedAt: new Date().toISOString(), localFile: resolve(localFile),
    deliverySha256: createHash('sha256').update(raw).digest('hex'), usage: delivery.usage };
  const readyFile = join(verification, 'ready.json');
  await writeFile(readyFile, JSON.stringify(ready, null, 2), { flag: 'wx', mode: 0o600 });
  console.log('Delivery verified:', readyFile);
} catch (error) {
  console.error(error instanceof Error ? error.message : 'Inspect the saved attempt.');
  process.exitCode = 1;
}
```


- [Boto3 GetObject](https://docs.aws.amazon.com/boto3/latest/reference/services/s3/client/get_object.html)
- [คําสั่ง AWS GetObject](https://docs.aws.amazon.com/cli/latest/reference/s3api/get-object.html)

<a id="verify-file"></a>

### ประมวลผลตรวจสอบ

หลังจากบันทึกสคริปต์แล้ว ให้ประมวลผลมันจากโฟลเดอร์รายการ

#### Python

##### ตรวจ และ อ่าน ประวัติการ ออก มือ

```bash
python verify-media.py
```


#### Node.js + AWS CLI

##### ตรวจ และ อ่าน ประวัติการ ออก มือ

```bash
set -euo pipefail
: "${DELIVERY_DIR:?Set the directory printed by recovery}"
node verify-media.mjs "$DELIVERY_DIR"
jq '{runId, jobId, bucket, region, objectKey, bytes, md5, storageVersionId}' \
  "$DELIVERY_DIR/verified/ready.json"
```



<a id="ready"></a>

### เอามือออก ready.json ไปยังโปรแกรมของคุณ

คาดว่าจะมีการตรวจสอบการส่งมอบและบันทึกที่บรรจุ run/job IDsตะกร้า, พื้นที่, กุญแจวัตถุ, ขนาดตรวจสอบและ MD5. นี่ เป็น ประวัติ บันทึก ของ คุณ ที่ สร้าง โดย สคริปต์. จัดเก็บลงแฟ้ม delivery.json และ (เราได้ทําให้) บรรดาสิ่งดี ๆ จากกิตติคุณ มันจะยังคงเหลืออยู่ API ผล ก็ คือ มี การ ใช้ หน้าต่าง สํารอง.

สําหรับตรวจสอบ, การทําดัชนีหรือการประมวลผลอื่น ๆ ผ่านการตรวจสอบ localFile กับพนักงานของคุณ สําหรับการดาวน์โหลดผู้ใช้ โดยทําต่อด้วย 6

- [ผลการตรวจสอบและจัดเก็บสื่อ](https://flashdata.dev/th/docs/guides/save-results/reference.md#media)

<a id="serve"></a>

## 6. ให้สิทธิ์ในการใช้งานโปรแกรมของคุณ

ใน แบ็คเอนต์ ของ คุณ ให้ มอบ อํานาจ ผู้ ใช้ และ ค้น ดู บันทึก ที่ ผู้ ใช้ ได้ ทํา ไว้ ใน ร้าน ของ คุณ เอง. จากนั้นให้อายุยืน S3 ดาวน์โหลด URL. ใช้ปลายทางที่บันทึกไว้; ไม่ต้องรับถังหรือปุ่มออบเจกต์ที่จัดให้โดยเบราว์เซอร์


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

### บันทึกสคริปต์ดาวน์โหลดลิงก์

The SDK ใช้ชื่ออ่านของโปรแกรมเบื้องหลัง AWS. ไม่ FlashData การสอบถามถูกส่งไปแล้ว

เดอะ URL ชื่อรุ่นของออบเจกต์ที่ตรวจสอบแล้วเมื่อ S3 การทําซ้ําทําให้ได้อย่างหนึ่ง โดยไม่ต้องมีรุ่น ID ให้เก็บแต่ละปุ่มพิมพ์ที่จะส่งออกหลังจากการตรวจสอบ การอ่านการแสดงตัวต้องการรุ่น s3: GetObjectVersion; การอ่านแบบไม่ซ้ําหน้าต้องการ S3: greopObjject

#### Python

สร้าง create-download-link.py ข้าง pipeline.py และคัดลอกรหัสที่สมบูรณ์ ลงในมัน มันใช้แพกเกจ Boto3 ที่ติดตั้งไว้ในตอนแรก

##### create-download-link.py

```python
# create-download-link.py — run in your backend after authorizing the user.
import json
import os
import sys

import boto3
from botocore.config import Config
from pipeline import delivery_directory, read_json


def main():
    os.umask(0o077)
    # In an app, load this user's verified ready record from your own store.
    directory = delivery_directory() / 'verified'
    ready = read_json(directory / 'ready.json')
    if any(not isinstance(ready.get(key), str) or not ready[key]
           for key in ['bucket', 'region', 'objectKey', 'verifiedAt']):
        raise ValueError('Use the ready.json produced by the verification step.')
    destination = directory / 'access.json'
    if destination.exists():
        raise FileExistsError('Keep the existing access.json or choose a new output filename.')
    params = {'Bucket': ready['bucket'], 'Key': ready['objectKey']}
    version = ready.get('storageVersionId')
    if version and version != 'null':
        params['VersionId'] = version
    s3 = boto3.client('s3', region_name=ready['region'], config=Config(signature_version='s3v4'))
    url = s3.generate_presigned_url('get_object', Params=params, ExpiresIn=300, HttpMethod='GET')
    with destination.open('x', encoding='utf-8') as output:
        json.dump({'url': url, 'expiresInSeconds': 300}, output, indent=2)
    # Do not log the signed URL; return it only to the authorized user.
    print('Access record saved:', destination)


if __name__ == '__main__':
    sys.stdout.reconfigure(encoding='utf-8')
    sys.stderr.reconfigure(encoding='utf-8')
    try:
        main()
    except Exception as error:
        print(str(error), file=sys.stderr)
        sys.exit(1)
```


#### Node.js

ติดตั้งแพกเกจที่เซ็นในโฟลเดอร์รายการ จากนั้นบันทึกแหล่งด้านล่างนี้เป็น create-download-link.mjs ในโฟลเดอร์ดังกล่าว

##### ติดตั้ง S3 โปรแกรมรับ/ เซ็น

```bash
test -f package.json || npm init -y
npm install @aws-sdk/client-s3 @aws-sdk/s3-request-presigner
```

##### create-download-link.mjs

```javascript
// create-download-link.mjs — run in your backend with its AWS read identity.
import { readFile } from 'node:fs/promises';
import { GetObjectCommand, S3Client } from '@aws-sdk/client-s3';
import { getSignedUrl } from '@aws-sdk/s3-request-presigner';

try {
  const path = process.argv[2];
  if (!path) throw new Error('Pass the verified ready.json file.');
  const ready = JSON.parse(await readFile(path, 'utf8'));
  if (['bucket', 'region', 'objectKey', 'verifiedAt'].some(
    key => typeof ready[key] !== 'string' || !ready[key])) {
    throw new Error('Use the ready.json produced by the verification step.');
  }
  // Load this record from your own store after authorizing the requesting user.
  const version = ready.storageVersionId;
  const command = new GetObjectCommand({
    Bucket: ready.bucket, Key: ready.objectKey,
    ...(version && version !== 'null' ? { VersionId: version } : {}),
  });
  const client = new S3Client({ region: ready.region });
  const url = await getSignedUrl(client, command, { expiresIn: 300 });
  console.log(JSON.stringify({ url, expiresInSeconds: 300 }, null, 2));
} catch (error) {
  console.error(error instanceof Error ? error.message : 'Could not create a download link.');
  process.exitCode = 1;
}
```


- [ตัวอย่าง Boto3 ที่มีการเซ็นล่วงหน้า URL](https://docs.aws.amazon.com/boto3/latest/guide/s3-presigned-urls.html)
- [ขนาด AWS JavaScript เซ็นก่อน URL ตัวอย่าง](https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/javascript_s3_code_examples.html)
- [S3 เข้าถึงและ URL หมดอายุ](https://docs.aws.amazon.com/AmazonS3/latest/userguide/using-presigned-url.html)

<a id="download-link"></a>

### คืนที่อยู่เชื่อมโยงไปยังผู้ใช้ที่มีสิทธิ์ในการใช้งาน

คาดหวังว่าจะเป็นเรื่องส่วนตัว access.json บรรจุ url และ expiresInSeconds: 300. แบ็คเอนต์ของคุณจะคืนเฉพาะแฟ้มเท่านั้น URL ไปยังผู้ใช้ที่ได้รับอนุญาต ใครก็ตามที่ถือมันสามารถดาวน์โหลดไฟล์ได้ถึงห้านาที มันอาจจะหมดอายุเร็วขึ้นด้วยเอกสารรับรองการลงนาม

สร้างการเชื่อมโยงใหม่จากบันทึกที่บันทึกไว้แล้ว เมื่อผู้ใช้ต้องการเข้าใช้งานครั้งต่อไป เก็บกุญแจออบเจกต์และรุ่นไว้ในฐานข้อมูลของคุณ แทนการเก็บค่าที่ตั้งของ URL ไว้ ตัวอย่างนี้ภายในเครื่องหยุดการทํางานหาก access.json มีอยู่แล้ว

#### Python

##### สร้างการเชื่อมโยงห้านาที

```bash
python create-download-link.py
```


#### Node.js

##### สร้างการเชื่อมโยงห้านาที

```bash
(
set -euo pipefail
umask 077
: "${DELIVERY_DIR:?Set the directory printed by recovery}"
# Keep the signed link in a private file; do not log it or paste it into chat.
set -C
node create-download-link.mjs "$DELIVERY_DIR/verified/ready.json" \
  > "$DELIVERY_DIR/verified/access.json"
)
```



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

## เริ่มต้นจากขั้นสุดท้ายที่ได้รับการยืนยัน

| สถานการณ์ | การกระทําถัดไป |
| --- | --- |
| รับงาน / รอเล่นท้องถิ่น | ทําซ้ํา runs recover เหมือนกัน runId เข้าสู่ไดเร็กทอรีใหม่ |
| S3 การเข้าถึงถูกปฏิเสธหรือขัดจังหวะการอ่าน | แก้ไขการแสดงตัวหรือการเชื่อมต่อของ AWS เรียกคืนไปยังไดเรกทอรีใหม่และตรวจสอบอีกครั้ง โปรดเก็บส่วนย่อยก่อน |
| จํานวนไบต์ / MD5 / ปลายทางไม่ตรงกัน | หยุด เปรียบเทียบรุ่นที่แสดง, ออบเจ็กต์ และวางแผนปลายทาง ก่อนที่จะใช้สื่อ |
| มีการตรวจสอบสิทธิ์/ มีอยู่แล้ว | อ่าน ready.json ของมัน หรือตรวจสอบการตรวจสอบไม่สมบูรณ์ สคริปต์จะไม่เขียนทับมัน |
| ดาวน์โหลดโปรแกรม URL หมดอายุ | อนุญาตให้เข้าใช้อีกครั้งและเซ็นบันทึก object/version. ไม่ต้องส่งการดาวน์โหลด FlashData อีก |
| run_id_input_conflict | คํา ขอ นั้น ได้ เปลี่ยน ไป. กู้ค่าเดิมที่ประมวลผล; ใช้ใหม่ runId เพื่อผลลัพธ์ใหม่โดยเจตนาเท่านั้น |
| 401 / 403 / 402 / 429 | ปรับแก้สิทธิ์ในการใช้งานหรือสมดุลย์ของ KDE Retry-After. จําแนกงานก่อนที่จะพยายามส่งอีกครั้ง |


<a id="scale"></a>

## ปรับใช้ระยะเดียวกันกับคิว

1. เริ่มด้วยรายการไฟอินฟลาย อ่านลิมิตในปัจจุบันก่อนที่จะเพิ่มความสอดคล้องของโปรแกรม
2. จง ยืน หยัด ต่อ ๆ ไป runId สําหรับแต่ละคน video/output รุ่นที่มีสัญลักษณ์พิเศษสําหรับปลายทางที่แตกต่างกัน เก็บบัญชี, งาน ID และผลสุดท้ายในฐานข้อมูลโปรแกรมของคุณ
3. ต่อเนื่อง CLI ไดเร็กทอรีสถานะที่อยู่ตรงข้ามโพรเซสเริ่มการทํางานใหม่ การแยกเครื่องจักรต้องการการประสานงานของโปรแกรมร่วมกัน ซึ่งบันทึกประจําวันท้องถิ่นไม่ได้ลดความซับซ้อนของไดเรกทอรีของรัฐ
4. ใช้ ready.json เหมือนการส่งเรือลงแม่น้ํา การ นํา ของ ที่ ไม่ ได้ ทํา สําเร็จ แต่ ละ ชิ้น มา ใช้ ใหม่ ได้ อย่าง ประสบ ผล สําเร็จ.

- [ข้อจํากัดของบัญชีผู้ใช้](https://flashdata.dev/th/docs/guides/usage-and-limits/reference.md)
- [การแสดงตัวของแม่ข่ายและส่วนบรรจุ](https://flashdata.dev/th/docs/guides/production-deployment/reference.md)
- [จัดตารางงานใหม่](https://flashdata.dev/th/docs/guides/recurring-tasks/reference.md)
