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 151-175 of 2121 flagged pages
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/includes/webjobs-create/webjob-types.md
...es/app-service/includes/webjobs-create/webjob-types.md
High Priority
View Details →
Detected Bias Types
Windows First
Windows Tools
Missing Linux Example
Summary
The documentation presents Windows file types and tools (cmd, bat, exe, PowerShell) first and in greater detail, listing multiple Windows-specific script formats and runtimes. Linux sections are comparatively brief, mentioning only *.sh* and providing fewer examples. Windows tools and patterns (cmd, PowerShell) are named explicitly, while Linux equivalents (bash, shell) are less emphasized and lack parity in example depth.
Recommendations
- List Linux file types and runtimes with equal specificity and detail as Windows (e.g., include *.py*, *.pl*, *.rb*, *.sh*, *.bash*).
- Provide Linux-first or parallel examples for each runtime and script type, matching the Windows examples.
- Explicitly mention Linux tools (bash, shell, etc.) and their usage, similar to how Windows cmd and PowerShell are described.
- Ensure examples for Linux containers include multiple language runtimes (e.g., Python, Java, Node.js) as done for Windows containers.
- Balance the order of presentation so that Linux and Windows are treated equally, or alternate which platform is presented first.
Create Pull Request
App Service
Migration Checklist - Azure App Service on Arc-enabled Kubernetes to Azure Container Apps on Arc-enabled Kubernetes
...b/main/articles/app-service/migrate-app-service-arc.md
High Priority
View Details →
Detected Bias Types
Powershell Heavy
Windows First
Missing Linux Example
Summary
The documentation provides both Azure CLI and Azure PowerShell examples for resource queries, but PowerShell is given equal prominence, which may indicate a bias toward Windows users. There are no explicit Linux shell (bash) or native Linux tool examples, and PowerShell is a Windows-centric tool. The documentation does not mention Linux-specific patterns or tools, and does not provide Linux-first or Linux-only instructions, despite the fact that the migration target (Azure Container Apps on Arc-enabled Kubernetes) only supports Linux containers.
Recommendations
- Add bash shell examples for all CLI commands, demonstrating usage in a native Linux environment.
- Clarify that Azure CLI is cross-platform and can be used on both Windows and Linux, while PowerShell is primarily a Windows tool.
- Remove or de-emphasize PowerShell examples unless there is a specific need for Windows users.
- Explicitly mention Linux prerequisites and patterns, such as using bash scripts for automation.
- Provide guidance for users migrating from Windows-based workloads to Linux containers, including tips for containerizing Windows applications for Linux.
App Service
Migrate Docker Compose to sidecars
...es/app-service/migrate-sidecar-multi-container-apps.md
High Priority
View Details →
Detected Bias Types
Powershell Heavy
Windows First
Missing Linux Example
Windows Tools
Summary
The documentation page demonstrates a Windows bias by recommending PowerShell as a prerequisite and providing only PowerShell-based migration scripts and examples for key steps (such as decoding base64). There are no Linux shell (bash) equivalents or examples, and Windows tools (PowerShell scripts) are referenced before any cross-platform alternatives. This may hinder Linux users or those working in non-Windows environments from following the migration guidance easily.
Recommendations
- Provide bash shell equivalents for all PowerShell commands, especially for decoding base64 and running migration scripts.
- Offer a cross-platform migration script (e.g., a bash or Python version) or clarify how Linux/macOS users can run the provided PowerShell script (e.g., via PowerShell Core on Linux).
- List prerequisites in a cross-platform manner, e.g., 'PowerShell (Windows or PowerShell Core on Linux/macOS) or bash', and clarify tool availability.
- Include Linux/macOS-specific instructions and examples alongside Windows/PowerShell ones throughout the documentation.
- Reference platform-neutral tools and patterns first, or present Windows and Linux approaches side-by-side.
App Service
Operating System Functionality in Azure App Service
...articles/app-service/operating-system-functionality.md
High Priority
View Details →
Detected Bias Types
Windows First
Missing Linux Example
Windows Tools
Powershell Heavy
Summary
The documentation page is heavily focused on Windows-specific functionality and patterns. It describes file, network, and registry access almost exclusively in terms of Windows concepts (e.g., %SystemDrive%, IIS, ASP.NET, COM components, Windows registry, PowerShell scripts). Linux is mentioned only briefly and generically, with no concrete examples, patterns, or equivalent tooling discussed. Windows tools and terminology (IIS, ASP.NET, registry, PowerShell) are used throughout, and Linux alternatives are not presented.
Recommendations
- Provide parallel Linux examples and explanations for file paths, environment variables, and storage (e.g., use $HOME, /tmp, etc. for Linux).
- Include Linux-specific tooling and patterns (e.g., Nginx/Apache instead of IIS, shell scripts instead of PowerShell, Linux process/user model).
- Discuss Linux container diagnostics and logging options (e.g., syslog, journald, container logs) alongside Windows event logs and tracing.
- Clarify differences in registry access by explaining Linux equivalents (e.g., config files, environment variables) and how to persist settings.
- Add code snippets or configuration samples for both Windows and Linux platforms.
- Reorganize sections to present Windows and Linux information side-by-side or in parallel, rather than Windows-first.
App Service
Per-App Scaling for High-Density Hosting
...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 bias toward Windows-centric tooling and workflows. All CLI-based examples use Azure PowerShell cmdlets, with no equivalent examples for Bash, Azure CLI, or Linux-native tools. The only imperative automation shown is via PowerShell, which is primarily a Windows tool, and there is no mention of Linux or cross-platform scripting alternatives. This may hinder accessibility for Linux users or those preferring non-Windows environments.
Recommendations
- Add equivalent examples using Azure CLI (az) commands, which are cross-platform and commonly used on Linux.
- Include Bash shell scripting examples for configuring per-app scaling.
- Explicitly mention that PowerShell examples can be run on Linux using PowerShell Core, if applicable.
- Reorder sections or provide parallel examples so that Linux/cross-platform methods are presented alongside or before Windows/PowerShell methods.
- Clarify in the introduction that all features and configuration methods are available regardless of OS, and provide links to relevant cross-platform tooling.
High Priority
View Details →
Detected Bias Types
Windows Tools
Missing Linux Example
Windows First
Summary
The documentation page shows evidence of Windows bias, particularly in the 'Hybrid Connections' section, which exclusively mentions installing the Hybrid Connection Manager on 'Windows Server 2012 or newer' hosts, with no mention of Linux support or alternatives. There are no Linux-specific instructions, examples, or parity notes for cross-platform scenarios. Additionally, the gateway-required virtual network integration feature is explicitly limited to 'App Service Windows plans', with no Linux equivalent or workaround described. The documentation generally presents Windows options and tools first, and omits Linux-specific guidance where relevant.
Recommendations
- Explicitly state platform support for features like Hybrid Connections, including whether Linux is supported and, if so, provide installation and usage instructions for Linux hosts.
- Where features are Windows-only (e.g., gateway-required VNet integration), clarify the lack of Linux support and suggest alternative approaches for Linux users.
- Add Linux-specific examples and instructions for networking features throughout the documentation to ensure parity.
- Review all tool and agent references (such as Hybrid Connection Manager) and provide cross-platform alternatives or note limitations.
- Consider a cross-platform compatibility matrix for networking features to help users quickly identify platform-specific limitations.
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 no Linux shell or Bash alternatives are given for PowerShell commands. Outbound IPv6 support is explicitly stated as available only for Windows apps, with Linux support still limited to IPv4. The documentation references Azure PowerShell before or alongside CLI, and does not clarify Linux-specific behaviors or limitations except in the context of IPv6 outbound support. There are no Linux-specific troubleshooting steps, nor are Linux-native tools (e.g., curl, dig) used except for a single curl example for IPv6 testing.
Recommendations
- Provide Bash or Linux shell command equivalents for all PowerShell examples, especially for querying outbound IP addresses.
- Clarify Linux-specific limitations and behaviors throughout, not only for IPv6 outbound support.
- Explicitly state when features/tools are Windows-only and provide Linux alternatives or workarounds where possible.
- Use cross-platform tools (curl, dig, nslookup) in examples where possible, and highlight their usage for both Windows and Linux users.
- Add troubleshooting steps or notes for Linux environments, especially where Azure CLI or portal behavior may differ.
App Service
Managed Instance on App Service overview (preview)
...main/articles/app-service/overview-managed-instance.md
High Priority
View Details →
Detected Bias Types
Windows First
Powershell Heavy
Windows Tools
Missing Linux Example
Summary
The documentation for Managed Instance on Azure App Service is heavily Windows-centric. All examples, configuration options, and tooling references are for Windows environments (PowerShell scripts, registry, COM, MSI, IIS, RDP, GAC, MSMQ). There are no Linux equivalents or examples, and Linux/container workloads are explicitly excluded. Windows tools and patterns are mentioned exclusively and before any mention of cross-platform alternatives.
Recommendations
- Clearly indicate Windows-only scope at the top of the documentation and in all relevant sections.
- Where possible, provide parity guidance for Linux users (e.g., link to Linux App Service documentation, explain how similar scenarios are handled on Linux).
- Add a comparison table highlighting feature differences between Windows Managed Instance and Linux App Service.
- Include references to Linux tools and configuration patterns where applicable, or explicitly state their absence.
- Ensure that navigation paths for Linux/container users are clear and accessible from this page.
App Service
Integrate your app with an Azure virtual network
...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 in several ways. Windows-specific features and limitations (such as Windows Containers and Windows Server Active Directory domain join) are discussed in detail, including sample calculations and resource requirements. Linux-specific guidance is limited to a brief mention regarding continuous deployment network dependencies, with no equivalent depth or examples for Linux containers or Linux-specific networking scenarios. Most examples, calculations, and operational patterns are presented for Windows environments, with Linux considerations appearing later and less prominently.
Recommendations
- Add equivalent Linux container subnet/IP calculations and resource requirements, similar to the detailed Windows Containers section.
- Provide Linux-specific examples for app integration, troubleshooting, and operational patterns, including CLI commands and environment variables relevant to Linux.
- Ensure Linux networking limitations and features are discussed with parity to Windows (e.g., domain join, mounting drives, etc.).
- Present Linux and Windows guidance side-by-side or in parallel sections, rather than Windows-first.
- Expand on Linux continuous deployment and container image pull scenarios, including references to Linux tools and best practices.
High Priority
View Details →
Detected Bias Types
Windows First
Missing Linux Example
Windows Tools
Summary
The documentation page exhibits Windows bias primarily in the 'Managed Instance on Azure App Service' section, which exclusively describes features and capabilities for Windows web apps, including PowerShell scripts, RDP access, and legacy Windows component support. There are no equivalent Linux examples, tools, or parity notes. The documentation also links to Windows-specific pricing details before Linux, and the managed instance feature is explicitly unavailable for Linux or containers.
Recommendations
- Add equivalent Linux-focused sections or explicitly state Linux limitations and roadmap for parity.
- Provide Linux-specific examples, such as Bash scripts or Linux-native configuration approaches, alongside PowerShell examples.
- Mention Linux tools and patterns (e.g., SSH for diagnostics instead of RDP, Linux package managers instead of MSI installers) where relevant.
- Clarify feature availability for both Windows and Linux throughout, not just in limitations.
- Ensure pricing and feature comparison tables include both Windows and Linux columns and links.
High Priority
View Details →
Detected Bias Types
Powershell Heavy
Windows Tools
Windows First
Missing Linux Example
Summary
The documentation demonstrates a moderate Windows bias. PowerShell is featured heavily, with many examples and scripts provided for PowerShell and Azure PowerShell modules, which are Windows-centric. There is no mention of Linux-specific shell examples (e.g., Bash), nor are there instructions for using Linux-native tools or patterns. The CLI examples use 'az', which is cross-platform, but the lack of Bash or shell scripting examples and the exclusive use of PowerShell in scripting sections suggest a Windows-first approach. Additionally, there are no references to Linux-specific considerations, troubleshooting, or parity in the context of managed identities.
Recommendations
- Add Bash shell examples for scripting tasks, especially for token retrieval and identity assignment/removal, to complement PowerShell scripts.
- Explicitly mention that Azure CLI commands work on Linux, macOS, and Windows, and provide example usage in Bash.
- Include troubleshooting notes or considerations for Linux environments, such as file permissions, environment variable handling, or differences in endpoint access.
- Where PowerShell is used for scripting, provide equivalent Bash scripts or curl commands for REST calls.
- Review and update documentation to ensure Linux and macOS users are equally supported in all example sections, especially in 'Connect to Azure services in app code' and 'Remove an identity'.
App Service
Use Private Endpoints for Apps
...main/articles/app-service/overview-private-endpoint.md
High Priority
View Details →
Detected Bias Types
Windows First
Powershell Heavy
Windows Tools
Summary
The documentation page demonstrates a Windows bias by listing Windows and PowerShell-based quickstarts and tools before Linux alternatives. PowerShell is highlighted as a primary automation method, and Windows terminology (such as 'Azure PowerShell') is prominent. While the page states that private endpoints are available for both Windows and Linux apps, example scripts and tool references (e.g., PowerShell, Azure portal) are Windows-centric, and Linux-specific instructions or parity examples are missing or less visible.
Recommendations
- Add explicit Linux command-line examples (e.g., bash, curl, dig) for DNS and endpoint verification.
- Include Linux-focused quickstarts or highlight Azure CLI usage (which is cross-platform) before PowerShell.
- Balance references to Windows tools (PowerShell, Azure portal) with Linux equivalents and clarify cross-platform support.
- Provide troubleshooting steps and logs examples for both Windows and Linux environments.
- Ensure that automation and scripting guidance is not PowerShell-centric; offer bash and Python alternatives.
High Priority
View Details →
Detected Bias Types
Windows First
Powershell Heavy
Windows Tools
Missing Linux Example
Summary
The documentation page demonstrates a Windows bias, especially in the Managed Instance section, which exclusively discusses Windows-specific features (COM, registry, MSI, drive mapping, PowerShell scripts, RDP) and tools. Windows workloads and tools (PowerShell, IIS, ACLs, MSMQ) are mentioned in detail, while Linux and container support are only referenced as not supported or as alternatives, with no equivalent Linux examples or tooling described. Command-line tooling lists Azure PowerShell before Azure CLI, and Windows-centric deployment patterns are described without Linux parity.
Recommendations
- Provide Linux-specific examples and tooling for deployment, configuration, and diagnostics where possible.
- List Azure CLI before or alongside Azure PowerShell in command-line tool recommendations, and include Bash examples.
- When describing features, present Linux and Windows options with equal detail, or explicitly state parity/limitations.
- For Managed Instance, clarify Linux alternatives or roadmap, and link to Linux/container documentation for similar scenarios.
- Include references to Linux-friendly IDEs and workflows, such as VS Code on Linux, and mention cross-platform support explicitly.
App Service
Create an App by Using a Terraform Template
...n/articles/app-service/provision-resource-terraform.md
High Priority
View Details →
Detected Bias Types
Windows First
Powershell Heavy
Windows Tools
Summary
The documentation page demonstrates some Windows bias in the prerequisites section, where Windows and PowerShell configuration options are listed before Linux equivalents. There is a strong emphasis on Windows-specific tools (PowerShell, Windows Bash, Visual Studio Code extension) and Windows container examples, with Windows options often mentioned before or alongside Linux ones. However, the main template examples do provide both Linux and Windows container options, and the implementation steps use Bash commands, which are cross-platform.
Recommendations
- List Linux configuration options before Windows ones in the prerequisites section to avoid 'windows_first' ordering.
- Provide explicit Linux shell (e.g., Bash) examples alongside PowerShell examples, especially for command-line steps.
- Mention Linux tools and patterns (such as native Linux editors, CLI usage) before or alongside Windows tools like Visual Studio Code.
- Clarify cross-platform compatibility for all steps, and ensure parity in instructions for both Linux and Windows environments.
- Consider adding a dedicated section for Linux users, highlighting any differences or additional steps required.
App Service
Quickstart: Run a Custom Container on App Service
...in/articles/app-service/quickstart-custom-container.md
High Priority
View Details →
Detected Bias Types
Windows First
Powershell Heavy
Windows Tools
Summary
The documentation page presents Windows-specific pivots (Visual Studio, Powershell, CLI) before Linux equivalents and includes multiple Windows-only tools (Visual Studio, Powershell) without clear Linux alternatives. Powershell and Windows CLI examples are explicitly called out, while Linux command-line examples are less prominent or missing. This structure may lead users to perceive Windows as the primary or preferred platform for custom container deployment on Azure App Service.
Recommendations
- Ensure Linux pivots (VS Code, Azure Portal, CLI) are presented with equal prominence and ordering as Windows pivots.
- Include Linux command-line examples (e.g., Bash, Azure CLI on Linux) wherever Powershell or Windows CLI examples are provided.
- Add explicit mentions and links to Linux tools and workflows, such as Docker on Linux, Bash scripting, and VS Code extensions for Linux.
- Review and balance the documentation so that Linux users can follow a clear, platform-specific path without needing to adapt Windows-centric instructions.
- Consider grouping pivots by platform (Windows/Linux) rather than by tool, to make parity and equivalence more obvious.
App Service
Quickstart: Deploy Managed Instance on Azure App Service (Preview)
...in/articles/app-service/quickstart-managed-instance.md
High Priority
View Details →
Detected Bias Types
Powershell Heavy
Windows Tools
Missing Linux Example
Windows First
Summary
The documentation page demonstrates a strong Windows bias. The only configuration (install) script provided is a PowerShell script (`Install.ps1`) that installs fonts specifically to the Windows Fonts directory and modifies the Windows registry. The sample app is described as using fonts from `C:\Windows\Fonts`, and the runtime stack is set to ASP.NET V4.8, which is Windows-only. There are no Linux equivalents or examples for configuration scripts, font installation, or runtime stack. The documentation does not mention how to perform similar tasks on Linux-based App Service plans, nor does it provide Bash or shell script examples for configuration.
Recommendations
- Provide equivalent Linux configuration script examples (e.g., Bash scripts to install fonts to `/usr/share/fonts` and update font cache).
- Clarify whether Managed Instance supports Linux-based plans and, if so, include instructions for deploying to Linux.
- Offer examples using cross-platform runtime stacks (e.g., .NET Core, Node.js, Python) and show how to configure dependencies on both Windows and Linux.
- Explicitly mention platform limitations and guide users on choosing between Windows and Linux plans.
- Add documentation for Linux-specific management tasks and troubleshooting.
App Service
Tutorial - .NET Web app accesses Microsoft Graph as the app| Azure
...e/scenario-secure-app-access-microsoft-graph-as-app.md
High Priority
View Details →
Detected Bias Types
Windows First
Powershell Heavy
Missing Linux Example
Summary
The documentation provides installation instructions for the required NuGet packages using both the .NET Core CLI and the Visual Studio Package Manager Console (PowerShell). However, the Visual Studio/PowerShell example is given directly after the cross-platform .NET CLI, and there is no mention of Linux-specific workflows, such as using VS Code or Linux-native package management tools. The tutorial assumes familiarity with Visual Studio and Windows tooling, with no explicit Linux or cross-platform IDE guidance.
Recommendations
- Add explicit instructions for installing NuGet packages on Linux, such as using the .NET CLI in a Bash shell.
- Mention and provide examples for using VS Code or other cross-platform editors, not just Visual Studio.
- Clarify that the .NET CLI commands work on Linux, macOS, and Windows, and highlight any platform-specific considerations.
- Avoid presenting Windows/PowerShell tooling immediately after cross-platform commands; instead, group platform-specific instructions and ensure Linux parity.
- Include troubleshooting notes for common Linux developer environments (e.g., Ubuntu, Fedora) when working with .NET and Azure.
App Service
Quickstart: Deploy an ASP.NET web app
...lob/main/articles/app-service/quickstart-dotnetcore.md
High Priority
View Details →
Detected Bias Types
Windows First
Powershell Heavy
Windows Tools
Missing Linux Example
Summary
The documentation page demonstrates several types of Windows bias. Visual Studio (Windows-only) is presented first and most extensively, with detailed step-by-step instructions and screenshots. PowerShell is given a dedicated section, and its usage is recommended for Windows hosting, while Linux deployment is relegated to Azure CLI or other tools. Many examples and screenshots use Windows paths and tools (e.g., Compress-Archive, cd bin\Release\net10.0\publish), and there are no equivalent Linux shell or cross-platform examples for tasks like zipping and publishing. The .NET Framework 4.8 workflow is exclusively Windows, and the portal instructions default to Windows for GitHub Actions deployment. Linux is often mentioned as an alternative, but not given equal prominence or example depth.
Recommendations
- Provide Linux shell (bash) equivalents for all PowerShell commands, especially for tasks like zipping and publishing.
- Include screenshots and instructions for Linux environments (e.g., Ubuntu, WSL) alongside Windows examples.
- Present cross-platform tools (Azure CLI, VS Code) before or alongside Windows-only tools (Visual Studio, PowerShell) in each section.
- Clarify when steps are OS-specific, and offer parity in guidance for both Windows and Linux users.
- Ensure that Linux deployment options (including GitHub Actions for Linux) are described with the same detail and priority as Windows.
- Avoid recommending PowerShell as the default for app creation; instead, suggest Azure CLI or other cross-platform tools for both Windows and Linux.
- Add explicit instructions for Linux users to create and compress deployment archives, and publish them using CLI tools.
App Service
Create a scheduled WebJob with prebuilt samples
...s/blob/main/articles/app-service/quickstart-webjobs.md
High Priority
View Details →
Detected Bias Types
Windows First
Powershell Heavy
Windows Tools
Summary
The documentation page demonstrates a Windows bias by presenting Windows examples and tools first, including multiple Windows-specific scripting languages (CMD, Batch, PowerShell, F#) and referencing Windows containers and settings before Linux equivalents. The Windows tab includes more scripting options than the Linux tab, and Windows-specific tools and patterns (such as PowerShell and CMD) are highlighted, while Linux equivalents (such as shell scripts or other Linux-native scripting languages) are not provided with similar breadth.
Recommendations
- Present Linux and Windows options with equal prominence, possibly alternating which platform appears first or combining them in a unified table.
- Expand Linux sample offerings to include additional scripting languages commonly used on Linux (e.g., Perl, Ruby, or shell variants) to match the breadth of Windows scripting samples.
- Include Linux-native tools and patterns (such as cron, shell scripting best practices, or systemd timers) where Windows tools (PowerShell, CMD) are mentioned.
- Clarify any platform-specific limitations or differences, and ensure that instructions and settings are equally detailed for both Windows and Linux.
- Where possible, provide cross-platform examples or highlight scripts that work on both Windows and Linux.
App Service
Tutorial - .NET Web app accesses Microsoft Graph as the user | Azure
...https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/scenario-secure-app-access-microsoft-graph-as-user.md
High Priority
View Details →
Detected Bias Types
Windows First
Powershell Heavy
Missing Linux Example
Summary
The documentation page demonstrates a bias towards Windows by presenting installation instructions for NuGet packages using Visual Studio's Package Manager Console (PowerShell) and referencing Visual Studio tooling, without providing equivalent Linux instructions (e.g., for VS Code, JetBrains Rider, or generic shell usage). The .NET Core CLI example is present, but the Package Manager Console (PowerShell) instructions are given equal prominence, and there is no mention of Linux-specific workflows or alternative editors. No Linux-specific tools or patterns are discussed.
Recommendations
- Explicitly mention that the .NET Core CLI commands work cross-platform (Windows, Linux, macOS) and are recommended for Linux users.
- Add instructions for installing NuGet packages using VS Code or JetBrains Rider, or generic shell usage on Linux.
- Clarify that the Package Manager Console is a Windows/Visual Studio feature and suggest alternatives for Linux users.
- Include a note or section on running and debugging .NET web apps on Linux, including any differences in environment setup.
- Ensure that all code and configuration examples are platform-agnostic, and avoid assuming Visual Studio or Windows as the default development environment.
App Service
Tutorial - .NET Web app accesses storage by using managed identities | Azure
...cles/app-service/scenario-secure-app-access-storage.md
High Priority
View Details →
Detected Bias Types
Windows First
Powershell Heavy
Missing Linux Example
Summary
The documentation page demonstrates Windows bias by providing installation instructions for both the .NET Core CLI and the Visual Studio Package Manager Console (PowerShell), but omits explicit Linux or cross-platform instructions. The Package Manager Console is a Windows/Visual Studio-specific tool, and its instructions are given equal prominence to the cross-platform .NET CLI. There are no Linux-specific examples or mentions of Linux development environments, and the documentation does not clarify which steps are cross-platform versus Windows-only.
Recommendations
- Clearly indicate which instructions are cross-platform (e.g., .NET CLI) and which are Windows-specific (e.g., Visual Studio Package Manager Console).
- Add explicit instructions or notes for Linux and macOS users, such as using the .NET CLI in Bash or other shells.
- Consider reordering the installation instructions to present the cross-platform .NET CLI first, and label Windows-specific instructions as such.
- Include a brief section or note on developing and running the sample on Linux (e.g., using VS Code, terminal, etc.).
- Avoid assuming Visual Studio usage; mention alternative editors and environments for non-Windows platforms.
App Service
Fix HTTP 502 and HTTP 503 Errors
...articles/app-service/troubleshoot-http-502-http-503.md
High Priority
View Details →
Detected Bias Types
Powershell Heavy
Windows Tools
Missing Linux Example
Windows First
Summary
The documentation page demonstrates a Windows bias by primarily referencing Windows-centric tools and workflows. PowerShell is mentioned as the command-line management option, with no mention of Bash, CLI, or Linux-native alternatives. The Kudu debug console is described as supporting PowerShell cmdlets and DOS commands, but there is no reference to Linux shells or commands. Troubleshooting tools like ProcDump (a Sysinternals tool) are highlighted, which are traditionally Windows utilities. There are no explicit Linux or cross-platform command examples, and Windows tools/patterns are mentioned before any Linux equivalents (which are absent).
Recommendations
- Include examples using Azure CLI and Bash for managing and troubleshooting apps, alongside PowerShell.
- Clarify that the Kudu console supports both PowerShell and Bash, and provide examples for both environments.
- Mention Linux-native troubleshooting tools (such as gcore, strace, or lsof) where applicable, especially for memory dumps and diagnostics.
- Add explicit Linux and cross-platform instructions for common tasks like restarting the app, collecting logs, and scaling.
- Ensure that references to Windows tools are balanced with Linux alternatives, and avoid presenting Windows-first workflows unless justified by platform limitations.
App Service
Tutorial: Connect a web app to SQL Database on behalf of the user
...utorial-connect-app-access-sql-database-as-user-dotnet.md
High Priority
View Details →
Detected Bias Types
Windows Tools
Windows First
Missing Linux Example
Summary
The documentation page demonstrates a moderate Windows bias. While the main workflow uses Azure CLI (which is cross-platform), several examples and tool references are Windows-centric. SQL Server Management Studio (SSMS) is mentioned as a primary tool for database user management, with no mention of Linux-native alternatives. Visual Studio and Visual Studio Code are referenced for publishing and debugging, but Linux equivalents (such as JetBrains Rider, VS Code on Linux, or CLI-based deployment) are not discussed. The local debugging section references 'Active Directory Interactive' authentication, which is typically Windows-centric, and remote debugging is described only for Visual Studio. There are no explicit Linux-specific examples or guidance for users on Linux systems.
Recommendations
- Include Linux-native tools for database management, such as Azure Data Studio, sqlcmd on Linux, or other cross-platform SQL clients.
- Provide examples for publishing and debugging using Linux environments, such as using VS Code on Linux, JetBrains Rider, or CLI-based deployment workflows.
- Mention how to perform local debugging and authentication on Linux, including any necessary configuration for Azure CLI, .NET, and authentication flows.
- When referencing tools like SSMS or Visual Studio, also mention cross-platform alternatives and provide links or instructions for their use.
- Ensure that all command-line examples are verified to work on Linux, and note any platform-specific differences or prerequisites.
App Service
Troubleshoot Performance Degradation
...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 frequently referencing Windows-specific tools (such as PowerShell, IIS diagnostics, and SysInternals Procdump), providing examples and links that are Windows-centric (e.g., .NET Profiler for Windows, Windows Azure Websites tools), and mentioning Windows approaches before or instead of Linux equivalents. There is a lack of Linux-specific troubleshooting guidance, and no examples are given for Linux-based App Service environments or their diagnostic tools.
Recommendations
- Include Linux-specific troubleshooting steps and examples, such as using SSH, Bash, or Linux-native diagnostic tools (e.g., strace, lsof, top).
- Provide parity in documentation for enabling diagnostics and collecting logs on Linux App Service environments, referencing relevant logging mechanisms (e.g., syslog, journald).
- Mention and link to Linux equivalents for tools like Procdump (e.g., gcore, gdb) and clarify which features are available on Linux vs. Windows App Service plans.
- Add explicit instructions for accessing the Kudu console on Linux (where only Bash is available, not PowerShell), and clarify differences in available commands.
- Ensure Application Insights and Profiler documentation links include Linux support status and guidance.
- Balance references to PowerShell with Azure CLI examples, which are cross-platform.
App Service
Tutorial: Access Azure databases with managed identity
...les/app-service/tutorial-connect-msi-azure-database.md
High Priority
View Details →
Detected Bias Types
Windows First
Powershell Heavy
Windows Tools
Summary
The documentation demonstrates a moderate Windows bias, particularly in the 'Set up your dev environment' section, where Windows/Visual Studio is presented first and in more detail than Linux/macOS alternatives. Windows-specific tools (Visual Studio for Windows, Azure PowerShell) are highlighted, and PowerShell is included as a primary example for authentication. Linux/macOS alternatives (Visual Studio for Mac, Azure CLI) are mentioned, but often with caveats or less integration. There are no explicit Linux command-line examples (e.g., Bash), and the documentation does not mention Linux-specific development environments or editors (such as JetBrains Rider or Vim).
Recommendations
- Reorder dev environment setup instructions to present cross-platform or Linux/macOS options first or equally with Windows.
- Include explicit examples and instructions for Linux users, such as using Bash, common Linux editors (e.g., Vim, Emacs), and Linux-native development workflows.
- Add parity for PowerShell examples by providing equivalent Bash or shell commands where appropriate.
- Highlight that Azure CLI and Visual Studio Code are cross-platform and provide instructions for their use on Linux.
- Mention and provide guidance for other popular Linux development environments (e.g., JetBrains Rider, Eclipse) where relevant.
- Avoid language that implies Windows is the default or preferred platform for development.