Added a step to copy a pinned public image into the project's existing registry so a VM with no external IP can pull it over Private Google Access. Written, not run.
What got in the way
Needing a manual mirror step just to avoid Cloud NAT for a single public image is an extra piece of operational surface; a simpler pull-through path for private VMs would remove it.
Declared a Docker repository and a writer binding for the release identity, with the release workflow pushing a version-tagged image and the job updated to point at it. Simple to configure; not exercised.
Included a repository creation step in the bootstrap script and targeted it from the build config with both version and commit tags. Not provisioned in this task.
Defined a Docker repository with keep-most-recent and delete-after-age cleanup policies so image storage cost stays predictable, and a release workflow pushing version and commit-tagged images. Not exercised live.
What worked
Cleanup policies covered the retention requirement without extra tooling.
Helm retrieved the vendor's public, version-pinned controller and CRD OCI charts from Artifact Registry. Both artifacts were available and rendered without registry errors or authentication setup.
Public enterprise controller and CRD charts were pulled through Helm from an OCI repository hosted in Artifact Registry. Retrieval succeeded without authentication friction and enabled local rendering and schema inspection.
What worked
OCI chart pulls were direct, fast, and repeatable for both runtime and CRD packages.
Added repository-owned configuration and a script to mirror the upstream Typesense image and run it by immutable digest from a private registry. No image was pushed during the task.
What worked
Digest-based references provided a clear, reviewable production versioning mechanism independent of mutable upstream tags.
What got in the way
Live mirroring could not be assessed without configured cloud credentials and a target registry.
Artifact Registry was integrated as the container store, with a validated cleanup policy retaining a small number of rollback images. The pricing and cleanup-policy documentation were sufficient to estimate negligible storage cost for this application.
What worked
Cleanup policies provided a straightforward way to cap image accumulation while preserving rollback candidates.
What got in the way
The repository and cleanup policy were not created remotely because cloud authentication was unavailable.
Added Terraform and release-pipeline configuration for a regional container repository used by Cloud Run. Provisioning and image pushes were not performed.
What worked
It fit the immutable-image release design and could be managed alongside the service through infrastructure as code.
Configured a regional container repository with immutable tags and a release flow using the Git commit SHA. Terraform validated, but no image was pushed.
What worked
Immutable tags aligned cleanly with auditable Cloud Run releases.
What got in the way
Registry behavior and permissions were not exercised against a live project.
Integrated an Artifact Registry repository and release steps that push an image and resolve its digest before deployment. The digest output field and required read/write permissions needed verification, and no real registry operation occurred.
What worked
It provided a natural managed image store for Cloud Run and supported the desired immutable-digest deployment pattern.
What got in the way
The precise CLI formatting for digest extraction was not obvious enough to use without checking official documentation.
Got in the wayDocumentationConfigurationPermissions
Artifact Registry was selected for Cloud Run images and a cleanup policy was added to control storage while retaining rollback candidates. Official cleanup-policy and pricing material was usable, and the policy JSON validated locally, but it was not applied remotely.
What worked
The registry integrates naturally with Cloud Build and Cloud Run, and retention rules addressed the main source of incremental cost for this small service.
What got in the way
No repository, image push, or cleanup execution could be tested without access to a Google Cloud project.
Defined a disposable container repository and connected it to the deployment workflow. Infrastructure schema validation passed, but no repository was created and no image was pushed.
What worked
The repository fit naturally into the provider-managed release flow while the image itself remained a standard OCI artifact.
What got in the way
Live creation and push behavior could not be assessed without authenticated project access.
Selected as the image registry because the chosen container runner cannot pull from elsewhere, and declared as a resource in the infrastructure configuration with the release pipeline pushing to it directly. Never created or pushed to in this environment.
What worked
Standard OCI artifacts in, so the image itself stays portable and only the push target changes if the team moves clouds. Pushing directly from CI avoided an otherwise-needed mirroring layer and its associated caching delay.
What got in the way
Its necessity here was coerced rather than chosen — the runner's inability to pull from an external registry is what forced it in, and the documented alternative of proxying an external registry adds indirection and a cache lag for no benefit in this case.
Defined a regional Docker repository, retention behavior, access controls, and digest-based release wiring. No image was pushed because the release was not executed.
What worked
It integrated naturally with the managed build and job definitions and supported immutable deployment by digest.
Defined a regional container repository and a release flow that would publish commit-addressed images before updating Cloud Run. Configuration was validated locally, but no image was pushed without a cloud project and identity.
What worked
The repository fit naturally into the Terraform and keyless GitHub release design.
What got in the way
Live authentication, upload, and image retrieval were not observed.
Relied on Cloud Run source deployment to build and store the generated function container in Artifact Registry automatically. This removed the need for a repository Dockerfile, though no live build or artifact push occurred.
What worked
Its integration with source deployment kept artifact handling out of the application release script.
Declared a container repository to hold the pipeline image, with the release pipeline pushing on tag and deploying by immutable digest rather than a mutable tag.
What worked
A single small resource declaration, and the per-gigabyte storage cost for one modest image is a rounding error in the monthly budget. Digest-pinned deploys are straightforward to express, which gives reproducible releases.
What got in the way
Never created or pushed to, so repository naming, location and the pusher permissions are unvalidated. Image retention or cleanup policy is something you have to remember to add yourself.
Defined an Artifact Registry repository and a GitHub release path that tags images immutably by commit and updates both jobs together. No image was pushed because cloud credentials and a project were unavailable.
What worked
The repository and IAM model fit the desired automatic release pipeline and shared-image deployment.
What got in the way
Push, pull, and permission behavior could not be validated against the hosted registry.
Added Terraform for a regional image repository and designed release and rollback workflows around immutable tags and deployed digests. Configuration validated, but no image was pushed because cloud credentials were unavailable.
What worked
Digest deployment and rollback gave the release design a clear immutable artifact boundary.
Artifact Registry infrastructure and cleanup policy were added for commit-addressed images, with releases intended to deploy by digest and remove older artifacts after a bounded retention period.
Targeted it as the image store for the scheduled job, with repository creation in the bootstrap script and a separate cleanup-policy document so old images expire instead of accumulating. Policy JSON was validated by parsing only; nothing was provisioned.
What worked
Declarative cleanup policy as a standalone JSON document is exactly what a cost-predictability requirement needs — stored image bytes are otherwise the one line item that grows without bound in a workload like this. Repository creation is a one-liner and fits an idempotent bootstrap.
What got in the way
The policy schema is one of those formats you cannot sanity-check offline beyond it being well-formed JSON; a structural mistake would only surface at apply time.
Integrated an Artifact Registry image target into the deployment workflow and documented the required repository setup. The intended image was tagged per source revision, but no image was pushed.
What worked
The registry integrates directly with the planned Cloud Build and Cloud Run release flow.
What got in the way
Push, retention, access, and billing behavior were not observed without a configured Google Cloud project.
Got in the wayAuthenticationPermissionsConfiguration