Migrar aplicativos do Azure Functions versão 1.x para a versão 4.x

  • Artigo

Importante

Não há suporte para Java na versão 1.x do runtime do Azure Functions. Provavelmente seria melhor migrar seu aplicativo Java da versão 3.x para a versão 4.x. Se você estiver migrando um aplicativo de funções versão 1.x, selecione acima C# ou JavaScript.

Importante

Não há suporte para TypeScript na versão 1.x do runtime do Azure Functions. Provavelmente seria melhor migrar seu aplicativo TypeScript da versão 3.x para a versão 4.x. Se você estiver migrando um aplicativo de funções versão 1.x, selecione acima C# ou JavaScript.

Importante

Não há suporte para PowerShell na versão 1.x do runtime do Azure Functions. Provavelmente seria melhor migrar seu aplicativo PowerShell da versão 3.x para a versão 4.x. Se você estiver migrando um aplicativo de funções versão 1.x, selecione acima C# ou JavaScript.

Importante

Não há suporte par Python na versão 1.x do runtime do Azure Functions. Provavelmente seria melhor migrar seu aplicativo Python da versão 3.x para a versão 4.x. Se você estiver migrando um aplicativo de funções versão 1.x, selecione acima C# ou JavaScript.

Importante

O suporte da versão 1.x do runtime do Azure Functions terminará em 14 de setembro de 2026. É altamente recomendável migrar seus aplicativos para a versão 4.x seguindo as instruções neste artigo.

Este artigo descreve o processo de migração segura do aplicativo de funções para execução na versão 4.x do runtime do Functions. Como as instruções de migração de projeto são dependentes de linguagem, escolha a linguagem de desenvolvimento no seletor na parte superior do artigo.

Se você estiver executando a versão 1.x do runtime no Azure Stack Hub, confira Considerações para o Azure Stack Hub primeiro.

Identificar aplicativos de funções a serem migrados

Use o seguinte script do PowerShell para gerar uma lista de aplicativos de funções em sua assinatura que atualmente se destinam à versão 1.x:

$Subscription = '<YOUR SUBSCRIPTION ID>' 

Set-AzContext -Subscription $Subscription | Out-Null

$FunctionApps = Get-AzFunctionApp

$AppInfo = @{}

foreach ($App in $FunctionApps)
{
     if ($App.ApplicationSettings["FUNCTIONS_EXTENSION_VERSION"] -like '*1*')
     {
          $AppInfo.Add($App.Name, $App.ApplicationSettings["FUNCTIONS_EXTENSION_VERSION"])
     }
}

$AppInfo

Escolher a versão do .NET de destino

Na versão 1.x do runtime do Functions, seu aplicativo de funções C# é direcionado ao .NET Framework.

Ao migrar seu aplicativo de funções, você tem a oportunidade de escolher a versão de destino do .NET. Você pode atualizar seu projeto C# para uma das seguintes versões do .NET, que podem ser executadas na versão 4.x do Functions:

Versão do .NET Tipo de versão da política de suporte oficial do .NET Modelo de processo do Functions 1,3
.NET 82 LTS Modelo de trabalho isolado
.NET 7 STS (fim do suporte 14 de maio de 2024) Modelo de trabalho isolado
.NET 6 LTS (fim do suporte 12 de novembro de 2024) Modelo de trabalho isolado,
Modelo em processo3
.NET Framework 4.8 Consultar política Modelo de trabalho isolado

1 O modelo de trabalho isolado dá suporte às versões LTS (suporte de longo prazo) e STS (suporte de curto prazo) do .NET, bem como .NET Framework. O modelo em processo só dá suporte a versões LTS do .NET. Para obter uma comparação completa de recursos e funcionalidades entre os dois modelos, confira Diferenças entre o processo de trabalho isolado e em processo do Azure Functions no .NET.

2 .NET 8 ainda não tem suporte no modelo em processo, embora esteja disponível no modelo de trabalho isolado. Para obter informações sobre planos do .NET 8, incluindo futuras opções para o modelo em processo, confira a postagem Atualização do roteiro do Azure Functions.

3 O suporte termina para o modelo em processo em 10 de novembro de 2026. Para obter mais informações, confira este comunicado de suporte. Para obter suporte completo contínuo, você deve migrar seus aplicativos para o modelo de trabalho isolado.

Dica

A menos que seu aplicativo dependa de uma biblioteca ou API disponível apenas para o .NET Framework, recomendamos atualizar para o .NET 8 no modelo de trabalho isolado. Muitos aplicativos na versão 1.x são direcionados ao .NET Framework, apenas porque era isso que estava disponível quando eles foram criados. Recursos adicionais estão disponíveis para versões mais recentes do .NET e, se o aplicativo não for forçado a permanecer no .NET Framework devido a uma dependência, você deverá direcioná-lo a uma versão mais recente. O .NET 8 é a versão totalmente lançada com a janela de suporte mais longa do .NET.

Embora você possa optar por usar o modelo em processo, isso não é recomendado se ele puder ser evitado. O suporte terminará para o modelo em processo em 10 de novembro de 2026, portanto, você precisará migrar para o modelo de trabalho isolado antes disso. Fazer isso durante a migração para a versão 4.x diminuirá o esforço total necessário, e o modelo de trabalhado isolado fornecerá benefícios adicionais para o seu aplicativo, incluindo a capacidade de direcionar mais facilmente versões futuras do .NET. Se você estiver migrando para o modelo de trabalho isolado, o Assistente de Atualização do .NET também poderá lidar com muitas das alterações de código necessárias para você.

Este guia não apresenta exemplos específicos para .NET 7 ou .NET 6 no modelo de trabalho isolado. Se você precisa visar essas versões, poderá adaptar os exemplos de modelo de trabalho isolado do .NET 8.

Preparar para a migração

Caso ainda não tenha feito isso, identifique a lista de aplicativos que precisam ser migrados em sua assinatura atual do Azure usando o Azure PowerShell.

Antes de migrar um aplicativo para a versão 4.x do runtime do Functions, realize as seguintes tarefas:

  1. Revise a lista de alterações de comportamento após a versão 1.x. A migração da versão 1.x para a versão 4.x também pode afetar associações.
  2. Conclua as etapas em Migrar seu projeto local para migrar seu projeto local para a versão 4.x.
  3. Após migrar seu projeto, faça um teste completo do aplicativo no local usando a versão 4.x do Azure Functions Core Tools.
  4. Atualize seu aplicativo de funções no Azure para a nova versão. Caso você precise minimizar o tempo de inatividade, considere o uso de um slot de preparo para testar e verificar seu aplicativo migrado no Azure na nova versão de runtime. Em seguida, você pode implantar o aplicativo com as configurações de versão atualizadas no slot de produção. Para saber mais, confira Atualizar usando slots.
  5. Publique seu projeto migrado para o aplicativo de funções atualizado.

Quando você usa o Visual Studio para publicar um projeto versão 4.x em um aplicativo de funções existente com uma versão inferior, é solicitado que você permita que o Visual Studio atualize o aplicativo de funções para a versão 4.x durante a implantação. Essa atualização usa o mesmo processo definido em Atualizar sem slots.

Migrar seu projeto local

As seções a seguir descrevem as atualizações que você deve fazer em seus arquivos de projeto C# para poder executar em uma das versões com suporte do .NET na versão 4.x do Functions. As atualizações mostradas são comuns à maioria dos projetos. O código do projeto pode exigir atualizações ignoradas neste artigo, especialmente ao usar pacotes NuGet personalizados.

Migrar um aplicativo de funções C# da versão 1.x para a versão 4.x do runtime do Functions exige que você faça alterações no código do projeto. Muitas dessas alterações são resultado de alterações na linguagem C# e nas APIs do .NET.

Escolha a guia que corresponde à versão de destino do .NET e ao modelo de processo desejado (em processo ou processo de trabalho isolado).

Dica

Se você estiver migrando para uma versão LTS ou STS do .NET usando o modelo de trabalho isolado, o Assistente de Atualização do .NET poderá ser usado para fazer automaticamente muitas das alterações mencionadas nas seções a seguir.

Arquivo de projeto

O exemplo a seguir é um arquivo de projeto .csproj executado na versão 1.x:

<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <TargetFramework>net48</TargetFramework>
    <AzureFunctionsVersion>v1</AzureFunctionsVersion>
  </PropertyGroup>
  <ItemGroup>
    <PackageReference Include="Microsoft.NET.Sdk.Functions" Version="1.0.24" />
  </ItemGroup>
  <ItemGroup>
    <Reference Include="Microsoft.CSharp" />
  </ItemGroup>
  <ItemGroup>
    <None Update="host.json">
      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
    </None>
    <None Update="local.settings.json">
      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
      <CopyToPublishDirectory>Never</CopyToPublishDirectory>
    </None>
  </ItemGroup>
</Project>

Use um dos procedimentos a seguir para atualizar esse arquivo XML a fim de executá-lo no Functions versão 4.x:

Essas etapas pressupõem um projeto C# local. Se, em vez disso, seu aplicativo estiver usando o script C# (arquivos .csx), você deverá converter para o modelo de projeto antes de continuar.

As seguintes alterações são necessárias no arquivo de projeto XML .csproj:

  1. Defina o valor de PropertyGroup:TargetFramework para net8.0.

  2. Defina o valor de PropertyGroup:AzureFunctionsVersion para v4.

  3. Adicione o seguinte elemento OutputType ao PropertyGroup:

    <OutputType>Exe</OutputType>

  4. No ItemGroup.Lista PackageReference, substitua a referência de pacote de Microsoft.NET.Sdk.Functions pelas seguintes referências:

      <FrameworkReference Include="Microsoft.AspNetCore.App" />
  <PackageReference Include="Microsoft.Azure.Functions.Worker" Version="1.21.0" />
  <PackageReference Include="Microsoft.Azure.Functions.Worker.Sdk" Version="1.17.2" />
  <PackageReference Include="Microsoft.Azure.Functions.Worker.Extensions.Http.AspNetCore" Version="1.2.1" />
  <PackageReference Include="Microsoft.ApplicationInsights.WorkerService" Version="2.22.0" />
  <PackageReference Include="Microsoft.Azure.Functions.Worker.ApplicationInsights" Version="1.2.0" />

    Anote todas as referências a outros pacotes nos namespaces Microsoft.Azure.WebJobs.*. Você substituirá esses pacotes em uma etapa posterior.

  5. Adicione o ItemGroup novo a seguir:

    <ItemGroup>
  <Using Include="System.Threading.ExecutionContext" Alias="ExecutionContext"/>
</ItemGroup>

Depois que você fizer essas alterações, o projeto atualizado será semelhante ao seguinte exemplo:

<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <TargetFramework>net8.0</TargetFramework>
    <AzureFunctionsVersion>v4</AzureFunctionsVersion>
    <RootNamespace>My.Namespace</RootNamespace>
    <OutputType>Exe</OutputType>
    <ImplicitUsings>enable</ImplicitUsings>
    <Nullable>enable</Nullable>
  </PropertyGroup>
  <ItemGroup>
    <FrameworkReference Include="Microsoft.AspNetCore.App" />
    <PackageReference Include="Microsoft.Azure.Functions.Worker" Version="1.21.0" />
    <PackageReference Include="Microsoft.Azure.Functions.Worker.Sdk" Version="1.17.2" />
    <PackageReference Include="Microsoft.Azure.Functions.Worker.Extensions.Http.AspNetCore" Version="1.2.1" />
    <PackageReference Include="Microsoft.ApplicationInsights.WorkerService" Version="2.22.0" />
    <PackageReference Include="Microsoft.Azure.Functions.Worker.ApplicationInsights" Version="1.2.0" />
    <!-- Other packages may also be in this list -->
  </ItemGroup>
  <ItemGroup>
    <None Update="host.json">
      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
    </None>
    <None Update="local.settings.json">
      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
      <CopyToPublishDirectory>Never</CopyToPublishDirectory>
    </None>
  </ItemGroup>
  <ItemGroup>
    <Using Include="System.Threading.ExecutionContext" Alias="ExecutionContext"/>
  </ItemGroup>
</Project>

Alterações de pacote e namespace

Com base no modelo para o qual você está migrando, talvez seja necessário atualizar ou alterar os pacotes aos quais o aplicativo faz referência. Ao adotar os pacotes de destino, talvez seja necessário atualizar o namespace das instruções de uso e alguns tipos que você referencia. Veja o efeito dessas alterações de namespace nas instruções using nos exemplos de modelos de gatilho HTTP mais adiante neste artigo.

Atualize seu projeto, caso ainda não tenha feito isso, para referenciar as versões estáveis mais recentes de:

Dependendo dos gatilhos e associações que seu aplicativo usa, talvez ele precise fazer referência a um conjunto diferente de pacotes. A seguinte tabela mostra as substituições de algumas das extensões mais usadas:

Cenário Alterações nas referências de pacote
Gatilho de temporizador Add
Microsoft.Azure.Functions.Worker.Extensions.Timer
Associações do armazenamento Substitua
Microsoft.Azure.WebJobs.Extensions.Storage
por
Microsoft.Azure.Functions.Worker.Extensions.Storage.Blobs,
Microsoft.Azure.Functions.Worker.Extensions.Storage.Queues e
Microsoft.Azure.Functions.Worker.Extensions.Tables
Associações de blob Substitua referências a
Microsoft.Azure.WebJobs.Extensions.Storage.Blobs
pela versão mais recente de
Microsoft.Azure.Functions.Worker.Extensions.Storage.Blobs
Associações de fila Substitua referências a
Microsoft.Azure.WebJobs.Extensions.Storage.Queues
pela versão mais recente de
Microsoft.Azure.Functions.Worker.Extensions.Storage.Queues
Associações de tabela Substitua referências a
Microsoft.Azure.WebJobs.Extensions.Tables
pela versão mais recente de
Microsoft.Azure.Functions.Worker.Extensions.Tables
Associações do Cosmos DB Substitua referências a
Microsoft.Azure.WebJobs.Extensions.CosmosDB
e/ou
Microsoft.Azure.WebJobs.Extensions.DocumentDB
pela versão mais recente de
Microsoft.Azure.Functions.Worker.Extensions.CosmosDB
Associações do barramento de serviço Substitua referências a
Microsoft.Azure.WebJobs.Extensions.ServiceBus
pela versão mais recente de
Microsoft.Azure.Functions.Worker.Extensions.ServiceBus
Associações dos Hubs de Eventos Substitua referências a
Microsoft.Azure.WebJobs.Extensions.EventHubs
pela versão mais recente de
Microsoft.Azure.Functions.Worker.Extensions.EventHubs
Associações da Grade de Eventos Substitua referências a
Microsoft.Azure.WebJobs.Extensions.EventGrid
pela versão mais recente de
Microsoft.Azure.Functions.Worker.Extensions.EventGrid
Associações do Serviço do SignalR Substitua referências a
Microsoft.Azure.WebJobs.Extensions.SignalRService
pela versão mais recente de
Microsoft.Azure.Functions.Worker.Extensions.SignalRService
Funções duráveis Substitua referências a
Microsoft.Azure.WebJobs.Extensions.DurableTask
pela versão mais recente de
Microsoft.Azure.Functions.Worker.Extensions.DurableTask
Funções duráveis
(provedor de armazenamento SQL)		 Substitua referências a
Microsoft.DurableTask.SqlServer.AzureFunctions
pela versão mais recente de
Microsoft.Azure.Functions.Worker.Extensions.DurableTask.SqlServer
Funções duráveis
(provedor de armazenamento Netherite)		 Substitua referências a
Microsoft.Azure.DurableTask.Netherite.AzureFunctions
pela versão mais recente de
Microsoft.Azure.Functions.Worker.Extensions.DurableTask.Netherite
Associações do SendGrid Substitua referências a
Microsoft.Azure.WebJobs.Extensions.SendGrid
pela versão mais recente de
Microsoft.Azure.Functions.Worker.Extensions.SendGrid
Associações do Kafka Substitua referências a
Microsoft.Azure.WebJobs.Extensions.Kafka
pela versão mais recente de
Microsoft.Azure.Functions.Worker.Extensions.Kafka
Associações do RabbitMQ Substitua referências a
Microsoft.Azure.WebJobs.Extensions.RabbitMQ
pela versão mais recente de
Microsoft.Azure.Functions.Worker.Extensions.RabbitMQ
Injeção de dependência
e configuração de inicialização		 Remover referências a
Microsoft.Azure.Functions.Extensions
(O modelo de trabalho isolado fornece essa funcionalidade por padrão.)

Confira as Associações com suporte para obter uma lista completa das extensões a serem consideradas, e confira a documentação de cada extensão para obter as instruções completas de instalação para o modelo de processo isolado. Instale a versão estável mais recente de todos os pacotes que você está direcionando.

Dica

Quaisquer alterações nas versões de extensão durante esse processo podem exigir que você atualize seu arquivo host.json também. Certifique-se de ler a documentação de cada extensão que você usa. Por exemplo, a extensão do Barramento de Serviço apresenta alterações significativas na estrutura entre as versões 4.xe 5.x. Para obter mais informações, veja Encadernações do Barramento de Serviço do Azure para Azure Functions.

Seu aplicativo de modelo de trabalho isolado não deve fazer referência a nenhum pacote nos namespaces Microsoft.Azure.WebJobs.* ou Microsoft.Azure.Functions.Extensions. Se você ainda tiver referências aos pacotes, é preciso removê-las.

Dica

Seu aplicativo também pode depender de tipos de SDK do Azure, seja como parte de seus gatilhos e associações ou como uma dependência autônoma. Você também deve aproveitar essa oportunidade para atualizá-los. As versões mais recentes das extensões do Functions funcionam com as versões mais recentes do SDK do Azure para .NET, quase todos os pacotes com o formato Azure.*.

Os Hubs de Notificação e as associações de Aplicativos Móveis são compatíveis apenas com a versão 1.x do runtime. Ao atualizar para a versão 4.x do runtime, você precisa remover essas associações para trabalhar com esses serviços diretamente usando seus SDKs.

Arquivo program.cs

Na maioria dos casos, a migração exige que você adicione o seguinte arquivo program.cs ao seu projeto:

using Microsoft.Azure.Functions.Worker;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;

var host = new HostBuilder()
    .ConfigureFunctionsWebApplication()
    .ConfigureServices(services => {
        services.AddApplicationInsightsTelemetryWorkerService();
        services.ConfigureFunctionsApplicationInsights();
    })
    .Build();

host.Run();

Este exemplo inclui a integração do ASP.NET Core para melhorar o desempenho e fornecer um modelo de programação clássica quando o aplicativo usar gatilhos HTTP. Se você não pretende usar gatilhos HTTP, pode substituir a chamada a ConfigureFunctionsWebApplication por uma chamada a ConfigureFunctionsWorkerDefaults. Se você fizer isso, poderá remover a referência ao Microsoft.Azure.Functions.Worker.Extensions.Http.AspNetCore do arquivo de projeto. No entanto, para obter o melhor desempenho, mesmo para funções com outros tipos de gatilho, você deve manter a FrameworkReference ASP.NET Core.

O arquivo Program.cs substituirá todos os arquivos que tenham o atributo FunctionsStartup, que normalmente é um arquivo Startup.cs. Em locais em que o código FunctionsStartup referenciaria IFunctionsHostBuilder.Services, você pode, em vez disso, adicionar instruções dentro do método .ConfigureServices() do HostBuilder em seu Program.cs. Para saber mais sobre como trabalhar com Program.cs, confira a Configuração e inicialização no guia do modelo de trabalho isolado.

Os exemplos padrão Program.cs acima incluem a configuração da integração do Application Insights para o modelo de trabalho isolado. No Program.cs, você também deve configurar qualquer filtragem de log que deve ser aplicada aos logs provenientes do código no seu projeto. No modelo de trabalho isolado, o arquivo host.json controla apenas os eventos emitidos pelo runtime do host do Functions. Se você não configurar regras de filtragem no Program.cs, poderá ver diferenças nos níveis de log presentes para várias categorias na telemetria.

Embora você possa registrar fontes de configuração personalizadas como parte do HostBuilder, observe que elas se aplicam somente ao código no seu projeto. A configuração de gatilho e associação também é necessária para a plataforma, e ela deve ser realizada por meio dos recursos de configurações de aplicativo, referências do Key Vault ou referências da Configuração de Aplicativos.

Depois de mover tudo de qualquer FunctionsStartup existente para o arquivo Program.cs, você poderá excluir o atributo FunctionsStartup e a classe à qual ele foi aplicado.

Arquivo host.json

As configurações no arquivo host.json são aplicáveis no nível do aplicativo de funções, localmente e no Azure. Na versão 1.x, o arquivo host.json está vazio ou contém algumas configurações que se aplicam a todas as funções no aplicativo de funções. Para obter mais informações, confira Host.json v1. Se o arquivo host.json tiver valores de configuração, revise o formato host.json v2 para ver se há alterações.

Para executar na versão 4.x, você deve adicionar "version": "2.0" ao arquivo host.json. Você também deve considerar adicionar logging à sua configuração, como nos seguintes exemplos:

{
    "version": "2.0",
    "logging": {
        "applicationInsights": {
            "samplingSettings": {
                "isEnabled": true,
                "excludedTypes": "Request"
            },
            "enableLiveMetricsFilters": true
        }
    }
}

O arquivo host.json controla apenas o log do runtime do host do Functions e, no modelo de trabalho isolado, alguns desses logs vêm diretamente do aplicativo, oferecendo mais controle. Confira Gerenciamento de níveis de log no modelo de trabalho isolado para obter detalhes sobre como filtrar esses logs.

Arquivo local.settings.json

O arquivo local.settings.json só é usado durante a execução local. Para obter informações, confira Arquivo de configurações local. Na versão 1.x, o arquivo local.settings.json tem apenas dois valores necessários:

{
    "IsEncrypted": false,
    "Values": {
        "AzureWebJobsStorage": "AzureWebJobsStorageConnectionStringValue",
        "AzureWebJobsDashboard": "AzureWebJobsStorageConnectionStringValue"
    }
}

Ao migrar para a versão 4.x, verifique se o arquivo local.settings.json tem pelo menos os seguintes elementos:

{
    "IsEncrypted": false,
    "Values": {
        "AzureWebJobsStorage": "AzureWebJobsStorageConnectionStringValue",
        "FUNCTIONS_WORKER_RUNTIME": "dotnet-isolated"
    }
}

Observação

Ao migrar da execução em processo para a execução em um processo de trabalho isolado, você precisa alterar o valor FUNCTIONS_WORKER_RUNTIME para "dotnet-isolated".

Alterações de nome de classe

Algumas classes de chave alteraram os nomes entre a versão 1.x e a versão 4.x. Essas alterações são resultado de alterações nas APIs do .NET ou em diferenças entre o processo de trabalho em processo e isolado. A seguinte tabela indica as principais classes .NET usadas pelo Functions que podem ser alteradas na migração:

Versão 1.x .NET 8
FunctionName (atributo) Function (atributo)
TraceWriter ILogger<T>, ILogger
HttpRequestMessage HttpRequestData, HttpRequest (usando a integração ASP.NET Core)
HttpResponseMessage HttpResponseData, IActionResult (usando a integração ASP.NET Core)

Também pode haver diferenças de nome da classe nas associações. Para saber mais, confira os artigos de referência das associações específicas.

Outras alterações de código

Esta seção destaca outras alterações de código a serem consideradas à medida que você trabalha com a migração. Essas alterações não são necessárias para todos os aplicativos, mas você deve avaliar se alguma é relevante para seus cenários. Verifique se há alterações de comportamento após a versão 1.x para obter alterações adicionais que talvez seja necessário fazer ao seu projeto.

Serialização JSON

Por padrão, o modelo de trabalho isolado usa System.Text.Json para serialização JSON. Para personalizar as opções do serializador ou alternar para JSON.NET (Newtonsoft.Json), consulte estas instruções.

Níveis de log e filtragem do Application Insights

Os logs podem ser enviados ao Application Insights do runtime do host do Functions e do código em seu projeto. O host.json permite que você configure regras para o registro do host, mas para controlar os logs provenientes do código, você precisará configurar regras de filtragem como parte do seu Program.cs. Confira Gerenciamento de níveis de log no modelo de trabalho isolado para obter detalhes sobre como filtrar esses logs.

Modelo de gatilho HTTP

A maioria das alterações de código entre a versão 1.x e a versão 4.x pode ser vista em funções disparadas por HTTP. O modelo de gatilho HTTP para a versão 1.x é semelhante ao exemplo a seguir:

using System.Linq;
using System.Net;
using System.Net.Http;
using System.Threading.Tasks;
using Microsoft.Azure.WebJobs;
using Microsoft.Azure.WebJobs.Extensions.Http;
using Microsoft.Azure.WebJobs.Host;

namespace Company.Function
{
    public static class HttpTriggerCSharp
    {
        [FunctionName("HttpTriggerCSharp")]
        public static async Task<HttpResponseMessage> 
            Run([HttpTrigger(AuthorizationLevel.AuthLevelValue, "get", "post", 
            Route = null)]HttpRequestMessage req, TraceWriter log)
        {
            log.Info("C# HTTP trigger function processed a request.");

            // parse query parameter
            string name = req.GetQueryNameValuePairs()
                .FirstOrDefault(q => string.Compare(q.Key, "name", true) == 0)
                .Value;

            if (name == null)
            {
                // Get request body
                dynamic data = await req.Content.ReadAsAsync<object>();
                name = data?.name;
            }

            return name == null
                ? req.CreateResponse(HttpStatusCode.BadRequest, 
                    "Please pass a name on the query string or in the request body")
                : req.CreateResponse(HttpStatusCode.OK, "Hello " + name);
        }
    }
}

Na versão 4.x, o modelo de gatilho HTTP é semelhante ao seguinte exemplo:

using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Azure.Functions.Worker;
using Microsoft.Extensions.Logging;

namespace Company.Function
{
    public class HttpTriggerCSharp
    {
        private readonly ILogger<HttpTriggerCSharp> _logger;

        public HttpTriggerCSharp(ILogger<HttpTriggerCSharp> logger)
        {
            _logger = logger;
        }

        [Function("HttpTriggerCSharp")]
        public IActionResult Run(
            [HttpTrigger(AuthorizationLevel.Function, "get")] HttpRequest req)
        {
            _logger.LogInformation("C# HTTP trigger function processed a request.");

            return new OkObjectResult($"Welcome to Azure Functions, {req.Query["name"]}!");
        }
    }
}

Para atualizar o projeto para o Azure Functions 4.x:

  1. Atualize a instalação local do Azure Functions Core Tools para a versão 4.x.

  2. Mover para uma das versões do Node.js com suporte na versão 4.x.

  3. Adicione elementos version e extensionBundle ao host.json para que ele se pareça com o exemplo a seguir:

    {
    "version": "2.0",
    "extensionBundle": {
        "id": "Microsoft.Azure.Functions.ExtensionBundle",
        "version": "[3.3.0, 4.0.0)"
    }
}

    O elemento extensionBundle é necessário porque, após a versão 1.x, as associações são mantidas como pacotes externos. Para obter mais informações, consulte Pacotes de extensão.

  4. Atualize o arquivo local.settings.json para que ele tenha pelo menos elementos a seguir:

    {
    "IsEncrypted": false,
    "Values": {
        "AzureWebJobsStorage": "UseDevelopmentStorage=true",
        "FUNCTIONS_WORKER_RUNTIME": "node"
    }
}

    A configuração AzureWebJobsStorage pode ser o emulador de armazenamento do Azurite ou uma conta de armazenamento do Azure de fato. Para obter mais informações, confira Emulador de armazenamento local.

Atualize seu aplicativo de funções no Azure

Você precisa atualizar o runtime do host do aplicativo de funções no Azure para a versão 4.x antes de publicar seu projeto migrado. A versão de runtime usada pelo host do Functions é controlada pela configuração de aplicativo FUNCTIONS_EXTENSION_VERSION, mas em alguns casos outras configurações também precisam ser atualizadas. As alterações de código e as alterações nas configurações de aplicativo exigem que o aplicativo de funções seja reiniciado.

A maneira mais fácil é a atualização sem slots e a nova publicação do projeto de aplicativo. Minimize também o tempo de inatividade no aplicativo e simplifique a reversão com a atualização por meio de slots.

Atualizar sem slots

A maneira mais simples de atualizar para a v4.x é definir a configuração de aplicativo FUNCTIONS_EXTENSION_VERSION como ~4 em seu aplicativo de funções no Azure. Siga um procedimento diferente em um site com slots.

az functionapp config appsettings set --settings FUNCTIONS_EXTENSION_VERSION=~4 -g <RESOURCE_GROUP_NAME> -n <APP_NAME>

Você também precisa definir outra configuração, que é diferente entre o Windows e o Linux.

Ao executar no Windows, você também precisa habilitar o .NET 6.0, que é exigido pela versão 4.x do runtime.

az functionapp config set --net-framework-version v6.0 -g <RESOURCE_GROUP_NAME> -n <APP_NAME>

O .NET 6 é necessário para aplicativos de funções em qualquer idioma em execução no Windows.

Neste exemplo, substitua <APP_NAME> pelo nome do aplicativo de funções e <RESOURCE_GROUP_NAME> pelo nome do grupo de recursos.

Agora você pode publicar novamente seu projeto de aplicativo que foi migrado para ser executado na versão 4.x.

Atualizar usando slots

Usar slots de implantação é uma boa maneira de atualizar seu aplicativo de funções para o runtime v4.x de uma versão anterior. Usando um slot de preparo, você pode executar o aplicativo na nova versão do runtime no slot de preparo e alternar para a produção após a verificação. Os slots também fornecem uma maneira de minimizar o tempo de inatividade durante a atualização. Se precisar minimizar o tempo de inatividade, siga as etapas em Atualização com tempo de inatividade mínimo.

Depois de verificar o aplicativo no slot atualizado, você pode trocar o aplicativo e as novas configurações da versão para produção. Essa troca requer a configuração WEBSITE_OVERRIDE_STICKY_EXTENSION_VERSIONS=0 no slot de produção. A maneira como você adiciona essa configuração afeta a quantidade de tempo de inatividade necessário para a atualização.

Atualização padrão

Se o aplicativo de funções habilitado para slots puder lidar com o tempo de inatividade de uma reinicialização completa, você poderá atualizar a configuração WEBSITE_OVERRIDE_STICKY_EXTENSION_VERSIONS diretamente no slot de produção. Como alterar essa configuração diretamente no slot de produção causa uma reinicialização que afeta a disponibilidade, considere fazer a alteração em um momento de tráfego reduzido. Em seguida, você pode trocar pela versão atualizada do slot de preparo.

No momento, o cmdlet do PowerShell Update-AzFunctionAppSetting não dá suporte a slots. Você precisa usar a CLI do Azure ou o portal do Azure.

  1. Use o seguinte comando para definir WEBSITE_OVERRIDE_STICKY_EXTENSION_VERSIONS=0 no slot de produção:

    az functionapp config appsettings set --settings WEBSITE_OVERRIDE_STICKY_EXTENSION_VERSIONS=0  -g <RESOURCE_GROUP_NAME>  -n <APP_NAME>

    Neste exemplo, substitua <APP_NAME> pelo nome do aplicativo de funções e <RESOURCE_GROUP_NAME> pelo nome do grupo de recursos. Esse comando faz com que o aplicativo em execução no slot de produção seja reiniciado.

  2. Use o seguinte comando para também definir WEBSITE_OVERRIDE_STICKY_EXTENSION_VERSIONS no slot de preparo:

    az functionapp config appsettings set --settings WEBSITE_OVERRIDE_STICKY_EXTENSION_VERSIONS=0 -g <RESOURCE_GROUP_NAME>  -n <APP_NAME> --slot <SLOT_NAME>

  3. Use o seguinte comando para alterar FUNCTIONS_EXTENSION_VERSION e atualizar o slot de preparo para a nova versão do runtime:

    az functionapp config appsettings set --settings FUNCTIONS_EXTENSION_VERSION=~4 -g <RESOURCE_GROUP_NAME>  -n <APP_NAME> --slot <SLOT_NAME>

  4. A versão 4.x do runtime do Functions exige o .NET 6 no Windows. No Linux, os aplicativos .NET também devem fazer upgrade para o .NET 6. Use o comando a seguir para que o runtime possa ser executado no .NET 6:

    Ao executar no Windows, você também precisa habilitar o .NET 6.0, que é exigido pela versão 4.x do runtime.

    az functionapp config set --net-framework-version v6.0 -g <RESOURCE_GROUP_NAME> -n <APP_NAME>

    O .NET 6 é necessário para aplicativos de funções em qualquer idioma em execução no Windows.

    Neste exemplo, substitua <APP_NAME> pelo nome do aplicativo de funções e <RESOURCE_GROUP_NAME> pelo nome do grupo de recursos.

  5. Se o projeto de código exigiu alguma atualização para ser executado na versão 4.x, implante essas atualizações no slot de preparo agora.

  6. Confirme se o aplicativo de funções é executado corretamente no ambiente de preparo atualizado antes da troca.

  7. Use o seguinte comando para colocar o slot de preparo atualizado na produção:

    az functionapp deployment slot swap -g <RESOURCE_GROUP_NAME>  -n <APP_NAME> --slot <SLOT_NAME> --target-slot production

Atualização com tempo de inatividade mínimo

Para minimizar o tempo de inatividade em seu aplicativo de produção, coloque a configuração WEBSITE_OVERRIDE_STICKY_EXTENSION_VERSIONS do slot de preparo para a produção. Depois disso, você pode trocar pela versão atualizada de um slot de preparo pré-aquecido.

  1. Use o seguinte comando para definir WEBSITE_OVERRIDE_STICKY_EXTENSION_VERSIONS=0 no slot de preparo:

    az functionapp config appsettings set --settings WEBSITE_OVERRIDE_STICKY_EXTENSION_VERSIONS=0 -g <RESOURCE_GROUP_NAME>  -n <APP_NAME> --slot <SLOT_NAME>

  2. Use os comandos a seguir para colocar o slot com a nova configuração em produção e, ao mesmo tempo, restaurar a configuração da versão no slot de preparo.

    az functionapp deployment slot swap -g <RESOURCE_GROUP_NAME>  -n <APP_NAME> --slot <SLOT_NAME> --target-slot production
az functionapp config appsettings set --settings FUNCTIONS_EXTENSION_VERSION=~3 -g <RESOURCE_GROUP_NAME>  -n <APP_NAME> --slot <SLOT_NAME>

    Você poderá ver erros do slot de preparo durante o período entre a troca e a versão do runtime que está sendo restaurada no preparo. Isso pode acontecer porque ter WEBSITE_OVERRIDE_STICKY_EXTENSION_VERSIONS=0 apenas no preparo durante uma troca remove a configuração FUNCTIONS_EXTENSION_VERSION no preparo. Sem a configuração da versão, o slot fica em um estado inválido. Atualizar a versão no slot de preparo logo após a troca deve colocar o slot de volta em um estado válido e você pode chamar uma reversão das alterações se necessário. No entanto, qualquer reversão da troca também exige que você remova WEBSITE_OVERRIDE_STICKY_EXTENSION_VERSIONS=0 diretamente da produção antes de trocar de volta para evitar os mesmos erros na produção vistos no preparo. Essa alteração na configuração de produção causaria uma reinicialização.

  3. Use o seguinte comando para definir WEBSITE_OVERRIDE_STICKY_EXTENSION_VERSIONS=0 novamente no slot de preparo:

    az functionapp config appsettings set --settings WEBSITE_OVERRIDE_STICKY_EXTENSION_VERSIONS=0 -g <RESOURCE_GROUP_NAME>  -n <APP_NAME> --slot <SLOT_NAME>

    Neste ponto, ambos os slots têm WEBSITE_OVERRIDE_STICKY_EXTENSION_VERSIONS=0 definido.

  4. Use o seguinte comando para alterar FUNCTIONS_EXTENSION_VERSION e atualizar o slot de preparo para a nova versão do runtime:

    az functionapp config appsettings set --settings FUNCTIONS_EXTENSION_VERSION=~4 -g <RESOURCE_GROUP_NAME>  -n <APP_NAME> --slot <SLOT_NAME>

  5. A versão 4.x do runtime do Functions exige o .NET 6 no Windows. No Linux, os aplicativos .NET também devem fazer upgrade para o .NET 6. Use o comando a seguir para que o runtime possa ser executado no .NET 6:

    Ao executar no Windows, você também precisa habilitar o .NET 6.0, que é exigido pela versão 4.x do runtime.

    az functionapp config set --net-framework-version v6.0 -g <RESOURCE_GROUP_NAME> -n <APP_NAME>

    O .NET 6 é necessário para aplicativos de funções em qualquer idioma em execução no Windows.

    Neste exemplo, substitua <APP_NAME> pelo nome do aplicativo de funções e <RESOURCE_GROUP_NAME> pelo nome do grupo de recursos.

  6. Se o projeto de código exigiu alguma atualização para ser executado na versão 4.x, implante essas atualizações no slot de preparo agora.

  7. Confirme se o aplicativo de funções é executado corretamente no ambiente de preparo atualizado antes da troca.

  8. Use o seguinte comando para colocar o slot de preparo atualizado e pré-aquecido na produção:

    az functionapp deployment slot swap -g <RESOURCE_GROUP_NAME>  -n <APP_NAME> --slot <SLOT_NAME> --target-slot production

Alterações de comportamento após a versão 1.x

Esta seção detalha as alterações feitas após a versão 1.x em comportamentos de gatilho e de associação, bem como nos principais recursos e comportamentos do Functions.

Alterações nos gatilhos e associações

A partir da versão 2.x, é necessário instalar as extensões de ligações e gatilhos específicos usadas pelas funções em seu aplicativo. A única exceção para isso são os gatilhos de temporizador e HTTP, que não exigem uma extensão. Para obter mais informações, confira Registrar e instalar extensões de associação.

Também há algumas alterações no function.json ou em atributos da função entre as versões. Por exemplo, a propriedade path do Hubs de Eventos agora é eventHubName. Veja a tabela de associação existente para obter links para a documentação de cada associação.

Alterações nos recursos e funcionalidades

Alguns recursos foram removidos, atualizados ou substituídos após a versão 1.x. Esta seção detalha as mudanças aplicadas às versões mais recentes após ter usado a versão 1.x.

As seguintes alterações foram feitas na versão 2.x:

  • As chaves para chamar pontos de extremidade HTTP são sempre armazenadas criptografadas no Armazenamento de Blobs do Azure. Na versão 1.x, as chaves eram armazenadas nos Arquivos do Azure por padrão. Ao migrar um aplicativo da versão 1.x para a 2.x, os segredos existentes que estão nos Arquivos do Azure serão redefinidos.

  • A versão 2.x do runtime não inclui suporte interno para provedores de webhook. Essa alteração foi feita para melhorar o desempenho. Você ainda pode usar gatilhos HTTP como pontos de extremidade para webhooks.

  • Para melhorar o monitoramento, o painel WebJobs no portal, o qual usou a configuração AzureWebJobsDashboard, é substituído com o Azure Application Insights, que usa a configuração APPINSIGHTS_INSTRUMENTATIONKEY. Para saber mais, consulte Monitorar Azure Functions.

  • Todas as funções em um aplicativo de funções devem compartilhar a mesma linguagem de programação. Quando você cria um aplicativo de funções, você deve escolher para ele uma pilha de runtime. A pilha de runtime é especificada pelo valor FUNCTIONS_WORKER_RUNTIME nas configurações do aplicativo. Esse requisito foi adicionado para melhorar o tempo de inicialização e o volume. Ao desenvolver localmente, você também deve incluir essa configuração no arquivo local.settings.json.

  • O tempo limite padrão para as funções em um plano do Serviço de Aplicativo foi alterado para 30 minutos. Você pode alterar manualmente o tempo limite para ilimitado, usando a configuração functionTimeout em host.json.

  • Restrições de simultaneidade HTTP são implementadas por padrão para funções de plano de consumo, com um padrão de 100 solicitações simultâneas por instância. Você pode alterar esse comportamento na configuração maxConcurrentRequests no arquivo host.json.

  • Devido às limitações do .NET Core, o suporte a funções de script F# (.fsx) foi removido. Funções F# compiladas (.fs) ainda são compatíveis.

  • O formato da URL de webhooks de gatilho da Grade de Eventos foi alterado para seguir este padrão: https://{app}/runtime/webhooks/{triggerName}.

  • Os nomes de algumas métricas personalizadas predefinidas foram alterados após a versão 1.x. Duration foi substituído por MaxDurationMs, MinDurationMs e AvgDurationMs. Success Rate também foi renomeado Success Rate.

Considerações sobre o Azure Stack Hub

O Serviço de Aplicativo no Azure Stack Hub não dá suporte à versão 4.x do Azure Functions. Ao planejar uma migração da versão 1.x no Azure Stack Hub, você pode escolher uma das seguintes opções:

  • Migre para a versão 4.x hospedada na nuvem pública do Azure Functions usando as instruções neste artigo. Em vez de atualizar seu aplicativo existente, você criaria um novo aplicativo usando a versão 4.x e, em seguida, implantaria seu projeto modificado nele.
  • Alterne para WebJobs hospedados em um plano do Serviço de Aplicativo no Azure Stack Hub.

Próximas etapas

Saiba mais sobre as versões do Functions