Azure Functions F# 開発者向けリファレンスAzure Functions F# Developer Reference

Azure Functions 用 F# は、小規模なコード ("関数") をクラウドで手軽に実行できるソリューションです。F# for Azure Functions is a solution for easily running small pieces of code, or "functions," in the cloud. データは関数の引数を通じて F# 関数に渡されます。Data flows into your F# function via function arguments. 引数名は function.jsonで指定され、関数のロガーやキャンセル トークンなどにアクセスするための定義済みの名前があります。Argument names are specified in function.json, and there are predefined names for accessing things like the function logger and cancellation tokens.


F# スクリプト (.fsx) は、Azure Functions バージョン 1.x の関数でのみサポートされています。F# script (.fsx) is only supported by version 1.x of the Azure Functions runtime. F# をバージョン 2.x 以降のランタイムで使用するには、プリコンパイル済み F# クラス ライブラリ プロジェクト (.fs) を使用する必要があります。If you want to use F# with version 2.x and later versions of the runtime, you must use a precompiled F# class library project (.fs). F# クラス ライブラリ プロジェクトを作成、管理、公開するには、C# クラス ライブラリ プロジェクトの場合と同じように Visual Studio を使用します。You create, manage, and publish an F# class library project using Visual Studio as you would a C# class library project. Functions バージョンの詳細については、「Azure Functions ランタイム バージョンの概要」をご覧ください。For more information about Functions versions, see Azure Functions runtime versions overview.

この記事では、「 Azure Functions developer reference (Azure Functions 開発者向けリファレンス)」を既に読んでいることを前提としています。This article assumes that you've already read the Azure Functions developer reference.

.fsx のしくみHow .fsx works

.fsx ファイルは、F# スクリプトです。An .fsx file is an F# script. 1 つのファイルに含まれている F# プロジェクトとして考えることができます。It can be thought of as an F# project that's contained in a single file. ファイルには、プログラムのためのコード (この場合は、Azure 関数) と、依存関係を管理するためのディレクティブの両方が含まれています。The file contains both the code for your program (in this case, your Azure Function) and directives for managing dependencies.

Azure 関数に対して .fsx を使用すると、一般に必要とされるアセンブリが自動的に含められるため、"定型" コードではなく、関数のコードに集中できます。When you use an .fsx for an Azure Function, commonly required assemblies are automatically included for you, allowing you to focus on the function rather than "boilerplate" code.

フォルダー構造Folder structure

F# スクリプト プロジェクトのフォルダー構造は、次のようになります。The folder structure for an F# script project looks like the following:

 | - MyFirstFunction
 | | - run.fsx
 | | - function.json
 | | - function.proj
 | - MySecondFunction
 | | - run.fsx
 | | - function.json
 | | - function.proj
 | - host.json
 | - extensions.csproj
 | - bin

関数アプリの構成に使用できる共有 host.json ファイルがあります。There's a shared host.json file that can be used to configure the function app. 各関数には、独自のコード ファイル (.fsx) とバインディング構成ファイル (function.json) があります。Each function has its own code file (.fsx) and binding configuration file (function.json).

Functions ランタイムのバージョン 2.x およびそれ以降 で必要なバインディング拡張機能は、bin フォルダー内の実際のライブラリファイルと共に、extensions.csprojファイルで定義されます。The binding extensions required in version 2.x and later versions of the Functions runtime are defined in the extensions.csproj file, with the actual library files in the bin folder. ローカルで開発する場合は、バインド拡張機能を登録する必要があります。When developing locally, you must register binding extensions. Azure portal 上で関数を開発するときに、この登録が実行されます。When developing functions in the Azure portal, this registration is done for you.

引数へのバインドBinding to arguments

Azure Functions のトリガーとバインドの開発者用リファレンス」で詳しく説明されているように、各バインドはいくつかの引数のセットをサポートしています。Each binding supports some set of arguments, as detailed in the Azure Functions triggers and bindings developer reference. たとえば、BLOB トリガーでサポートされている引数バインドの 1 つは、POCO です。これは、F# レコードを使用して表すことができます。For example, one of the argument bindings a blob trigger supports is a POCO, which can be expressed using an F# record. 次に例を示します。For example:

type Item = { Id: string }

let Run(blob: string, output: byref<Item>) =
    let item = { Id = "Some ID" }
    output <- item

F# Azure 関数は、1 つまたは複数の引数を受け取ります。Your F# Azure Function will take one or more arguments. Azure Functions の引数についての説明では、"入力" 引数と "出力" 引数が出てきます。When we talk about Azure Functions arguments, we refer to input arguments and output arguments. 入力引数は、名前が示すとおり、F# Azure 関数への入力です。An input argument is exactly what it sounds like: input to your F# Azure Function. "出力" 引数は、関数から "出力" データを返す方法として機能する、変更可能なデータまたは byref<> 引数です。An output argument is mutable data or a byref<> argument that serves as a way to pass data back out of your function.

上の例では、blob が入力引数で、output が出力引数です。In the example above, blob is an input argument, and output is an output argument. outputbyref<> を使用したことに注意してください ([<Out>] という注釈を付ける必要はありません)。Notice that we used byref<> for output (there's no need to add the [<Out>] annotation). byref<> 型を使用すると、関数は引数が参照するレコードまたはオブジェクトを変更できます。Using a byref<> type allows your function to change which record or object the argument refers to.

F# レコードを入力型として使用する場合は、Azure Functions フレームワークがレコードを関数に渡す前にフィールドを適切に設定できるように、レコード定義を [<CLIMutable>] でマークする必要があります。When an F# record is used as an input type, the record definition must be marked with [<CLIMutable>] in order to allow the Azure Functions framework to set the fields appropriately before passing the record to your function. 内部的には、 [<CLIMutable>] によってレコードのプロパティのセッターが生成されます。Under the hood, [<CLIMutable>] generates setters for the record properties. 次に例を示します。For example:

type TestObject =
    { SenderName : string
      Greeting : string }

let Run(req: TestObject, log: ILogger) =
    { req with Greeting = sprintf "Hello, %s" req.SenderName }

F# クラスも、入力と出力の両方の引数で使用できます。An F# class can also be used for both in and out arguments. クラスの場合、プロパティには通常、ゲッターとセッターが必要です。For a class, properties will usually need getters and setters. 次に例を示します。For example:

type Item() =
    member val Id = "" with get,set
    member val Text = "" with get,set

let Run(input: string, item: byref<Item>) =
    let result = Item(Id = input, Text = "Hello from F#!")
    item <- result


出力を F# のストリーミング ログに記録するには、関数が ILogger 型の引数を受け取る必要があります。To log output to your streaming logs in F#, your function should take an argument of type ILogger. 一貫性のために、この引数は logという名前にすることをお勧めします。For consistency, we recommend this argument is named log. 次に例を示します。For example:

let Run(blob: string, output: byref<string>, log: ILogger) =
    log.LogInformation(sprintf "F# Azure Function processed a blob: %s" blob)
    output <- input


async ワークフローを使用できますが、結果は Task を返す必要があります。The async workflow can be used, but the result needs to return a Task. そのためには、たとえば Async.StartAsTaskを使用します。This can be done with Async.StartAsTask, for example:

let Run(req: HttpRequestMessage) =
    async {
        return new HttpResponseMessage(HttpStatusCode.OK)
    } |> Async.StartAsTask

キャンセル トークンCancellation Token

関数が正常なシャットダウンを処理する必要がある場合は、 CancellationToken 引数を設定できます。If your function needs to handle shutdown gracefully, you can give it a CancellationToken argument. これは、たとえば asyncと結合される場合があります。This can be combined with async, for example:

let Run(req: HttpRequestMessage, token: CancellationToken)
    let f = async {
        do! Async.Sleep(10)
        return new HttpResponseMessage(HttpStatusCode.OK)
    Async.StartAsTask(f, token)

名前空間のインポートImporting namespaces

名前空間は、通常の方法で開くことができます。Namespaces can be opened in the usual way:

open System.Net
open System.Threading.Tasks
open Microsoft.Extensions.Logging

let Run(req: HttpRequestMessage, log: ILogger) =

以下の名前空間は、自動的に開かれます。The following namespaces are automatically opened:

  • System
  • System.Collections.Generic
  • System.IO
  • System.Linq
  • System.Net.Http
  • System.Threading.Tasks
  • Microsoft.Azure.WebJobs
  • Microsoft.Azure.WebJobs.Host.Microsoft.Azure.WebJobs.Host.

外部アセンブリの参照Referencing External Assemblies

同様に、フレームワーク アセンブリ参照を、#r "AssemblyName" ディレクティブと共に追加できます。Similarly, framework assembly references can be added with the #r "AssemblyName" directive.

#r "System.Web.Http"

open System.Net
open System.Net.Http
open System.Threading.Tasks
open Microsoft.Extensions.Logging

let Run(req: HttpRequestMessage, log: ILogger) =

次のアセンブリは、Azure Functions をホストしている環境によって自動的に追加されます。The following assemblies are automatically added by the Azure Functions hosting environment:

  • mscorlib,mscorlib,
  • System
  • System.Core
  • System.Xml
  • System.Net.Http
  • Microsoft.Azure.WebJobs
  • Microsoft.Azure.WebJobs.Host
  • Microsoft.Azure.WebJobs.Extensions
  • System.Web.Http
  • System.Net.Http.Formatting.System.Net.Http.Formatting.

さらに、次のアセンブリは特別扱いされ、simplename によって参照される場合があります (例: #r "AssemblyName")。In addition, the following assemblies are special cased and may be referenced by simplename (e.g. #r "AssemblyName"):

  • Newtonsoft.Json
  • Microsoft.WindowsAzure.Storage
  • Microsoft.ServiceBus
  • Microsoft.AspNet.WebHooks.Receivers
  • Microsoft.AspNEt.WebHooks.Common.Microsoft.AspNEt.WebHooks.Common.

プライベート アセンブリを参照する必要がある場合は、アセンブリ ファイルを関数に関連する bin フォルダーにアップロードし、ファイル名 (例: #r "MyAssembly.dll") を使用して参照できます。If you need to reference a private assembly, you can upload the assembly file into a bin folder relative to your function and reference it by using the file name (e.g. #r "MyAssembly.dll"). 関数フォルダーにファイルをアップロードする方法については、パッケージ管理の次のセクションを参照してください。For information on how to upload files to your function folder, see the following section on package management.

エディター準備Editor Prelude

F# Compiler Services をサポートしているエディターは、Azure Functions が自動的に含める名前空間とアセンブリを認識しません。An editor that supports F# Compiler Services will not be aware of the namespaces and assemblies that Azure Functions automatically includes. そのため、使用されているアセンブリを検索するエディターを支援するための準備を行い、明示的に名前空間を開くと、便利な場合があります。As such, it can be useful to include a prelude that helps the editor find the assemblies you are using, and to explicitly open namespaces. 次に例を示します。For example:

#I "../../bin/Binaries/WebJobs.Script.Host"
#r "Microsoft.Azure.WebJobs.Host.dll"

open System
open Microsoft.Azure.WebJobs.Host
open Microsoft.Extensions.Logging

let Run(blob: string, output: byref<string>, log: ILogger) =

Azure Functions は、コードを実行するとき、 COMPILED が定義されているソースを処理するため、エディター準備は無視されます。When Azure Functions executes your code, it processes the source with COMPILED defined, so the editor prelude will be ignored.

パッケージの管理Package management

NuGet パッケージを F# 関数で使用するには、project.json ファイルを関数アプリのファイル システムにある関数のフォルダーに追加します。To use NuGet packages in an F# function, add a project.json file to the function's folder in the function app's file system. 次に示すのは、Microsoft.ProjectOxford.Face Version 1.1.0 への NuGet パッケージ参照を追加する、project.json ファイルの例です。Here is an example project.json file that adds a NuGet package reference to Microsoft.ProjectOxford.Face version 1.1.0:

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

.NET Framework 4.6 のみがサポートされているので、次に示すように project.json ファイルが net46 を指定していることを確認します。Only the .NET Framework 4.6 is supported, so make sure that your project.json file specifies net46 as shown here.

project.json ファイルをアップロードすると、ランタイムによってパッケージが取得され、パッケージ アセンブリへの参照が自動的に追加されます。When you upload a project.json file, the runtime gets the packages and automatically adds references to the package assemblies. #r "AssemblyName" ディレクティブを追加する必要はありません。You don't need to add #r "AssemblyName" directives. 単に、必要な open ステートメントを .fsx ファイルに追加します。Just add the required open statements to your .fsx file.

エディターと F# Compile Services との相互作用を向上させるために、エディター準備に参照アセンブリを自動的に配置したい場合があるかもしれません。You may wish to put automatically references assemblies in your editor prelude, to improve your editor's interaction with F# Compile Services.

project.json ファイルを Azure 関数に追加する方法How to add a project.json file to your Azure Function

  1. Azure ポータルで関数を開き、関数アプリが実行中であることを確認して開始します。Begin by making sure your function app is running, which you can do by opening your function in the Azure portal. これにより、パッケージのインストール出力が表示されるストリーミング ログへのアクセス権が付与されます。This also gives access to the streaming logs where package installation output will be displayed.
  2. project.json ファイルをアップロードするには、「関数アプリ ファイルを更新する方法」で説明されているいずれかの方法を使用します。To upload a project.json file, use one of the methods described in how to update function app files. Azure Functions の継続的なデプロイを使用している場合は、project.json ファイルをステージング環境の分岐に追加して、デプロイ分岐に追加する前に実験することができます。If you are using Continuous Deployment for Azure Functions, you can add a project.json file to your staging branch in order to experiment with it before adding it to your deployment branch.
  3. project.json ファイルが追加された後、関数のストリーミング ログの出力は次の例のようになります。After the project.json file is added, you will see output similar to the following example in your function's streaming log:
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.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.455 Packages restored.

環境変数Environment variables

環境変数またはアプリ設定値を取得するには、次の例のように、 System.Environment.GetEnvironmentVariableを使用します。To get an environment variable or an app setting value, use System.Environment.GetEnvironmentVariable, for example:

open System.Environment
open Microsoft.Extensions.Logging

let Run(timer: TimerInfo, log: ILogger) =
    log.LogInformation("Storage = " + GetEnvironmentVariable("AzureWebJobsStorage"))
    log.LogInformation("Site = " + GetEnvironmentVariable("WEBSITE_SITE_NAME"))

.fsx コードの再利用Reusing .fsx code

他の .fsx ファイルのコードを利用するには、#load ディレクティブを使用します。You can use code from other .fsx files by using a #load directive. 次に例を示します。For example:


#load "logger.fsx"

let Run(timer: TimerInfo, log: ILogger) =
    mylog log (sprintf "Timer: %s" DateTime.Now.ToString())


let mylog(log: ILogger, text: string) =

#load ディレクティブに指定するパスは、.fsx ファイルの場所からの相対パスです。Paths provides to the #load directive are relative to the location of your .fsx file.

  • #load "logger.fsx" によって、関数フォルダーにあるファイルが読み込まれます。#load "logger.fsx" loads a file located in the function folder.
  • #load "package\logger.fsx" によって、関数フォルダー内の package フォルダーにあるファイルが読み込まれます。#load "package\logger.fsx" loads a file located in the package folder in the function folder.
  • #load "..\shared\mylogger.fsx" によって、関数フォルダーと同じレベル (wwwroot の直下) にある shared フォルダーのファイルが読み込まれます。#load "..\shared\mylogger.fsx" loads a file located in the shared folder at the same level as the function folder, that is, directly under wwwroot.

#load ディレクティブは、.fsx (F# スクリプト) ファイルだけで動作します。.fs ファイルでは動作しません。The #load directive only works with .fsx (F# script) files, and not with .fs files.

次のステップNext steps

詳細については、次のリソースを参照してください。For more information, see the following resources: