SSLZ Agent documentation · Launch the agent · Classic direct-operator site

Startup Workload Profiles

Opinionated workload choices for agent-assisted SSLZ planning

Status

These profiles are implemented by the dependency-free, read-only workload planner. They do not add or change deployable examples.

Run the planner with a local startup input:

./scripts/startup-workload-plan.sh plan \
  --input agent/examples/startup-input.json \
  --output json

The output conforms to agent/schemas/workload-profile-plan.schema.json. It includes the profile version, selection rationale, assumptions, required checks, unresolved decisions, and cost assumptions. The command makes no Azure calls, writes no files, and always reports iacGenerated: false.

A ready workload profile can be passed with timestamped evidence to the regional and capacity planner. That planner consumes the versioned profile selection and does not change the selected compute profile or extensions.

Profile selection rules

The agent asks only questions that change architecture, cost, or operational ownership. It selects the simplest profile that meets the stated requirements and explains which answer caused each deviation from the default.

The profiles assume:

  • one primary workload;
  • separate prod and non-prod subscriptions;
  • no dedicated platform team;
  • managed services unless the workload requires control that a managed service cannot provide;
  • a single region unless recovery or capacity requirements justify Hot/Cool;
  • the existing SSLZ security, monitoring, cost, and policy baseline.

Discovery questions

Question Why it matters
What does the application do? Establishes workload shape and required services
Is traffic HTTP, event driven, scheduled, or mixed? Selects compute and scaling model
Does the team require Kubernetes APIs or cluster-level control? Distinguishes AKS from Container Apps
Does the workload use a relational database? Selects PostgreSQL when appropriate
Does it call Foundry-managed models? Adds model, quota, filtering, and regional checks
Does it run or train a custom model on GPU? Adds GPU quota, SKU, and AKS requirements
What data residency boundary applies? Restricts primary and secondary regions
What are the target RTO and RPO? Selects single-region or Hot/Cool readiness
What monthly platform budget is acceptable? Prevents unsuitable services and standby scale
Who owns production incidents? Determines whether the operational burden is supportable
Is AKS ingress private or a public Azure Load Balancer? Prevents generic AKS selection from silently creating public exposure

Decision order

  1. Start with Container Apps.
  2. Select AKS only when a stated requirement needs Kubernetes or customer-managed GPU nodes.
  3. Add PostgreSQL only when the workload needs relational persistence.
  4. Prefer Foundry-managed models over customer-managed model serving.
  5. Keep the profile single-region unless the founder provides a recovery or capacity requirement.
  6. Stop and recommend further architecture review when the workload falls outside SSLZ boundaries.

Docker packaging is input context only. It is never an AKS selection reason.

Profile: Container Apps

Default for: HTTP APIs, web applications, background workers, scheduled jobs, and event-driven services.

Why it is the default: Container Apps provides managed ingress, autoscaling, health monitoring, revisions, and scale to zero, and the startup does not have to operate Kubernetes.

Baseline decisions:

  • workload-profiles environment;
  • VNet integration when private service access is selected;
  • managed identity for Azure service access;
  • startup, readiness, and liveness probes;
  • min replicas of zero for nonprod unless startup latency requires otherwise;
  • production min replicas based on the availability target;
  • Log Analytics and application telemetry;
  • secrets referenced from Key Vault, not copied into IaC parameters.

Select AKS instead when:

  • the application requires Kubernetes APIs, operators, admission controllers, or custom schedulers;
  • a service mesh is a documented requirement;
  • the team requires cluster-level networking behavior unavailable in Container Apps;
  • custom GPU model serving requires Kubernetes scheduling and device plugins;
  • the workload depends on a Kubernetes ecosystem component that cannot run as a regular container.

Do not select AKS because the team already uses Docker or expects future scale. Container Apps supports containerized applications and horizontal scaling without cluster operations.

Profile: AKS

Default for: none. AKS is an exception that requires a recorded justification.

Prerequisites:

  • an engineer owns cluster upgrades, node-image upgrades, capacity, networking, and incident response;
  • production uses the Standard tier and uptime SLA;
  • the region and selected VM SKUs pass quota and capacity checks;
  • address space supports node, pod, upgrade-surge, and failover growth;
  • application workloads run on user node pools;
  • system and user workloads are separated;
  • production workloads use multiple replicas, disruption budgets, and topology spread constraints.
  • ingress is explicitly private (ClusterIP) or public-azure-load-balancer (one exact frontend-to-NodePort path);
  • public client source prefixes, the Azure Load Balancer probe, and existing NSG priorities are reviewed before planning.

Startup limits:

  • begin with one system pool and one user pool;
  • add a GPU pool only when required;
  • avoid service mesh, private cluster, custom egress, and many node pools unless a current requirement justifies them;
  • use cluster autoscaler or node autoprovisioning only after validating quota headroom and workload compatibility.

If the founder cannot name an owner for AKS operations, the agent returns to the Container Apps profile or stops for manual architecture review.

The planner also stops when ingress is omitted, a public service is requested under private mode, an arbitrary NodePort range is supplied, or the exact probe/source/priority constraints cannot be proven. The normalized ingress decision and its planning-only postcheck placeholders are copied unchanged into regional planning, IaC parameters, readiness, the deployment manifest, and the signed approval.

Profile: Foundry application

This profile extends Container Apps or AKS. It is not a standalone compute profile.

Preferred path: use a Foundry-managed model when it meets functional, data, latency, and throughput requirements.

Required checks:

  • model and deployment type are available in the selected region;
  • quota is sufficient for the expected throughput;
  • content filtering settings fit the application and have an identified owner;
  • application retries, timeouts, and fallback behavior are defined;
  • model endpoint access uses managed identity where supported;
  • token usage, latency, throttling, and content-filter outcomes are monitored.

Model availability and current capacity must be validated in both regions for Hot/Cool. A paired region does not guarantee the same model, version, deployment type, or capacity.

Profile: PostgreSQL

Use Azure Database for PostgreSQL when the workload needs relational data and PostgreSQL compatibility.

PostgreSQL selection uses the separate dependency-free regional planner:

node scripts/startup-postgresql-plan.mjs plan \
  --input agent/examples/postgresql-regional-plan-input.json \
  --output json

Candidate evidence is point-in-time and region-specific. It records service availability, exact edition/tier/SKU, engine major and minor version, extensions, zone support, quota eligibility, capacity state, residency, estimated monthly cost, and source observation/expiry. Unsupported edition or version, extension mismatch, insufficient quota, unavailable capacity, unknown or stale capacity, policy denial, residency rejection, unsupported recovery targets, and cost-ceiling breaches remain distinct blocking reasons.

Every candidate also emits an auditable runtime result for each PostgreSQL catalog check: edition/version, extensions, quota, capacity, recovery, and Bicep/Terraform parameter parity. A fallback can be selected only when all six results pass; stale evidence produces unresolved evidence-backed checks, and readiness revalidates the exact check set before IaC planning.

Nonprod default:

  • Burstable compute when supported by the workload;
  • no high-availability standby;
  • backup retention appropriate for development data;
  • private access only when the workload profile already justifies private networking.

Production default:

  • General Purpose unless measured demand supports another tier;
  • zone-redundant high availability when the business requires zone resilience and the region supports it;
  • managed identity or Microsoft Entra authentication where application support allows;
  • alerts for availability, storage, connections, CPU, and failed authentication;
  • tested backup restore procedure.

Cross-region recovery requires an explicit data plan. A secondary application environment without replicated or restorable data does not provide recovery.

When the requested region is ineligible, the planner ranks only exact eligible alternatives. It never lowers the engine version, changes tier or SKU, drops an extension or feature, weakens zone/RTO/RPO requirements, exceeds the cost ceiling, or claims that point-in-time availability is reserved capacity. No eligible alternate means blocked, not a best-effort downgrade.

The current repository has no reviewed PostgreSQL Flexible Server Bicep or Terraform deployment module. The planner therefore emits provider-equivalent planning parameters and immutable evidence bindings only. deploymentBoundary is planning-only, azureOperations is none, and neither provider artifact creates a PostgreSQL server.

Profile: Customer-managed GPU

Use only when managed models cannot satisfy the workload.

Required checks:

  • training or serving requirement that needs direct GPU control;
  • eligible GPU SKU in the subscription and region;
  • current quota headroom;
  • a second acceptable SKU or region;
  • container image and model-artifact strategy;
  • startup, readiness, and liveness behavior;
  • interruption tolerance before using Spot;
  • expected utilization and monthly cost.

GPU Spot is suitable for interruptible training, batch inference, and workloads designed to reschedule. It is not the default for a latency-sensitive production endpoint.

Composition examples

Founder need Selected composition
Web API with background jobs Container Apps
SaaS API with relational data Container Apps + PostgreSQL
AI assistant using managed models Container Apps + Foundry + optional PostgreSQL
Custom GPU inference with Kubernetes requirements AKS + GPU pool + storage
AI application with defined regional recovery Compute profile + Foundry + data profile + Hot/Cool plan

Stop conditions

The agent stops for architecture review when any of these apply:

  • more than one independent production workload;
  • five or more subscriptions;
  • regulated workload with controls beyond the SSLZ baseline;
  • hybrid connectivity or centralized egress inspection;
  • active/active multi-region writes;
  • a business requirement for automatic failover that has no tested data strategy;
  • a dedicated platform team requesting enterprise-wide shared services;
  • the architecture requires services that no current profile covers.

When one applies, use the Graduation Guide instead of expanding the startup profiles.

Official guidance