Weekly DevOps Roundup: Runtime Upgrades and Safer Automation
.NET 11 is available as .NET 8 and .NET 9 leave support, making runtime migration an immediate maintenance task, while PowerShell 7.7 introduces script-default and security changes that require compatibility checks. Aspire 13.6 adds persistent dashboard history and lower memory use, alongside broader language hosting and deployment tooling for distributed applications. Git 2.56.1 fixes six vulnerabilities, and GitHub adds opt-in secret scanning for Actions logs while setting a December deadline for ARM32 hosted jobs. Azure Resource Manager MCP now supports resource changes and deployment operations, while Foundry Toolbox guidance separates deployment from validated version promotion. Across these developments, teams need explicit support checks, deterministic test gates, and permission boundaries rather than treating successful automation as proof of production readiness.
This Week's Overview
- .NET 11 arrives as older runtimes leave support
- Aspire expands the developer loop and retains diagnostic history
- TypeScript and Go join the integrated development loop
- Resource interaction and deployment modeling
- Dashboard persistence changes diagnostics and resource use
- Repository rollout uses deterministic checks around agents
- Isolated end-to-end tests exercise real service dependencies
- Distributed agent applications share one observable service graph
- Toolchain upgrades require explicit support and compatibility checks
- Infrastructure hardening adds inventory, audit, and servicing requirements
- Repository security spans Git patching, release integrity, and scan policy
- GitHub updates planning, review, and runner operations
- Azure networking adds cross-cluster reach and finer traffic control
- Cloud cost management adds local analysis and scheduled compute pauses
- Azure Container Apps connects assessment with release operations
- Azure DocumentDB adds managed failover with explicit recovery trade-offs
- AI-assisted cloud operations expose different levels of authority
- Cosmos DB emulator workflows make local validation more repeatable
- SQL operations connect schema delivery with compatibility checks
- Python tooling separates type checking from environment management
- Coding-agent workflows add guided deployment and session controls
- Reusable agent workflows need provenance and independent validation
- Production agents require controlled promotion, identity, and state ownership
- Toolbox versions require deliberate promotion
- Foundry guidance distinguishes evaluation, delegation, and quotas
- Hosted-agent migration preserves evaluation and telemetry contracts
- Worker isolation does not require exposing inference credentials
- Application code remains responsible for authoritative actions
- Other DevOps News
- Also relevant this week
- Dates to know
.NET 11 arrives as older runtimes leave support
.NET 11 is available, while .NET 8 and .NET 9 reached end of support on November 10, 2026. The release brings runtime and language changes alongside more command-line support for application development, but several capabilities remain experimental.
Release scope and support boundaries
.NET 11 is a Standard Term Support (STS) release with two years of support, and its SDK is available to download. C# 15 adds union types and closed hierarchies, while separate memory-safety work remains in preview. For teams still running .NET 8 or .NET 9, the support deadline makes runtime migration an immediate maintenance task.
The SDK includes a Model Context Protocol (MCP) server template, but Runtime Async and Blazor AI components remain preview or prerelease capabilities. .NET MAUI now defaults to CoreCLR across platforms, while Android Native AOT, or ahead-of-time compilation, remains experimental. Teams should distinguish these preview features from the supported release when choosing production dependencies.
Mobile development through the .NET CLI
.NET 11 brings dotnet run, dotnet test, and dotnet watch to .NET MAUI mobile development. The commands select and launch applications on devices or emulators, capture test results, and update running applications after code changes. Android and iOS still require platform tooling, packaging, device communication, and application-lifetime handling, so command-line support does not remove those build-agent prerequisites.
Windows application workflows
A WinUI demonstration covers new dotnet new templates and how dotnet run handles Windows package identity. It follows building, debugging, testing, and packaging through Visual Studio and VS Code, with WinAppCLI and coding agents helping with repetitive tasks. Native AOT is discussed as an application delivery option rather than a replacement for the rest of the packaging workflow.
Logic Apps migration requires different local and cloud settings
The Logic Apps Standard migration guide preserves connector registration code and workflow definitions while moving NuGet-based applications and custom built-in connectors to net10.0 and a .NET 10 host. Prerequisites include .NET SDK 10.0.403 or later and Azure Functions Core Tools 4.16.0 or later. Local development requires FUNCTIONS_WORKER_RUNTIME=dotnet-isolated, while Azure retains dotnet and removes LOGICAPP_INPROC_REDIRECT.
Extension bundle configuration must be removed from both host.json and Azure app settings so the packaged runtime registers custom connectors. The validation covered a sample connector action locally and in Azure, not triggers or applications combining NuGet-based and custom-code projects. Those untested combinations need their own migration checks.
Testing assistance and language references
An AI-assisted testing session demonstrates identifying coverage gaps, generating and improving tests, and validating changes with MSTest and Microsoft Testing Platform. Developers retain responsibility for decisions about test quality and code changes. A separate syntax reference targets .NET 10 and C# 14, covering features such as field and null-conditional assignment, so readers should not mistake it for a C# 15 reference.
- Test Smarter: AI-Assisted Testing for Modern .NET
- C# Cheat Sheet: Modern Syntax Reference with Examples
Aspire expands the developer loop and retains diagnostic history
The supplied Aspire updates cover language hosting, resource interaction, deployment, and a dashboard that retains data between runs. The accompanying engineering reports show how those capabilities support repository onboarding, isolated tests, and distributed agent applications.
TypeScript and Go join the integrated development loop
Aspire 13.4 makes TypeScript AppHosts generally available, using apphost.mts as the entry point and generated SDK modules under .aspire/modules/. Startup validation runs before the application, and first-party Go hosting includes OpenTelemetry, health checks, module helpers, and debugging through dlv-dap. The VS Code extension can debug C# and TypeScript AppHosts and coordinate debugging across C#, JavaScript, TypeScript, Python, and Go resources.
Resource commands now accept typed arguments, defaults, choices, validation, and secret inputs, which the extension collects through prompts. WithProcessCommand exposes local scripts and tools, while aspire logs and aspire otel can search on the server before streaming results. Kubernetes deployment support adds cert-manager, Gateway API, Azure Application Gateway for Containers, arbitrary manifests, and external Helm charts.
The broader toolchain session explains how Aspire uses .NET for orchestration and developer tooling without requiring applications to use .NET. One workflow change to check is dashboard launch behavior: beginning mid-June, AppHosts started from VS Code no longer open it automatically, although settings can restore that behavior.
- Aspire 13.4 is here
- Aspire in VS Code: the 13.4 developer loop
- How Aspire uses .NET to build an agent-first toolchain for any programming language
Resource interaction and deployment modeling
Aspire 13.5 adds file imports for resource commands, progress dialogs, interactive terminal sessions, and a refreshed dashboard. The Core Interaction Service and file-input APIs are stable, but progress dialogs and terminal APIs remain experimental. Kubernetes persistent-volume modeling now emits persistent volume claims and StatefulSet workloads from storage-class, capacity, and access-mode settings.
Existing Azure resources can be referenced across resource groups, subscriptions, and tenants using literal values or Aspire parameters. Terminal resources currently run as plain processes, requiring manual debugger attachment. WithTerminal() and withTerminal() attach terminal emulators to projects, executables, and containers, with Aspire 13.6 adding docked terminals and richer emulation.
The terminal tooling includes database clients for Redis, Mongo, SQL Server, Postgres, Valkey, and MySQL resources. Its experimental aspire terminal tape play command automates an existing terminal and prints the final screen, rather than producing a video or recording file.
Dashboard persistence changes diagnostics and resource use
Aspire 13.6 persists resource snapshots and telemetry in SQLite, retaining up to 10 runs per application with optional pinning. Persistence is enabled by default when an AppHost launches the dashboard, and default limits for console logs, structured logs, and traces rise from 10,000 to 100,000 entries each. The standalone dashboard instead defaults to None, with Run and Resume available for retaining data.
The implementation uses Dapper queries with build-time query and mapping generation for Native AOT. In the reported benchmark, private memory fell from 1,007 MB in Aspire 13.5 to 241 MB in Aspire 13.6, a 76% reduction. Native AOT publishing also reduced median page-visible startup from 1,429 ms to 491 ms and brought the dashboard footprint to 110.22 MB, compared with approximately 183.08 MB for the managed dashboard and its required runtime.
These changes do not turn the dashboard into a production telemetry store: persisted data has no separate encryption or authorization layer. Preview database REPL support requires explicit opt-in because authenticated clients receive full write access. The dashboard executable needs no separately installed .NET runtime, but the CLI still ensures one is available for other components, and Native AOT publishing for Blazor Web Apps remains experimental.
Aspire 13.6 also moves Java and Rust hosting into first-party preview packages with generated Dockerfiles and VS Code debugging support. Its prerelease Azure sandbox deployment integration requires preview access and currently excludes volumes, TCP ports, private service discovery, and Windows or ARM64 images.
- Aspire 13.6: Your dashboard gets memory
- Adding persistence to the Aspire dashboard
- Bringing Native AOT to the Aspire dashboard
Repository rollout uses deterministic checks around agents
The Aspire rollout report describes adoption across more than 50 microservice repositories by May 2026, up from approximately 15 in the previous report. MARS combines Aspire, Microsoft Agent Framework, and GitHub Copilot SDK in a check, plan, fix, validate, and learn loop. Repository health comes from deterministic C# metrics and Azure DevOps pull-request and build snapshots, rather than an agent's unsupported assessment.
The team estimates that agentic onboarding removes 4-8 hours of manual setup per repository. The rollout system itself has more than 700 end-to-end tests, all run on every pull request, making validation part of the automation rather than a separate follow-up task.
Isolated end-to-end tests exercise real service dependencies
Azure Chaos Studio uses Aspire to run roughly 90 hermetic tests, meaning tests isolated from shared external environments, on every pull request in Azure Pipelines. Its four independently shipped services run against Cosmos DB and Storage emulators, a community Key Vault emulator, and WireMock where an emulator is unavailable. The fixture waits for real resource health checks and tears down the application afterward.
The tests exercise zone outages, identity outages, DNS failures, and geo-replication failures through the service graph. Running these environments in parallel without shared-environment interference gives the team a way to validate failure handling before deployment.
Distributed agent applications share one observable service graph
AlpineAI models .NET and Python specialist agents, a Go telemetry generator, a React frontend, and Microsoft Foundry resources in one Aspire AppHost. Its advisor exposes four Agent-to-Agent (A2A) specialists and a Foundry prompt agent as five tools, while chat and voice use different hosting paths. Aspire models Azure Container Apps placement, Cosmos DB conversation storage, dependencies, and health checks alongside OpenTelemetry traces spanning advisor processing, specialist calls, models, and downstream HTTP requests.
Toolchain upgrades require explicit support and compatibility checks
Java support deadlines, PowerShell behavior changes, and a longer Visual Studio servicing channel create different maintenance decisions. Each requires checking more than whether an application still starts.
Java upgrade planning has a fixed Azure deadline
Azure App Service and Azure Functions support for Java 8, 11, and 17 ends on September 1, 2027. Applications continue running afterward, but those Java versions stop receiving security updates, improvements, and related customer support. Microsoft Build of OpenJDK separately lists September 2027 as the earliest support end for Java 11 and 17, with possible extensions, so the two support schedules should not be treated as identical.
Modernize CLI supports assessment, planning, and execution of upgrades, but requires a GitHub Copilot subscription and GitHub CLI. The practical guidance is to align Maven configuration, GitHub Actions, and production runtimes, then validate staging deployments and prepare rollback paths. That avoids upgrading source compatibility while leaving build or hosting environments behind.
PowerShell 7.7 changes script defaults
PowerShell 7.7 is generally available as a Standard Term Support release built on .NET 11. New-TemporaryDirectory creates a uniquely named directory and returns a DirectoryInfo object, while New-Guid now generates time-sortable version 7 UUIDs instead of version 4 UUIDs by default. Scripts that depend on the previous identifier format should review that change before upgrading.
Security updates strengthen remoting validation and restrict property assignment on non-core objects in Constrained Language Mode. Test-Json no longer resolves external schema references by default, so scripts that need them must explicitly use -FetchExternalReference.
Visual Studio extends the fixed servicing window
Visual Studio 2026 LTSC 18.11 is available with support through November 14, 2028, extending Long-Term Servicing Channel support from one year to two. It includes .NET 10 LTS and MSVC 14.50 and 14.52 toolsets, and receives security and critical fixes rather than regular feature updates. Installations must still take servicing updates to remain supported.
Microsoft recommends Stable for most customers, with monthly feature and quality updates required to maintain support. Existing Visual Studio 2026 Enterprise, Professional, and Build Tools keys work on both channels without another purchase. The choice is therefore about update policy and toolchain stability, not avoiding maintenance entirely.
Infrastructure hardening adds inventory, audit, and servicing requirements
The infrastructure updates combine stronger defaults with controls for understanding their operational effects. Image inventories, audit modes, and documented exceptions matter alongside the settings themselves.
Azure Container Linux improves scaling and security evidence
Azure Container Linux now supports Azure Kubernetes Service (AKS) node auto-provisioning, which chooses virtual machine sizes and provisions nodes from workload resource requirements. Confidential virtual machine support covers Intel TDX and AMD SEV-SNP, with FIPS-enabled confidential images also being introduced. Optional IPE audit mode records execution attempts that violate integrity policies without blocking them, allowing teams to inspect compatibility before enforcement.
The CIS Benchmark for Azure Container Linux is generally available. Each image now embeds an SPDX 2.2 JSON software bill of materials (SBOM), but vulnerability assessment requires scanners that integrate with that inventory. The embedded file supplies package evidence, not an automatic vulnerability assessment on its own.
Windows servicing can affect signed automation
Released on November 10, 2026, KB5132061 applies to Windows 11 versions 26H2, 25H2, and 24H2. The November release enables clients to offer NTLM message signing by default for non-anonymous connections and adds auditing. Stricter PowerShell signature verification can reject scripts with invalid UTF-8 encoding, requiring affected scripts to be saved as valid UTF-8 with a byte-order mark and signed again.
Hotpatch-enabled devices need separate PowerShell security packages after the November hotpatch update: KB5135385 for applicable Windows 11 versions and KB5135386 for Windows Server 2025. Microsoft will skip the December 2026 non-security preview update during the month's second half, with normal monthly servicing resuming in January 2027. Automation owners should account for both script compatibility and the separate hotpatch package requirements.
Azure Local documents baseline exceptions and customization
Azure Local 2610 evaluates 429 security settings for domain-joined deployments and 403 for deployments using local identities. CIS Level 1 alignment reaches 87% for both host types and 88% for disconnected operations infrastructure, rising above 99% when documented overrides are excluded. Those figures describe benchmark alignment, not certification or accreditation.
Set-AzsSecurity lets administrators customize individual settings while preserving drift control and values across solution updates. Seven additional metadata columns describe compliance mappings, security impact, change risk, and customization posture, giving operators more context for retaining or overriding a baseline setting.
Repository security spans Git patching, release integrity, and scan policy
Git vulnerabilities require local and bundled-client updates, while GitHub security guidance focuses on what repository controls actually protect. The distinction between recording dependencies, enforcing permissions, and verifying published artifacts remains important.
Patch Git clients and enterprise servers
Six Git vulnerabilities can lead to code execution, path traversal, memory corruption, crashes, or unauthorized filesystem access. Fixes ship in Git 2.56.1, with backports to 2.55.1, 2.54.1, 2.53.1, 2.52.1, 2.51.3, and 2.50.2. Patched GitHub Enterprise Server releases are 3.19.15, 3.20.11, 3.21.9, and 3.22.4.
GitHub.com and GitHub Enterprise Cloud, including data-residency deployments, have already received fixes. That does not update Git copies bundled with local tools or automation environments. Until patched, users should avoid untrusted clones, merges, binary patches, and fast-import streams.
Publisher controls have specific boundaries
Following last week's coverage of public-repository trigger controls, GitHub Actions will block pull_request_target events by default from December 2, 2026, unless an applicable event policy explicitly permits them. The action-publisher guidance also distinguishes workflow actor policies from token permissions: restricting who triggers a workflow does not restrict publishing through other workflows or APIs. Dependency lockfiles record action commits and repository identities, including supported transitive dependencies, but do not pin job-level reusable workflows.
Immutable releases protect published tags and assets only for releases published after immutability is enabled, and they do not protect release notes. Maintainers who move floating major or minor tags must keep those tags separate from immutable releases. CLI extension publishers must upload release assets and build provenance before publishing the immutable release.
Installing a GitHub CLI extension does not automatically verify its assets or attestations, and Actions lock files do not pin container images. The CLI extension guide also warns that installing an already-installed extension with --pin --force currently ignores the pin. These limitations make consumer-side verification and installation checks necessary even when the publisher uses protected releases.
- Protect the repository hosting your GitHub Action (2026)
- Protect the repository behind your GitHub CLI extension
Workflow log scanning needs explicit enablement
Secret scanning for GitHub Actions workflow logs is in public preview for GitHub Enterprise Cloud enterprises with GitHub Secret Protection or GitHub Advanced Security. Enterprise owners must enable the policy, which is off by default and applies only to eligible repositories already using secret scanning. Only runs completed after enablement are scanned, with no historical backfill.
The preview detects provider patterns, excluding generic patterns, custom patterns, AI-detected secrets, and values already masked by Actions. Findings appear in repository alerts without notifications during preview and remain available after the underlying workflow logs are deleted. Teams enabling the feature therefore need an alert-review process rather than relying on notifications.
AI Scan policy does not start repository scans
The AI Scan REST API preview adds repository_scan controls at organization and repository levels. Organizations can disable repository scanning centrally or permit inherited settings with repository opt-outs. Changes to pr_scan and repository_scan are atomic: if either is blocked, neither changes and the request returns HTTP 422.
Enabling repository AI Scan does not launch a scan. Users with write access run scans on demand, consuming GitHub Code Security AI credits, and GitHub Enterprise Server is not supported. The preview covers organization-owned public repositories and eligible private or internal repositories.
GitHub updates planning, review, and runner operations
GitHub's workflow updates range from personal-account issue metadata to a near-term runner retirement. Its availability report separately shows how infrastructure migration and service-path changes affected operations.
ARM32 hosted jobs face a December deadline
GitHub Actions hosted runners will end ARM32 job execution support on Windows and Linux by December 8, 2026, including native AArch32 user-space execution. The retirement follows the end of Node.js 20 support because Node.js 24 does not support ARM32. Repositories depending on those hosted execution paths need to review their job requirements before the deadline.
Personal repositories gain structured issue metadata
Issue types and fields are generally available for repositories owned by personal accounts. Accounts can customize defaults and create up to 25 issue types and 25 fields, with text, number, date, single-select, and multi-select values. REST API, GraphQL API, and webhook support make the metadata usable in repository automation rather than only in the web interface.
Users can now create labels and milestones directly from an issue. The GitHub dashboard also shows six pull requests and issues by default instead of three, preserves custom selections, and uses more compact lists. Accounts without agent sessions no longer see an empty agent-session section.
Stacked pull requests support dependent reviews
GitHub stacked pull requests are generally available, allowing complex changes to be split into smaller dependent pull requests while retaining context. Sameen Karim demonstrates creating a stack with GitHub CLI and reviewing it on github.com. The session covers atomic merges, branch protection, auto-merge, VS Code support, and rebasing, addressing the operational details that determine whether smaller reviews remain manageable.
Availability reporting connects capacity work with failure causes
As of November 9, GitHub had moved 140 of 151 production services and 32 of 50 MySQL primaries to Azure Central US, while more than doubling compute capacity across all nine Central US Kubernetes clusters. An Actions endpoint handling over 250 million daily requests moved to a more efficient service path, reducing peak database reads by 85%.
The October report also records two October 7 write outages totaling about 19 minutes after routing settings directed writes to retired servers. On October 28, an invalid upstream-provider credential caused about one in ten requests to affected Copilot models to fail. These incidents distinguish capacity improvements from configuration and credential failures that require different safeguards.
Azure networking adds cross-cluster reach and finer traffic control
The networking updates address service connectivity, workload-specific interfaces, and application-level routing. Several capabilities are generally available, but the previews carry limitations that affect production routing decisions.
AKS separates connectivity, performance, and telemetry controls
Cross-cluster networking for Azure Kubernetes Fleet Manager is generally available, supporting service discovery, communication, network policy enforcement, and observability across AKS clusters. Multi-NIC pods are in public preview, allowing separate network interfaces for application and storage traffic. This gives teams a way to model different traffic paths without treating every pod connection as equivalent.
Managed DRANET support for remote direct memory access (RDMA) network interfaces is generally available, with topology-aware resource allocation for distributed AI and high-performance computing workloads. Configurable observability dimensions are in public preview, enabling targeted network-data collection for troubleshooting, security investigations, and compliance. Teams can evaluate telemetry scope separately from adopting the networking features themselves.
Application Gateway routing preview has health and SLA limits
Azure Application Gateway's advanced routing and load-balancing previews support up to five AND-combined conditions per rule, with RE2 expressions for paths, headers, and query strings. Backend pools can be selected by weight or priority, while server selection supports round robin, weighted round robin, or least connections. Priority-based failover uses Minimum Healthy Percent, including scenarios that move AI traffic between reserved and pay-as-you-go endpoints.
The features require API version 2026-03-01 or later. Preview weighted distribution ignores pool health, and the previews have no service-level agreement. Those constraints matter when evaluating the feature for failover rather than only for traffic experimentation.
Cloud cost management adds local analysis and scheduled compute pauses
FinOps toolkit changes focus on cost-data processing and analysis, while App Service introduces a way to stop paying for compute during planned downtime. Both require checking what remains active or chargeable around the primary feature.
FinOps toolkit 15 changes analysis and ingestion
FinOps toolkit 15 adds an agent plugin with five agents and a read-only Azure MCP server scoped to Data Explorer. Local FinOps hubs require Docker with at least 16 GB of container memory, PowerShell 7, and FOCUS cost exports in Parquet format. Private deployments gain optional NAT Gateway support alongside virtual-network and public networking modes.
FinOps hubs 15 corrects swapped commitment-discount eligibility columns, but historical Prices data must be reingested to apply the correction. Azure Optimization Engine now uses a Data Collection Rule and Ingestion API following the Data Collection API's September 2026 deprecation. Upgrading the toolkit therefore includes data-repair and ingestion-path checks, not only installation of the new agent tooling.
App Service can pause plan-level compute billing
Plan-level start/stop is in public preview for Premium v4 and Premium memory-optimized v4 App Service plans. Stopping a plan takes every hosted app and deployment slot offline and pauses compute billing, while other resource charges may continue. Because operations are asynchronous, automation must check application readiness before restoring traffic.
Plans using App Service automatic scaling are unsupported, and start/stop operations have a five-minute throttle. Operators must start a plan before scaling or updating it and wait for asynchronous scaling to finish before starting or stopping. The feature fits planned downtime, but its plan-wide impact and operation ordering need to be explicit in scheduling scripts.
Azure Container Apps connects assessment with release operations
Azure Migrate now evaluates Container Apps as a hosting destination, while deployment guidance explains the work that follows an assessment. Readiness findings, application changes, and production capacity remain separate steps.
Migration assessments do not execute migrations
Azure Migrate adds Azure Container Apps as a target workload for discovered web applications. Assessments provide readiness findings, migration requirements, resource recommendations, and estimated hosting costs. Discovery alone does not establish readiness, and committing a migration wave accepts the plan without starting migration.
GitHub Copilot app modernization handles code changes, validation, containerization, and deployment through Java and .NET workflows. The distinction gives teams a clearer handoff: assess the application and approve the plan before treating modernization or deployment as complete.
AI application releases need independent model-capacity planning
The Container Apps deployment guide connects Azure Container Registry images to Azure Container Apps and Azure OpenAI. Managed identity can provide access to Key Vault secrets, and supported pipelines should use OpenID Connect (OIDC) workload identity federation instead of long-lived client secrets. Multiple-revision mode supports traffic splitting, blue-green deployments, and canary releases.
Increasing application replicas does not increase Azure OpenAI model capacity, quota, or token throughput. A separate demonstration for .NET developers covers Container Apps sandboxes for isolated code, AI Gateway tracking of model and tool calls, SRE Agent operational assistance, and Copilot canvases. Together, the material separates application scaling and release controls from the model services those applications call.
Azure DocumentDB adds managed failover with explicit recovery trade-offs
Azure DocumentDB's service-managed failover is generally available, while a migration report shows a different set of trade-offs during bulk ingestion. Recovery protection and migration throughput need separate operational plans.
Regional failover requires enablement and a suitable connection string
Service-Managed Failover is generally available across Azure regions supporting Azure DocumentDB. It is disabled by default and requires cross-region replication, a support ticket for enablement, and use of the global read-write connection string. The service promotes a replica when the primary region is unavailable and recovery across local zones is impossible.
Committed writes that have not replicated may be lost during service-managed failover. Graceful promotion provides zero data loss for planned failovers, so it should not be confused with emergency regional recovery. The guidance recommends both in-region high availability and service-managed failover for production workloads.
Large migration results depended on controlled ingestion
An enterprise migration moved 47 TB and more than 7,000 collections, completing production cutover in under 48 hours. The source's 27 nodes across nine shards were consolidated onto a three-node, 16 TB Azure DocumentDB target. Four balanced migration jobs ran under continuous manual monitoring and throttling.
High availability and cross-region replicas were disabled during bulk ingestion to reduce write-ahead-log and disk pressure. Non-unique indexes were built afterward in blocking mode, with change-data-capture online synchronization paused during the builds. The result is a case study in managed migration trade-offs, not evidence that the same timing applies without those conditions.
AI-assisted cloud operations expose different levels of authority
Azure management and diagnostics tools now give agents more ways to inspect or change resources. The practical question is which identity each tool uses and whether its operations are read-only, validated writes, or resource-management actions.
Resource Manager MCP supports deployment and resource changes
The Azure Resource Manager MCP server supports resource and resource-group creation or updates through ARM PUT patterns, plus provider-defined POST actions through execute_resource_action. Deployment tools cover WhatIf previews, execution, status tracking, and cancellation, with Bicep MCP available for authoring and compilation. get_resource retrieves current ARM state for tracked, proxy, and extension resources using a specific resource ID.
Cost tools support general and AKS cost queries, retail prices, and negotiated price-sheet downloads. Experimental skills return SKILL.md workflows and require the request header x-mcp-toolset: Skills. Because the server includes write operations as well as inspection, deployment previews and current-state checks are relevant safeguards in agent-driven workflows.
Grafana MCP uses the signed-in user's existing access
Azure Monitor dashboards with Grafana MCP use a global endpoint that requires no Azure Managed Grafana resource, MCP server deployment, or Grafana data-source configuration. Of its 21 tools, 20 are read-only and one updates existing saved dashboards. Each call uses the signed-in user's Microsoft Entra ID token and existing permissions, with no additional access granted by sign-in.
Dashboard changes support validation without saving and version checks to prevent overwriting intervening edits. The endpoint supports user sign-in only and cannot create dashboards or access Grafana alerting, Loki, SQL, or ClickHouse tools. It is therefore a bounded diagnostics and dashboard-editing interface, not a general Grafana administration endpoint.
Database Hub Copilot is read-only but consumes capacity
Following last week's Database Hub coverage, Copilot in Database Hub is now in public preview for questions grounded in resource inventory, detected issues, and performance telemetry. It respects existing Azure and Fabric permissions and does not change databases. A Fabric administrator must enable the required tenant settings before users can access it.
The preview requires Fabric capacity F2 or higher or Power BI Premium capacity P1 or higher, and token use consumes capacity units. OpenAI-operated models are not currently available in government or sovereign clouds. Teams evaluating the feature need to check administrative enablement, capacity impact, and cloud availability as separate prerequisites.
Cosmos DB emulator workflows make local validation more repeatable
The Cosmos DB material connects a cross-platform emulator with isolated coding tasks, live-model tests, and direct data inspection. Each example also states what local validation cannot establish about production.
Emulator setup and inspection become easier to automate
The generally available vNext emulator runs through a Linux container on Windows, macOS, and Linux hosts using x64 or ARM64. Scripts mounted at /init run on first startup when ENABLE_INIT_DATA=true, not before every test. OpenTelemetry Protocol (OTLP) export and shell --otel correlate client and gateway spans, while October releases added CosmosBinary support, stricter indexing-metadata validation, and an experimental Nacelle gateway.
The shell walkthrough uses Azure Cosmos DB Shell 1.1.280-preview against a local Linux emulator. Installing it as a .NET global tool requires SDK 10.0 or later, while self-contained binaries need no separate .NET installation. Its print command performs a point read using both the item ID and complete partition key, with database and readiness endpoints on loopback-bound ports 8081 and 8080.
Authentication is not enforced in the emulator. Successful local operations therefore do not validate production authorization, throughput, performance, or resiliency, and must be followed by appropriate Azure validation.
Coding agents receive task-specific database environments
The agentic CI/CD sample gives each coding task its own Git worktree, Cosmos DB emulator, versioned fixtures, and artifacts. Its isolation proof writes identical document identities independently and verifies that removing one emulator leaves the other readable. The observed GitHub Actions run completed three genuine Copilot tasks and passed 75 combined tests against a fresh emulator.
The real-agent job uses GITHUB_TOKEN instead of a stored personal access token and caps usage at 150 AI credits across five possible sessions. Emulator containers isolate database state, but do not sandbox untrusted agents. That distinction matters when treating environment independence as evidence of security isolation.
Live-model tests verify persisted outcomes
FleetCharge combines Python, Microsoft Agent Framework, and FastAPI with local Phi-3.5 inference through Ollama. GitHub Actions runs independent component and live-model jobs, each with a fresh emulator. The live tests make 20 real inference calls and verify recommendation creation, replacement, and deletion through SDK checks.
The dispatch test checks stored data, model context, and generated answers before and after an update while ensuring another partition remains unchanged. No Azure credentials are required, but repository rules or branch protection must require both jobs to make them an enforced merge gate. A passing optional workflow is not equivalent to a required release check.
SQL operations connect schema delivery with compatibility checks
The SQL updates cover versioned Warehouse definitions, database tooling, and time-zone behavior that can affect scheduled work. Their common concern is keeping deployed database behavior aligned with the definitions and policies teams review.
Fabric Warehouse previews project-based delivery
Fabric Warehouse Git integration represents a Warehouse as a SQL database project, supporting branches, commits, and pull-request review. DacFx compares source and target database states to generate incremental schema deployments, while versioned pre- and post-deployment scripts run around those changes. Warehouse Item Definition APIs support both SQL project and DACPAC formats for creating, retrieving, and updating definitions.
Deployment configurations, Warehouse support in fabric-cicd, and CI/CD for the SQL analytics endpoint are planned capabilities rather than part of the current preview. Teams adopting the workflow should distinguish the available schema-deployment path from that roadmap.
SQL tooling and backup coverage have product-specific limits
The Microsoft SQL roundup highlights generally available GitHub Copilot Agent Mode, the Database DevOps workload, Schema Compare, and SQL Formatter in SSMS 22.10.2. It also covers Hyperscale elastic pools in preview, supporting up to 50 databases and 128 TB per pool depending on hardware and service objective. Automatic backup immutability protects up to seven days of Azure SQL Database point-in-time restore backups, but currently excludes Hyperscale.
Canadian time-zone changes need operating-system and schedule review
Affected Canadian locations retain UTC-07:00, UTC-06:00, and UTC-05:00 rather than turning clocks back on November 1, 2026. SQL Server on Windows needs the applicable Windows update, not a separate SQL Server product update, for those regional definitions. A known .NET TimeZoneInfo issue can also apply incorrect offsets for one hour at the 2026/2027 year boundary.
Azure SQL Managed Instance cannot change its instance-level time zone after creation without replacement and workload migration. Database-level time-zone settings require the Always-up-to-date policy and do not change SQL Agent schedules or historical conversions. Updating a database setting alone therefore does not resolve every scheduling or timestamp concern.
Python tooling separates type checking from environment management
The supplied Python coverage includes a new type-checker integration alongside earlier environment and editor releases. Those earlier articles provide compatibility context, rather than representing newly shipped November features.
Pylance can use Pyrefly without replacing its editor features
Microsoft and Meta designed and implemented Type Server Protocol, an open standard extending Language Server Protocol for interchangeable type-checker backends. Pyright remains Pylance's default, but developers can select Pyrefly as their diagnostics source with Pylance 2026.4.1 or newer and Pyrefly 0.60.0 or newer. Completions, Quick Info, environment management, and GitHub Copilot integrations remain with Pylance regardless of the checker.
Pylance can detect or download Pyrefly, and settings support version pinning or a local executable. That lets teams change diagnostics engines while retaining the editor workflow, with explicit version control available for reproducibility.
Environment workflows gain a dedicated extension
The Python Environments general-availability rollout follows a year in preview, with immediate opt-in through python.useEnvsExtension. The extension uses the Rust-based Python Environment Tool to discover venv, conda, pyenv, poetry, pipenv, and system environments. When uv is installed, it becomes the default for venv creation and package installation, while multi-project testing assigns each project its own test root, interpreter, and discovery settings.
The supplied April update narrows default environment search patterns to .venv and */.venv, requiring custom workspace paths for deeper layouts. It defers Pipenv, pyenv, and Poetry discovery until interaction, refreshes package lists after metadata changes, and retries environment refreshes after tool crashes. PowerShell activation uses a process-scoped execution policy rather than requiring system-wide policy changes.
Earlier editor updates clarify navigation and interpreter behavior
The March 2026 release optionally includes installed-package symbols in Workspace Symbol search, with export-based limits for libraries lacking py.typed. Its experimental out-of-process Rust indexer averaged 10 times faster indexing on large Python projects in Microsoft's testing. Saved workspace interpreter selections take precedence over terminal-activated virtual or conda environments across restarts, and detected Pixi environments prompt a recommendation for the community Pixi extension.
The November 2025 release added formatted docstring insertion from Copilot Hover Summaries and made those summaries respect the VS Code display language. Pylance can replace wildcard imports with explicit imports while preserving aliases, and the debugger supports project-specific interpreters when python.useEnvironmentsExtension is enabled. These dated releases help explain current editor behavior without implying that their features arrived this week.
- Python in Visual Studio Code – March 2026 Release
- Python in Visual Studio Code – November 2025 Release
Coding-agent workflows add guided deployment and session controls
The coding-agent material spans Azure application scaffolding, model orchestration, editor sessions, and an outdated integration announcement. Availability and documentation currency need checking before adopting a demonstrated workflow.
Guided Azure development now includes Python
Python projects now have full support in the guided Copilot experience for building Azure applications in VS Code, joining the initially supported JavaScript and TypeScript workflows. Developers review and approve a proposed architecture before code generation, then inspect deployment tools, Azure resources, and estimated costs before deployment. Getting started requires the Azure Tools extension pack and an empty folder in VS Code.
Demonstrations cover model routing and local automation
The VS Code 1.144 and 1.145 demonstrations show Copilot Fusion routing and orchestrating models, computer use for interacting with desktop applications, and local automations using cron schedules and custom agents. Some demonstrated features may be unavailable under particular enterprise policies or pricing plans. The October GitHub review separately covers Copilot Automations for issue triage and Copilot Projects for multi-repository work without local cloning.
A further VS Code release recap demonstrates updates from the past month. These sessions provide workflow examples, but enterprise policy and plan checks remain necessary before teams depend on a particular agent capability.
- Visual Studio Code and GitHub Copilot - What's new in 1.144 + 145 - GitHub Universe 26 edition
- What is new in GitHub: October releases explained
- VS Code: Release Recap
Insiders explores an inbox for agent sessions
Visual Studio Code 1.147 Insiders release notes, updated November 10, 2026, describe experimental inbox mode that groups On hold sessions by workspace and offers inline merging for eligible pull requests. Empty categories are hidden while Inbox remains visible, and Compare Models preview chats expose their original settings on hover. These are Insiders and experimental workflow changes, not a statement of stable availability.
The JetBrains announcement now points elsewhere
The original JetBrains integration made GitHub Copilot a default option in the AI Assistant agent picker through ACP, with automatic discovery requiring a valid subscription and credentials. The article also describes plugin features including completion, Next Edit Suggestions, inline chat, review, and commit-message generation, alongside Copilot CLI workflows on local and remote systems.
A November 4, 2026 editor's note explicitly says the original experience is outdated and directs readers to GitHub Copilot in JetBrains Air. Teams should follow that correction rather than use the original announcement as current setup guidance.
Reusable agent workflows need provenance and independent validation
Skills, catalogs, and automated governance can preserve team decisions across agent sessions. The supplied examples also show why installing instructions or receiving an agent's approval does not establish that a change is safe.
Skills package instructions, not permissions or proof
An agent skill is a versioned directory centered on SKILL.md, with the host responsible for tools, credentials, and permissions. The Data Forge example separates project configuration into a manifest and uses a seven-phase support-desk workflow with human checkpoints. Its Proof Agent performs static diff review without running code or tests, returning PASS, FAIL, or PARTIAL with evidence.
Git-Ape's installation flow asks users to approve the skill, pinned source commit, and destination workspace before writing files. Search uses the registry bundled with the installed copy rather than automatically fetching the latest registry, and installation requires Node.js, an authenticated GitHub CLI, and a workspace-skills client. Proposed pack installation checks member content and refuses overwrites, but installing skills neither executes community scripts nor validates generated deployment designs.
Internal catalogs make adoption visible
Slack's internal AI tool catalog grew from Frances Coronel's personal setup after engineers began forking it. The session demonstrates using GitHub Projects and Issues as a single source of truth for MCP servers, skills, and Copilot agents. An adoption dashboard tracks real usage across teams, with six months of metrics presented in the session.
Repository governance can include reversible enforcement
Jeff Doolittle's demonstration describes building a governance system with GitHub Copilot in four days without manually writing code. It addresses a compliance backlog across 436 repositories using GitHub Actions and custom prompts to enforce remediation lifecycles. The session covers reversible enforcement, self-service remediation, and achieving 100% repository compliance, presenting a specific implementation rather than a general guarantee for agent-built governance.
Version labels can bias agent review
Researchers used Microsoft's Vally evaluation tool and GitHub Copilot CLI to test identical dependency changes under different semantic-version labels. Claude Sonnet 5.5 checked 2 of 10 patch upgrades but all 10 major upgrades in the first experiment. A broader review experiment included 540 runs across six models, six scenarios, and patch, minor, and major labels.
Claude Haiku 5.5 merged updates unchecked in 37% of patch runs versus 7% of major runs. Four breaking-update merges left main broken, all under patch or minor labels. The results support keeping deterministic compatibility and test gates independent of the version label an agent sees.
Production agents require controlled promotion, identity, and state ownership
The production-agent guidance puts release and authorization decisions outside model reasoning. Hosted infrastructure can take over operational responsibilities, but validation, trusted state transitions, and recovery policy still need explicit design.
Toolbox versions require deliberate promotion
A Microsoft Foundry Toolbox is a versioned collection of tools exposed through one MCP-compatible endpoint inside a Foundry Project. Versions are immutable configuration snapshots, subsequent versions require explicit promotion, and rollback means promoting a previously retained version. The project, project-level role-based access control, and required connections must exist before deployment through the project endpoint.
Current guidance requires Azure Developer CLI 1.37.0 or later and the unified microsoft.foundry extension. The sample promotes immediately through a postdeploy hook, but production guidance calls for candidate validation before promotion. Deployment success and release approval should therefore remain separate pipeline decisions.
Foundry guidance distinguishes evaluation, delegation, and quotas
Foundry tool search retrieves relevant tools rather than loading every definition into each model request. Evaluation datasets can come from intelligently sampled traces or be synthesized from instructions, prompts, and reference documents. Insights, rubric evaluators, custom evaluators, and managed memory are described as preview capabilities.
User delegation supports On-Behalf-Of access so downstream services can authorize requests using the user's delegated identity. AI Gateway supplies token-rate limits and total token quotas, not native dollar-budget enforcement in Agent Service. Cost controls and authorization checks therefore need to match the actual controls available rather than assumed equivalents.
Hosted-agent migration preserves evaluation and telemetry contracts
The research-assistant case study describes moving from Azure Container Apps, PostgreSQL conversation storage, and dynamic-session sandboxes toward Foundry hosted agents. Hosted agents provide virtual-machine-isolated session sandboxes and manage compute, persistence, scaling, endpoints, and agent identity. Networking guidance recommends a /24 subnet for production, with /27 documented as the supported minimum for smaller deployments.
The team retained traces in both Azure Monitor Application Insights and Langfuse during migration. Stable backend contracts allowed reuse of evaluation sets and graders against expert-supplied golden answers. That preserved a way to compare behavior while changing the hosting architecture.
Worker isolation does not require exposing inference credentials
Patrick Nikoletich demonstrates a Dockerized agent worker pool with isolated containers and inference gateways that keep credentials out of workers. Agent Host Protocol tunnels CLI sessions into those containers, and the repository includes a harness builder and secure Aspire agent service. A Rust rewrite and direct Azure tunneling are plans for Copilot Harness 2.0, not capabilities demonstrated in the current setup.
Application code remains responsible for authoritative actions
The agentic scheduler lets agents propose placements while application code owns calendar state and validates demand, duration, spacing, conflicts, and capacity. Its backend runs as one Node.js service on Azure Container Apps with PostgreSQL queues and checkpoints and an Azure Files session workspace. The gateway persists commands before returning 202 Accepted, with queued replies reaching browsers through Server-Sent Events.
A related illustrative architecture separates reasoning, trusted action, and operational intelligence into distinct logical planes. Trusted services enforce authorization, policy, and authoritative state before records change, while uncertain partner execution outcomes require reconciliation before retrying. Duplicate detection alone does not resolve an uncertain booking, and Microsoft Fabric stays outside booking, payment, and command execution in that design.
The scheduler records model requests and tool calls through OpenTelemetry and Azure Application Insights and targets failing programs for up to three retries. The broader architecture is not a verified production reference and proposes staged pilots from shadow mode through assisted booking to bounded autonomy. Both examples make model output a proposal to validate rather than authority to mutate state.
- Engineering an Agentic Scheduler
- The Model Isn’t the Boss: An Azure Architecture for Accountable AI Agents
Other DevOps News
Gilles Chehade demonstrates a backup reconciliation loop connected to GitHub CI that fails builds when expected and actual backup state disagree. The discussion recommends reusing infrastructure inventories and repeatedly validating restores, because a completed backup job does not prove recoverability.
Azure's AMD Helios engineering report describes versioned validation of firmware, operating-system images, GPU and network drivers, and diagnostics. SuperBench burn-in and RCCL communication tests identify failures, with faulty nodes quarantined and workload-validated before returning as healthy spares.
A 3D-printing workflow uses separate engine and model-catalog repositories to preserve reusable tools, measurements, outputs, and verification evidence across Copilot sessions. The author still supplies requirements and corrections and reviews generated results and physical prints, while the project's October 11 history reports a 61 percent reduction in print support through measured orientation changes.
Hardware demonstrations connect development tooling with physical feedback: Copilot CLI hooks control an Octolamp through the WLED API, including handling network fallbacks and competing lifecycle events. The GitHub Universe badge report covers its progression from e-ink prototypes to RP2040-powered color screens, including battery-safety work and accelerometer-driven display rotation.
- I made my Octolamp think with GitHub Copilot CLI hooks
- The hardware secrets behind the GitHub Universe badge
The Fabric community spotlight collects 46 posts, videos, and tutorials, including deployment plans, CI/CD, Spark performance, and guidance for securing and governing data agents and semantic models. It provides a broader learning collection rather than a single product release.
The GitHub Universe discussions examine the distinction between being able to build software and deciding whether it is worth maintaining, alongside the role of human judgment in agent-assisted development. Topics include architecture, code security, MCP integrations, developer education, and future skills.
- What's worth building when AI can build anything?
- The view from the labs: What's next for AI-assisted development
- Path to Production for AI Agents
Also relevant this week
- GitHub Enterprise Server support in the GitHub Copilot app: GitHub Enterprise Server support in the GitHub Copilot app is generally available after an opt-in preview. Full story in the GitHub Copilot roundup.
- Dependabot alerts will pause on inactive repositories: Starting December 8, 2026, GitHub will pause Dependabot alerts on most repositories inactive for one year and archive existing alerts. Full story in the Security roundup.
- Give Your .NET Agent a Face: Building an AI Desk Companion with M5Stack: C++ on M5Stack/StackChan hardware controls the companion's display, movement, and sensors, while a .NET 11 backend hosts supporting services. Full story in the .NET roundup.
- Modern web development with ASP.NET Core & Blazor in .NET 11: The session covers ASP.NET Core and Blazor in .NET 11 through demonstrations. Full story in the .NET roundup.
- Introducing Azure Container Apps Sandboxes in Visual Studio Code: The Azure Container Apps extension adds sandbox groups and individual sandboxes to Visual Studio Code's Azure Resources view. Full story in the Azure roundup.
- Query Performance Tuning in Azure DocumentDB: A Practical Guide: Azure DocumentDB diagnostic logs can route to Log Analytics, where KQL identifies slow operations in VCoreMongoRequests. Full story in the Azure roundup.
- Build faster apps: database caching patterns with Azure Managed Redis: The article describes eight caching patterns, including cache-aside, write-through, write-behind, event-driven updates, and multi-region caching. Full story in the Azure roundup.
- Public preview: Auto scaling of ingestion limits in Azure Monitor workspace: In public preview, Auto-scale is opt-in per Azure Monitor workspace and adjusts ingestion limits upward and downward according to utilization. Full story in the Azure roundup.
- Closing a monitoring blind spot: version store read metrics: Azure SQL Database now exposes version store read counters through STATISTICS IO, DMVs, extended events, and query plan XML. Full story in the Azure roundup.
- C# Dev Kit 11: Faster Foundations for .NET Development—and What Comes Next: C# Dev Kit 11 consolidates five back-end processes into a single Native AOT server. Full story in the .NET roundup.
- Smarter Spring Development in Eclipse with GitHub Copilot: The setup requires Spring Tools for Eclipse 2.0 or later, the GitHub Copilot plugin, and an open Spring Boot project. Full story in the GitHub Copilot roundup.
- Visual Studio Code and GitHub Copilot - What's new in 1.146: The video demonstrates selected GitHub Copilot features in Visual Studio Code 1.146 rather than covering every release feature. Full story in the GitHub Copilot roundup.
- Detecting sleeper agents hiding in AI model neurons: Edits to fewer than ten neurons can create a sleeper agent that passes evaluations and emits an attacker’s command when triggered. Full story in the Security roundup.
- More Processes, More Problems - how to speed up your builds with Multithreaded MSBuild: The .NET team presents multithreaded MSBuild as a new execution mode for improving build performance. Full story in the .NET roundup.
- My Favorite Undocumented Feature in SQL MCP Server: Data API builder 2.0 introduced auto configuration in June 2026, using autoentities wildcard patterns to include SQL tables. Full story in the Artificial Intelligence roundup.
- What's New in Aspire for .NET Developers: Supporting additional languages prompted the Aspire team to revisit assumptions in its original .NET-focused experience. Full story in the .NET roundup.
- 🐘 Database performance issues? Start investigating in VS Code! #vscode #postgresql: The walkthrough investigates PostgreSQL performance issues from a Visual Studio Code workflow. Full story in the Azure roundup.
- Instant Free Tier Clusters in Azure DocumentDB: Azure DocumentDB free tier cluster provisioning now completes in seconds instead of a few minutes. Full story in the Azure roundup.
- Secret scanning detects Cloudflare service tokens: GitHub secret scanning now detects Cloudflare service tokens using the cloudflare_access_service_token secret type. Full story in the Security roundup.
- C++ language server now auto-configures MSBuild builds: The Microsoft C++ Language Server now bundles an MSBuild compile commands extractor and invokes it automatically on project open. Full story in the GitHub Copilot roundup.
- Protect your PC from AI coding agents while modernising legacy .NET apps: The session discusses isolation options for AI coding agents using GitHub Copilot CLI modernisation plugins on legacy .NET applications. Full story in the Security roundup.
- Turning the GitHub Universe badge into a retro gaming console: The GitHub Universe badge uses graphics as capacitive touch buttons for handheld gaming controls. Full story in the GitHub Copilot roundup.
- Security in 60 Seconds: Malicious Dependencies: Attackers can compromise maintainer accounts to insert malware into trusted packages. Full story in the Security roundup.
- Public monitoring alerts now have direct links: Individual public monitoring alerts now have direct links. Full story in the Security roundup.
- Visual Studio Keynote at .NET Conf 2026: The keynote covers current Visual Studio capabilities and improvements. Full story in the .NET roundup.
- What's new in Visual Studio: The session demonstrates Visual Studio features and productivity improvements for .NET developers. Full story in the .NET roundup.
Dates to know
Deadlines
- 2 December 2026: GitHub Actions: Public repositories block pull_request_target events by default unless an applicable Actions event policy explicitly allows them. (Protect the repository hosting your GitHub Action (2026))
- 8 December 2026: GitHub Actions Hosted runners: Support ends for ARM32 job execution on Windows and Linux hosted runners, including native AArch32 user-space execution. (Actions for ARM32 Linux & Windows retirement)
- 8 December 2026: GitHub Dependabot: Dependabot alerts pause after one year of repository inactivity on github.com and GitHub Enterprise Cloud with data residency, subject to policy exemptions. (Dependabot alerts will pause on inactive repositories)
- 1 September 2027: End of support — Azure App Service; Azure Functions: Support for Java 8, 11, and 17 ends; existing applications continue running without related runtime updates or support. (Plan Your Java Upgrade Ahead of Microsoft’s 2027 Support Milestones)
- September 2027: Microsoft Build of OpenJDK: Earliest end-of-support target for Java 11 and 17 builds, subject to extension by Microsoft. (Plan Your Java Upgrade Ahead of Microsoft’s 2027 Support Milestones)
- September 2028: Microsoft Build of OpenJDK: Earliest end-of-support target for Java 21 builds, subject to extension by Microsoft. (Plan Your Java Upgrade Ahead of Microsoft’s 2027 Support Milestones)
- 14 November 2028: Visual Studio LTSC: Support ends for Visual Studio 2026 LTSC 18.11. (Announcing Visual Studio 2026 LTSC 18.11)
- September 2030: Microsoft Build of OpenJDK: Earliest end-of-support target for Java 25 builds, subject to extension by Microsoft. (Plan Your Java Upgrade Ahead of Microsoft’s 2027 Support Milestones)