Azure Skills Plugin

The azure-kubernetes skill provides authoritative guidance for planning, creating, and configuring production-ready AKS clusters. It distinguishes between Day-0 decisions (networking, API server access) which are difficult to change after creation, and Day-1 features (observability, autoscaling) that can be enabled post-creation.

Key Capabilities:

• Cluster Selection: Choosing between AKS Automatic (curated, best-practice default) and AKS Standard (full control).
• Networking Design: Configuring Pod IP models (Azure CNI Overlay vs. VNet-routable), Dataplanes (Cilium), Egress (Static Egress Gateway), and Ingress (App Routing, Istio, or Application Gateway).
• Security & Identity: Implementing Microsoft Entra ID, Workload Identity, Azure Key Vault (via Secrets Store CSI Driver), and Azure Policy.
• Operations: Setting up observability (Managed Prometheus, Container Insights), upgrade strategies (Maintenance Windows, Fleet Manager), and performance optimizations (Ephemeral OS disks, KEDA).
• Cost & Reliability: Utilizing Spot node pools, Availability Zones, and Pod Disruption Budgets (PDBs).

The azure-app-onboard skill is an end-to-end orchestrator designed to take a business idea, app idea, or existing codebase and turn it into a running Azure deployment. It automates service selection, architecture planning, infrastructure-as-code (IaC) scaffolding, and deployment, providing cost estimates and pre-deployment approval gates along the way.

Best Use Cases

• Deploying existing code when you are unsure which Azure services to use.
• Migrating existing applications to Azure with minimal changes.
• Checking if existing code is ready for Azure deployment.
• Obtaining architecture plans and cost estimates before committing to infrastructure.
• Getting guided onboarding for Azure without prior experience.

Inputs and Outputs

• Inputs: Business ideas, existing codebases, and optional budget or scale preferences.
• Outputs: Architecture plans, cost estimates, IaC files, and deployed Azure resources.

Important Constraints

• Do NOT use for running azd up (use azure-deploy instead).
• Do NOT use for optimizing existing costs (use azure-cost instead).
• Do NOT use for generating Bicep/Terraform for a known architecture (use azure-prepare instead).
• Do NOT use for Kubernetes/AKS management (use azure-kubernetes instead).

The Pairing Constraints Index provides a categorized directory of constraint files for the azure-enterprise-infra-planner. Use this index to find specific architectural constraints and resource pairing rules based on Azure service categories.

Categories include:

• AI & ML: AI Search, Cognitive Services, ML Workspace
• Compute (PaaS): App Service, ASP, Function App, Container App, CAE, ACR, Static Web App
• Compute (IaaS): AKS, VM, VMSS, Availability Set, Managed Disk
• Data (Relational): SQL Server, SQL Database, MySQL, PostgreSQL
• Data (Analytics): Cosmos DB, Redis, Storage, Data Factory, Synapse
• Messaging: Event Grid, Event Hub, Service Bus
• Monitoring: App Insights, Log Analytics
• Networking (Core): VNet, Subnet, NSG, Route Table, NIC, Public IP, NAT Gateway
• Networking (Traffic): App Gateway, Front Door, LB, APIM
• Networking (Connectivity): Bastion, Firewall, VPN GW, DNS, Private DNS, PE
• Security: Key Vault, Managed Identity

The azure-app-onboard-prereq skill is used to evaluate a repository for build health, app completeness, and Azure deployment feasibility before any infrastructure work begins. It answers questions like "is my app ready to deploy?", "what does my app need to deploy?", and "can I ship this to Azure?".

Key Capabilities

• Build Health: Evaluates if the code can be built.
• Completeness: Checks for missing dependencies, configurations, or files (like Dockerfiles).
• Stack Compatibility: Verifies if the current frameworks and dependencies are supported by Azure.
• Deployment Feasibility: Identifies blockers that prevent successful deployment.

When NOT to use this skill

Do not use this skill if you intend to:

• Validate infrastructure (Bicep/Terraform/azure.yaml) $\rightarrow$ Use azure-validate.
• Generate Infrastructure as Code (IaC) $\rightarrow$ Use azure-prepare.
• Perform end-to-end idea-to-production $\rightarrow$ Use azure-app-onboard.
• Run azd up or actual deployment $\rightarrow$ Use azure-deploy.

Important Constraints

Strictly NO package manager commands: Under no circumstances should npm install, npm test, pip install, dotnet build, or any similar install/build/test commands be run. This skill performs static-only verification. The only exception is if the agent has specifically modified or written code and has received explicit, per-command user consent via a build-validation gate.

The finetuning sub-skill provides tools and guidance for fine-tuning models on Azure AI Foundry using three primary methods:

1. SFT (Supervised Fine-Tuning): Standard supervised training.
2. DPO (Direct Preference Optimization): Training based on preference pairs.
3. RFT (Reinforcement with Graders): Reinforcement learning using automated graders.

This skill covers the entire lifecycle: dataset preparation, training job submission, monitoring, deployment, and evaluation. It also includes utilities for distillation, synthetic data generation, and dataset quality scoring.

When to use this skill:

• Fine-tuning models (SFT, DPO, or RFT).
• Preparing, validating, or formatting training data.
• Submitting, monitoring, or diagnosing training jobs.
• Calibrating graders or pass thresholds for RFT.
• Deploying or evaluating a fine-tuned model.
• Choosing between training types.
• Distillation or synthetic data generation.
• Large file uploads for training data.
• Cleaning up fine-tuning resources.

When NOT to use this skill:

• General model deployment without fine-tuning (use deploy-model).
• Agent creation (use agents).
• Prompt optimization without training (use prompt-optimizer).