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 176-200 of 982 flagged pages
Automation
Disable system-assigned managed identity for Azure Automation account
.../automation/disable-managed-identity-for-automation.md
High Priority
View Details →
Detected Bias Types
Powershell Heavy
Windows First
Missing Linux Example
Windows Tools
Summary
The documentation provides only PowerShell-based examples for interacting with the Azure REST API, relying on Windows-centric tools and cmdlets (e.g., Connect-AzAccount, Invoke-RestMethod) without mentioning or demonstrating equivalent Linux/macOS workflows (such as using Azure CLI, curl, or bash scripting). This creates a Windows bias by assuming users are on Windows and familiar with PowerShell, and omits guidance for Linux users.
Recommendations
- Add equivalent examples using Azure CLI (az login, az rest) for Linux/macOS users.
- Provide curl-based REST API invocation examples, which are cross-platform.
- Explicitly mention that PowerShell examples are for Windows and offer alternatives for other operating systems.
- Include notes or sections for Linux/macOS users, highlighting any differences in authentication or tooling.
- Ensure all steps (authentication, request construction, confirmation) have cross-platform parity.
Create Pull Request
Automation
Deploy an extension-based Windows or Linux User Hybrid Runbook Worker in Azure Automation
...ation/extension-based-hybrid-runbook-worker-install.md
High Priority
View Details →
Detected Bias Types
Windows First
Powershell Heavy
Windows Tools
Missing Linux Example
Summary
The documentation exhibits several signs of Windows bias. Windows and PowerShell examples are consistently presented first and in greater detail, with Linux equivalents often relegated to secondary tabs or brief mentions. The use of Windows-specific tools (e.g., Windows PowerShell 5.1, .NET Framework) is emphasized, while Linux requirements and tooling are less thoroughly explained. Infrastructure-as-code examples (Bicep, ARM templates) and REST API samples are focused on Windows VM creation and extension installation, with no parallel Linux VM examples. Folder and permission paths are Windows-centric, and troubleshooting notes often reference Windows features (UAC/LUA, registry keys) without Linux alternatives. The documentation lacks parity in Linux-specific automation, deployment, and management workflows.
Recommendations
- Provide Linux-first or side-by-side examples for all deployment, management, and troubleshooting steps, including PowerShell, CLI, Bicep, ARM, and REST API workflows.
- Expand infrastructure-as-code samples (Bicep, ARM templates) to include Linux VM creation and extension installation, with clear parameterization for OS type.
- Include Linux-specific tooling and requirements (e.g., shell commands, package managers, systemd integration) where Windows tools are referenced.
- Balance the explanation of prerequisites and permissions, detailing Linux file paths, permissions, and security contexts (e.g., SELinux, sudoers) alongside Windows equivalents.
- Add troubleshooting and operational guidance for Linux environments, such as log file locations, service management, and common issues.
- Ensure all code snippets and instructions are available for both platforms, and avoid presenting Windows examples before Linux unless contextually justified.
- Reference Linux documentation and best practices as prominently as Windows resources in the 'Next steps' and related links sections.
Automation
Move your Azure Automation account to another subscription
...s/blob/main/articles/automation/how-to/move-account.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 providing only PowerShell examples for resource deletion and management, referencing Windows-centric tools and cmdlets (Remove-AzResource, Remove-AzActionGroup), and omitting equivalent Azure CLI or REST API examples that are more commonly used on Linux or cross-platform environments. The ordering and language also prioritize PowerShell and portal instructions, which are more familiar to Windows users, without mentioning Linux-specific workflows or tools.
Recommendations
- Add Azure CLI examples for all resource management tasks (e.g., deleting solutions, action groups) alongside PowerShell examples.
- Explicitly mention that both PowerShell and Azure CLI can be used, and provide links to both sets of documentation.
- Include REST API example snippets for advanced users, especially those on Linux or using automation scripts.
- Reorder instructions to present cross-platform tools (Azure CLI, REST API) before or alongside PowerShell, to avoid Windows-first impression.
- Add notes or sections highlighting Linux compatibility and usage patterns, ensuring parity in guidance for non-Windows environments.
Automation
Use Azure Private Link to securely connect networks to Azure Automation
...in/articles/automation/how-to/private-link-security.md
High Priority
View Details →
Detected Bias Types
Powershell Heavy
Windows First
Missing Linux Example
Summary
The documentation page demonstrates a Windows bias by providing only PowerShell examples for configuring public network access, referencing Windows-specific tools (PowerShell Desired State Configuration), and omitting equivalent Linux CLI or scripting examples. While Linux is mentioned as supported in some features (e.g., Update Management), practical setup and configuration steps are exclusively shown for Windows environments, leaving Linux users without direct guidance.
Recommendations
- Include equivalent Linux CLI (e.g., Azure CLI, Bash) examples alongside PowerShell scripts for all configuration steps.
- Provide examples and instructions for managing Azure Automation and Private Link from Linux environments, such as using az CLI commands.
- Expand references to configuration management tools to include Linux-native options (e.g., Ansible, Chef) where relevant, or clarify DSC usage on Linux.
- Ensure screenshots and UI walkthroughs highlight cross-platform parity, mentioning any OS-specific considerations.
- Add troubleshooting and agent installation steps for both Windows and Linux environments.
Automation
Manage Office 365 services using Azure Automation
...ocs/blob/main/articles/automation/manage-office-365.md
High Priority
View Details →
Detected Bias Types
Powershell Heavy
Windows First
Missing Linux Example
Windows Tools
Summary
The documentation page exhibits a strong Windows bias. All examples and instructions rely exclusively on Windows PowerShell, with no mention of Linux-compatible alternatives or cross-platform scripting. The Microsoft Graph PowerShell module is stated to require Windows PowerShell, and PowerShell Core (which is cross-platform) is explicitly excluded. There are no Bash, Linux shell, or CLI examples, and Windows tools and patterns (such as Send-MailMessage and credential assets) are used throughout.
Recommendations
- Provide equivalent instructions and examples for Linux environments, using PowerShell Core or Azure CLI where possible.
- Clarify which features are Windows-only and suggest cross-platform alternatives (e.g., using REST API calls or Microsoft Graph SDKs in Python, Bash, etc.).
- Include notes or tables summarizing platform compatibility for each step.
- Offer guidance on how to run Azure Automation scripts from Linux/macOS, or how to interact with Office 365 services using non-Windows tools.
- Where PowerShell modules are Windows-only, link to or describe alternative approaches for Linux users.
Automation
Manage Runtime Environment and Associated Runbooks in Azure Automation
...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 page demonstrates a noticeable Windows bias. PowerShell is consistently mentioned first and in greater detail than Python, with examples and package management instructions focused on PowerShell modules and tools (e.g., Az PowerShell, PowerShell Gallery). Windows-specific patterns (such as .zip module packaging and references to Windows PowerShell modules) are highlighted, while Linux/Python equivalents are only briefly mentioned or omitted. There are no explicit Linux shell or CLI examples, and package management for Python is referenced only in passing, with no concrete examples or parity in guidance.
Recommendations
- Provide equal, detailed examples for Python runbooks, including REST API payloads and portal steps.
- Include Linux-oriented instructions and examples, such as using .whl files, pip, or Linux shell commands for package management.
- Mention Python and Linux options before or alongside PowerShell/Windows options to avoid ordering bias.
- Add screenshots and walkthroughs for Python runbook creation and management, similar to those provided for PowerShell.
- Clarify platform compatibility (Windows vs. Linux) for runtime environments, and highlight differences in supported features.
- Reference Python package repositories (e.g., PyPI) and provide guidance for importing Python packages, not just PowerShell Gallery.
High Priority
View Details →
Detected Bias Types
Powershell Heavy
Windows Tools
Windows First
Missing Linux Example
Summary
The documentation page for Azure Automation demonstrates a moderate Windows bias. PowerShell is repeatedly referenced as the primary automation language, especially in the context of Desired State Configuration (DSC), with little mention of Linux-native equivalents. Windows-centric tools and scenarios (Active Directory, SharePoint Server, SQL Server) are highlighted, while Linux-specific examples, tools, or configuration management approaches are absent. Although the page claims heterogeneous support, practical Linux parity is not demonstrated through examples or tool references.
Recommendations
- Add Linux-specific examples for runbooks, such as Bash or Python scripts managing Linux services or configurations.
- Mention and link to Linux-native configuration management tools (e.g., Ansible, Chef, Puppet) and how they can integrate with Azure Automation.
- Provide explicit guidance or examples for managing Linux workloads, such as package updates, service restarts, or log collection.
- Balance scenario lists by including Linux-centric use cases (e.g., automating Apache/Nginx, managing cron jobs, handling SELinux policies).
- Clarify how DSC applies to Linux, or mention Linux alternatives for state configuration.
- Ensure that references to modules, galleries, and shared resources include Linux-relevant content (e.g., Bash modules, Python packages for Linux automation).
Automation
Manage runbooks in Azure Automation
...-docs/blob/main/articles/automation/manage-runbooks.md
High Priority
View Details →
Detected Bias Types
Powershell Heavy
Windows First
Missing Linux Example
Windows Tools
Summary
The documentation page for managing runbooks in Azure Automation demonstrates a strong Windows bias. All code examples use PowerShell, with no Bash, CLI, or Linux-native scripting shown. Windows file paths (e.g., C:\Runbooks\...) are used in examples, and all automation tooling references are to PowerShell cmdlets. There is no mention of Linux shell equivalents, nor are Linux-specific patterns or tools discussed. The documentation assumes familiarity with Windows/PowerShell environments and does not provide parity for Linux users.
Recommendations
- Add Azure CLI and Bash examples alongside PowerShell for all major operations (create, import, publish, retrieve job status, etc.).
- Include Linux file path examples (e.g., /home/user/runbooks/Sample_TestRunbook.py) where file selection/import is discussed.
- Mention and demonstrate how to use Python runbooks and Linux shell scripts in Azure Automation, including any limitations or differences.
- Reference Linux tools and patterns (such as cron for scheduling, shell scripting for error handling) where relevant.
- Clarify cross-platform support for Hybrid Runbook Worker and provide Linux-specific setup and usage instructions.
- Ensure that introductory and summary sections do not assume PowerShell as the default, but present both Windows and Linux options equally.
Automation
Manage databases in Azure SQL databases using Azure Automation
...articles/automation/manage-sql-server-in-automation.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 by exclusively providing PowerShell-based examples and instructions, referencing Windows-centric tools (e.g., PowerShell cmdlets, environment variables like $env:computerName), and omitting any Linux or cross-platform alternatives. The setup and troubleshooting steps assume a Windows environment, with no mention of Bash, Azure CLI, or Linux-specific guidance. This limits accessibility for users managing Azure SQL databases from Linux or non-Windows platforms.
Recommendations
- Provide equivalent examples using Azure CLI and Bash scripts for Linux users.
- Clarify which steps and tools are cross-platform and which are Windows-specific.
- Include instructions for installing and using required modules on Linux/macOS environments.
- Reference both PowerShell and CLI documentation, and offer links to Linux-specific troubleshooting guides.
- Add notes or sections explicitly addressing Linux and macOS usage scenarios, including environment variable differences and command syntax.
Automation
Migrate an existing agent-based hybrid workers to extension-based-workers in Azure Automation
...g-agent-based-hybrid-worker-to-extension-based-workers.md
High Priority
View Details →
Detected Bias Types
Windows First
Missing Linux Example
Powershell Heavy
Windows Tools
Summary
The documentation demonstrates a Windows bias in several ways: Windows is consistently presented first in OS support tables and examples; Bicep and ARM template samples are exclusively for Windows VMs, with no Linux equivalents; PowerShell is used heavily for management and migration tasks, while Linux-specific CLI or scripting examples are sparse or absent; and Windows-specific tools and requirements (e.g., Windows PowerShell, .NET Framework, registry edits) are detailed, whereas Linux requirements and procedures are less comprehensive or relegated to notes.
Recommendations
- Provide Bicep and ARM template examples for deploying and managing Linux VMs as Hybrid Workers, including the correct extension type (HybridWorkerForLinux).
- Ensure Linux is presented equally or first in tables, examples, and step-by-step instructions where relevant.
- Include Linux-specific CLI and scripting examples (e.g., Bash scripts, cloud-init, Ansible) for migration and management tasks.
- Expand on Linux requirements and troubleshooting steps to match the detail given for Windows (e.g., folder permissions, extension settings).
- Balance PowerShell usage with equivalent Linux-native tooling (e.g., Azure CLI, REST API, Bash) in all management scenarios.
- Explicitly mention Linux-specific extension types and settings in all relevant code samples and API payloads.
Automation
Azure Quickstart - Configure a VM with Desired State Configuration
...n/articles/automation/quickstarts/dsc-configuration.md
High Priority
View Details →
Detected Bias Types
Powershell Heavy
Windows First
Windows Tools
Missing Linux Example
Summary
The documentation page demonstrates several forms of Windows bias. The workflow and examples are centered around PowerShell and Windows-centric tooling (DSC, PowerShell Gallery, Chocolatey), even though the example configuration is for a LAMP stack (Linux). The documentation references Windows servers explicitly, uses PowerShell syntax throughout, and links to Windows-focused resources. There is no mention of Linux-native configuration tools or alternative workflows for Linux users, and the retirement of Linux DSC is noted without offering Linux alternatives.
Recommendations
- Provide equivalent Linux-native configuration examples (e.g., using Ansible, Chef, or native Azure Policy Guest Configuration for Linux).
- Include Linux command-line instructions and examples alongside PowerShell, especially for module management and configuration deployment.
- Reference Linux package managers and service management tools (apt, systemctl, etc.) where relevant.
- Offer guidance for users migrating from retired Linux DSC to supported Linux configuration management solutions.
- Balance references to Windows and Linux tools in prerequisites and next steps, including links to Linux-focused documentation.
Automation
Quickstart - Enable managed identities for your Automation account using the Azure portal
...cles/automation/quickstarts/enable-managed-identity.md
High Priority
View Details →
Detected Bias Types
Powershell Heavy
Windows First
Missing Linux Example
Summary
The documentation page demonstrates bias towards Windows by exclusively referencing PowerShell in the 'Next steps' section, without mentioning or providing examples for Linux or cross-platform alternatives such as Python or Bash runbooks. There are no instructions or links for creating or using managed identities with non-Windows tools, and the only runbook example provided is for PowerShell, which is traditionally associated with Windows environments.
Recommendations
- Include links and examples for creating and using managed identities with Python and Bash runbooks, which are commonly used on Linux.
- Add a 'Next steps' section that references tutorials for Linux-based automation scenarios, such as Python runbooks.
- Explicitly mention that managed identities can be used with multiple runbook types, not just PowerShell.
- Provide parity in documentation by ensuring that Linux and cross-platform examples are given equal prominence to Windows/PowerShell examples.
Automation
Runtime Environment in Azure Automation
...in/articles/automation/runtime-environment-overview.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 focusing primarily on PowerShell as the main scripting language, with multiple versions listed and examples centered around PowerShell environments. Azure CLI is only mentioned as a default package within PowerShell 7.4, and there is no mention of Bash, Linux shell scripting, or Linux-specific tools. Package sources reference PSGallery (PowerShell) before PyPI (Python), and there are no examples or guidance for Linux users or Bash runbooks.
Recommendations
- Include examples and guidance for Bash or Linux shell scripting in Azure Automation runbooks.
- Mention Linux-native tools and package sources (e.g., apt, yum, or other Linux package managers) alongside PSGallery and PyPI.
- Provide parity in documentation by listing Bash and Python examples before or alongside PowerShell examples.
- Clarify support for Linux-based runtime environments, if available, and provide instructions for configuring them.
- Reference Linux documentation and best practices for automation in addition to PowerShell resources.
Automation
Manage certificates in Azure Automation
...n/articles/automation/shared-resources/certificates.md
High Priority
View Details →
Detected Bias Types
Powershell Heavy
Windows Tools
Windows First
Missing Linux Example
Summary
The documentation page demonstrates a strong Windows bias by focusing almost exclusively on PowerShell cmdlets and Windows-centric tools for certificate management in Azure Automation. All code examples for certificate creation and management use PowerShell, with no equivalent Bash, CLI, or Linux-native examples. Windows tools and patterns (e.g., PowerShell, .pfx files, Windows cryptographic providers) are mentioned first and exclusively, while Linux alternatives are absent. The Python examples are limited to runbook usage and do not cover certificate creation or management workflows outside of the PowerShell ecosystem.
Recommendations
- Add equivalent examples using Azure CLI and Bash scripts for certificate management tasks, such as creating, uploading, and retrieving certificates.
- Include instructions and examples for Linux users, such as using OpenSSL to generate certificates and uploading them via Azure CLI.
- Mention Linux-compatible cryptographic providers and clarify whether the certificate requirements (e.g., Microsoft Enhanced RSA and AES Cryptographic Provider) are Windows-specific or if alternatives exist for Linux.
- Provide guidance on managing certificates from Linux/macOS environments, including any platform-specific caveats.
- Ensure that documentation does not assume PowerShell as the default or only method, and present cross-platform options side-by-side.
Automation
Quickstart: Use Terraform to create an Azure Automation account
...ickstarts/create-azure-automation-account-terraform.md
High Priority
View Details →
Detected Bias Types
Windows First
Powershell Heavy
Windows Tools
Summary
The documentation provides both Azure CLI and Azure PowerShell examples for verifying results, but PowerShell is given equal prominence and is referenced in the next steps (specifically a PowerShell runbook tutorial). There is no mention of Linux-specific tools or shell environments, and the use of PowerShell (a Windows-centric tool) is highlighted. The 'Clean up resources' and other operational steps do not show Linux-specific commands or considerations, and the next steps focus on PowerShell automation, reinforcing a Windows-centric approach.
Recommendations
- Add explicit Bash/Linux shell examples alongside PowerShell, especially for verification and operational steps.
- Include references to Linux-native tools or workflows where applicable (e.g., Bash scripts, cloud shell usage).
- Balance next steps by linking to tutorials for both PowerShell and Python runbooks, or other cross-platform automation options.
- Clarify that Azure CLI and Terraform are cross-platform and can be used on Linux, macOS, and Windows.
- Consider adding a section or note about running Terraform and Azure CLI in Linux environments, including any OS-specific considerations.
Automation
Azure Quickstart - Install Hybrid Worker extension on Azure portal.
...omation/quickstarts/install-hybrid-worker-extension.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 installing the Hybrid Worker extension on Windows Azure Virtual Machines. All step-by-step instructions, screenshots, and extension selection refer only to 'Azure Automation Windows Hybrid Worker', with no mention or example for Linux VMs. Prerequisites specifically call out a Windows VM, and there are no Linux-specific instructions, screenshots, or extension names provided. The documentation does not illustrate parity for Linux users, despite mentioning Linux support in the introduction.
Recommendations
- Add explicit instructions and screenshots for installing the Hybrid Worker extension on Linux Azure Virtual Machines.
- Include the extension name for Linux (e.g., 'Azure Automation Linux Hybrid Worker') in the step-by-step guide.
- Update prerequisites to mention both Windows and Linux VMs as supported targets.
- Present Windows and Linux instructions side-by-side or in parallel sections to ensure equal visibility.
- Clarify any differences in configuration or requirements between Windows and Linux installations.
Automation
Configure runbook input parameters in Azure Automation
...b/main/articles/automation/runbook-input-parameters.md
High Priority
View Details →
Detected Bias Types
Powershell Heavy
Windows First
Missing Linux Example
Windows Tools
Summary
The documentation page exhibits a strong Windows bias, with nearly all examples, code snippets, and tool references centered around PowerShell, PowerShell Workflow, and Windows-centric patterns. The page lacks Linux shell (bash) or cross-platform CLI examples, and does not mention Linux-specific tools or workflows. Even when discussing Python runbooks, the examples and context are minimal compared to the extensive PowerShell coverage. The instructions for starting runbooks from local machines exclusively use PowerShell, with no mention of Bash, Azure CLI, or Linux-native approaches.
Recommendations
- Add equivalent examples using Azure CLI (az) commands for starting and managing runbooks, which are cross-platform and widely used on Linux.
- Include bash shell examples for passing parameters to runbooks, especially for Python runbooks, to demonstrate Linux parity.
- Mention Linux and macOS environments explicitly in sections about running scripts locally, and provide instructions for those platforms.
- Reference Linux tools (e.g., curl for REST API calls, jq for JSON manipulation) alongside PowerShell examples.
- Balance the documentation by providing equal detail and screenshots for non-Windows workflows, such as using Azure Automation from a Linux VM or container.
- Clarify which features or behaviors are platform-specific (e.g., PowerShell parameter handling) and which are cross-platform.
Automation
Manage modules in Azure Automation
...b/main/articles/automation/shared-resources/modules.md
High Priority
View Details →
Detected Bias Types
Powershell Heavy
Windows First
Missing Linux Example
Windows Tools
Summary
The documentation is heavily focused on PowerShell modules and cmdlets, with nearly all examples, instructions, and tooling centered around Windows PowerShell and Az/AzureRM modules. Windows-specific features (such as internal cmdlets and Hybrid Runbook Worker) are described in detail, while Linux equivalents are either missing or mentioned only to note their lack of support. There are no Linux shell (bash) examples, and Python is referenced only briefly. The documentation assumes a Windows-centric workflow and does not provide parity for Linux users.
Recommendations
- Add Linux-specific guidance and examples, such as using bash scripts or Python runbooks in Azure Automation.
- Clearly document which features are Windows-only and provide alternatives or workarounds for Linux users where possible.
- Include instructions for managing modules on Linux Hybrid Runbook Workers, even if limited, and highlight differences.
- Expand the Python section to include practical examples and module management steps for Linux environments.
- Where PowerShell is used, clarify compatibility with PowerShell Core (cross-platform) and provide examples for non-Windows platforms.
- Add a comparison table showing feature parity and gaps between Windows and Linux Hybrid Runbook Workers.
Automation
Manage credentials in Azure Automation
...in/articles/automation/shared-resources/credentials.md
High Priority
View Details →
Detected Bias Types
Powershell Heavy
Windows First
Windows Tools
Missing Linux Example
Summary
The documentation page exhibits a strong Windows and PowerShell bias. All command-line examples for credential management use PowerShell cmdlets, with no mention of Linux shell equivalents or cross-platform CLI tools. The creation and retrieval of credentials are demonstrated exclusively with Windows PowerShell, and the documentation references Windows-specific objects like PSCredential. The Python examples are provided, but there are no Bash, Azure CLI, or Linux-native instructions. The documentation does not address how Linux users can manage credentials outside of the Azure portal or Python SDK, nor does it mention cross-platform alternatives to PowerShell cmdlets.
Recommendations
- Add Azure CLI examples for credential management, showing how to create, retrieve, and use credentials from Linux/macOS terminals.
- Include Bash or shell script snippets for common credential operations, or clarify if such operations are not supported outside PowerShell.
- Explicitly state platform limitations and provide guidance for Linux users, including links to relevant cross-platform tools or SDKs.
- Reorder sections so that cross-platform or platform-neutral methods (e.g., Azure portal, REST API, Azure CLI) are presented before Windows/PowerShell-specific instructions.
- Mention and link to documentation for managing credentials using REST API or SDKs in languages other than Python and PowerShell.
- Clarify whether PowerShell Core (pwsh) on Linux/macOS is supported and provide examples if so.
Automation
Manage variables in Azure Automation
...main/articles/automation/shared-resources/variables.md
High Priority
View Details →
Detected Bias Types
Powershell Heavy
Windows First
Windows Tools
Missing Linux Example
Summary
The documentation page demonstrates a strong Windows bias. PowerShell is presented as the primary scripting interface for variable management, with extensive examples and cmdlet tables. Windows-specific tools and terminology (e.g., 'Windows PowerShell', 'Windows Hybrid Runbook Worker') are used throughout, and there is no mention of Linux shell (bash, sh) or CLI equivalents for variable management. The Python examples are provided, but only in the context of runbooks, not for general variable management from a Linux environment. No Linux-native scripting or command-line examples are given.
Recommendations
- Add examples for managing variables using Azure CLI commands, which are cross-platform and commonly used in Linux environments.
- Include bash or shell script examples for interacting with Azure Automation variables, possibly via REST API or Azure CLI.
- Explicitly mention Linux support and patterns for variable management, including how to use runbooks or automation from Linux-based Hybrid Runbook Workers.
- Reorder sections so that cross-platform tools (e.g., Azure CLI, REST API) are presented before or alongside PowerShell examples.
- Clarify which features and cmdlets are available on Linux and which are Windows-only, to help users choose appropriate tooling.
Automation
Remove DSC and node from Automation State Configuration
...configuration/remove-node-and-configuration-package.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 prioritizing PowerShell-based instructions and tools, mentioning Windows-specific cmdlets (e.g., Remove-DscConfigurationDocument) and Azure PowerShell before Linux equivalents. Linux instructions are present but less detailed, and manual Linux steps are described only briefly, without example commands or scripts. Windows tools and patterns (PowerShell, .mof file management) are emphasized, while Linux instructions lack parity in depth and clarity.
Recommendations
- Provide Linux command-line examples for unregistering nodes and deleting configuration files, similar to the PowerShell examples given for Windows.
- Include sample bash scripts or commands for common Linux distributions to automate DSC removal and configuration deletion.
- Present Windows and Linux instructions side-by-side or in parallel tabs, ensuring equal prominence and clarity.
- Expand Linux documentation to match the detail and guidance provided for Windows, including troubleshooting tips and file locations.
- Reference Linux-specific tools or patterns (e.g., systemctl, package managers) where appropriate, not just generic file deletion.
Automation
Troubleshoot extension-based Hybrid Runbook Worker issues in Azure Automation
.../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 page demonstrates a moderate Windows bias. In most troubleshooting steps and scenarios, Windows instructions, tools, and examples are presented before Linux equivalents. Windows-specific tools (such as PowerShell scripts, registry edits, and event logs) are described in detail, often with explicit code samples, while Linux instructions are sometimes less detailed or appear later. Several scenarios are exclusively Windows-focused (e.g., registry, UAC, event logs) without Linux analogs, and troubleshooting guidance often references Windows event logs and tools before mentioning Linux alternatives.
Recommendations
- Alternate the order of Windows and Linux instructions so that Linux is not always presented second.
- Provide Linux equivalents for all troubleshooting steps, especially where only Windows tools (e.g., PowerShell scripts, registry edits, event logs) are mentioned.
- Include Linux-specific troubleshooting scenarios (e.g., SELinux, systemd issues, Linux authentication problems) to match the depth of Windows coverage.
- Where Windows event logs are referenced, provide guidance for Linux log analysis (e.g., using journalctl, syslog, or custom logs).
- Ensure that code samples and step-by-step instructions for Linux are as detailed and explicit as those for Windows.
- Review all scenarios for parity, adding Linux-specific error messages, causes, and resolutions where missing.
Automation
Manage schedules in Azure Automation
...main/articles/automation/shared-resources/schedules.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 examples and cmdlets for schedule management in Azure Automation. There are no examples using Bash, Azure CLI, or Linux-native tools, and PowerShell is presented as the primary automation interface. The use of PowerShell cmdlets and references to Windows-centric patterns (such as System.TimeZoneInfo and Get-Date) further reinforce this bias, making it less accessible for Linux users or those preferring cross-platform tools.
Recommendations
- Add equivalent Azure CLI examples for all PowerShell cmdlet scenarios, including schedule creation, linking, disabling, and removal.
- Include Bash script examples where possible, especially for common automation tasks.
- Explicitly mention cross-platform compatibility of Azure Automation and clarify that PowerShell Core is available on Linux/macOS, but also provide non-PowerShell alternatives.
- Reorder sections to present Azure CLI and Bash examples alongside or before PowerShell to avoid 'Windows first' perception.
- Reference Linux tools or patterns (e.g., cron syntax, date handling in Bash) when discussing scheduling concepts.
- Provide guidance for Linux users on installing and using Azure CLI and PowerShell Core, and clarify any platform-specific limitations.
Automation
Use Source Control Integration in Azure Automation
...main/articles/automation/source-control-integration.md
High Priority
View Details →
Detected Bias Types
Powershell Heavy
Windows First
Missing Linux Example
Windows Tools
Summary
The documentation demonstrates a strong Windows/Powershell bias. All command-line examples are provided exclusively using Azure PowerShell cmdlets, with no mention of Bash, Azure CLI, or cross-platform scripting alternatives. The prerequisites and configuration steps assume the use of PowerShell and Windows-centric tools, and there is no guidance for Linux or macOS users. The documentation also references PowerShell 5.1 runbooks as the only supported type for source control integration, further reinforcing the Windows-centric approach.
Recommendations
- Provide equivalent Azure CLI examples for all PowerShell cmdlets, especially for assigning roles and configuring source control.
- Explicitly mention cross-platform compatibility and provide instructions for Linux/macOS users where applicable.
- Clarify whether source control integration supports Python or other runbook types on non-Windows platforms, and update documentation accordingly.
- Include troubleshooting and setup guidance for users working from Linux or macOS environments.
- Reference file encoding and editor issues in a cross-platform context, not just via PowerShell/VSCode links.
Automation
Troubleshoot agent-based Hybrid Runbook Worker issues in Azure Automation
...icles/automation/troubleshoot/hybrid-runbook-worker.md
High Priority
View Details →
Detected Bias Types
Windows First
Powershell Heavy
Windows Tools
Missing Linux Example
Summary
The documentation demonstrates a Windows bias in several ways: Windows troubleshooting scenarios and examples are presented first and in greater detail, with many steps and resolutions referencing Windows-specific tools (e.g., PowerShell, registry edits, event logs, Windows file paths). PowerShell is used heavily for troubleshooting and configuration, while Linux equivalents (e.g., Bash, systemd, Linux logs) are less frequently mentioned and often appear later or in less detail. Some troubleshooting steps and workarounds are only described for Windows, with Linux alternatives missing or less explicit.
Recommendations
- Ensure that troubleshooting scenarios and examples are presented for both Windows and Linux, with parity in detail and clarity.
- Provide Linux-first or side-by-side examples for commands, file locations, and configuration steps (e.g., show Bash/systemctl commands alongside PowerShell).
- Include Linux-specific troubleshooting tools and logs (e.g., journalctl, /var/log) where Windows event logs are referenced.
- Avoid referencing Windows file paths, registry keys, or tools exclusively; always provide the Linux equivalent or clarify platform differences.
- Balance the order of presentation so that Linux scenarios are not always after Windows, or group by platform for clarity.
- Expand Linux sections to match the depth of Windows troubleshooting, including more common issues and their resolutions.