Documentatie bekijken
Handleidingen
Download een MP4 naar privé S3 opslag, hervat na een herstart en geef uw applicatie toegang tot het geverifieerde bestand.
Op deze pagina
Wat je zult bouwen
Een duurzaam item verplaatst van een video ID naar een toepassing-ready bestand. Houd elke fase op de schijf zodat een nieuw proces kan doorgaan vanaf het laatst bevestigde resultaat.
item.json
→ een keer indienen → opgeslagen run + taak ID
→ herstel de taak → delivery.json
→ Controleer S3 bytes → media.mp4 + ready.json
→ machtiging app gebruiker → korte levensduur downloaden URLVoordat u begint
Kies één voorbeeldpad voor alle zes de stappen. Beiden gebruiken een geïnstalleerde FlashData CLI met een opgeslagen eigenaarsprofiel en youtube_download toestemming, privé S3 storage.json voor uploads, en een AWS identiteit die het geleverde object kan lezen.
Gebruik Python 3.10+ in uw Python omgeving. De scripts noemen de CLI om zijn run journal te behouden, en Boto3 om S3 te lezen en links te ondertekenen. Bash, jq, Node.js en AWS CLI zijn niet nodig. Voer de onderstaande commando's uit met python, of python3 als dat je tolknaam is.
python --version
flashdata --version
python -m pip install boto3Installeer Bash, jq, Node.js 22+ en AWS CLI v2. Op Windows, voer Bash commando's uit in Git Bash. Installeer de Node S3 ondertekening pakketten in stap 6.
De runtime-instellingen opslaan
Een privé-itemmap maken buiten de broncode. Sla de instellingen op voor het gekozen pad en bewerk de absolute paden en profielnaam. Elk proces maakt gebruik van dat opgeslagen account en draait journaal. Opslaggegevens blijven in privé storage.json. Eén proces per item tegelijk uitvoeren.
Opslaan pipeline.json. Op Windows werken vooruitstrevende paden zoals 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. Bewaar één duurzaam item
Bewaar item.json in die map. Vervang de video en S3 bestemming; dit voorbeeld vraagt om een MP4 op maximaal 720p. Houd zijn runId voor herhalingen. Een andere geplande uitvoer heeft een nieuwe runId en objectprefix nodig.
{
"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. Het script opslaan en toegang controleren
Maak het onderstaande bestand aan voordat u de controles uitvoert. Het valideert de S3 bestemming en houdt een ontvangstbewijs bij voor elke poging tot indienen.
Het pipeline-script aanmaken
Maak pipeline.py in dezelfde map als pipeline.json en item.json. Kopieer de volledige code hieronder in dat bestand en sla het op. U gebruikt het voor controles, indiening en herstel in stappen 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)Maak request-media.sh in dezelfde map als pipeline.env en item.json. Kopieer de volledige code hieronder in dat bestand en sla het op.
#!/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"
fiControleer uw opgeslagen account
Voer deze gratis controle uit uit de item map na het opslaan van het script. Ontbrekende eigenaar toegang of youtube_download toestemming stopt de controle. Bevestig de rekening ID, balans, per-TB-snelheid en limieten. De uiteindelijke lading hangt af van geüploade bytes.
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-interactiveValideren zonder download
Na het redden van de helper, lopen zijn droge loop. Python print ok: true en dryRun: true; Bash print true. Dit valideert input en toegang zonder het indienen van mediawerk of het reserveren van credits.
python pipeline.py dry-runset -euo pipefail
bash request-media.sh dry-run | jq -e '.ok and .data.dryRun'3. De taak ID indienen en behouden
Dit geeft een betaalde achtergrond download. Verwacht status: accepted en een jobId in de lokale run. Houd het profiel, de status directory en item.json voor herstel. De media is pas klaar na stap 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}'Als de run al opgeslagen of onzeker is
| CLI-status | Actie |
|---|---|
| accepted + jobId | Herstel deze run in stap 4. Houd de taak ID als het proces stopt. |
| succeeded | Recover/export de opgeslagen respons, controleer dan de opslag. Geen nieuw item indienen. |
| Onbekend resultaat / geen bevestigde taak ID | Hou de loop, ontvangst en fout. Inspecteer History of kandidaat IDs voordat u beslist over een andere indiening. |
4. Terughalen van de levering record
Uitvoeren vanuit de itemmap in elke nieuwe terminal. Herstel wacht op de oorspronkelijke taak en print een directory met delivery.json, run.json en ontvangsten. Een 10-minute timeout stopt het lokale wachten; herhaal herstel om dezelfde baan te hervatten.
De bewaarde taak hervatten
Hergebruik pipeline.py opgeslagen in stap 2. Er is geen extra script nodig.
python pipeline.py recoverMaak eerst recover-media.sh naast item.json en plak in de onderstaande code. Sla het bestand op en voer het herstel commando eronder uit.
#!/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"Controleer het geleverde object
Verwacht één S3 object URL, een positieve bestandsgrootte en een MD5. Privé-objecten hebben uw AWS leesidentiteit nodig. Python slaat de succesvolle directory in delivery-dir.txt op voor latere scripts. Bash houdt DELIVERY_DIR; in een nieuwe terminal, zet het op de gedrukte map.
python pipeline.py deliveryjq '{status, file: .results[0], usage}' "$DELIVERY_DIR/delivery.json"5. Verifieer bytes voordat u klaar bent
De verificateur controleert de oorspronkelijke invoer, S3 emmer en voorvoegsel, stroomt het privé-object naar de schijf, en vergelijkt de bytetelling en MD5. Alleen overeenkomende bestanden produceren verified/ready.json. Python leest delivery-dir.txt; Node gebruikt DELIVERY_DIR. Geen van beide dient een FlashData query in.
Het verificatiescript opslaan
Deze verificateur behandelt standaard Amazon S3 object URLs. Voor aangepaste eindpunten of een andere provider, gebruik de geauthentiseerde object gelezen en behouden dezelfde bestemming, byte-telling en controles van het controlesom.
Maak verify-media.py naast pipeline.py en kopieer de volledige code hieronder in het. Sla beide bestanden op in de itemmap.
# 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)Maak verify-media.mjs naast item.json en kopieer de volledige code hieronder in het.
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;
}Voer de verificatie uit
Na het opslaan van het script, voer het uit vanuit de item map.
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"Laat ready.json aan uw toepassing over
Verwacht Levering geverifieerd en een record met de run/job IDs, emmer, regio, objectsleutel, geverifieerde grootte en MD5. Dit is uw applicaties record, gemaakt door het script. Archiveer het met delivery.json en het originele item; het overleeft het API resultaat.
Voor transcriptie, indexering of andere verwerking, geef de geverifieerde localFile door aan uw werknemer. Voor een gebruikersgerichte download, ga verder met stap 6.
6. Geef uw toepassing gecontroleerde toegang
In uw backend, machtiging van de gebruiker en opzoeken die gebruiker staat klaar record in uw eigen winkel. Maak dan een kortlevende S3 download URL. Gebruik de opgeslagen bestemming; accepteer geen door de browser meegeleverde emmer of objectsleutel.
Het download-linkscript opslaan
De SDK maakt gebruik van de backend. Er wordt geen FlashData-query verzonden.
De URL noemt de geverifieerde objectversie wanneer S3 versiering er een bevat. Zonder een versie ID, houden elke output sleutel onveranderlijk na verificatie. Een identiteit die een specifieke versie leest, heeft s3 nodig:GetObjectVersion; een niet-verversied leesprogramma heeft s3:GetObject nodig.
Maak create-download-link.py naast pipeline.py en kopieer de volledige code hieronder in het. Het maakt gebruik van het Boto3 pakket geïnstalleerd bij de start.
# 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)Installeer de ondertekeningspakketten in de itemmap en sla de bron hieronder op als create-download-link.mjs in die map.
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;
}Geef de link terug naar de geautoriseerde gebruiker
Verwacht een privé access.json met url en expiresInSeconds: 300. Uw backend geeft alleen de URL terug aan de geautoriseerde gebruiker. Iedereen die het bezit kan het bestand downloaden voor maximaal vijf minuten; het kan eerder verlopen met de ondertekenings-gegevens.
Maak een nieuwe link van de opgeslagen kant-en-klare record wanneer de gebruiker vraagt om toegang. Bewaar de objectsleutel en versie in uw database, in plaats van het aflopende URL als het activaadres op te slaan. Dit lokale voorbeeld stopt als access.json al bestaat.
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"
)Herstart vanaf de laatste bevestigde fase
| Situatie | Volgende actie |
|---|---|
| Geaccepteerde baan / lokale wachttijd is verlopen | Herhaal runs recover met dezelfde runId in een nieuwe pogingsmap. |
| S3-toegang geweigerd of onderbroken lezen | Repareer de AWS gelezen identiteit of verbinding. Terug naar een nieuwe map en opnieuw controleren; het vorige gedeeltelijke bestand bewaren. |
| Bytetelling / MD5 / bestemmingsafwijking | Stop. Vergelijk het manifest, de objectversie en de geplande bestemming voordat u de media gebruikt. |
| geverifieerd/ bestaat al | Lees zijn ready.json, of inspecteer de onvolledige verificatie. Het script zal het niet overschrijven. |
| Toepassingen downloaden URL verlopen | Toegang opnieuw autoriseren en de opgeslagen object/version. ondertekenen Geen nieuwe FlashData-download indienen. |
| run_id_input_conflict | Het verzoek is gewijzigd. Herstellen van de oorspronkelijke run; gebruik een nieuwe runId alleen voor een opzettelijke nieuwe uitvoer. |
| 401 / 403 / 402 / 429 | Repareer toegang, toegangsrechten of balans; volg Retry-After. Inspecteer opgeslagen werk voordat u een onderwerping opnieuw probeert. |
Dezelfde stappen toepassen op een wachtrij
- Begin met één vluchtitem. Lees de huidige limieten voor het verhogen van de toepassing concurrency.
- Houd één duurzame runId voor elke video/output-versie, met een aparte bestemmingsprefix. Bewaar het account, de functie ID en het uiteindelijke resultaat in uw toepassingsdatabase.
- Perst de CLI-statusmap over procesherstarten. Aparte machines hebben behoefte aan gezamenlijke applicatiecoördinatie; een lokaal run journaal dedupliceert geen onafhankelijke staatsmappen.
- Gebruik ready.json als de overdracht naar downstream verwerking. Gefailleerde items behouden individueel zodat succesvolle leveringen worden hergebruikt.