# Buat pipeline pengiriman media

Unduh MP4 ke penyimpanan S3 pribadi, lanjutkan setelah restart dan berikan akses aplikasi ke berkas yang diverifikasi.

Referensi kanonikal: https://flashdata.dev/id/docs/guides/media-delivery-pipeline
Diulang: 2026-11-05 oleh FlashData

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

## What you 'll build

Satu item tahan lama bergerak dari video ID ke sebuah peralatan-siap file. Menjaga setiap tahap di disk sehingga proses baru dapat melanjutkan dari hasil dikonfirmasi terakhir.

### Baris pipa dan catatan tersimpan

```text
item.json
  Diserahkan setelah memperoleh informasi yang telah disimpan ID
  Jangan khawatir, aku akan mencari pekerjaan. delivery.json
  Pastikan S3 bytes = media.mp4 + ready.json
  Authortifikasi pengguna aplikasi membakarnya langsung mengunduh URL
```

- [Pilih audio, video, atau klip](https://flashdata.dev/id/docs/guides/youtube-download-guide/reference.md#formats)

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

### Sebelum Anda mulai

Pilih salah satu contoh jalan untuk semua enam langkah. Keduanya gunakan instalasi FlashData CLI dengan profil pemilik tersimpan dan youtube_download ijin, private S3 storage.json untuk upload, dan sebuah identitas AWS yang dapat membaca objek yang disampaikan.

#### Python

Gunakan Python 3.10 + dalam lingkungan Python Anda. Naskah menyebut CLI untuk melestarikan jurnalnya, dan Boto3 untuk membaca S3 dan menandatangani link. Bash, jq, Node.js dan AWS CLI tidak diperlukan. Jalankan perintah di bawah ini dengan python3 atau jika itu adalah nama penerjemah Anda.

##### Pasang ketergantungan Python

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


#### Bash / Node.js

Pasang Bash, jq, Node.js 22+ dan AWS CLI V2. Pada Windows, jalankan perintah Bash dalam Git Bash. Pasang Node S3 menandai paket dalam langkah 6.


- [Pengunduhan pertama](https://flashdata.dev/id/docs/guides/download-video-recipe/reference.md)
- [Prebet storage.json setup](https://flashdata.dev/id/docs/guides/cli-automation/reference.md#storage)
- [Profil tersimpan](https://flashdata.dev/id/docs/guides/cli-automation/reference.md#profiles)
- [Kredensial Boto3 AWS](https://docs.aws.amazon.com/boto3/latest/guide/credentials.html)

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

### Simpan pengaturan waktu-jalan

Membuat folder butir privat di luar kendali sumber. Simpan pengaturan bagi path yang Anda pilih dan sunting path absolut dan nama profil. Setiap proses menggunakan akun yang disimpan dan menjalankan jurnal. Kredensial penyimpanan tetap dalam storage.json pribadi. Jalankan satu proses per item pada suatu waktu.

#### Python

Simpan pipeline.json. Pada Windows, jalur garis miring seperti C: /private/flashdata-state bekerja di 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. Simpan satu butir tahan lama

Simpan item.json dalam folder itu. Ganti video dan tujuan S3; contoh ini meminta satu MP4 di hingga 720p. Simpan runId-nya untuk percobaan ulang. Keluaran berbeda yang direncanakan memerlukan runId baru dan prefiks objek.

### 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. Simpan skrip dan periksa akses

Membuat berkas di bawah ini sebelum menjalankan pemeriksaan. Ini memvalidasi tujuan S3 dan menyimpan tanda terima untuk setiap percobaan pengiriman.


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

### Buat skrip pipeline

#### Python

Buat pipeline.py dalam folder yang sama seperti pipeline.json dan item.json. Salin kode lengkap di bawah ini ke dalam berkas itu dan simpan. Anda akan menggunakannya kembali untuk pemeriksaan, penyerahan dan pemulihan di langkah 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

Buat request-media.sh dalam folder yang sama seperti pipeline.env dan item.json. Salin kode lengkap di bawah ini ke dalam berkas itu dan simpan.

##### 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>

### Periksa akun Anda yang tersimpan

Jalankan pemeriksaan gratis dari folder butir setelah menyimpan skrip. Kehilangan akses pemilik atau izin youtube_download menghentikan pemeriksaan. Konfirmasikan rekening ID, keseimbangan, tingkat per- TB dan batas. Biaya akhir tergantung pada byte upload.

#### Python

##### Periksa lingkungan dan akun

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


#### Bash

##### Periksa lingkungan dan akun

```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
```


- [Kembali ke sumber skrip](https://flashdata.dev/id/docs/guides/media-delivery-pipeline/reference.md#request-script)

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

### Validate tanpa sebuah download

Setelah menyelamatkan pembantu, jalankan nya kering lari. Python cetak ok: true dan dryRun: true; Bash cetak true. Ini memvalidasi masukan dan akses tanpa mengirimkan pekerjaan media atau reserving kredit.

#### Python

##### Uji coba bebas

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


#### Bash

##### Uji coba bebas

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



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

## 3. Kirim dan pertahankan pekerjaan ID

Ini menyerahkan yang dibayar latar belakang download. Mengharapkan status: accepted dan jobId dalam run lokal. Simpan profil, direktori negara dan item.json untuk pemulihan. Media hanya siap setelah langkah 5.

### Python

#### Kirim sekali

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

#### Inspeksi keadaan lokal

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


### Bash

#### Kirim sekali

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

#### Inspeksi keadaan lokal

```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>

### Jika jalankan sudah disimpan atau tidak pasti

| Kondisi CLI | Aksi |
| --- | --- |
| accepted + jobId | Recover run ini dalam langkah 4. Pertahankan pekerjaan ID jika prosesnya berhenti. |
| succeeded | Recover/export respon yang tersimpan, kemudian periksa penyimpanan. Jangan mengirimkan item baru. |
| Hasil tidak diketahui / tidak ada konfirmasi pekerjaan ID | Tetap jalankan, penerimaan dan kesalahan. Inspeksi History atau kandidat IDs sebelum memutuskan pengajuan lain. |

- [Meminta riwayat](https://flashdata.dev/app/jobs)
- [Kembali ke pengiriman yang tidak pasti](https://flashdata.dev/id/docs/guides/agent-recovery/reference.md)

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

## 4. Merebut kembali catatan pengiriman

Jalankan dari folder butir di terminal baru manapun. Pemulihan menunggu pekerjaan aslinya dan mencetak sebuah direktori berisi delivery.json, run.json dan penerimaan. A 10-menit timeout berhenti menunggu lokal; recovery untuk melanjutkan pekerjaan yang sama.


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

### Lanjutkan pekerjaan yang disimpan

#### Python

Gunakan pipeline.py disimpan dalam langkah 2. Tak ada skrip tambahan yang diperlukan.

##### Mengembalikan pekerjaan yang telah ada

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


#### Bash

Ciptaan pertama recover-media.sh di samping item.json dan paste dalam kode di bawah ini. Simpan berkasnya, kemudian jalankan perintah pemulihan di bawahnya.

##### 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"
```

##### Mengembalikan pekerjaan yang telah ada

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



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

### Inspeksi objek yang dikirim

Mengharapkan satu S3 objek URL, ukuran berkas positif dan sebuah MD5. Benda pribadi perlu Anda AWS membaca identitas. Python menyimpan direktori sukses dalam delivery-dir.txt untuk skrip selanjutnya. Bash menyimpan DELIVERY_DIR; dalam terminal baru, mengaturnya ke direktori yang dicetak.

#### Python

##### Catatan pengiriman

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


#### Bash

##### Catatan pengiriman

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



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

## 5. Verifikasi bytes sebelum menandai siap

Pemeriksaan verifikasi pada masukan asli, ember S3 dan awalan, arus objek pribadi ke disk, dan membandingkan byte terhitung dan MD5. Hanya berkas yang cocok yang menghasilkan verified/ready.json. Python membaca delivery-dir.txt; Node menggunakan DELIVERY_DIR. Baik menyerahkan permintaan FlashData.


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

### Simpan skrip verifikasi

Verifier ini menangani standar Amazon S3 objek URLs. Untuk titik akhir kustom atau penyedia lain, gunakan objek terotentikasi yang dibaca dan pertahankan tujuan yang sama, dengan menghitung dan cek checksum.

#### Python

Buat verify-media.py di samping pipeline.py dan salin kode lengkap di bawahnya. Simpan kedua berkas dalam folder butir.

##### 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

Buat verify-media.mjs di samping item.json dan salin kode lengkap di bawahnya.

##### 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)
- [Perintah GetObject AWS](https://docs.aws.amazon.com/cli/latest/reference/s3api/get-object.html)

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

### Jalankan verifikasi

Setelah menyimpan skrip, jalankan dari folder butir.

#### Python

##### Verifikasi dan baca catatan handoff

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


#### Node.js + AWS CLI

##### Verifikasi dan baca catatan handoff

```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>

### Serahkan ready.json ke aplikasi Anda

Mengharapkan Pengiriman diverifikasi dan sebuah catatan berisi run/job IDs, ember, wilayah, kunci objek, ukuran yang diverifikasi dan MD5. Ini adalah catatan aplikasi Anda, dibuat oleh script. Arsipkan dengan delivery.json (Dan pohon pisang) yang juga dikenal dengan nama pohon muz (yang bersusun-susun) buahnya mulai dari bagian atas hingga bagian bawahnya. API jendela retensi hasil.

Untuk transkripsi, indeks atau pemrosesan lainnya, lulus diverifikasi localFile kepada pekerja Anda. Untuk sebuah unduhan hadapi, lanjutkan dengan langkah 6.

- [Retensi hasil dan penyimpanan media](https://flashdata.dev/id/docs/guides/save-results/reference.md#media)

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

## 6. Berikan akses kendali aplikasi Anda

Dalam backend Anda, otorisasi pengguna dan mencari bahwa pengguna siap merekam di toko Anda sendiri. Lalu buatlah S3 yang singkat untuk diunduh URL. Gunakan tujuan yang disimpan; jangan terima sebuah ember atau kunci objek yang disediakan oleh peramban.


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

### Simpan skrip download- link

SDK menggunakan identitas pembacaan AWS di backend. Tidak. FlashData query is sent.

The URL names versi objek yang diverifikasi ketika S3 versioning menyediakan satu. Tanpa versi ID, jaga setiap kunci keluaran tak dapat diubah setelah verifikasi. Pembacaan identitas versi tertentu membutuhkan s3: GetObjectversion; pembacaan tanpa versi memerlukan s3: GetObject.

#### Python

Buat create-download-link.py di samping pipeline.py dan salin kode lengkap di bawahnya. Menggunakan paket Boto3 yang dipasang di awal.

##### 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

Instal paket penandatanganan dalam folder butir, kemudian simpan sumber di bawah sebagai create-download-link.mjs dalam folder itu.

##### Pasang klien penandatanganan 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 sebelumnya contoh URL](https://docs.aws.amazon.com/boto3/latest/guide/s3-presigned-urls.html)
- [AWS JavaScript presigned URL contoh](https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/javascript_s3_code_examples.html)
- [Akses S3 dan URL kadaluarsa](https://docs.aws.amazon.com/AmazonS3/latest/userguide/using-presigned-url.html)

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

### Kembalikan taut ke pengguna yang berwenang

Berharap access.json pribadi berisi url dan expiresInSeconds: 300. Backend Anda kembali hanya URL kepada pengguna yang berwenang. Siapapun yang memegangnya dapat mengunduh berkas hingga lima menit. Ini mungkin berakhir lebih awal dengan kredensial penandatanganan.

Buat taut baru dari catatan siap disimpan ketika pengguna selanjutnya meminta akses. Simpan kunci dan versi objek di basis data Anda, daripada menyimpan URL yang diekspor sebagai alamat aset. Contoh lokal ini berhenti jika access.json sudah ada.

#### Python

##### Buat sebuah taut lima menit

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


#### Node.js

##### Buat sebuah taut lima menit

```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>

## Mulai lagi dari tahap dikonfirmasi terakhir

| Situasi | Aksi berikutnya |
| --- | --- |
| Menerima tugas / waktu tunggu lokal habis | Ulangi runs recover dengan sama runId ke direktori percobaan yang baru. |
| Akses S3 ditolak atau terganggu pembacaan | Perbaiki AWS membaca identitas atau koneksi. Kembali ke direktori baru dan periksa lagi; simpan berkas parsial sebelumnya. |
| Jumlah byte / MD5 / tujuan tidak cocok | Berhenti. Bandingkan manifest, versi objek dan tujuan yang direncanakan sebelum menggunakan media. |
| diverifikasi / sudah ada | Baca ready.json-nya, atau periksa verifikasi-nya. Naskah tidak akan menimpanya. |
| Aplikasi download URL berakhir | Otorisasi akses lagi dan tandatangani object/version. yang tersimpan Jangan kirim download FlashData lain. |
| run_id_input_conflict | Permintaan berubah. Recover run asli; gunakan runId baru hanya untuk keluaran baru yang disengaja. |
| 401 / 403 / 402 / 429 | Perbaiki akses, perizinan, atau keseimbangan; ikuti Retry-After. Inspeksi menyimpan pekerjaan sebelum mencoba kembali pengajuan. |


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

## Terapkan tahap yang sama ke antrian

1. Mulailah dengan satu item in- penerbangan. Baca batas saat ini sebelum meningkatkan konkuensi aplikasi.
2. Pertahankan satu runId yang dapat dipertahankan untuk setiap versi video/output, dengan awalan tujuan yang berbeda. Simpan akunnya, kerja ID dan hasil akhir dalam database aplikasi Anda.
3. Persist direktori keadaan CLI melalui proses restart. Mesin-mesin terpisah perlu koordinasi aplikasi bersama; jurnal lokal tidak mendeduplikasi direktori negara independen.
4. Gunakan ready.json sebagai handoff untuk pemrosesan hilir. Menyimpan item yang gagal secara individual pengiriman yang sukses digunakan kembali.

- [Batas akun](https://flashdata.dev/id/docs/guides/usage-and-limits/reference.md)
- [Kredensial Server dan kontainer](https://flashdata.dev/id/docs/guides/production-deployment/reference.md)
- [Penjadwalan ulang tugas](https://flashdata.dev/id/docs/guides/recurring-tasks/reference.md)
