How azure/azure-functions-templates works
Project type and purpose
• This is a monorepo of “Azure Functions” templates (both script-type and pre-compiled .NET templates).
• Purpose: host, build, package, version and publish function-app starter templates consumed by Azure Functions Core Tools, Azure Portal, VS Code, Visual Studio, and Extension Bundles.
File structure
• Top-level directories:
• Functions.Templates/ – raw template definitions (folders per trigger type, language).
• Build/ – build scripts (gulp), package files (.nuspec), localization config.
• Docs/ – markdown and JSON schema for metadata and actions.
• Tools/ – helper console apps and scripts (e.g., CheckResourceStrings).
• eng/ – CI configuration (YAML templates, builds).
• Build artifacts: package-lock.json, package.json for Node/Gulp.
• Patterns: separation of template definitions vs. build logic vs. docs vs. CI.
• Packaging: uses .nuspec files under Build/PackageFiles for .NET templates; extension-bundle nuspecs for script templates.
README for additional insights
• Build prerequisites (Node, Gulp) and steps (gulp build-all).
• Two template families: dotnet precompiled (project & item templates with .template.config) and script-type (metadata.json, bindings.json, resources.resx, sample.dat).
• Artifacts deployed:
• .nupkg for .NET (VS/VS Code/Core Tools)
• zip or static files for script templates (Extension Bundles).
• CI branches (dev, release/main) drive build and release.
a. Main components to include
• Source Repository – houses Functions.Templates, Docs, Build, Tools, eng
• CI/CD Pipeline – YAML templates in eng/ci trigger on commits/PRs
• Build Engine – Node + Gulp tasks (Build/gulpfile.js) that:
– compile .NET templates (into nupkg)
– bundle script templates (copy metadata, resx, code)
– generate documentation artifacts
• Packaging – .nuspec files produce:
– Dotnet Project & Item template packages (v3.x, v4.x, isolated)
– Extension Bundle packages (1.x–4.x, preview)
• Artifact Repository / Feed – NuGet feed for .NET, Static content for extension bundles
• Consumers – Azure Functions Core Tools, Azure Portal, Visual Studio Code, Visual Studio
• Documentation Site – Docs files used to generate schema reference / UI help
b. Relationships and interactions
– Developer commits → CI/CD triggers build → Build Engine runs Gulp → produces packages → publishes to feed/storage → Consumers fetch templates on “func new” or new-project wizard
– Tools/CheckResourceStrings validates resource keys → integrated in CI
– Docs schemas drive metadata.json and UI in clients
c. Architectural patterns/design principles
– Separation of Concerns: template definitions vs. build scripts vs. CI configs vs. docs
– Content-Driven: metadata-first approach (schema files drive UI prompts)
– Versioned Packaging: multiple nuspecs support side-by-side runtime versions
– Automation: CI templates make builds reproducible; Gulp tasks orchestrate multi-language packaging
d. Relevant technologies/frameworks/libraries
– Node.js & Gulp (Build pipeline)
– .NET templating engine (dotnet new)
– NuGet (.nuspec) for .NET templates
– JSON metadata, RESX for localization
– YAML for Azure Pipelines (eng/ci)
– PowerShell scripts for tooling (UpdateTemplatePackages.ps1)
Detail guidance
• Every folder group as a logical component (Functions.Templates, Build, Docs, Tools, eng)
• External dependencies: Node.js, .NET SDK, Azure DevOps
• Avoid over-splitting: group similar languages/triggers under one “Script Templates” component
• Packaging outputs and their targets (VS, VS Code, Portal, Core Tools, Extension Bundles)