283
Pages Scanned
90
Pages Flagged
283
Changed Pages
31.8%
% Pages Flagged
Live Progress
đ´ Connecting...
Phase: discovery
Processing: Initializing...
Activity Feed
00:00:06
Scan Information
Started At: 2026-02-15 00:00:06
Finished At: In Progress
Status: in_progress
Target Repo: Azure Compute
Current Phase: discovery
Files Queued: 283
Files Completed: 283
Problematic Pages
91 issues found
Service Fabric
Initializer CodePackages in Service Fabric
...in/articles/service-fabric/initializer-codepackages.md
High Priority
View Details â
Detected Bias Types
windows_first
missing_linux_example
windows_tools
Summary
The documentation page for Initializer CodePackages in Service Fabric is heavily focused on Windows container scenarios. All examples use Windows containers (nanoserver), Windows paths (C:\...), and Windows command syntax (cmd, echo, type, ping). There are no Linux container examples, nor is there guidance for Linux-based Service Fabric clusters. Windows tools and patterns are referenced exclusively, and the example assumes familiarity with Windows container creation.
Recommendations
- Add equivalent examples using Linux containers (e.g., Ubuntu, Alpine) and Linux command syntax (bash, echo, cat, etc.).
- Show how to specify volume mounts and commands for Linux containers in Service Fabric manifests.
- Clarify whether Initializer CodePackages are supported for Linux clusters and containers; if not, state this explicitly.
- If Linux support exists, provide a complete Linux-based manifest and walkthrough.
- If Windows-only, add a clear note at the top indicating Initializer CodePackages are not supported for Linux clusters/containers.
Create Pull Request
Service Fabric
Azure Service Fabric reverse proxy
...articles/service-fabric/service-fabric-reverseproxy.md
High Priority
View Details â
Detected Bias Types
windows_first
missing_linux_example
Summary
The documentation explicitly states that the Service Fabric reverse proxy is not available for Linux clusters, and all examples, configuration instructions, and code samples are implicitly Windows-centric. There are no Linux-specific instructions or examples, and Linux users are informed that the feature is unavailable to them.
Recommendations
- Clearly indicate at the top of the page that the reverse proxy feature is Windows-only, to prevent confusion for Linux users.
- Provide links or references to alternative approaches for service discovery and communication in Linux Service Fabric clusters, if available.
- Consider adding a section outlining the roadmap or status of reverse proxy support for Linux, or suggest workarounds for Linux users.
- Ensure that navigation from Linux-related Service Fabric documentation does not lead to this page without a clear warning about platform limitations.
Service Fabric
Introduction to the Service Fabric Infrastructure Service
.../articles/service-fabric/infrastructure-service-faq.md
Medium Priority
View Details â
Detected Bias Types
powershell_heavy
windows_first
Summary
The documentation provides a PowerShell-only example for bypassing Infrastructure Service, without mentioning Linux/macOS equivalents or CLI alternatives. Service Fabric Explorer is referenced, which is cross-platform, but the command-line guidance is Windows-centric.
Recommendations
- Add equivalent Azure CLI or Bash examples for bypassing Infrastructure Service, or clarify if PowerShell is required regardless of OS.
- Explicitly state whether the PowerShell cmdlet is available on Linux/macOS (via PowerShell Core), and provide installation guidance if so.
- If the operation is only possible via PowerShell, clarify this limitation for Linux/macOS users.
- Consider providing links or instructions for using Service Fabric Explorer from Linux/macOS if relevant.
Service Fabric
Azure Service Fabric networking best practices
...ice-fabric/service-fabric-best-practices-networking.md
Medium Priority
View Details â
Detected Bias Types
powershell_heavy
windows_first
windows_tools
missing_linux_example
Summary
The documentation page presents several examples and references that prioritize Windows tools and patterns, such as PowerShell, and often mentions Windows-specific concepts before Linux equivalents. Some sections (e.g., API access, DevOps, and port explanations) focus on Windows tools or provide Windows-centric guidance, while Linux alternatives are less prominent or missing. Although Linux is referenced, parity in examples and explanations is lacking.
Recommendations
- Provide Linux CLI (az, bash) examples alongside PowerShell for cluster management and networking tasks.
- Clarify when guidance applies to both Windows and Linux, and explicitly note any differences.
- Add Linux-specific guidance for DevOps/API access, including relevant tools and commands.
- Ensure port explanations and security rule tables clearly indicate which apply to Linux, which to Windows, and provide Linux-specific context.
- Include ARM template samples for Linux clusters, not just Windows.
- Balance references to Windows and Linux throughout the page, avoiding Windows-first ordering unless justified.
Service Fabric
Application upgrade: data serialization
...ps://github.com/MicrosoftDocs/azure-compute-docs/blob/main/articles/service-fabric/service-fabric-application-upgrade-data-serialization.md
Medium Priority
View Details â
Detected Bias Types
powershell_heavy
windows_first
Summary
The documentation page provides links to application upgrade tutorials using Visual Studio and PowerShell, both of which are primarily Windows-centric tools. No equivalent Linux/macOS upgrade examples or CLI instructions are mentioned or linked. The serialization guidance is focused on C# and .NET, which are cross-platform, but the upgrade workflow references Windows tools first and exclusively.
Recommendations
- Add links or sections describing how to perform application upgrades using cross-platform tools such as Azure CLI or Service Fabric CLI (sfctl), which are available on Linux/macOS.
- Include upgrade examples or tutorials for Linux/macOS environments, or explicitly state if only Windows tools are supported for certain workflows.
- If PowerShell is referenced, clarify whether PowerShell Core (cross-platform) is supported, and provide instructions for Linux/macOS if applicable.
- Consider mentioning Visual Studio Code as a cross-platform alternative to Visual Studio for relevant tasks.
Service Fabric
Architecture of Azure Service Fabric
...articles/service-fabric/service-fabric-architecture.md
Medium Priority
View Details â
Detected Bias Types
powershell_heavy
windows_first
Summary
The documentation references PowerShell cmdlets as primary management tools in the Management subsystem section, without mentioning Linux/macOS equivalents (such as Azure CLI or REST APIs). Additionally, Windows security is mentioned alongside X509 certificates in the Transport subsystem, suggesting Windows-first patterns. No explicit Linux/macOS management examples or tools are provided.
Recommendations
- Add references to Azure CLI and REST API management options alongside PowerShell cmdlets.
- Clarify that Service Fabric management can be performed from Linux/macOS using CLI or API tools.
- Provide examples or links for Linux/macOS users to manage Service Fabric clusters.
- Mention Linux security mechanisms (e.g., certificate-based auth) where relevant, not just Windows security.
Service Fabric
Node types and virtual machine scale sets
...les/service-fabric/service-fabric-cluster-nodetypes.md
Medium Priority
View Details â
Detected Bias Types
windows_first
missing_linux_example
Summary
The documentation provides general information about Azure Service Fabric node types and VM scale sets, and includes a JSON snippet for the Service Fabric Virtual Machine extension. While the extension supports both Linux and Windows nodes, the example uses Windows-style paths (e.g., 'D:\\SvcFab') and certificate store names, which are Windows-centric. Additionally, the 'Next steps' section links to PowerShell-based scripts for RDP port and credential changes, without mentioning Linux/SSH equivalents or alternatives. There are no explicit Linux examples or guidance for Linux users, and Windows patterns (RDP, PowerShell) are referenced first or exclusively.
Recommendations
- Provide Linux-specific examples, such as using SSH for remote connection instead of RDP.
- Include Linux file path conventions (e.g., '/var/svcfab') in extension examples.
- Add links or guidance for managing Linux node types (e.g., changing SSH port/user/password) alongside Windows/PowerShell scripts.
- Clarify which steps or scripts are Windows-only and provide Linux alternatives where possible.
- Mention Linux certificate store handling if relevant.
Medium Priority
View Details â
Detected Bias Types
windows_first
powershell_heavy
Summary
The documentation page focuses primarily on deploying custom Windows images in Service Fabric Managed Clusters, with Windows terminology and PowerShell examples presented. While it references Linux custom image creation and Azure CLI for browsing marketplace images, the main narrative and examples are Windows-centric, and the PowerShell command is given without a Linux CLI equivalent.
Recommendations
- Add explicit examples and guidance for deploying Linux custom images in Service Fabric Managed Clusters, including ARM template snippets for Linux node types.
- Provide Azure CLI or Bash equivalents for role assignment and other operations currently shown only in PowerShell.
- Clarify in the introduction that both Windows and Linux images are supported, and highlight any differences or limitations.
- Ensure links to Linux documentation are as prominent as Windows links, and avoid Windows-first language unless the feature is Windows-only.
Service Fabric
On-demand backup in Azure Service Fabric
...ps://github.com/MicrosoftDocs/azure-compute-docs/blob/main/articles/service-fabric/service-fabric-backup-restore-service-ondemand-backup.md
Medium Priority
View Details â
Detected Bias Types
powershell_heavy
windows_first
missing_linux_example
Summary
The documentation page for on-demand backup in Azure Service Fabric exclusively provides PowerShell-based examples and instructions, including module installation and REST API calls via PowerShell. There are no examples or guidance for Linux/macOS users (e.g., Bash, curl, Azure CLI), and Windows/PowerShell tools are mentioned first and exclusively throughout. This creates friction for non-Windows users, though REST APIs are referenced and could be used from other platforms.
Recommendations
- Add equivalent Bash/curl examples for REST API calls, showing how Linux/macOS users can trigger backups and track progress.
- Mention Azure CLI commands if available for Service Fabric backup operations.
- Clarify that the Microsoft.ServiceFabric.Powershell.Http module is Windows-only, and provide alternative instructions for Linux/macOS users (e.g., using REST APIs directly).
- Reorganize sections to present cross-platform approaches (REST API, Azure CLI) before or alongside PowerShell examples.
- Explicitly state platform requirements for each tool or command.
Service Fabric
Cluster Resource Manager - Management Integration
...fabric-cluster-resource-manager-management-integration.md
Medium Priority
View Details â
Detected Bias Types
powershell_heavy
windows_first
Summary
The documentation provides a PowerShell example for querying partition health, using the Get-ServiceFabricPartitionHealth cmdlet with a Windows-style prompt. No equivalent Linux or cross-platform CLI example is given. The example and command syntax are Windows-centric, potentially creating friction for Linux/macOS users who may use Service Fabric CLI or REST APIs instead. The rest of the documentation is generally platform-neutral, but the example section is notably Windows-focused.
Recommendations
- Add equivalent examples using Service Fabric CLI (sfctl) for Linux/macOS users.
- Mention REST API options for querying health, which are platform-agnostic.
- Clarify that PowerShell is one option, and provide links or references to cross-platform tools.
- Where possible, show both Windows and Linux command examples side-by-side.
Service Fabric
Learn more about Azure Service Fabric
...icles/service-fabric/service-fabric-content-roadmap.md
Medium Priority
View Details â
Detected Bias Types
windows_first
windows_tools
powershell_heavy
missing_linux_example
Summary
The documentation provides a broad overview of Azure Service Fabric, which supports both Windows and Linux. However, there is a notable Windows bias: Windows-specific tools (e.g., PowerShell, Visual Studio) are mentioned first or exclusively in several sections, and Windows terminology (e.g., Windows service, FabricHost.exe) is used without always clarifying Linux equivalents. Some examples and links focus on Windows clusters, and Linux standalone clusters are explicitly noted as unsupported. CLI tools are mentioned, but PowerShell is often listed first. There are few explicit Linux examples or instructions, and Linux tools (e.g., Bash, Linux-specific CLI usage) are not highlighted.
Recommendations
- Ensure that examples and instructions for cluster creation, management, and health monitoring are provided for both Windows and Linux, with Linux examples shown alongside or before Windows ones where possible.
- Clarify when features or instructions are Windows-only, and provide Linux alternatives or note limitations.
- Mention Linux tools (e.g., Bash, Linux CLI usage) and provide sample commands for Linux users.
- Balance the order of tool mentions (e.g., list CLI and PowerShell together, or mention CLI first for cross-platform parity).
- Add links and references to Linux-specific documentation and guides where available.
- Explicitly state feature parity or differences, and link to the 'Differences between Service Fabric on Linux and Windows' page earlier in the document.
Service Fabric
Azure Service Fabric hosting model
...rticles/service-fabric/service-fabric-hosting-model.md
Medium Priority
View Details â
Detected Bias Types
powershell_heavy
windows_tools
missing_linux_example
Summary
The documentation provides command-line examples only in PowerShell, references PowerShell cmdlets for management tasks, and does not mention or provide examples for Linux/macOS CLI tools (such as sfctl) or Bash equivalents. This creates friction for Linux/macOS users, who must translate PowerShell commands or seek alternative tooling.
Recommendations
- Add equivalent examples using sfctl (the cross-platform Service Fabric CLI) for all PowerShell command examples, especially for service creation and management.
- Mention sfctl as a supported tool for Linux/macOS users alongside PowerShell.
- Where possible, provide Bash or generic REST API examples in addition to PowerShell.
- Clarify in the 'Next steps' and other sections that PowerShell is not the only supported management tool, and link to Linux/macOS-friendly documentation.
Service Fabric
Manage apps for multiple environments
...e-fabric-manage-multiple-environment-app-configuration.md
Medium Priority
View Details â
Detected Bias Types
powershell_heavy
windows_first
missing_linux_example
Summary
The documentation page presents Windows/PowerShell examples first and in more detail, with explicit mention of PowerShell cmdlets and Visual Studio workflows. Linux tooling (sfctl, install.sh) is mentioned, but lacks example commands or detailed guidance. There are no explicit Linux/macOS shell examples or parity in walkthroughs, creating friction for non-Windows users.
Recommendations
- Add explicit Linux/macOS shell examples for parameter passing, e.g., using sfctl and install.sh.
- Provide sample scripts or command lines for Linux environments alongside PowerShell examples.
- Ensure Visual Studio/PowerShell workflows are matched with CLI-based workflows suitable for Linux/macOS users.
- Clarify which tools are cross-platform and which are Windows-only, to help users choose the right workflow.
Service Fabric
Upgrading Azure Service Fabric clusters
...icles/service-fabric/service-fabric-cluster-upgrade.md
Medium Priority
View Details â
Detected Bias Types
windows_first
windows_tools
Summary
The documentation provides general guidance for upgrading Azure Service Fabric clusters, but there are subtle signs of Windows bias. For example, when discussing OS image upgrades, the only linked guidance is for patching Windows operating systems. Additionally, references to PowerShell are made before Azure CLI, and no explicit Linux-specific examples or guidance are provided. However, most instructions are platform-agnostic and do not prevent Linux/macOS users from completing the tasks.
Recommendations
- Add links and guidance for patching/upgrading Linux-based Service Fabric clusters, if supported.
- When mentioning PowerShell, always mention Azure CLI alongside it, and provide CLI examples where possible.
- Ensure that references to tools and examples are presented in a platform-neutral order (e.g., 'Azure CLI/PowerShell' instead of 'PowerShell/Azure CLI').
- Clarify if certain features (like Patch Orchestration Application) are Windows-only, and provide Linux alternatives or explicitly state limitations.
Virtual Machine Scale Sets
Migrate deployments and resources to Virtual Machine Scale Sets in Flexible orchestration
...lexible-virtual-machine-scale-sets-migration-resources.md
Medium Priority
View Details â
Detected Bias Types
windows_first
powershell_heavy
missing_linux_example
Summary
The documentation mentions Azure CLI, Azure PowerShell, and ARM Template as options for creating Virtual Machine Scale Sets, but does not provide explicit Linux/bash examples or clarify parity between PowerShell and CLI usage. Windows-specific scenarios (activation, updates) are listed before Linux equivalents, and PowerShell is referenced alongside CLI without clear Linux guidance. No Linux/macOS-specific migration steps or examples are provided.
Recommendations
- Provide explicit bash/Azure CLI examples for key operations, such as creating scale sets and migrating VMs.
- Clarify that Azure CLI is cross-platform and provide Linux/macOS usage guidance where PowerShell is mentioned.
- List Linux scenarios (e.g., package manager access) alongside Windows scenarios, not after them.
- Add sample migration scripts or commands for Linux users, including handling disks, NICs, and VM creation.
- Ensure that references to tools (CLI, PowerShell) are balanced and that Linux/macOS users are not required to use Windows tools.
Service Fabric
Specifying Service Fabric service endpoints
...ce-fabric/service-fabric-service-manifest-resources.md
Medium Priority
View Details â
Detected Bias Types
powershell_heavy
windows_tools
windows_first
Summary
The documentation provides several PowerShell-based deployment examples (e.g., New-ServiceFabricApplication) and references to Windows file paths and certificate stores (e.g., C:\Program Files\..., X509StoreName="MY"). While there is a brief note about Linux certificate storage, Linux/macOS equivalents for deployment commands and tooling are missing. Windows tools and patterns are mentioned first and most prominently.
Recommendations
- Add equivalent Linux/macOS deployment examples using Azure CLI or sfctl where possible.
- When referencing file paths or certificate stores, provide both Windows and Linux equivalents in the main text, not just in notes.
- Include a section or callout for Linux/macOS users describing any differences in workflow, especially for certificate management and application deployment.
- When showing PowerShell commands, provide bash/shell alternatives if supported.
Service Fabric
Manage certificates in a Service Fabric cluster
...vice-fabric/cluster-security-certificate-management.md
Medium Priority
View Details â
Detected Bias Types
powershell_heavy
windows_tools
windows_first
Summary
The documentation provides a comprehensive overview of certificate management in Azure Service Fabric clusters, but it exhibits Windows bias in several areas. PowerShell is the only scripting example provided for programmatic certificate enrollment, and references to Windows-specific tools and concepts (such as certificate stores, ACLing, S-channel, and Key Vault VM extension for Windows) are frequent and often precede or exclude Linux equivalents. The Key Vault VM extension is described primarily in its Windows context, and there is no mention of Linux-specific certificate provisioning mechanisms or examples. While the JSON ARM templates are cross-platform, operational guidance and troubleshooting are Windows-centric.
Recommendations
- Add Linux-specific examples for certificate provisioning and management, such as using Azure CLI or Bash scripts instead of only PowerShell.
- Document the Key Vault VM extension for Linux, including its schema, behaviors, and any differences from the Windows extension.
- Provide guidance for certificate store locations and access control on Linux nodes, including how Service Fabric handles certificates on Linux.
- Include troubleshooting steps and FAQ entries relevant to Linux environments.
- Ensure that scripting and automation examples are available in both PowerShell and Bash/Azure CLI.
- Clarify which features or steps are Windows-only and provide Linux alternatives where possible.
Service Fabric
Configure or modify a Service Fabric managed cluster node type
...vice-fabric/how-to-managed-cluster-modify-node-type.md
Medium Priority
View Details â
Detected Bias Types
powershell_heavy
missing_linux_example
windows_first
Summary
The documentation provides examples for configuring Service Fabric managed cluster node types using Azure Portal, ARM templates, and PowerShell. PowerShell is the only CLI example provided, with no mention of Azure CLI or Bash alternatives. This creates friction for Linux/macOS users, as PowerShell is primarily a Windows tool and not natively available on all platforms. Additionally, PowerShell examples are consistently given, and no Linux-specific tools or workflows are referenced. The ordering often presents Portal and PowerShell before ARM templates, and there are no explicit Linux/macOS parity notes.
Recommendations
- Add Azure CLI examples alongside PowerShell for all relevant operations (add, remove, scale, configure placement properties, etc.).
- Explicitly mention that ARM templates and Portal are cross-platform and suitable for Linux/macOS users.
- Where PowerShell is referenced, note that PowerShell Core is available cross-platform, but Azure CLI is often preferred for Linux/macOS.
- Consider providing Bash script snippets for ARM template deployments.
- Clarify any limitations or parity gaps for Linux/macOS users.
Service Fabric
Monitor Azure Service Fabric
...main/articles/service-fabric/monitor-service-fabric.md
Medium Priority
View Details â
Detected Bias Types
windows_first
windows_tools
missing_linux_example
Summary
The documentation provides monitoring guidance for Azure Service Fabric clusters on both Windows and Linux, but several sections and examples prioritize Windows tools and terminology. Windows-specific tools (e.g., EventStore APIs, Diagnostics Agent, Event Viewer) are mentioned before Linux equivalents, and some features (like EventStore APIs) are noted as Windows-only without clear Linux alternatives or guidance. Linux monitoring is referenced but often lacks detailed examples or step-by-step parity with Windows instructions.
Recommendations
- Ensure Linux monitoring tools and workflows are described with equal detail and prominence as Windows equivalents.
- Add Linux-specific examples for configuring and querying Service Fabric events, logs, and performance counters, especially where Windows tools (e.g., Event Viewer, Diagnostics Agent) are referenced.
- Where features are Windows-only (e.g., EventStore APIs), provide clear Linux alternatives or guidance, or explicitly state the limitation and recommend best practices for Linux users.
- Review tutorials and linked resources to ensure Linux users can follow along and complete monitoring tasks without friction.
- Consider adding a comparative table or section summarizing monitoring approaches and tools for both Windows and Linux clusters.
Service Fabric
X.509 Certificate-based Authentication in a Service Fabric Cluster
...ticles/service-fabric/cluster-security-certificates.md
Medium Priority
View Details â
Detected Bias Types
windows_first
windows_tools
powershell_heavy
Summary
The documentation generally describes Service Fabric's X.509 certificate authentication in a cross-platform manner, but there are several areas where Windows-specific terminology, tools, and patterns are prioritized or mentioned first. Windows certificate store paths and Win32 CryptoAPI are referenced before or instead of Linux equivalents. Troubleshooting guidance and event log locations are Windows-centric, and PowerShell/C++ error codes are used without Linux-specific alternatives or guidance.
Recommendations
- When referencing certificate stores, always mention both Windows and Linux paths together (e.g., 'LocalMachine\My' (Windows) or '/var/lib/sfcerts' (Linux)).
- For troubleshooting, provide Linux equivalents for event log locations and diagnostic steps (e.g., journalctl, syslog, or Service Fabric log file locations on Linux nodes).
- When discussing API calls (like Win32 CryptoAPI), clarify the Linux equivalent or note how the functionality is implemented/can be debugged on Linux.
- Include Linux-specific error messages or troubleshooting steps alongside Windows error codes.
- If PowerShell or Windows tools are referenced, provide Linux CLI or script alternatives (e.g., OpenSSL commands for certificate inspection).
Service Fabric
Service Fabric Explorer blocking operations
...ged-cluster-service-fabric-explorer-blocking-operation.md
Medium Priority
View Details â
Detected Bias Types
powershell_heavy
windows_first
missing_linux_example
Summary
The documentation page predominantly references Az PowerShell cmdlets (e.g., Remove-AzResource, AzSF PowerShell cmdlets) for managing Service Fabric resources, with no explicit mention or examples of equivalent Azure CLI commands or Linux/macOS workflows. While 'az resource' is briefly mentioned for deleting applications, the majority of guidance and links are PowerShell-focused, which may create friction for Linux/macOS users who rely on Azure CLI.
Recommendations
- Provide equivalent Azure CLI commands alongside PowerShell cmdlets for all management operations (e.g., creating and deleting applications, services, and application type versions).
- Clarify when Az PowerShell cmdlets are required versus when Azure CLI can be used, and note any platform limitations.
- Include example commands for both Windows (PowerShell) and Linux/macOS (Azure CLI) users in each relevant section.
- Link to Azure CLI documentation where appropriate, not just PowerShell modules.
Service Fabric
RunToCompletion semantics and specifications
...blob/main/articles/service-fabric/run-to-completion.md
Medium Priority
View Details â
Detected Bias Types
windows_first
powershell_heavy
windows_tools
missing_linux_example
Summary
The documentation page presents RunToCompletion semantics in Service Fabric with a strong Windows bias. All code examples use Windows containers (nanoserver), Windows-specific commands (cmd, echo, ping, set), and Windows container images. Querying deployment status is described only via PowerShell and C# APIs, with no mention of Linux tools or cross-platform alternatives. There are no examples or guidance for Linux containers or Linux-based workflows, despite Service Fabric supporting Linux containers.
Recommendations
- Add equivalent Linux container examples using popular Linux base images (e.g., Ubuntu, Alpine) and shell commands (bash, echo, ping, etc.).
- Provide guidance or examples for querying deployment status using Linux tools or cross-platform CLI (e.g., Azure CLI, sfctl).
- Clarify which aspects are Windows-specific and which are cross-platform, to help Linux/macOS users understand applicability.
- Consider including a section or links for Linux container application development with RunToCompletion semantics.
Service Fabric
Azure Service Fabric infrastructure as Code Best Practices
...tps://github.com/MicrosoftDocs/azure-compute-docs/blob/main/articles/service-fabric/service-fabric-best-practices-infrastructure-as-code.md
Medium Priority
View Details â
Detected Bias Types
powershell_heavy
windows_tools
windows_first
Summary
The documentation provides both Azure CLI and PowerShell examples for deploying Service Fabric clusters, but PowerShell is featured prominently and exclusively for several critical operations (e.g., manual cluster upgrade). Windows-specific tools and registry settings are discussed without Linux equivalents or alternatives. Windows configuration properties are shown before any mention of Linux, and some upgrade instructions are Windows-centric.
Recommendations
- Include Linux-specific instructions and examples for manual cluster upgrades, such as using Bash scripts or Linux-native tools.
- Provide equivalent Linux configuration guidance for disabling automatic updates and managing upgrades, or clarify if/when these steps are not needed on Linux.
- Balance PowerShell and CLI examples throughout, ensuring that Linux users have clear, actionable steps for all major operations.
- Explicitly note when a step is Windows-only, and provide links or references to Linux documentation where appropriate.
Service Fabric
Describing Azure Service Fabric apps and services
...ic/service-fabric-application-and-service-manifests.md
Medium Priority
View Details â
Detected Bias Types
windows_first
powershell_heavy
windows_tools
Summary
The documentation page primarily describes Service Fabric application and service manifests, which are cross-platform concepts. However, there are signs of Windows bias: the only tooling example given for validating XML schema is Visual Studio with a Windows file path, and the only explicit mention of command-line tooling for service creation is PowerShell. No Linux/macOS equivalents (such as VS Code, xmllint, or Azure CLI) are mentioned, nor are cross-platform file paths or tools provided. Windows-specific tools and patterns are referenced first and exclusively.
Recommendations
- Add examples and instructions for validating XML manifests using cross-platform tools (e.g., VS Code, xmllint, or other editors) and reference Linux/macOS file paths.
- Include Azure CLI or REST API examples for service creation and management, not just PowerShell.
- Mention cross-platform approaches for editing and validating manifests, such as using VS Code extensions or command-line utilities.
- Clarify that Service Fabric can be used on Linux and provide links or notes for Linux-specific guidance where relevant.
Service Fabric
Learn about Azure Service Fabric application security
...ric/service-fabric-application-and-service-security.md
Medium Priority
View Details â
Detected Bias Types
windows_first
missing_linux_example
windows_tools
Summary
The documentation provides a general overview of Service Fabric application security, but several sections show Windows bias. Windows-specific features (e.g., Active Directory, gMSA, BitLocker) are mentioned before Linux equivalents or without Linux parity. Some examples and links focus on Windows scenarios (e.g., disk encryption via PowerShell, running services as AD users), while Linux-specific guidance is minimal or missing. The section on encrypting disks references BitLocker and PowerShell for Windows, with only a TODO for Linux disk encryption.
Recommendations
- Add explicit Linux examples for disk encryption, such as using Azure Disk Encryption with Linux or dm-crypt/LUKS.
- Provide parity for service account management on Linux clusters, including guidance for Linux user/group configuration.
- Ensure container certificate access examples cover both Windows and Linux clusters with clear instructions.
- Where Windows-specific tools (e.g., PowerShell, BitLocker, gMSA) are mentioned, add or link to Linux alternatives and clarify platform applicability.
- Review 'Next steps' links to ensure Linux users are not directed only to Windows-centric content.
Service Fabric
Application upgrade: upgrade parameters
...abric/service-fabric-application-upgrade-parameters.md
Medium Priority
View Details â
Detected Bias Types
windows_first
powershell_heavy
windows_tools
Summary
The documentation page presents PowerShell and Visual Studio (Windows-centric tools) parameters and workflows first and in greater detail, with Linux/macOS (SFCTL/CLI) options covered later and less prominently. Most parameter tables and examples are focused on PowerShell and Visual Studio, with SFCTL (the cross-platform CLI) described in a separate, shorter section. There are no explicit Linux/macOS command-line examples or screenshots, and the PowerShell/Visual Studio workflow dominates the narrative.
Recommendations
- Reorder sections or provide parallel sections so that SFCTL (Service Fabric CLI) parameters and workflows are presented alongside PowerShell/Visual Studio, not after them.
- Add explicit SFCTL command-line examples for common upgrade scenarios, similar to the PowerShell examples.
- Clarify in the introduction that SFCTL is the recommended cross-platform tool for Linux/macOS users.
- Where parameter tables are shown, include a column for SFCTL equivalents, or provide a unified table indicating which parameters apply to which tool.
- Add Linux/macOS-specific notes or screenshots where appropriate.
- Ensure that links to Linux/macOS upgrade tutorials are as prominent as those for PowerShell/Visual Studio.
Service Fabric
Restoring backup in Azure Service Fabric
...ps://github.com/MicrosoftDocs/azure-compute-docs/blob/main/articles/service-fabric/service-fabric-backup-restore-service-trigger-restore.md
Medium Priority
View Details â
Detected Bias Types
powershell_heavy
missing_linux_example
windows_tools
Summary
The documentation page for restoring backups in Azure Service Fabric is heavily biased towards Windows/PowerShell usage. All code examples are provided exclusively in PowerShell, and the prerequisite steps require installation of a PowerShell module (Microsoft.ServiceFabric.Powershell.Http). There are no examples or guidance for Linux/macOS users, such as using Azure CLI, curl, or other cross-platform tools to interact with the REST APIs. The documentation assumes the reader is using Windows and PowerShell, creating friction for Linux/macOS users who may need to restore backups in Service Fabric clusters.
Recommendations
- Add equivalent examples using Azure CLI, curl, or other cross-platform tools for REST API calls.
- Document how to authenticate and make REST API calls from Linux/macOS environments, including certificate handling.
- Clarify whether the PowerShell module is required for all scenarios, or if REST API calls can be made directly from any platform.
- Provide sample scripts or commands for Linux/macOS users to trigger restores and track progress.
- Mention any limitations or requirements for Linux/macOS users explicitly.
Service Fabric
Application lifecycle in Service Fabric
...service-fabric/service-fabric-application-lifecycle.md
Medium Priority
View Details â
Detected Bias Types
powershell_heavy
windows_tools
windows_first
Summary
The documentation page frequently references PowerShell cmdlets and Windows-centric tooling (e.g., Register-ServiceFabricApplicationType, Remove-ServiceFabricApplicationPackage) alongside .NET APIs and REST operations. PowerShell examples are consistently provided, but Linux equivalents (such as Azure CLI or sfctl) are not explicitly shown or described. The page mentions the Service Fabric CLI (sfctl) in an include, but does not provide concrete examples or parity for Linux/macOS users. Windows tools and patterns are often mentioned first or exclusively, creating friction for non-Windows users.
Recommendations
- Add explicit examples using sfctl (Service Fabric CLI) and Azure CLI for each lifecycle operation, alongside PowerShell and .NET API references.
- Where PowerShell cmdlets are mentioned, provide the equivalent sfctl or Azure CLI command and link to relevant documentation.
- Clarify which tools are cross-platform and which are Windows-only, to help Linux/macOS users navigate the options.
- Consider reordering examples so that cross-platform tools (sfctl, REST API, Azure CLI) are presented before or alongside Windows-specific tools.
- Add a section summarizing tool parity and supported platforms for Service Fabric management.
Service Fabric
Advanced Application Upgrade Topics
...-fabric/service-fabric-application-upgrade-advanced.md
Medium Priority
View Details â
Detected Bias Types
powershell_heavy
windows_first
missing_linux_example
Summary
The documentation page for advanced Service Fabric application upgrade topics heavily relies on PowerShell cmdlets for examples and guidance, with no mention of Linux/macOS equivalents or cross-platform CLI tools. All command-line examples use PowerShell syntax, and references to tooling (such as Visual Studio) are Windows-centric. There is no discussion of Linux-compatible approaches (e.g., Azure CLI, REST API, or sfctl), nor are Linux/macOS users provided with alternative instructions or examples.
Recommendations
- Add examples using sfctl (Service Fabric CLI), which is cross-platform and supported on Linux/macOS.
- Mention and provide examples for Azure CLI or REST API where applicable.
- Clarify which PowerShell cmdlets are available cross-platform (PowerShell Core) and which are Windows-only.
- Include notes or links for Linux/macOS users on how to perform equivalent operations.
- Reorder sections or examples so that Windows and Linux approaches are presented equally, or explicitly state if a feature is Windows-only.
Service Fabric
Service Fabric application upgrade
...s/service-fabric/service-fabric-application-upgrade.md
Medium Priority
View Details â
Detected Bias Types
powershell_heavy
windows_tools
missing_linux_example
windows_first
Summary
The documentation demonstrates a notable Windows bias. PowerShell is used exclusively for command-line examples, and only PowerShell cmdlets (e.g., Get-ServiceFabricApplication, Start-ServiceFabricApplicationUpgrade) are shown for performing upgrades. There are no equivalent examples or guidance for Linux/macOS users (e.g., using sfctl or REST APIs). Windows-specific tools and APIs (http.sys, PowerShell) are referenced without mention of cross-platform alternatives. This creates friction for Linux users, who must translate the instructions themselves.
Recommendations
- Add equivalent examples using sfctl (the Service Fabric CLI, which is cross-platform) for all PowerShell command examples.
- Where PowerShell cmdlets are referenced, also mention or link to REST API documentation or sfctl equivalents.
- Clarify which features or commands are Windows-only, and provide Linux/macOS alternatives where possible.
- In sections referencing Windows-specific components (e.g., http.sys), note the Linux/macOS behavior or limitations.
- Reorder examples or provide parallel examples so that Linux/macOS users are not always second-class.
Service Fabric
Capacity planning and scaling for Azure Service Fabric
...bric/service-fabric-best-practices-capacity-scaling.md
Medium Priority
View Details â
Detected Bias Types
powershell_heavy
windows_first
Summary
The documentation page provides several manual scaling instructions using PowerShell cmdlets (e.g., Disable-ServiceFabricNode, Get-ServiceFabricNode, Remove-ServiceFabricNodeState) without mentioning Linux equivalents or cross-platform alternatives. PowerShell is referenced as the primary tool for cluster operations, and Windows-centric tooling is presented first. While Service Fabric supports Linux clusters, the guidance for scaling operations is heavily oriented toward Windows/PowerShell users, creating friction for Linux users who may need to find their own methods or tools.
Recommendations
- Add equivalent Linux instructions for manual scaling, such as using Service Fabric CLI (sfctl) or REST API calls.
- Explicitly mention cross-platform tools and provide examples for both Windows (PowerShell) and Linux (sfctl/REST).
- Clarify which steps are universal and which are platform-specific, and link to platform-specific guides where appropriate.
- Consider providing bash shell examples alongside PowerShell examples for parity.
Service Fabric
Change Azure Service Fabric cluster settings
...rvice-fabric/service-fabric-cluster-fabric-settings.md
Medium Priority
View Details â
Detected Bias Types
windows_first
windows_tools
Summary
The documentation provides a comprehensive reference for Service Fabric cluster settings, covering both Azure-hosted and standalone clusters. However, there is evidence of Windows bias: Windows terminology and tools (such as certificate store names like 'MY', 'LocalMachine', and references to NTLM authentication) are used throughout, often without explicit Linux equivalents or clarifications. Windows-specific features (e.g., Windows Update, NTLM, log file paths) are mentioned, sometimes without clear Linux alternatives. In some cases, Windows defaults are listed first or exclusively, even for settings that are cross-platform.
Recommendations
- Where certificate store names or authentication mechanisms are mentioned (e.g., 'MY', 'LocalMachine', NTLM), clarify Linux equivalents or note differences in Linux deployments.
- For parameters with Windows-only defaults (e.g., ContainerNetworkSetup, log file settings), explicitly state Linux defaults and behaviors.
- Add notes or examples for Linux-specific configuration where relevant (e.g., file paths, certificate storage, authentication).
- Review guidance text for implicit Windows assumptions and add Linux/macOS parity notes.
- Consider adding a summary table or section highlighting which settings are platform-specific and which are cross-platform.
Service Fabric
Service Fabric Cluster Resource Manager - Application Groups
...ice-fabric-cluster-resource-manager-application-groups.md
Medium Priority
View Details â
Detected Bias Types
powershell_heavy
missing_linux_example
windows_tools
Summary
The documentation page provides only PowerShell and C# examples for managing Service Fabric Application Groups, with no mention of Linux-compatible CLI tools or examples. PowerShell is a Windows-centric tool, and its exclusive use in the examples creates friction for Linux/macOS users who may use Azure CLI or REST APIs instead. There is no guidance or parity for Linux users, nor are alternative tools or commands referenced.
Recommendations
- Add Azure CLI examples for all operations shown (creation, update, querying, removal) if supported.
- Mention REST API endpoints for managing Application Groups, with example requests.
- Clarify which management operations are possible from Linux/macOS and provide links to relevant cross-platform tools.
- If PowerShell is required, explicitly state its availability on Linux/macOS and provide installation instructions.
- Consider including Bash or shell script examples where applicable.
Service Fabric
Service Fabric Cluster Resource Manager - Placement Policies
...ce-manager-advanced-placement-rules-placement-policies.md
Medium Priority
View Details â
Detected Bias Types
powershell_heavy
windows_first
missing_linux_example
Summary
The documentation consistently provides PowerShell examples for configuring placement policies, but does not include equivalent Linux/macOS CLI (e.g., Azure CLI, Bash, or REST API) examples. PowerShell is primarily used on Windows, and its exclusive presence creates friction for Linux/macOS users. Additionally, PowerShell examples are presented immediately after C# code samples, with no mention of cross-platform alternatives.
Recommendations
- Add Azure CLI examples for each placement policy configuration, as Azure CLI is cross-platform and widely used on Linux/macOS.
- Include REST API or ARM template snippets where applicable, to provide platform-neutral configuration options.
- Explicitly mention that PowerShell examples are Windows-centric, and provide guidance or links for Linux/macOS users.
- Consider reordering examples so that cross-platform options (Azure CLI, REST) are shown before or alongside PowerShell.
Service Fabric
Azure Service Fabric Auto Scaling Services and Containers
...ttps://github.com/MicrosoftDocs/azure-compute-docs/blob/main/articles/service-fabric/service-fabric-cluster-resource-manager-autoscaling.md
Medium Priority
View Details â
Detected Bias Types
powershell_heavy
windows_first
missing_linux_example
Summary
The documentation provides example code for configuring auto scaling policies in Service Fabric using application manifests, C# APIs, and PowerShell. All CLI examples are PowerShell-based, with no equivalent Bash or Linux CLI examples. PowerShell is a Windows-centric tool, and its exclusive use creates friction for Linux/macOS users. The documentation does not mention or demonstrate Linux-native tools or workflows for configuring auto scaling, nor does it clarify how Linux users should perform these tasks. Additionally, PowerShell examples are presented alongside C# and manifest examples, but no Linux-first or cross-platform CLI guidance is given.
Recommendations
- Add Bash or Azure CLI examples for configuring scaling policies, especially for Linux clusters.
- Clarify which steps and tools are supported on Linux and macOS, and provide guidance for Linux users.
- Mention any limitations or differences in auto scaling configuration between Windows and Linux clusters.
- If PowerShell is required, note its availability on Linux and provide installation instructions, or recommend cross-platform alternatives.
Service Fabric
Describe a cluster by using Cluster Resource Manager
...ce-fabric-cluster-resource-manager-cluster-description.md
Medium Priority
View Details â
Detected Bias Types
windows_first
windows_tools
Summary
The documentation provides configuration examples for Service Fabric clusters using both ClusterManifest.xml (with <WindowsServer> element) and ClusterConfig.json, but the XML example is explicitly Windows Server-focused and appears first. PowerShell examples are included for service creation and updates, but there are no Linux shell (bash/CLI) equivalents. The documentation does not mention Linux-specific node configuration or tools, nor does it clarify Linux support for standalone clusters. However, JSON-based configuration is shown, which is cross-platform, and the overall concepts are platform-agnostic.
Recommendations
- Add explicit Linux configuration examples (e.g., using ClusterManifest.xml for Linux, or clarify if only JSON is supported for Linux standalone clusters).
- Include Linux/macOS shell (bash/CLI) equivalents for PowerShell commands, or reference Azure CLI where applicable.
- Clarify platform support for standalone Service Fabric clusters (Windows vs. Linux) and note any limitations.
- If ClusterManifest.xml is only for Windows, state this clearly and provide Linux alternatives.
- Ensure examples and tools are presented in a platform-neutral order, or group them by platform.
Service Fabric
Manage Azure Service Fabric app load using metrics
...ric/service-fabric-cluster-resource-manager-metrics.md
Medium Priority
View Details â
Detected Bias Types
powershell_heavy
windows_first
missing_linux_example
Summary
The documentation provides code examples for managing Service Fabric metrics primarily in C# and PowerShell. PowerShell is a Windows-centric tool, and no equivalent Linux/macOS CLI examples (such as Azure CLI or Bash scripts) are provided. The PowerShell examples are presented alongside C# code, but there is no mention of cross-platform alternatives or guidance for Linux/macOS users. This creates friction for users running Service Fabric clusters on Linux or developing from non-Windows environments.
Recommendations
- Add Azure CLI examples for service creation and metric management, as Azure CLI is cross-platform.
- Include Bash script examples or reference REST API usage for metric operations, which are accessible from any OS.
- Explicitly mention whether PowerShell Core (cross-platform) is supported, and provide guidance for Linux/macOS users if so.
- Clarify any limitations or differences for Service Fabric metric management on Linux clusters.
- Reorder examples so that cross-platform tools (Azure CLI, REST API) are shown before or alongside PowerShell.
Service Fabric
Service Fabric Cluster Resource Manager: Movement cost
...ps://github.com/MicrosoftDocs/azure-compute-docs/blob/main/articles/service-fabric/service-fabric-cluster-resource-manager-movement-cost.md
Medium Priority
View Details â
Detected Bias Types
powershell_heavy
windows_first
missing_linux_example
Summary
The documentation page provides PowerShell and C# examples for configuring Service Fabric movement cost, but does not include equivalent Linux/bash/CLI examples. PowerShell is a Windows-centric tool, and its usage is presented first, which may create friction for Linux/macOS users. There is no mention of Service Fabric CLI or REST API alternatives, nor guidance for Linux-based deployments.
Recommendations
- Add Azure CLI or Service Fabric CLI examples for creating and updating services with move cost, where possible.
- Include bash or shell script snippets for Linux users, or reference REST API documentation for cross-platform usage.
- Clarify whether PowerShell examples are usable on Linux (e.g., via PowerShell Core), or provide explicit guidance for Linux/macOS environments.
- Present examples in a platform-neutral order, or group them by platform to avoid implicit prioritization.
Service Fabric
Service sensitivity
...ttps://github.com/MicrosoftDocs/azure-compute-docs/blob/main/articles/service-fabric/service-fabric-cluster-resource-manager-sensitivity.md
Medium Priority
View Details â
Detected Bias Types
powershell_heavy
windows_first
missing_linux_example
Summary
The documentation provides extensive PowerShell examples for configuring service sensitivity and maximum load, but does not mention or provide equivalent CLI or scripting examples for Linux/macOS users. PowerShell is presented as the primary scripting interface, and there is no reference to Service Fabric CLI (sfctl), Bash, or cross-platform tools. This creates friction for Linux/macOS users who may not have access to PowerShell or prefer native tools.
Recommendations
- Add equivalent examples using Service Fabric CLI (sfctl), which is cross-platform and works on Linux/macOS.
- Explicitly mention that PowerShell examples are for Windows and provide guidance for Linux/macOS users.
- Include Bash or shell script examples where applicable.
- Clarify any platform-specific requirements for the APIs and tools used.
Service Fabric
Secure an Azure Service Fabric cluster
...cles/service-fabric/service-fabric-cluster-security.md
Medium Priority
View Details â
Detected Bias Types
windows_first
windows_tools
missing_linux_example
Summary
The documentation page for securing an Azure Service Fabric cluster demonstrates moderate Windows bias. Windows Server clusters and Windows authentication methods are mentioned prominently and often before Linux equivalents. Several sections, especially those about node-to-node and client-to-node security, provide links and guidance specifically for Windows standalone clusters, with no equivalent guidance for Linux standalone clusters. Windows tools (such as Windows Server certificate service and MakeCert.exe) are referenced for certificate creation, while Linux certificate creation tools are not mentioned. The concept of Linux clusters is acknowledged, but practical instructions and examples for Linux users are missing.
Recommendations
- Add explicit instructions, examples, and links for securing standalone Linux Service Fabric clusters, including certificate setup and authentication methods.
- Mention Linux-compatible certificate creation tools (e.g., OpenSSL) alongside Windows tools like MakeCert.exe.
- Provide parity in guidance for Linux clusters wherever Windows clusters are discussed, especially in node-to-node and client-to-node security sections.
- Clarify which features are cross-platform and which are Windows-only, to reduce ambiguity for Linux users.
Service Fabric
Azure Service Fabric application resource model
...ervice-fabric/service-fabric-concept-resource-model.md
Medium Priority
View Details â
Detected Bias Types
powershell_heavy
windows_tools
missing_linux_example
windows_first
Summary
The documentation page demonstrates notable Windows bias. All deployment and deletion examples use PowerShell cmdlets (New-AzResourceGroupDeployment, Get-AzResource, Remove-AzResource) with no mention of Azure CLI or other cross-platform tools. Application packaging instructions reference Visual Studio, a Windows-centric IDE, and do not provide alternatives for Linux/macOS users. The workflow assumes Windows tools and patterns throughout, with no Linux/macOS parity or guidance.
Recommendations
- Add Azure CLI examples for deployment and resource management alongside PowerShell examples.
- Provide instructions for packaging Service Fabric applications using cross-platform tools (e.g., dotnet CLI, sfctl, or manual zip commands).
- Mention and link to Linux/macOS-compatible development environments (e.g., VS Code) for application packaging.
- Explicitly state which steps are Windows-only and offer Linux/macOS alternatives where possible.
- Show both PowerShell and Azure CLI commands in parallel for resource operations.
Service Fabric
Azure Service Fabric Events
...es/service-fabric/service-fabric-diagnostics-events.md
Medium Priority
View Details â
Detected Bias Types
windows_tools
missing_linux_example
windows_first
Summary
The documentation page on Azure Service Fabric Events primarily references Windows-specific logging mechanisms (ETW/Windows Event logs) and the Windows Azure diagnostics agent. There are no explicit examples or instructions for accessing Service Fabric events on Linux clusters, nor are Linux-native tools or patterns mentioned. Windows tools are discussed first and exclusively, creating friction for Linux users.
Recommendations
- Add explicit guidance for accessing Service Fabric events on Linux clusters, including supported logging mechanisms and monitoring tools.
- Mention Linux-native equivalents (e.g., journald, syslog, or Azure Monitor integration for Linux nodes) alongside Windows tools.
- Clarify which methods are cross-platform and which are Windows-only, to help users understand applicability.
- Provide example workflows or commands for Linux environments where possible.
Service Fabric
Azure Service Fabric dynamic node tags
...tps://github.com/MicrosoftDocs/azure-compute-docs/blob/main/articles/service-fabric/service-fabric-cluster-resource-manager-node-tagging.md
Medium Priority
View Details â
Detected Bias Types
powershell_heavy
missing_linux_example
windows_tools
Summary
The documentation page provides PowerShell examples for managing node tags and service tag requirements, but does not offer equivalent examples for Linux/macOS users (e.g., Bash, CLI, or REST API usage). PowerShell is a Windows-centric tool, and its exclusive use creates friction for non-Windows users. The C# API examples are cross-platform, but operational/administrative tasks are only shown via PowerShell.
Recommendations
- Add Azure CLI or Bash script examples for managing node tags and service tag requirements.
- Include REST API usage examples for tag operations, which are platform-neutral.
- Clearly indicate if PowerShell is required due to Service Fabric limitations, or provide guidance for Linux/macOS users.
- Consider referencing any available cross-platform tools for Service Fabric administration.
Service Fabric
Azure Service Fabric standalone cluster scaling
...ce-fabric/service-fabric-cluster-scaling-standalone.md
Medium Priority
View Details â
Detected Bias Types
powershell_heavy
windows_tools
missing_linux_example
Summary
The documentation page on scaling Azure Service Fabric standalone clusters exhibits Windows bias by referencing PowerShell cmdlets (e.g., Get-ServiceFabricClusterManifest, Start-ServiceFabricClusterConfigurationUpgrade) and linking to guides that are Windows Server-specific. There are no examples or instructions for Linux-based standalone clusters, nor are Linux tools or commands mentioned.
Recommendations
- Add equivalent Linux instructions and examples for scaling standalone clusters, including relevant CLI commands (e.g., sfctl or REST APIs).
- Clarify whether standalone clusters can be run on Linux, and if so, provide guidance for Linux environments.
- Include links to Linux-specific documentation or note any limitations if Linux standalone clusters are not supported.
- When referencing PowerShell or Windows tools, also mention Linux alternatives or explicitly state if the feature is Windows-only.
Service Fabric
Upgrade an Azure Service Fabric standalone cluster
...ce-fabric/service-fabric-cluster-upgrade-standalone.md
Medium Priority
View Details â
Detected Bias Types
windows_first
windows_tools
missing_linux_example
Summary
The documentation page primarily references Windows-specific upgrade paths and tools, such as linking to 'service-fabric-cluster-upgrade-windows-server.md' and 'service-fabric-cluster-config-upgrade-windows-server.md'. The Patch Orchestration Application is described as 'for Windows', with no mention of Linux equivalents or guidance. There are no explicit Linux examples or references, and Windows terminology/tools are mentioned first or exclusively.
Recommendations
- Add explicit guidance or links for upgrading Service Fabric standalone clusters running on Linux, if supported.
- Provide Linux-specific configuration and upgrade documentation, or clarify if Linux standalone clusters are not supported.
- Mention Linux patch orchestration options or clarify their absence.
- Ensure that examples and references are balanced between Windows and Linux, or clearly state platform limitations.
Service Fabric
Scalability of Service Fabric services
.../service-fabric/service-fabric-concepts-scalability.md
Medium Priority
View Details â
Detected Bias Types
powershell_heavy
windows_first
missing_linux_example
Summary
The documentation page provides code examples and administrative patterns primarily using PowerShell, which is a Windows-centric tool. There are no equivalent Linux CLI or bash examples, nor is there mention of Linux-native tools or commands for managing Service Fabric clusters. Windows/PowerShell commands are presented first and exclusively, creating friction for Linux users who may need to translate these steps to their environment.
Recommendations
- Add equivalent Linux CLI/bash examples for Service Fabric administrative actions (e.g., scaling services, creating/deleting services/applications).
- Reference Linux-native tools or commands (such as sfctl or REST API usage) alongside PowerShell examples.
- Explicitly mention cross-platform support and differences, including links to Linux-specific documentation where relevant.
- Present examples for both Windows and Linux platforms, ideally side-by-side, to improve parity and accessibility.
Service Fabric
Package an existing executable to Azure Service Fabric
...abric/service-fabric-guest-executables-introduction.md
Medium Priority
View Details â
Detected Bias Types
windows_tools
windows_first
Summary
The documentation references the Service Fabric SDK schema path using a Windows directory (C:\Program Files\Microsoft SDKs\Service Fabric\schemas\...), and does not mention Linux/macOS equivalents. The overall structure and examples assume a Windows environment, and Visual Studio is mentioned as a primary tool, which is Windows-centric for Service Fabric development. However, the documentation does not explicitly exclude Linux, and Service Fabric does have Linux support.
Recommendations
- Add notes or examples for Linux/macOS users, such as where the Service Fabric SDK schema files are located on those platforms.
- Clarify whether the packaging and deployment steps can be performed on Linux/macOS, and if so, provide equivalent instructions or references.
- When mentioning Visual Studio, also mention cross-platform alternatives (e.g., Visual Studio Code, CLI tools) if available.
- Ensure that file paths and tooling instructions are not Windows-only, or provide both Windows and Linux/macOS variants.
Service Fabric
Networking patterns for Azure Service Fabric
...s/service-fabric/service-fabric-patterns-networking.md
Medium Priority
View Details â
Detected Bias Types
powershell_heavy
missing_linux_example
windows_tools
windows_first
Summary
The documentation demonstrates a notable Windows bias. All deployment and resource management examples use PowerShell cmdlets (e.g., New-AzResourceGroup, Get-AzPublicIpAddress), with no mention of Azure CLI, Bash, or cross-platform alternatives. Even basic network testing is shown with Windows command prompt syntax (e.g., ping from C:\>). There are no Linux/macOS-specific instructions or examples, and PowerShell is presented as the default/only method for template deployment.
Recommendations
- Provide equivalent Azure CLI (az) commands alongside PowerShell for all resource group, deployment, and resource management steps.
- Include Bash shell examples for network testing (e.g., using ping from a Linux/macOS terminal).
- Explicitly state that both PowerShell and Azure CLI can be used, and link to Azure CLI documentation.
- Where possible, use platform-agnostic language and tools in code snippets and instructions.
- Add a note clarifying that the instructions are valid for all platforms, and highlight any platform-specific differences.
Service Fabric
Replica soft delete for enhanced data protection in Service Fabric
...s/service-fabric/service-fabric-replica-soft-delete.md
Medium Priority
View Details â
Detected Bias Types
powershell_heavy
windows_first
missing_linux_example
Summary
The documentation page for 'Replica soft delete for enhanced data protection in Service Fabric' consistently references PowerShell APIs (e.g., Remove-ServiceFabricReplica, Restore-ServiceFabricReplica) and provides examples and links exclusively for PowerShell usage. There is no mention of Linux or macOS command-line equivalents, nor are cross-platform SDK usage patterns (such as .NET Core or REST APIs) highlighted. The documentation assumes familiarity with Windows tooling and does not clarify whether these operations can be performed on Linux clusters or with non-Windows tools.
Recommendations
- Add explicit examples for Linux environments, such as using Service Fabric CLI (sfctl) or REST APIs where applicable.
- Clarify whether the PowerShell APIs are available or supported on Linux/macOS, and provide alternative instructions if not.
- Mention and link to cross-platform SDKs (e.g., .NET Core, Java) for performing replica management operations.
- Include sample commands or code snippets for Linux users, and note any limitations or differences in feature support.
Service Fabric
Azure Service Fabric DNS service
...n/articles/service-fabric/service-fabric-dnsservice.md
Medium Priority
View Details â
Detected Bias Types
powershell_heavy
windows_first
missing_linux_example
Summary
The documentation provides PowerShell examples for setting DNS names, references ApplicationManifest.xml (a Windows-centric deployment artifact), and describes enabling DNS service through the Azure portal (which is not supported for Linux clusters). There are no Linux-specific CLI examples (e.g., Bash, Azure CLI), and Linux limitations are mentioned but not addressed with alternative guidance. Windows tools and patterns are presented first and more completely.
Recommendations
- Add Azure CLI or Bash examples for Linux users to set DNS names and manage services.
- Clarify how Linux users can enable DNS service (e.g., via ARM templates), and provide step-by-step instructions.
- Explicitly note which features are Windows-only and provide Linux alternatives or workarounds where possible.
- Include guidance for containerized services on Linux, since this is the supported scenario.
- Balance example ordering so Linux approaches are not always secondary to Windows/PowerShell.
Service Fabric
Health monitoring in Service Fabric
...s/service-fabric/service-fabric-health-introduction.md
Medium Priority
View Details â
Detected Bias Types
powershell_heavy
missing_linux_example
Summary
The documentation provides a detailed conceptual overview of Service Fabric health monitoring, which is cross-platform in nature. However, the only concrete example given for reporting and evaluating application health uses PowerShell cmdlets, with no equivalent Linux/macOS CLI or REST API example. The documentation mentions REST as a reporting option but does not demonstrate it, and PowerShell is the only example shown. This creates friction for Linux/macOS users who may not have access to PowerShell or prefer other tools.
Recommendations
- Add equivalent examples using Service Fabric CLI (sfctl), which is cross-platform and works on Linux/macOS.
- Provide REST API example for health reporting and querying, as REST is mentioned as an option.
- Clarify that PowerShell is Windows-specific and suggest alternatives for Linux/macOS users.
- Consider showing CLI or REST examples before or alongside PowerShell examples to improve parity.
Service Fabric
Azure Service Fabric hosting activation and deactivation life cycle
...les/service-fabric/service-fabric-hosting-lifecycle.md
Medium Priority
View Details â
Detected Bias Types
powershell_heavy
windows_first
Summary
The documentation page is largely platform-neutral in its conceptual explanations, but the 'Next steps' section and one example link reference PowerShell, which is primarily a Windows tool. There are no explicit Linux/macOS command examples or references to Linux-native tools for deploying or managing Service Fabric applications. The link for downloading a ServicePackage in advance points to a PowerShell cmdlet, and the 'Deploy and remove applications' link is also PowerShell-focused, suggesting Windows as the primary platform for operational tasks.
Recommendations
- Add equivalent Linux/macOS instructions or links for deploying and managing Service Fabric applications, such as using Azure CLI, REST API, or Service Fabric CLI (sfctl).
- Where PowerShell is referenced, clarify if cross-platform PowerShell Core is supported, or provide alternative commands for Linux/macOS users.
- Include examples or links for Linux-native tools and workflows, ensuring parity in operational guidance.
- Explicitly state platform requirements or limitations where relevant, so users know if a task is Windows-only.
Service Fabric
Azure Service Fabric image store connection string
...fabric/service-fabric-image-store-connection-string.md
Medium Priority
View Details â
Detected Bias Types
powershell_heavy
windows_first
missing_linux_example
Summary
The documentation page for the Azure Service Fabric image store connection string shows a moderate Windows/PowerShell bias. It references PowerShell as the primary method for retrieving the cluster manifest and links to a PowerShell-based deployment guide as the next step. There is no mention of Linux/macOS command-line tools (such as Azure CLI, Bash, or cross-platform SDKs) for these tasks, nor are there examples or guidance for non-Windows environments. The documentation assumes Visual Studio usage for publishing, which is also Windows-centric.
Recommendations
- Add examples or references for retrieving the cluster manifest using cross-platform tools such as Azure CLI or Bash scripts.
- Include guidance or links for deploying applications to Service Fabric clusters from Linux/macOS environments, such as using Azure CLI, REST API, or cross-platform SDKs.
- When referencing PowerShell, clarify if the instructions are applicable to PowerShell Core (which is cross-platform) or only to Windows PowerShell.
- Provide parity in 'Next steps' by including links to non-Windows deployment guides or documentation.
Service Fabric
Azure Service Fabric container application manifest examples
...abric/service-fabric-manifest-example-container-app.md
Medium Priority
View Details â
Detected Bias Types
windows_first
missing_linux_example
Summary
The documentation page exhibits a Windows-first bias. The manifest examples and explanations are based on the 'Windows Server 2016 Container Sample', and references to OS-specific behaviors (such as using 'winver' to get the build version) are Windows-centric. There are no explicit Linux container examples, nor are Linux-specific patterns or commands shown. While some notes mention Linux (e.g., certificate handling), the overall guidance and sample manifests do not provide parity for Linux container deployments on Service Fabric.
Recommendations
- Add equivalent Linux container manifest examples, referencing Linux-based images and configuration differences.
- Include instructions or notes for obtaining Linux OS build/version information relevant to Service Fabric container compatibility.
- Clarify which manifest elements or features differ between Windows and Linux container deployments.
- Where features are cross-platform, provide both Windows and Linux sample values, paths, and commands.
- Link to Linux container samples in the Azure-Samples repository if available.
Service Fabric
Service communication with the ASP.NET Core
...vice-fabric-reliable-services-communication-aspnetcore.md
Medium Priority
View Details â
Detected Bias Types
windows_tools
windows_first
missing_linux_example
Summary
The documentation covers both Windows-only (HTTP.sys) and cross-platform (Kestrel) web servers for ASP.NET Core in Service Fabric. However, Windows-specific tools (HTTP.sys, netsh) and patterns are discussed in detail, often before their Linux equivalents. There are explicit notes about HTTP.sys being Windows-only, but Linux-specific guidance and examples are limited. Kestrel, the cross-platform option, is recommended for Linux, but Linux-specific configuration, troubleshooting, or parity notes are missing.
Recommendations
- Add explicit Linux/macOS guidance for Service Fabric scenarios, including any OS-specific configuration steps or troubleshooting.
- Provide Linux/macOS-specific examples (e.g., file paths, firewall configuration, certificate management for HTTPS with Kestrel).
- Clarify any limitations or differences for Service Fabric on Linux (e.g., port assignment, endpoint configuration, cluster setup).
- Mention Linux tools or commands where Windows tools (like netsh) are referenced.
- Ensure parity in example ordering: present Kestrel (cross-platform) before HTTP.sys (Windows-only) in relevant sections.
Service Fabric
Add custom Service Fabric health reports
...rticles/service-fabric/service-fabric-report-health.md
Medium Priority
View Details â
Detected Bias Types
powershell_heavy
windows_first
missing_linux_example
Summary
The documentation page provides detailed examples for reporting health in Service Fabric using PowerShell and .NET APIs, but all PowerShell examples are Windows-centric and there are no equivalent Linux/bash CLI examples. PowerShell is presented as a primary method for interacting with Service Fabric, with no mention of cross-platform alternatives like Azure CLI or Bash scripts. The REST API is mentioned but not demonstrated with a concrete example. This creates friction for Linux/macOS users, who cannot use PowerShell natively and are left without clear guidance for their platforms.
Recommendations
- Add equivalent examples using Azure CLI or Bash scripts for health reporting tasks, especially where PowerShell is used.
- Explicitly mention cross-platform tools and how Linux/macOS users can perform the same operations.
- Provide concrete REST API examples (with curl or HTTPie) for health reporting, including sample request bodies and endpoints.
- Clarify which Service Fabric management tasks can be performed using Azure CLI or REST, and link to relevant cross-platform documentation.
Service Fabric
Define Service Configuration in StartupServices.xml for a Service Fabric Application
...service-fabric/service-fabric-startupservices-model.md
Medium Priority
View Details â
Detected Bias Types
windows_first
missing_linux_example
Summary
The documentation is heavily oriented toward Visual Studio workflows, referencing Windows-specific actions (Build/Rebuild/F5/Ctrl+F5/Publish) and UI elements. It does not provide equivalent guidance or examples for Linux/macOS users, nor does it mention cross-platform tooling or alternative approaches outside Visual Studio. The only mention of command-line deployment refers to PowerShell cmdlets, with no Linux CLI or Azure CLI examples.
Recommendations
- Add explicit guidance for Linux/macOS users, including how to manage StartupServices.xml and ApplicationManifest.xml outside Visual Studio.
- Provide examples using Azure CLI or Service Fabric CLI (sfctl) for deployment and configuration, not just PowerShell.
- Clarify whether StartupServices.xml is supported or relevant for non-Windows development environments, and if not, state this clearly.
- Mention alternative editors or workflows for editing XML files and deploying Service Fabric applications on Linux/macOS.
- If the feature is Visual Studio/Windows-only, add a clear note at the top indicating this limitation.
Service Fabric
Configure the upgrade of a Service Fabric application
...abric/service-fabric-visualstudio-configure-upgrade.md
Medium Priority
View Details â
Detected Bias Types
windows_first
powershell_heavy
missing_linux_example
windows_tools
Summary
The documentation is heavily focused on Windows-centric tools, specifically Visual Studio and PowerShell, for configuring and upgrading Service Fabric applications. All examples and instructions reference Windows tools, with no mention of Linux/macOS alternatives or cross-platform CLI methods. The use of PowerShell is presented as the only manual upgrade method, and there are no examples or guidance for Linux users or those using Azure CLI or REST APIs.
Recommendations
- Add instructions and examples for upgrading Service Fabric applications using cross-platform tools such as Azure CLI or REST API.
- Include guidance for Linux/macOS users, such as how to perform upgrades from a Linux machine or using non-Windows tools.
- Clarify if Visual Studio and PowerShell are required, or provide alternative workflows for users on other platforms.
- Present PowerShell and Windows tools alongside, not before, cross-platform options to avoid Windows-first bias.
Virtual Machine Scale Sets
Enable Automatic Zone Balance on Virtual Machine Scale Sets (Preview)
...virtual-machine-scale-sets/auto-zone-balance-enable.md
Medium Priority
View Details â
Detected Bias Types
windows_first
powershell_heavy
windows_tools
Summary
The documentation provides both Azure CLI and PowerShell examples for enabling Automatic Zone Balance on VM Scale Sets. However, PowerShell (a Windows-centric tool) is consistently presented alongside CLI, and in some sections, PowerShell examples reference Windows-specific extension types (e.g., ApplicationHealthWindows), while CLI examples reference ApplicationHealthLinux. The PowerShell examples are not clearly marked as Windows-only, and PowerShell is presented as a first-class option, which may create friction for Linux/macOS users. Portal instructions are platform-neutral, but PowerShell is a Windows tool and is not available natively on most Linux/macOS systems.
Recommendations
- Clearly indicate that Azure PowerShell is primarily for Windows users and recommend Azure CLI for Linux/macOS users.
- Ensure that all extension examples (e.g., Application Health) are shown for both Linux and Windows, and clarify which is appropriate for each OS.
- Consider presenting Azure CLI examples before PowerShell, as CLI is cross-platform.
- Add explicit notes or links for Linux/macOS users about how to install and use Azure CLI.
- Where PowerShell is used, clarify if the example is Windows-specific or if PowerShell Core is supported on Linux/macOS.
Service Fabric
Fault Analysis Service overview
.../service-fabric/service-fabric-testability-overview.md
Medium Priority
View Details â
Detected Bias Types
powershell_heavy
windows_first
Summary
The documentation provides explicit PowerShell instructions for using the Fault Analysis Service, but does not mention or provide examples for Linux/macOS command-line tools or SDKs. The PowerShell section appears before any mention of cross-platform alternatives, and there is no guidance for Linux users on how to interact with the service via CLI or REST APIs.
Recommendations
- Add examples for using the Fault Analysis Service from Linux/macOS environments, such as via Azure CLI, REST API, or cross-platform SDKs.
- Clarify whether PowerShell usage is required or if alternative tools are available for non-Windows users.
- Provide parity in documentation by including Linux/macOS-specific instructions or references alongside PowerShell examples.
Virtual Machine Scale Sets
Orchestration modes for Virtual Machine Scale Sets in Azure
...sets/virtual-machine-scale-sets-orchestration-modes.md
Medium Priority
View Details â
Detected Bias Types
windows_first
missing_linux_example
Summary
The documentation provides conceptual information about orchestration modes for Azure Virtual Machine Scale Sets and includes some command-line examples (e.g., az vm create) without specifying OS-specific instructions. However, in the 'Backup and recovery' section, Azure Site Recovery is noted as supported only 'via PowerShell' for Flexible orchestration, without mentioning Linux/CLI alternatives. Additionally, the documentation sometimes references Windows and Linux together (e.g., mixing OSes in scale sets), but Windows-specific tooling (PowerShell) is mentioned where Linux parity is unclear.
Recommendations
- Clarify whether Azure Site Recovery for Flexible orchestration mode can be used with Azure CLI or REST API, and provide Linux/macOS-compatible instructions if possible.
- Where PowerShell is mentioned, add equivalent Azure CLI or REST API examples for Linux/macOS users.
- Ensure all command-line examples (such as az vm create) are shown with correct syntax for both Windows and Linux shells, avoiding Windows-specific formatting.
- Explicitly state OS compatibility for features and tools, and provide links or references for Linux/macOS users where relevant.
Virtual Machines
Associate a virtual machine to a capacity reservation group
.../virtual-machines/capacity-reservation-associate-vm.md
Medium Priority
View Details â
Detected Bias Types
windows_first
missing_linux_example
powershell_heavy
Summary
The documentation covers both Windows and Linux VMs, but there are signs of Windows bias. PowerShell examples are provided alongside Azure CLI, but there are no explicit Bash or Linux shell script examples. The ARM template example is Windows-centric, with only Windows Server images and parameters. In some sections, Windows-specific terminology (e.g., password complexity, RDP port 3389) appears before Linux equivalents, and PowerShell is given equal prominence despite being Windows-focused. Linux users may need to adapt some steps or infer details for their environment.
Recommendations
- Add explicit Linux-focused examples in ARM templates (e.g., Ubuntu or CentOS images, SSH key authentication instead of password).
- Include Bash shell script examples for common operations, especially for associating VMs to capacity reservation groups.
- Clarify password/SSH authentication requirements for Linux VMs in portal and template instructions.
- Balance the order of CLI and PowerShell examples, or note that PowerShell is primarily for Windows users.
- In ARM templates, provide both Windows and Linux image references and OS configuration options.
Virtual Machines
Create and upload an Ubuntu Linux VHD in Azure
...rticles/virtual-machines/linux/create-upload-ubuntu.md
Medium Priority
View Details â
Detected Bias Types
windows_tools
windows_first
powershell_heavy
missing_linux_example
Summary
The documentation page, while focused on creating and uploading an Ubuntu Linux VHD to Azure, exhibits notable Windows bias. Hyper-V (a Windows-only virtualization tool) is referenced as the primary example for creating VHDs, and Windows-specific instructions (such as using PowerShell's Convert-VHD cmdlet) are provided without Linux alternatives. Steps involving Hyper-V Manager and PowerShell are described in detail, but equivalent Linux tools (like qemu-img or VirtualBox) are not mentioned or explained. This creates friction for Linux/macOS users, who may not have access to Hyper-V or PowerShell.
Recommendations
- Add instructions and examples for creating VHDs using Linux-native tools such as qemu-img, KVM, or VirtualBox.
- Provide Linux/macOS alternatives for disk conversion (e.g., using qemu-img to convert raw images to fixed VHD format).
- Include guidance for deprovisioning and shutting down VMs using Linux tools and commands, not just Hyper-V Manager.
- Reorganize sections so Linux-native methods are presented first or alongside Windows methods, rather than Windows-first.
- Clarify which steps are Windows-specific and offer parity for Linux/macOS users wherever possible.
Virtual Machines
Create an Azure Image Builder Bicep file or ARM template JSON template
.../articles/virtual-machines/linux/image-builder-json.md
Medium Priority
View Details â
Detected Bias Types
windows_first
powershell_heavy
windows_tools
Summary
The documentation covers both Windows and Linux usage for Azure Image Builder, but there is a notable Windows bias in several areas. Windows/PowerShell examples and tools are often presented first, and PowerShell is frequently referenced for tasks like generating SHA256 checksums and running commands. Windows-specific customizers (PowerShell, WindowsRestart, WindowsUpdate) are described in detail, while Linux equivalents are less prominent or missing (e.g., no Linux restart customizer). Windows tools (PowerShell cmdlets) are mentioned for checksum generation, with Linux alternatives referenced but less emphasized. However, Linux support is present throughout, and Linux-specific instructions are included, especially for shell customizers and validations.
Recommendations
- Present Linux and Windows examples side-by-side or alternate which is shown first.
- For checksum generation, mention Linux/Mac commands (sha256sum) before or alongside PowerShell Get-FileHash.
- Clarify limitations (e.g., no Linux restart customizer) and suggest Linux workarounds (such as using shell scripts with 'reboot' and validation logic).
- Expand Linux-specific guidance for common tasks (e.g., file downloads, validation, customization) to match Windows detail.
- Ensure all CLI instructions are equally applicable to Linux/macOS users and highlight cross-platform compatibility.
- Add links to Linux troubleshooting and scripting resources where Windows links are provided.
Virtual Machines
Run scripts in a Linux VM in Azure using managed Run Commands
...articles/virtual-machines/linux/run-command-managed.md
Medium Priority
View Details â
Detected Bias Types
windows_tools
powershell_heavy
windows_first
missing_linux_example
Summary
The documentation page, while focused on Linux VMs, includes significant PowerShell usage and references to Windows-centric tools and patterns. PowerShell examples are provided extensively alongside Azure CLI, but some examples and notes reference Windows-specific behaviors or tools (e.g., 'ipconfig', 'Write-Host', SAS token generation with PowerShell). REST API and ARM template examples use Windows-style scripts (.ps1) and 'Write-Host', and PowerShell is presented with equal or greater prominence than Azure CLI. Some explanations and examples lack explicit Linux shell script equivalents, and Windows terminology is used in parameter explanations.
Recommendations
- Ensure all script examples in REST API and ARM template sections use Linux shell scripts (e.g., 'echo Hello World!', '.sh' files) when the context is Linux VMs.
- Replace or supplement PowerShell-centric instructions (e.g., SAS token generation, 'Write-Host') with Azure CLI or Linux-native alternatives.
- Clarify when a command or parameter is Windows-specific versus Linux-specific, especially in sections describing parameter passing and script execution.
- Present Azure CLI examples before PowerShell, as CLI is more native to Linux environments.
- Add explicit Linux shell script examples for all major scenarios, including REST API and ARM template deployments.
- Avoid referencing Windows tools (e.g., 'ipconfig') in Linux contexts; use Linux equivalents like 'ifconfig' or 'ip'.
Service Fabric
Deny assignment policy for Service Fabric managed clusters
...cles/service-fabric/managed-cluster-deny-assignment.md
Low Priority
View Details â
Detected Bias Types
powershell_heavy
windows_first
Summary
The documentation provides examples and links for Azure PowerShell before Azure CLI, and references PowerShell-specific modules for Service Fabric management. While both Azure CLI and PowerShell are mentioned, PowerShell is emphasized in the best practices section and linked first for critical operations. This creates a mild Windows bias, as PowerShell is more commonly used on Windows, and Linux/macOS users may prefer CLI or other tools.
Recommendations
- Provide Azure CLI examples and links alongside PowerShell for all operations, especially in the best practices section.
- Clarify that Azure CLI is fully supported on Linux/macOS and can be used for managing Service Fabric clusters.
- Consider listing Azure CLI before PowerShell in tables and guidance to balance visibility.
- Add explicit Linux/macOS usage notes or examples where relevant.
Service Fabric
Overview of Azure Service Fabric
...ain/articles/service-fabric/service-fabric-overview.md
Low Priority
View Details â
Detected Bias Types
windows_first
Summary
The documentation mentions both Windows and Linux support for Azure Service Fabric, and provides parity in describing development environments and cluster deployment options. However, Windows development (Visual Studio, PowerShell) is mentioned before Linux development (Eclipse, Yeoman) in the 'Any OS, any cloud' section, and the quickstart link points to a .NET (likely Windows-centric) guide. No explicit Linux example or quickstart is provided or linked directly from this overview page.
Recommendations
- Provide quickstart links for both Windows (.NET) and Linux (Java/.NET Core) users in the 'Next steps' section.
- Mention Linux development options before or alongside Windows options in relevant sections.
- Ensure that examples and links are balanced between Windows and Linux, or clarify when a guide is Windows-specific.
- Add a brief note in the 'Any OS, any cloud' section highlighting parity and linking to both Windows and Linux getting started guides.
Service Fabric
Overview of Service Fabric and containers
...s/service-fabric/service-fabric-containers-overview.md
Low Priority
View Details â
Detected Bias Types
windows_first
windows_tools
Summary
The documentation provides a balanced overview of Service Fabric container support on both Linux and Windows, but there is a slight bias towards Windows in the ordering and emphasis of examples and scenarios. Windows-specific tools (Mirantis Container Runtime, DockerEE) are mentioned, and IIS lift-and-shift scenarios are highlighted first. However, Linux support is clearly described, and Linux tutorials are linked alongside Windows equivalents.
Recommendations
- Ensure Linux examples and scenarios are presented before or alongside Windows examples, especially in introductory sections.
- Expand Linux-specific scenarios (e.g., NGINX, Apache, Node.js) to match the detail given to Windows/IIS scenarios.
- Mention Linux container runtimes and tools (e.g., containerd, Podman) if relevant, not just Docker.
- Balance the order of quickstart/tutorial links so Linux and Windows are equally prominent.
- Add explicit notes about parity and limitations for each platform where applicable.
Virtual Machine Scale Sets
Networking for Azure Virtual Machine Scale Sets
...ne-scale-sets/virtual-machine-scale-sets-networking.md
Low Priority
View Details â
Detected Bias Types
windows_first
powershell_heavy
Summary
The documentation provides both Azure CLI and PowerShell examples for most tasks, but PowerShell (a Windows-centric tool) is often presented before CLI, and some sections (such as querying public IPs) show PowerShell examples first or in greater detail. There is a slight preference for Windows/PowerShell in ordering and example depth, but Linux parity is generally maintained. No critical features are Windows-only, and Linux users can complete all tasks using CLI or ARM templates.
Recommendations
- Present Azure CLI examples before PowerShell examples, or in parallel, to avoid implicit Windows-first ordering.
- Ensure CLI and PowerShell examples are equally detailed and comprehensive.
- Explicitly mention that Azure CLI works cross-platform (Windows, Linux, macOS) to reassure non-Windows users.
- Where possible, add Bash shell script examples for common Linux workflows.
- Review for any subtle language that implies PowerShell is the default or preferred tool.
Virtual Machine Scale Sets
Create an Azure scale set that uses Availability Zones
...s/virtual-machine-scale-sets-use-availability-zones.md
Low Priority
View Details â
Detected Bias Types
windows_first
powershell_heavy
Summary
The documentation provides both Azure CLI and Azure PowerShell examples for creating and updating scale sets with Availability Zones. However, PowerShell examples are given equal prominence to CLI, and in some sections (such as 'Use Azure PowerShell'), PowerShell is presented as a primary method. Additionally, the PowerShell example is shown before the ARM template example, and the CLI and PowerShell tabs are both present for update operations. There is a minor 'windows_first' bias in the order of examples and the explicit mention of PowerShell, which is primarily a Windows tool, but Linux parity is generally maintained via CLI and ARM template examples.
Recommendations
- Ensure that Azure CLI examples are always shown before PowerShell examples, as CLI is cross-platform and PowerShell is primarily Windows-focused.
- Explicitly mention that Azure CLI is recommended for Linux/macOS users, and PowerShell for Windows users.
- Consider adding Bash shell script examples for Linux users where appropriate.
- Clarify that all operations shown via PowerShell can also be performed via Azure CLI or ARM templates, and link to those sections.
- Where possible, add notes about cross-platform compatibility for each tool.
Low Priority
View Details â
Detected Bias Types
powershell_heavy
windows_first
Summary
The documentation provides both Azure CLI and PowerShell examples for checking vCPU quotas. However, the PowerShell section is given equal prominence to the CLI, despite PowerShell being primarily a Windows tool. The CLI example is shown first, which is positive, but the PowerShell section is still highlighted as a main method, which may create friction for Linux/macOS users who do not use PowerShell. No Linux-specific tools or shell commands are mentioned, but the CLI example is cross-platform.
Recommendations
- Clearly indicate that Azure CLI is the recommended cross-platform method for Linux/macOS users.
- Add a note clarifying that PowerShell is primarily for Windows users, and that Azure CLI works on all platforms.
- Consider providing Bash shell script examples for common quota-checking tasks, or referencing how to install Azure CLI on Linux/macOS.
- If possible, link to Azure CLI installation guides for Linux/macOS in the 'Related content' section.
Virtual Machines
Create an image definition and image version
...s/blob/main/articles/virtual-machines/image-version.md
Low Priority
View Details â
Detected Bias Types
windows_first
powershell_heavy
Summary
The documentation provides parity between Linux and Windows in most sections, including CLI, REST, and portal instructions. However, there is a mild Windows bias in the PowerShell examples, which default to Windows OS and show Windows-specific parameters first. Additionally, in some sections, Windows is mentioned before Linux, and PowerShell examples are more prominent than Bash or Linux shell alternatives.
Recommendations
- In PowerShell examples, show both Linux and Windows OS types equally, or default to Linux where appropriate.
- Ensure that Linux and Windows examples are presented in parallel, rather than defaulting to Windows in PowerShell sections.
- Where possible, provide Bash or shell script equivalents for PowerShell commands, especially for Linux users.
- Review order of OS mentions to avoid always listing Windows first.
- Add explicit notes or examples for Linux-specific scenarios in PowerShell sections, if relevant.
Service Fabric
Azure Service Fabric container image management
.../articles/service-fabric/container-image-management.md
Low Priority
View Details â
Detected Bias Types
windows_first
windows_tools
Summary
The documentation references Windows container base images (microsoft/windowsservercore, microsoft/nanoserver) as default exclusions in image cleanup, and mentions Windows images before Linux equivalents. No Linux-specific examples or references are provided, and the examples for skipping images focus on Windows images first.
Recommendations
- Add examples and references for common Linux container base images (e.g., 'docker.io/library/ubuntu', 'docker.io/library/alpine') in the 'ContainerImagesToSkip' setting.
- Clarify that image cleanup applies equally to Linux containers, and provide Linux-focused guidance where relevant.
- Mention Linux container base images in descriptions and examples alongside Windows images to ensure parity.
- If there are platform-specific behaviors (e.g., cleanup differences between Windows and Linux containers), document them explicitly.
Service Fabric
Understanding periodic backup configuration
...-fabric-backuprestoreservice-configure-periodic-backup.md
Low Priority
View Details â
Detected Bias Types
windows_tools
missing_linux_example
Summary
The documentation page for configuring periodic backups in Azure Service Fabric shows minor Windows bias. The only on-premises backup storage example is a Windows file share, with authentication options focused on Windows (Integrated Windows Authentication, username/password). No Linux or cross-platform file share options (such as NFS or SMB on Linux) are mentioned, nor are Linux-specific authentication patterns or examples provided. All other examples (Azure Blob storage) are platform-neutral, and no PowerShell or Windows-first patterns are present.
Recommendations
- Add examples for configuring backup storage to Linux-compatible file shares (e.g., NFS, SMB on Linux).
- Mention authentication options for Linux environments, such as Kerberos, or how to access SMB shares from Linux nodes.
- Clarify whether the file share backup storage option is Windows-only or if it can be used from Linux Service Fabric clusters.
- If Linux is not supported for file share backups, explicitly state this limitation.
Service Fabric
Azure Service Fabric security best practices
...rvice-fabric/service-fabric-best-practices-security.md
Low Priority
View Details â
Detected Bias Types
windows_first
powershell_heavy
windows_tools
Summary
The documentation provides both Windows and Linux guidance for most security best practices, but Windows examples and tools (such as PowerShell and Windows Defender) are often presented first or exclusively. Windows-specific recommendations (e.g., Windows Defender, security baselines) are included without Linux equivalents, and PowerShell commands are used for Windows encryption, while Linux uses bash/openssl. Some sections, like Windows Defender and security baselines, are Windows-only, but this is appropriate given their nature. However, minor friction exists for Linux users due to Windows-first ordering and lack of Linux parity in some recommendations.
Recommendations
- Where possible, provide Linux-first or parallel examples (e.g., bash/openssl before or alongside PowerShell).
- Explicitly mention Linux alternatives for Windows-specific tools (e.g., recommend ClamAV or other Linux antivirus solutions in the Windows Defender section).
- For security baseline recommendations, link to Linux security best practices (e.g., CIS Linux benchmarks) alongside Windows baselines.
- Ensure that Linux guidance is as prominent and detailed as Windows guidance throughout the document.
Service Fabric
Azure Service Fabric Docker Compose Deployment Preview
...ticles/service-fabric/service-fabric-docker-compose.md
Low Priority
View Details â
Detected Bias Types
powershell_heavy
windows_first
Summary
The documentation provides both PowerShell and Service Fabric CLI (sfctl) examples for deploying Docker Compose files to Azure Service Fabric. However, PowerShell commands are presented first and in greater detail, which may suggest a Windows-first bias. The CLI examples are present and usable on Linux/macOS, but PowerShell is emphasized, potentially creating friction for non-Windows users.
Recommendations
- Present CLI (sfctl) examples before PowerShell, or at least equally.
- Explicitly mention that sfctl is cross-platform and preferred for Linux/macOS users.
- Add notes clarifying that PowerShell examples are for Windows users, while sfctl is for Linux/macOS.
- Ensure all critical operations are covered in both PowerShell and CLI sections.
- Consider adding bash/zsh shell example snippets for Linux/macOS users where relevant.
Service Fabric
Reliable services app manifest examples
...ps://github.com/MicrosoftDocs/azure-compute-docs/blob/main/articles/service-fabric/service-fabric-manifest-example-reliable-services-app.md
Low Priority
View Details â
Detected Bias Types
windows_first
powershell_heavy
windows_tools
Summary
The documentation page provides Service Fabric application and service manifest examples, but exhibits mild Windows bias. Windows-specific concepts (such as running scripts via .bat files, referencing PowerShell modules, and using Windows account types like NetworkService and Administrators) are present. The only script example is a Windows batch file (Setup.bat), and the documentation references using the ServiceFabric PowerShell module to create service instances. There are no explicit Linux or cross-platform examples, nor are Linux-specific tools or account types mentioned.
Recommendations
- Add examples for running startup scripts using cross-platform formats (e.g., .sh for Linux/macOS).
- Mention Linux account types and how principals/policies map to Linux environments.
- Reference Service Fabric CLI (sfctl) or other cross-platform tools alongside PowerShell.
- Clarify which manifest settings are platform-agnostic and which require Windows-specific configuration.
- Provide guidance or links for Linux/macOS users deploying Service Fabric applications, including any differences in manifest usage or deployment steps.
Service Fabric
Reliable Collection object serialization
...c-reliable-services-reliable-collections-serialization.md
Low Priority
View Details â
Detected Bias Types
windows_first
Summary
The documentation provides examples and references primarily in C# and .NET, which are cross-platform but historically associated with Windows. In the 'Next steps' section, Windows tools (Visual Studio and PowerShell) are mentioned before any Linux alternatives, and there is no explicit mention of Linux/macOS tooling or workflows. However, the core serialization concepts are platform-agnostic and do not depend on Windows-specific features.
Recommendations
- Add explicit guidance or examples for Linux/macOS users, such as using CLI tools or cross-platform editors (e.g., VS Code, dotnet CLI).
- In the 'Next steps' section, include links or instructions for upgrading applications using Linux/macOS-compatible tools (e.g., Bash scripts, Azure CLI).
- Clarify that Service Fabric Reliable Collections and serialization are supported on both Windows and Linux clusters, and note any platform-specific differences if relevant.
Service Fabric
Standalone Service Fabric clusters overview
...-fabric/service-fabric-standalone-clusters-overview.md
Low Priority
View Details â
Detected Bias Types
missing_linux_example
windows_first
Summary
The documentation initially describes Service Fabric clusters as supporting both Windows Server and Linux, but later clarifies that Linux is not yet supported for standalone clusters. All examples, security patterns, and OS lists are Windows-centric, with no Linux-specific guidance or parity. Windows authentication and security mechanisms are discussed exclusively, and the supported OS list is Windows-only.
Recommendations
- Clarify at the top that standalone clusters are currently Windows-only, to avoid confusion from the initial claim of Linux support.
- Remove or revise statements implying Linux support for standalone clusters until it is available.
- When Linux support is added, provide equivalent Linux examples, security guidance, and OS lists.
- Consider linking to documentation for Service Fabric on Linux (if available) or noting the distinction between standalone and managed clusters.
Service Fabric
Learn Azure Service Fabric terminology
...es/service-fabric/service-fabric-technical-overview.md
Low Priority
View Details â
Detected Bias Types
windows_first
windows_tools
Summary
The documentation page is generally platform-neutral and describes Service Fabric concepts applicable to both Windows and Linux. However, there are subtle signs of Windows bias: Windows terminology and tools (such as 'Windows service', 'FabricHost.exe', 'EXE/DLL files') are mentioned first or exclusively in some sections, and Windows-specific executables are referenced without always providing Linux equivalents or clarifying cross-platform behavior. Linux is mentioned in some places (e.g., Docker containers), but Windows patterns and terminology are more prominent.
Recommendations
- Where Windows-specific executables or services are mentioned (e.g., 'FabricHost.exe', 'EXE/DLL files'), clarify if/how these concepts map to Linux deployments (e.g., systemd services, ELF binaries).
- When describing node startup and service management, include Linux equivalents or note differences in process management.
- Ensure examples and terminology are balanced: mention Linux alongside Windows when discussing executables, containers, or deployment models.
- Add explicit statements or links about Linux support and any platform-specific differences in Service Fabric operation.
Virtual Machine Scale Sets
Attach or detach a virtual machine to or from a Virtual Machine Scale Set
...le-sets/virtual-machine-scale-sets-attach-detach-vm.md
Low Priority
View Details â
Detected Bias Types
powershell_heavy
windows_first
Summary
The documentation provides both Azure CLI and Azure PowerShell examples for all major operations (attach, detach, move), as well as portal instructions. However, PowerShell examples are given equal prominence to CLI, despite PowerShell being primarily a Windows tool. In some cases, PowerShell examples are more verbose and detailed, which may subtly favor Windows users. Azure CLI is cross-platform, but there are no explicit Linux/macOS shell examples (e.g., Bash, zsh), nor any mention of Linux-specific considerations. PowerShell is presented as a first-class option, which may create friction for Linux/macOS users who do not use PowerShell.
Recommendations
- Clearly indicate that Azure CLI is cross-platform and preferred for Linux/macOS users.
- Consider providing Bash/zsh shell command examples where relevant, or clarifying that Azure CLI commands work identically on Linux/macOS.
- Add a note that PowerShell is primarily for Windows users, and recommend Azure CLI for Linux/macOS.
- If PowerShell is required for some advanced scenarios, explain how Linux/macOS users can install and use PowerShell Core.
- Review the order of examples: consider listing Azure CLI before PowerShell to reduce Windows-first bias.
Virtual Machine Scale Sets
Configure rolling upgrades on Virtual Machine Scale Sets
...ps://github.com/MicrosoftDocs/azure-compute-docs/blob/main/articles/virtual-machine-scale-sets/virtual-machine-scale-sets-configure-rolling-upgrades.md
Low Priority
View Details â
Detected Bias Types
windows_first
powershell_heavy
Summary
The documentation provides parity between Azure CLI and PowerShell for all command-line examples, but PowerShell examples are consistently presented alongside CLI, and in some cases, PowerShell is given its own section. The use of PowerShell is inherently Windows-centric, and there are no explicit Linux/macOS shell examples (e.g., Bash, zsh), nor are there references to Linux-specific tools or workflows. However, the Azure CLI is cross-platform and is presented first in most cases, mitigating the impact. No critical tasks are Windows-only.
Recommendations
- Clarify that Azure CLI commands work on Linux, macOS, and Windows, and are the preferred cross-platform option.
- Add explicit Bash/zsh shell examples where relevant, or note that Azure CLI commands can be run in Bash on Linux/macOS.
- Consider grouping PowerShell examples under a 'Windows/PowerShell' heading to reinforce their platform specificity.
- Add a short note in the 'CLI' sections indicating that these commands are suitable for Linux/macOS users.
Virtual Machine Scale Sets
Rolling upgrades with MaxSurge for Virtual Machine Scale Sets
...hine-scale-sets/virtual-machine-scale-sets-maxsurge.md
Low Priority
View Details â
Detected Bias Types
powershell_heavy
windows_first
Summary
The documentation provides configuration examples for rolling upgrades with MaxSurge using Azure Portal, Azure CLI, PowerShell, and ARM Template. The PowerShell example is present, which is Windows-centric, but the CLI example (az CLI) is cross-platform and appears before PowerShell. There are no exclusive Windows tools or patterns mentioned, and Linux/macOS users can fully complete the task using the CLI or ARM Template. However, the inclusion of PowerShell and its detailed example may slightly favor Windows users, and the PowerShell section is present before ARM Template, which could be seen as a minor ordering bias.
Recommendations
- Clarify that Azure CLI is fully cross-platform and suitable for Linux/macOS users.
- Consider adding explicit Bash or shell scripting examples for Linux users, if relevant.
- Ensure parity in detail and explanation between CLI and PowerShell sections.
- If possible, reorder sections so CLI appears before PowerShell, emphasizing cross-platform tools.
Virtual Machine Scale Sets
Custom metrics for rolling upgrades on Virtual Machine Scale Sets
...tual-machine-scale-sets-rolling-upgrade-custom-metrics.md
Low Priority
View Details â
Detected Bias Types
windows_first
powershell_heavy
windows_tools
Summary
The documentation provides both Linux (Bash/Python) and Windows (PowerShell) examples for configuring custom metrics and the application health extension on Azure Virtual Machine Scale Sets. However, there is evidence of Windows bias: PowerShell examples are often presented before or alongside Bash, and Windows-specific extension types (ApplicationHealthWindows) are used in several code snippets and REST examples, sometimes without clear Linux equivalents. The PowerShell section is more detailed and prominent, and Windows tools are referenced frequently. Linux examples are present but sometimes less emphasized or detailed.
Recommendations
- Ensure Linux and Windows examples are equally detailed and prominent in all sections.
- Where extension types are shown (e.g., ApplicationHealthWindows), also show ApplicationHealthLinux explicitly in REST and PowerShell examples.
- In REST and CLI examples, clarify which values are for Linux and which for Windows, and provide both where applicable.
- Consider presenting Bash/Linux examples before PowerShell/Windows examples, or alternate their order.
- Add troubleshooting and verification steps for Linux (e.g., systemd, netstat, firewall-cmd) alongside Windows-specific guidance.
Virtual Machines
Azure VM Extensions and Features for Linux
...articles/virtual-machines/extensions/features-linux.md
Low Priority
View Details â
Detected Bias Types
windows_first
powershell_heavy
Summary
The documentation is generally Linux-focused and provides comprehensive guidance for Linux VM extensions in Azure. However, in several sections, Azure PowerShell examples are presented alongside Azure CLI examples, sometimes with PowerShell shown first or with equal prominence. This could create minor friction for Linux users, as PowerShell is less commonly used on Linux compared to Azure CLI. All example scripts and ARM templates are Linux-centric, and no Windows-only tools or patterns are promoted.
Recommendations
- Where both Azure CLI and PowerShell examples are shown, consider listing Azure CLI first, as it is the more common tool for Linux users.
- Explicitly note that PowerShell examples are optional for Linux users and that Azure CLI is the primary cross-platform tool.
- Where possible, provide Bash script examples for local troubleshooting or automation tasks, in addition to Azure CLI.
- If PowerShell is included, clarify its cross-platform availability but emphasize CLI for Linux workflows.
Virtual Machines
Create a Gallery for Sharing Resources
.../blob/main/articles/virtual-machines/create-gallery.md
Low Priority
View Details â
Detected Bias Types
windows_first
Summary
The documentation provides examples for Azure Portal, Azure CLI, PowerShell, and REST API. PowerShell is presented as a distinct example, but it is not prioritized over cross-platform tools. However, in the 'Create a private gallery' section, the PowerShell example is shown after CLI and Portal, which is appropriate. All CLI examples use Azure CLI, which is cross-platform and works on Windows, Linux, and macOS. There are no Windows-specific tools or patterns mentioned, and Linux/macOS users are not excluded from any critical steps. The only minor bias is that PowerShell is included as a separate example, which may be unnecessary given Azure CLI's cross-platform nature, but it is not shown first.
Recommendations
- Clarify that Azure CLI is cross-platform and preferred for Linux/macOS users.
- Consider adding a note that PowerShell examples are primarily for Windows users, but PowerShell Core is available cross-platform.
- Ensure that CLI examples are always shown before PowerShell, as is currently done.
- Optionally, add Bash shell script examples for Linux users, though Azure CLI covers most needs.
Virtual Machines
NVIDIA GPU Driver Extension - Azure Linux VMs
...es/virtual-machines/extensions/hpccompute-gpu-linux.md
Low Priority
View Details â
Detected Bias Types
powershell_heavy
windows_first
Summary
The documentation is focused on Linux VM GPU driver installation, but includes PowerShell examples alongside Azure CLI and ARM templates. The PowerShell example is presented before the Azure CLI example, which is more relevant for Linux users. There is also a brief mention of a Windows extension, but it is clearly separated and not the main topic. No Windows-only tools or patterns are prioritized, and Linux-specific commands and troubleshooting are well covered.
Recommendations
- Move the Azure CLI example before the PowerShell example, as Azure CLI is more commonly used for Linux VM management.
- Clarify that PowerShell is primarily for users managing Azure from Windows environments, and highlight Azure CLI as the preferred cross-platform tool.
- Consider adding Bash shell script examples for advanced automation, if relevant.
- Ensure all screenshots and instructions are Linux-specific (which they currently are).
Virtual Machines
Azure Key Vault VM Extension for Linux
...rticles/virtual-machines/extensions/key-vault-linux.md
Low Priority
View Details â
Detected Bias Types
powershell_heavy
windows_first
Summary
The documentation is generally Linux-focused and covers Linux-specific extension details, paths, and certificate handling. However, in deployment and troubleshooting sections, Azure PowerShell examples are presented first and in greater detail, with explicit warnings about PowerShell quirks. Azure CLI examples are present but often shown after PowerShell, and troubleshooting instructions reference PowerShell before CLI. There are no missing Linux examples, but the ordering and emphasis may create friction for Linux users who typically prefer CLI or shell-based workflows.
Recommendations
- Present Azure CLI examples before PowerShell in deployment and troubleshooting sections, as CLI is more commonly used on Linux.
- Expand CLI troubleshooting instructions to match the detail provided for PowerShell.
- Add a brief note clarifying that both Azure CLI and PowerShell are supported, but CLI is recommended for Linux environments.
- Ensure all JSON and shell examples use Linux-friendly syntax and paths (which is already mostly the case).
Virtual Machines
Share VM images in a compute gallery
...in/articles/virtual-machines/shared-image-galleries.md
Low Priority
View Details â
Detected Bias Types
windows_first
powershell_heavy
minor_windows_tools
Summary
The documentation covers both Linux and Windows VM images, but there are several signs of Windows bias. PowerShell examples are provided alongside Azure CLI, and Windows terminology/tools (e.g., Sysprep, Windows upload links) are often mentioned first or more prominently. In some cases, Windows-specific links or examples precede Linux equivalents, and PowerShell is referenced in feature explanations and sharing instructions. However, Linux is explicitly supported and referenced throughout, and CLI examples are present.
Recommendations
- Ensure Linux and Windows examples are given equal prominence, alternating order where possible.
- Provide Bash/Linux shell examples alongside PowerShell, especially in sections where only PowerShell is shown.
- When referencing upload or creation guides, mention Linux and Windows links together, not with Windows first.
- Clarify that both Linux and Windows tools (waagent, Sysprep) are required for generalization, and provide links for both.
- Where PowerShell is referenced for sharing or management, ensure CLI/Bash alternatives are equally visible.
Virtual Machines
Create and upload a Red Hat Enterprise Linux VHD for use in Azure
...les/virtual-machines/linux/redhat-create-upload-vhd.md
Low Priority
View Details â
Detected Bias Types
windows_first
windows_tools
Summary
The documentation provides step-by-step instructions for preparing and uploading a Red Hat Enterprise Linux VHD for Azure using multiple hypervisors, including Hyper-V (Windows), KVM (Linux), VMware, and Kickstart. However, in most sections and workflows, Hyper-V (a Windows-based tool) is presented first, and Windows-centric terminology (e.g., Hyper-V Manager, VHD conversion using Windows tools) is prominent. Linux alternatives (KVM, VMware, Kickstart) are covered in detail, but Windows/Hyper-V instructions are consistently prioritized and referenced as the primary workflow. Some conversion steps mention Windows tools (e.g., Hyper-V Manager, convert-vhd cmdlet) before Linux equivalents (e.g., qemu-img), and the overall structure puts Windows/Hyper-V steps before Linux/KVM/VMware steps.
Recommendations
- Reorder sections so that Linux-native hypervisors (KVM, VMware, Kickstart) are presented before or alongside Hyper-V, rather than always after.
- Where disk conversion is discussed, mention Linux tools (qemu-img) before or alongside Windows tools (Hyper-V Manager, convert-vhd).
- Add a summary table or navigation at the top to help Linux users quickly find their relevant workflow.
- Ensure that Linux-specific terminology and tools are not overshadowed by Windows/Hyper-V references.
- Consider adding explicit notes that all workflows are equally supported, and none is preferred based on OS.
Virtual Machines
Time sync for Linux VMs in Azure
...blob/main/articles/virtual-machines/linux/time-sync.md
Low Priority
View Details â
Detected Bias Types
windows_first
Summary
The documentation is focused on Linux VM time synchronization in Azure and provides Linux-specific guidance and examples. However, the introductory section discusses Windows Server 2016 time sync improvements and references Windows documentation before Linux-specific details. All configuration instructions, tools, and examples are Linux-centric, with no PowerShell or Windows tool bias in the main content. The only minor bias is mentioning Windows infrastructure and linking to Windows docs first, which may be unnecessary for Linux users.
Recommendations
- Move or minimize Windows Server 2016 discussion to a background or context section, clarifying its relevance to Linux VM time sync.
- Prioritize Linux-specific information and links in the introduction.
- Add a brief explanation that Windows infrastructure is relevant only as the underlying Azure host, not for Linux VM configuration.
- Ensure Linux documentation links are given equal or greater prominence compared to Windows links.