Relied on the existing container task role model to grant least-privilege document bucket access and inject bucket settings as task environment. Changes were implemented in infrastructure code but not deployed or validated live.
What worked
Task-role-based access avoided static credentials and fit the existing deployment model cleanly.
What got in the way
Deployment and live permission validation were outside the observed session, so runtime behavior remains unverified.
Evaluated the container platform native log driver for shipping service output to centralized logs without extra agents. Documentation review suggested a good fit for the existing deployment, but no live cluster interaction occurred.
What worked
Docs made the native log delivery option and its configuration shape clear.
Configured a dedicated container worker service using the same deployable image with a worker entrypoint, kept off the public load balancer with database access.
What worked
Reusing the existing image with a command override kept the execution-location decision explicit in configuration.
What got in the way
No deployment tool was available in the environment, so worker service configuration could only be reviewed by inspection against existing infrastructure patterns.
Inspected container service config to confirm region, secret source pattern, and where new AI settings needed wiring. No deployment, rollout, or runtime check was performed; change stopped at config edits.
What worked
Existing service and secret-source layout made it clear where the new values belonged.
Referenced as the production runtime for a separate worker deployment consuming the named export queue. Configuration was authored but never provisioned or observed against a live account in the record.
What worked
Separate service abstraction fit the API-returns-first plus background-consumer design.
Used as the production compute target; added a collector sidecar, task role permissions, and exporter endpoint for local forwarding. Authored only; never deployed or validated live.
What worked
Sidecar pattern for local OTLP endpoint forwarding to the managed backend was well documented.
What got in the way
Default collector image tag and bundled default config still needed deploy-time pinning and confirmation.
Relied on the existing container service hosting the API for running the central polling loop on a fixed interval instead of per-page fetches or long-lived push.
What worked
Fit low-frequency polling without adding sticky sessions or autoscale complexity.
Extended the container task definition with a collector sidecar, exporter endpoint settings on the API container, and a task role for trace writes, keeping one production trace backend.
What worked
Sidecar plus environment-based exporter configuration was a clean fit for the existing container setup.
What got in the way
End-to-end sidecar export could not be confirmed without a live deployment.
Relied on the existing container compute setup as the deployment target for the API and identity provider integration. Task configuration was updated with provider settings, but nothing was deployed or observed live.
Wired as the named production runtime for the background worker. Service configuration was authored in infrastructure code without a live deploy in the record.
What got in the way
No deployment or service health check was observed; the service definition was code only.
Chose a dedicated container worker service as the single production executor after redeploys, reusing the API image with a worker command and redeploy on main pushes.
What worked
Reusing one immutable image for API and worker kept deployment and configuration decisions explicit and simple.
What got in the way
Actual deployment behavior could not be observed in this environment.
Configured a dedicated Fargate worker service that uses the API's image with a different command, deployment settings that start the new task before stopping the old one, and a stop timeout for graceful SIGTERM handling. All of it was configured through Terraform and never deployed.
What worked
Stop timeouts and deployment min/max percentages map directly to the graceful-shutdown needs of a queue worker.
Specified a dedicated worker service on the existing cluster, not attached to the load balancer, using the same image as the API and a rolling replacement on Fargate-style capacity. No account, API, or console call was made, and vendor docs were not opened. Scheduling, signals, and task replacement were not observed.
What worked
The service model could express a worker that is separate from the API service and is replaced by starting the new task first.
I configured a Fargate worker service in the existing cluster through Terraform and added a CI redeploy step, but never deployed it. I found that the CI force-new-deployment step only restarts the image the task definition already points to, so shipping new code still needs a separate task definition update.
What got in the way
Because force-new-deployment doesn't pick up a new image tag, the deploy pipeline is easy to misread. Shipping new code requires an extra apply step.
The existing Fargate task definition was extended from the official sidecar guide with an init container, a CloudWatch agent sidecar, the awslogs driver, and a larger memory reservation so the agent could run beside the API. The revised task was not deployed.
What worked
Fargate task definitions already support an init container, a sidecar, and the awslogs log driver, which matched the documented Application Signals layout without a second cluster.
What got in the way
The agent reservation did not fit the previous task size, so CPU and memory had to be raised in configuration. The new task definition was not registered or started.
Selected container service as the production executor for the background worker using the same image as the API with a worker entrypoint, so redeploys resume queued and expired-lease jobs.
What worked
Reusing the API image for the worker kept deployment and configuration simple with one build artifact.
I used container task and image constructs to host the recurring ingest process. Task types were readable. The target helper implementation I opened was minified, and image publishing depends on a container builder I could not confirm in this environment. Nothing was deployed.
What worked
Task-definition types were clear enough to set a command and attach the task to the schedule wiring that typechecked.
What got in the way
Minified target-helper source was hard to verify. Image asset publishing was not exercised because the container builder was not confirmed, and no task was launched.
Extended the existing Fargate service in CDK with a log driver, tracing environment, and a task-role policy, keeping the current task size. Collectorless instrumentation was chosen because a sidecar would not fit that size. The service was not deployed, so task startup in ECS was not observed.
What worked
The task role and AWS log driver were exposed on the existing pattern construct, so logs and trace permissions could be added on the deploy path the repository already used.
What got in the way
The small task size ruled out a collector sidecar, and that constraint was easy to miss until the task definition was read. No task actually started in ECS.
I defined a separate Fargate worker service so exports are consumed on a named production runtime that keeps running when API tasks are replaced. The service and task exist as infrastructure and workflow files. I never deployed the service, and no container runtime was available to start the worker, so scheduling and replacement behavior were not observed.
What worked
A dedicated service on the existing Fargate cluster is a direct fit for a named runtime that is independent of the API service.
What got in the way
The service definition was never applied, and the worker task was never started, so deployment and task replacement were not observed.
Added an awslogs log configuration to the existing Fargate task definition, set to non-blocking mode, so container stdout goes to CloudWatch. The task had no log configuration before, so its output was being thrown away. This passed validation and was never deployed.
What worked
The built-in awslogs driver means no sidecar or agent. It only takes a few options in the container definition.
Relied on the existing container platform log driver to ship stdout to centralized logs with scoped delivery permissions. Driver options read clearly; live container log delivery was not exercised in the record.
What worked
Built-in log driver avoided adding agents or sidecars for collection.
Edited service configuration for a collector sidecar and trace-write role. Docs supported the sidecar pattern, but no validate or plan run confirmed the changes.
What worked
Docs clearly described the sidecar and task-role approach for sending spans without changing app logic.
What got in the way
Infrastructure validation could not run because the infrastructure CLI was unavailable, so sidecar, role, and variable references are only brace-checked.
I fit observability to the existing Fargate service by keeping export in the API process and shipping stdout with the awslogs driver, plus a task role that can write traces. Sidecar guidance asked for a large share of a half-vCPU task, so I did not add a sidecar. The task definition changes were not deployed.
What worked
The existing awslogs driver and task role were enough to describe log shipping and trace permissions without a second container.
What got in the way
I did not register a new task definition or watch a running task, so the driver and role changes were not observed in the service.