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.
16. Follow a packet through names, sockets and namespaces
A hostname is not a listening socket. DNS maps a name to an address; a TCP port selects a listener at that address; TLS authenticates the server name; HTTP host and path select the service. A failure at one layer cannot be fixed by changing an unrelated layer.
Trace a native HTTPS request
For https://localhost:11443/health, the client resolves localhost and opens a
TCP connection. The server's listening descriptor accepts a new socket. OpenSSL
performs TLS through Asio; Beast parses decrypted HTTP bytes. The listener's I/O
thread advances connection state and dispatches service work to the executor.
The completion returns to that connection's executor for serialization and
socket writes. Keep-alive can reuse the accepted socket for another request.
client resolver -> address:port -> TCP accepted socket -> TLS
-> HTTP parse -> bounded request queue -> module handler
-> completion on connection executor -> TLS records -> client
Nonblocking socket I/O means a thread need not wait for every byte. It does not make every service operation nonblocking: JSON persistence, SQLite commits and some outbound calls occupy a service worker while they execute. When the 64-item queue is full, the executor returns 503 rather than creating more workers. Increasing a Unix file-descriptor limit does not remove that queue bound.
Understand the standard Docker network
Compose creates a private bridge network with cloud address 172.29.53.10 and
CoreDNS 172.29.53.53 by default. Each container has its own network namespace,
interfaces and loopback. Docker connects it to the bridge and provides host-port
publication. The exact firewall/proxy mechanism depends on Docker's setup; the
important observable mapping is host loopback 11443 to cloud-container 11443.
Inside an application container, 127.0.0.1 means that application container.
It does not mean the operator host or Quinzee Cloud. Joining the bridge also
does not select CoreDNS: the client must use the configured DNS server.
| Connection | Standard destination |
|---|---|
| Host to native cloud HTTPS through Compose | localhost:11443, published by Docker |
| Lab container to native cloud APIs | quinzee.cloud:11443 on the private network |
| Lab container to Azure-name HTTPS | Supported Azure hostname on private port 443 |
| Host DNS diagnostic | localhost:10053, UDP or TCP publication to CoreDNS:53 |
| Service Bus AMQP | Namespace hostname, TLS port 5671 when enabled |
| Native SQL/cache client | Engine container's published DNS address, ports 5432/3306/10000 |
| Cloud gateway to Functions/web runtime | Selected workload IP, verified hostname, TLS port 8443 |
The cloud does not proxy SQL or Redis protocol bytes through its HTTPS listener. Provisioning uses ARM; application queries go to the real engine.
Inspect each layer independently
These host commands assume the standard Compose lab already exists. ss comes
from iproute2, dig from a DNS client package, and the TLS probe uses OpenSSL:
ss -ltn
ss -lun
docker compose port quinzee-cloud 11443
dig @127.0.0.1 -p 10053 quinzee.cloud A +short
openssl s_client -connect localhost:11443 -servername localhost \
-verify_hostname localhost -verify_return_error \
-CAfile .local/certificates/ca/quinzee-dev-root-ca.crt </dev/null
curl --fail --silent --show-error \
--cacert .local/certificates/ca/quinzee-dev-root-ca.crt \
https://localhost:11443/health
A correct A record with a refused TCP connection points toward binding, routing, publication or process state. A successful TCP connection with failed TLS points toward certificate name, chain or trust. Successful TLS with 401/403 means you have reached an authentication/authorization boundary. Do not skip those tests by disabling certificate checks.
Distinguish TLS names from network destinations
HTTP native and Azure-name emulation use separate listener/certificate contexts. The host's certificate must cover the name the client verifies. Changing the HTTP Host header does not change the certificate already received during TLS. The Service Bus AMQP TLS adapter separately supports its configured native and Azure namespace certificates; it is not the HTTP listener's certificate switch.
For an upstream hosted app, the gateway connects to the helper-selected IP but still verifies the app hostname and its constrained runtime CA. Connecting to an IP is therefore compatible with strict name validation when the client deliberately carries the correct TLS server name. It is not permission to turn verification off.
Look inside the container boundary without dumping secrets
cloud_container=$(docker compose ps -q quinzee-cloud)
docker inspect --format '{{json .NetworkSettings.Networks}}' "$cloud_container"
docker inspect --format '{{.HostConfig.ReadonlyRootfs}} {{json .HostConfig.CapDrop}}' \
"$cloud_container"
Network namespaces isolate addresses; mount namespaces isolate filesystem views; cgroups bound workload resources; UIDs and filesystem modes govern access to shared files. These mechanisms cooperate but do not substitute for one another. A read-only container root still permits writes into an explicitly writable bind mount. A host bind mount refers to host inodes; it is not automatically a private copy. Docker/user-namespace mappings can alter how numeric IDs appear, so check the actual host and container ownership when diagnosing access failures.
The cloud uses no Docker socket. CoreDNS sees the generated zone directory only. The standard cloud runs without Linux capabilities and uses a container-local unprivileged-port setting for port 443. CoreDNS has its separately documented port-53 setup. Neither configuration requires making the whole host's ports unprivileged.