App Service
432
Total Pages
240
Linux-Friendly Pages
192
Pages with Bias
44.4%
Bias Rate
Bias Trend Over Time
Pages with Bias Issues
2121 issues found
Showing 751-775 of 2121 flagged pages
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/deploy-run-package.md
...s/blob/main/articles/app-service/deploy-run-package.md
High Priority
View Details →
Detected Bias Types
Windows First
Windows Tools
Missing Linux Example
Summary
The documentation demonstrates a Windows bias by referencing Windows file paths (e.g., D:\home\site\wwwroot) before Linux equivalents, describing deployment directories and behaviors primarily in Windows terms, and omitting explicit Linux/macOS command-line examples or file system details. There is also a reliance on Windows-centric patterns (backslashes in paths, drive letters) and no Linux-specific troubleshooting or parity in examples.
Recommendations
- Present both Windows and Linux file paths together, or list Linux paths first where appropriate (e.g., "/home/site/wwwroot" alongside "D:\home\site\wwwroot").
- Include Linux/macOS-specific examples and notes, especially for file system operations, directory creation, and troubleshooting.
- Avoid using only Windows-style paths (backslashes, drive letters) in explanations; always provide the Linux equivalent.
- Explicitly mention any differences in behavior or requirements between Windows and Linux App Service plans.
- Add troubleshooting tips relevant to Linux environments (e.g., permissions, case sensitivity).
- Where possible, use platform-neutral language and examples, or provide tabs/switchers for Windows and Linux instructions.
Create Pull Request
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/includes/deploy-intelligent-apps/deploy-intelligent-apps-linux-dotnet-pivot.md
...ent-apps/deploy-intelligent-apps-linux-dotnet-pivot.md
High Priority
View Details →
Detected Bias Types
Windows First
Missing Linux Example
Windows Tools
Summary
The documentation page demonstrates a bias toward Windows by referencing Windows/Visual Studio tooling and workflows first (e.g., right-click instructions, NuGet Package Manager in Visual Studio), and omits explicit Linux or cross-platform command-line examples for key steps such as file creation and package installation. There are no Linux-specific or cross-platform instructions for tasks like editing files, managing secrets, or deploying, and the CLI instructions are only linked, not shown inline.
Recommendations
- Provide explicit Linux and cross-platform command-line instructions for all steps, including file creation (e.g., using 'touch' and editors like 'nano' or 'vim'), package installation (using 'dotnet CLI' and 'nuget CLI'), and environment variable management.
- When referencing tools, mention cross-platform options (e.g., VS Code, JetBrains Rider) alongside Visual Studio, and avoid assuming a GUI workflow.
- Include inline examples for both Windows and Linux for critical steps, such as setting environment variables, managing Azure Key Vault secrets, and deploying to App Service.
- Structure instructions so that CLI/cross-platform approaches are presented before or alongside Windows/GUI-specific methods.
- Add a note clarifying that all steps are possible on Linux/macOS and provide links to relevant documentation for those platforms.
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/manage-scale-per-app.md
...blob/main/articles/app-service/manage-scale-per-app.md
High Priority
View Details →
Detected Bias Types
Powershell Heavy
Missing Linux Example
Windows Tools
Windows First
Summary
The documentation page demonstrates a Windows bias by providing only PowerShell-based CLI examples for per-app scaling, with no equivalent examples for Linux users (such as Azure CLI/bash). The use of PowerShell cmdlets and Windows-centric scripting patterns is exclusive, and no mention is made of Linux-native tools or workflows. The PowerShell section appears before any mention of cross-platform or ARM template approaches, reinforcing the Windows-first perspective.
Recommendations
- Add equivalent Azure CLI (az) examples for all PowerShell commands to support Linux and macOS users.
- Include bash shell script examples alongside PowerShell to demonstrate parity.
- Explicitly mention that both PowerShell and Azure CLI can be used, and provide links to cross-platform tool documentation.
- Reorder sections or provide parallel examples so that Windows and Linux workflows are presented equally.
- Clarify that ARM templates are platform-agnostic and can be used from any OS, and provide command-line deployment examples using az CLI.
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/troubleshoot-diagnostic-logs.md
...n/articles/app-service/troubleshoot-diagnostic-logs.md
High Priority
View Details →
Detected Bias Types
Windows First
Missing Linux Example
Windows Tools
Summary
The documentation demonstrates a Windows-first bias: logging types and features are described with Windows as the primary or only supported platform in several sections, with Linux-specific instructions and capabilities less detailed or omitted. Several advanced logging features (web server logging, detailed error messages, failed request tracing) are described only for Windows, with no Linux equivalents or workarounds mentioned. Tooling references (e.g., Log Parser, W3C log format) are Windows-centric. Linux logging options are described more briefly and lack parity in detail and functionality.
Recommendations
- Provide equivalent Linux examples and instructions for all logging types, or clearly state if a feature is unavailable on Linux.
- Explicitly document any feature gaps between Windows and Linux App Service plans, and suggest alternative approaches or workarounds for Linux users.
- Include Linux-friendly tooling and log analysis options (e.g., mention open-source log viewers, CLI tools, or how to access logs via SSH/SFTP).
- Ensure that for every Windows-specific section, there is a corresponding Linux section or a clear note about platform support.
- List platform support for each logging feature in a summary table at the top for quick reference.
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/app-service-best-practices.md
...ain/articles/app-service/app-service-best-practices.md
High Priority
View Details →
Detected Bias Types
Windows Tools
Windows First
Missing Linux Example
Summary
The documentation demonstrates a mild Windows bias, primarily by referencing Windows-specific tools (such as web.config and iisnode) without providing equivalent Linux alternatives or examples. While there is a brief mention of Linux (in the Node.js/PM2 section), most configuration and troubleshooting guidance assumes a Windows environment or omits Linux-specific instructions.
Recommendations
- For features like auto-healing, provide Linux-specific configuration guidance (e.g., how to configure auto-healing for Linux-based App Service, or note if it's not available).
- When referencing web.config or iisnode, clarify their applicability (Windows only), and provide Linux equivalents or alternative approaches (e.g., app settings, startup scripts, or configuration files used in Linux containers).
- Ensure that all examples (such as memory dump, process recycling, or diagnostics) include both Windows and Linux approaches, or explicitly state platform limitations.
- In sections discussing Node.js, expand on Linux-native process management and monitoring tools (e.g., systemd, supervisord) alongside PM2.
- Audit the documentation for other Windows-centric terminology or features, and add Linux parity or clear notes about platform differences.
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/app-service-asp-net-migration.md
.../articles/app-service/app-service-asp-net-migration.md
High Priority
View Details →
Detected Bias Types
Windows First
Missing Linux Example
Windows Tools
Powershell Heavy
Summary
The documentation page demonstrates a strong Windows bias: all migration tools and examples focus exclusively on Windows environments, specifically IIS servers and PowerShell scripts. There is no mention of Linux-based hosting, migration from Linux web servers, or equivalent Linux tools. The App Service Migration Assistant and related scripts are Windows-only, and containerization is discussed only in the context of Windows Containers. No Linux migration scenarios, commands, or tools are provided.
Recommendations
- Include migration guidance and examples for .NET apps hosted on Linux servers (e.g., Apache, Nginx).
- Provide Linux-compatible migration tools or document manual migration steps for Linux environments.
- Offer Bash or shell script equivalents for PowerShell-based migration scripts.
- Mention and link to Azure App Service for Linux documentation where relevant.
- Clarify tool/platform limitations up front and suggest alternative approaches for Linux users.
- Highlight containerization options for Linux-based .NET Core/ASP.NET Core apps, not just Windows Containers.
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/app-service-configure-premium-v4-tier.md
...s/app-service/app-service-configure-premium-v4-tier.md
High Priority
View Details →
Detected Bias Types
Windows First
Powershell Heavy
Windows Tools
Missing Linux Example
Summary
The documentation demonstrates a Windows-first bias by presenting Windows-related information and tools before Linux equivalents. Azure PowerShell (a Windows-centric tool) is given a dedicated section, while Linux-specific automation (e.g., Bash scripting) is not mentioned. The portal instructions and screenshots are Windows-oriented, and there are no Linux-specific examples for automating deployments or scaling operations. Although Azure CLI is cross-platform, the lack of explicit Linux/Bash scripting examples and the ordering of Windows information before Linux equivalents indicate a bias.
Recommendations
- Provide Linux/Bash scripting examples alongside PowerShell for automation tasks.
- Ensure Linux-specific instructions and screenshots are included where relevant, especially for portal workflows that may differ.
- Present Linux and Windows options in parallel, rather than listing Windows first.
- Include guidance for Linux container scenarios, especially since Premium V4 supports custom containers on Linux.
- Clarify any differences in experience or limitations between Windows and Linux throughout the documentation.
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/app-service-configure-premium-v3-tier.md
...s/app-service/app-service-configure-premium-v3-tier.md
High Priority
View Details →
Detected Bias Types
Windows First
Powershell Heavy
Windows Tools
Summary
The documentation demonstrates a mild Windows bias: Windows examples and terminology are often presented before Linux equivalents, and Azure PowerShell (a Windows-centric tool) is given equal prominence to Azure CLI, despite the CLI being more cross-platform. The documentation also references the Azure portal UI, which is platform-agnostic but often more familiar to Windows users. There are no explicit Linux shell or scripting examples, and Linux-specific guidance is limited to a single CLI flag.
Recommendations
- Present Linux and Windows options side-by-side or in parallel sections, rather than listing Windows first.
- Include Linux shell scripting examples (e.g., Bash) alongside PowerShell examples for automation.
- Clarify that Azure CLI is fully cross-platform and can be used on Windows, macOS, and Linux.
- Expand on Linux-specific considerations, such as differences in deployment or troubleshooting.
- Where possible, provide parity in example depth and detail for both Linux and Windows environments.
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/configure-authentication-file-based.md
...les/app-service/configure-authentication-file-based.md
High Priority
View Details →
Detected Bias Types
Windows First
Windows Tools
Missing Linux Example
Summary
The documentation demonstrates Windows bias by referencing the Windows file path (C:\home\site\wwwroot) first and in more detail, mentioning relative and absolute paths for Windows but only absolute paths for Linux. There are no Linux command-line or file-system examples, and the Linux-specific path is only mentioned in a note, not in the main instructions or examples. No Linux tools or patterns are referenced.
Recommendations
- Provide Linux file path examples (e.g., /home/site/wwwroot) alongside or before Windows paths in all relevant instructions and code samples.
- Include explicit Linux-focused instructions and examples, not just as a note, but integrated into the main steps.
- Mention both Windows and Linux behaviors equally when discussing platform differences (e.g., path formats, deployment locations).
- If referencing tools or file locations, always provide the Linux equivalent (e.g., show how to deploy or locate the config file on Linux App Service).
- Consider adding a table or section summarizing platform-specific differences for clarity.
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/app-service-hybrid-connections.md
...articles/app-service/app-service-hybrid-connections.md
High Priority
View Details →
Detected Bias Types
Windows First
Powershell Heavy
Windows Tools
Missing Linux Example
Summary
The documentation demonstrates a moderate Windows bias. Windows instructions, tools, and examples are often presented first or exclusively, especially in troubleshooting and GUI usage. PowerShell commands are referenced for network testing, and the GUI for Hybrid Connection Manager is only available on Windows, with Linux users relegated to CLI. Some troubleshooting steps and tools (e.g., Test-NetConnection) are Windows-specific, with no direct Linux equivalents provided. Linux support is present but less detailed and less user-friendly.
Recommendations
- When providing troubleshooting steps, include equivalent Linux commands (e.g., use 'nc' or 'telnet' for TCP connectivity instead of only PowerShell's Test-NetConnection).
- Present Windows and Linux instructions in parallel, or alternate which OS is presented first in each section to avoid a 'Windows-first' perception.
- Where GUI tools are only available on Windows, provide enhanced CLI guidance and scripts for Linux users to achieve parity.
- Expand Linux installation and usage sections with more detailed, step-by-step instructions, including common troubleshooting scenarios.
- In all code examples and command references, ensure both Windows and Linux equivalents are shown, especially for network diagnostics and endpoint testing.
- Explicitly acknowledge feature gaps (such as lack of GUI on Linux) and, where possible, offer workarounds or roadmap information.
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/app-service-migration-discover-net.md
...cles/app-service/app-service-migration-discover-net.md
High Priority
View Details →
Detected Bias Types
Windows First
Missing Linux Example
Windows Tools
Summary
The documentation focuses exclusively on discovering ASP.NET web apps hosted on IIS web servers within VMware environments, which are Windows-centric technologies. There are no references to Linux-based hosting scenarios, such as .NET apps running on Kestrel, Apache, or Nginx, nor are there examples or guidance for discovering .NET apps on Linux servers. All discovery capabilities and tooling (Azure Migrate appliance, IIS) are described in a Windows context, with no Linux parity.
Recommendations
- Include explicit guidance and examples for discovering .NET web apps hosted on Linux servers (e.g., Kestrel, Apache, Nginx).
- Mention whether Azure Migrate supports Linux-based .NET app discovery, and if not, clarify the limitation.
- Provide parity in documentation by listing Linux discovery steps, tools, or limitations alongside Windows/IIS instructions.
- Reference Linux-compatible tools or scripts for app discovery, if available, or suggest alternative approaches for Linux environments.
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/app-service-managed-certificate-changes-july-2025.md
...e/app-service-managed-certificate-changes-july-2025.md
High Priority
View Details →
Detected Bias Types
Powershell Heavy
Windows Tools
Windows First
Missing Linux Example
Summary
The documentation demonstrates a Windows bias primarily in the section addressing Azure Traffic Manager endpoints. It exclusively recommends and documents a PowerShell script (with explicit PowerShell usage instructions) to identify non-Azure endpoints, without offering equivalent Bash, Azure CLI, or cross-platform alternatives. Throughout the page, while REST API and Azure CLI commands are referenced for certificate management, the only explicit script-based automation example is for PowerShell, and there is no mention of Linux shell or Bash scripting. This may disadvantage users on Linux or macOS, or those preferring non-Windows automation tools.
Recommendations
- Provide equivalent Bash or Azure CLI scripts for identifying non-Azure Traffic Manager endpoints, or reference cross-platform tools where possible.
- When recommending scripts or automation, offer both PowerShell and Bash (or at least Azure CLI) examples to ensure parity for Linux/macOS users.
- Explicitly state when a solution is Windows-only and offer alternatives for other platforms.
- Where possible, prefer Azure CLI or REST API examples for automation, as these are cross-platform.
- Review other sections for implicit Windows-first assumptions and ensure Linux users are equally supported in all procedural guidance.
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/configure-language-java-data-sources.md
...es/app-service/configure-language-java-data-sources.md
High Priority
View Details →
Detected Bias Types
Windows First
Powershell Heavy
Windows Tools
Summary
The documentation provides both Linux and Windows instructions for configuring Tomcat data sources, but the Windows section is notably more detailed and prescriptive, with step-by-step PowerShell scripts and Windows-specific file paths and tools. Windows configuration is described with more explicit automation (PowerShell), while Linux relies on more generic shell scripting and manual steps. The Windows section also introduces Windows-specific patterns (startup.cmd, PowerShell, %HOME% paths) and tools (PowerShell, Windows environment variables) that have no direct Linux equivalents presented with the same level of detail. In some places, Windows instructions or tools are mentioned before or more prominently than their Linux counterparts.
Recommendations
- Provide equally detailed, step-by-step Linux automation scripts (e.g., bash scripts) for tasks that are automated with PowerShell on Windows, such as copying Tomcat, transforming XML, and setting up environment variables.
- Where Windows-specific tools or patterns are introduced (e.g., startup.cmd, PowerShell), offer direct Linux equivalents (e.g., startup.sh, bash scripting) with matching detail and sample code.
- Ensure that Linux instructions are not only present but are as comprehensive and prescriptive as Windows instructions, including error handling, idempotency, and automation tips.
- When listing instructions for both platforms, consider presenting Linux examples first or side-by-side to avoid the impression of Windows primacy.
- Include more Linux-native patterns and tools (e.g., systemd, cron, shell scripting best practices) where appropriate, and avoid assuming familiarity with Windows concepts in Linux sections.
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/app-service-web-nodejs-best-practices-and-troubleshoot-guide.md
...rvice-web-nodejs-best-practices-and-troubleshoot-guide.md
High Priority
View Details →
Detected Bias Types
Windows First
Windows Tools
Missing Linux Example
Powershell Heavy
Summary
The documentation is heavily focused on Windows environments, specifically Azure App Service on Windows with iisnode. All configuration and troubleshooting steps are tailored to Windows, referencing Windows-specific tools (iisnode, web.config, named pipes, Win32 error codes, Kudu CMD/PowerShell), and file paths (e.g., d:\home\LogFiles). There are no examples or guidance for Linux-based Azure App Service environments, nor are Linux equivalents or cross-platform alternatives mentioned.
Recommendations
- Add a parallel section or separate documentation for Node.js on Azure App Service Linux, covering configuration, deployment, and troubleshooting steps relevant to Linux environments.
- Include Linux-specific examples (e.g., using pm2, nginx, or other common Node.js process managers on Linux) and configuration files (such as process.json, ecosystem.config.js, or nginx.conf).
- Reference Linux file paths and logging locations alongside Windows paths.
- Provide guidance for using the Azure Cloud Shell (bash) and SSH-based troubleshooting, not just Kudu CMD/PowerShell.
- Mention cross-platform Node.js debugging and profiling tools, and clarify which steps are Windows-only.
- Clearly label the scope of the document as Windows-specific at the top, and link to Linux-focused documentation for parity.
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/deploy-run-package.md
...s/blob/main/articles/app-service/deploy-run-package.md
High Priority
View Details →
Detected Bias Types
Windows First
Windows Tools
Missing Linux Example
Summary
The documentation demonstrates a Windows bias by referencing Windows directory paths (e.g., D:\home\site\wwwroot) before Linux equivalents, using Windows path separators in examples, and omitting explicit Linux command-line or file path examples. The instructions and troubleshooting sections focus on Windows conventions, with only brief mentions of Linux paths and no Linux-specific deployment or troubleshooting guidance.
Recommendations
- Provide Linux-specific examples alongside Windows ones, including directory paths (e.g., /home/site/wwwroot) and command-line instructions.
- Use platform-agnostic path notation or show both Windows and Linux paths in all relevant sections.
- Include troubleshooting steps and notes that address Linux-specific behaviors and issues.
- Ensure that all references to tools (such as Azure CLI) clarify their cross-platform availability and usage.
- Add explicit Linux/macOS shell command examples (e.g., bash) where appropriate, not just Azure CLI.
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/configure-encrypt-at-rest-using-cmk.md
...les/app-service/configure-encrypt-at-rest-using-cmk.md
High Priority
View Details →
Detected Bias Types
Windows First
Windows Tools
Missing Linux Example
Summary
The documentation demonstrates a mild Windows bias by referencing Azure Storage Explorer (a GUI tool with a primary Windows focus) for uploading files and generating SAS tokens, and by providing a link that defaults to Windows instructions. There are no explicit Linux or cross-platform CLI examples for these steps, and no mention of Linux-native tools or workflows for uploading or managing blobs. All command-line examples use Azure CLI, which is cross-platform, but the initial file upload and SAS generation steps are Windows-centric.
Recommendations
- Provide explicit Linux and macOS instructions for uploading files and generating SAS tokens, such as using the Azure CLI (az storage blob upload, az storage blob generate-sas) or AzCopy.
- Include cross-platform command-line examples alongside or instead of GUI-based instructions, especially for critical steps like uploading and securing deployment packages.
- When referencing Azure Storage Explorer, clarify its availability on all platforms or provide alternative methods for Linux users.
- Ensure that documentation links and tabs do not default to Windows, and that Linux/macOS tabs are equally visible and complete.
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/configure-language-dotnet-framework.md
...les/app-service/configure-language-dotnet-framework.md
High Priority
View Details →
Detected Bias Types
Windows First
Windows Tools
Missing Linux Example
Summary
The documentation page demonstrates a Windows bias by focusing exclusively on Windows-based deployment and configuration patterns for ASP.NET apps. All runtime version discovery steps use Windows file paths and tools (Kudu, CMD, PowerShell), with no mention of Linux equivalents. There are no examples or instructions for configuring or troubleshooting ASP.NET apps running on Linux App Service plans, nor any Linux shell or file system references.
Recommendations
- Add parallel instructions and examples for ASP.NET apps running on Linux App Service plans, including how to check installed .NET runtimes and access environment variables.
- Provide Linux shell (bash) commands for listing available .NET runtimes and SDKs in Linux containers or App Service for Linux.
- Mention and demonstrate how to use Kudu SSH or App Service SSH console for Linux-based apps.
- Clarify which instructions apply only to Windows App Service and provide links or sections for Linux-specific guidance.
- Include troubleshooting and diagnostic log access steps for Linux-based ASP.NET apps, referencing Linux file paths and tools.
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/manage-scale-per-app.md
...blob/main/articles/app-service/manage-scale-per-app.md
High Priority
View Details →
Detected Bias Types
Powershell Heavy
Missing Linux Example
Windows Tools
Windows First
Summary
The documentation page demonstrates a strong Windows bias by providing only PowerShell-based CLI examples for per-app scaling, with no equivalent examples for Linux users (e.g., Bash, Azure CLI). The use of Azure PowerShell cmdlets and the absence of cross-platform command-line alternatives or explicit mention of Linux tooling make the instructions less accessible to non-Windows users. Additionally, the documentation metadata and custom tags emphasize Azure PowerShell, reinforcing the Windows-centric approach.
Recommendations
- Add equivalent Azure CLI (az) examples for all PowerShell commands, as Azure CLI is cross-platform and widely used on Linux and macOS.
- Include Bash shell script examples where appropriate, especially for scripting scenarios.
- Explicitly mention that per-app scaling can be configured using Azure CLI and provide links or references to relevant documentation.
- Balance the order of examples by presenting Azure CLI or ARM template examples before or alongside PowerShell examples.
- Review metadata and custom tags to ensure they do not exclusively reference Windows/Powershell tooling.
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/configure-linux-open-ssh-session.md
...ticles/app-service/configure-linux-open-ssh-session.md
High Priority
View Details →
Detected Bias Types
Windows First
Missing Linux Example
Windows Tools
Summary
The documentation page demonstrates a Windows-first bias by presenting Windows container information before Linux, and by providing more detailed, actionable SSH instructions and examples for Linux containers only. Windows containers are described as requiring no modifications, but there are no equivalent CLI or PowerShell examples for Windows containers, nor is there guidance for SSH access outside the browser. This leaves Linux users with richer, more practical guidance, while Windows users are limited to browser-based access and lack parity in tooling or command-line examples.
Recommendations
- Provide equivalent command-line (CLI or PowerShell) instructions for opening SSH sessions to Windows containers, or clearly state if such access is not possible and why.
- If browser-based SSH is the only supported method for Windows containers, explicitly mention this limitation and suggest any available workarounds or alternatives.
- Balance the order of presentation by either combining Linux and Windows guidance where possible or alternating which platform is presented first.
- Include references to Windows-native tools (such as PowerShell or Windows Terminal) for SSH access if supported, or clarify their absence.
- Ensure that both Linux and Windows sections contain comparable levels of detail, troubleshooting tips, and example commands.
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/includes/deploy-intelligent-apps/deploy-intelligent-apps-linux-dotnet-pivot.md
...ent-apps/deploy-intelligent-apps-linux-dotnet-pivot.md
High Priority
View Details →
Detected Bias Types
Windows First
Missing Linux Example
Windows Tools
Summary
The documentation demonstrates a Windows bias by prioritizing Windows/Visual Studio workflows (e.g., right-clicking folders, using the NuGet package manager in Visual Studio) and omitting explicit Linux or cross-platform command-line instructions for common tasks such as file creation, package installation, and deployment. While some CLI links are provided, the main narrative and step-by-step instructions assume a Windows GUI environment, leaving Linux users without equivalent guidance.
Recommendations
- For every Visual Studio or GUI-based instruction (e.g., right-click to add files), provide equivalent command-line instructions suitable for Linux/macOS users (e.g., using 'touch' or 'mkdir').
- When referencing the NuGet package manager in Visual Studio, also include explicit 'dotnet add package' CLI commands for installing dependencies.
- Clarify that all .NET 8 Blazor development steps can be performed on Linux/macOS using the .NET CLI, and provide links or brief instructions for setting up the development environment on those platforms.
- When mentioning navigation in the Azure Portal, note that the experience is platform-agnostic, but also provide Azure CLI or ARM template alternatives for configuration steps where possible.
- Add a section or callout summarizing cross-platform compatibility and pointing to resources for Linux/macOS developers.
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/overview-inbound-outbound-ips.md
.../articles/app-service/overview-inbound-outbound-ips.md
High Priority
View Details →
Detected Bias Types
Windows First
Powershell Heavy
Missing Linux Example
Windows Tools
Summary
The documentation page demonstrates a moderate Windows bias. PowerShell examples are provided alongside Azure CLI, but there are no explicit Linux shell or Bash script examples for key operations (e.g., retrieving outbound IPs). In the section on outbound IPv6 support, it is noted that outbound IPv6 is only available for Windows apps, with Linux apps limited to IPv4. The documentation references Azure PowerShell cmdlets and does not mention Linux-native tools or workflows (such as Bash scripting, jq, or curl for API queries) except for a single 'curl' example for IPv6 testing. The order of examples often presents Windows/PowerShell before CLI or Linux-relevant methods.
Recommendations
- For every PowerShell example, provide an equivalent Bash/Azure CLI example, and ensure both are given equal prominence and ordering.
- Explicitly mention Linux support or limitations in all relevant sections, not only for IPv6 outbound.
- Where possible, include Linux-native tools (e.g., Bash with az CLI and jq) for querying properties, especially in 'Find outbound IPs' and similar sections.
- Avoid presenting Windows/PowerShell examples before CLI/Bash; alternate the order or present them in parallel tabs.
- Clarify in the documentation when a feature is Windows-only, and suggest workarounds or alternatives for Linux users.
- Expand the 'Test IPv6 connectivity' section with Windows and Linux command-line examples, if differences exist.
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/overview-local-cache.md
...blob/main/articles/app-service/overview-local-cache.md
High Priority
View Details →
Detected Bias Types
Windows First
Windows Tools
Missing Linux Example
Summary
The documentation page demonstrates a Windows-first bias by exclusively referencing Windows-style paths (e.g., D:\home), using Windows-centric terminology, and omitting Linux-specific examples or instructions. Tools and folder structures are described only in the context of Windows, and there is no guidance for Linux-based App Service environments. The only mention of Linux is to state that the feature is unsupported for Linux containers, without further Linux-specific context or alternatives.
Recommendations
- Provide equivalent Linux path examples (e.g., /home/site) alongside Windows paths.
- Include instructions or notes for Linux-based App Service environments, even if only to clarify differences or limitations.
- Mention and describe Linux tools or commands where applicable, such as how to check folder sizes or environment variables in Linux environments.
- Clarify which features or settings apply to Windows, Linux, or both, and provide parity in documentation structure.
- If a feature is unsupported on Linux, offer links or references to Linux alternatives (such as App Cache) and describe how to use them.
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/overview-vnet-integration.md
...main/articles/app-service/overview-vnet-integration.md
High Priority
View Details →
Detected Bias Types
Windows First
Windows Tools
Missing Linux Example
Summary
The documentation page demonstrates a Windows bias by providing detailed, specific guidance and calculations for Windows Containers (including subnet sizing and networking units), while Linux containers and apps are only briefly mentioned. The only explicit Linux-specific section is a short note about network dependencies for Linux continuous deployment, with no comparable depth or example calculations as provided for Windows. There are no Linux-specific examples or parity in the subnet/IP calculation guidance, and Windows terminology and patterns (such as Windows Server Active Directory, NetBIOS, and Windows Containers) are mentioned without Linux equivalents or alternatives.
Recommendations
- Add equivalent subnet/IP calculation examples and guidance for Linux containers and Linux App Service plans, similar to the detailed Windows Containers section.
- Include Linux-specific limitations, considerations, or best practices where applicable (e.g., for networking, scaling, or integration).
- Provide examples or references for Linux-based tools or patterns (e.g., integration with Linux authentication mechanisms, Linux-based storage mounts, etc.) where Windows-specific features are discussed.
- Ensure that Linux and Windows examples are presented with parity and, where possible, in parallel, rather than focusing on Windows first or exclusively.
- Clarify when guidance is Windows-specific and provide Linux alternatives or explicitly state if a feature/limitation applies to both platforms.
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/troubleshoot-performance-degradation.md
...es/app-service/troubleshoot-performance-degradation.md
High Priority
View Details →
Detected Bias Types
Powershell Heavy
Windows Tools
Windows First
Missing Linux Example
Summary
The documentation page demonstrates a Windows bias by referencing Windows-specific tools (such as IIS, Procdump, and PowerShell), providing links and examples that are Windows-centric, and omitting equivalent Linux guidance. Diagnostic and troubleshooting steps focus on Windows App Service features, with no mention of Linux-specific logging, diagnostic tools, or command-line examples. The Kudu console is described in terms of PowerShell and DOS commands, and links reference Windows Azure resources. There are no Linux command-line examples or references to Linux-native tools.
Recommendations
- Include Linux-specific troubleshooting steps, such as using SSH, Bash, or Linux-native diagnostic tools (e.g., strace, lsof, top).
- Provide examples and instructions for enabling diagnostics and collecting logs on Linux App Service plans, including differences in log file locations and formats.
- Mention and link to Linux equivalents for tools like Procdump (e.g., gcore, gdb) and explain how to collect memory dumps on Linux.
- Update references to the Kudu console to clarify differences between Windows and Linux App Service environments (e.g., Bash vs. PowerShell availability).
- Add parity in code and command examples, ensuring both Windows and Linux users are supported throughout the troubleshooting process.
- Where features are Windows-only (such as IIS-specific diagnostics), clearly state this and provide alternative guidance for Linux users.
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/troubleshoot-diagnostic-logs.md
...n/articles/app-service/troubleshoot-diagnostic-logs.md
High Priority
View Details →
Detected Bias Types
Windows First
Missing Linux Example
Windows Tools
Summary
The documentation page demonstrates a Windows-first bias by providing detailed, step-by-step instructions and feature coverage for Windows App Service apps before Linux equivalents. Several logging features (web server logging, detailed error messages, failed request tracing) are described only for Windows, with no Linux or container alternatives or workarounds mentioned. Windows-specific tools and log formats (e.g., W3C, Log Parser, D:\ paths) are referenced without Linux parallels. Linux instructions are present but less detailed and sometimes limited to basic configuration, lacking parity with Windows features.
Recommendations
- Provide equivalent, detailed instructions for Linux and container-based App Service apps for all logging features, or clearly state if a feature is unavailable.
- Include Linux-specific examples, such as log file paths, tools for viewing logs (e.g., tail, less, jq), and troubleshooting steps.
- If certain logging types (web server logging, detailed error messages, failed request tracing) are not supported on Linux, explicitly mention this and suggest alternative approaches or workarounds.
- Avoid referencing only Windows tools (e.g., Log Parser, D:\ paths) and include Linux alternatives (e.g., /home/LogFiles, grep, awk).
- Structure sections so that Linux and Windows instructions are presented with equal prominence, or group them together for direct comparison.
- Expand code examples to include Linux-friendly languages and frameworks, not just .NET/ASP.NET.