Weekly Azure Roundup: Agent Security, Foundry GA, and SQL Changes

by TechHub

Microsoft observed an AI agent turn exposed application credentials into Azure Key Vault data exfiltration in five minutes, underscoring the need to revoke or rotate leaked credentials rather than merely remove their public disclosure. GPT-6.1 Terra reached general availability in Microsoft Foundry with text and image inputs and up to one million input tokens, while Foundry's Azure Developer CLI extension reached version 1.0 for shared local and CI/CD deployment definitions. Azure SQL Database watcher will retire on April 30, 2027, with resource creation and editing blocked starting November 9, 2026, making replacement monitoring and cleanup of chargeable resources immediate planning tasks. Azure SQL also gained agent-free migration for Arc-registered SQL Server instances and a generally available Modern Query Editor, while Service Bus Premium added generally available Geo-Replication for partitioned namespaces and Azure Files previewed additional recovery options. Across these updates, developers gain more deployment and resilience capabilities, but identity enforcement, migration planning, and explicit operational controls remain application-team responsibilities.

This Week's Overview

Azure SQL changes migration, monitoring, and day-to-day operations

Azure SQL updates span agent-free migration, a monitoring retirement deadline, and a generally available portal editor. Operational guidance adds more specific ways to investigate performance and recovery problems before changing database configuration.

Migrate Arc-registered SQL Server without the Arc agent

Azure Arc now supports portal-based migration from Arc-registered SQL Server instances without deploying the Arc agent. The migration mechanism depends on the destination: Azure SQL Database, including Hyperscale, uses Azure Database Migration Service with a self-hosted integration runtime, while Azure SQL Managed Instance uses Log Replay Service. SQL Server on Azure VMs uses backup and restore through Azure Blob Storage.

The distinction between migration and assessment matters: portal readiness assessments still require the Arc agent, but SQL Server Management Studio 22 can assess instances without it. Teams can add databases manually when inventory is stale, although Managed Instance link remains unavailable for Arc-registered instances.

Database watcher retirement puts monitoring migration on the calendar

Database watcher for Azure SQL Database and Azure SQL Managed Instance will retire on April 30, 2027, without reaching general availability. Creating watcher resources and editing existing ones will be blocked starting November 9, 2026. Database Hub provides an alternative that monitors databases in their existing environments without a separate monitoring data store, and access does not require Fabric capacity.

Database Hub alerts are now in public preview through Fabric Activator, using templates or Performance charts. Activator queries Microsoft-managed telemetry rather than the databases themselves, so it requires no additional database credentials and adds no database query load. CPU telemetry arrives every 10 to 15 seconds, with alert queries running as often as every minute, but alert rules consume their Fabric workspace's capacity.

Retirement does not automatically deprovision Azure Data Explorer or Fabric Eventhouse resources, delete historical data, or stop associated charges. Teams therefore need to review both their replacement monitoring configuration and the resources left behind.

Modern Query Editor reaches general availability

Modern Query Editor for Azure SQL Database is generally available in the Azure portal, with Microsoft Entra and SQL authentication support. Object Explorer adds name searches, object-type filters, and table or view previews of up to 1,000 rows. The results grid supports sorting, filtering, copying, and exports to CSV, JSON, or Excel.

Open query tabs and text persist during the browser session, while saved queries reside in the browser profile. That storage distinction matters when switching browsers or profiles, and the classic Query editor remains available.

Hyperscale benchmark results depend on the tested workload

Principled Technologies compared Azure SQL Database Hyperscale with Amazon Aurora PostgreSQL I/O-Optimized using an I/O-intensive HammerDB workload across two vCore counts and multiple concurrency loads. Hyperscale delivered similar or stronger performance across the tested configurations, including up to 52 percent more performance and 51 percent better performance per dollar at 16 vCores. Those results provide a workload-specific comparison, not a prediction for every application.

Separate CPU pressure from waiting before scaling

The CPU and pipeline troubleshooting guides share a useful starting point: distinguish execution work from compilation, worker saturation, blocking, and I/O waits before adding capacity. High elapsed time with little CPU consumption can indicate waiting, while a NULL grant_time in sys.dm_exec_query_memory_grants identifies a request still waiting for its memory grant. Query Store supplies historical plans, runtime intervals, and wait categories, while live dynamic management views expose current waits and blocking.

Pipeline concurrency changes database demand even when stored procedures and database configuration stay unchanged. Broadly applying OPTION (RECOMPILE) can make matters worse when excessive compilation already contributes to resource pressure.

Investigate scaling delays without assuming CDC is responsible

Change Data Capture (CDC) latency can delay transaction log truncation, but a REPLICATION reuse wait does not prove CDC is blocking a scaling operation. The guide recommends inspecting operation state, log usage, CDC progression, and long-running transactions independently before changing CDC configuration. It also clarifies that Azure SQL Database uses a built-in CDC scheduler, and that percent_complete of 50 often means an operation is in progress rather than exactly halfway finished.

Measure statistics-update work with the right units

Query Store can expose historical duration, CPU, and reads for captured StatMan statements, using execution-count-weighted averages and accumulated resource estimates. Duration and CPU are reported in microseconds, while reads are counts of 8 KB pages. These measurements describe captured StatMan activity, not application latency, blocking, or the total cost of the surrounding statistics update.

Treat Change Tracking cleanup as a measured investigation

Change Tracking consumers must validate saved synchronization versions against CHANGE_TRACKING_MIN_VALID_VERSION before requesting changes with CHANGETABLE. Repeated version and storage measurements help distinguish progressing cleanup from a persistent backlog. The playbook warns against deleting internal-table rows, changing internal schemas, or creating unsupported indexes, and recommends collecting configuration, workload, storage, version, and consumer evidence for escalation.

Make application recovery part of transient-failure handling

Many Azure SQL reconfiguration events complete in less than 60 seconds, but application recovery can take longer. Microsoft.Data.SqlClient supports configurable connection and command retries in version 3.0 and later, and the example combines exponential delays with randomized jitter. When a transient failure invalidates an active transaction, the guidance is to retry the entire transaction rather than only the failed statement.

Ransomware recovery starts with containment

Microsoft published Azure SQL Database and Azure SQL Managed Instance ransomware recovery guidance organized around Protect, Detect, Contain, Assess, Restore, Validate, and Harden. It addresses attacks through customer-controlled identities, networks, applications, and configurations, not compromise of the Azure platform itself. Teams should contain attacker access before restoring, preserve backups and evidence, test available restore paths, and rehearse the full response annually.

Ledger testing demonstrates history verification

An Azure SQL ledger lab found that changing a balance produced DELETE and INSERT history entries, while attempts to modify ledger history or update an append-only ledger table were rejected. Verification failed against an incorrect digest and succeeded against valid digests, supporting the author's recommendation to store digests automatically in immutable Blob storage or Azure confidential ledger.

Identity controls face agent-assisted attacks

Microsoft's threat report shows how exposed application credentials can become a cloud data incident within minutes. Related guidance puts authorization in identity, policy, and runtime controls rather than relying on an AI model or a shared secret to enforce boundaries.

Exposed secrets led to Key Vault exfiltration in five minutes

Microsoft observed an AI agent progress from searching GitHub for client secrets to exfiltrating Azure Key Vault data in five minutes. Starting in August 2026, threat actors used an agentic AI framework to submit large volumes of GitHub searches for secrets. As early as October 28, compromised application credentials enabled service principal sign-ins across multiple tenants, including downstream tenants of vendor-owned applications.

The observed requests showed adaptive troubleshooting: failed calls were followed by changes to API versions or HTTP methods and then successful responses. Microsoft's immediate recommendation is to revoke or rotate exposed credentials, because removing the public disclosure does not invalidate them.

Enforce agent permissions outside the model

The Foundry least-privilege guide places enforcement in identity, connection configuration, Azure role-based access control (RBAC), narrow tool contracts, and runtime policy. Its invoice tool binds the storage account and container server-side and derives user partitions from verified identity context. Read, propose, and commit capabilities stay separate, with trusted approval and idempotency controls for high-consequence actions.

The Python example uses DefaultAzureCredential locally and explicitly selects ManagedIdentityCredential in Azure-hosted production code. OpenTelemetry records authorization decisions, while negative tests exercise wrong tenants, unknown agents, missing user context, and disallowed actions.

Connected Registry previews managed identity synchronization

Azure Container Registry's Connected Registry private preview replaces synchronization secrets with a user-assigned managed identity on supported Azure Arc-enabled Kubernetes distributions. It requires Azure Workload Identity, a Premium parent registry with attribute-based access control (ABAC) repository permissions, a dedicated data endpoint, and subscription approval. Repository scope comes from RBAC assignments with ABAC conditions, and permissions across assignments are additive.

Changing synchronization scope requires az acr connected-registry resync, and narrowing permissions does not remove artifacts already synchronized. Migration from eligible sync-token deployments is one-way, requires an offline maintenance window, and fixes the managed identity binding afterward.

Azure Policy can distinguish callers

Azure Policy's requestContext().identity exposes caller claims such as identity type, client application ID, authentication context, and object ID. The denyAction effect currently supports only DELETE, allowing policies to block manual deletion while permitting application callers. Identity-based exemptions are generally available with userPrincipalId and groupPrincipalId selectors, while assignment-level selectors, overrides, and enforcement mode support progressive rollout and rollback.

Microsoft Foundry expands models and shared serving

Foundry's model updates cover generally available multimodal inference, preview fine-tuning options, and shared adapter deployments. The accompanying examples make deployment constraints and benchmark limitations important parts of model selection.

GPT-6.1 Terra reaches general availability

GPT-6.1 Terra is generally available in Microsoft Foundry, accepting text and image inputs with up to one million input tokens. It uses the Responses API without new SDK requirements or schema changes. Global Standard deployments cover all supported regions, while Data Zone Standard deployments are available in the US, EU, and APAC.

Developer controls include adjustable reasoning effort, a none setting, verbosity adjustment, and interim messages where the orchestration layer supports them. Global Standard short-context pricing is $1 per million input tokens and $5 per million output tokens.

Fine-tuning previews share base-model capacity

Muse-Glimmer-30B, qwen3.8-27b, qwen3.6-35b-a3b, and gpt-oss-120b enter public preview with supervised and reinforcement fine-tuning support. MAI-Code-1.1-Flash becomes the first Microsoft model available for Managed Fine-Tuning on Foundry resources, supporting reinforcement fine-tuning only in this preview.

Multi-LoRA Managed Compute, which lets low-rank adaptation adapters share base-model weights and GPU capacity, is also in public preview. A target deployment supports up to eight adapters, and applications select one by setting the chat-completions request's model value to its deployment name. Adapters must match the target's base model and version, and the preview accepts Foundry fine-tuning outputs rather than externally trained adapters.

Shared adapters do not provision additional compute or carry separate pricing, but Managed Compute bills hourly for hardware, including idle time. Deployment still requires a compatible LoRA-enabled template and accelerator quota, so capacity planning remains necessary even when several adaptations share one deployment.

ComfyUI calls hosted image and video models

Microsoft Foundry now hosts fal video models such as MiniMax H3 Max alongside gpt-image, FLUX, and MAI Image models. Two custom ComfyUI nodes call Foundry APIs directly, allowing the local workflow to run on a CPU-only machine. DefaultAzureCredential uses Azure CLI sign-in locally or managed identity on Azure, avoiding API keys.

The calling identity needs the Cognitive Services User or Foundry User role on the Foundry resource. The example produced a five-second, 24 fps video in about 80 seconds in the author's run, which is an example execution rather than a general latency guarantee.

Decision-model experiments need careful comparisons

A Work IQ routing experiment reported that Jev answered first on 12 of 13 questions, with a 5.6-second median compared with 22.3 seconds for Work IQ ask. On a separate 134-question routing set, Jev scored 131 and both Microsoft-Decision-1 and OpenAI's Decisions API scored 128. The wording had been refined against Jev rather than held out, and Microsoft-Decision-1's timings measured individual API calls rather than complete routing plans.

A separate next-best-action example compares fixed rules and models against isolated copies of synthetic evidence from Azure AI Search. Microsoft-Decision-1 returns selected actions and scores through POST /providers/microsoft/v1/systemone, without written rationales. Its latency and token-cost observations are single-run results on authored cases, not general benchmarks or evidence of sales outcomes.

Agent engineering connects deployment, evaluation, and operations

Agent tooling now offers a generally available Foundry CLI extension alongside preview hosting features and implementation guides. The practical theme is to make deployment definitions, permissions, state, and release behavior explicit rather than leaving them to the agent loop.

Foundry's Azure Developer CLI extension reaches version 1.0

The Microsoft Foundry extension bundle for Azure Developer CLI is generally available at version 1.0. Agent and deployment configuration lives in azure.yaml, allowing local development and continuous integration and delivery (CI/CD) to reuse the same definition. Deployment uploads source for a remote Foundry build, without requiring a local container build.

The walkthrough requires Azure Developer CLI 1.37.0 or later, a current uv release, and Python 3.13 or later. The Evaluations extension generates datasets and grading rubrics, runs evaluations, and supports reusing those checks in CI/CD, connecting deployment automation with repeatable quality checks.

Copilot harness examples separate reasoning from execution

Following last week's Copilot harness preview, a newsroom implementation shows how to divide work between the managed agent loop and Hosted code. The harness handles research and editing, while code calls external APIs, validates results, synthesizes audio, and publishes outputs. Completed evidence, scripts, audio, and status are checkpointed in private Blob storage so interrupted tasks can reuse finished work.

The initial public preview does not support switching an existing agent to a different harness. In the example, granting Foundry User at project scope to the Hosted service's calling instance identity resolved permission failures when creating editorial conversations.

Hosted-agent releases require version and quota discipline

The hosted-agent design and operations guides describe managed identity, session sandboxes, immutable versions, private networking, and default OpenTelemetry tracing through hosting protocol libraries. Applications still own authorization, business effects, data handling, and evidence of correct end-to-end behavior. Concurrent hosted-session quotas are shared across accounts and projects within a subscription and region, and several covered features remain in preview without a service-level agreement or a production recommendation.

Default routing follows the latest version, so teams must pin the serving version before creating a release candidate. The endpoint selector serves one version at 100%, while existing sessions remain attached to their original version. Configuring both Application Insights and an OpenTelemetry Protocol destination sends telemetry to both, and optimizer evaluations invoke hosted tools for real rather than simulating their effects.

Keep document lifecycle operations deterministic

A self-updating retrieval-augmented generation (RAG) design uses Azure Cosmos DB as the authoritative document-lifecycle metadata store and Azure AI Search as the retrieval index. Conditional version updates prevent delayed ingestion jobs from activating older documents, while logical deletion blocks retrieval before asynchronous workers remove indexed chunks. A transactional outbox can coordinate metadata changes with reliable background-job publication, leaving deterministic lifecycle work to conventional workers and reasoning or tool-based queries to Microsoft Agent Framework.

Route Claude Code through an explicitly governed gateway

The CCOF implementation uses Azure API Management to route Claude Code requests to Microsoft Foundry, but it is the author's implementation rather than a Microsoft product. The gateway validates tenant, audience, client application, and delegated scope, while managed identities authenticate backend calls. Its deployment stages end with authentication, model-permission, and accounting tests.

The architecture retains a single-region API Management and Function Apps stack, and Foundry accounts in the same subscription share model quota pools. Displayed spend is a lower bound rather than a strict invoice cap because reconciliation is delayed and some token categories remain unknown.

Specialized Azure plugins make operational boundaries explicit

The Azure plugin catalog now includes six specialized plugins alongside the core plugin, with installation through the microsoft/azure-skills marketplace in GitHub Copilot CLI, Claude Code, or Cursor. The core cost-analysis skill has moved to Azure Cost, which users must install to retain that capability. AKS Skills starts with evidence collection and requires explicit approval for resource changes and packet captures, while Foundry IQ Skills manages and troubleshoots knowledge bases through Azure AI Search.

GitHub's Git storage redesign uses Azure Blob Storage

GitHub's new Git storage architecture is in limited private preview, with a broader rollout planned for early next year. Internal testing supported 5,000 concurrent agents and 7,200 pushes per second to one repository while maintaining consistently low read latency. These are internal test results, not a generally available service guarantee.

Azure Blob Storage holds Git objects, while Ref-CAS stores references and the repository's pack manifest. Ref-CAS locks only the references touched by a transaction and supports tens of thousands of reference-state operations per second. Dedicated compaction nodes maintain packs separately from the virtual replicas serving reads and writes, separating background storage maintenance from repository traffic.

The GitHub Universe recaps reinforce the same architectural change: durable repository data moves to Blob Storage, while ephemeral serving nodes provide caching. For Azure readers, that separation is the relevant infrastructure story behind the reported concurrency results.

Workload resilience adds replication and recovery options

Azure resilience updates address regional messaging continuity, hardware failure handling, and file-share recovery. Each operates at a different layer, so application teams still need to account for configuration and workload eligibility.

Service Bus partitioned namespaces gain generally available Geo-Replication

Geo-Replication is generally available for partitioned Azure Service Bus Premium namespaces. It replicates messages, processing state, and configuration to a secondary Azure region, and existing partitioned Premium namespaces can enable it for their current queues and topics.

Partitioning must be enabled when a namespace is created and cannot be changed afterward. That makes namespace design an up-front decision, while non-partitioned Premium namespaces offer up to 16 messaging units.

Failure prediction exposes signals for application automation

Azure Failure Prediction and Detection has operated automatically across the Azure fleet since becoming fully operational in 2024. Microsoft reports more than a 36% reduction in hardware reboots and an 80% increase in the monthly node repair rate. Eligible workloads can live-migrate with a pause typically lasting a few seconds, although not all M-series virtual machines support live migration.

Findings are available through Resource Health, Resource Graph, Event Grid, and Scheduled Events. Automation consuming Scheduled Events should handle NotBefore times up to seven days in the future.

Azure Files previews additional protection and transfer paths

Azure Files announced public previews for vaulted NFS backups, Revert Snapshot, and Azure Files-to-Azure Files copy and synchronization. Vaulted backups keep NFS recovery points separate from production shares, with policies for long-term retention, immutability, and cyber recovery. Revert Snapshot initially supports SMB shares and restores a selected snapshot without changing the endpoint or mount path.

Azure Storage Mover supports SMB transfers across accounts, regions, and subscriptions within the same tenant, including scheduled incremental transfers. NFS support for Revert Snapshot and Azure Files-to-Azure Files copy is planned for later.

PostgreSQL scaling starts with connections and workload routing

PostgreSQL guidance and a customer migration account both show the value of connection pooling before treating capacity as the only constraint. Read distribution adds another layer, but it brings consistency and middleware responsibilities.

Pool connections before distributing reads

Azure Database for PostgreSQL Flexible Server includes PgBouncer to reduce connection churn. Read replicas scale reads rather than writes, and asynchronous replication requires applications to tolerate lag. Virtual endpoints provide stable connection points, but the read-only endpoint targets one server rather than distributing traffic across replicas.

The walkthrough uses Pgpool-II 4.7.2 on Ubuntu 24.04.4 to send writes to the primary and eligible reads to replicas. A single Pgpool-II VM is a single point of failure, and customers remain responsible for its patching, monitoring, security, and recovery.

Wolters Kluwer reports results from migration and tuning

Wolters Kluwer used pgcopydb to migrate roughly 6.4 TB over one weekend after about three months of design, cleanup, and testing. Adding PgBouncer reduced physical connections to close to one-sixth of their earlier level, while average statement execution time stabilized below 20 milliseconds and peak memory stayed below 80% after migration and tuning. Production runs across six nodes, with Terraform provisioning smaller environments and a Citus Docker container supporting local development.

Azure Databricks clarifies configuration and private access

Databricks guidance addresses two separate sources of operational surprises: how serverless jobs select configuration and how clients reach workspaces with overlapping network ranges. Both require explicit setup rather than assumed inheritance or connectivity.

Serverless job variables remain in Beta

Environment variables for serverless Lakeflow Jobs are still in Beta, with job-level entries explicitly selected for each task and no merging or inheritance between entries. Inline variables override file values, later files override earlier files, and the last definition within a file wins. Jobs support ten entries with twenty inline variables per entry, and user-defined functions cannot read them.

Secret references resolve using the job's Run as identity. Redaction is best-effort, so printing secrets can still expose them in compute execution logs.

Overlapping networks need reachable endpoints and deliberate DNS

A proposed design puts uniquely addressed Databricks front-end private endpoints in an enterprise-reachable transit virtual network while leaving overlapping compute networks isolated. Hybrid DNS forwards azuredatabricks.net to an Azure DNS Private Resolver inbound endpoint and must return endpoints reachable by each client. The browser_authentication endpoint handles browser single sign-on callbacks, not REST API authentication.

Front-end private endpoints do not automatically disable public access, and complete isolation requires additional backend connectivity and workspace configuration. The overlapping-address design is an architectural inference, not a Microsoft-certified or independently tested reference architecture.

AKS expands host onboarding and documents private ingress

Azure Kubernetes Service guidance covers adding user-managed compute and routing application traffic through a private ingress path. The cluster integration does not remove responsibility for host readiness, network access, or certificate validation.

Flex node pools gain portal onboarding

The Azure portal now supports creating preview AKS flex node pools and guided onboarding for supported Azure VMs and Azure Arc-enabled servers. Flex nodes extend an existing cluster with user-managed compute without adding another Kubernetes control plane, and hosts outside Azure can use a portal-provided onboarding script. Labels, node affinity, and taints and tolerations control placement, but users must manage host security and connectivity and verify that nodes are Ready before scheduling workloads.

Traefik connects private AKS ingress to Front Door

The Traefik walkthrough connects Azure Front Door Premium through Azure Private Link and an AKS internal load balancer. It deploys Traefik Helm chart 41.6.0 with two replicas on a user node pool, then uses IngressRoute resources for hostname and path routing and Middleware to remove the /api prefix. Front Door terminates client-facing TLS and creates a separate HTTPS connection that Traefik terminates with a Kubernetes TLS Secret, requiring validation of both certificate and private connectivity paths.

Logic Apps updates custom code and agent orchestration

Logic Apps Standard adds .NET 10 custom-code support, while the monthly newsletter connects local development tooling with Foundry agent orchestration. Existing applications need an explicit migration rather than assuming that new-project defaults update deployed code.

.NET 10 custom code requires configuration changes

Support requires Azure Logic Apps Standard extension 5.1013.2 and extension bundle 1.194.31. New custom-code projects target only .NET 10, while existing .NET 8 projects require explicit configuration migration. Deployed settings must include LOGIC_APPS_CUSTOMCODE_DOTNETVERSION=net10.0 and FUNCTIONS_INPROC_NET8_ENABLED=1, with FUNCTIONS_WORKER_RUNTIME remaining dotnet.

Verification includes building, checking publication under lib\custom\net10.0, executing the workflow, and confirming a function breakpoint. The optional migration skill requires GitHub CLI 2.90.0 or later, and installing it for GitHub Copilot does not perform the migration.

Automation coordinates Foundry agents with workflow controls

Following last week's local CLI preview, the newsletter revisits project creation, connector discovery, runtime management, validation, and execution diagnostics from the terminal. Logic Apps Automation can orchestrate Foundry Prompt Agents and Hosted Agents with branching, retries, timeouts, parallel execution, and run history. A community example exposes workflows as OpenAPI tools using managed identity and Microsoft Entra authorization.

Azure SRE Agent guides emphasize evidence and access limits

Azure SRE Agent examples cover server investigations and cloud-spend analysis without treating agent output as automatic remediation. Both depend on the data actually collected and the permissions actually granted.

Reader-only IIS investigations depend on collected telemetry

The reader-only IIS guide limits Azure SRE Agent to control-plane signals and collected Log Analytics data, without guest commands or server changes. Its starter collection rule includes IIS logs, selected Windows events, configuration and file auditing, and eight performance counters, with 60-second sampling and narrowly scoped file auditing to control ingestion. The supplied triage skill tells the agent to verify telemetry availability, cite timestamped evidence, and recommend actions for operators.

Cost investigations must distinguish snapshots from live billing

The cost-analysis prototype combines Azure Cost Management billing data, Resource Graph inventory, and Azure Advisor recommendations, requiring Cost Management Reader and Reader permissions on target subscriptions. Opening its report displays the latest refreshed snapshot, while direct billing refreshes require a supported connector. Current-month projections are not completed-month actuals, newly billed resources are not necessarily newly created, and the prototype does not establish production readiness or measured savings.

GitHub Actions workflows use isolated runners and federated deployment

Azure-hosted delivery examples separate build execution from deployment identity and make release checks part of the repository workflow. They also expose trade-offs around startup latency and database rollback.

Container Apps runs one workflow per ephemeral runner

The runner design uses KEDA to start Azure Container Apps event-job executions for matching queued workflows, with minimum executions set to zero. Each repository-scoped runner handles one workflow, deregisters, and exits. A user-assigned managed identity retrieves GitHub App credentials through a Key Vault private endpoint with public network access disabled, while workflows deploy through GitHub OpenID Connect (OIDC) and a separate Microsoft Entra identity.

Installing tools at runtime avoids a dedicated Azure Container Registry, but increases cold-start latency and dependence on external download endpoints. Deployment permissions remain constrained through Azure RBAC.

Repository-driven releases retain human review and real tests

Bartolesi's workflow keeps requirements in the repository, uses Copilot CLI for implementation, and retains a final human pull-request review after Claude Code review. Brainy's Playwright CI job runs against a real SQL Server database and uploads traces and screenshots on failure, while DayPulse uses Azure Static Web Apps preview environments for same-repository pull requests. A shared SaaS release workflow deploys versioned packages to Azure App Service through OIDC, with the explicit limitation that rolling back application code does not reverse database migrations.

Other Azure News

Microsoft's internal electronic design automation tests on Cobalt 200 delivered 1.30x to 4.15x performance relative to Cobalt 100, with existing Arm-enabled tools running unmodified. The results apply only to the evaluated workloads, software versions, VM configurations, concurrency levels, and test conditions.

The free, public, read-only pghacker-mcp server exposes 17 Model Context Protocol tools connecting PostgreSQL source history with mailing-list discussions. Its Azure HorizonDB deployment stores 105,000 commits as 24 million line versions, with the author reporting a 50-millisecond historical search for fsync_fname.

Azure Local deployment guidance highlights decisions that cannot be changed in place: subscription or resource-group placement requires redeployment, and infrastructure DNS settings cannot be changed after deployment. Each release is supported for six months, and Azure Arc extension deployment permissions deserve close control because they permit code execution as Local System or root.

Azure Migrate's public preview discovers and assesses network-attached storage on Dell PowerScale/Isilon and NetApp ONTAP clusters using cluster-level read-only access. Per-share assessments include readiness, recommended configurations, monthly cost estimates, and mixed-service versus single-service migration comparisons, with inventory refreshed daily.

An Azure Route Server walkthrough summarizes 100 /24 prefixes across 50 spoke virtual networks into three prefixes and verifies the outbound policy on an ExpressRoute connection. The practical limit is explicit: advertising more than 1,000 virtual-network prefixes to an ExpressRoute circuit exceeds the route limit and disconnects the gateway-to-circuit Border Gateway Protocol session.

An Azure Container Registry cleanup example proposes a 90-day soft-delete window, 30-day retention for untagged manifests, and a dry-run purge before scheduling recurring cleanup. Soft-deleted data continues to count toward storage until its retention window expires, and the author recommends considering Microsoft Defender for Containers findings rather than image age alone.

The industrial-edge agent example places Foundry Local workloads on premises and connects on-site devices through Azure IoT Operations, while cloud-connected devices use Azure IoT Hub. Both paths send data to Microsoft Fabric, and the on-site operational-technology virtual coworker continues working when cloud connectivity drops.

A short update highlights Zstd write-ahead log compression as a storage-saving option for Azure Database for PostgreSQL. It also covers a WebTransport headers browser change that can alter runtime behavior without application-code changes and the Copilot Studio Conversation Harness.

The weekly video covers Azure Site Recovery for Azure Local, enhanced Virtual Machine Scale Sets Flex support, and networking topics including Front Door post-quantum TLS key exchange and Application Gateway for Containers private ingress. Its database coverage includes database-level managed identity and point-in-time recovery backup immutability for Azure SQL Database and Managed Instance.

Also relevant this week

Dates to know

Deadlines