Effective_Being_8048 asks for practical advice on architecting a deployment pipeline that manages multiple environments, server roles, and application dependencies without hardcoding configurations. This summary explores their setup, challenges, and desired solutions.

Article Summary

Effective_Being_8048 is designing a deployment pipeline spanning four environments: Production, PreProduction, Test, and Development. Each of these environments contains a differing number of virtual machines (VMs), with deployments involving tasks like file copy operations and service management (i.e., no containers or cloud-native orchestration yet).

Key Challenges Presented

  • Server/Role/App Mapping: Each application must be deployed to specific servers aligned with their roles (frontend, backend, job processor, etc.).
  • Variable Groups Limitation: The initial attempt to use Azure DevOps Variable Groups for mapping servers to applications encountered significant shortcomings, especially for expressing server roles and inter-application dependencies.
  • Application Dependencies: The author needs to support deployments where certain applications must be deployed in a specific order (e.g., App B depends on App A).
  • Dynamic Targeting: There’s a desire for a system to target VMs dynamically based on environment and role, avoiding hardcoded mappings or scattered variable group definitions.
  • Tag Management Complexity: While VM tags could provide a way to indicate roles, dynamic resolution and maintenance appear complex within their current workflow.

What the Author Wants

  • A clean, maintainable way to:
    • Target servers dynamically by role and environment
    • Maintain an up-to-date inventory of which apps go where
    • Encode/apply application dependency chains in deployment logic
  • To avoid hardcoded, repetitive configurations

Community Request

The author is soliciting:

  • Tooling suggestions
  • Process and pattern recommendations
  • Conceptual models for expressing the required mappings and dependencies
  • Real-world experiences or case studies from similar projects

Discussion Points for Response

  • Inventory management and dynamic role assignment patterns in Azure DevOps and other common toolchains
  • Managing dependencies and order of deployment in pipelines using YAML, task dependencies, or custom scripts
  • Possibility of external configuration (e.g., JSON, YAML, or database-driven inventories) as a mapping layer between servers, roles, and applications
  • Integrations with CMDBs or lightweight service registries
  • Use of orchestration tools (Ansible, PowerShell DSC, etc.) for more granular application of deployment logic

The article provides a concise yet thorough overview of the difficulties encountered when scaling beyond basic Variable Group usage in Azure DevOps. Suggestions or case studies about centralizing deployment logic, configuration-driven pipelines, or better inventory solutions would directly address the author’s concerns.

This post appeared first on “Reddit Azure DevOps”. Read the entire article here