Provisioning a Function App

1. Start Locally

Firstly, we need to launch Locally which we can do from a terminal by running:

Once Locally has started, the Locally Dashboard will open automatically:

2. Create a Resource Group

Next we can create the Resource Group:

There's two things to note here:

1. The Azure CLI supports Automatic Configuration, meaning that it can automatically be configured to work against Locally just by prefixing commands with locally run.
2. Locally intentionally uses a different set of locations to Azure as a safety precaution, so that you can be confident you're deploying against Locally rather than regular Azure. You can also configure Locally to use the Azure locations too, but you'll want to be extra sure that you're prefixing commands with locally run when you do.

3. Create the Storage Account and Function App

A Function App keeps its state - trigger leases, timer schedules, the deployed package itself - in a Storage Account, so that comes first:

Now the Function App itself:

{
  "note": "some fields skipped for brevity",

  "defaultHostName": "samplefuncapp1.furnace.locally:5663",
  "kind": "functionapp",
  "location": "berlin",
  "name": "samplefuncapp1",
  "resourceGroup": "sample-resources",
  "state": "Running",
  "type": "Microsoft.Web/sites"
}

That furnace.locally hostname is served by Locally's own DNS server and points at the Function App Emulator running on your machine.

4. Build a function package

With somewhere to deploy to, we need something to deploy. A Function App package is a zip of the files you'd have in your project, so we can build the smallest useful one by hand.

The host configuration:

A package.json, which is what tells the Functions host this is a Node app:

Then the function itself. Each function is a directory with a function.json describing its triggers and bindings, and the code they call:

The function.json declares an anonymous HTTP trigger and an HTTP response:

{
  "bindings": [
    { "authLevel": "anonymous", "type": "httpTrigger", "direction": "in", "name": "req", "methods": ["get"] },
    { "type": "http", "direction": "out", "name": "res" }
  ]
}

And the handler it points at:

module.exports = async function (context, req) {
  context.res = { body: "hello from Locally" };
};

authLevel: anonymous keeps this guide to one moving part. Functions default to requiring a key, and Locally enforces those keys too, so an authenticated function can be tested the same way.

Then zip it, which is the artefact Azure's own zip deploy expects:

5. Deploy the package

Locally can deploy the package for you:

Deploying app.zip to function app "samplefuncapp1"...
Deployment 81ebc763-7a60-492a-8084-55276d9f689a accepted. Waiting for worker to start...
Deployed. Dashboard: https://samplefuncapp1.furnace.locally:5663/_ui/

Environment variables the function needs can go alongside it, which saves a round-trip through app settings while you're iterating:

6. Invoke the function

And then we can call it:

hello from Locally

That's your code, running in a real Functions worker on your machine, reached through the same host name and route it would have in Azure.

7. List the Function Apps

To see the Function Apps in the Resource Group:

Name             State    Host
---------------  -------  ----------------------------------
samplefuncapp1   Running  samplefuncapp1.furnace.locally:5663

We can see the Function App in the Locally Dashboard too:

8. Tidy up

Finally, we can tidy up. To remove the Resource Group and everything within it:

That stops the function worker as well as removing the records of it, so nothing is left running on your machine afterwards.

Doing this with other tooling

Whilst this guide used the Azure CLI, Function Apps work the same way through any of the tooling that Locally supports - a Microsoft.Web/sites resource in HashiCorp Terraform or OpenTofu, Pulumi, Bicep or an ARM Template all provision against Locally in the same way, with only the location changed.

Deployment works the same way too: az functionapp deployment source config-zip and the Azure Functions Core Tools both target Locally's Functions host unchanged, and locally function deploy above is a shortcut rather than a different mechanism.

Next steps

The Function App Emulator shows every invocation with its trigger payload. To read secrets without credentials in the app, see Managed Identity.

Should you encounter any issues, please take a look at the troubleshooting section.