# Arc Jumpstart keeps the automation separate from the documentation

> The microsoft/azure_arc repository holds the automation scripts behind the Arc Jumpstart website, split into one directory per Azure Arc scenario. Contributors are told to clone a second repository for the documentation, and most contributions require a Microsoft Contributor License Agreement.

**microsoft/azure_arc** — Automated Azure Arc, Azure Local, IoT, and Kubernetes environments

- Repository: https://github.com/microsoft/azure_arc
- Website: https://aka.ms/ArcJumpstart
- Stars: 813 · Forks: 626
- Language: HTML
- License: CC-BY-4.0
- Published: 2026-10-20 · Updated: 2026-10-20 · Language: en
- Canonical page: https://hysenlabs.com/projects/microsoft-azure-arc

## One directory per scenario, with no releases to install

The repository's own description is short: automated Azure Arc, Azure Local, IoT and Kubernetes environments. The default branch is main, the last push was on 2026-09-22, and the repository has no GitHub releases at all. That last point matters more than it sounds for anyone who came looking for a downloadable artifact.

What the tree contains is a set of scenario directories, each with its own name and its own scope. The listing shows arc_data_services/, azure_arc_app_services_jumpstart/, azure_arc_data_jumpstart/, azure_arc_k8s_jumpstart/, azure_arc_ml_jumpstart/, azure_arc_servers_jumpstart/, azure_arc_sqlsrv_jumpstart/, azure_arc_vsphere_jumpstart/, azure_edge_iot_ops_jumpstart/, azure_jumpstart_ag/, azure_jumpstart_arcbox/ and azure_jumpstart_localbox/.

Read as a set, that covers the surfaces someone deploying Arc-enabled infrastructure touches: application services, data, Kubernetes, machine learning, servers, SQL Server, vSphere, edge IoT operations, Azure Arc enabled for Azure Local, and Arc Box. There is also an archive/ directory, which suggests retired scenarios are kept rather than deleted.

Around those sit the infrastructure directories for contributors rather than users: .azure-pipelines/ for CI, .devcontainer/ for a local development environment, .github/ for workflows, and tools/, scripts/ and tests/ directories.

## Contributing means cloning two repositories

The documented contribution path starts with a clone, and the instruction covers both the code and the docs:

```bash
git clone https://github.com/microsoft/azure_arc.git
git clone https://github.com/Azure/arc_jumpstart_docs.git
```

The stated reason is that the documentation source lives in the dedicated arc_jumpstart_docs repository, and that repository in turn populates the Arc Jumpstart website at https://aka.ms/arcjumpstart. The current repository is described as the backend source code repository that complements it.

That split is the defining structural fact about the project. It is not a documentation site with a few scripts in it; the prose is somewhere else entirely. A change to a scenario's scripts belongs here, and a change to how a scenario is explained belongs in the other repository.

Keeping the clones current is a pull from main:

```bash
git pull origin main
```

The README also offers a lighter clone for contributors who do not need the full history, using a partial clone that skips the blobs:

```bash
git clone --filter=blob:none https://github.com/microsoft/azure_arc
```

The reasoning given is size and speed. By default a clone carries all the files plus blobs and diff history, and this form omits the blobs.

Where to ask questions is also documented. A GitHub discussion is offered for anyone unsure about contributing, and the contribution guidelines live behind https://aka.ms/JumpstartContribution.

## The CLA bot decides whether your pull request can proceed

Most contributions to this repository require agreeing to a Contributor License Agreement, which the README states declares that you have the right to, and actually do, grant the rights to use your contribution. The Microsoft Contributor License Agreements site at https://cla.opensource.microsoft.com holds the details.

The mechanics are automated. When a pull request is submitted, a CLA bot determines whether the contributor needs to provide a CLA and decorates the pull request accordingly, with a status check or a comment. The README notes that this needs to be done only once across all repositories using Microsoft's CLA, which is a real convenience if you contribute to more than one Microsoft project.

A practical consequence for a team is that the sign-off happens per person rather than per organisation, so a contributor who has never signed has to clear that step before review starts. That is worth doing before opening a large pull request rather than after.

The project has also adopted the Microsoft Open Source Code of Conduct, with a FAQ linked and a contact address given for questions. Separate from the CLA, REPO_POLICIES.md holds the automated pull request and issue management policies, which the README sends you to rather than reproducing.

## Two license files and a separate code license

The top-level tree carries both LICENSE and LICENSE-CODE, alongside SECURITY.md, CONTRIBUTING.md, CODE_OF_CONDUCT.md, AI_DISCLAIMER.MD and REPO_POLICIES.md. The repository is published under CC-BY-4.0, which is a content licence rather than a software licence, and the presence of a distinct code licence file points to a split between the two.

That split is common in documentation-and-code repositories where the written material and the scripts need different permissions, and it is worth reading both files before reusing anything. The README itself does not summarise what each one covers, so anyone planning to vendor a scenario directory into their own automation should check the terms directly rather than assume the CC-BY-4.0 tag applies to the scripts.

There is also a trademark section, which matters because this repository is full of Microsoft product names by necessity. The README states that the project may contain trademarks or logos for projects, products or services, that authorised use of Microsoft trademarks is subject to Microsoft's Trademark and Brand Guidelines, and that use of the trademarks in modified versions must not cause confusion or imply Microsoft sponsorship. Third-party trademarks remain subject to their own policies.

And there is an AI_DISCLAIMER.MD at the root, a file whose contents the README does not describe.

## The website is the front end, this repository is the plumbing

It helps to separate the two artefacts a newcomer meets. The Arc Jumpstart site at https://aka.ms/arcjumpstart is what a person browsing for a scenario sees, and it is populated from the documentation repository. The repository here is the backend source code that the site is generated from and that the automation runs out of.

That division of labour explains why the README opens by describing the repository as a go-to resource for working with and contributing to the Jumpstart automation scripts and tools, and then lists what you will find there: the automation source code used in the scenarios and solutions, and the supportive documents and files used across the website.

The second category is the one easy to overlook. Images and reference assets that the documentation pages depend on live here too, so a docs pull request that changes a screenshot can touch both repositories.

If your interest is in automating an Arc-enabled environment rather than in the Jumpstart project as a codebase, this repository is the source of the scripts you would adapt, not a tool you install. Nothing here is packaged, released or versioned for consumption as a dependency.

## Where this fits against running the scenarios by hand

The honest comparison is not with another GitHub project but with the alternative of scripting the same deployments yourself.

The Jumpstart approach bundles the automation for a scenario into a directory with its supporting files, which means you can read one example end to end and adapt it. The alternative, writing PowerShell or Bicep for an Arc-enabled server or a local box yourself, gives you full control but starts from a blank page and leaves you to discover the same ordering steps that the scenario directories already encode.

What the Jumpstart approach does not give you is a supported product boundary. There are no releases, so there is no version to pin, no changelog to read for breaking changes, and no upgrade path between scenario revisions. The release notes live in a separate repository, and the two named repositories that hold documentation, one under Azure and one under microsoft, already signal that this is a collection of maintained pieces rather than one tool.

For that reason, treating the scenario directories as reference implementations rather than as a dependency is the mindset that fits. You copy the approach, you do not upgrade to it.

## Conclusion

Work in microsoft/azure_arc when you are changing the automation behind a Jumpstart scenario rather than the prose, since the website content lives in the separate Azure/arc_jumpstart_docs repository. Do not expect a turnkey product here, the tree is a set of scenario directories and supporting policy files with no released versions. Before opening a pull request, sign the Microsoft Contributor License Agreement, and check REPO_POLICIES.md for the automated issue and pull request management rules that apply to the repository.

## FAQ

### What is in the microsoft/azure_arc repository?

It holds the Arc Jumpstart automation scripts and tools used by the scenarios and solutions, plus the supportive documents and files the Arc Jumpstart website uses. The documentation source code itself is in the separate Azure/arc_jumpstart_docs repository.

### How do I contribute to Arc Jumpstart?

Clone both this repository and the documentation repository, then read the contribution guidelines at https://aka.ms/JumpstartContribution. Most contributions need a Microsoft Contributor License Agreement, which a bot checks automatically on the pull request, and the process has to be done only once across repositories using Microsoft's CLA.

### Can I install Arc Jumpstart from GitHub releases?

No. The repository has no GitHub releases. It is a source repository of scripts and supporting files for the scenarios rather than a packaged tool, so the material is cloned and adapted rather than installed as a dependency.

## Sources

- [Issues](https://github.com/microsoft/azure_arc/issues)
- [License: CC-BY-4.0](https://github.com/microsoft/azure_arc/blob/main/LICENSE)
- [microsoft/azure_arc on GitHub](https://github.com/microsoft/azure_arc)
- [Project website](https://aka.ms/ArcJumpstart)
- [README](https://github.com/microsoft/azure_arc/blob/main/README.md)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/microsoft-azure-arc