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

3. Prepare a C# development container

Keep the chapter 2 environment running. You will attach a separate .NET SDK container to its private network. Edit C# files with your host editor and run dotnet inside that container. The source files remain on your host.

The supplied quinzee.test container already has working DNS and CA trust, but contains the .NET runtime, not an interactive SDK toolchain. Do not install development tools into it. The separate SDK container below shares the network and public trust bundle without receiving CA signing keys or a Docker socket. The SDK image includes the compiler and build tools. A runtime image contains what an already-built application needs to execute, so dotnet build belongs in the SDK container below.

Step 1: prepare a private tutorial directory

Run this on the host, from the repository root, after the application prints its URL:

umask 077
mkdir -p .local/book/project
python3 - <<'PYSETUP'
from pathlib import Path
import copy, json, secrets, shutil
import xml.etree.ElementTree as ET
base = Path('.local/application/development')
source = json.loads((base / 'client/settings.json').read_text())
book = Path('.local/book')
settings = book / 'settings.json'
if not settings.exists():
    prefix = 'bk' + secrets.token_hex(4)
    settings.write_text(json.dumps({
        **{key: source[key] for key in ('tenantId', 'clientId', 'clientSecret', 'subscriptionId')},
        'prefix': prefix, 'group': 'quinzee-book-' + prefix,
        'databasePassword': secrets.token_urlsafe(24)
    }))
    settings.chmod(0o600)
# Reuse the repository's verified package versions and complete lock file.
project = ET.Element('Project', Sdk='Microsoft.NET.Sdk')
properties = ET.SubElement(project, 'PropertyGroup')
for name, value in {'OutputType':'Exe', 'TargetFramework':'net10.0',
                    'ImplicitUsings':'enable', 'Nullable':'enable',
                    'RestorePackagesWithLockFile':'true'}.items():
    ET.SubElement(properties, name).text = value
items = ET.SubElement(project, 'ItemGroup')
ET.SubElement(items, 'FrameworkReference', Include='Microsoft.AspNetCore.App')
for package in ET.parse('test/backend/Quinzee.Test.csproj').findall('.//PackageReference'):
    items.append(copy.deepcopy(package))
ET.indent(project)
ET.ElementTree(project).write(book / 'project/BookClient.csproj', encoding='unicode')
shutil.copyfile('test/backend/packages.lock.json', book / 'project/packages.lock.json')
PYSETUP

This creates independent tutorial resource names and a database password while using the local tenant's application identity. It never prints secrets. Reusing this directory reuses the same tutorial resources. If you recreate the entire application environment, prepare a new tutorial directory for its new identity.

The packages include Azure.Identity, the ARM/deployment clients, Blob and Queue clients, Key Vault, App Configuration, Azure Monitor exporters/query clients, and Npgsql/MySqlConnector/StackExchange.Redis. The extra ASP.NET Core framework reference makes the logging examples available to this console app. The generated project and caches stay under Git-ignored .local/.

Step 2: attach the SDK container

On the host:

book_env="$PWD/.local/application/development"
book_network=$(python3 -c 'import json,sys; print(json.load(open(sys.argv[1]))["project"] + "_quinzee")' "$book_env/environment.json")
book_dns=$(python3 -c 'import json,sys; print(json.load(open(sys.argv[1]))["networkPrefix"] + ".53")' "$book_env/environment.json")
docker run --rm -it \
  --user "$(id -u):$(id -g)" --cap-drop ALL \
  --security-opt no-new-privileges \
  --network "$book_network" --dns "$book_dns" \
  --mount "type=bind,src=$PWD/.local/book/project,dst=/work" \
  --mount "type=bind,src=$PWD/.local/book/settings.json,dst=/run/book/settings.json,readonly" \
  --mount "type=bind,src=$book_env/client/trust.pem,dst=/run/book/trust.pem,readonly" \
  --mount "type=bind,src=$book_env/client/engine-ca.crt,dst=/run/book/engine-ca.crt,readonly" \
  --env SSL_CERT_FILE=/run/book/trust.pem \
  --env DOTNET_CLI_HOME=/tmp --env NUGET_PACKAGES=/work/.nuget \
  --env DOTNET_CLI_TELEMETRY_OPTOUT=1 \
  --env APPLICATIONINSIGHTS_STATSBEAT_DISABLED=true \
  --workdir /work \
  mcr.microsoft.com/dotnet/sdk:10.0@sha256:fe0fd4e93bd2fbb47c883b7a6369e5c8d3db8bf01cdc5981f6ee35fbdf3ff4fb bash

The SDK image is pinned to the digest used to verify these examples, and the NuGet dependency graph is locked. Update the image deliberately when adopting .NET servicing updates, then rerun your application checks. The trust.pem bundle contains public roots for HTTPS services and native engines, as well as ordinary public internet roots used for package restoration.

Step 3: verify DNS and trust before authenticating

In the client container:

dotnet --version
getent hosts management.azure.com
getent hosts login.microsoftonline.com
curl --fail --silent --show-error https://management.azure.com/health

Both names must resolve to the application environment's cloud address (networkPrefix plus .10 in environment.json). The HTTPS response must identify quinzee.cloud. If either check fails, fix DNS/trust before running credentialed examples. Joining the network alone does not select Quinzee DNS; --dns is essential.

Azure emulation is already enabled by the application helper. On a separately started make cloud-up environment, enable it explicitly in QHQ's DNS page; see certificates and DNS.

Step 4: restore and begin editing

In the client container:

dotnet restore --locked-mode

On the host, open .local/book/project in your editor. In chapter 4, create BookContext.cs and Program.cs there. Build/run in this container with:

dotnet run --no-restore

Each following chapter replaces Program.cs. The context, project, lock file, compiled template and deployment outputs remain in the same directory. You can use your editor's container-attach feature if you prefer running its terminal and debugger in the SDK container. No host-wide CA installation or DNS change is needed for this development path.

Moving your application to Azure

Keep credentials and resource endpoints in configuration. The C# service clients use normal Microsoft URLs; remove the local DNS/trust setup and supply actual Azure credentials/resources in the Azure environment. First check your app against real Azure permissions and any features outside the local subset. Compatibility here is not evidence that production RBAC, resilience or scale has been tested.