Azure AI Models, CLI Agents, Rust Ports, and Java/Nginx Patches
As of November 19, 2026, five Azure-adjacent signals deserve attention: model selection, agent-operated CLIs, incremental Rust rewrites, and two runtime vulnerabilities. The common theme is verification. Whether you are
As of November 19, 2026, five Azure-adjacent signals deserve attention: model selection, agent-operated CLIs, incremental Rust rewrites, and two runtime vulnerabilities.
The common theme is verification. Whether you are switching models, granting an agent command-line access, porting an endpoint, or deploying a patch, the safe approach is the same: define the expected behavior, make the change in a controlled environment, and compare the result.
If you operate either affected Java or Nginx runtime, start with the patching sections rather than the experiments.
Five practical Azure engineering workflows
1. Compare seven models in Azure AI Foundry
- What it is: The Azure AI Foundry catalog provides access to the seven models announced at Microsoft Ignite 2026, with workflows for evaluating and calling them.
- Why now: The Ignite 2026 announcement reached 470 points on Hacker News. More model choices do not remove selection work; they make repeatable evaluation more important.
- Tutorial angle: Run one representative workload through all seven models and compare task quality, schema adherence, latency, token usage, and estimated cost. Keep the prompt, model settings, and input data identical. Run each case multiple times to separate model behavior from one-off output, then deploy the winner gradually.
- Difficulty: Intermediate.
A useful benchmark sheet contains:
- Correct task completion
- Required output fields or structure
- p50 and p95 latency
- Input and output token counts
- Published rate-card cost
- Failure and retry rates
- Notes about hallucinations or unsupported claims
For workloads with deterministic answers, automate the correctness check. For open-ended outputs, use a small rubric and save every response for later review. After selecting a winner, canary it against the current production model rather than switching all traffic at once.
-
Start today: Open
https://ai.azure.com, select one of the newly announced models, and paste the same smoke-test prompt into its playground.
2. Give an Azure CLI coding agent a safe contract
- What it is: CLI-Anything is an open-source approach to making command-line software agent-native. In this case, it can expose Azure CLI operations to a coding agent while keeping command discovery, execution, and verification explicit.
-
Why now: The November 19 GitHub Trending snapshot attributed 389 stars to CLI-Anything for the day and 59,886 stars overall. That interest reflects a practical problem: agents often understand the intent of an
azcommand but invent flags, skip confirmation, or fail to explain what changed. - Tutorial angle: Build a small Azure CLI interface, deliberately submit a malformed command, and confirm that it fails with a useful error. Then implement a plan → apply → verify workflow against a disposable resource group.
- Difficulty: Intermediate.
The agent should not receive unrestricted access to a production subscription. Give it a constrained workflow:
- Discover valid operations and parameters.
- Produce an executable plan without changing resources.
- Require approval before applying it.
- Capture the commands and expected changes.
- Read the resulting state and verify it independently.
A disposable resource group is essential for the first run. For example, create a test group, let the agent deploy a small resource, and require the agent to show az group show output before considering the task complete. If the malformed command succeeds—or if verification does not match the plan—the interface is not ready for broader use.
- Start today: Open the CLI-Anything repository search and identify the canonical repository.
3. Port .NET to Rust with differential tests
-
What it is:
rust-anythingis an open-source workflow for rewriting an application incrementally in Rust while comparing the rewritten components against the original application's recorded behavior. - Why now: The repository accumulated 3,547 stars in roughly three days after being created on November 16, making it the strongest new-repository signal in the research report.
- Tutorial angle: Port one .NET endpoint rather than an entire service. Record the original endpoint's request and response fixtures, implement the Rust version, and run both implementations against the same test corpus. Any material mismatch should fail the migration and trigger review or rollback.
- Difficulty: Intermediate.
Good fixtures should cover more than successful responses. Include:
- Different HTTP methods and status codes
- Missing and malformed parameters
- Authentication and authorization failures
- Empty, large, and Unicode payloads
- Database or downstream-service errors
- Response headers and content types
- Stable ordering and timestamps
Normalize values that are expected to change between runs, such as timestamps and generated identifiers. Everything else should match exactly or through an explicitly documented transformation.
The rewrite should remain reviewable as a sequence of small changes. A pull request that replaces an endpoint with a Rust service, adds its fixtures, and demonstrates a passing differential test is much safer than a repository-wide conversion.
-
Start today: Run
gh search repos "rust-anything" --limit 5and open the result that describes the incremental migration workflow.
4. Triage and patch Java4Shell on Azure App Service
- What it is: The Java4Shell advisory describes an unauthenticated remote-code-execution vulnerability associated with OpenJDK Base64 processing. Azure App Service hosting does not automatically make an application vulnerable; the deployed JDK, reachable code path, and runtime configuration determine exposure.
- Why now: The disclosure received 1,156 points and 321 comments on Hacker News during the previous seven days. That makes runtime identification and patching more urgent than another general Azure feature update.
- Tutorial angle: Inventory the actual JDK used by each App Service deployment, compare it with the advisory, update the tested base image, run a benign Base64 compatibility regression, and rehearse a safe redeployment and rollback.
- Difficulty: Intermediate.
Start with deployment metadata rather than the Java version shown in an old configuration file. For App Service, record:
- The container image and digest
- The output of
java -versioninside that image - Whether the application uses a built-in Java stack or its own container
- The App Service configuration and deployment slots
- Internet exposure and relevant authentication settings
A useful inventory command is:
az webapp list --query "[].{name:name,javaVersion:javaVersion,linuxFxVersion:linuxFxVersion,windowsFxVersion:windowsFxVersion}" -o table
Treat this as a starting point, not proof of the running version. Verify the actual image or runtime. Patch a staging deployment first, exercise normal Base64 encoding and decoding with non-sensitive fixtures, and confirm that application behavior is unchanged. Do not attempt exploit payloads against a production application.
-
Start today: Run
java -versioninside the same JDK image used by your Azure build and save the output beside the deployment manifest.
5. Patch the Nginx HTTP/2 RCE exposed through Azure workloads
- What it is: The Nginx HTTP/2 advisory describes an unauthenticated remote-code-execution flaw affecting certain Nginx versions. The risk applies when your workload actually exposes an affected Nginx build, potentially including an Azure App Service deployment using Nginx as a proxy or container.
- Why now: The advisory was the Hacker News front-page leader in the research snapshot, with 1,193 points and 532 comments.
-
Tutorial angle: Identify the deployed Nginx version, compare it with the fixed release, rebuild from a patched image, run
nginx -t, perform a benign HTTP/2 smoke test, and rehearse rollback through an App Service deployment slot. - Difficulty: Intermediate.
The application UI may show an Azure stack name without revealing the exact Nginx build. Inspect the container image and run nginx -v inside the same runtime used in production. Also confirm whether HTTP/2 is enabled and reachable from untrusted networks.
After updating the image:
- Run
nginx -tbefore sending traffic. - Verify that the server starts with the expected configuration.
- Test ordinary HTTP/2 requests with
curl --http2. - Check application logs for startup or proxy errors.
- Shift a small amount of traffic to the patched deployment.
- Keep the previous image available for rollback.
Do not expose a vulnerable build merely to reproduce the advisory. Inventory, patching, and defensive validation are enough for the first remediation pass.
-
Start today: Run
az webapp list --query "[].{name:name,linuxFxVersion:linuxFxVersion}" -o tableto identify App Services that may need an image-level Nginx inspection.
Building in public: my lead-gen engine
Today's run of my Hong Kong SME lead-gen engine discovered 1,776 leads, enriched 201, and recorded 231 contacts. Because the contact count is higher than the enrichment count, these totals should not be interpreted as a strict same-cohort funnel without shared cohort IDs. Publishing the counters makes it easier to identify where the pipeline needs better instrumentation.
- Discovered: 1,776
- Enriched: 201
- Contacted: 231
- Next measurement improvement: join enrichment and contact records with a shared lead or campaign ID
Start with this today
Open https://ai.azure.com, choose one of the seven newly announced models, and paste this exact prompt into its playground:
Write a TypeScript function named chunk<T>(items: T[], size: number): T[][].
Split the array into groups of the requested size while preserving order.
Throw a RangeError when size is not greater than zero.
Return only code.
Use the result as the first fixture in your seven-model comparison sheet. Keep the prompt unchanged when you repeat it across the catalog.
Picks of the week
- Model selection: Benchmark one real workload instead of choosing from a leaderboard.
- Agent-operated CLIs: Make plan, apply, and verify separate, observable stages.
- Incremental Rust ports: Record the old behavior before rewriting the component.
- Runtime patching: Inventory the actual deployed version; the Azure resource name is not a version.
Which would you tackle first: a measured model switch, an agent-safe Azure CLI, a behavior-tested Rust port, or an urgent Java/Nginx patch?
Connect
If this kind of post is useful, the easiest way to support the work is to:
- Star / follow on dev.to (you're already here 🙂)
- Follow on X: @devkingov
- Reach out for HK-based dev work — .NET / Azure / system integration / IT security: studio.resurrects.co or email [email protected]
- Subscribe to weekly HK tech posts → studio.resurrects.co/blog (one email a week, no spam)
Originally published by Dev.to AI. Aggregated on AIWithGhost for educational purposes — full credit and traffic to the original publisher.