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.
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.