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 726-750 of 2121 flagged pages
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
Summary
The documentation provides both Azure CLI and Azure PowerShell examples for finding outbound IP addresses, but the PowerShell examples are given equal prominence to CLI, and there is no explicit mention that PowerShell commands are Windows-specific or how to run them on Linux. The only explicit Linux/Unix command is 'nslookup' and 'curl', but there are no Bash scripting or Linux-native tool examples for interacting with Azure beyond Azure CLI. The section on outbound IPv6 support specifically notes that outbound IPv6 is only available for Windows apps, with no Linux equivalent or roadmap. Overall, the documentation assumes familiarity with Windows tools and patterns, and does not clarify cross-platform differences or provide Linux-specific guidance where Windows-only features are mentioned.
Recommendations
- Clearly indicate that Azure PowerShell commands are Windows-centric and provide guidance for running them on Linux (e.g., via PowerShell Core).
- Prioritize Azure CLI examples before PowerShell, as CLI is fully cross-platform.
- Where outbound IPv6 support is Windows-only, explicitly state the lack of Linux support and, if possible, provide a roadmap or alternatives for Linux users.
- Add more Linux-native examples or troubleshooting tips (e.g., using Bash scripting, jq for JSON parsing, or other common Linux tools).
- In sections where Windows-only features are discussed, provide equivalent Linux guidance or clearly state when a feature is not available for Linux.
- Consider a 'Platform differences' callout box summarizing any disparities between Windows and Linux App Service behaviors.
Create Pull Request
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 by providing more detailed instructions and features for Windows-based App Service apps, including exclusive logging types (web server logging, detailed error messages, failed request tracing) and examples. Linux instructions are present but less detailed, and some features are unavailable or not described for Linux. Windows tools and file paths are referenced more frequently, and Linux-specific tools or patterns are not mentioned.
Recommendations
- Provide equivalent, detailed instructions and examples for Linux-based App Service apps wherever possible, including logging types and file access.
- Clearly indicate feature parity or differences between Windows and Linux, and offer workarounds or alternatives for Linux where features are missing.
- Include Linux-specific tools, file paths, and troubleshooting patterns alongside Windows ones (e.g., mention Linux text editors, log viewers, or CLI utilities).
- When referencing tools like Log Parser or file paths, provide Linux equivalents or note their applicability.
- Where features are Windows-only, explain why and suggest alternative monitoring/logging strategies for Linux users.
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 primarily referencing Windows development tools and workflows (e.g., Visual Studio, right-click actions), and omitting explicit Linux or cross-platform instructions. Package installation is described first via Visual Studio (a Windows-centric tool), with CLI instructions only linked and not shown inline. There are no Linux-specific or cross-platform development environment examples, and no mention of Linux file managers or editors. The guidance assumes a GUI-based workflow typical of Windows, with no parity for Linux users.
Recommendations
- Provide explicit CLI-based instructions for all steps, including file creation and editing, to support Linux and cross-platform users.
- Include examples using cross-platform editors (e.g., VS Code, nano, vim) and file system navigation commands (e.g., mkdir, touch, cp).
- Present package installation instructions for both Visual Studio (Windows) and dotnet CLI (cross-platform) side-by-side, not just as links.
- Avoid instructions that assume a GUI (e.g., 'right-click'), or supplement them with equivalent terminal commands.
- Add a section or callouts for Linux/macOS users, highlighting any differences or additional steps required.
- Ensure screenshots (if any) and terminology are inclusive of both Windows and Linux environments.
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/includes/deploy-intelligent-apps/deploy-intelligent-apps-linux-python-pivot.md
...ent-apps/deploy-intelligent-apps-linux-python-pivot.md
High Priority
View Details →
Detected Bias Types
Windows First
Windows Tools
Missing Linux Example
Summary
The documentation page exhibits a mild Windows bias. In the prerequisites and quickstart links, Windows is listed first in tabbed instructions and URLs (e.g., 'tabs=flask,windows,azure-cli,...'), and there is an implicit assumption of Azure Portal/GUI usage (which is more common on Windows). There are no explicit Linux or cross-platform shell examples for environment variable setup or deployment, and the instructions for setting environment variables and app settings focus on the Azure Portal UI, which is more familiar to Windows users. There is also no mention of Linux-specific tools or shell commands for local development, aside from generic Python commands.
Recommendations
- Provide explicit Linux/macOS shell examples for setting environment variables (e.g., export commands) and running the app.
- Ensure that quickstart and prerequisite links include Linux and macOS tabs/examples, not just Windows.
- Mention and demonstrate use of cross-platform tools (such as Azure CLI in Bash) for all setup and deployment steps.
- Clarify that all Python and Azure CLI commands work identically on Linux/macOS, and provide any necessary platform-specific notes.
- Include screenshots or instructions for both Azure Portal (GUI) and CLI-based configuration to support users on all 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-native tools (such as Bash, Azure CLI, or REST API via curl). The exclusive use of PowerShell and references to Azure PowerShell cmdlets assume a Windows environment or familiarity with Windows tooling. No mention is made of cross-platform or Linux-first approaches, and the PowerShell section appears before any mention of ARM templates or other platform-neutral methods.
Recommendations
- Add equivalent Azure CLI (az) examples for all PowerShell commands to ensure Linux and macOS users have clear, native instructions.
- Include Bash shell and REST API (curl) examples where appropriate, especially for scripting and automation scenarios.
- Explicitly state that PowerShell examples can be run cross-platform (if true), or clarify any platform limitations.
- Reorder sections to present cross-platform or platform-neutral methods (such as Azure CLI or ARM templates) before or alongside PowerShell examples.
- Add a note or table summarizing available tooling for both Windows and Linux environments, helping users choose the best fit for their platform.
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, featuring extensive PowerShell scripting and Windows-specific patterns (e.g., use of startup.cmd, %HOME% paths, and PowerShell for XML transforms). Windows tools and patterns (PowerShell, Windows environment variables) are emphasized and explained in greater depth than their Linux equivalents. The Linux instructions are present and functional, but the Windows approach is more elaborate and receives more step-by-step attention.
Recommendations
- Ensure Linux and Windows sections are equally detailed, with step-by-step Linux shell script examples matching the depth of the Windows PowerShell instructions.
- Provide Linux-native alternatives for all Windows-specific tools and patterns (e.g., show how to use Bash scripts for XML transforms, not just PowerShell).
- When introducing cross-platform steps, present Linux and Windows instructions in parallel, rather than giving more prominence or detail to Windows.
- Where possible, use platform-agnostic tools or highlight them first, then provide OS-specific details as needed.
- Expand on Linux troubleshooting, file locations, and automation patterns to match the clarity and completeness of the Windows section.
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 exhibits a Windows-first bias. All file paths and examples use Windows-style paths (e.g., D:\home), and the discussion of folder structure and cache locations is entirely in Windows terms. There is no mention of Linux equivalents or file paths. The only tool mentioned for checking disk usage is the 'Azure Web Apps Disk Usage' site extension, which is primarily relevant to Windows-based App Service. While the page notes that local cache is not supported for Linux containers and points to an alternative ('App Cache'), it does not provide Linux-native examples or guidance for Linux App Service environments.
Recommendations
- Include Linux-specific paths and behaviors (e.g., /home/site/wwwroot) alongside Windows paths when describing folder structure and cache locations.
- Provide examples or instructions for enabling and managing local cache on Linux-based App Service plans, or clearly state if the feature is unavailable.
- Mention Linux-compatible tools or commands for checking disk usage (e.g., using 'du' in SSH/Kudu Bash) in addition to or instead of Windows-specific site extensions.
- Clarify the differences in feature support and behavior between Windows and Linux App Service environments early in the documentation.
- If local cache is not supported on Linux, provide a clear link to the Linux equivalent feature documentation and summarize key differences.
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 demonstrates a Windows-centric bias by referencing Windows-specific tools (IIS, Procdump, SysInternals), focusing on PowerShell for management, and linking to Windows-oriented resources. There is a lack of Linux-specific troubleshooting guidance, examples, or mention of Linux-native tools, despite Azure App Service supporting Linux-based apps.
Recommendations
- Provide equivalent Linux troubleshooting steps, including how to access logs, collect diagnostics, and use the Kudu console or SSH for Linux-based App Service plans.
- Include examples for managing and restarting apps using Azure CLI (cross-platform) alongside or before PowerShell.
- Mention Linux-native tools (such as strace, lsof, top, or dotnet-trace for .NET Core on Linux) for diagnostics and profiling.
- Clarify which features or tools are Windows-only and provide Linux alternatives or workarounds where possible.
- Add links to Linux-specific documentation for Application Insights Profiler, diagnostic logging, and Kudu features on Linux.
- Balance references to Windows and Linux in both text and linked resources to ensure parity.
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 exhibits a mild Windows bias. Windows-specific concepts and limitations (e.g., Windows Containers subnet sizing, Windows Server Active Directory, NetBIOS) are discussed in detail, while Linux-specific scenarios are only briefly mentioned. There are no Linux-specific configuration or troubleshooting examples, and the only explicit Linux mention is a short note about continuous deployment dependencies. No Linux command-line examples or tools are provided, and Windows terminology (e.g., Kudu console) is used without Linux equivalents.
Recommendations
- Add explicit Linux-focused sections or examples, such as Linux container subnet sizing, common Linux networking issues, or Linux-specific environment variables.
- Include Linux CLI (bash/az CLI) command examples for configuring and troubleshooting VNet integration, alongside any PowerShell or portal instructions.
- Balance the coverage of Windows and Linux limitations and features, ensuring that Linux-specific caveats (e.g., file system mounts, SELinux, DNS resolution) are addressed.
- Reference Linux-native tools (e.g., curl, dig, ip, netcat) for network troubleshooting, not just Windows tools or the Kudu console.
- Where Windows-specific features are mentioned (e.g., Windows Containers, Active Directory), provide parallel Linux context or explicitly state if a feature is not applicable to Linux.
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
Missing Linux Example
Windows Tools
Powershell Heavy
Summary
The documentation is heavily focused on Windows environments, specifically Azure App Service on Windows with iisnode. All configuration, troubleshooting, and operational examples are tailored to Windows, referencing Windows-specific tools (e.g., CMD, PowerShell, web.config, iisnode, Win32 error codes, named pipes, d:\ paths). There are no Linux equivalents, examples, or guidance, and Linux-based deployment or troubleshooting is not addressed.
Recommendations
- Provide equivalent guidance and examples for Node.js applications running on Azure App Service for Linux.
- Include Linux-specific troubleshooting steps, such as using SSH, Bash, and Linux file paths.
- Reference Linux-native process managers (e.g., PM2, systemd) and configuration files instead of only iisnode and web.config.
- Add examples for monitoring, logging, and debugging on Linux (e.g., using stdout logs, Linux diagnostic tools, and Azure Kudu Bash console).
- Clearly separate Windows-specific and Linux-specific instructions, or provide a platform selection pivot at the top of the article.
- Mention Linux equivalents for any Windows-specific tools or patterns referenced (e.g., how to check logs, manage processes, or debug on Linux).
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 in several areas. Windows examples and terminology are presented before Linux equivalents, especially in the availability section. PowerShell scripting is highlighted alongside Azure CLI, but there are no Linux shell (bash) or scripting examples. The use of Windows-centric tools and patterns (e.g., PowerShell, references to Windows SKUs) is prevalent, while Linux-specific automation or deployment workflows are not covered. There is also a lack of parity in scripting examples for Linux users.
Recommendations
- Present Linux and Windows options in parallel or alternate their order to avoid a Windows-first impression.
- Include bash shell scripting examples for automating tasks, not just Azure CLI and PowerShell.
- Expand automation sections to mention Linux-native tools and scripting environments (e.g., bash, sh) and provide equivalent examples.
- Clarify when instructions or features are Windows-specific, and provide Linux-specific guidance where applicable.
- Ensure that all code samples and automation workflows are cross-platform or provide platform-specific variants side by side.
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 and tools (such as the GUI and PowerShell commands) are often presented first or exclusively, while Linux alternatives are sometimes less detailed or missing. The Windows GUI is featured prominently, with Linux users directed to CLI-only workflows. Troubleshooting and connectivity testing examples use Windows-centric tools (e.g., PowerShell's Test-NetConnection) without providing equivalent Linux commands. Some sections, such as upgrade instructions and troubleshooting, focus on Windows-specific patterns or omit Linux parity.
Recommendations
- Provide Linux command-line equivalents for all PowerShell examples (e.g., use 'nc', 'telnet', or 'curl' for connectivity tests).
- When presenting instructions, alternate or parallelize Windows and Linux sections rather than always listing Windows first.
- Include more detailed Linux installation, configuration, and troubleshooting steps, matching the depth given to Windows.
- Highlight any differences or limitations for Linux users up front, and offer workarounds or alternatives where possible.
- Where GUI tools are Windows-only, suggest or develop equivalent CLI workflows for Linux and document them clearly.
- In troubleshooting, include Linux-native tools (e.g., 'ss', 'netcat', 'dig', 'nslookup') alongside Windows tools.
- Ensure parity in upgrade and maintenance instructions for both platforms.
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 exhibits a strong Windows bias. All migration tools and examples focus exclusively on migrating from Windows environments, specifically IIS servers, and use Windows-specific tools such as the App Service Migration Assistant (available as an MSI installer) and PowerShell scripts. There are no references to Linux-based .NET hosting environments (such as Kestrel, Apache, or Nginx), nor are there migration paths or tools described for Linux servers. The documentation consistently mentions Windows and Windows tools first (and often exclusively), with no Linux parity in examples, tools, or migration scenarios.
Recommendations
- Add documentation and tooling for migrating .NET web apps hosted on Linux servers (e.g., Kestrel, Apache, Nginx) to Azure App Service.
- Provide Linux-specific migration examples and scripts, such as Bash or shell scripts, alongside PowerShell scripts.
- Mention Linux migration scenarios and tools in parallel with Windows/IIS scenarios, not just as an afterthought.
- Clarify whether the App Service Migration Assistant or similar tools support Linux-based .NET apps, and if not, provide guidance or alternatives for Linux users.
- Include references to containerization for Linux-based .NET apps, not just Windows Containers.
- Ensure that resource tables and tool lists include Linux-compatible options where available.
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. In sections where both Windows and Linux are relevant (such as SKU availability), Windows examples and terminology are presented first. The automation section provides both Azure CLI (cross-platform) and Azure PowerShell (Windows-centric) examples, but does not mention Bash scripting or Linux-native automation tools. The UI walkthroughs and screenshots are based on the Azure Portal, which is platform-agnostic, but the scripting focus leans toward Windows tools and patterns.
Recommendations
- Ensure Linux and Windows examples are given equal prominence and order is alternated or clarified as arbitrary.
- Include Bash or shell script examples for Linux users alongside PowerShell examples, especially in automation sections.
- Explicitly state that Azure CLI commands work on all platforms and can be run in Bash, PowerShell, or Cloud Shell.
- If referencing PowerShell, consider also referencing Linux-native scripting environments where appropriate.
- Where possible, clarify that the Azure Portal UI is the same across platforms to avoid perceived bias.
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
Missing Linux Example
Windows First
Summary
The documentation page demonstrates a moderate Windows bias. It references Windows-specific tools and patterns (such as web.config and iisnode), omits equivalent Linux-native configuration examples, and presents Windows approaches before mentioning Linux alternatives. While there is some mention of Linux (e.g., using PM2 for Node.js), the guidance is generally Windows-centric, and Linux-specific best practices are underrepresented.
Recommendations
- For features like auto-healing, provide Linux-native configuration guidance (e.g., using app settings or startup scripts) alongside web.config instructions.
- When mentioning iisnode or web.config, clarify that these are Windows-specific and provide equivalent Linux approaches (such as using process managers like PM2, or configuring environment variables).
- Ensure that examples and recommendations are presented for both Windows and Linux App Service environments, ideally side-by-side.
- Where possible, avoid assuming the use of Windows-specific file structures or configuration files; instead, mention both Windows and Linux paths and conventions.
- Expand troubleshooting and best practices sections to include Linux-native tools and diagnostics (e.g., using Kudu, SSH, or Linux logs).
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 First
Missing Linux Example
Summary
The documentation exhibits a Windows bias primarily in the section addressing the identification of impacted Traffic Manager endpoints, where only a PowerShell script is provided for detecting non-Azure endpoints. There are no equivalent Bash, Azure CLI, or cross-platform scripting examples for Linux/macOS users. The instructions for running the script assume a Windows/PowerShell environment and do not mention alternatives for Linux users. Elsewhere, the documentation does use Azure CLI and REST API examples, which are cross-platform, but the exclusive reliance on PowerShell for a key scenario stands out.
Recommendations
- Provide equivalent Bash or Azure CLI scripts for identifying non-Azure Traffic Manager endpoints, or at least mention how Linux/macOS users can achieve the same result.
- When referencing scripts, clarify OS compatibility and offer alternatives or guidance for non-Windows environments.
- Where possible, prioritize Azure CLI examples (which are cross-platform) or present them alongside PowerShell scripts to ensure parity.
- Explicitly state when a tool or script is Windows-only and direct users to cross-platform documentation or community solutions.
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 Tools
Missing Linux Example
Windows First
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 is no mention of Linux-based web servers (such as Apache or Nginx), nor are there examples or guidance for discovering .NET apps running on Linux. The tools and patterns described (Azure Migrate appliance, IIS, VMware) are all Windows-oriented, and Linux alternatives are not addressed.
Recommendations
- Include information on discovering .NET web apps hosted on Linux servers (e.g., Apache, Nginx, Kestrel).
- Provide examples or guidance for using Azure Migrate or other tools to discover Linux-based .NET deployments.
- Mention Linux environments explicitly where applicable, and clarify any limitations or differences in discovery capabilities between Windows and Linux.
- Add references or links to documentation covering Linux discovery scenarios for .NET apps.
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 advanced Tomcat server-level configuration, but the Windows section is significantly longer, more detailed, and uses Windows-specific tools (PowerShell, CMD scripts, Windows paths) without equivalent Linux scripting examples. Windows instructions are presented before Linux in some places, and the PowerShell script is much more elaborate than the Linux shell script. There is no explicit parity in scripting complexity or guidance for Linux users.
Recommendations
- Provide a Linux shell script example for automating Tomcat configuration changes, matching the detail and robustness of the Windows PowerShell script.
- Ensure that Linux and Windows instructions are presented with equal prominence and in parallel structure, rather than Windows-first.
- Include Linux-native tooling and patterns (e.g., bash, sh, systemd, cron) where appropriate, not just Windows tools.
- Offer a downloadable sample Linux startup script that mirrors the PowerShell script's logic (checking for marker files, copying Tomcat, applying XSLT, etc.).
- Clarify any differences in capabilities or limitations between Windows and Linux App Service environments for Tomcat configuration.
- Where possible, use cross-platform tools or highlight them (e.g., using Azure CLI for both platforms) and avoid assuming Windows as the default.
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
Summary
The documentation provides both Azure CLI and Azure PowerShell examples for finding outbound IP addresses, but the PowerShell examples are presented alongside the CLI examples without clarifying platform applicability. There is no explicit mention that PowerShell commands are Windows-centric or that Azure CLI is cross-platform. Additionally, outbound IPv6 support is noted as being available only for Windows apps, but there is no guidance or parity for Linux users beyond stating the limitation. No Linux-specific tools or shell examples (e.g., bash scripting) are provided, and the documentation does not clarify that Azure CLI commands work identically on Linux, macOS, and Windows.
Recommendations
- Clearly label PowerShell examples as Windows-specific and Azure CLI examples as cross-platform (Linux, macOS, Windows).
- Present Azure CLI (cross-platform) examples before PowerShell (Windows-centric) examples to avoid 'windows_first' bias.
- Add explicit notes or callouts for Linux/macOS users, confirming that Azure CLI commands are fully supported on those platforms.
- Where outbound IPv6 support is Windows-only, provide a clear roadmap or workaround for Linux users, or link to relevant feature requests.
- Consider including bash or shell script examples for common tasks, especially in sections where only PowerShell is shown.
- Where features are Windows-only, provide context and alternatives for Linux users, or at least acknowledge the gap.
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
Windows First
Windows Tools
Powershell Heavy
Missing Linux Example
Summary
The documentation page demonstrates a Windows bias by prioritizing Windows-specific tools and patterns, such as IIS diagnostics, PowerShell commands, and references to Windows-only features (e.g., Procdump, .NET Profiler for Windows). There is a lack of Linux-specific troubleshooting guidance, and Linux-native tools or examples are not mentioned. The Kudu Console is described in terms of PowerShell and DOS commands, with no mention of Bash or Linux shell support. Diagnostic and mitigation steps are presented from a Windows-centric perspective, with Linux alternatives either omitted or not given equal prominence.
Recommendations
- Add explicit Linux troubleshooting steps and examples, such as using Bash in Kudu, Linux-native diagnostic tools (e.g., strace, lsof, top), and log file locations for Linux-based App Service plans.
- When referencing tools like Procdump or IIS logs, provide Linux equivalents or note their applicability (e.g., using gcore for memory dumps on Linux).
- In sections about enabling diagnostics or profiling, clarify which features are available on Linux App Service and provide links to relevant Linux documentation.
- Balance PowerShell examples with Azure CLI or Bash alternatives, especially for app management and automation tasks.
- Review all tool and feature references to ensure Linux users are not left without guidance or are directed to appropriate resources.
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 page demonstrates a mild Windows bias by referencing Azure Storage Explorer with a direct link to Windows-specific instructions and not providing equivalent Linux tooling or instructions. The Storage Explorer SAS generation link includes a '?tabs=windows' parameter, and there are no examples or notes for Linux users regarding uploading files or generating SAS tokens. All command-line examples use Azure CLI, which is cross-platform, but the only GUI tool mentioned is Storage Explorer with a Windows focus. There is no mention of Linux-native tools (e.g., azcopy, Linux file managers) or parity in GUI instructions.
Recommendations
- Add explicit instructions or links for Linux and macOS users on how to upload files and generate SAS tokens, either using Azure Storage Explorer (with appropriate tabs/sections for each OS) or alternative tools like azcopy.
- Remove or supplement the '?tabs=windows' parameter in documentation links to ensure cross-platform guidance is visible.
- Mention that Azure Storage Explorer is available on Windows, macOS, and Linux, and provide platform-specific instructions or clarify that the steps are similar across platforms.
- Consider including CLI-based alternatives (e.g., az storage blob upload, az storage blob generate-sas) for users who prefer or require command-line solutions, especially on Linux.
- Review all tool references to ensure Linux users are not left without clear, actionable steps.
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
Missing Linux Example
Windows Tools
Summary
The documentation page exhibits a Windows bias by focusing exclusively on Windows-based deployment and configuration patterns for ASP.NET apps. All runtime version examples reference Windows file paths and tools (CMD, PowerShell, Kudu), with no mention of Linux equivalents or how to perform similar tasks on Linux-based App Service plans. There are no Linux-specific instructions or examples, and Windows tools and patterns are presented as the default or only option.
Recommendations
- Add equivalent instructions and examples for Linux-based App Service plans, including how to check .NET runtime versions and access diagnostic tools on Linux.
- Provide Linux shell (bash) commands alongside CMD/PowerShell examples, and clarify when a command or tool is Windows-specific.
- Mention and link to documentation for configuring ASP.NET apps on Linux App Service, including differences in environment variable access, file paths, and diagnostic tooling.
- Clearly indicate when a section applies only to Windows and provide parity for Linux scenarios to ensure cross-platform inclusivity.
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 bias by referencing Windows-style paths (e.g., D:\home), using Windows terminology and tools (such as Kudu/SCM), and omitting Linux-specific examples or guidance. While there is a brief mention of Linux containers, the main documentation, examples, and folder structures are Windows-centric, with no equivalent Linux paths, commands, or operational details provided.
Recommendations
- Include Linux-specific examples and folder paths (e.g., /home/site/wwwroot) alongside Windows examples.
- Clarify differences in local cache behavior and configuration for Linux-based App Service plans.
- Provide parity in tooling instructions, such as how to inspect environment variables or folder structures on Linux (e.g., using SSH or Linux shell commands).
- Explicitly state when a feature or instruction is Windows-only, and offer alternatives or workarounds for Linux users.
- Reference Linux tools or commands (such as ls, du, or cat) where appropriate, and provide equivalent instructions for both platforms.
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 presents Windows container information before Linux, and the Windows section lacks parity with the Linux section. Only browser-based SSH is described for Windows containers, with no mention of CLI or PowerShell-based access, while the Linux section provides detailed Azure CLI and SSH command-line instructions. There are no PowerShell or Windows-native SSH client examples, and the documentation does not mention Windows command-line tools or provide equivalent instructions for Windows users.
Recommendations
- Provide equivalent command-line SSH access instructions for Windows containers, or clearly state if such access is unsupported.
- If CLI-based SSH access is not available for Windows containers, explain the limitation and suggest any available alternatives (such as PowerShell remoting, RDP, or other tools).
- Include examples using Windows-native SSH clients or PowerShell where appropriate, especially for users on Windows workstations.
- Balance the order of presentation so that Linux and Windows instructions are given equal prominence, or use parallel structure in the documentation.
- If certain features are only available on Linux, explicitly state this at the top of the page to set expectations for Windows users.
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, explicit guidance and calculations for Windows Containers (e.g., subnet sizing), while Linux-specific scenarios are only briefly mentioned (such as a single note about Linux continuous deployment network dependencies). There are no Linux container-specific examples or parity in subnet/IP calculations, and Windows terminology and features (e.g., Windows Server Active Directory, NetBIOS) are referenced without Linux equivalents or alternatives. The overall structure and examples prioritize Windows scenarios and tools.
Recommendations
- Add equivalent subnet/IP address calculation examples for Linux containers, including any unique considerations or limitations.
- Provide Linux-specific guidance for App Service plans, such as scaling, networking, and known limitations, similar to the Windows Containers section.
- Include Linux-relevant features or caveats (e.g., integration with Linux authentication systems, Linux-specific networking behaviors) where Windows-specific features are discussed.
- Ensure that Linux and Windows examples are presented with equal prominence, or alternate which platform is discussed first in each section.
- Where Windows-only features are mentioned (e.g., NetBIOS, Windows Server Active Directory), explicitly state their absence or alternatives for Linux workloads.