quinzee.cloud

Development edition · 16 November 2026. Commands using repository paths, Make targets or sample projects require access to the Quinzee source checkout. No public installer is available. Examples use disposable local environments.

Developer’s guide

22. Host a web application

Azure App Service runs an application as a service. Quinzee's Linux container subset runs your real web process behind HTTPS. Start with the disposable example on the host:

make app-service-test

It builds a small ASP.NET Core app and verifies its gateway, identity and lifecycle in a disposable network. That test image has a token-returning probe for verification; use the minimal application below for your own shared lab.

Step 1: build your own web image

Create a private working project on the host:

mkdir -p .local/book-web
cp tests/compatibility/app_service/WebFixture.csproj .local/book-web/
cp tests/compatibility/app_service/packages.lock.json .local/book-web/

Save this complete Program.cs there. It has one public route and never returns credentials or workload tokens:

var builder = WebApplication.CreateBuilder(args);
var app = builder.Build();
app.MapGet("/", () => new {
    message = "Hello from my web app",
    greeting = Environment.GetEnvironmentVariable("Greeting")
});
app.Run();

The project targets .NET 10 using the ASP.NET Core shared framework. Publish and package it with the verified runtime Dockerfile:

DOTNET_CLI_HOME="$PWD/.packages/dotnet-home" \
NUGET_PACKAGES="$PWD/.packages/nuget" \
  dotnet publish .local/book-web/WebFixture.csproj -c Release \
  --property:RestoreLockedMode=true --output "$PWD/.local/book-web/publish"
docker build --file tests/compatibility/app_service/Dockerfile \
  --tag quinzee-book-web:local .local/book-web/publish

Step 2: register the image and start its helper

Leave the standalone cloud from make qhq-run running. In another host terminal:

python3 infrastructure/functions/register.py \
  --image quinzee-book-web:local \
  --registry .local/functions-helper/images.json
make functions-run

The registry maps the approved name to an immutable local image ID. The helper runs separately with Docker access, the cloud's data path, its private state, the matching network/DNS and the development CA. QHQ never launches Docker itself. Restart the helper after changing the registry. Keep it running while creating, updating, stopping or deleting apps.

ASP.NET Core uses the helper's injected Kestrel TLS certificate settings and listens on port 8443. The helper checks / for a successful response. An arbitrary HTTP-only container does not satisfy this contract. The process runs non-root with a read-only root and bounded resources; write temporary data only to the provided writable locations and use a real storage service for durable data.

Provision through QHQ

  1. Create a resource group under Resource Manager.
  2. Expand Azure / App Service → App Service plans. Check the subscription Scope in Browse. In Create / Edit enter a name, resource group and location, then Create. The supported plan is Linux B1/Basic with one instance.
  3. Open Web apps. Check the subscription scope, then enter the app name, resource group, location and approved image name quinzee-book-web:local in Create / Edit. Select the plan. Optionally enable the system identity or attach a user-assigned identity. Create the app and refresh until the runtime is Running.
  4. Open https://<app-name>.appservice.quinzee.cloud/ using the configured DNS and trusted CA. The container must serve TLS on port 8443 and respond at /; the provided ASP.NET example already follows this contract.
  5. Select the app in Browse. Use App settings to load setting names, add/replace a private value or remove a selected setting. Existing settings are preserved. Saving settings restarts the container. Secret values are masked and cleared from the input after submission.
  6. Use Start, Stop or Restart for runtime control. Refresh to observe completion. To remove the app, select it and confirm Delete selected. Delete its plan only after removing the apps that use it.

QHQ web-app creation form

The plan selector is populated after creating a plan. Scroll to reach the image, identity and lifecycle controls below this screenshot.

Functions use the same plan/identity/settings controls under Functions → Function apps and retain their real Azure Functions runtime. Application images must match the selected hosting kind. Attachments selected in QHQ preserve other existing user-assigned identities; clearing the attachment checkbox removes all user-assigned attachments. Use ARM for finer-grained multi-identity edits.

A managed identity grants no permissions by itself. Assign Azure resource roles or API app roles using the identity pages. The app receives a protected workload token endpoint, so it need not store a client secret. The normal web endpoint remains the application's responsibility: implement its user authentication and authorization in your code.

Emulator → Modules shows App Service separately from Functions. Unloading App Service blocks its gateway while retaining configuration and running containers; use Stop first if the process must stop. Dependency checks require unloading App Service before Functions. Slots, autoscale, Windows containers, Kudu deployment, Easy Auth and VNet integration are outside this implementation. There is no Azure tenant connection yet.