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 576-600 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
Windows Tools
Summary
The documentation demonstrates a moderate Windows bias. PowerShell examples are provided alongside Azure CLI, but there are no explicit Linux shell or Bash scripting examples for tasks like retrieving outbound IPs. In the outbound IPv6 section, outbound IPv6 support is noted as available only for Windows apps, with no Linux parity or roadmap mentioned. The ordering of examples often places PowerShell (a Windows-centric tool) before or alongside CLI, but never Bash or Linux-native tools. There are no references to Linux-specific tools or patterns, and some features (outbound IPv6) are Windows-only.
Recommendations
- For every PowerShell example, provide an equivalent Bash/Linux shell example where possible, especially for common tasks like querying IP addresses.
- Clarify in the outbound IPv6 section whether Linux support is planned or provide a link to the roadmap.
- Where possible, avoid listing PowerShell examples before CLI or Bash, or explicitly note that both Windows and Linux users are supported.
- Highlight any feature gaps between Windows and Linux (such as outbound IPv6) and provide workarounds or alternatives for Linux users.
- Include troubleshooting or verification steps using Linux-native tools (e.g., dig, host, curl) alongside nslookup and PowerShell.
Create Pull Request
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/overview-managed-identity.md
...main/articles/app-service/overview-managed-identity.md
High Priority
View Details →
Detected Bias Types
Powershell Heavy
Windows Tools
Missing Linux Example
Summary
The documentation provides extensive examples using Azure PowerShell, which is primarily a Windows-centric tool, and does not offer equivalent Bash or Linux shell scripting examples. While Azure CLI is cross-platform, the PowerShell examples are more detailed and prevalent, and there are no explicit Linux/Bash shell command examples for tasks such as token retrieval. This may disadvantage Linux users or those who prefer Bash scripting.
Recommendations
- Add Bash shell scripting examples for token retrieval and other automation tasks, especially in sections where PowerShell scripts are provided.
- Clarify that Azure CLI commands are cross-platform and can be run on Linux, macOS, and Windows.
- Where PowerShell is used for scripting, provide equivalent Bash (curl/jq) examples to ensure Linux parity.
- Explicitly mention and demonstrate how to perform key operations (such as HTTP GET to the local MSI endpoint) using common Linux tools (curl, wget) alongside PowerShell.
- Review all code tabs to ensure that Linux users have a clear, first-class path for all documented scenarios.
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/tutorial-auth-aad.md
...cs/blob/main/articles/app-service/tutorial-auth-aad.md
High Priority
View Details →
Detected Bias Types
Windows First
Windows Tools
Missing Linux Example
Summary
The documentation demonstrates a 'windows_first' bias by presenting Windows-specific instructions and examples before Linux equivalents in several sections. It also references Windows-specific tools and directory structures (e.g., 'js-e2e-web-app-easy-auth-app-to-app/frontend' vs 'frontend'), and omits or simplifies Linux-specific guidance in some cases. The Linux instructions are present but sometimes less detailed or appear as an afterthought. There is also a lack of parity in runtime versions and directory navigation between Windows and Linux examples.
Recommendations
- Present Windows and Linux instructions in parallel or in a unified table, rather than always listing Windows first.
- Ensure that Linux examples are as detailed and accurate as Windows examples, including directory structure and runtime versions.
- Avoid Windows-centric terminology or tools unless absolutely necessary; provide Linux equivalents where possible.
- Use neutral language and structure (e.g., 'cd frontend' for both platforms if possible) to reduce perceived bias.
- Explicitly call out any platform-specific differences and explain why they exist.
- Review and update runtime versions for parity (e.g., use the same Node.js version for both Windows and Linux examples).
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/tutorial-connect-msi-sql-database.md
...icles/app-service/tutorial-connect-msi-sql-database.md
High Priority
View Details →
Detected Bias Types
Windows First
Powershell Heavy
Missing Linux Example
Windows Tools
Summary
The documentation demonstrates a Windows bias by prioritizing Windows and Visual Studio (Windows) workflows, using PowerShell and Windows-specific tools for critical steps (such as SQLCMD and Package Manager Console), and omitting explicit Linux or cross-platform alternatives for several development and database administration tasks. Linux/macOS development environments are only briefly mentioned, and there are no concrete examples for performing key steps (like database permission grants) from non-Windows systems.
Recommendations
- Provide explicit Linux/macOS equivalents for all PowerShell and Windows-specific steps, especially for database administration (e.g., using sqlcmd or Azure Data CLI on Linux/macOS).
- Include examples using cross-platform tools (e.g., Azure CLI, dotnet CLI, VS Code) for all major steps, not just for setup but also for database access and migrations.
- Reorder sections or use tabs to present Windows and Linux/macOS instructions with equal prominence, rather than listing Windows/PowerShell first.
- Clarify which tools and commands are cross-platform and provide installation or usage notes for Linux/macOS users.
- Add troubleshooting or notes for common Linux/macOS issues (e.g., sqlcmd installation, authentication 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 migrating from Windows environments, specifically IIS servers, and use Windows-specific tools such as the App Service Migration Assistant (MSI installer) and PowerShell scripts. There are no examples, tools, or guidance provided for migrating .NET apps from Linux environments (e.g., Apache, Nginx, Kestrel), nor are Linux command-line or scripting options mentioned. The documentation assumes the source environment is Windows/IIS and does not address Linux-based .NET hosting scenarios.
Recommendations
- Add migration guidance and examples for .NET apps hosted on Linux servers (e.g., Apache, Nginx, Kestrel).
- Include Linux-native tools or scripts (e.g., Bash, shell scripts) for discovery, assessment, and migration.
- Provide parity in documentation by listing Linux migration options alongside Windows options, not only after or as an afterthought.
- Mention cross-platform migration considerations, such as differences in file paths, environment variables, and dependencies.
- If certain tools are Windows-only, clearly state this and suggest alternative approaches for Linux users.
- Offer containerization guidance for Linux-hosted .NET apps, not just Windows containers.
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 page focuses exclusively on discovering ASP.NET web apps hosted on IIS web servers within VMware environments, which are inherently Windows-centric technologies. There are no references to discovering .NET web apps running on Linux (e.g., Kestrel, Apache, or Nginx), nor are there examples or guidance for Linux-based deployments. All discovery capabilities and tooling mentioned (Azure Migrate appliance, IIS) are Windows-specific, and Linux scenarios are entirely absent.
Recommendations
- Include guidance and examples for discovering .NET web apps running on Linux servers (e.g., Kestrel, Apache, Nginx).
- Mention whether Azure Migrate supports Linux-based .NET app discovery, and if not, clarify this limitation.
- Provide parity in documentation by listing Linux discovery steps, tools, or alternative approaches if available.
- Add references to Linux migration resources or related Azure documentation for Linux-based .NET workloads.
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 examples, troubleshooting steps, and tool references (such as web.config, iisnode, node.exe, and Kudu CMD/PowerShell) are Windows-specific. There are no Linux equivalents or examples provided, and Linux-based deployment, configuration, or troubleshooting is not mentioned. Windows tools and patterns (e.g., web.config, named pipes, Win32 error codes, Kudu CMD/PowerShell) are referenced exclusively and without Linux alternatives.
Recommendations
- Add a parallel section or separate guide for Node.js on Azure App Service Linux, covering best practices and troubleshooting.
- Include Linux-specific configuration and troubleshooting examples (e.g., using environment variables, PM2, NGINX/Apache, or systemd instead of iisnode/web.config).
- Provide examples of accessing logs, debugging, and profiling on Linux (e.g., using SSH, Bash, Linux file paths, and Linux-native tools).
- Reference Linux equivalents for Windows-specific concepts (e.g., explain how to handle process management, logging, and configuration on Linux).
- Avoid assuming the use of Windows-specific tools (like Kudu CMD/PowerShell); mention Bash or SSH where appropriate.
- Clarify in the introduction that the guide is Windows-specific and link to Linux-specific documentation if available.
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 First
Missing Linux Example
Windows Tools
Summary
The documentation page shows subtle Windows bias, particularly in its references to Windows-centric configuration files (web.config), tools (iisnode), and the absence of Linux-specific or cross-platform alternatives in several sections. While there is a mention of Linux in the Node.js/PM2 section, most configuration and troubleshooting guidance defaults to Windows paradigms, and Linux equivalents are not consistently provided.
Recommendations
- When mentioning configuration via 'web.config', also provide equivalent instructions for Linux-based App Service (e.g., using app settings, environment variables, or other Linux-supported configuration files).
- In the Node.js section, balance references to 'iisnode' (Windows-specific) with Linux-native process managers or reverse proxies (e.g., PM2, Nginx) and provide guidance for both environments.
- Where troubleshooting or diagnostics steps are given, clarify any differences between Windows and Linux App Service plans, and provide examples for both.
- Review all examples and recommendations to ensure Linux users are not required to infer or research their own equivalents; provide explicit Linux instructions where appropriate.
- Consider adding a table or section that summarizes differences and best practices for both Windows and Linux App Service environments.
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 page demonstrates a mild Windows bias. In several sections, Windows-related tools and patterns are mentioned before their Linux equivalents, such as listing 'Windows' SKU availability before 'Linux' SKU availability. The automation section provides both Azure CLI (cross-platform) and Azure PowerShell (Windows-centric) examples, but does not mention Bash scripting or Linux-specific automation. The portal instructions and screenshots are platform-neutral, but the overall structure and tool recommendations lean towards Windows users.
Recommendations
- Alternate the order of Windows and Linux instructions/examples to avoid always listing Windows first.
- Include Bash or shell script automation examples alongside Azure PowerShell, especially for Linux users.
- Explicitly mention that Azure CLI commands work on both Windows and Linux, and provide any Linux-specific notes if needed.
- Where possible, add Linux-specific troubleshooting tips or considerations.
- Ensure parity in terminology and tool recommendations for both Windows and Linux environments.
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 exhibits a moderate Windows bias. Windows-specific terminology and tools (such as Azure PowerShell) are mentioned prominently, and Windows SKU availability is listed before Linux. While Azure CLI examples are provided (which are cross-platform), there are no Linux shell-specific examples or references to Linux-native scripting. The PowerShell automation section is included without a corresponding Bash or Linux shell script example. The documentation also refers to the Azure portal UI, which is platform-agnostic, but does not address Linux-specific workflows or tools.
Recommendations
- Provide Linux shell (Bash) script examples for automating tasks, alongside PowerShell.
- List Linux SKU availability before or alongside Windows, or alternate their order.
- Clarify that Azure CLI commands work on both Windows and Linux, and provide explicit Bash usage where appropriate.
- Include references to Linux-native tools or workflows where relevant.
- Ensure that all automation and scripting sections have parity between Windows (PowerShell) and Linux (Bash/CLI).
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 demonstrates 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 (Kudu, CMD, PowerShell), with no mention of Linux-based App Service environments or their equivalents. There are no Linux-specific instructions or examples, and Windows tools and patterns are presented as the default or only option.
Recommendations
- Add parallel instructions and examples for configuring ASP.NET apps on Linux-based App Service plans, including how to check .NET runtime versions and access diagnostic tools.
- Include Linux shell (bash) commands and file paths where appropriate, especially for sections showing how to enumerate installed runtimes or access environment variables.
- Mention and link to Linux-specific tools (such as SSH, bash, or Linux Kudu equivalents) alongside Windows tools like CMD and PowerShell.
- Clarify in each section whether the instructions apply only to Windows App Service plans, and provide Linux alternatives if available.
- Consider a table or side-by-side comparison for common tasks (e.g., setting environment variables, accessing logs) on both Windows and Linux App Service environments.
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 mild Windows bias. Windows instructions, tools, and troubleshooting steps are often presented first or exclusively, especially in troubleshooting and GUI usage. PowerShell commands are provided for connectivity testing, but equivalent Linux commands are missing. The GUI for Hybrid Connection Manager is only available on Windows, and while this is a product limitation, the documentation does not provide parity in terms of Linux troubleshooting or alternative tools. Some sections (e.g., troubleshooting) reference Windows-specific tools and patterns without Linux equivalents.
Recommendations
- When providing troubleshooting steps (e.g., testing connectivity), include Linux equivalents for PowerShell commands, such as using 'nc', 'telnet', or 'curl' for TCP connectivity tests.
- In sections where Windows GUI tools are referenced, explicitly acknowledge the lack of Linux GUI and provide detailed CLI alternatives or scripts for Linux users.
- Where Windows tools or patterns are mentioned (e.g., 'Test-NetConnection', 'Azure Hybrid Connection Manager Service'), provide Linux service management equivalents (e.g., 'systemctl status hcm', 'journalctl -u hcm').
- Ensure that all code snippets, especially for installation and troubleshooting, are present for both Windows and Linux, or clearly state when a feature is unavailable on a platform.
- Consider reordering some sections to present Windows and Linux instructions in parallel tabs or side-by-side, rather than defaulting to Windows-first presentation.
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
Missing Linux Example
Summary
The documentation demonstrates a Windows bias primarily through its reliance on PowerShell scripts for advanced resource discovery and mitigation (e.g., identifying Traffic Manager endpoints). While general Azure CLI and REST API references are present, all scripting automation examples are PowerShell-based, with no Bash, shell, or cross-platform alternatives provided. There is also no explicit mention of Linux/macOS compatibility or guidance for users on those platforms.
Recommendations
- Provide equivalent Bash/shell scripts for all PowerShell automation examples, especially for identifying Traffic Manager endpoints and other resource queries.
- Explicitly state whether provided PowerShell scripts are compatible with PowerShell Core on Linux/macOS, or provide guidance for running them cross-platform.
- Where possible, offer Azure CLI-based alternatives for automation tasks, as Azure CLI is natively cross-platform.
- Include notes or links for Linux/macOS users on how to perform the same tasks, or reference relevant documentation.
- Ensure that any downloadable scripts or automation tools are tested and documented for both Windows and Linux environments.
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 uses Windows-specific tools and patterns (PowerShell, .cmd scripts, Windows environment variables). The Windows instructions are longer, more step-by-step, and rely heavily on PowerShell scripting, while the Linux section uses standard shell scripting and Linux tools. In some places, Windows-specific patterns (like copying Tomcat to a local directory and using %LOCAL_EXPANDED%) are described in detail, and PowerShell is used for XML transforms, which may not have direct Linux equivalents. The Linux instructions are present and functional, but the Windows approach is more thoroughly documented and uses Windows-native tooling.
Recommendations
- Ensure Linux and Windows sections are equally detailed, with step-by-step instructions for both platforms.
- Where PowerShell is used for Windows, provide a Bash or shell script equivalent for Linux, especially for XML transforms.
- Avoid using Windows environment variable syntax (e.g., %VAR%) in general explanations; use cross-platform or platform-specific sections.
- Provide parity in troubleshooting tips and automation examples for both platforms.
- Highlight cross-platform tools (like Azure CLI) where possible, and ensure examples are shown for both Linux and Windows.
- Consider including a summary table comparing steps for Linux and Windows to help users quickly find the relevant instructions.
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 exhibits subtle Windows bias by referencing Windows-specific tools (Azure Storage Explorer) and providing instructions that default to Windows tabs or workflows. There are no explicit Linux or cross-platform alternatives mentioned for uploading files or generating SAS tokens, and the only tool-specific instructions link to Windows tabs. All command-line examples use Azure CLI, which is cross-platform, but the supporting tooling and workflow references are Windows-centric.
Recommendations
- Include explicit instructions or links for performing storage operations (uploading files, generating SAS tokens) using cross-platform or Linux-native tools, such as the Azure CLI, azcopy, or REST APIs.
- When referencing Azure Storage Explorer, clarify its cross-platform availability and provide Linux/macOS installation and usage guidance or links.
- Avoid linking only to Windows-specific tabs or sections in documentation; ensure parity by referencing or including Linux/macOS instructions where applicable.
- Consider adding a section or callout for Linux/macOS users, highlighting any differences or additional steps required.
- Review related documentation links to ensure they are not Windows-centric and provide balanced coverage for all major platforms.
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/configure-language-java-deploy-run.md
...cles/app-service/configure-language-java-deploy-run.md
High Priority
View Details →
Detected Bias Types
Windows First
Powershell Heavy
Windows Tools
Missing Linux Example
Summary
The documentation generally provides parity between Linux and Windows, but there are subtle signs of Windows bias. In several sections, Windows instructions or tools (such as Kudu, Advanced Tools, and FTPS) are mentioned first or exclusively, and some explanations assume familiarity with Windows-specific patterns. There are also more detailed step-by-step instructions for Windows in some advanced scenarios (e.g., Java Flight Recorder), while Linux sections sometimes refer users to external links or provide less detail. Some tools and troubleshooting approaches (like Kudu/Process Explorer) are Windows-centric, and Linux alternatives are not always described. In a few places, Linux-specific instructions are missing or less emphasized.
Recommendations
- Ensure that for every Windows-specific tool or workflow (e.g., Kudu, FTPS, Advanced Tools), the equivalent Linux approach is described with equal detail and visibility.
- When presenting examples or instructions, alternate the order (Linux first in some sections, Windows first in others) or present both simultaneously to avoid the impression of a default OS.
- Expand Linux troubleshooting and diagnostic sections to match the level of detail provided for Windows, including step-by-step instructions for common tasks (e.g., finding process IDs, downloading files, using SSH instead of Kudu).
- Where Windows tools are referenced (such as Kudu Process Explorer), explicitly mention the Linux alternative (e.g., SSH and ps/top commands) and provide sample commands.
- Audit for any missing Linux examples, especially in advanced configuration, deployment, and diagnostics, and add them where absent.
- Review language to ensure that neither OS is implied as the default or primary platform; use neutral phrasing or parallel structure.
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
Windows Tools
Missing Linux Example
Windows First
Summary
The documentation page demonstrates a strong bias toward Windows-centric tooling and workflows. All command-line examples are provided exclusively using Azure PowerShell cmdlets, which are most commonly used in Windows environments. There are no equivalent examples for Linux-native tools such as Azure CLI or Bash scripting. The documentation does not mention or demonstrate Linux-first or cross-platform workflows, and the PowerShell section appears before any mention of ARM templates or other alternatives.
Recommendations
- Add equivalent Azure CLI (az) command examples for all PowerShell cmdlets shown, as Azure CLI is cross-platform and widely used in Linux environments.
- Include Bash scripting examples where appropriate, or at least note that the steps can be performed in Bash on Linux/Mac.
- Explicitly mention that per-app scaling can be configured using both PowerShell and Azure CLI, and provide links to relevant CLI documentation.
- Consider reordering sections so that cross-platform or neutral options (e.g., Azure CLI, ARM templates) are presented before or alongside PowerShell.
- Add a note clarifying that PowerShell is available cross-platform, but that Azure CLI may be more familiar to Linux users.
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 page exhibits a Windows-first bias. Directory paths and deployment details are primarily described using Windows-style paths (e.g., D:\home\site\wwwroot), with Linux equivalents only briefly mentioned in passing. Instructions for manual deployment (such as creating directories and files) reference only Windows paths, and there are no explicit Linux or cross-platform examples for these steps. Additionally, the documentation refers to Windows-centric deployment patterns and tools (e.g., backslashes in paths, drive letters), while omitting Linux-specific instructions or examples.
Recommendations
- Provide parallel Linux examples and explicitly mention Linux directory paths (e.g., /home/site/wwwroot) wherever Windows paths are given.
- When describing manual steps (such as creating directories or files), include both Windows and Linux commands (e.g., using mkdir or touch in Bash).
- Avoid using only Windows-style paths and backslashes; use cross-platform path notation or provide both formats.
- Clarify any platform-specific differences in deployment behavior or directory structure.
- Where possible, use platform-agnostic language and examples, or clearly separate instructions for 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-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-centric tools and workflows, such as Visual Studio and NuGet Package Manager, and by omitting explicit Linux or cross-platform instructions. There are no Linux-specific examples or mentions of Linux-native tools, and the instructions for package installation and deployment are oriented toward Windows users.
Recommendations
- Provide explicit Linux and cross-platform instructions for all steps, including package installation (e.g., using dotnet CLI and apt for dependencies).
- Mention and demonstrate the use of cross-platform editors (e.g., VS Code) and command-line workflows alongside Visual Studio.
- Include Linux-specific deployment guidance (e.g., using Azure CLI from Bash, setting environment variables via the portal or CLI, and troubleshooting on Linux).
- Ensure all code and configuration examples are tested and shown in both Windows and Linux environments.
- Where GUI instructions are given (e.g., right-clicking in Visual Studio), provide equivalent command-line or editor-agnostic alternatives.
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 retrieving outbound IP addresses, but the PowerShell examples are given equal prominence to CLI, and there is no explicit mention of Linux shell or Bash alternatives for PowerShell commands. Additionally, outbound IPv6 support is noted as being available only for Windows apps, with no Linux parity or roadmap discussed. The documentation does not explicitly favor Windows tools overall, but it does not clarify that PowerShell is cross-platform or provide Linux-specific guidance where Windows-only features are mentioned.
Recommendations
- Clarify that Azure PowerShell can be run cross-platform, or explicitly note when a command is Windows-only.
- Provide Bash or Linux-native command alternatives (e.g., using jq with az CLI) where PowerShell is shown, or at least note that the CLI commands work on Linux/macOS.
- When mentioning features only available for Windows (such as outbound IPv6), clearly state the lack of Linux support and, if possible, provide a roadmap or alternatives for Linux users.
- In sections where both Azure CLI and PowerShell are shown, consider listing CLI first, as it is cross-platform, or explicitly mention that both are supported on all platforms.
- Add more explicit Linux/Bash testing examples (e.g., using dig or host in addition to nslookup, which is available on both platforms but less common on Linux).
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 demonstrates a moderate Windows bias. In the prerequisites and quickstart links, 'windows' is listed as a primary tab, and there is a lack of explicit Linux-specific instructions or examples for environment variable management, deployment, or local development. The documentation refers to the Azure portal and Visual Studio (a Windows-centric tool) for deployment and configuration, but does not provide parity for Linux command-line or deployment tools. There are no PowerShell-specific commands, but the overall pattern and tool references are Windows-first.
Recommendations
- Ensure all quickstart and prerequisite links include Linux tabs/examples, not just Windows.
- Provide explicit Linux (and macOS) command-line instructions for setting environment variables and deploying to Azure App Service (e.g., using Azure CLI or Bash scripts).
- Mention cross-platform editors and deployment tools (such as VS Code, Azure CLI, GitHub Actions) alongside or before Visual Studio.
- Include Linux-specific troubleshooting tips or notes where platform differences may arise (e.g., file permissions, environment variable syntax).
- Where the Azure portal is referenced, clarify that it is platform-agnostic, and provide CLI alternatives for common tasks.
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/getting-started.md
...docs/blob/main/articles/app-service/getting-started.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, particularly in the .NET section, where Windows tools (Visual Studio, Azure PowerShell) are listed before cross-platform or Linux-native options. Some quickstart links default to Windows or PowerShell tabs, and Linux-specific instructions are sometimes secondary or missing. The 'Next step' call-to-action also defaults to an ASP.NET (typically Windows-first) example. Other stacks (Java, Node.js, PHP) are more Linux-oriented, but the overall structure and tool recommendations often prioritize Windows or do not provide Linux parity.
Recommendations
- Ensure that for every Windows-specific tool or example (e.g., Visual Studio, Azure PowerShell), an equivalent Linux-friendly option (e.g., VS Code, Azure CLI, Bash) is provided and listed with equal prominence.
- In quickstart tables, alternate the order of tool listings or group them by platform to avoid always listing Windows tools first.
- Where possible, default documentation tabs and links to cross-platform or Linux options, or provide clear toggles for both environments.
- Expand the use of Linux/CLI examples in .NET sections, including explicit mention of Bash and Linux development environments.
- For the 'Next step' section, offer multiple language/framework options (not just ASP.NET) and ensure at least one Linux-native path is highlighted.
- Audit all linked quickstarts to ensure Linux instructions are present and up-to-date, not just Windows/PowerShell.
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), focusing on Windows-specific deployment patterns, and mentioning tools and behaviors (such as Kudu/SCM and Azure Web Apps Disk Usage) that are primarily associated with Windows App Service environments. There are no Linux-specific examples or equivalent Linux paths, and Linux/container scenarios are only mentioned to state that the feature is unsupported, without offering Linux alternatives or guidance.
Recommendations
- Include Linux-specific examples and equivalent Linux filesystem paths (e.g., /home/site) where relevant.
- Clarify which features and instructions apply to Windows, Linux, or both, and provide parallel guidance for Linux App Service where possible.
- Mention Linux-compatible tools or commands (such as using SSH or Linux-native utilities to check disk usage) alongside Windows tools.
- If a feature is unsupported on Linux, provide links or references to alternative solutions (such as App Cache) and include basic usage instructions.
- Ensure that terminology and examples are inclusive of both platforms, or clearly indicate when content is Windows-only.
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 exhibits a mild Windows bias. It provides detailed calculations and limits specifically for Windows Containers, while Linux-specific details are limited to a brief note about continuous deployment network dependencies. There are no Linux container-specific subnet/IP calculations or operational examples. The documentation also references Windows-centric features (e.g., Windows Server Active Directory, NetBIOS) in the context of unsupported features, but does not mention Linux equivalents. Additionally, the order of presentation often places Windows-related content before Linux, and there is a lack of parity in operational guidance for Linux scenarios.
Recommendations
- Add a dedicated section for Linux Containers, including subnet/IP address calculation examples and operational limits similar to the Windows Containers section.
- Provide Linux-specific examples or notes where Windows-specific features are discussed (e.g., mention that Linux containers do not require extra IPs per app, or clarify Linux limitations).
- Ensure that Linux and Windows scenarios are presented in parallel, with equal detail and prominence.
- Include Linux command-line examples (e.g., Azure CLI, Bash) where relevant, especially in sections discussing configuration or troubleshooting.
- Mention Linux authentication and networking patterns (e.g., integration with LDAP or Kerberos, if applicable) when Windows equivalents are referenced.
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/reference-app-settings.md
...ob/main/articles/app-service/reference-app-settings.md
High Priority
View Details →
Detected Bias Types
Windows First
Windows Tools
Powershell Heavy
Missing Linux Example
Summary
The documentation demonstrates a Windows-first bias in several areas: Windows paths and conventions are often mentioned before Linux equivalents, Windows-specific tools (such as MSDeploy, Web Deploy, and Kudu for Windows) are described in detail, and some settings are explained only in a Windows context or with Windows-centric examples. There are also several environment variables and features that are described primarily or exclusively for Windows, with Linux equivalents either missing, less detailed, or mentioned secondarily. In some sections, Linux-specific behaviors are described as exceptions or afterthoughts. There is a lack of parity in example commands, paths, and tool references for Linux users.
Recommendations
- For every environment variable or feature that behaves differently on Windows and Linux, provide both Windows and Linux examples side by side, including file paths, default values, and configuration nuances.
- When referencing tools or deployment methods (e.g., MSDeploy, Web Deploy, Kudu), ensure that Linux equivalents (such as Oryx, ZIP deploy, or other Linux-native tools) are described with equal detail and prominence.
- Avoid using Windows paths (e.g., D:\home) as the sole example; always include the Linux equivalent (/home) in the same context.
- Where features are Windows-only, explicitly state the lack of Linux support and, where possible, suggest Linux alternatives or workarounds.
- Reorganize sections so that Linux and Windows information is presented in parallel, rather than Windows-first with Linux as an addendum.
- Add Linux/POSIX shell command examples (where relevant) alongside any PowerShell or Windows CMD examples.
- Audit the documentation for any settings or behaviors that are only described for Windows and ensure Linux users have clear, actionable guidance.