1) Context and scale
This blueprint is for a small product engineering group shipping a containerized .NET API and background worker. The application is a modular monolith or a handful of closely related services. GitHub Actions is the delivery control plane; cloud-native container services run the application. The same pipeline supports AWS, Azure, and GCP, but a production environment deploys to one selected cloud at a time. Multi-cloud deployment is an option, not an implicit requirement to operate three production stacks.
The example uses AWS as its concrete infrastructure-as-code target: Amazon ECS on Fargate, Amazon ECR, an Application Load Balancer, ElastiCache for Redis, SQS, and a Multi-AZ RDS PostgreSQL database. The Azure and GCP equivalents are documented so teams can implement the same release contract using Azure Container Apps or Cloud Run.
A pull request produces test and security results but cannot deploy to production. A merge to the protected default branch builds one immutable image. That image is promoted to staging and, after approval, to production. The workflow authenticates to cloud APIs with GitHub Actions OIDC federation rather than long-lived cloud credentials.
| Assumption | Planning value |
|---|---|
| Daily users | 10,000–100,000 |
| Average API traffic | 15 requests/s; design for short bursts around 100 requests/s |
| Data volume | 100–500 GB in the primary relational database, excluding backups |
| Engineering team | 1–2 teams; roughly 6–12 engineers |
| Environments | Pull-request checks, shared staging, production |
| Monthly infrastructure budget | Assumption: $500–$2,000 for one cloud, excluding support plans and engineering labor |
| Availability target | 99.9% monthly for the application API |
These are sizing assumptions, not measured capacity or a cloud quote. Replace them with traffic profiles, retention requirements, and region-specific prices before committing to a budget.
2) Requirements
Separate what the pipeline must do from the qualities it must preserve. A green workflow is not sufficient evidence of a safe release: the artifact must be traceable, the deployment identity constrained, and rollback practical.
| Functional requirement | Design response |
|---|---|
| Validate proposed changes | Run formatting, compilation, unit tests, dependency checks, and image scanning on pull requests |
| Produce a deployable artifact | Build one OCI image, tag it with the commit SHA, and retain a release manifest |
| Promote through environments | Deploy the same image digest to staging and production; require an approval gate before production |
| Support three clouds | Use a shared build and gate process, plus a cloud-specific authentication, registry, and deployment adapter |
| Preserve release history | Record commit, digest, workflow run, environment, approver, and deployment result |
| Roll back | Redeploy the prior known-good image digest through the normal deployment path |
| Non-functional requirement | Target or constraint |
|---|---|
| Credential safety | OIDC federation, least-privilege roles, no static cloud keys in repository secrets |
| Reproducibility | Pin action references and tool versions; promote immutable image digests rather than mutable tags |
| Deployment safety | Staging verification, production approval, health checks, and bounded rollout |
| Availability | Multi-AZ database and multiple application replicas in production |
| Feedback time | Assumption: pull-request checks usually finish within 10 minutes |
| Auditability | Protected branches, GitHub environments, retained workflow logs, and deployment records |
| Portability | Cloud differences isolated in deployment configuration rather than application build logic |
3) High-level design
The workflow runs on GitHub-hosted runners for ordinary builds. A self-hosted runner is not required at this scale unless private network access, specialized hardware, or policy demands it. For AWS, the application runs on ECS Fargate behind an Application Load Balancer. SQS buffers asynchronous work, ElastiCache serves cacheable reads, and Multi-AZ RDS PostgreSQL stores durable state.
The diagram shows the AWS implementation and the alternatives at the deployment boundary. GitHub Actions does not need to execute inside the application VPC. Cloud access is through short-lived OIDC credentials, and the application’s runtime identity is separate from the deployment role.
flowchart LR dev["Engineer"] --> gh["GitHub pull request and protected branch"] gh --> gha["GitHub Actions: build, test, scan"] gha --> oidc["OIDC federation"] gha --> ecr["Amazon ECR"] oidc --> ecs["Amazon ECS on Fargate"] ecr --> ecs ecs --> alb["Application Load Balancer"] alb --> api[".NET API and worker"] api --> db["Multi-AZ Amazon RDS PostgreSQL"] api --> cache["Amazon ElastiCache for Redis"] api --> queue["Amazon SQS"] queue --> worker["ECS worker"]
The AWS path is the concrete deployment; replace its registry, identity, and runtime adapters for Azure or GCP.
An Azure implementation substitutes Azure Container Registry, Entra workload identity federation, Azure Container Apps, Azure Database for PostgreSQL, Azure Cache for Redis, and Service Bus. A GCP implementation substitutes Artifact Registry, Workload Identity Federation, Cloud Run, Cloud SQL for PostgreSQL, Memorystore, and Pub/Sub. The application should depend on stable interfaces—database, cache, and queue—not on deployment workflow details.
4) Cloud service mapping
Keep the pipeline’s intent common, but do not force identical infrastructure abstractions where cloud behavior differs. Container runtime settings, autoscaling, network ingress, and identity policies need cloud-specific review.
| Component | AWS choice | Azure equivalent | GCP equivalent |
|---|---|---|---|
| CI/CD control plane | GitHub Actions | GitHub Actions | GitHub Actions |
| CI-to-cloud identity | IAM OIDC provider and role | Entra federated credential and service principal | Workload Identity Federation and service account |
| Container registry | Amazon ECR | Azure Container Registry | Artifact Registry |
| Container runtime | ECS on Fargate | Azure Container Apps | Cloud Run |
| HTTP ingress | Application Load Balancer | Container Apps ingress or Application Gateway | Cloud Run ingress or external Application Load Balancer |
| Relational data | Multi-AZ Amazon RDS for PostgreSQL | Azure Database for PostgreSQL Flexible Server | Cloud SQL for PostgreSQL |
| Cache | ElastiCache for Redis | Azure Managed Redis or Azure Cache for Redis, as available for the chosen region and offer | Memorystore |
| Work queue | Amazon SQS | Azure Service Bus | Pub/Sub |
| Secrets | AWS Secrets Manager | Azure Key Vault | Secret Manager |
| Logs and metrics | CloudWatch | Azure Monitor and Log Analytics | Cloud Logging and Cloud Monitoring |
| Infrastructure as code | Terraform | Terraform or Bicep | Terraform |
Cloud-native equivalents are not identical products. For example, queues differ in ordering, delivery, and dead-letter semantics. Confirm those properties against the application’s needs before treating a provider change as a configuration-only migration.
5) Data design
The deployment mechanism does not require a new database. GitHub’s workflow runs, environments, and deployment records are the operational source of truth for a small team. If engineering leadership needs cross-repository release reporting or longer retention, export a narrow release ledger to an existing PostgreSQL reporting store. Do not add a database just to make the pipeline look more “enterprise.”
The following model records immutable artifacts and their environment deployments. Its purpose is reporting and audit, not deciding whether a deployment is authorized.
erDiagram
RELEASE_ARTIFACT ||--o{ DEPLOYMENT : promoted_as
RELEASE_ARTIFACT {
string digest PK
string repository
string commit_sha
string workflow_run_id
timestamp built_at
}
DEPLOYMENT {
string deployment_id PK
string digest FK
string environment
string cloud
string result
timestamp started_at
timestamp completed_at
}The ledger relates each immutable image digest to its build and environment-specific deployment attempts.
A minimal PostgreSQL schema captures the reportable fields. Store secrets nowhere in this schema; store secret references or identifiers only if they are needed for audit.
CREATE TABLE release_artifact (
digest text PRIMARY KEY,
repository text NOT NULL,
commit_sha text NOT NULL,
workflow_run_id text NOT NULL,
built_at timestamptz NOT NULL DEFAULT now()
);
CREATE TABLE deployment (
deployment_id text PRIMARY KEY,
digest text NOT NULL REFERENCES release_artifact(digest),
environment text NOT NULL CHECK (environment IN ('staging', 'production')),
cloud text NOT NULL CHECK (cloud IN ('aws', 'azure', 'gcp')),
result text NOT NULL CHECK (result IN ('started', 'succeeded', 'failed', 'rolled_back')),
started_at timestamptz NOT NULL DEFAULT now(),
completed_at timestamptz
);
CREATE INDEX deployment_environment_started_idx
ON deployment (environment, started_at DESC);
For most teams, a retained JSON release manifest attached to the workflow run is enough. Add the ledger only when a real reporting, retention, or audit requirement exists.
6) Low-level design
Treat the workflow as a release state machine: validate the change, build and identify the artifact, deploy to staging, verify it, then promote the exact digest to production. A failure should stop the transition, not trigger an alternate build. Cloud-specific adapters own registry authentication and deployment commands; shared gates own test and promotion policy.
classDiagram
class ReleaseWorkflow {
+validate()
+build()
+promote(environment)
}
class QualityGate {
+runTests()
+scanDependencies()
+scanImage()
}
class Artifact {
+commitSha
+imageDigest
+manifest
}
class DeployTarget {
+authenticate()
+publish(artifact)
+deploy(artifact, environment)
+verify()
}
class AwsTarget
class AzureTarget
class GcpTarget
ReleaseWorkflow --> QualityGate
ReleaseWorkflow --> Artifact
ReleaseWorkflow --> DeployTarget
DeployTarget <|-- AwsTarget
DeployTarget <|-- AzureTarget
DeployTarget <|-- GcpTargetThe shared release policy calls one cloud target adapter, while all targets consume the same artifact identity.
A minimal application health endpoint gives the deployment verifier a fast way to check that the new revision started. It is not a substitute for readiness checks against required dependencies.
var builder = WebApplication.CreateBuilder(args);
var app = builder.Build();
app.MapGet("/health/live", () => Results.Ok(new { status = "live" }));
app.Run();
Notice that liveness reports process health only; keep dependency readiness and synthetic user checks separate.
For a production API, instrument a named activity source and emit structured logs with release identity. The same trace context should flow through HTTP handlers and supported messaging instrumentation. Use the image digest or commit SHA as a deployment attribute, not as a metric label with unbounded cardinality.
using System.Diagnostics;
var builder = WebApplication.CreateBuilder(args);
builder.Services.AddOpenTelemetry()
.WithTracing(tracing => tracing
.AddAspNetCoreInstrumentation()
.AddHttpClientInstrumentation()
.AddSource("Example.ReleaseApi")
.AddOtlpExporter());
var app = builder.Build();
var source = new ActivitySource("Example.ReleaseApi");
app.MapPost("/jobs", (ILogger<Program> logger, HttpContext context) =>
{
using var activity = source.StartActivity("jobs.accept");
activity?.SetTag("deployment.environment", app.Environment.EnvironmentName);
var requestId = context.TraceIdentifier;
logger.LogInformation(
"Accepted job {RequestId} for release {ReleaseSha}",
requestId,
Environment.GetEnvironmentVariable("RELEASE_SHA") ?? "unknown");
return Results.Accepted();
});
app.Run();
Notice that telemetry is emitted through standard .NET and OpenTelemetry APIs, so the collector or backend can change without changing request behavior.
7) Key flows
A pull request should fail early and visibly. It does not need cloud deployment credentials: unit tests, dependency checks, and image scans can run without permission to alter infrastructure.
sequenceDiagram participant E as Engineer participant G as GitHub participant A as GitHub Actions participant T as Test and scan tools E->>G: Open pull request G->>A: Start validation workflow A->>T: Restore, build, test, and scan T-->>A: Results and findings A-->>G: Required checks pass or fail G-->>E: Publish check status
The pull-request workflow provides evidence for merge; it does not deploy or receive production credentials.
The release flow builds once, pushes an immutable artifact, and promotes it across environments. Production approval belongs in a GitHub environment with required reviewers and branch restrictions. A deployment command should wait for the platform rollout and then run an application-level verification.
sequenceDiagram participant G as GitHub participant A as GitHub Actions participant I as Cloud identity participant R as Container registry participant S as Staging runtime participant P as Production runtime G->>A: Merge protected branch A->>A: Build, test, scan, record digest A->>I: Exchange GitHub OIDC token I-->>A: Short-lived deployment credentials A->>R: Push immutable image A->>S: Deploy image digest S-->>A: Health and smoke checks A->>G: Request production approval G-->>A: Approval granted A->>P: Deploy same image digest P-->>A: Rollout and health result
Promotion changes the environment, not the artifact; a failed gate prevents production deployment.
8) Build and release
The following Terraform fragment provisions an ECR repository with immutable tags and a bounded retention policy. Production infrastructure also needs an ECS service, task definition, networking, database, queue, and narrowly scoped IAM roles; those are deliberately omitted rather than compressed into a misleading “complete” snippet. Use separate state and permissions for application runtime and GitHub deployment identities.
resource "aws_ecr_repository" "app" {
name = "release-api"
image_tag_mutability = "IMMUTABLE"
image_scanning_configuration {
scan_on_push = true
}
encryption_configuration {
encryption_type = "AES256"
}
}
resource "aws_ecr_lifecycle_policy" "app" {
repository = aws_ecr_repository.app.name
policy = jsonencode({
rules = [{
rulePriority = 1
description = "Expire old untagged images"
selection = {
tagStatus = "untagged"
countType = "imageCountMoreThan"
countNumber = 20
}
action = { type = "expire" }
}]
})
}
Notice that immutable tags prevent an accidental overwrite, while the digest remains the authoritative promotion identifier.
This workflow is an illustrative single-cloud-target release. Configure one target’s GitHub variables and OIDC identity, then select that target at dispatch. Pin third-party actions to reviewed full commit SHAs in production; major-version references below make the workflow readable but are not a substitute for dependency pinning. The image is saved as a workflow artifact so the deployment job can authenticate and push it to the selected cloud registry.
name: release
on:
pull_request:
push:
branches: [main]
workflow_dispatch:
inputs:
target:
description: Cloud deployment target
type: choice
options: [aws, azure, gcp]
required: true
permissions:
contents: read
jobs:
validate:
runs-on: ubuntu-latest
permissions:
contents: read
steps:
- uses: actions/checkout@v4
- uses: actions/setup-dotnet@v4
with:
dotnet-version: "10.0.x"
- run: dotnet restore
- run: dotnet build --no-restore --configuration Release
- run: dotnet test --no-build --configuration Release
- run: dotnet list package --vulnerable --include-transitive
- run: docker build --tag release-api:${{ github.sha }} .
- name: Scan image
run: |
docker run --rm -v /var/run/docker.sock:/var/run/docker.sock \
aquasec/trivy:0.58.1 image --exit-code 1 \
--severity HIGH,CRITICAL release-api:${{ github.sha }}
- name: Save image
if: github.event_name != 'pull_request'
run: docker save release-api:${{ github.sha }} -o image.tar
- uses: actions/upload-artifact@v4
if: github.event_name != 'pull_request'
with:
name: image
path: image.tar
retention-days: 7
deploy:
if: github.event_name == 'push' || github.event_name == 'workflow_dispatch'
needs: validate
runs-on: ubuntu-latest
environment: ${{ github.event_name == 'push' && 'staging' || 'production' }}
permissions:
contents: read
id-token: write
steps:
- uses: actions/download-artifact@v4
with:
name: image
- run: docker load --input image.tar
- name: Configure AWS identity
if: inputs.target == 'aws' || github.event_name == 'push'
uses: aws-actions/configure-aws-credentials@v4
with:
role-to-assume: ${{ vars.AWS_DEPLOY_ROLE_ARN }}
aws-region: ${{ vars.AWS_REGION }}
- name: Login to ECR
if: inputs.target == 'aws' || github.event_name == 'push'
id: ecr
uses: aws-actions/amazon-ecr-login@v2
- name: Push and deploy to AWS
if: inputs.target == 'aws' || github.event_name == 'push'
env:
REGISTRY: ${{ vars.AWS_ECR_REGISTRY }}
REPOSITORY: ${{ vars.AWS_ECR_REPOSITORY }}
IMAGE_TAG: ${{ github.sha }}
run: |
docker tag release-api:${IMAGE_TAG} ${REGISTRY}/${REPOSITORY}:${IMAGE_TAG}
docker push ${REGISTRY}/${REPOSITORY}:${IMAGE_TAG}
aws ecs update-service --cluster "${{ vars.AWS_ECS_CLUSTER }}" \
--service "${{ vars.AWS_ECS_SERVICE }}" --force-new-deployment
Notice that this excerpt fully illustrates AWS authentication and deployment; add equivalent Azure and GCP conditional steps or call reviewed reusable workflows for those targets.
The example’s target selection is intentionally incomplete for Azure and GCP: a real workflow should make target choice explicit for every event, then add cloud-specific OIDC login, registry push, and deployment steps. Do not let a default-branch push silently choose a production cloud. A clearer production design often separates reusable build.yml from protected, cloud-specific deployment workflows, each accepting an image digest as input. The GitHub documentation covers OIDC in cloud providers.
Use a staged test strategy:
| Test type | Run when | What it should prove |
|---|---|---|
| Unit | Every pull request | Domain rules and pure application behavior, quickly and without cloud dependencies |
| Integration | Pull request or merge | Database migrations, queue behavior, cache interaction, and serialization against disposable dependencies |
| Contract | Pull request and scheduled | Compatibility of API schemas and event messages with their consumers |
| Load | Before significant releases and after capacity changes | Latency, saturation, autoscaling response, and database connection behavior at an agreed workload |
| Smoke | After each deployment | Critical route, authentication, and one representative dependency path work in that environment |
For cloud-specific identity, follow the official guides for AWS GitHub OIDC, Azure login with OIDC, and Google Cloud Workload Identity Federation. Restrict trust by repository, branch or environment, and audience where the provider supports it. A role that can deploy one service should not be able to administer the whole account or subscription.
9) Observability
Pipeline observability and application observability answer different questions. The workflow should report which commit was built, which image digest was published, which identity deployed it, which environment changed, and how rollout verification ended. The application should expose request behavior and resource pressure independently of GitHub Actions.
Emit structured logs to standard output in the application and let the cloud runtime collect them. For workflow logs, include stable identifiers in step output and avoid printing tokens, connection strings, or full environment dumps.
{
"timestamp": "2026-11-08T12:00:00Z",
"level": "Information",
"event": "deployment.verified",
"repository": "example/release-api",
"commit_sha": "abc123",
"image_digest": "sha256:...",
"environment": "staging",
"cloud": "aws",
"workflow_run_id": "123456",
"result": "succeeded",
"duration_ms": 42000
}
Use commit and digest fields to join workflow records to runtime logs without logging credentials or user data.
Use RED (rate, errors, duration) for HTTP services and USE (utilization, saturation, errors) for resources. Track queue age and dead-letter volume as application signals; they are often more useful than a generic worker “up” indicator. OpenTelemetry spans should carry trace context through inbound HTTP and supported outbound calls. The .NET example above uses OTLP export; configure the endpoint and authentication through environment-specific secret management.
| SLI | SLO | Measurement |
|---|---|---|
| API availability | 99.9% monthly | Successful eligible requests divided by eligible requests |
| API latency | 95% under 500 ms for the agreed request mix | Server-side request duration, excluding explicitly documented long-running routes |
| Release health | 95% of deployments complete without rollback | Successful production deployments divided by production deployments |
| Queue freshness | 99% of jobs start within 2 minutes | Enqueue-to-start time, split by queue and priority |
Dashboards should include request rate, error rate, latency percentiles, replica count, CPU and memory, database connections and storage, cache hit behavior, queue depth and oldest-message age, and deployment annotations. Keep environment and service as bounded labels. Do not label metrics with request IDs, user IDs, commits, or arbitrary exception text.
Page on sustained customer impact or imminent loss of recovery options: API error-budget burn, production availability below its SLO, database storage approaching its operational limit, exhausted database connections, persistent queue age beyond its SLO, or repeated failed production rollouts. Route non-urgent CPU peaks, isolated test failures, and staging-only alerts to dashboards or team notifications rather than waking an on-call engineer.
10) Security and compliance
A release pipeline is privileged software. Treat workflow files, action dependencies, build inputs, and deployment roles as part of the production attack surface.
- Require pull requests, protected branches, code-owner review for workflow and infrastructure changes, and required checks before merge.
- Use OIDC federation and short-lived credentials. Scope trust to the intended repository and GitHub environment; scope cloud permissions to the specific registry and runtime service.
- Pin third-party actions to reviewed commit SHAs, update them through a controlled dependency process, and review changes to reusable workflows.
- Build from a clean checkout. Do not execute untrusted pull-request code with production secrets or write permissions.
- Scan dependencies and container images, define a vulnerability exception process, and retain evidence of approved exceptions.
- Use immutable image digests, registry retention rules, and signed or attested build provenance where the organization’s tooling supports it.
- Separate deployment identity from application runtime identity. The application should have only the permissions it needs for its queue, database secrets, and other runtime dependencies.
- Keep secrets in the cloud secret manager; avoid placing secret values in workflow inputs, artifacts, logs, or Terraform state.
- Encrypt data in transit and at rest, restrict database network access, and establish backup retention and deletion policies for the relevant jurisdiction.
This design does not claim a particular compliance certification. Map evidence retention, access reviews, approval requirements, and vulnerability remediation timelines to the actual regulatory and contractual obligations.
11) Cost
The figures below are assumption-based monthly estimates, not quoted prices. They assume one production environment and one small staging environment in a single region, moderate traffic, a modest managed PostgreSQL instance with Multi-AZ production availability, basic cache and queue use, and GitHub-hosted runners. They exclude engineering labor, taxes, premium support, cross-region disaster recovery, and substantial data egress. Region, storage, backup retention, network topology, and actual workload can materially change the result.
| One-cloud deployment option | Assumption-based monthly estimate | Main cost drivers |
|---|---|---|
| AWS: ECS Fargate, ALB, RDS PostgreSQL, ElastiCache, SQS, ECR | $500–$1,500 | Multi-AZ database, always-on tasks, load balancer, NAT and data transfer |
| Azure: Container Apps, PostgreSQL Flexible Server, managed cache, Service Bus, ACR | $450–$1,400 | Database tier and HA, minimum replicas, ingress and network egress |
| GCP: Cloud Run, Cloud SQL, Memorystore, Pub/Sub, Artifact Registry | $400–$1,300 | Cloud SQL availability and sizing, minimum Cloud Run instances, cache and egress |
The lower end assumes modest utilization and disciplined non-production shutdowns. The upper end allows more database capacity, higher availability overhead, and less predictable network cost. Do not interpret the ranges as a like-for-like quote: service billing models and included capabilities differ.
CI cost is separate from cloud runtime cost. Track runner minutes, artifact retention, and registry storage. Set a budget alert before a cost target becomes a hard operating limit, and verify the actual deployment plan with each provider’s pricing calculator and current regional prices.
12) Failure modes, resilience and disaster recovery
| Failure mode | Likely effect | Response |
|---|---|---|
| Test or scan fails | Release blocked | Fix the change or document an approved exception; never skip the gate to meet a routine deadline |
| OIDC trust or role policy is wrong | Deployment cannot authenticate | Fail closed; inspect federation claims and audit logs, then correct trust scope |
| Registry push succeeds but deployment fails | New image exists but runtime stays old | Keep the prior revision available; retry or redeploy the previous digest |
| Migration is incompatible with rollback | Old application cannot use new schema | Use expand-and-contract migrations and defer destructive changes until old code is no longer running |
| Cloud control plane is unavailable | Deployment delayed | Keep serving the current revision; retry with bounded backoff and use the provider status page |
| Queue consumer falls behind | Delayed background work | Scale workers within database and downstream limits; inspect oldest-message age and dead letters |
| Region becomes unavailable | Application or data may be unavailable | Restore from tested backups or activate a separately designed recovery region |
At this scale, resilience means a controlled failure and a known recovery path, not automatic active-active operation across clouds. Run multiple application replicas across available zones, use managed database high availability, define queue visibility and retry policies, and ensure that idempotency protects handlers from duplicate delivery.
A rollback is a new deployment of a previous digest, not an attempt to reverse arbitrary database writes. Keep schema changes backward-compatible across at least the transition window. Test restore procedures periodically; a configured backup is not proof that recovery works. Set recovery point and recovery time objectives explicitly before adding cross-region replicas or a second cloud.
13) Evolving to the next scale
Change the design when operational evidence or a concrete requirement justifies it—not because daily users crossed an arbitrary threshold.
- More teams and repositories: extract reusable, versioned GitHub workflows for build, scan, and release policy. Keep application-specific deployment inputs explicit, and avoid a central workflow that hides important security behavior.
- Longer or more constrained builds: use dependency caching and split independent test suites. Move to controlled self-hosted runners only when private network access, specialized tooling, or predictable runner economics justify the maintenance burden.
- Higher deployment frequency: use canary or progressive delivery with automated health analysis. First make telemetry and rollback reliable; gradual traffic shifting without trustworthy signals is ceremony.
- Growing queue and worker load: scale workers independently from the API and set concurrency limits based on database and downstream capacity. Split the worker into a service only when independent scaling or ownership warrants it.
- Cloud-specific requirements: maintain separate infrastructure modules and deployment adapters. A multi-cloud workflow is not multi-cloud resilience; independent data, identity, networking, and failover designs are required for that claim.
- Stronger provenance requirements: add image signing, build attestations, policy verification, and artifact retention aligned to the organization’s threat model and audit obligations.
At every step, preserve the release invariant: tests and scans apply to the artifact that is actually promoted, and the production deployment can be traced to its source commit and build.
14) Phased implementation plan
- Agree on the release contract. Choose the production cloud, define staging and production boundaries, name artifact identifiers, and document rollback and schema compatibility rules.
- Protect the repository. Configure required reviews and checks, own workflow files explicitly, and ensure pull-request workflows do not receive deployment credentials.
- Establish the build and gates. Add restore, build, unit tests, dependency review, container build, and image scanning. Make failures actionable before wiring up deployment.
- Provision one target with infrastructure as code. Create the registry, runtime, least-privilege OIDC role, network access, and required managed services. Keep Terraform state and production permissions protected.
- Deploy to staging. Publish an immutable image, deploy it, wait for rollout, run smoke checks, and record the commit and digest. Test a rollback before production use.
- Add production promotion. Require an environment approval, deploy the same digest, and annotate dashboards with deployment metadata. Define who can approve and who responds to failures.
- Instrument and review. Implement the SLIs, dashboards, and paging rules; exercise database restore and deployment recovery; then tune capacity and cost from observed workload.
- Add another cloud only for a reason. Implement and review that cloud’s identity, registry, runtime, networking, and recovery adapter independently. Reuse the artifact and quality policy, not assumptions about provider equivalence.
The result is deliberately modest: one well-governed release path, one selected production cloud, and clear seams for additional targets. That is enough structure for a medium-scale team to ship frequently without turning CI/CD into a second platform product to operate.
This article was generated with AI. #AIGenerated