Automation
123
Total Pages
24
Linux-Friendly Pages
99
Pages with Bias
80.5%
Bias Rate
Bias Trend Over Time
Pages with Bias Issues
982 issues found
Showing 426-450 of 982 flagged pages
Automation
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/automation/manage-runtime-environment.md
...main/articles/automation/manage-runtime-environment.md
High Priority
View Details →
Detected Bias Types
Powershell Heavy
Windows Tools
Windows First
Missing Linux Example
Summary
The documentation demonstrates a strong bias towards Windows and PowerShell environments. Most examples, screenshots, and instructions focus on PowerShell runbooks and modules, with detailed steps for PowerShell and only minimal, secondary mentions of Python (Linux) environments. Windows-specific tools (e.g., PowerShell Gallery, Az PowerShell module) are referenced throughout, and there is a lack of Linux-native or cross-platform examples, especially for Python runbooks. The documentation structure and examples consistently present PowerShell/Windows options first or exclusively, with Linux/Python support mentioned as an afterthought.
Recommendations
- Provide equal, parallel examples for both PowerShell (Windows) and Python (Linux) runbooks, including REST API payloads and portal workflows.
- Include screenshots and instructions for creating and managing Python runbooks and environments, not just PowerShell.
- Reference Linux-native tools and package formats (e.g., pip, .whl, PyPI) alongside PowerShell Gallery and .nupkg.
- Clarify when instructions or features are Windows/PowerShell-specific versus cross-platform.
- Add explicit examples and guidance for managing Python packages (including troubleshooting and best practices) in the same detail as for PowerShell modules.
- Reorganize sections to avoid always listing PowerShell/Windows options first; consider side-by-side or tabbed presentation for PowerShell and Python/Linux.
Create Pull Request
Automation
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/automation/troubleshoot/extension-based-hybrid-runbook-worker.md
.../troubleshoot/extension-based-hybrid-runbook-worker.md
High Priority
View Details →
Detected Bias Types
Windows First
Powershell Heavy
Windows Tools
Summary
The documentation generally provides parity between Windows and Linux for most troubleshooting steps, with separate sections and commands for each OS. However, there is a noticeable Windows bias: Windows examples and tools (such as PowerShell scripts, registry edits, and event logs) are often mentioned first or in more detail, and some troubleshooting scenarios (e.g., registry or event log checks) are Windows-specific or lack Linux equivalents. The documentation also references Windows-specific tools and patterns (e.g., PowerShell scripts, registry keys, Microsoft-SMA event logs) more frequently and in greater depth than their Linux counterparts.
Recommendations
- Ensure that for every Windows-specific troubleshooting step (e.g., checking registry keys, using PowerShell scripts, reviewing event logs), there is a clear Linux equivalent or an explicit statement if no equivalent exists.
- Alternate the order of Windows and Linux instructions to avoid always listing Windows first.
- Expand Linux troubleshooting sections to match the detail provided for Windows, including log locations, service management, and common issues.
- Where Windows event logs are referenced, provide guidance on equivalent Linux log files (e.g., syslog, journalctl) or clarify if no direct equivalent exists.
- For steps involving PowerShell, provide bash or Python script equivalents for Linux where possible.
- Review all scenarios to ensure Linux is not treated as an afterthought and that Linux administrators have actionable, detailed guidance.
Automation
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/automation/delete-account.md
...e-docs/blob/main/articles/automation/delete-account.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 command-line examples exclusively in Azure PowerShell, with no equivalent Azure CLI (cross-platform) or Bash examples. The PowerShell examples are presented as the only scripting/automation option, and the documentation references Windows-centric tools and patterns (such as PowerShell cmdlets) without mentioning or prioritizing Linux-friendly alternatives. The structure and ordering of examples also place PowerShell before any mention of CLI, and in some sections, CLI is omitted entirely.
Recommendations
- Add equivalent Azure CLI (az) command examples alongside all PowerShell examples to ensure Linux and macOS users have clear guidance.
- Where scripting is demonstrated, provide both PowerShell and Bash (or at least CLI) scripts.
- In tabbed example sections, present Azure CLI before or alongside PowerShell to avoid implicit prioritization of Windows tools.
- Explicitly mention that all operations can be performed from any OS using Azure CLI, and provide links to CLI documentation.
- Audit for any terminology or references that assume a Windows environment and update to be OS-neutral where possible.
Automation
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/automation/overview.md
...s/azure-docs/blob/main/articles/automation/overview.md
High Priority
View Details →
Detected Bias Types
Powershell Heavy
Windows First
Windows Tools
Missing Linux Example
Summary
The documentation page demonstrates a bias towards Windows and PowerShell-centric automation. PowerShell and DSC (Desired State Configuration) are repeatedly emphasized as the primary or default automation and configuration technologies, with Linux support mentioned only in general terms or as an afterthought. Examples, modules, and galleries focus on PowerShell, and there is a lack of concrete Linux-specific examples or equivalent tooling references. Windows tools and scenarios (e.g., Active Directory, SQL Server, SharePoint) are explicitly named, while Linux-specific tools, patterns, or use cases are not highlighted.
Recommendations
- Provide Linux-specific examples and scenarios alongside Windows ones, such as managing Linux services, using Bash or Python runbooks for Linux tasks, and integrating with Linux-native tools (e.g., systemd, cron, logrotate).
- Mention Linux configuration management tools or equivalents (e.g., Ansible, Chef, native Linux DSC support) where PowerShell DSC is discussed.
- Ensure that references to modules, galleries, and shared resources include Python and Bash examples, and highlight any Linux-specific modules or packages available.
- Balance scenario descriptions by including Linux workloads and open-source technologies (e.g., Apache, NGINX, MySQL, PostgreSQL) in addition to Windows-centric ones.
- Where Windows tools or patterns are mentioned (e.g., PowerShell Gallery, Active Directory), provide Linux equivalents or alternatives.
- Explicitly state the parity or differences in feature support between Windows and Linux for Azure Automation, and link to Linux-specific guidance where available.
Automation
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/automation/automation-hrw-run-runbooks.md
...ain/articles/automation/automation-hrw-run-runbooks.md
High Priority
View Details →
Detected Bias Types
Windows First
Powershell Heavy
Windows Tools
Missing Linux Example
Summary
The documentation page demonstrates a moderate Windows bias. Windows instructions, tools, and examples are often presented before their Linux equivalents, and PowerShell is the primary scripting language shown in code samples. Several sections (such as credential management and runbook authentication) provide detailed PowerShell/Windows-centric examples, while Linux examples are less detailed or missing. Windows-specific tools and paths (e.g., Control Panel, cert store locations) are referenced more frequently and with more depth than their Linux counterparts.
Recommendations
- Present Windows and Linux instructions in parallel or with equal prominence, rather than listing Windows first in each section.
- Provide Linux-specific code samples (e.g., Bash, Python) wherever PowerShell examples are given, especially for runbook authentication and management.
- Include Linux-native tools and workflows (e.g., use of environment variables, certificate/key management) with the same level of detail as Windows tools.
- Where possible, use cross-platform language and avoid Windows-specific terminology unless necessary.
- Expand Linux sections to match the granularity and clarity of Windows instructions, particularly for credential management, runbook signing, and troubleshooting.
- Add explicit Linux examples for starting runbooks via CLI (e.g., Azure CLI or Bash scripts), not just PowerShell.
- Ensure that troubleshooting and logging sections provide Linux log paths and diagnostic methods with the same detail as Windows.
Automation
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/automation/automation-runbook-types.md
...b/main/articles/automation/automation-runbook-types.md
High Priority
View Details →
Detected Bias Types
Windows First
Powershell Heavy
Windows Tools
Missing Linux Example
Summary
The documentation page demonstrates a Windows bias by prioritizing and extensively detailing PowerShell (a Windows-centric technology) and Windows-specific patterns. Windows tools, file paths (e.g., C:\modules), and environment variables are referenced throughout, with examples and troubleshooting steps almost exclusively using Windows conventions. Linux support is mentioned, but Linux-specific examples, troubleshooting, or parity guidance are largely absent. The Python section briefly mentions Linux, but most operational details and examples are Windows-focused.
Recommendations
- Provide Linux-specific examples and troubleshooting steps, especially for Hybrid Runbook Workers and file path references.
- When discussing file paths, include both Windows (C:\...) and Linux (/usr/...) equivalents.
- Expand on Linux support for PowerShell runbooks, including any differences in module management, environment variables, and known issues.
- In sections about environment variables and Python versions, clarify the behavior and configuration for Linux Hybrid Workers, not just Windows.
- Ensure parity in examples: for every PowerShell/Windows example, provide an equivalent for Linux/Python where applicable.
- Highlight any limitations or best practices unique to Linux environments, not just those for Windows.
- Reorder or balance the presentation so that Linux and Windows are treated equally, rather than Windows/PowerShell being the default or primary focus.
Automation
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/automation/manage-runtime-environment.md
...main/articles/automation/manage-runtime-environment.md
High Priority
View Details →
Detected Bias Types
Powershell Heavy
Windows Tools
Windows First
Missing Linux Example
Summary
The documentation demonstrates a clear bias towards Windows and PowerShell environments. Most examples, screenshots, and REST API payloads focus on PowerShell runbooks and the Az PowerShell module. Windows/PowerShell-specific tools and patterns (e.g., PowerShell Gallery, .zip modules, Get-Module cmdlet) are mentioned and illustrated, while Linux/Python equivalents are only briefly referenced or relegated to notes. There are no concrete Linux or Python-focused examples, and the documentation assumes familiarity with Windows-centric tooling.
Recommendations
- Provide parallel, concrete examples for Python runbooks, including REST API payloads and portal workflows.
- Include Linux/Python-specific instructions and screenshots where relevant (e.g., uploading .whl files, using pip or other Linux-native tools).
- Mention Python/Linux options before or alongside PowerShell/Windows options, rather than as afterthoughts or notes.
- Demonstrate how to view installed Python packages in a runbook, similar to the PowerShell Get-Module example.
- Clarify when steps or tools are Windows/PowerShell-specific and provide Linux/Python alternatives.
- Balance the documentation structure so that both PowerShell and Python/Linux users can easily find relevant guidance.
Automation
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/automation/python-3-packages.md
...ocs/blob/main/articles/automation/python-3-packages.md
High Priority
View Details →
Detected Bias Types
Windows First
Missing Linux Example
Powershell Heavy
Windows Tools
Summary
The documentation exhibits several forms of Windows bias. In the section on generating wheel files, the Windows (Python 3.8) workflow is presented after the Linux (Python 3.10) workflow, but both are covered. However, in the PowerShell cmdlets section, only Windows PowerShell/Az PowerShell examples are provided for managing Python packages, with no equivalent CLI or bash/Linux-native commands. The documentation also references Windows-specific architectures (win_amd64) and tools (PowerShell), and does not provide parity for Linux users in terms of automation tooling or command-line management. There are no examples using Azure CLI, Bash, or Linux-native scripting for package management, and the PowerShell section is extensive and detailed, reinforcing a Windows-centric approach.
Recommendations
- Provide Azure CLI and/or Bash examples for managing Python packages in Azure Automation, alongside or before PowerShell examples.
- Include Linux-native command-line workflows for package management tasks (add, list, remove, update), not just Windows/PowerShell.
- Ensure that all automation and scripting examples are available for both Windows and Linux users, or clearly indicate platform-specific limitations.
- Where possible, use cross-platform tools and commands, or provide equivalent instructions for both operating systems.
- Explicitly mention when a feature or tool is Windows-only, and suggest alternatives for Linux users.
Automation
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/automation/troubleshoot/extension-based-hybrid-runbook-worker.md
.../troubleshoot/extension-based-hybrid-runbook-worker.md
High Priority
View Details →
Detected Bias Types
Windows First
Windows Tools
Powershell Heavy
Windows Heavy Scenarios
Summary
The documentation generally provides parity between Windows and Linux for most troubleshooting steps, but there is a noticeable Windows-first bias. In several sections, Windows examples, tools, and troubleshooting steps are listed before their Linux equivalents. Some scenarios are described only for Windows (e.g., registry and event log troubleshooting, PowerShell scripts, UAC issues), and Windows-specific tools (like PowerShell scripts and registry edits) are prominent. Linux steps are present but sometimes less detailed or appear after Windows steps. There are also more scenario-specific troubleshooting sections for Windows than for Linux.
Recommendations
- Alternate the order of Windows and Linux instructions throughout the document to avoid always listing Windows first.
- Where possible, provide Linux equivalents for all troubleshooting steps, especially for scenarios currently described only for Windows (e.g., registry, event logs, UAC).
- Ensure Linux troubleshooting steps are as detailed and explicit as Windows steps, including command-line examples and log file locations.
- Include Linux-specific troubleshooting scenarios (e.g., SELinux/AppArmor issues, systemd service failures, permission issues) to match the depth of Windows coverage.
- Where PowerShell scripts are provided for Windows, consider providing Bash or Python scripts for Linux where appropriate.
- Review the language and structure to ensure Linux is treated as a first-class platform, not as an afterthought.
Automation
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/automation/overview.md
...s/azure-docs/blob/main/articles/automation/overview.md
High Priority
View Details →
Detected Bias Types
Powershell Heavy
Windows First
Windows Tools
Missing Linux Example
Summary
The documentation page demonstrates a Windows bias by emphasizing PowerShell and Windows-centric tools and terminology. PowerShell is repeatedly mentioned as the primary automation language, with features like Desired State Configuration (DSC) described specifically in the context of PowerShell. The documentation references Windows tools and services (e.g., Active Directory, SharePoint Server) in common scenarios, and the PowerShell Gallery is highlighted for module management. Linux support is mentioned, but Linux-specific examples, tools, or workflows are largely absent, and Windows terminology is often presented first or exclusively.
Recommendations
- Provide balanced examples for both Windows (PowerShell) and Linux (Python, Bash) runbooks, including sample scripts for each.
- Highlight Linux-native tools and scenarios (e.g., systemd, cron, Linux package management) alongside Windows tools in common scenarios.
- Expand on configuration management by including Linux configuration frameworks (e.g., Ansible, Chef, native Linux DSC) and clarify how Azure Automation integrates with them.
- Reference Linux module/package repositories (e.g., PyPI for Python, native Linux package managers) in addition to the PowerShell Gallery.
- Ensure that when listing supported platforms or features, Linux is mentioned with equal prominence and detail as Windows.
- Include Linux-specific use cases in the 'Common scenarios' section, such as automating updates, managing Linux services, or integrating with Linux-based monitoring tools.
Automation
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/automation/automation-runbook-types.md
...b/main/articles/automation/automation-runbook-types.md
High Priority
View Details →
Detected Bias Types
Windows First
Powershell Heavy
Windows Tools
Missing Linux Example
Summary
The documentation exhibits a strong Windows and PowerShell bias. PowerShell (including Windows PowerShell and PowerShell Workflow) is presented first and in greatest detail, with numerous examples and troubleshooting steps focused on Windows-specific paths, tools, and cmdlets. Many examples reference Windows file paths (e.g., C:\modules), environment variables, and PowerShell-specific modules. Linux is only mentioned in passing, often as a limitation (e.g., certain runbooks can't run on Linux Hybrid Runbook Workers), and there are no Linux-specific examples or guidance. Python runbooks receive less detailed coverage, and Linux-specific considerations are minimal or absent.
Recommendations
- Provide Linux-specific examples for PowerShell and Python runbooks, including file paths, environment variables, and troubleshooting steps relevant to Linux Hybrid Runbook Workers.
- Balance the order of presentation by not always listing Windows/PowerShell options first; consider grouping by cross-platform compatibility or providing parallel sections for Windows and Linux.
- Include explicit notes and examples for running runbooks on Linux Hybrid Runbook Workers, including any differences in behavior, limitations, or best practices.
- Where Windows tools, paths, or patterns are mentioned (e.g., C:\modules, .ps1 scripts), provide Linux equivalents (e.g., /opt/automation/modules, ./child-runbook.ps1) where applicable.
- Expand the Python runbook section to include more parity with PowerShell, such as troubleshooting, best practices, and Linux-specific guidance.
- Add a summary table or matrix indicating which runbook types and features are supported on Windows vs. Linux Hybrid Runbook Workers.
Automation
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/automation/delete-account.md
...e-docs/blob/main/articles/automation/delete-account.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 command-line examples exclusively in Azure PowerShell, with no equivalent Azure CLI (cross-platform) or Bash examples. The PowerShell examples are presented as the only scripting/automation option, and the documentation does not mention or demonstrate Linux-native tools or workflows. The structure and tab order also place PowerShell before any mention of CLI, and in some sections, CLI is omitted entirely.
Recommendations
- Add Azure CLI examples (az commands) alongside PowerShell for all automation and deletion tasks, as Azure CLI is cross-platform and widely used on Linux and macOS.
- Include Bash script snippets where appropriate, especially for tasks that can be automated outside of PowerShell.
- Ensure that CLI and PowerShell examples are presented in parallel tabs, with neither given priority in ordering.
- Explicitly mention that all operations can be performed from Linux, macOS, or Windows, and provide guidance for non-Windows users.
- Review all sections for references to Windows-specific tools or patterns and add Linux-equivalent instructions where needed.
Automation
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/automation/manage-runtime-environment.md
...main/articles/automation/manage-runtime-environment.md
High Priority
View Details →
Detected Bias Types
Powershell Heavy
Windows Tools
Windows First
Missing Linux Example
Summary
The documentation demonstrates a strong bias toward Windows and PowerShell environments. PowerShell is consistently presented as the primary or default scripting language, with detailed examples and screenshots. Windows-specific tools and packaging formats (e.g., PowerShell Gallery, .zip for modules, Az PowerShell module) are emphasized, while Linux or cross-platform equivalents receive minimal or secondary mention. Python (the main cross-platform alternative) is mentioned, but examples and guidance are sparse, and Linux-specific details are limited to a brief note about .whl files for Python packages. There are no concrete Linux shell (bash) examples, nor is there parity in tool recommendations or workflows for Linux users.
Recommendations
- Provide equal coverage and examples for both PowerShell and Python runbooks, including REST API payloads for Python.
- Include Linux/bash shell examples for managing runtime environments and runbooks, not just PowerShell.
- Mention and demonstrate the use of cross-platform tools (e.g., Azure CLI) alongside or before Windows-specific tools like PowerShell Gallery.
- Clarify when instructions or file formats are Windows-specific (e.g., .zip for PowerShell modules) and provide Linux equivalents or alternatives.
- Add screenshots and walkthroughs for Python runbooks and Linux package management, ensuring visual parity.
- Explicitly state support for Linux-based automation scenarios and provide troubleshooting tips relevant to Linux environments.
Automation
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/automation/python-3-packages.md
...ocs/blob/main/articles/automation/python-3-packages.md
High Priority
View Details →
Detected Bias Types
Windows First
Windows Tools
Powershell Heavy
Missing Linux Example
Summary
The documentation exhibits a Windows bias in several areas: Windows is mentioned first or exclusively in some sections, especially for Python 3.8; PowerShell cmdlets are provided for package management without Linux CLI or Bash equivalents; and Windows-specific instructions and terminology are used more prominently than Linux ones. Linux examples are present for Python 3.10, but Linux parity is lacking for Python 3.8 and for command-line tooling.
Recommendations
- Provide equivalent Linux/Bash/Azure CLI examples for all PowerShell cmdlets shown, especially for Python 3.8 package management.
- When describing how to generate wheel files, present Linux and Windows instructions side by side for both Python 3.8 and 3.10, rather than only Linux for 3.10 and only Windows for 3.8.
- Avoid presenting Windows-specific instructions or tools (e.g., PowerShell) before or instead of cross-platform alternatives.
- Clarify which steps are platform-specific and offer guidance for both Windows and Linux users throughout.
- Where possible, use platform-neutral language and tooling, or clearly indicate when a step is only possible on one OS.
Automation
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/automation/troubleshoot/extension-based-hybrid-runbook-worker.md
.../troubleshoot/extension-based-hybrid-runbook-worker.md
High Priority
View Details →
Detected Bias Types
Windows First
Windows Tools
Powershell Heavy
Windows Registry Focus
Summary
The documentation generally provides both Windows and Linux troubleshooting steps for Hybrid Runbook Worker issues, but there is a noticeable Windows bias. Windows examples, tools, and troubleshooting steps are often presented first, with more detailed PowerShell and registry instructions. Windows-specific tools (e.g., PowerShell scripts, registry edits, event logs) are described in detail, while Linux equivalents are sometimes less emphasized or described with less context. Some troubleshooting scenarios and resolutions are Windows-only or provide more granular steps for Windows than for Linux.
Recommendations
- Alternate the order of Windows and Linux instructions throughout the document, or group them together to avoid always presenting Windows first.
- Ensure Linux troubleshooting steps are as detailed as Windows steps, including explicit command examples, log file locations, and explanations.
- Where Windows registry or event log steps are given, provide equivalent Linux configuration or log file checks, or explicitly state if there is no equivalent.
- Include Linux-specific troubleshooting scenarios where applicable, not just Windows-specific ones.
- Balance the use of PowerShell examples with Bash or Python script examples for Linux, and provide context for both.
- Where possible, use cross-platform tools or commands, or clarify platform-specific differences in a neutral way.
Automation
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/automation/automation-hrw-run-runbooks.md
...ain/articles/automation/automation-hrw-run-runbooks.md
High Priority
View Details →
Detected Bias Types
Windows First
Powershell Heavy
Windows Tools
Missing Linux Example
Summary
The documentation demonstrates a Windows-first and PowerShell-centric bias. Windows instructions, tools, and examples are consistently presented before Linux equivalents. PowerShell and Windows-specific tools (e.g., Control Panel, cert store paths, Windows event logs) are emphasized, and most code samples are PowerShell-based. Linux instructions are present but often less detailed, and there are few, if any, Linux shell or Python script examples for runbook operations or authentication. Some features (like Hybrid Worker credentials) are not supported on Linux, but this is not always clearly highlighted up front.
Recommendations
- Alternate the order of Windows and Linux sections/examples to avoid always presenting Windows first.
- Provide equivalent Linux shell (bash) and Python examples for all PowerShell/Windows examples, especially for runbook authentication, starting runbooks, and certificate/key management.
- Include Linux-specific troubleshooting and logging details at parity with Windows (e.g., mention Linux event logs or syslog integration if available).
- Where features are Windows-only (e.g., Hybrid Worker credentials), clearly state this at the start of the relevant section and suggest Linux alternatives if possible.
- Add more Linux-focused guidance for common tasks, such as using managed identities, environment variable management, and runbook signing.
- Where PowerShell is used as the only example, provide Python or bash alternatives, especially for Linux users.
- Ensure that links and references are balanced between Windows and Linux documentation.
Automation
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/automation/disable-local-authentication.md
...in/articles/automation/disable-local-authentication.md
High Priority
View Details →
Detected Bias Types
Powershell Heavy
Windows First
Missing Linux Example
Windows Tools
Summary
The documentation page demonstrates a strong Windows bias by exclusively providing PowerShell-based instructions and examples for disabling local authentication in Azure Automation. All command-line guidance is given using PowerShell cmdlets or Azure PowerShell modules, with no mention of Bash, Azure CLI, or Linux-native tooling. The documentation assumes the use of Windows tools and patterns, and does not provide equivalent steps or examples for Linux or cross-platform environments.
Recommendations
- Provide equivalent Azure CLI (az) commands for checking and updating the DisableLocalAuth property, as Azure CLI is cross-platform and widely used on Linux.
- Include REST API examples using curl or HTTPie to demonstrate how to update the flag from Linux or non-Windows environments.
- Explicitly mention that the steps can be performed from any platform using REST API calls, and provide sample scripts for Bash.
- Balance the documentation by presenting both PowerShell and non-PowerShell (e.g., Bash, CLI) examples side by side.
- Clarify any platform dependencies or limitations, and guide users on how to perform the same operations from Linux/macOS.
Automation
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/automation/automation-runbook-types.md
...b/main/articles/automation/automation-runbook-types.md
High Priority
View Details →
Detected Bias Types
Windows First
Powershell Heavy
Windows Tools
Missing Linux Example
Summary
The documentation page exhibits a strong Windows and PowerShell bias. PowerShell (including Windows PowerShell and PowerShell Workflow) is presented first and in the most detail, with extensive examples and troubleshooting focused on Windows-specific paths, cmdlets, and behaviors. Many code samples and known issues reference Windows file paths (e.g., C:\modules), Windows environment variables, and Windows-centric tools. Linux support is mentioned only in passing, often as a limitation (e.g., certain runbooks cannot run on Linux Hybrid Runbook Workers), and there are no Linux-specific examples or troubleshooting guidance. Python runbooks receive less coverage, and Linux-specific considerations are minimal or absent.
Recommendations
- Provide Linux-specific examples for PowerShell and Python runbooks, including file paths, environment variables, and troubleshooting steps relevant to Linux Hybrid Runbook Workers.
- Balance the order of presentation so that Python and Linux support are not always secondary to Windows/PowerShell.
- Explicitly document any differences or additional steps required for Linux Hybrid Runbook Workers, including module management, file system access, and environment setup.
- Include sample scripts and known issues that are relevant to Linux environments, not just Windows.
- Where limitations exist for Linux, provide workarounds or alternative approaches where possible.
- Ensure that references to tools, paths, and environment variables are cross-platform or clearly indicate when they are Windows-specific.
Automation
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/automation/overview.md
...s/azure-docs/blob/main/articles/automation/overview.md
High Priority
View Details →
Detected Bias Types
Powershell Heavy
Windows First
Windows Tools
Missing Linux Example
Summary
The documentation page demonstrates a Windows bias by emphasizing PowerShell and Windows-centric tools and patterns throughout. PowerShell and DSC (Desired State Configuration, a Windows technology) are mentioned repeatedly, often without equivalent Linux examples or references to Linux-native automation tools. The 'Modules gallery' and integration examples focus on PowerShell, and the configuration management section centers on PowerShell DSC. Although Linux is mentioned as supported, there are no concrete Linux-specific examples, tools, or workflows provided. Windows technologies (e.g., Active Directory, SQL Server, SharePoint) are listed in scenarios, while Linux equivalents are absent.
Recommendations
- Add Linux-specific examples for runbooks, such as using Bash or Python scripts to automate Linux tasks.
- Mention and provide guidance for Linux-native configuration management tools (e.g., Ansible, Chef, Puppet) where appropriate, or clarify integration options.
- Balance scenario examples by including Linux workloads and services (e.g., Apache, NGINX, MySQL, systemd services) alongside Windows-centric ones.
- Expand on how Python runbooks can be used for Linux automation, with sample use cases.
- In the 'Modules gallery' and shared resources sections, highlight modules/packages relevant to Linux management.
- Ensure that references to configuration management do not exclusively focus on PowerShell DSC; discuss cross-platform or Linux-native alternatives where possible.
- Where Windows tools or technologies are mentioned, provide Linux equivalents or parallel guidance.
Automation
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/automation/delete-account.md
...e-docs/blob/main/articles/automation/delete-account.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 Azure PowerShell command-line examples, with no equivalent Azure CLI (cross-platform) or Bash examples. The PowerShell examples and references are presented as the only scripting/automation option, and there is no mention of Linux-native tools or workflows. The structure also presents PowerShell before any mention of CLI or REST API, and the only detailed automation example is for PowerShell.
Recommendations
- Add Azure CLI (az) command examples alongside PowerShell for all automation and deletion tasks, as Azure CLI is cross-platform and widely used on Linux and macOS.
- Include Bash script snippets or instructions where relevant, especially for unlinking and deleting resources.
- Explicitly mention that PowerShell is available on Linux and macOS, but also provide CLI alternatives for users who prefer native Linux tools.
- Reorder sections so that Azure CLI examples are presented alongside or before PowerShell, or use tabs to allow users to select their preferred platform.
- Where REST API is mentioned, provide curl or HTTP request examples that can be run from any OS.
- Review all screenshots and UI instructions to ensure they are not Windows-specific, or clarify when steps are platform-agnostic.
Automation
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/automation/manage-runtime-environment.md
...main/articles/automation/manage-runtime-environment.md
High Priority
View Details →
Detected Bias Types
Powershell Heavy
Windows Tools
Windows First
Missing Linux Example
Summary
The documentation demonstrates a strong bias toward Windows and PowerShell. Most examples, screenshots, and REST API payloads focus on PowerShell runbooks and the Az PowerShell module. There is extensive mention of Windows/PowerShell-specific tools and patterns (e.g., PowerShell Gallery, .zip modules, Get-Module cmdlet), while Linux/Python equivalents are only briefly mentioned or omitted. Linux-specific details (e.g., .whl files for Python) are present but minimal, and there are no practical Linux/Python runbook examples or screenshots. The documentation consistently presents PowerShell/Windows options first and in more detail.
Recommendations
- Provide parallel, detailed examples for Python runbooks, including REST API payloads and portal screenshots.
- Include Linux/Python-specific instructions and troubleshooting steps, not just brief notes.
- When referencing package formats (e.g., .zip for PowerShell), also explain and show .whl or other Linux-native formats for Python.
- Demonstrate how to view installed Python packages in a runbook, similar to the PowerShell 'Get-Module' example.
- Balance the order of presentation so that Python/Linux options are given equal prominence to PowerShell/Windows.
- Reference both PowerShell Gallery and PyPI (Python Package Index) for package sources.
- Clarify when a feature or limitation applies only to PowerShell/Windows or Python/Linux.
Automation
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/automation/troubleshoot/extension-based-hybrid-runbook-worker.md
.../troubleshoot/extension-based-hybrid-runbook-worker.md
High Priority
View Details →
Detected Bias Types
Windows First
Powershell Heavy
Windows Tools
Missing Linux Example
Summary
The documentation provides both Windows and Linux troubleshooting steps for Hybrid Runbook Workers, but there is a noticeable Windows bias. Windows examples, tools, and registry paths are often presented first or in greater detail. Several scenarios (e.g., registry edits, event log checks, PowerShell scripts) are Windows-specific, with Linux equivalents either less detailed or missing. PowerShell and Windows event log troubleshooting are emphasized, while Linux log and troubleshooting methods are less thoroughly covered.
Recommendations
- Alternate the order of Windows and Linux instructions so that Linux is presented first in some sections.
- Ensure Linux troubleshooting steps are as detailed as Windows, including equivalent commands for log collection, service status, and error investigation.
- Provide Linux equivalents for all Windows-specific tools and scripts (e.g., PowerShell scripts, registry edits, event log checks).
- Where Windows registry or event log locations are mentioned, include corresponding Linux configuration or log file locations, or explicitly state if not applicable.
- For each scenario that is Windows-only, clarify if there is no Linux equivalent or provide a comparable Linux troubleshooting path.
- Balance the use of PowerShell examples with Bash or Python examples for Linux.
- Review the language to avoid implying Windows is the default or primary platform.
Automation
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/automation/delete-account.md
...e-docs/blob/main/articles/automation/delete-account.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 Azure PowerShell command-line examples for automation account management, with no equivalent examples for Azure CLI (which is cross-platform and more common on Linux) or bash scripting. The PowerShell examples are presented as the sole scripting/command-line automation method. Additionally, the structure and language of the documentation prioritize Windows-centric tools and patterns, with no mention of Linux-native approaches or parity in command-line instructions.
Recommendations
- Add Azure CLI examples alongside PowerShell for all automation account management tasks, including deleting accounts and solutions.
- Explicitly mention that Azure CLI commands can be run on Linux, macOS, and Windows, and provide bash syntax where appropriate.
- Where PowerShell is referenced, clarify that it is available cross-platform, but also provide native bash or shell script equivalents for Linux users.
- Include a section or tab for Linux users, demonstrating how to perform the same actions using the Azure CLI and/or REST API with curl.
- Review all command-line examples to ensure Linux parity and avoid implying that PowerShell is the only or primary automation tool.
Automation
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/automation/overview.md
...s/azure-docs/blob/main/articles/automation/overview.md
High Priority
View Details →
Detected Bias Types
Powershell Heavy
Windows First
Windows Tools
Missing Linux Example
Summary
The documentation demonstrates a Windows bias by emphasizing PowerShell and Windows-centric tools and patterns throughout. PowerShell and DSC (Desired State Configuration) are highlighted as primary automation and configuration mechanisms, with minimal mention of Linux-native equivalents. Examples and terminology (such as modules, cmdlets, and references to Windows services like Active Directory and SQL Server) are Windows-focused. Linux support is mentioned, but Linux-specific examples, tools, or patterns are absent or secondary.
Recommendations
- Provide Linux-native examples alongside PowerShell, such as Bash or Python runbooks specifically for Linux scenarios.
- Explicitly mention and document Linux configuration management options (e.g., Ansible, Chef, native Linux DSC support) where relevant.
- Balance references to Windows tools (e.g., Active Directory, SQL Server) with Linux equivalents (e.g., OpenLDAP, MySQL/PostgreSQL).
- Include Linux-specific modules, package management, and automation patterns in the shared resources and scenarios sections.
- Ensure that all features and capabilities are described with parity for both Windows and Linux, including any limitations or differences.
Automation
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/automation/automation-hrw-run-runbooks.md
...ain/articles/automation/automation-hrw-run-runbooks.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 examples are consistently presented before Linux equivalents, and PowerShell (a Windows-centric tool) is used exclusively in all code samples for runbook authentication, management, and execution. Windows-specific tools and paths (e.g., Control Panel, cert store locations, Windows file paths) are referenced in detail, while Linux instructions are often less detailed or missing (e.g., no Linux example for starting a runbook via CLI, no Linux-specific credential asset support). Some advanced features (like Hybrid Worker Credentials) are not supported on Linux, and this is noted but not compensated for with Linux alternatives.
Recommendations
- Provide Linux examples alongside Windows examples for all key scenarios, especially for starting runbooks, configuring environment variables, and authentication.
- Include Bash or Python code samples for Linux where PowerShell is used for Windows.
- Present Windows and Linux instructions in parallel sections or tabs, rather than always listing Windows first.
- Where features are unsupported on Linux (e.g., Hybrid Worker Credentials), suggest alternative Linux-native approaches or workarounds.
- Reference Linux tools and paths with the same level of detail as Windows (e.g., environment variable setup, log locations, certificate/key management).
- Add explicit Linux CLI examples for tasks like starting a runbook, managing credentials, and configuring permissions.
- Ensure parity in troubleshooting and logging guidance for both platforms.