ext/hyperframes
2
0
Fork 0
mirror of https://github.com/heygen-com/hyperframes.git synced 2026-10-30 09:16:55 +00:00
Code Issues Packages Projects Releases Wiki Activity
Files
2a14cbc924ab6bd08b1e5ee97eadb5da3374acff
hyperframes/examples/aws-lambda/template.yaml
T
Miguel Ángel 2a14cbc924 perf(aws-lambda): size distributed renders from account concurrency limits (#5813) 
* perf(aws-lambda): run chunks through a Distributed Map to lift the 40-chunk cap

The inline Map runs at most 40 chunk renders at once. Both state machine
definitions (CDK and SAM) now use a Distributed Map with STANDARD child
executions, capped at the function's reserved concurrency so chunks past it
queue instead of being throttled. Progress reads each chunk's child
execution history so frames, cost and chunk errors still show up.

* fix(aws-lambda): retry Lambda throttles for minutes and stop on oversized chunks

A throttled task used to burn its four catch-all retries in about 30 s.
It now gets its own jittered backoff of several minutes, because another
render on the same function can still hold the reserved slots. Plan
treats CHUNK_EXCEEDS_WORKER_TIMEOUT as terminal in both definitions.

* chore(aws-lambda): trim stack comments to keep the comment share flat

* fix(aws-lambda): keep render --wait working at hundreds of chunks

Progress polls read the chunk Map Run's counts (one DescribeMapRun) instead of
every child execution's history, take exact chunk frames and cost from the Map
output once it exits, and read failed children only when the counts show a
failure. The SDK client retries throttled calls up to 8 times with backoff.

* feat(aws-lambda): size each render's concurrency to the account instead of a fixed 8

* fix(lambda): keep the concurrency SDK external in published modules

* fix(cli): keep an existing stack's reserved concurrency on redeploy

Redeploying without --concurrency sent ReservedConcurrency=-1, which
removed the cap of 8 that earlier CLI versions reserved by default and
stopped recording it in the state file. The override is now left out
when the flag is omitted, so SAM keeps the stack's current value (a new
stack still gets the template's unreserved default). The state file
records the deployed value, and deploy prints the kept reservation.

* fix(aws-lambda): keep progress working for callers without DescribeMapRun

Callers whose IAM policy came from an earlier `lambda policies user`
lack states:DescribeMapRun, so reading a running Distributed Map threw
AccessDeniedException out of `lambda progress` and `render --wait`
while the render itself went on to succeed. getRenderProgress now
catches only that error around the map-run read, returns the parent
snapshot (status, plan and assemble progress) and adds a warning to
re-apply the policy, which both commands print. Other errors still
throw.

* fix(cli): let the documented deploy policy drop a reserved concurrency

When a redeploy removes a function's reserved concurrency, CloudFormation
calls lambda:DeleteFunctionConcurrency. The policy printed by
`lambda policies role|user` granted only PutFunctionConcurrency, so the
update failed and rolled back. Grant it, and pin it with
states:DescribeMapRun in the required-actions test.

* fix(aws-lambda): read smoke chunk hashes from the Distributed Map output

With chunks in a Distributed Map, their task results live in child
executions, so the smoke gate's chunk-hash check found 0 chunks in the
parent history and failed every v1/v2 comparison. Read Chunks[] from the
RenderChunks / RenderChunksV2 MapStateExited output instead, as
getRenderProgress does. The stack this script deploys only has the
Distributed Map, so the inline-Map path is gone.

* fix(producer): cap a pinned chunk size at the worker concurrency, not 16

With --chunk-size or --target-chunk-frames and no --max-parallel-chunks,
the plan still capped the render at 16 chunks however many workers the
account allowed, so --chunk-size 30 on a 60 s render gave 16 chunks of
113 frames. The cap is now one wave across the worker concurrency, as
the --max-parallel-chunks docs say; 16 remains when the concurrency is
unknown.

* feat(cli): remove a stack's reserved concurrency with --concurrency=none

Since an omitted --concurrency now keeps the stack's reservation, there
was no CLI way back to the unreserved default. --concurrency=none sends
ReservedConcurrency=-1, the state file records the stack as unreserved
and deploy says the reservation was removed. Positive N and an omitted
flag behave as before; any other value is rejected instead of being
silently ignored.

* chore(aws-lambda): raise the package size budget for account-sized concurrency

Measured with pnpm@10.17.1 pack after rebasing on main with the S3 assembly change: 67,763 packed / 244,685 unpacked; the budget is the check's own 5% headroom over that.
2026-10-19 00:57:30 +00:00

776 lines
31 KiB
YAML
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
AWSTemplateFormatVersion: "2010-09-09"
Transform: AWS::Serverless-2016-10-31
Description: >-
HyperFrames distributed rendering — Step Functions standard workflow with
one Lambda function handling Plan, RenderChunk (fan-out via Map state),
and Assemble. One S3 bucket, alarms for runaway concurrency, Lambda
errors, and Step Functions execution failures.
Built from the handler ZIP at packages/aws-lambda/dist/handler.zip.
See:
- packages/aws-lambda/README.md (handler architecture)
- examples/aws-lambda/README.md (this directory's deploy guide)
Parameters:
ProjectName:
Type: String
Default: hyperframes
Description: Name prefix applied to all created resources.
LambdaMemoryMb:
Type: Number
Default: 10240
AllowedValues: [2048, 3072, 4096, 5120, 6144, 7168, 8192, 9216, 10240]
Description: >-
Lambda memory in MB. Render workloads are CPU-bound; bumping memory
proportionally bumps the CPU share Lambda gives the function. 10 GB
(the max) is recommended for 1080p renders.
LambdaTimeoutSec:
Type: Number
Default: 900
MinValue: 60
MaxValue: 900
Description: >-
Per-invocation Lambda timeout. Render chunks at the default
chunkSize=240 frames complete in seconds; 15 minutes is the Lambda
hard ceiling and the default here to absorb cold-start variance.
ReservedConcurrency:
Type: Number
Default: -1
Description: >-
Lambda reserved concurrency cap. Set to a positive integer to bound
simultaneous chunk renders (e.g. 50 to limit cost). -1 means
unreserved: each render runs up to 90% of the account's unreserved
concurrency.
ChromeSource:
Type: String
Default: sparticuz
AllowedValues: [sparticuz, chrome-headless-shell]
Description: >-
Which Chrome runtime the bundled ZIP was built with. Must match the
`--source=` flag passed to `build-zip.ts`. The handler reads this
via the HYPERFRAMES_LAMBDA_CHROME_SOURCE env var at boot.
ChunkInvocationAlarmThreshold:
Type: Number
Default: 1000
Description: >-
CloudWatch alarm threshold for total RenderChunk invocations per
hour. The runaway-Map state pathology would fan out far more
chunks than expected; an alarm at 10× the typical workload
protects against billing surprises.
Conditions:
HasReservedConcurrency: !Not [!Equals [!Ref ReservedConcurrency, -1]]
Globals:
Function:
Runtime: nodejs22.x
MemorySize: !Ref LambdaMemoryMb
Timeout: !Ref LambdaTimeoutSec
# x86_64 is required for @sparticuz/chromium — its prebuilt
# Chromium ships x86_64-only. Adopters who switch to a custom
# ARM-built chrome-headless-shell can change this to `arm64`, but
# the default ZIP build will fail to launch on Graviton.
Architectures: [x86_64]
# Lambda function-level X-Ray tracing. The state machine already
# has Tracing.Enabled: true; without this, X-Ray traces would
# terminate at the Step Functions → Lambda boundary instead of
# following into per-function spans.
Tracing: Active
# Cost-allocation tags. Setting these at the Globals level applies
# to every AWS::Serverless::Function in the template — there's
# only one today, but the contract is portable to multi-function
# variants. Bucket + state-machine carry the same tags resource-
# locally because Globals only covers functions.
Tags:
Project: !Ref ProjectName
HyperFramesComponent: lambda-renderer
Environment:
Variables:
NODE_OPTIONS: "--enable-source-maps"
HYPERFRAMES_LAMBDA_CHROME_SOURCE: !Ref ChromeSource
Resources:
# ── S3 bucket for plan tarballs, chunk outputs, and final renders ───────
RenderBucket:
Type: AWS::S3::Bucket
DeletionPolicy: Retain
UpdateReplacePolicy: Retain
Properties:
# BucketName omitted — CloudFormation generates a unique name like
# "<stack-name>-renderbucket-<random>". S3 bucket names are capped at
# 63 chars; a static !Sub expression including ProjectName +
# AWS::AccountId + AWS::Region trips that limit when ProjectName
# carries a timestamp (e.g. the smoke script's per-run stack name).
PublicAccessBlockConfiguration:
BlockPublicAcls: true
BlockPublicPolicy: true
IgnorePublicAcls: true
RestrictPublicBuckets: true
VersioningConfiguration:
# `Suspended` keeps storage costs flat — versions are not
# retained on overwrites. Tradeoff: if an adopter writes their
# final rendered mp4 to this bucket and a re-render overwrites
# the same key, the prior version is gone. Adopters who treat
# the final mp4 as user-keepable should set this to `Enabled`
# (intermediates under `renders/` still expire via the
# lifecycle rule below regardless).
Status: Suspended
LifecycleConfiguration:
Rules:
- Id: ExpireIntermediates
Status: Enabled
Prefix: renders/
# Plan tarballs and chunk outputs are intermediate artifacts.
# Users keep the final mp4 (different key prefix); the rest
# can age out after a week to keep storage costs flat.
ExpirationInDays: 7
Tags:
- Key: Project
Value: !Ref ProjectName
- Key: HyperFramesComponent
Value: lambda-renderer
# ── Single Lambda function handling all three roles ──────────────────────
RenderFunction:
Type: AWS::Serverless::Function
Properties:
FunctionName: !Sub "${ProjectName}-render"
Description: >-
HyperFrames distributed render handler. Dispatches on event.Action.
Handler: handler.handler
# Local path is resolved by `sam build` + `sam deploy --resolve-s3`
# (or `--s3-bucket`); the resulting CodeUri rewrites to s3://.
CodeUri: ../../packages/aws-lambda/dist/handler.zip
PackageType: Zip
ReservedConcurrentExecutions: !If
- HasReservedConcurrency
- !Ref ReservedConcurrency
- !Ref AWS::NoValue
EphemeralStorage:
Size: 10240
Environment:
Variables:
# Lambda's Node 22 runtime sets these by default; explicit for
# clarity + so users can override during local SAM invoke.
TMPDIR: /tmp
HYPERFRAMES_RENDER_BUCKET: !Ref RenderBucket
HYPERFRAMES_LAMBDA_RESERVED_CONCURRENCY: !Ref ReservedConcurrency
Policies:
- S3CrudPolicy:
BucketName: !Ref RenderBucket
- Statement:
- Effect: Allow
Action: s3:AbortMultipartUpload
Resource: !Sub "arn:${AWS::Partition}:s3:::${RenderBucket}/*"
# Plan sizes an unreserved render to the account's concurrency.
- Statement:
- Effect: Allow
Action: lambda:GetAccountSettings
Resource: "*"
# CloudWatch Logs perms are covered by SAM's default
# AWSLambdaBasicExecutionRole — explicit `CloudWatchLogsFullAccess`
# would be overscope (`logs:*` on `*`, including DeleteLogGroup +
# CreateExportTask). Reference templates shouldn't leak overbroad
# IAM into adopters' accounts.
# ── CloudWatch log group for the state machine ──────────────────────────
# SAM doesn't auto-create one when `LoggingConfiguration` is set, so we
# define it explicitly — that way the IAM grant on the state-machine
# role has a destination to write to.
RenderStateMachineLogGroup:
Type: AWS::Logs::LogGroup
Properties:
LogGroupName: !Sub "/aws/states/${ProjectName}-render"
RetentionInDays: 30
# ── Step Functions state machine: Plan → Map(N) RenderChunk → Assemble ──
RenderStateMachine:
Type: AWS::Serverless::StateMachine
Properties:
Name: !Sub "${ProjectName}-render"
Type: STANDARD
Tracing:
Enabled: true
Logging:
# Without this, the `WriteCloudwatchLogs` grant on the state
# machine role would be unused — operators would see zero
# execution history outside the Step Functions console.
# `Level: ERROR` keeps log volume low; bump to `ALL` for
# heavy debugging.
Level: ERROR
IncludeExecutionData: false
Destinations:
- CloudWatchLogsLogGroup:
LogGroupArn: !GetAtt RenderStateMachineLogGroup.Arn
Definition:
Comment: >-
HyperFrames distributed render orchestration: Plan → Map(N)
RenderChunk → Assemble.
# Defensive 1-hour ceiling on the whole choreography. The
# individual states already have retries + per-task timeouts;
# this catches pathological runaways (Plan-retry storm,
# stuck-state-machine bugs) at the top before per-task budgets
# compound into a multi-hour execution. The longest legitimate
# render observed in PR 880's eval was ~3 minutes.
TimeoutSeconds: 3600
StartAt: SelectPlanProtocol
States:
SelectPlanProtocol:
Type: Choice
Choices:
- Variable: $.PlanProtocol
StringEquals: v2
Next: PlanV2
- Variable: $.PlanProtocol
StringEquals: v1
Next: Plan
- Variable: $.PlanProtocol
IsPresent: true
Next: UnsupportedPlanProtocol
Default: PlanV2
UnsupportedPlanProtocol:
Type: Fail
Error: PLAN_PROTOCOL_UNSUPPORTED
Cause: PlanProtocol must be "v1", "v2", or absent (defaults to v2).
Plan:
Type: Task
Resource: arn:aws:states:::lambda:invoke
Parameters:
FunctionName: !GetAtt RenderFunction.Arn
Payload:
Action: plan
PlanProtocol: v1
ProjectS3Uri.$: "$.ProjectS3Uri"
PlanOutputS3Prefix.$: "$.PlanOutputS3Prefix"
Config.$: "$.Config"
ResultSelector:
PlanProtocol: v1
PlanS3Uri.$: "$.Payload.PlanS3Uri"
PlanHash.$: "$.Payload.PlanHash"
ChunkCount.$: "$.Payload.ChunkCount"
MaxChunkConcurrency.$: "$.Payload.MaxChunkConcurrency"
Format.$: "$.Payload.Format"
HasAudio.$: "$.Payload.HasAudio"
AudioS3Uri.$: "$.Payload.AudioS3Uri"
ResultPath: $.Plan
Retry:
- ErrorEquals:
# These error names are thrown by the producer's plan
# stage when retrying can never help — version skew,
# determinism violations, GPU misconfiguration, font
# fetch failures, plan-size cap, unsupported format.
# Fail fast rather than burning ~120s of retry budget.
- FFMPEG_VERSION_MISMATCH
- PLAN_HASH_MISMATCH
- BROWSER_GPU_NOT_SOFTWARE
- FONT_FETCH_FAILED
- PLAN_TOO_LARGE
- PlanTooLargeError
- PLAN_PROTOCOL_UNSUPPORTED
- PlanProtocolUnsupportedError
- VIDEO_SOURCE_UNRENDERABLE
- INVALID_VIDEO_METADATA
- NOT_MEDIA_PAYLOAD
- NotMediaPayloadError
- PLAN_ARTIFACT_DIGEST_MISMATCH
- FORMAT_NOT_SUPPORTED_IN_DISTRIBUTED
- CHUNK_EXCEEDS_WORKER_TIMEOUT
MaxAttempts: 0
# Another render on the same function can still take the reserved slots; wait minutes.
- ErrorEquals: [Lambda.TooManyRequestsException]
IntervalSeconds: 5
MaxAttempts: 10
BackoffRate: 2
MaxDelaySeconds: 60
JitterStrategy: FULL
- ErrorEquals: [States.ALL]
IntervalSeconds: 2
MaxAttempts: 4
BackoffRate: 2
MaxDelaySeconds: 60
Next: BuildChunkList
PlanV2:
Type: Task
Resource: arn:aws:states:::lambda:invoke
Parameters:
FunctionName: !GetAtt RenderFunction.Arn
Payload:
Action: plan
PlanProtocol: v2
ProjectS3Uri.$: "$.ProjectS3Uri"
PlanOutputS3Prefix.$: "$.PlanOutputS3Prefix"
Config.$: "$.Config"
ResultSelector:
PlanProtocol: v2
PlanV2ManifestS3Uri.$: "$.Payload.PlanV2ManifestS3Uri"
PlanV2ArtifactS3Prefix.$: "$.Payload.PlanV2ArtifactS3Prefix"
PlanHash.$: "$.Payload.PlanHash"
ChunkCount.$: "$.Payload.ChunkCount"
MaxChunkConcurrency.$: "$.Payload.MaxChunkConcurrency"
Format.$: "$.Payload.Format"
HasAudio.$: "$.Payload.HasAudio"
ResultPath: $.Plan
Retry:
- ErrorEquals:
- FFMPEG_VERSION_MISMATCH
- PLAN_HASH_MISMATCH
- S3_URI_NOT_ALLOWED
- BROWSER_GPU_NOT_SOFTWARE
- FONT_FETCH_FAILED
- PLAN_TOO_LARGE
- PlanTooLargeError
- PLAN_PROTOCOL_UNSUPPORTED
- PlanProtocolUnsupportedError
- PLAN_V2_INTEGRITY_UNRECOVERABLE
- VIDEO_SOURCE_UNRENDERABLE
- INVALID_VIDEO_METADATA
- NOT_MEDIA_PAYLOAD
- NotMediaPayloadError
- PlanV2IntegrityError
- PLAN_ARTIFACT_DIGEST_MISMATCH
- FORMAT_NOT_SUPPORTED_IN_DISTRIBUTED
- CHUNK_EXCEEDS_WORKER_TIMEOUT
- ChromeBinaryUnavailableError
MaxAttempts: 0
- ErrorEquals: [Lambda.TooManyRequestsException]
IntervalSeconds: 5
MaxAttempts: 10
BackoffRate: 2
MaxDelaySeconds: 60
JitterStrategy: FULL
- ErrorEquals: [States.ALL]
IntervalSeconds: 2
MaxAttempts: 4
BackoffRate: 2
MaxDelaySeconds: 60
Next: BuildChunkList
BuildChunkList:
# Translate ChunkCount into an array `[0, 1, ..., N-1]` so the
# Map state below has something to iterate. Range is the
# idiomatic Step Functions intrinsic for this; no Lambda call
# required.
Type: Pass
Parameters:
ChunkIndexes.$: "States.ArrayRange(0, States.MathAdd($.Plan.ChunkCount, -1), 1)"
ResultPath: $.Iterator
Next: AssertChunkCount
AssertChunkCount:
# Defensive gate: `resolveChunkPlan` guarantees ChunkCount ≥ 1,
# but if some future regression let a zero-chunk plan through,
# `RenderChunks` (Map state) would iterate zero times and
# `Assemble` would receive an empty `ChunkS3Uris` array — silently
# producing an empty output. Fail fast instead.
Type: Choice
Choices:
- Variable: $.Plan.ChunkCount
NumericGreaterThan: 0
Next: SelectWorkerProtocol
Default: PlanProducedZeroChunks
PlanProducedZeroChunks:
Type: Fail
Error: PLAN_TOO_LARGE
Cause: Plan returned ChunkCount=0 — non-retryable producer-side invariant violation.
SelectWorkerProtocol:
Type: Choice
Choices:
- Variable: $.Plan.PlanProtocol
StringEquals: v2
Next: RenderChunksV2
Default: RenderChunks
RenderChunks:
Type: Map
Label: RenderChunks
ItemsPath: $.Iterator.ChunkIndexes
ItemSelector:
ChunkIndex.$: "$$.Map.Item.Value"
PlanS3Uri.$: "$.Plan.PlanS3Uri"
PlanHash.$: "$.Plan.PlanHash"
ChunkOutputS3Prefix.$: "$.PlanOutputS3Prefix"
Format.$: "$.Plan.Format"
# Chunks past the plan's concurrency queue here instead of being throttled by Lambda.
MaxConcurrencyPath: $.Plan.MaxChunkConcurrency
ResultPath: $.Chunks
ItemProcessor:
ProcessorConfig:
# Inline Map runs at most 40 iterations at once. STANDARD children
# because EXPRESS ones stop at 5 minutes and a chunk may run 15.
Mode: DISTRIBUTED
ExecutionType: STANDARD
StartAt: RenderChunk
States:
RenderChunk:
Type: Task
Resource: arn:aws:states:::lambda:invoke
Parameters:
FunctionName: !GetAtt RenderFunction.Arn
Payload:
Action: renderChunk
PlanProtocol: v1
ChunkIndex.$: "$.ChunkIndex"
PlanS3Uri.$: "$.PlanS3Uri"
PlanHash.$: "$.PlanHash"
ChunkOutputS3Prefix.$: "$.ChunkOutputS3Prefix"
Format.$: "$.Format"
ResultSelector:
ChunkS3Uri.$: "$.Payload.ChunkS3Uri"
ChunkIndex.$: "$.Payload.ChunkIndex"
Sha256.$: "$.Payload.Sha256"
FramesEncoded.$: "$.Payload.FramesEncoded"
DurationMs.$: "$.Payload.DurationMs"
Retry:
- ErrorEquals:
- FFMPEG_VERSION_MISMATCH
- PLAN_HASH_MISMATCH
- BROWSER_GPU_NOT_SOFTWARE
- PLAN_TOO_LARGE
- PlanTooLargeError
- PLAN_PROTOCOL_UNSUPPORTED
- PlanProtocolUnsupportedError
- INVALID_VIDEO_METADATA
- PLAN_ARTIFACT_DIGEST_MISMATCH
MaxAttempts: 0
- ErrorEquals: [Lambda.TooManyRequestsException]
IntervalSeconds: 5
MaxAttempts: 10
BackoffRate: 2
MaxDelaySeconds: 60
JitterStrategy: FULL
- ErrorEquals: [States.ALL]
IntervalSeconds: 2
MaxAttempts: 4
BackoffRate: 2
MaxDelaySeconds: 60
End: true
Next: Assemble
Assemble:
Type: Task
Resource: arn:aws:states:::lambda:invoke
Parameters:
FunctionName: !GetAtt RenderFunction.Arn
Payload:
Action: assemble
PlanProtocol: v1
PlanS3Uri.$: "$.Plan.PlanS3Uri"
ChunkS3Uris.$: "$.Chunks[*].ChunkS3Uri"
AudioS3Uri.$: "$.Plan.AudioS3Uri"
OutputS3Uri.$: "$.OutputS3Uri"
Format.$: "$.Plan.Format"
ResultSelector:
OutputS3Uri.$: "$.Payload.OutputS3Uri"
FramesEncoded.$: "$.Payload.FramesEncoded"
FileSize.$: "$.Payload.FileSize"
ResultPath: $.Output
Retry:
- ErrorEquals:
# Same non-retryable error names as the Plan state's
# gate — these surface at assemble time too because
# ffmpeg-driven concat picks up version drift and we
# re-verify plan hash + format at assemble. Skip the
# retry storm; fail fast.
- FFMPEG_VERSION_MISMATCH
- PLAN_HASH_MISMATCH
- FORMAT_NOT_SUPPORTED_IN_DISTRIBUTED
- PLAN_TOO_LARGE
- PlanTooLargeError
- PLAN_PROTOCOL_UNSUPPORTED
- PlanProtocolUnsupportedError
- PLAN_ARTIFACT_DIGEST_MISMATCH
MaxAttempts: 0
- ErrorEquals: [Lambda.TooManyRequestsException]
IntervalSeconds: 5
MaxAttempts: 10
BackoffRate: 2
MaxDelaySeconds: 60
JitterStrategy: FULL
- ErrorEquals: [States.ALL]
IntervalSeconds: 2
MaxAttempts: 4
BackoffRate: 2
MaxDelaySeconds: 60
End: true
RenderChunksV2:
Type: Map
Label: RenderChunksV2
ItemsPath: $.Iterator.ChunkIndexes
ItemSelector:
ChunkIndex.$: "$$.Map.Item.Value"
PlanV2ManifestS3Uri.$: "$.Plan.PlanV2ManifestS3Uri"
PlanV2ArtifactS3Prefix.$: "$.Plan.PlanV2ArtifactS3Prefix"
PlanHash.$: "$.Plan.PlanHash"
ChunkOutputS3Prefix.$: "$.PlanOutputS3Prefix"
Format.$: "$.Plan.Format"
# Chunks past the plan's concurrency queue here instead of being throttled by Lambda.
MaxConcurrencyPath: $.Plan.MaxChunkConcurrency
ResultPath: $.Chunks
ItemProcessor:
ProcessorConfig:
Mode: DISTRIBUTED
ExecutionType: STANDARD
StartAt: RenderChunkV2
States:
RenderChunkV2:
Type: Task
Resource: arn:aws:states:::lambda:invoke
Parameters:
FunctionName: !GetAtt RenderFunction.Arn
Payload:
Action: renderChunk
PlanProtocol: v2
ChunkIndex.$: "$.ChunkIndex"
PlanV2ManifestS3Uri.$: "$.PlanV2ManifestS3Uri"
PlanV2ArtifactS3Prefix.$: "$.PlanV2ArtifactS3Prefix"
PlanHash.$: "$.PlanHash"
ChunkOutputS3Prefix.$: "$.ChunkOutputS3Prefix"
Format.$: "$.Format"
ResultSelector:
ChunkS3Uri.$: "$.Payload.ChunkS3Uri"
ChunkIndex.$: "$.Payload.ChunkIndex"
Sha256.$: "$.Payload.Sha256"
FramesEncoded.$: "$.Payload.FramesEncoded"
DurationMs.$: "$.Payload.DurationMs"
Retry:
- ErrorEquals:
- FFMPEG_VERSION_MISMATCH
- PLAN_HASH_MISMATCH
- S3_URI_NOT_ALLOWED
- BROWSER_GPU_NOT_SOFTWARE
- PLAN_TOO_LARGE
- PlanTooLargeError
- PLAN_PROTOCOL_UNSUPPORTED
- PlanProtocolUnsupportedError
- PLAN_V2_INTEGRITY_UNRECOVERABLE
- INVALID_VIDEO_METADATA
- PlanV2IntegrityError
- PLAN_ARTIFACT_DIGEST_MISMATCH
- ChromeBinaryUnavailableError
MaxAttempts: 0
- ErrorEquals: [Lambda.TooManyRequestsException]
IntervalSeconds: 5
MaxAttempts: 10
BackoffRate: 2
MaxDelaySeconds: 60
JitterStrategy: FULL
- ErrorEquals: [States.ALL]
IntervalSeconds: 2
MaxAttempts: 4
BackoffRate: 2
MaxDelaySeconds: 60
End: true
Next: AssembleV2
AssembleV2:
Type: Task
Resource: arn:aws:states:::lambda:invoke
Parameters:
FunctionName: !GetAtt RenderFunction.Arn
Payload:
Action: assemble
PlanProtocol: v2
PlanV2ManifestS3Uri.$: "$.Plan.PlanV2ManifestS3Uri"
PlanV2ArtifactS3Prefix.$: "$.Plan.PlanV2ArtifactS3Prefix"
PlanHash.$: "$.Plan.PlanHash"
ChunkS3Uris.$: "$.Chunks[*].ChunkS3Uri"
AudioS3Uri: null
OutputS3Uri.$: "$.OutputS3Uri"
Format.$: "$.Plan.Format"
ResultSelector:
OutputS3Uri.$: "$.Payload.OutputS3Uri"
FramesEncoded.$: "$.Payload.FramesEncoded"
FileSize.$: "$.Payload.FileSize"
ResultPath: $.Output
Retry:
- ErrorEquals:
- FFMPEG_VERSION_MISMATCH
- PLAN_HASH_MISMATCH
- S3_URI_NOT_ALLOWED
- FORMAT_NOT_SUPPORTED_IN_DISTRIBUTED
- PLAN_TOO_LARGE
- PlanTooLargeError
- PLAN_PROTOCOL_UNSUPPORTED
- PlanProtocolUnsupportedError
- PLAN_V2_INTEGRITY_UNRECOVERABLE
- PlanV2IntegrityError
- PLAN_ARTIFACT_DIGEST_MISMATCH
- ChromeBinaryUnavailableError
MaxAttempts: 0
- ErrorEquals: [Lambda.TooManyRequestsException]
IntervalSeconds: 5
MaxAttempts: 10
BackoffRate: 2
MaxDelaySeconds: 60
JitterStrategy: FULL
- ErrorEquals: [States.ALL]
IntervalSeconds: 2
MaxAttempts: 4
BackoffRate: 2
MaxDelaySeconds: 60
End: true
Role: !GetAtt RenderStateMachineRole.Arn
RenderStateMachineRole:
Type: AWS::IAM::Role
Properties:
AssumeRolePolicyDocument:
Version: "2012-10-17"
Statement:
- Effect: Allow
Principal:
Service: states.amazonaws.com
Action: sts:AssumeRole
Policies:
- PolicyName: InvokeRenderFunction
PolicyDocument:
Version: "2012-10-17"
Statement:
- Effect: Allow
Action: lambda:InvokeFunction
Resource: !GetAtt RenderFunction.Arn
# A Distributed Map runs each chunk as a child execution of this state machine.
# ARNs built by name: !Ref RenderStateMachine here would be a dependency cycle.
- PolicyName: RunDistributedMapChildren
PolicyDocument:
Version: "2012-10-17"
Statement:
- Effect: Allow
Action: states:StartExecution
Resource: !Sub "arn:${AWS::Partition}:states:${AWS::Region}:${AWS::AccountId}:stateMachine:${ProjectName}-render"
- Effect: Allow
Action:
- states:DescribeExecution
- states:StopExecution
Resource: !Sub "arn:${AWS::Partition}:states:${AWS::Region}:${AWS::AccountId}:execution:${ProjectName}-render:*"
- PolicyName: WriteCloudwatchLogs
PolicyDocument:
Version: "2012-10-17"
Statement:
- Effect: Allow
Action:
- logs:CreateLogDelivery
- logs:GetLogDelivery
- logs:UpdateLogDelivery
- logs:DeleteLogDelivery
- logs:ListLogDeliveries
- logs:PutResourcePolicy
- logs:DescribeResourcePolicies
- logs:DescribeLogGroups
Resource: "*"
- PolicyName: XRayTracing
PolicyDocument:
Version: "2012-10-17"
Statement:
- Effect: Allow
Action:
- xray:PutTraceSegments
- xray:PutTelemetryRecords
Resource: "*"
# ── CloudWatch alarm: runaway chunk invocations ─────────────────────────
RenderChunkInvocationAlarm:
Type: AWS::CloudWatch::Alarm
Properties:
AlarmName: !Sub "${ProjectName}-runaway-chunk-invocations"
AlarmDescription: >-
Fires if RenderChunk Lambda invocations exceed the configured
threshold in a 1-hour window. The Map state's MaxConcurrency cap
protects against simultaneous fan-out, but a runaway state
machine that triggers many sequential renders would still rack
up cost; this alarm catches that pattern.
Namespace: AWS/Lambda
MetricName: Invocations
Dimensions:
- Name: FunctionName
Value: !Ref RenderFunction
Statistic: Sum
Period: 3600
EvaluationPeriods: 1
Threshold: !Ref ChunkInvocationAlarmThreshold
ComparisonOperator: GreaterThanThreshold
TreatMissingData: notBreaching
# ── CloudWatch alarm: Lambda function errors ────────────────────────────
# Fires on any non-zero error rate. The invocation alarm above catches
# *too many calls*; this catches *calls that failed*. Without it,
# silent per-chunk failures (a non-retryable error inside the
# producer) would only surface by reading Step Functions execution
# history.
RenderFunctionErrorsAlarm:
Type: AWS::CloudWatch::Alarm
Properties:
AlarmName: !Sub "${ProjectName}-render-function-errors"
AlarmDescription: >-
Fires if the render Lambda reports any errors in a 5-minute
window. Set EvaluationPeriods=1 so a single failure pages.
Namespace: AWS/Lambda
MetricName: Errors
Dimensions:
- Name: FunctionName
Value: !Ref RenderFunction
Statistic: Sum
Period: 300
EvaluationPeriods: 1
Threshold: 1
ComparisonOperator: GreaterThanOrEqualToThreshold
TreatMissingData: notBreaching
# ── CloudWatch alarm: Step Functions execution failures ─────────────────
# Fires when a state-machine execution reaches a terminal failure
# state (typed non-retryable, retry-exhausted, or top-level timeout).
# Complementary to the Lambda Errors alarm: SFN failures include
# Choice-state Fail branches (PlanProducedZeroChunks) that bypass
# Lambda entirely, plus retry-exhaustion of transient errors that
# individual Lambda invocations counted as successful "retries".
RenderStateMachineFailedAlarm:
Type: AWS::CloudWatch::Alarm
Properties:
AlarmName: !Sub "${ProjectName}-render-state-machine-failed"
AlarmDescription: >-
Fires when the render state machine reports a failed
execution. Catches retry-exhaustion + typed non-retryable +
TimeoutSeconds cases that the Lambda Errors metric misses.
Namespace: AWS/States
MetricName: ExecutionsFailed
Dimensions:
- Name: StateMachineArn
Value: !Ref RenderStateMachine
Statistic: Sum
Period: 300
EvaluationPeriods: 1
Threshold: 1
ComparisonOperator: GreaterThanOrEqualToThreshold
TreatMissingData: notBreaching
Outputs:
RenderBucketName:
Description: S3 bucket for plan tarballs, chunk outputs, and final renders.
Value: !Ref RenderBucket
Export:
Name: !Sub "${AWS::StackName}-RenderBucket"
RenderFunctionArn:
Description: ARN of the Lambda function. Pass to `aws lambda invoke` for local testing.
Value: !GetAtt RenderFunction.Arn
Export:
Name: !Sub "${AWS::StackName}-RenderFunctionArn"
RenderStateMachineArn:
Description: ARN of the Step Functions state machine. Pass to `aws stepfunctions start-execution`.
Value: !Ref RenderStateMachine
Export:
Name: !Sub "${AWS::StackName}-RenderStateMachineArn"
Reference in New Issue View Git Blame Copy Permalink