# メディア配信パイプラインの構築

MP4をプライベートS3ストレージにダウンロードし、再起動後に再開し、確認されたファイルへのアプリケーションアクセスを与えます。

キャニシニカル参照: https://flashdata.dev/ja/docs/guides/media-delivery-pipeline
レビュー: FlashData による 2026-11-05

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

## ビルドする

耐久性のあるアイテムは、IDからアプリケーション対応のファイルに移動します。 各ステージをディスクに保存することで、最終確認結果から新しいプロセスが続行できます。

### パイプラインと保存されたレコード

```text
item.jsonの特長
  → 一度送信 → 保存実行 + ジョブ ID
  → ジョブを回復 → delivery.json
  → S3バイト → media.mp4 + ready.json
  → アプリのユーザーを承認 → 短命ダウンロード URL
```

- [オーディオ、ビデオ、クリップを選択します。](https://flashdata.dev/ja/docs/guides/youtube-download-guide/reference.md#formats)

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

### はじめる前に

6つのステップで1つの例のパスを選択します。 FlashData CLIは、保存された所有者プロファイルとyoutube_downloadのパーミッション、アップロード用のプライベートS3 storage.json、および配信されたオブジェクトを読むことができるAWS IDを使用します。

#### Python

Python 3.10+をPython環境で使用して下さい。 スクリプトは、CLI を呼び出して、実行ジャーナルを保存し、Bto3 は S3 を読み込み、リンクを署名します。 Bash、jq、Node.js、AWS CLIは必要ありません。 python で以下のコマンドを実行するか、 python3 は、通訳者名である場合は python3 を実行します。

##### Pythonの依存性をインストール

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


#### Bash / Node.js

インストール Bash, jq, Node.js 22+とAWS CLI v2. . Windows では、Git Bash で Bash コマンドを実行します。 ノードをインストール S3 ステップでパッケージを署名する 6.


- [初回ダウンロード](https://flashdata.dev/ja/docs/guides/download-video-recipe/reference.md)
- [プライベートstorage.jsonセットアップ](https://flashdata.dev/ja/docs/guides/cli-automation/reference.md#storage)
- [保存されたプロファイル](https://flashdata.dev/ja/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つの項目ごとの1つのプロセスを実行して下さい。

#### Python

pipeline.json を保存します。 Windowsでは、JSONでのC:/private/flashdata-state作業などのフォワードスラッシュパス。

##### 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. 1つの耐久性のあるアイテムを保存

そのフォルダにitem.jsonを保存します。 ビデオとS3の宛先を置き換えます。 この例では、最大720pでMP4をリクエストします。 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.jsonとitem.jsonと同じフォルダにpipeline.pyを作成します。 下のコードをコピーして保存します。 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

pipeline.envとitem.jsonと同じフォルダにrequest-media.shを作成します。 下のコードをコピーして保存します。

##### 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、残高、1TB当たりのレートと制限を確認します。 最終手数料はアップロードされたバイトによって異なります。

#### 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/ja/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/ja/docs/guides/agent-recovery/reference.md)

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

## 4. 配達記録を回復して下さい

任意の新しいターミナルの項目フォルダから実行します。 復元は、元のジョブを待って、delivery.json、run.json、レシートを含むディレクトリを印刷します。 10-minuteのタイムアウトはローカルの待機を停止します;同じ仕事を再開するために回復を繰り返して下さい。


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

### 保存したジョブを再開

#### Python

リユース pipeline.py ステップで保存 2. 追加のスクリプトは必要ありません。

##### 既存のジョブを回復する · 新規投稿なし

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


#### Bash

まずは、item.jsonの横にあるrecover-media.shを作成し、以下のコードに貼り付けます。 ファイルを保存し、回復コマンドを実行します。

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

### 納品されたオブジェクトの特定

S3オブジェクトURL、正なファイルサイズ、MD5を期待してください。 プライベートオブジェクトは、AWS の読み取り ID が必要です。 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を読みました; NodeはDELIVERY_DIRを使用します。 FlashData クエリを提出する。


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

### 検証スクリプトを保存

この頂点は標準のAmazon S3オブジェクトURLsを扱います。 カスタムエンドポイントまたは別のプロバイダーでは、認証されたオブジェクトを読み取り、同じ宛先、バイトカウント、チェックサムチェックを保持します。

#### Python

pipeline.pyの横にあるverify-media.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

item.jsonの横にあるverify-media.mjsを作成し、以下の完全なコードをコピーします。

##### 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/ja/docs/guides/save-results/reference.md#media)

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

## 6. アプリケーション管理されたアクセスを与える

バックエンドでは、ユーザを承認し、自分のストアでユーザーの既定のレコードを調べます。 その後、短命のS3のダウンロードURLを作成します。 保存先を使用して下さい。ブラウザが供給する Bucket や object キーは受け付けません。


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

### ダウンロードリンクスクリプトを保存

SDK はバックエンドの AWS 読み取り ID を使用します。 FlashDataのクエリは送信されません。

URL は、S3 のバージョンアップ時に検証されたオブジェクトバージョンの名前を 1 つ付けます。 バージョンIDがなければ、各出力キーのimmutableを点検の後で保って下さい。 特定のバージョンを読み込みる ID は s3:GetObjectVersion が必要です。 未バージョンの読み込みには s3:GetObject が必要です。

#### Python

pipeline.pyの横にあるcreate-download-link.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のみを認証されたユーザーに返します。 ファイルを最大5分間ダウンロードすることができます。 署名の資格情報で以前の期限が切れる可能性があります。

ユーザの次のリクエストアクセス時に保存された既定のレコードから新しいリンクを作成します。 URLをアセットアドレスとして拡張するのではなく、オブジェクトキーとバージョンをデータベースに保存します。 access.json が既に存在していると、このローカルの例は止まります。

#### Python

##### 5分のリンクを作成

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


#### Node.js

##### 5分のリンクを作成

```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 の読み取り ID または接続を修正します。 新規ディレクトリに復元し、再度確認します。以前の部分的なファイルを保持します。 |
| バイト数 / MD5 / 目的地の不一致 | ストップ。 メディアを使用する前に、マニフェスト、オブジェクトバージョン、および計画された目的地を比較します。 |
| 検証済み/既に存在する | ready.json を読んで、または不完全な検証を検査してください。 スクリプトは上書きしません。 |
| アプリケーションのダウンロード URL 期限切れ | アクセスを再度承認し、保存されたobject/version.に署名して下さい 別のFlashDataのダウンロードを提出しないでください。 |
| run_id_input_conflict | リクエストが変更されました。 元の実行を回復する。意図的な新しい出力のためにだけ新しいrunIdを使用して下さい。 |
| 401 / 403 / 402 / 429 | アクセス、アクセス許可、残高の修正、Retry-Afterのフォロー 投稿を再試行する前に保存した作業を点検します。 |


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

## 同じステージをキューに入れる

1. 1つの機内アイテムから始めましょう。 アプリケーションの通貨を増やす前に、現在の制限値を読みます。
2. video/outputバージョンごとに耐久性のあるrunIdを1つ保存し、異なる宛先プレフィックスで保存します。 アプリケーションデータベースのアカウント、ジョブID、最終結果を保存します。
3. プロセスの再起動を渡る CLI 状態のディレクトリを永続化します。 別々のマシンは、共有アプリケーション協調を必要としています。ローカルランジャーナルは独立した州のディレクトリを複製しません。
4. ready.jsonは、下流処理へのハンドオフとして使用します。 失敗したアイテムを個々に保持し、配送が成功する。

- [口座の制限](https://flashdata.dev/ja/docs/guides/usage-and-limits/reference.md)
- [サーバーとコンテナの認証情報](https://flashdata.dev/ja/docs/guides/production-deployment/reference.md)
- [タスクのスケジューリングの再発](https://flashdata.dev/ja/docs/guides/recurring-tasks/reference.md)
