Sfoglia la documentazione
Guide
Scarica un MP4 per lo storage privato S3, riprendi dopo un riavvio e dia l'accesso all'applicazione al file verificato.
In questa pagina
Che cosa costruirete
Un elemento durevole si sposta da un video ID a un file pronto per l'applicazione. Tenere ogni fase sul disco in modo che un nuovo processo possa continuare dall'ultimo risultato confermato.
item.json
→ inviare una volta → run + job salvato ID
→ recuperare il lavoro → delivery.json
→ verificare S3 byte → media.mp4 + ready.json
→ autorizzare l'utente di app → download di breve durata URLPrima di iniziare
Scegli un percorso di esempio per tutti e sei i passaggi. Entrambi utilizzano un installato FlashData CLI con un profilo proprietario salvato e youtube_download permesso, privato S3 storage.json per gli upload, e un'identità AWS che può leggere l'oggetto consegnato.
Usa Python 3.10+ nel tuo ambiente Python. Gli script chiamano CLI per preservare il suo diario di esecuzione, e Boto3 per leggere S3 e firmare i link. Bash, jq, Node.js e AWS CLI non sono necessari. Eseguire i comandi qui sotto con pitone, o python3 se questo è il tuo nome interprete.
python --version
flashdata --version
python -m pip install boto3Installare Bash, jq, Node.js 22+ e AWS CLI v2. Su Windows, eseguire i comandi Bash in Git Bash. Installare i pacchetti di firma Node S3 nella fase 6.
Salvare le impostazioni di runtime
Creare una cartella di oggetti privata al di fuori del controllo sorgente. Salvare le impostazioni per il percorso scelto e modificare i percorsi assoluti e il nome del profilo. Ogni processo utilizza l'account salvato ed esegue il diario. Le credenziali di archiviazione rimangono in privato storage.json. Eseguire un processo per articolo alla volta.
Salva pipeline.json. Su Windows, i percorsi in avanti come il lavoro C:/private/flashdata-state in 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. Salvare un elemento durevole
Salva item.json in quella cartella. Sostituire il video e la destinazione S3; questo esempio richiede un MP4 fino a 720p. Tenere il suo runId per i retries. Un'uscita pianificata diversa ha bisogno di un nuovo prefisso runId e oggetto.
{
"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. Salvare lo script e controllare l'accesso
Creare il file qui sotto prima di eseguire i controlli. convalida la destinazione S3 e mantiene una ricevuta per ogni tentativo di presentazione.
Creare lo script pipeline
Creare pipeline.py nella stessa cartella di pipeline.json e item.json. Copia il codice completo qui sotto in quel file e salvalo. Lo riuserà per i controlli, la presentazione e il recupero nei passaggi 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)Creare request-media.sh nella stessa cartella di pipeline.env e item.json. Copia il codice completo qui sotto in quel file e salvalo.
#!/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"
fiControlla il tuo account salvato
Eseguire questo controllo gratuito dalla cartella dell'elemento dopo aver salvato lo script. L'accesso del proprietario mancante o il permesso youtube_download blocca l'assegno. Confermare l'account ID, l'equilibrio, il tasso per-TB e i limiti. L'addebito finale dipende da byte caricate.
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-interactiveConvalida senza download
Dopo aver salvato l'aiutante, eseguire la sua corsa a secco. Python stampa ok: true e dryRun: true; Bash stampa true. Questo convalida l'ingresso e l'accesso senza inviare il lavoro dei media o riservare i crediti.
python pipeline.py dry-runset -euo pipefail
bash request-media.sh dry-run | jq -e '.ok and .data.dryRun'3. Inviare e mantenere il lavoro ID
Questo presenta un download di sfondo pagato. Aspettatevi status: accepted e jobId in pista locale. Mantenere il profilo, la directory di stato e item.json per il recupero. Il supporto è pronto solo dopo passo 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}'Se la corsa è già salvata o incerta
| Stato di CLI | Azione |
|---|---|
| accepted + jobId | Recuperare questo funzionamento nel passo 4. Mantenere il lavoro ID se il processo si ferma. |
| succeeded | Recover/export la sua risposta salvata, quindi verifica lo storage. Non inviare un nuovo articolo. |
| Risultato sconosciuto / nessun lavoro confermato ID | Mantenere la corsa, la ricevuta e l'errore. Ispezionare History o il candidato IDs prima di decidere su un'altra presentazione. |
4. Recuperare il record di consegna
Eseguire dalla cartella dell'elemento in qualsiasi nuovo terminale. Recovery aspetta il lavoro originale e stampa una directory contenente delivery.json, run.json e ricevute. Un timeout 10-minute ferma l'attesa locale; ripeti il recupero per riprendere lo stesso lavoro.
Riprendi il lavoro salvato
Riutilizzare pipeline.py salvato nella fase 2. Non è necessario alcun script aggiuntivo.
python pipeline.py recoverPrima di creare recover-media.sh accanto a item.json e incollare nel codice qui sotto. Salvare il file, quindi eseguire il comando di recupero sotto di esso.
#!/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"Ispezione dell'oggetto consegnato
Aspettatevi un oggetto S3 URL, una dimensione di file positiva e una MD5. Gli oggetti privati hanno bisogno della tua identità di lettura AWS. Python salva la directory di successo in delivery-dir.txt per gli script successivi. Bash mantiene DELIVERY_DIR; in un nuovo terminale, impostalo sulla directory stampata.
python pipeline.py deliveryjq '{status, file: .results[0], usage}' "$DELIVERY_DIR/delivery.json"5. Verificare i byte prima di marcare pronto
Il verificatore controlla l'ingresso originale, il secchio e il prefisso S3, trasmette l'oggetto privato al disco e confronta il suo conteggio byte e MD5. Solo i file corrispondenti producono verified/ready.json. Python legge delivery-dir.txt; Node utilizza DELIVERY_DIR. Né presenta una query FlashData.
Salvare lo script di verifica
Questo verificatore gestisce standard Amazon S3 oggetto URLs. Per i endpoint personalizzati o un altro fornitore, utilizzare il suo oggetto autenticato leggere e mantenere la stessa destinazione, byte-count e controlli di checksum.
Creare verify-media.py accanto a pipeline.py e copiare il codice completo qui sotto. Salvare entrambi i file nella cartella dell'elemento.
# 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)Creare verify-media.mjs accanto a item.json e copiare il codice completo qui sotto.
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;
}Eseguire la verifica
Dopo aver salvato lo script, eseguirlo dalla cartella dell'elemento.
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"Consegna ready.json alla tua applicazione
Consegna prevista verificata e un record contenente run/job IDs, secchio, regione, chiave dell'oggetto, dimensione verificata e MD5. Questo è il record della tua applicazione, creato dallo script. Archiviarlo con delivery.json e l'elemento originale; sopravvive alla finestra di ritenzione del risultato API.
Per la trascrizione, l'indicizzazione o altri trattamenti, passare il localFile verificato al vostro lavoratore. Per un download rivolto all'utente, continuare con passo 6.
6. Fornisci l'accesso controllato alle applicazioni
Nel tuo backend, autorizza l'utente e cerca il record pronto dell'utente nel tuo negozio. Quindi creare un S3 di breve durata scaricare URL. Utilizzare la destinazione salvata; non accettare un secchio o un oggetto chiave fornita dal browser.
Salvare lo script download-link
SDK utilizza l'identità di lettura di AWS del backend. Nessuna query FlashData viene inviata.
La versione URL nomina la versione dell'oggetto verificata quando la versione S3 fornisce una. Senza una versione ID, mantenere ogni chiave di uscita immutabile dopo la verifica. Un'identità che legge una versione specifica ha bisogno s3: GetObjectVersion; una lettura inversione ha bisogno s3: GetObject.
Creare create-download-link.py accanto a pipeline.py e copiare il codice completo qui sotto. Utilizza il pacchetto Boto3 installato all'inizio.
# 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)Installare i pacchetti di firma nella cartella dell'elemento, quindi salvare la fonte qui sotto come create-download-link.mjs in quella cartella.
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;
}Restituisce il link all'utente autorizzato
Aspettatevi un access.json privato contenente url e expiresInSeconds: 300. Il tuo backend restituisce solo lo URL all'utente autorizzato. Chiunque lo trattiene può scaricare il file fino a cinque minuti; può scadere prima con le credenziali di firma.
Creare un nuovo link dal record pronto salvato quando l'utente successivo richiede l'accesso. Mantenere la chiave dell'oggetto e la versione nel database, piuttosto che memorizzare l'indirizzo di attività di scadenza URL. Questo esempio locale si ferma se access.json esiste già.
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"
)Riavviare dall'ultima fase confermata
| Situazione | Prossima azione |
|---|---|
| Lavoro accettato / locale aspettare tempo fuori | Ripetere runs recover con lo stesso runId in una directory di tentativo fresco. |
| accesso S3 negato o interrotto letto | Fissare l'identità o la connessione di lettura AWS. Recuperare a una directory fresca e verificare di nuovo; mantenere il file parziale precedente. |
| Conto byte / MD5 / errore di destinazione | Smettila. Confrontare la versione di manifesto, oggetto e destinazione pianificata prima di utilizzare i media. |
| verificato/già esistente | Leggere la sua ready.json, o ispezionare la sua verifica incompleta. Lo script non lo sovrascriverà. |
| Scarica l'applicazione URL scaduto | Autorizzare l'accesso di nuovo e firmare il object/version. salvato Non inviare un altro FlashData download. |
| run_id_input_conflict | La richiesta è cambiata. Recuperare l'esecuzione originale; utilizzare una nuova runId solo per una nuova uscita intenzionale. |
| 401 / 403 / 402 / 429 | Fissare l'accesso, le autorizzazioni o l'equilibrio; seguire Retry-After. Ispezione del lavoro salvato prima di riprovare una presentazione. |
Applicare le stesse fasi di una coda
- Iniziare con un elemento in volo. Leggere i limiti attuali prima di aumentare la convalutazione delle applicazioni.
- Mantenere uno runId durevole per ogni versione video/output, con un prefisso di destinazione distinto. Conservare l'account, lavorare ID e l'esito finale nel database delle applicazioni.
- Persistere la directory di stato CLI attraverso riavviamenti di processo. Le macchine separate hanno bisogno di un coordinamento delle applicazioni condiviso; una rivista locale non deduplica le directory statali indipendenti.
- Utilizzare ready.json come handoff per l'elaborazione a valle. Mantenere oggetti falliti singolarmente così le consegne di successo sono riutilizzati.