Explorar documentación
Guías
Descarga un MP4 a un almacenamiento S3 privado, reanuda el proceso tras un reinicio y permite que tu aplicación acceda al archivo verificado.
En esta página
Lo que construirás
Un artículo duradero se mueve de un vídeo ID a un archivo listo para la aplicación. Mantenga cada etapa en el disco para que un nuevo proceso pueda continuar desde el último resultado confirmado.
item.json
→ enviar una vez → salvo carrera + trabajo ID
→ recuperar el trabajo → delivery.json
→ verificar S3 bytes → media.mp4 + ready.json
→ autoriza el usuario de la aplicación → descarga de corto plazo URLAntes de empezar
Elija un ejemplo de ruta para los seis pasos. Ambos usen un instalado FlashData CLI con un perfil de propietario guardado y youtube_download permiso, privado S3 storage.json para subidas, y una identidad AWS que puede leer el objeto entregado.
Uso Python 3.10+ en tu Python los scripts llaman al CLI para preservar su diario de ejecución, y Boto3 para leer S3 y firma enlaces. Bash, jq, Node.js and AWS CLI no son necesarios. Ejecute los comandos a continuación con python, o python3 si ese es su nombre de intérprete.
python --version
flashdata --version
python -m pip install boto3Instala Bash, jq, Node.js 22+ y AWS CLI v2. On Windows, corre Bash comandos in Git Bash. Instalar el Nodo S3 firmar paquetes en el paso 6.
Guardar la configuración de tiempo de ejecución
Crear una carpeta de artículo privada fuera del control de fuente. Guardar la configuración para su ruta elegida y editar los caminos absolutos y el nombre de perfil. Cada proceso utiliza que la cuenta guardada y la revista de funcionamiento. Las credenciales de almacenamiento permanecen en storage.json privado. Ejecutar un proceso por artículo a la vez.
Ahorre pipeline.json. En Windows, los caminos de choque hacia adelante como C:/private/flashdata-state trabajan en 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. Ahorre un elemento duradero
Guardar item.json en esa carpeta. Reemplazar el destino de vídeo y S3; este ejemplo solicita un MP4 hasta 720p. Mantenga su runId para las retries. Una salida planificada diferente necesita un nuevo runId y el prefijo de objetos.
{
"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. Ahorre el script y verifique el acceso
Cree el archivo a continuación antes de ejecutar los cheques. valida el destino S3 y mantiene un recibo para cada intento de presentación.
Crear el script de tuberías
Cree pipeline.py en la misma carpeta que pipeline.json y item.json. Copia el código completo a continuación en ese archivo y guardarlo. Lo reutilizará para cheques, sumisión y recuperación en los pasos 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)Cree request-media.sh en la misma carpeta que pipeline.env y item.json. Copia el código completo a continuación en ese archivo y guárdalo.
#!/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"
fiRevise su cuenta guardada
Ejecute este cheque gratuito de la carpeta del elemento después de guardar el script. El acceso del propietario o el permiso youtube_download detiene el cheque. Confirme la cuenta ID, balance, tasa y límites por TB. La carga final depende de los bytes cargados.
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-interactiveValidar sin descarga
Después de guardar el ayudante, ejecute su carrera seca. Python impresiones ok: verdadero y dryRun: verdadero; Bash imprime verdad. Esto valida la entrada y el acceso sin enviar trabajo multimedia o reservar créditos.
python pipeline.py dry-runset -euo pipefail
bash request-media.sh dry-run | jq -e '.ok and .data.dryRun'3. Presentar y retener el trabajo ID
Esto presenta una descarga de fondo pagada. Espere status: accepted y un jobId en el funcionamiento local. Mantenga el perfil, directorio estatal y item.json para la recuperación. Los medios están listos sólo después del paso 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}'Si la carrera ya está salvada o incierta
| Estado CLI | Medida |
|---|---|
| accepted + jobId | Recover this run in step 4. Mantenga el trabajo ID si el proceso se detiene. |
| succeeded | Recover/export su respuesta guardada, luego verificar el almacenamiento. No enviar un nuevo artículo. |
| Resultado desconocido / no confirmado trabajo ID | Mantenga la carrera, la recepción y el error. Inspeccione Historia o candidato IDs antes de decidir sobre otra presentación. |
4. Recover the delivery record
Corre desde la carpeta del elemento en cualquier nuevo terminal. La recuperación espera el trabajo original e imprime un directorio que contiene delivery.json, run.json y recibos. Un tiempo de espera de 10 para detener la espera local; repetir la recuperación para reanudar el mismo trabajo.
Reanudar el trabajo salvado
Reutiliza pipeline.py guardado en el paso 2. No se necesita script adicional.
python pipeline.py recoverPrimero crear recover-media.sh junto a item.json y pegar en el código de abajo. Guardar el archivo, luego ejecutar el comando de recuperación debajo de él.
#!/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"Inspeccione el objeto entregado
Espere un objeto S3 URL, un tamaño de archivo positivo y un MD5. Los objetos privados necesitan su identidad de lectura AWS. Python guarda el directorio exitoso en delivery-dir.txt para scripts posteriores. Bash mantiene DELIVERY_DIR; en un nuevo terminal, establecerlo en el directorio impreso.
python pipeline.py deliveryjq '{status, file: .results[0], usage}' "$DELIVERY_DIR/delivery.json"5. Verificar los bytes antes de marcar listo
El verificador comprueba la entrada original, el bucket S3 y el prefijo; descarga el objeto privado a disco y compara su tamaño en bytes y su MD5. Solo los archivos que coinciden generan verified/ready.json. Python lee delivery-dir.txt; Node utiliza DELIVERY_DIR. Ninguno envía una consulta a FlashData.
Guardar el script de verificación
Este verificador maneja estándar Amazon S3 objeto URLs. Para endpoints personalizados u otro proveedor, utilice su objeto autenticado leer y conservar el mismo destino, cheques de byte-count y checksum.
Crear verify-media.py junto a pipeline.py y copiar el código completo a continuación en él. Guardar ambos archivos en la carpeta del 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)Cree verify-media.mjs junto a item.json y copie el código completo a continuación en él.
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;
}Ejecutar la verificación
Después de guardar el script, ejecutelo desde la carpeta del 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"Descargue ready.json a su aplicación
Expect Delivery verificado y un registro que contiene el run/job IDs, cubo, región, clave de objeto, tamaño verificado y MD5. Este es el registro de su aplicación, creado por el script. Archivarlo con delivery.json y el elemento original; sobrevive la ventana de retención del resultado API.
Para la transcripción, indexación u otro procesamiento, pasar el localFile verificado a su trabajador. Para una descarga orientada al usuario, continúe con el paso 6.
6. Dar acceso controlado a su aplicación
En su backend, autorice al usuario y busque el registro listo del usuario en su propia tienda. A continuación, cree un S3 de corta duración descarga URL. Utilice el destino guardado; no acepte una clave de cubo o objeto suministrado por el navegador.
Guardar el script para descargar
El SDK utiliza la identidad de lectura AWS del backend. No se envía ninguna consulta FlashData.
El URL nombra la versión de objeto verificada cuando S3 versión proporciona uno. Sin una versión ID, mantenga cada clave de salida inmutable después de la verificación.Una lectura de identidad una versión específica necesita s3:GetObjectVersion; una lectura no versionada necesita s3:GetObject.
Cree create-download-link.py junto a pipeline.py y copie el código completo a continuación en él. Utiliza el paquete Boto3 instalado al principio.
# 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)Instalar los paquetes de firma en la carpeta de elementos, a continuación, guardar la fuente abajo como create-download-link.mjs en esa carpeta.
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;
}Regresar el enlace al usuario autorizado
Espere un access.json privado que contenga url y expiresInSeconds: 300. Su backend devuelve sólo el URL al usuario autorizado. Cualquier persona que lo sostenga puede descargar el archivo por hasta cinco minutos; puede expirar antes con las credenciales de firma.
Cree un nuevo enlace desde el registro listo guardado cuando el usuario siguiente solicite acceso. Mantenga la clave del objeto y la versión en su base de datos, en lugar de almacenar el URL expiador como la dirección del activo. Este ejemplo local se detiene si access.json ya existe.
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"
)Reinicie desde la última etapa confirmada
| Situación | Siguiente acción |
|---|---|
| Trabajo aceptado / hora de espera local | Repetir carreras recuperar con el mismo runId en un directorio de intentos frescos. |
| Acceso S3 denegado o interrumpido leer | Arreglar la identidad o conexión de lectura AWS. Recuperar a un directorio nuevo y verificar de nuevo; mantener el archivo parcial anterior. |
| Conteo de bytes / MD5 / desajuste de destino | Parar. Compare el manifiesto, la versión de objeto y el destino planificado antes de usar los medios. |
| verificadas/ ya existentes | Lea su ready.json, o inspeccione su verificación incompleta. El script no lo sobreescribirá. |
| descarga de aplicaciones URL expirado | Autorizar el acceso de nuevo y firmar el objeto guardado/version. No enviar otra descarga FlashData. |
| run_id_input_conflict | La solicitud cambió. Recuperar la ejecución original; utilizar un nuevo runId sólo para una nueva salida intencional. |
| 401 / 403 / 402 / 429 | Fijar el acceso, permisos o equilibrio; seguir Retry-After. Inspeccionar el trabajo guardado antes de reintentar una presentación. |
Aplicar las mismas etapas a una cola
- Comience con un elemento en vuelo. Lea los límites actuales antes de aumentar la concurrencia de aplicación.
- Mantenga una versión runId duradera para cada vídeo/output, con un prefijo de destino distinto. Almacene la cuenta, trabajo ID y resultado final en su base de datos de aplicaciones.
- Persistir el directorio estatal CLI a través de proceso reinicia. Las máquinas separadas necesitan coordinación de aplicaciones compartidas; una revista de ejecución local no deduplica directorios estatales independientes.
- Utilice ready.json como el handoff al procesamiento de aguas abajo. Retenga elementos fallidos individualmente para que los envíos exitosos sean reutilizados.