Referência F# do Azure Functions DeveloperAzure Functions F# Developer Reference

F#por Azure Functions é uma solução para executar facilmente pequenas partes de código ou "funções" na nuvem.F# for Azure Functions is a solution for easily running small pieces of code, or "functions," in the cloud. Os dados fluem para F# sua função por meio de argumentos de função.Data flows into your F# function via function arguments. Os nomes de argumentos são especificados em function.jsone há nomes predefinidos para acessar itens como os tokens de agente de log de função e cancelamento.Argument names are specified in function.json, and there are predefined names for accessing things like the function logger and cancellation tokens.

Importante

F#o script (. fsx) só tem suporte da versão 1. x do tempo de execução de Azure functions.F# script (.fsx) is only supported by version 1.x of the Azure Functions runtime. Se você quiser usar F# o com a versão 2. x e versões posteriores do tempo de execução, deverá usar um projeto F# de biblioteca de classes pré-compilado (. 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). Você cria, gerencia e publica um F# projeto de biblioteca de classes usando o Visual Studio como faria com um projeto de C# biblioteca de classes.You create, manage, and publish an F# class library project using Visual Studio as you would a C# class library project. Para obter mais informações sobre versões do functions, consulte visão geral de versões do Azure Functions Runtime.For more information about Functions versions, see Azure Functions runtime versions overview.

Este artigo pressupõe que você já leu a referência do Azure Functions Developer.This article assumes that you've already read the Azure Functions developer reference.

Como o. fsx funcionaHow .fsx works

Um arquivo de .fsx é F# um script.An .fsx file is an F# script. Pode ser pensado como um F# projeto contido em um único arquivo.It can be thought of as an F# project that's contained in a single file. O arquivo contém o código para seu programa (nesse caso, sua função do Azure) e diretivas para gerenciar dependências.The file contains both the code for your program (in this case, your Azure Function) and directives for managing dependencies.

Quando você usa um .fsx para uma função do Azure, os assemblies comumente necessários são incluídos automaticamente para você, permitindo que você se concentre na função em vez do código "clichê".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.

Estrutura de pastasFolder structure

A estrutura de pastas de F# um projeto de script é semelhante ao seguinte:The folder structure for an F# script project looks like the following:

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

Há um arquivo host. JSON compartilhado que pode ser usado para configurar o aplicativo de funções.There's a shared host.json file that can be used to configure the function app. Cada função tem seu próprio arquivo de código (. fsx) e o arquivo de configuração de associação (Function. JSON).Each function has its own code file (.fsx) and binding configuration file (function.json).

As extensões de associação necessárias na versão 2. x e versões posteriores do tempo de execução do Functions são definidas no arquivo extensions.csproj, com os arquivos de biblioteca reais na pasta bin.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. Ao desenvolver localmente, você deve registrar extensões de associação.When developing locally, you must register binding extensions. Ao desenvolver funções no portal do Azure, esse registro é feito para você.When developing functions in the Azure portal, this registration is done for you.

Associação a argumentosBinding to arguments

Cada associação dá suporte a algum conjunto de argumentos, conforme detalhado na referência do desenvolvedor de Azure Functions gatilhos e associações.Each binding supports some set of arguments, as detailed in the Azure Functions triggers and bindings developer reference. Por exemplo, uma das associações de argumento que um gatilho de blob dá suporte é um POCO, que pode ser expresso F# usando um registro.For example, one of the argument bindings a blob trigger supports is a POCO, which can be expressed using an F# record. Por exemplo:For example:

type Item = { Id: string }

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

Sua F# função do Azure usará um ou mais argumentos.Your F# Azure Function will take one or more arguments. Quando falamos sobre argumentos Azure Functions, nos referimos a argumentos de entrada e argumentos de saída .When we talk about Azure Functions arguments, we refer to input arguments and output arguments. Um argumento de entrada é exatamente o que parece: entrada para a F# função do Azure.An input argument is exactly what it sounds like: input to your F# Azure Function. Um argumento de saída é dados mutáveis ou um argumento byref<> que serve como uma maneira de passar dados de volta para fora de sua função.An output argument is mutable data or a byref<> argument that serves as a way to pass data back out of your function.

No exemplo acima, blob é um argumento de entrada e output é um argumento de saída.In the example above, blob is an input argument, and output is an output argument. Observe que usamos byref<> para output (não há necessidade de adicionar a anotação [<Out>]).Notice that we used byref<> for output (there's no need to add the [<Out>] annotation). O uso de um tipo de byref<> permite que sua função altere o registro ou objeto ao qual o argumento se refere.Using a byref<> type allows your function to change which record or object the argument refers to.

Quando um F# registro é usado como um tipo de entrada, a definição de registro deve ser marcada com [<CLIMutable>] para permitir que a estrutura de Azure Functions defina os campos adequadamente antes de passar o registro para sua função.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. Nos bastidores, [<CLIMutable>] gera setters para as propriedades do registro.Under the hood, [<CLIMutable>] generates setters for the record properties. Por exemplo:For example:

[<CLIMutable>]
type TestObject =
    { SenderName : string
      Greeting : string }

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

Uma F# classe também pode ser usada para argumentos de entrada e saída.An F# class can also be used for both in and out arguments. Para uma classe, as propriedades geralmente precisam de getters e setters.For a class, properties will usually need getters and setters. Por exemplo: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

RegistoLogging

Para registrar a saída em seus logs de F#streaming no, sua função deve usar um argumento do tipo ILogger.To log output to your streaming logs in F#, your function should take an argument of type ILogger. Para fins de consistência, recomendamos que esse argumento seja nomeado log.For consistency, we recommend this argument is named log. Por exemplo:For example:

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

AsyncAsync

O fluxo de trabalho async pode ser usado, mas o resultado precisa retornar um Task.The async workflow can be used, but the result needs to return a Task. Isso pode ser feito com Async.StartAsTask, por exemplo:This can be done with Async.StartAsTask, for example:

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

Token de cancelamentoCancellation Token

Se sua função precisar lidar com o desligamento normal, você poderá dar a ele um CancellationToken argumento.If your function needs to handle shutdown gracefully, you can give it a CancellationToken argument. Isso pode ser combinado com async, por exemplo: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)

Importando namespacesImporting namespaces

Os namespaces podem ser abertos da maneira usual: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) =
    ...

Os seguintes namespaces são abertos automaticamente: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.

Referenciando assemblies externosReferencing External Assemblies

Da mesma forma, as referências de assembly de estrutura podem ser adicionadas com a diretiva #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) =
    ...

Os assemblies a seguir são adicionados automaticamente pelo ambiente de hospedagem 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.

Além disso, os seguintes assemblies são especiais em maiúsculas e podem ser referenciados por SimpleName (por exemplo, #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.

Se você precisar fazer referência a um assembly particular, poderá carregar o arquivo do assembly em uma pasta bin em relação à sua função e fazer referência a ele usando o nome do arquivo (por exemplo, #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"). Para obter informações sobre como carregar arquivos para sua pasta de funções, consulte a seção a seguir sobre gerenciamento de pacotes.For information on how to upload files to your function folder, see the following section on package management.

Prelúdio do editorEditor Prelude

Um editor que dá F# suporte a serviços de compilador não estará ciente dos namespaces e assemblies que Azure Functions inclui automaticamente.An editor that supports F# Compiler Services will not be aware of the namespaces and assemblies that Azure Functions automatically includes. Como tal, pode ser útil incluir um prelúdio que ajude o editor a localizar os assemblies que você está usando e para abrir explicitamente os namespaces.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. Por exemplo:For example:

#if !COMPILED
#I "../../bin/Binaries/WebJobs.Script.Host"
#r "Microsoft.Azure.WebJobs.Host.dll"
#endif

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

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

Quando Azure Functions executa seu código, ele processa a fonte com COMPILED definido, portanto, o editor prelúdio será ignorado.When Azure Functions executes your code, it processes the source with COMPILED defined, so the editor prelude will be ignored.

Gestão de pacotesPackage management

Para usar pacotes NuGet em uma F# função, adicione um arquivo de project.json à pasta da função no sistema de arquivos do aplicativo de funções.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. Aqui está um exemplo project.json arquivo que adiciona uma referência de pacote NuGet ao Microsoft.ProjectOxford.Face versão 1.1.0:Here is an example project.json file that adds a NuGet package reference to Microsoft.ProjectOxford.Face version 1.1.0:

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

Somente o .NET Framework 4,6 tem suporte, portanto, verifique se o arquivo de project.json especifica net46 como mostrado aqui.Only the .NET Framework 4.6 is supported, so make sure that your project.json file specifies net46 as shown here.

Quando você carrega um arquivo de project.json, o tempo de execução Obtém os pacotes e adiciona referências automaticamente aos assemblies de pacote.When you upload a project.json file, the runtime gets the packages and automatically adds references to the package assemblies. Você não precisa adicionar diretivas de #r "AssemblyName".You don't need to add #r "AssemblyName" directives. Basta adicionar as instruções de open necessárias ao arquivo de .fsx.Just add the required open statements to your .fsx file.

Talvez você queira colocar automaticamente os assemblies de referência em seu editor prelúdio para melhorar a interação do editor com F# os serviços de compilação.You may wish to put automatically references assemblies in your editor prelude, to improve your editor's interaction with F# Compile Services.

Como adicionar um arquivo de project.json à sua função do AzureHow to add a project.json file to your Azure Function

  1. Comece verificando se seu aplicativo de funções está em execução, o que pode ser feito abrindo a função no portal do Azure.Begin by making sure your function app is running, which you can do by opening your function in the Azure portal. Isso também fornece acesso aos logs de streaming em que a saída da instalação do pacote será exibida.This also gives access to the streaming logs where package installation output will be displayed.
  2. Para carregar um arquivo de project.json, use um dos métodos descritos em como atualizar os arquivos do aplicativo de funções.To upload a project.json file, use one of the methods described in how to update function app files. Se estiver usando a implantação contínua para Azure Functions, você poderá adicionar um arquivo de project.json à sua ramificação de preparo para experimentá-lo antes de adicioná-lo à sua ramificação de implantação.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. Depois que o arquivo de project.json for adicionado, você verá uma saída semelhante ao exemplo a seguir no log de streaming da sua função: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.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.

Variáveis de ambienteEnvironment variables

Para obter uma variável de ambiente ou um valor de configuração de aplicativo, use System.Environment.GetEnvironmentVariable, por exemplo: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"))

Reutilizando o código. fsxReusing .fsx code

Você pode usar código de outros arquivos de .fsx usando uma diretiva #load.You can use code from other .fsx files by using a #load directive. Por exemplo:For example:

run.fsx

#load "logger.fsx"

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

logger.fsx

let mylog(log: ILogger, text: string) =
    log.LogInformation(text);

Os caminhos fornecidos para a diretiva de #load são relativos ao local do arquivo de .fsx.Paths provides to the #load directive are relative to the location of your .fsx file.

  • #load "logger.fsx" carrega um arquivo localizado na pasta de funções.#load "logger.fsx" loads a file located in the function folder.
  • #load "package\logger.fsx" carrega um arquivo localizado na pasta package na pasta de funções.#load "package\logger.fsx" loads a file located in the package folder in the function folder.
  • #load "..\shared\mylogger.fsx" carrega um arquivo localizado na pasta shared no mesmo nível que a pasta de funções, ou seja, diretamente em wwwroot.#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.

A diretiva #load só funciona com arquivos deF# .fsx (script) e não com arquivos .fs.The #load directive only works with .fsx (F# script) files, and not with .fs files.

Passos seguintesNext steps

Para obter mais informações, consulte os seguintes recursos:For more information, see the following resources: