All skills
microsoft avatar

/azure-enterprise-infra-planner

@5f24d7e official

Architect and provision enterprise Azure infrastructure from workload descriptions. For cloud architects and platform engineers planning networking, identity, security, compliance, and multi-resource topologies with WAF alignment. Generates Bicep or Terraform directly (no azd). WHEN: 'plan Azure infrastructure', 'architect Azure landing zone', 'design hub-spoke network', 'plan multi-region DR topology', 'set up VNets firewalls and private endpoints', 'subscription-scope Bicep deployment', 'Azure Backup for VM workloads'. PREFER azure-prepare FOR app-centric workflows.

Use this Skill: https://skilld.dev/gh/microsoft/github-copilot-for-azure/azure-enterprise-infra-planner

This session only. Nothing lands on disk.

referencesschema.md

≈964 tokens on demand. Your agent reads this file only when SKILL.md points to it.

Infrastructure Plan Schema

{
  meta: {
    planId: string // Unique identifier (e.g., "plan-1")
    generatedAt: string // ISO 8601 timestamp
    version: string // Schema version (e.g., "0.1-draft")
    status: "draft" | "approved" | "deployed" // Lifecycle state
  }
  inputs: {
    userGoal: string // User's stated objective or workload description, matches user query exactly
    subGoals?: string[] // Inferred architectural constraints and priorities derived from the user's request and research phase. Examples: "Cost-optimized: user chose defaults, avoid premium networking", "Security-first: encrypt all data, use managed identity", "Minimal complexity: single region, no VNet". These help evaluators understand intentional tradeoffs. Should be short list of 0-3 points.
    insightsApplied: string[] // For each insight that influenced this plan, cite the insight ID and explain how and why it was applied. Set to an empty array if no insights were applied. Document any unapplied insights in plan.overallReasoning.tradeoffs.
  }
  plan: {
    resources: {
      name: string // Logical resource name (CAF-compliant)
      type: string // ARM resource type (e.g., "Microsoft.Storage/storageAccounts")
      subtype?: string // Exact subtype (e.g., "Blob Storage", "Azure Function")
      location: string // Azure region (e.g., "eastus")
      sku: string // SKU tier (e.g., "Standard_LRS", "Consumption")
      properties?: Record<string, unknown> // Resource-specific properties
      reasoning: {
        whyChosen: string // Justification referencing WAF pillars (see phases/2-research-best-practices.md and phases/3-research-resources.md) or requirements
        alternativesConsidered: string[] // Other options evaluated
        tradeoffs: string // Key tradeoffs in this choice
      }
      dependencies: string[] // Names of resources this depends on (empty if none)
      dependencyReasoning?: string // Why these dependencies exist
      references: { title: string, url: string }[] // Links to Azure docs
    }[]
    overallReasoning: {
      summary: string // Overall architecture rationale
      tradeoffs: string // Top-level tradeoffs and gaps
    }
    validation: string // Deployment coherence statement
    architecturePrinciples: string[] // Guiding principles (e.g., "Highly available", "Secure")
    references: { title: string, url: string }[] // Architecture-level doc links
  }
}

Insights Schema

type ExistingResource = {
  id: string // Full ARM ID for actual state; logical or parameter reference otherwise
  type: string // ARM resource type (e.g., "Microsoft.Network/virtualNetworks")
  name: string
  role: "reference-and-integrate" | "retain" | "ignore"
  must_not_recreate: true
  integrationPoints: string[] // Connections or dependencies involving the new workload
}

type Insight =
  | {
      id: string // Stable identifier (e.g., "insight-001"); cited from inputs.insightsApplied
      pattern: string // Observed fact from the tenant scan or referenced workload
      implication: string // Recommended planning action derived from the pattern
      existingResource?: ExistingResource
    }
  | {
      id: string // Stable identifier for a resource-only entry
      existingResource: ExistingResource
      pattern?: string // Include with implication when the resource produces a broader insight
      implication?: string
    }

type Insights = Insight[]

In referenced mode:

  • Include exactly one entry for every inventoried existing resource, uniquely identified by existingResource.id.
  • Preserve the full ARM ID in existingResource.id for actual-state resources.
  • Use an empty integrationPoints array when the resource has no integration points.
  • A resource-only entry may omit pattern and implication; when recording a broader insight, include both.

Source: SKILL.md on GitHub

No alerts5mo4 checks · Risk SAFE
  • Gen Agent Trust Hub5mo

    This skill provides a comprehensive framework for planning and deploying Azure infrastructure using Bicep and Terraform. It leverages official Microsoft documentation and Azure CLI tools to ensure architectural alignment with the Well-Architected Framework. The skill includes built-in security practices such as managed identity usage, RBAC enforcement, and secure parameter handling.

  • Socket5mo

    No alerts

  • Snyk5mo

    Risk: LOW · No issues

  • ZeroLeaks5mo

    Score: 93/100 · 2 sections analyzed

Signed by skilld at 5f24d7e. This ties the file your Agent reads to that commit on GitHub. It does not review the instructions.

Last checked against GitHub yesterday.

Activeupdated last month
metadata
{
  "author": "Microsoft",
  "version": "0.0.0-placeholder"
}
  • Infrastructure
  • azure
  • bicep
  • terraform
  • networking
  • landing-zone
  • hub-spoke
  • identity
  • disaster-recovery
  • compliance

README badge

README badge for microsoft/github-copilot-for-azure/azure-enterprise-infra-planner

Generates Bicep or Terraform code for enterprise Azure infrastructure from workload descriptions, covering networking, identity, security, and multi-region topologies aligned with Azure Well-Architected Framework. Targets cloud architects and platform engineers planning landing zones, hub-spoke networks, and subscription-scope deployments.

Generated from the current SKILL.md.

Does this skill generate Terraform or Bicep?
It generates both Bicep and Terraform directly. The skill targets subscription-scope and multi-resource-group deployments without using Azure Developer CLI (azd).
What Azure infrastructure patterns does this skill handle?
It covers enterprise patterns including landing zones, hub-spoke networks, multi-region disaster recovery, VNets, firewalls, private endpoints, VPN gateways, identity, RBAC, and compliance-driven topologies.
Should I use this skill for application-centric workflows?
No. The skill description explicitly recommends using azure-prepare instead for app-centric workflows. This skill is optimized for infrastructure and platform engineering.
Does this skill validate generated infrastructure code?
Yes. It includes validation for both Bicep (az bicep build) and Terraform (terraform validate) and checks for pairing constraint violations before deployment.
What MCP tools does this skill rely on?
It uses insights_get, get_azure_bestpractices_get, wellarchitectedframework_serviceguide_get, microsoft_docs_search, microsoft_docs_fetch, and bicepschema_get to fetch best practices, WAF guidance, and schema definitions.

Generated from the current SKILL.md. These answers refresh after source changes.