Przeglądaj dokumentację
Poradniki
Pobierz MP4 do prywatnej pamięci S3, wznowić po ponownym uruchomieniu i dać aplikacji dostęp do zweryfikowanego pliku.
Na tej stronie
Co zbudujesz
Jeden trwały element przenosi się z wideo ID do pliku applation- ready. Zachować każdy etap na dysku, aby nowy proces mógł być kontynuowany od ostatniego potwierdzonego wyniku.
item.json
→ złożyć raz → zapisane uruchomić + zadanie ID
→ odzyskać pracę → delivery.json
→ weryfikuj bajty S3 → media.mp4 + ready.json
→ autoryzuj użytkownika aplikacji → short- live download URLZanim zaczniesz
Wybierz jedną ścieżkę przykładową dla wszystkich sześciu kroków. Oba używać zainstalowany FlashData CLI z zapisanym profilem właściciela i zezwolenia youtube_download, prywatny S3 storage.json do wysyłania i AWS tożsamości, które mogą odczytać dostarczony obiekt.
Użyj Python 3.10 + w środowisku Python. Skrypty wzywają CLI do zachowania dziennika pracy, a Boto3 do odczytu S3 i podpisania linków. Bash, jq, Node.js i AWS CLI nie są potrzebne. Uruchom poniższe polecenia pythonem lub python3, jeśli jest to nazwa tłumacza.
python --version
flashdata --version
python -m pip install boto3Zainstaluj Bash, jq, Node.js 22 + i AWS CLI v2. Na Windows uruchom polecenia Bash w Git Bash. Zainstaluj pakiety podpisywania węzła S3 w kroku 6.
Zapisz ustawienia runtime
Utwórz prywatny folder elementów poza kontrolą źródła. Zapisz ustawienia dla wybranej ścieżki i edytuj ścieżki bezwzględne i nazwę profilu. Każdy proces używa zapisanego konta i uruchamia dziennik. Zapisy pamięci w prywatnych storage.json. Uruchom jeden proces na element na raz.
Zapisz pipeline.json. Na Windows, forward- slash ścieżki takie jak C: /private/flashdata-state pracy w JSON.
{
"stateDir": "/absolute/path/to/flashdata-state",
"storageConfig": "/absolute/path/to/private/storage.json",
"profile": "default"
}# 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_KEY1. Zapisz jeden trwały element
Zapisz item.json w tym folderze. Zastąp wideo i cel S3; ten przykład wymaga jednego MP4 do 720p. Zachowaj runId na powtórki. Inne planowane wyjście wymaga nowego prefiksu runId i obiektu.
{
"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"
}
}2. Zapisz skrypt i sprawdź dostęp
Utwórz plik poniżej przed uruchomieniem kontroli. Potwierdza on cel S3 i zachowuje paragon dla każdej próby złożenia.
Utwórz skrypt rurociągu
Utwórz pipeline.py w tym samym folderze co pipeline.json i item.json. Skopiuj cały kod poniżej do tego pliku i zapisz go. Użyjesz go do kontroli, składania i odzyskiwania w etapach 2–4.
# 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)Utwórz request-media.sh w tym samym folderze co pipeline.env i item.json. Skopiuj cały kod poniżej do tego pliku i zapisz go.
#!/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"
fiSprawdź zapisane konto
Uruchom ten bezpłatny czek z folderu elementu po zapisaniu skryptu. Zaginiony dostęp właściciela lub pozwolenie youtube_download zatrzymuje czek. Potwierdź konto ID, saldo, wskaźnik przerobu TB i limity. Ostateczna opłata zależy od wczytanych bajtów.
python pipeline.py checkset -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-interactiveSprawdzić bez pobierania
Po uratowaniu pomocnika, uruchom jego suchy bieg. Python drukuje ok: true i dryRun: true; Bash drukuje true. Potwierdza to wejście i dostęp bez składania pracy mediów lub rezerwowania kredytów.
python pipeline.py dry-runset -euo pipefail
bash request-media.sh dry-run | jq -e '.ok and .data.dryRun'3. Prześlij i zachowaj zadanie ID
To przedstawia jeden płatny pobór tła. Oczekuj status: accepted i jobId w lokalnym biegu. Zachowaj profil, katalog stanu i item.json do odzyskania. Media są gotowe dopiero po kroku 5.
python pipeline.py submitpython pipeline.py inspectbash request-media.sh submitset -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}'Jeśli bieg jest już zapisany lub niepewny
| Stan CLI | Działanie |
|---|---|
| accepted + jobId | Odzyskać ten bieg w kroku 4. Zatrzymaj zadanie ID, jeśli proces się zatrzyma. |
| succeeded | Recover/export jego zapisaną odpowiedź, a następnie zweryfikować przechowywanie. Nie należy składać nowego elementu. |
| Nieznany wynik / brak potwierdzonej pracy ID | Utrzymuj bieg, odbiór i błąd. Przed podjęciem decyzji o innym złożeniu należy sprawdzić History lub kandydata IDs. |
4. Odzyskiwanie zapisów dostawy
Uruchom z folderu elementów w dowolnym nowym terminalu. Odzysk czeka na oryginalne zadanie i drukuje katalog zawierający delivery.json, run.json i paragony. 10- minute timeout zatrzymuje lokalne oczekiwanie; powtórne odzyskanie, aby wznowić to samo zadanie.
Wznowienie uratowanej pracy
Ponowne użycie pipeline.py zapisanego w kroku 2. Nie jest potrzebny dodatkowy skrypt.
python pipeline.py recoverNajpierw utwórz recover-media.sh obok item.json i wklej kod poniżej. Zapisz plik, a następnie uruchom polecenie odzyskiwania pod nim.
#!/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"set -euo pipefail
DELIVERY_DIR=$(bash recover-media.sh)
printf 'Delivery files: %s\n' "$DELIVERY_DIR"Sprawdź dostarczony obiekt
Oczekuj jednego obiektu S3 URL, dodatniego rozmiaru pliku i MD5. Prywatne obiekty potrzebują twojej tożsamości AWS. Python zapisuje udany katalog w delivery-dir.txt dla późniejszych skryptów. Bash zachowuje DELIVERY_DIR; w nowym terminalu ustaw go na drukowany katalog.
python pipeline.py deliveryjq '{status, file: .results[0], usage}' "$DELIVERY_DIR/delivery.json"5. Weryfikacja bajtów przed oznakowaniem gotowym
Weryfikator sprawdza oryginalne wejście, wiadro S3 i przedrostek, strumieniuje obiekt prywatny na dysk i porównuje jego liczbę bajtów i MD5. Tylko pasujące pliki produkują verified/ready.json. Python czyta delivery-dir.txt; Węzeł wykorzystuje DELIVERY_DIR. Ani nie składa zapytania FlashData.
Zapisz skrypt weryfikacji
Ten weryfikator obsługuje standardowy obiekt Amazon S3 URLs. W przypadku niestandardowych punktów końcowych lub innego dostawcy, użyj jego uwierzytelnionego obiektu przeczytaj i zachowaj to samo miejsce docelowe, licznik bajkowy i kontrole sumy kontrolnej.
Utwórz verify-media.py obok pipeline.py i skopiuj do niego cały kod poniżej. Zapisz oba pliki w folderze elementów.
# 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)Utwórz verify-media.mjs obok item.json i skopiuj do niego cały kod poniżej.
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;
}Uruchom weryfikację
Po zapisaniu skryptu, uruchom go z folderu elementu.
python verify-media.pyset -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"Rozdaj ready.json do aplikacji
Oczekiwanie Dostawa zweryfikowany i rekord zawierający run/job IDs, wiadro, region, klucz obiektu, zweryfikowany rozmiar i MD5. To jest rekord twojej aplikacji, stworzony przez skrypt. Archiwizuj go za pomocą delivery.json i oryginalnego elementu; przetrwa okno retencyjne wyniku API.
Do transkrypcji, indeksowania lub innego przetwarzania, przekazać zweryfikowany localFile do pracownika. Dla użytkownika do pobrania, kontynuuj krok 6.
6. Daj dostęp kontrolowany aplikacji
W swoim tle, autoryzuj użytkownika i sprawdź, że użytkownik jest gotowy rekord w swoim sklepie. Następnie utworzyć krótko żywą S3 pobierz URL. Użyj zapisanego miejsca docelowego; nie akceptuj kubełka lub klucza obiektu dostarczonego przez przeglądarkę.
Zapisz skrypt download- link
SDK używa odczytu AWS. Nie wysyła się zapytania FlashData.
URL określa zweryfikowaną wersję obiektu, kiedy jest to wersja z wersją S3. Bez wersji ID, po weryfikacji zachować każdy klucz wyjściowy niezmienny. Tożsamość odczytująca konkretną wersję wymaga s3: GetObjectVersion; niemodyfikowane potrzeby odczytu s3: GetObject.
Utwórz create-download-link.py obok pipeline.py i skopiuj do niego cały kod poniżej. Wykorzystuje pakiet Boto3 zainstalowany na początku.
# 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)Zainstaluj pakiety podpisywania w folderze elementów, a następnie zapisz źródło poniżej jako create-download-link.mjs w tym folderze.
test -f package.json || npm init -y
npm install @aws-sdk/client-s3 @aws-sdk/s3-request-presigner// 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;
}Zwróć link do autoryzowanego użytkownika
Oczekuj prywatnego access.json zawierającego url i expiresInSeconds: 300. Twój backend zwraca tylko URL do autoryzowanego użytkownika. Każdy, kto go posiada, może pobrać plik na okres do pięciu minut; może on wygasnąć wcześniej wraz z podpisem.
Utwórz nowy link z zapisanego, gotowego rekordu, gdy użytkownik następny żąda dostępu. Zatrzymaj klucz obiektu i jego wersję w bazie danych, zamiast przechowywać wygasające URL jako adres aktywów. Ten lokalny przykład zatrzymuje się, jeśli access.json już istnieje.
python create-download-link.py(
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"
)Wznawiaj z ostatniego potwierdzonego etapu
| Sytuacja | Następna akcja |
|---|---|
| Zaakceptowana praca / lokalne oczekiwanie w czasie | Powtórzyć runs recover z tym samym runId do nowego katalogu prób. |
| Odmowa lub przerwanie dostępu do S3 | Napraw AWS odczytuje tożsamość lub połączenie. Odzyskiwanie do nowego katalogu i weryfikacja ponownie; zachować poprzedni plik częściowy. |
| Liczba bajtów / MD5 / niedopasowanie miejsca przeznaczenia | Przestań. Porównaj manifest, wersję obiektu i planowany cel przed użyciem mediów. |
| zweryfikowane / już istnieje | Przeczytaj ready.json lub sprawdź jego niekompletną weryfikację. Skrypt nie nadpisze tego. |
| Pobieranie aplikacji URL wygasło | Autoryzacja dostępu ponownie i podpisać zapisane object/version. Nie należy wysyłać kolejnego pobrania FlashData. |
| run_id_input_conflict | Wniosek się zmienił. Odzyskiwanie oryginalnego przebiegu; użycie nowego runId tylko dla zamierzonego nowego wyjścia. |
| 401 / 403 / 402 / 429 | Popraw dostęp, uprawnienia lub równowagę; postępuj zgodnie z Retry-After. Sprawdzić zapisane pracy przed ponownym próbami złożenia. |
Zastosuj te same etapy do kolejki
- Zacznij od jednej pozycji w locie. Przeczytaj aktualne limity przed zwiększeniem współzależności aplikacji.
- Dla każdej wersji video/output należy zachować jeden trwały prefiks runId, z odrębnym przedrostkiem docelowym. Zapisz konto, zadanie ID i wynik końcowy w bazie danych aplikacji.
- Persist katalog stanu CLI w całym procesie restartuje. Oddzielne maszyny wymagają wspólnej koordynacji aplikacji; lokalny dziennik nie dedukuje niezależnych katalogów państwowych.
- Używać ready.json jako przekazania do dalszego przetwarzania. Utrzymanie nieudanych elementów indywidualnie, tak aby udane dostawy były ponownie wykorzystywane.