How can I use NuGet packages in my Azure Functions?

Solution 1:

Yes! Although the Azure Functions portal does not currently provide a mechanism to add and manage NuGet packages, the runtime supports NuGet references and will make sure they are correctly used when compiling and executing your functions.

In order to define your dependencies, you need to create a Project.json file with the required NuGet package references. Here is an example that adds a reference to Microsoft.ProjectOxford.Face version 1.1.0:

{
  "frameworks": {
    "net46":{
      "dependencies": {
        "Microsoft.ProjectOxford.Face": "1.1.0"
      }
    }
   }
}

The Azure Functions portal provides a convenient way to manage your function files, which we can use to create (or upload) our project.json:

1. In the function's develop section, click on view files
2. Click on the option to create a file (you can also click on the option to upload a file if you have a previously created project.json file on your machine
3. Name the file project.json and define your package references (you can use the example above as a template).

The package restore process will begin and you should see output similar to the following in your log window:

2016-04-04T19:02:48.745 Restoring packages.
2016-04-04T19:02:48.745 Starting NuGet restore
2016-04-04T19:02:50.183 MSBuild auto-detection: using msbuild version '14.0' from 'D:\Program Files (x86)\MSBuild\14.0\bin'.
2016-04-04T19:02:50.261 Feeds used:
2016-04-04T19:02:50.261 C:\DWASFiles\Sites\facavalfunctest\LocalAppData\NuGet\Cache
2016-04-04T19:02:50.261 https://api.nuget.org/v3/index.json
2016-04-04T19:02:50.261 
2016-04-04T19:02:50.511 Restoring packages for D:\home\site\wwwroot\HttpTriggerCSharp1\Project.json...
2016-04-04T19:02:52.800 Installing Newtonsoft.Json 6.0.8.
2016-04-04T19:02:52.800 Installing Microsoft.ProjectOxford.Face 1.1.0.
2016-04-04T19:02:57.095 All packages are compatible with .NETFramework,Version=v4.6.
2016-04-04T19:02:57.189 
2016-04-04T19:02:57.189 
2016-04-04T19:02:57.455 Packages restored.

As expected, the Azure Functions runtime will automatically add the references to the package assemblies, so you DO NOT need to explicitly add assembly references using #r "AssemblyName", you can just add the required using statements to your function and use the types defined in the NuGet package you've referenced.

Additional deployment options

Since Azure Functions is built on top of App Services, as an alternative to the steps above, you also have access to all the great deployment options available to standard Azure Web Apps (Azure Websites).

Here are some examples:

Using App Service Editor (Monaco)

In order to manage your files directly from your browser by using the App Service Editor (Monaco):

• On the Azure Functions portal, click on Function app settings
• Under the Advanced Settings section, click on Go to App Service Settings
• Click on the Tools button
• Under Develop, click on App Service Editor
• Turn it On if it is not already enabled and click on Go
• Once it loads, drag-and-drop your project.json file into your function's folder (the folder named after your function.

Using SCM (Kudu) endpoint

• Navigate to: https://<function_app_name>.scm.azurewebsites.net
• Click on Debug Console > CMD
• Navigate to D:\home\site\wwwroot\<function_name>
• Drag-and-drop your Project.json file into the folder (onto the file grid)

FTP

• Follow the instructions here to get FTP configured

• Once connected (following the instructions above) copy your Project.json file to /site/wwwroot/<function_name>

  For additional deployment options, see: https://azure.microsoft.com/en-us/documentation/articles/web-sites-deploy/

Continuous Integration

If you enable continuous integration and deploy your function with a project.json file when your Function App is not running, the package restore will happen automatically once your Function App initializes. It is recommended that you do not add your project.lock.json file to source control.

Pre-compiled assemblies

Functions may also be deployed as pre-compiled assemblies, and in this case, all dependency management is handled in Visual Studio. This option may be used as standard class libraries on any version of Visual Studio or by using the Visual Studio 2017 Azure Functions Tools.

Solution 2:

This thread helped me a lot - but I still wasted a few hours trying to get the Project.json to work - to no avail.

If you make an Azure function in version 2.x you need to do this in a different way.

Create a new file as stated but name it function.proj. This file has an XML structure for importing libraries via Nuget.

Here is my example importing the Amazon S3 SDK for .Net;

<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
    <TargetFramework>netstandard2.0</TargetFramework>
  </PropertyGroup>

  <ItemGroup>
    <PackageReference Include="AWSSDK.S3" Version="3.3.26.3"/>
    <PackageReference Include="AWSSDK.Core" Version="3.3.29.1"/>
  </ItemGroup>

</Project>

upon saving this you should see the console update stating that the packages are getting installed. This really isn't well documented and it took me a good few hours to find this out. So I hope this helps someone.

Solution 3:

You can use Nuget packages in your Azure Functions. Easiest way will be to use Visual Studio 2017 15.4 where there is a template for Azure Functions. Follow below steps

1) Add Azure function Project : Right click on solution and select Add New project. Go to CLOUD option there you will find "Azure Function" project.

2) Now it's pretty to add any Nuget package. Expand "DEPENDENCIES" and right click on it to select option "Manage Nuget Packages". Nuget Package dialog will appear, select any Nuget package you want to install. See screenshot below

3) Now publish your Azure function, Visual Studio will take care of all settings, etc.

This method will work only if you use Visual Studio 2017 15.4 or above, if not you will have to follow other ways as explained by others.

Solution 4:

Let's assume we want to use the SFTP client, which is an external library, stored somewhere in NuGet.

To accomplish that, according to the latest Azure Functions specification, do the following:

1. Open files section inside your Azure Function and add a new file called function.proj.

   For more information refer to Microsoft documentation.

2. Inside that function.proj put the Nuget package reference using the XML structure (the same kind of structure you can find inside *.csproj file if you create a local project with Visual Studio and install some NuGet package into it).

   

3. Next, let's include the library reference to the project:

   What is essential here is that you should provide a full path to the library, like in the example you can see it is: "D:\home\site\wwwroot\bin\your_custom_library.dll"

4. Next test some library-specific code:

5. Finally, open the Logs section and save the code. After some time you should see the NuGet packages restoring log.

   Note: these logs could also appear when saving function.proj file or when running the project.

In case if the library still appears as unknown try to add it's Dll's manually into the bin folder using Azure Cloud explorer from the Visual Studio.

Solution 5:

Note that the new .csproj format in Visual studio 2017 is supported also. If you create your project as a ASPNET Web Project, the Azure Functions runtime downloads all the nuget packages necessary before building your project.