# Постройте трубопровод доставки медиа

Загрузите MP4 в частное хранилище S3, возобновите после перезагрузки и дайте вашему приложению доступ к проверенному файлу.

Каноническая ссылка: https://flashdata.dev/ru/docs/guides/media-delivery-pipeline
Разработчик: 2026-11-05 by FlashData

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

## Что вы будете строить

Один прочный элемент перемещается из видео ID в готовый к применению файл. Держите каждый этап на диске, чтобы новый процесс мог продолжаться от последнего подтвержденного результата.

### Трубопровод и сохраненные записи

```text
item.json
  Отправить сообщение Once Save Run + Job ID
  Восстановление работы delivery.json
  Проверить байты S3 media.mp4 + ready.json
  Авторизовать пользователя приложения → Краткосрочная загрузка URL
```

- [Выберите аудио, видео или клип](https://flashdata.dev/ru/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, чтобы сохранить свой журнал, и Boto3, чтобы читать S3 и подписывать ссылки. Bash, jq, Node.js и AWS CLI не нужны. Запустите команды ниже с помощью python или python3, если это ваше имя переводчика.

##### Установите зависимость 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. Установите подписывающие пакеты Node S3 в шаге 6.


- [Первая загрузка](https://flashdata.dev/ru/docs/guides/download-video-recipe/reference.md)
- [Частная настройка storage.json](https://flashdata.dev/ru/docs/guides/cli-automation/reference.md#storage)
- [Сохраненные профили](https://flashdata.dev/ru/docs/guides/cli-automation/reference.md#profiles)
- [Учетные данные Boto3 AWS](https://docs.aws.amazon.com/boto3/latest/guide/credentials.html)

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

### Сохранить настройки Runtime

Создайте папку с частными предметами вне контроля источника. Сохраните настройки для выбранного вами пути и отредактируйте абсолютные пути и имя профиля. Каждый процесс использует сохраненную учетную запись и запускает журнал. Личные данные хранятся в storage.json. Запускайте один процесс за единицу за раз.

#### 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, баланс, ставку по ТБ и лимиты. Окончательная зарядка зависит от загруженных байтов.

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

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

## 4. Восстановить запись доставки

Бег из папки товара в любом новом терминале. Восстановление ждет оригинальную работу и печатает каталог, содержащий delivery.json, run.json и квитанции. Минутный тайм-аут 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>

### Осмотрите доставленный объект

Ожидайте один объект S3 URL, положительный размер файла и 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/ru/docs/guides/save-results/reference.md#media)

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

## 6. Предоставьте вашему приложению контролируемый доступ

В вашем бэкэнде авторизуйте пользователя и посмотрите готовую запись этого пользователя в своем собственном магазине. Затем создайте короткоживущий S3 скачать URL. Используйте сохраненный пункт назначения; не принимайте ведро или ключ объекта, предоставленный браузером.


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

### Сохранить скрипт download-link

SDK использует идентификатор чтения бэкэнда AWS. Запрос FlashData не отправляется.

URL именует верифицированную объектную версию, когда она предоставляется в версии S3. Без версии ID, сохраняйте каждый выходной ключ неизменным после проверки. Идентификационное чтение конкретной версии требует s3:GetObjectVersion; неверсированное чтение требует s3:GetObject.

#### 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 | Исправьте доступ, разрешения или баланс; следуйте Retry-After. Проверить сохраненную работу, прежде чем повторно подавать заявку. |


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

## Применять одни и те же этапы к очереди

1. Начните с одного элемента в полете. Прочитайте текущие ограничения перед увеличением параллелизма приложений.
2. Держите один прочный runId для каждой версии video/output с отдельным префиксом назначения. Храните учетную запись, работу ID и конечный результат в базе данных приложений.
3. Сохраняйте каталог состояния CLI при перезапуске процесса. Отдельные машины нуждаются в совместной координации приложений; местный журнал не дублирует независимые государственные каталоги.
4. Используйте ready.json в качестве передачи для последующей обработки. Сохраняйте неисправные предметы по отдельности, поэтому успешные поставки используются повторно.

- [Ограничения по счетам](https://flashdata.dev/ru/docs/guides/usage-and-limits/reference.md)
- [Серверные и контейнерные учетные данные](https://flashdata.dev/ru/docs/guides/production-deployment/reference.md)
- [Планирование повторяющихся задач](https://flashdata.dev/ru/docs/guides/recurring-tasks/reference.md)
