azure-functions-core-tools

Command line tools for Azure Functions

1,295

429

1,295

658

View on GitHub View on NPM

Top Related Projects

serverless

46,361

⚡ Serverless Framework – Effortlessly build apps that auto-scale, incur zero costs when idle, and require minimal maintenance using AWS Lambda and other managed cloud services.

nuclio

5,271

High-Performance Serverless event and data processing platform

kubeless

6,860

Kubernetes Native Serverless Framework

openwhisk

6,467

Apache OpenWhisk is an open source serverless cloud platform

Quick Overview

Azure Functions Core Tools is a command-line interface for developing and testing Azure Functions locally. It provides a local development experience for creating, testing, and deploying Azure Functions, allowing developers to work offline and streamline their development process.

Pros

Local development and testing of Azure Functions without the need for constant cloud deployment
Cross-platform support (Windows, macOS, and Linux)
Seamless integration with Visual Studio Code and other development environments
Ability to run and debug functions locally with full access to logs and debugging tools

Cons

Requires separate installation and setup, which can be time-consuming for new users
May have version compatibility issues with Azure Functions runtime in the cloud
Limited support for some advanced Azure Functions features in local development
Can consume significant system resources when running multiple functions locally

Getting Started

To get started with Azure Functions Core Tools:

Install Node.js (version 10.x or later)
Install the Azure Functions Core Tools:

npm install -g azure-functions-core-tools@4

Create a new function project:

func init MyFunctionProject
cd MyFunctionProject

Create a new function:

func new --name MyHttpTrigger --template "HTTP trigger"

Run the function locally:

func start

Your function is now running locally and can be accessed at http://localhost:7071/api/MyHttpTrigger.

Competitor Comparisons

serverless

46,361

⚡ Serverless Framework – Effortlessly build apps that auto-scale, incur zero costs when idle, and require minimal maintenance using AWS Lambda and other managed cloud services.

Pros of Serverless

Multi-cloud support (AWS, Azure, Google Cloud, etc.)
Extensive plugin ecosystem for enhanced functionality
Strong community support and active development

Cons of Serverless

Steeper learning curve for beginners
More complex configuration for advanced scenarios
Potential vendor lock-in with cloud-specific features

Code Comparison

Azure Functions Core Tools:

func init MyFunctionProject
func new --name MyFunction --template "HTTP trigger"
func start

Serverless:

service: my-service
provider:
  name: aws
  runtime: nodejs14.x
functions:
  hello:
    handler: handler.hello
    events:
      - http: GET hello

Key Differences

Azure Functions Core Tools is specific to Azure, while Serverless supports multiple cloud providers
Serverless uses YAML for configuration, Azure Functions Core Tools uses JSON and host.json
Azure Functions Core Tools provides a more streamlined experience for Azure-specific development
Serverless offers more flexibility in terms of cloud provider choice and customization

Use Cases

Choose Azure Functions Core Tools for Azure-focused serverless development
Opt for Serverless when working with multiple cloud providers or requiring extensive customization

Both tools are actively maintained and have strong communities, making them viable options for serverless development depending on specific project requirements and cloud preferences.

nuclio

5,271

High-Performance Serverless event and data processing platform

Pros of nuclio

Platform-agnostic: Can run on various cloud providers and on-premises
High performance: Optimized for low latency and high throughput
Advanced auto-scaling capabilities

Cons of nuclio

Steeper learning curve compared to Azure Functions
Less extensive documentation and community support
Limited integration with Microsoft ecosystem

Code Comparison

azure-functions-core-tools:

[FunctionName("HttpTrigger")]
public static async Task<IActionResult> Run(
    [HttpTrigger(AuthorizationLevel.Function, "get", "post", Route = null)] HttpRequest req,
    ILogger log)
{
    // Function logic here
}

nuclio:

package handler

import (
    "github.com/nuclio/nuclio-sdk-go"
)

func Handler(context *nuclio.Context, event nuclio.Event) (interface{}, error) {
    // Function logic here
}

Both frameworks allow for easy creation of serverless functions, but they differ in syntax and runtime environment. Azure Functions Core Tools is tightly integrated with the Azure ecosystem, while nuclio offers more flexibility in deployment options and supports multiple languages and platforms.

kubeless

6,860

Kubernetes Native Serverless Framework

Pros of Kubeless

Platform-agnostic: Works with any Kubernetes cluster, not tied to a specific cloud provider
Supports multiple programming languages out-of-the-box
Leverages Kubernetes native concepts, making it easier for teams already familiar with Kubernetes

Cons of Kubeless

Less extensive documentation and community support compared to Azure Functions
Requires more setup and configuration, as it's not a fully managed service
Limited integration with other cloud services compared to Azure's ecosystem

Code Comparison

Azure Functions Core Tools:

func new --name MyFunction --template "HTTP trigger"
func start

Kubeless:

kubeless function deploy hello --runtime python3.7 \
                               --from-file test.py \
                               --handler test.hello
kubeless function call hello --data '{"msg": "Hello World!"}'

Both tools provide CLI interfaces for creating and managing serverless functions, but Kubeless is more focused on Kubernetes-native deployment and management, while Azure Functions Core Tools offers a more streamlined experience for Azure-specific deployments.

openwhisk

6,467

Apache OpenWhisk is an open source serverless cloud platform

Pros of OpenWhisk

Open-source and vendor-neutral, allowing for greater flexibility and community contributions
Supports multiple programming languages and runtimes out-of-the-box
Offers a distributed architecture for better scalability and fault tolerance

Cons of OpenWhisk

Steeper learning curve and more complex setup compared to Azure Functions Core Tools
Less integrated with cloud services and tooling ecosystems
May require more infrastructure management and maintenance

Code Comparison

OpenWhisk action example:

function main(params) {
    var name = params.name || 'World';
    return {payload: 'Hello, ' + name + '!'};
}

Azure Functions Core Tools function example:

public static async Task<IActionResult> Run(
    HttpRequest req,
    ILogger log)
{
    string name = req.Query["name"];
    return new OkObjectResult($"Hello, {name}");
}

Both examples demonstrate simple serverless functions, but OpenWhisk uses a more language-agnostic approach, while Azure Functions Core Tools integrates more closely with .NET and Azure-specific patterns.

Convert designs to code with AI

Introducing Visual Copilot: A new AI model to turn Figma designs to high quality code using your components.

Try Visual Copilot

README

ï»¿

Branch	Status
v4.x
v3.x
dev
v1.x

Azure Functions Core Tools

The Azure Functions Core Tools provide a local development experience for creating, developing, testing, running, and debugging Azure Functions.

Versions

v1 (v1.x branch): Requires .NET 4.7.1 Windows Only

v2 (dev branch): Self-contained cross-platform package

v3: (v3.x branch): Self-contained cross-platform package

v4: (v4.x branch): Self-contained cross-platform package (recommended)

Installing

Windows

To download and install with MSI:

v4

Windows 64-bit (VS Code debugging requires 64-bit)
Windows 32-bit

v3

Windows 64-bit (VS Code debugging requires 64-bit)
Windows 32-bit

To install with npm:

v4

npm i -g azure-functions-core-tools@4 --unsafe-perm true

v3

npm i -g azure-functions-core-tools@3 --unsafe-perm true

v2

npm i -g azure-functions-core-tools@2 --unsafe-perm true

To install with chocolatey:

v4

choco install azure-functions-core-tools

v3

choco install azure-functions-core-tools-3

Notice: To debug functions under vscode, the 64-bit version is required

choco install azure-functions-core-tools-3 --params "'/x64'"

v2

choco install azure-functions-core-tools-2

To install with winget:

v4

winget install Microsoft.Azure.FunctionsCoreTools

v3

winget install Microsoft.Azure.FunctionsCoreTools -v 3.0.3904

Mac

Homebrew:

v4

brew tap azure/functions
brew install azure-functions-core-tools@4

v3

brew tap azure/functions
brew install azure-functions-core-tools@3

v2

brew tap azure/functions
brew install azure-functions-core-tools@2

Homebrew allows side by side installation of v2 and v3, you can switch between the versions using

brew link --overwrite azure-functions-core-tools@3

Linux

1. Set up package feed

Ubuntu 22.04

wget -q https://packages.microsoft.com/config/ubuntu/22.04/packages-microsoft-prod.deb
sudo dpkg -i packages-microsoft-prod.deb

Ubuntu 20.04

wget -q https://packages.microsoft.com/config/ubuntu/20.04/packages-microsoft-prod.deb
sudo dpkg -i packages-microsoft-prod.deb

Ubuntu 19.04

wget -q https://packages.microsoft.com/config/ubuntu/19.04/packages-microsoft-prod.deb
sudo dpkg -i packages-microsoft-prod.deb

Ubuntu 18.10

wget -q https://packages.microsoft.com/config/ubuntu/18.10/packages-microsoft-prod.deb
sudo dpkg -i packages-microsoft-prod.deb

Ubuntu 18.04

wget -q https://packages.microsoft.com/config/ubuntu/18.04/packages-microsoft-prod.deb
sudo dpkg -i packages-microsoft-prod.deb

Ubuntu 16.04 / Linux Mint 18

wget -q https://packages.microsoft.com/config/ubuntu/16.04/packages-microsoft-prod.deb
sudo dpkg -i packages-microsoft-prod.deb

Debian 12

export DEBIAN_VERSION=12

apt-get update && apt-get install gpg wget  -y
wget -qO- https://packages.microsoft.com/keys/microsoft.asc | gpg --dearmor | tee /usr/share/keyrings/microsoft-prod.gpg
wget -q https://packages.microsoft.com/config/debian/$DEBIAN_VERSION/prod.list
mv prod.list /etc/apt/sources.list.d/microsoft-prod.list
chown root:root /usr/share/keyrings/microsoft-prod.gpg
chown root:root /etc/apt/sources.list.d/microsoft-prod.list
apt-get update && apt-get install azure-functions-core-tools-4  -y
apt-get update && apt-get install libicu-dev  -y

2. Install

v4

sudo apt-get update
sudo apt-get install azure-functions-core-tools-4

v3

sudo apt-get update
sudo apt-get install azure-functions-core-tools-3

v2

sudo apt-get update
sudo apt-get install azure-functions-core-tools-2

Other Linux Distributions

Download latest release

Download the latest release for your platform from here.
Unzip release zip

Using your preferred tool, unzip the downloaded release. To unzip into an azure-functions-cli directory using the unzip tool, run this command from the directory containing the downloaded release zip:
```
unzip -d azure-functions-cli Azure.Functions.Cli.linux-x64.*.zip
```
Make the func command executable

Zip files do not maintain the executable bit on binaries. So, you'll need to make the func binary, as well as gozip (used by func during packaging) executables. Assuming you used the instructions above to unzip:
```
cd azure-functions-cli
chmod +x func
chmod +x gozip
./func
```
Optionally add func to your $PATH

To execute the func command without specifying the full path to the binary, add its directory to your $PATH environment variable. Assuming you're still following along from above:
```
export PATH=`pwd`:$PATH
func
```

Code and test Azure Functions locally

NOTE: npm can be used on all platforms. On unix platforms, you may need to specify --unsafe-perm if you are running npm with sudo. That's due to npm behavior of post install script.

Getting Started on Kubernetes

Using the Core Tools, you can easily configure a Kubernetes cluster and run Azure Functions on it.

Prerequisites

Installing Kubernetes scalers

This deploys KEDA to your cluster which allows you to deploy your functions in a scale-to-zero by default for non-http scenarios only.

func kubernetes install --namespace {namespace}

KEDA: Handles monitoring polling event sources currently QueueTrigger and ServiceBusTrigger.

Deploy to Kubernetes

First make sure you have Dockerfile for your project. You can generate one using

func init --docker # or --docker-only (for existing projects)

Then to deploy to kubernetes

func kubernetes deploy \
    --name myfunction \
    --namespace functions-ns \
    --registry <docker-hub-id or registry-server>

This will build the current Dockerfile and push the image to the registry specified, then deploys a Secret, Deployment, and ScaledObject. If your functions have httpTrigger, you'll get an additional Deployment and Service.

Deploy using a private registry

func kubernetes deploy --name myfunction --registry <docker-hub-id or registry-server> --pull-secret <registry auth secret>

Deploy a function to Knative

Prerequisites

Knative

Deploying Azure Functions to knative is supported with the --platform knative flag. The Core Tools CLI identifies non HTTP trigger functions and annotates the knative manifest with the the minScale annotation to opt out of scale-to-zero.

func deploy --platform knative --name myfunction --registry <docker-hub-id or registry-server>

Deploying a function to AKS using ACR

Using the configuration options an Azure Function app can also be deployed to a AKS (Azure Kubernetes Service) Kubernetes cluster and use ACR as the registry server. Do all of the following before you run the deployment command.

Create a AKS cluster

You can create an AKS cluster using the Azure Portal or using Azure CLI.

Once your AKS cluster is created make sure that you can access it using kubectl. To make kubectl run in the context of your cluster, configure a connection using the command below.

az aks get-credentials \
    --name FunctionsCluster \
    --resource-group <resource-group-name>

To verify the connection to your cluster run the following command

> kubectl get nodes

NAME                       STATUS    ROLES     AGE       VERSION
aks-agentpool-20257154-0   Ready     agent     1d        v1.11.5
aks-agentpool-20257154-1   Ready     agent     1d        v1.11.5
aks-agentpool-20257154-2   Ready     agent     1d        v1.11.5

Create a ACR Registry

An ACR instance can be created using the Azure Portal or the Azure CLI

Login to the ACR Registry

Before pushing and pulling container images, you must log in to the ACR instance.

az acr login --name <acrName>

Give the AKS cluster access to the ACR Registry

The AKS cluster needs access to the ACR Registry to pull the container. Azure creates a service principal to support cluster operability with other Azure resources. This can be used for authentication with an ACR registry. See here for how to grant the right access here: Authenticate with Azure Container Registry from Azure Kubernetes Service

Run the deployment

The deployment will build the docker container and upload the container image to your referenced ACR instance (Note: Specify the ACR Login Server in the --registry parameter this is usually of the form <container_registry_name>.azurecr.io) and then your AKS cluster will use that as a source to obtain the container and deploy it.

func kubernetes deploy --name myfunction --registry <acr-registry-loginserver>

If the deployment is successful, you should see this:

Function deployed successfully! Function IP: 40.121.21.192

Verifying your deployment

You can verify your deployment by using the Kubernetes web dashboard. To start the Kubernetes dashboard, use the az aks browse command.

az aks browse --resource-group myResourceGroup --name myAKSCluster

In the Kubernetes dashboard look for the namespace "azure-functions" and make sure that a pod has been deployed sucessfully with your container.

Deploying Azure Functions with Virtual-Kubelet

Azure Functions running on Kubernetes can take advantage of true serverless containers model by getting deployed to different providers of Virtual Kubelet, such as Azure Container Instances.

Functions deployed to Kubernetes already contain all the tolerations needed to be schedulable to Virtual Kubelet nodes. All you need to do is to set up VKubelet on your Kubernetes cluster:

Important note: Virtual Kubelet does not currently allow for Kubernetes Services to route external traffic to pods. This means that HTTP triggered functions will not receive traffic running on a VKubelet provider (including ACI).

A good usage scenario for using functions with VKubelet would be with event triggered / time triggered functions that do not rely on external HTTP traffic.

Known Issues:

func extensions command require the dotnet cli to be installed and on your path. This requirement is tracked here. You can install .NET Core for your platform from https://www.microsoft.com/net/download/

Default Directories

CurrentDirectory: is the default directory the functions runtime looks for functions in.
%TMP%\LogFiles\Application\Functions: is the default directory for logs. It mirrors the logs directory on Azure as well.

Telemetry

The Azure Functions Core tools collect usage data in order to help us improve your experience. The data is anonymous and doesn't include any user specific or personal information. The data is collected by Microsoft.

You can opt-out of telemetry by setting the FUNCTIONS_CORE_TOOLS_TELEMETRY_OPTOUT environment variable to '1' or 'true' using your favorite shell.

Microsoft privacy statement

License

This project is under the benevolent umbrella of the .NET Foundation and is licensed under the MIT License

This project has adopted the Microsoft Open Source Code of Conduct. For more information see the Code of Conduct FAQ or contact opencode@microsoft.com with any additional questions or comments.

Contact Us

For questions on Azure Functions or the tools, you can ask questions here:

File bugs at Azure Functions Core Tools repo on GitHub.

Top Related Projects

Convert designs to code with AI

Introducing Visual Copilot: A new AI model to turn Figma designs to high quality code using your components.

Try Visual Copilot