DEV Community: Douglas SantAnna Figueredo

Azure Function with .NET Isolated Worker: Sharing Services Between API and Function Apps

Douglas SantAnna Figueredo — Wed, 19 Feb 2025 15:37:59 +0000

This tutorial demonstrates how to create an Azure Function with a .NET isolated worker process that utilizes services defined in a separate API project. This architecture allows you to share business logic and data access code between your API and functions, promoting code reuse and maintainability.

Prerequisites:

Visual Studio Code: Installed and configured for .NET development.
SQL Server Instance: A running SQL Server instance with a database and a "Users" table already created. (We'll focus on the integration, not the full database setup.)
Azurite: Installed for local Azure Storage emulation (if using triggers that require storage).
.NET SDK and Runtime (Version 8): .NET 8 SDK and runtime environment installed on your machine.
Azure Functions Core Tools: Azure Functions Core Tools installed for local function development and deployment.

For this example, we'll use a simplified scenario with fake data and methods. It's assumed you have a database server running and a database with a "Users" table already created. We'll focus on the integration between the API and Function rather than full database setup.

Step-by-Step Guide

Project Setup

Create a project folder:

mkdir az-func-api
cd az-func-api

Create the API project:

mkdir api
cd api
dotnet new webapi -f net8.0  # Use webapi template for cleaner API project

Create the Function project:

cd ..
mkdir functions
cd functions
func init --worker-runtime dotnet-isolated  # Or func init http for an HTTP triggered function

Follow the prompts to configure your function. Choose the dotnet (isolated worker model) and then c#-isolated.

Add both projects to the solution:

cd ..
dotnet new sln # Create Solution File
dotnet sln add api
dotnet sln add functions

Add a project reference from the Functions project to the API project:

cd functions
dotnet add reference ../api/

API Project Setup

Install NuGet Packages:

cd api
dotnet add package Microsoft.EntityFrameworkCore.SqlServer --version 8.0.1
dotnet add package Microsoft.EntityFrameworkCore.Tools --version 8.0.1

Configure Database Connection:
Add your database connection string to appsettings.json in the API project:

{
  "ConnectionStrings": {
    "DefaultConnection": "Server=localhost,1433;Database=MyDatabase;User Id=sa;Password=MyPassword;Encrypt=True;TrustServerCertificate=True"
  }
}

Create Data Model (User.cs):

// api/Models/User.cs
public class User
{
    public int Id { get; set; }
    public string Name { get; set; }
    public string Email { get; set; } // Added Email property for demonstration
}

Create Data Context (DataContext.cs):

// api/Data/DataContext.cs
public class DataContext : DbContext
{
    public DataContext(DbContextOptions<DataContext> options) : base(options) { }
    public DbSet<User> Users { get; set; }
}

Create Repository Interface and Implementation (IUserRepository.cs, UserRepository.cs):

// api/Interfaces/IUserRepository.cs
public interface IUserRepository
{
    Task<List<User>> GetUsers(CancellationToken cancellationToken);
    Task CreateUsers(List<User> users);
}

// api/Repositories/UserRepository.cs
public class UserRepository : IUserRepository
{
    private readonly DataContext _context;
    public UserRepository(DataContext context)
    {
        _context = context;
    }

    public async Task<List<User>> GetUsers(CancellationToken cancellationToken)
    {
        return await _context.Users.ToListAsync(cancellationToken);
    }

    public async Task CreateUsers(List<User> users)
    {
        await _context.Users.AddRangeAsync(users);
        await _context.SaveChangesAsync();
    }
}

// api/Extensions/ServiceExtensions.cs
public static class ServiceExtensions
{
    public static void AddApplicationServices(this IServiceCollection services, string connectionString)
    {
        services.AddDbContext<DataContext>(opt =>
            opt.UseSqlServer(connectionString));
        services.AddTransient<IUserRepository, UserRepository>();
    }
}

Configure API Endpoints (Program.cs):

// api/Program.cs
var builder = WebApplication.CreateBuilder(args);

// Retrieve the connection string (better practice than hardcoding)
var connectionString = builder.Configuration.GetConnectionString("DefaultConnection");
if (string.IsNullOrEmpty(connectionString))
{
    throw new InvalidOperationException("Connection string 'DefaultConnection' is missing.");
}

builder.Services.AddApplicationServices(connectionString);  // Pass connection string here

var app = builder.Build();

app.MapPost("/users", async (IUserRepository userRepository) =>
{
    var fakeUsers = new List<User> // List of fake users 
    { 
        new User { Name = "Alice", Email = "alice@example.com" }, 
        new User { Name = "Bob", Email = "bob@example.com" }, 
        new User { Name = "Charlie", Email = "charlie@example.com" }, // Add more fake users as needed 
    };
    await userRepository.CreateUsers(fakeUsers);
    return Results.Created($"/users", fakeUsers);
});

app.MapGet("/users", async (IUserRepository userRepository, CancellationToken cancellationToken) =>
{
    return Results.Ok(await userRepository.GetUsers(cancellationToken));
});

app.Run();

Test API Endpoints: Use Postman or a similar tool to test the /users POST and GET endpoints.

Functions Project Setup

Configure local.settings.json:

{
  "IsEncrypted": false,
  "Values": {
    "AzureWebJobsStorage": "UseDevelopmentStorage=true",
    "FUNCTIONS_WORKER_RUNTIME": "dotnet-isolated",
    "DefaultConnection": "Server=localhost,1433;Database=MyDatabase;User Id=sa;Password=MyPassword;Encrypt=True;TrustServerCertificate=True"
  }
}

Configure Program.cs:

// functions/Program.cs
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.Hosting;
using System;

var builder = FunctionsApplication.CreateBuilder(args);

builder.ConfigureFunctionsWebApplication();

builder.Configuration
.AddJsonFile("local.settings.json", optional: true, reloadOnChange: true)
.AddEnvironmentVariables();

var connectionString = builder.Configuration.GetValue<string>("Values:DefaultConnection");
if (string.IsNullOrEmpty(connectionString))
    throw new InvalidOperationException("Connection string 'DefaultConnection' is missing.");

builder.Services.AddApplicationServices(connectionString); // Use the same extension method

builder.Build().Run();

Create the Function by running command func new --name users, select function type TimerTrigger

// functions/listUsers.cs
using Microsoft.Azure.Functions.Worker;
using Microsoft.Extensions.Logging;
using api.Interfaces; // Important: Use the interface from the API project

namespace MyFunctionApp
{
    public class listUsers
    {
        private readonly ILogger _logger;
        private readonly IUserRepository _userRepository; // Inject the repository

        public listUsers(ILoggerFactory loggerFactory, IUserRepository userRepository)
        {
            _logger = loggerFactory.CreateLogger<listUsers>();
            _userRepository = userRepository;
        }

        [Function("listUsers")]
        public async Task Run([TimerTrigger("0/10 * * * * *")] CancellationToken cancellationToken) // Example: Timer trigger
        {
            var users = await _userRepository.GetUsers(cancellationToken); // Use the repository

            foreach (var user in users)
            {
                _logger.LogInformation($"Username: {user.Name}, Email: {user.Email}");
            }
        }
    }
}

Run the Projects

Start Azurite (if needed): If your Azure Function uses any triggers or bindings that require Azure Storage (like Queue Storage, Blob Storage, or Table Storage), you'll need to start Azurite, the local Azure Storage emulator.

Using the VS Code Extension: The easiest way is often through the Azurite extension in VS Code. Install the "Azurite" extension. Then, use Ctrl+Shift+P (or Cmd+Shift+P on macOS) and type "Azurite: Start." This will start Azurite. The extension usually configures the connection strings automatically.
Start the API project: open a terminal, navigate to the api directory, and run dotnet run.
Start the Functions project: open a new terminal window, navigate to the functions project, and run the command func start --dotnet-isolated
Verify: Observe the output in the functions terminal. You should see the users being logged there, confirming that the function is running correctly and accessing the API.

Customizando o seu Windows Terminal

Douglas SantAnna Figueredo — Wed, 18 Jan 2023 02:32:35 +0000

Dê vida ao seu Windows Terminal de forma simples!

Não sei vocês, mas eu gosto muito de utilizar linhas de comando para criar certos serviços e apps. Aqui uso bastante a CLI do Azure, dotnet e do Angular. E pensando em deixar o terminal mais agradável aos olhos, decidi personaliza-lo e vou mostrar como fiz isso em poucos passos.

Ao final do passo-a-passo, seu terminal deverá ficar assim:

Windows Terminal

Você deve instalar o Windows Terminal na sua maquina. É um passo muito simples. Basta ir até a Microsoft Store, pesquisar por Windows Terminal e fazer o download gratuito do app.
Após a instalação abra o Windows Terminal e você verá a seguinte tela. Veja que não existe nenhum tipo de customização.

Oh-my-posh

Vamos utilizar o Oh-my-posh para dar vida ao terminal. Essa engine possui diversos temas que podem ser personalizados e importados ao nosso terminal.

Para fazer o download e instalação do Oh-my-posh, execute o codigo abaixo no terminal.

Set-ExecutionPolicy Bypass -Scope Process -Force; Invoke-Expression ((New-Object System.Net.WebClient).DownloadString('https://ohmyposh.dev/install.ps1'))

Clique aqui para ver a documentação do Oh-my-posh.

Terminal-Icons

Já o Terminal-Icons, como o nome sugere, adiciona ícones ao terminal através do módulo PSGallery.
Para fazer o download e instalação do Terminal-Icons, execute o codigo abaixo no terminal.

Install-Module -Name Terminal-Icons -Repository PSGallery

Clique aqui para ver a documentação do Terminal-Icons.

Nerd Fonts

A fonte padrão utilizada pelo terminal não suporta o Oh-my-posh e nem o Terminal-Icons. Então para que tudo funcione de forma correta vamos utilizar uma fonte que suporta tudo isso.

Acesse o site Nerd Fonts, vá em downloads e procure pela fonte Caskaydia Cove Nerd Font.

O download vem zipado, por isso você deve descompactar a pasta e após isso instalar as fontes na sua máquina. Você pode selecionar todos os arquivos de uma só vez, clicar com o botão direito do mouse e selecionar a opção Instalar.

Configuração

Com esses passos feitos, abra o terminal, digite CTRL + , , selecione a aba Padrões e a opção Aparência.

Agora, em Tipo de fonte, selecione a fonte recem instalada Caskaydia Nerd Font Mono e clique em salvar.

Volte no terminal e execute o código:

notepad $PROFILE

Esse comando faz com que o arquivo de configuração do perfil do seu terminal seja aberto.
Nesse arquivo, adicione as seguintes linhas de código:

Import-Module -Name Terminal-Icons
oh-my-posh init pwsh --config 'https://raw.githubusercontent.com/JanDeDobbeleer/oh-my-posh/main/themes/aliens.omp.json' | Invoke-Expression
Clear-Host
Write-Host 'Ola mundo'

Antes de eu dizer que está tudo pronto, me deixe explicar qual a função de cada linha dessas acima.

Toda vez que o seu terminal for aberto essas linhas serão executadas.
Import-Module -Name Terminal-Icons e oh-my-posh init pwsh: importa os módulos instalados na sua máquina no perfil do seu Windows Terminal.
Clear-Host: limpa o seu terminal na hora da inicialização.
Write-Host: aqui você pode escrever uma mensagem de sua preferência.

Mudar o tema

Como você pode ver, a engine Oh-my-posh disponibiliza dezenas de temas, com cores e simbolos diferentes, para que possamos escolher um que mais nos agrada.
O tema é configurado nessa linha de código que você inseriu no perfil do seu Windows Terminal:

oh-my-posh init pwsh --config 'https://raw.githubusercontent.com/JanDeDobbeleer/oh-my-posh/main/themes/aliens.omp.json' | Invoke-Expression

Caso você queira trocar o tema, basta você acessar a página do Oh-my-posh clicando aqui.
Veja a quantidade de temas gratuitos que você pode escolher. Pra isso você só precisa mudar o nome do tema no final da linha de código que você salvou no seu perfil, exemplo:

'https://raw.githubusercontent.com/JanDeDobbeleer/oh-my-posh/main/themes/aliens.omp.json' | Invoke-Expression
Substitua aliens por amro e sua linha de código deve ficar assim:
'https://raw.githubusercontent.com/JanDeDobbeleer/oh-my-posh/main/themes/amro.omp.json' | Invoke-Expression
Salve o arquivo, feche o seu terminal e abra novamente e veja a mágica acontecer.

Aumente a segurança da sua aplicação com Azure Key Vault

Douglas SantAnna Figueredo — Tue, 17 Jan 2023 16:35:34 +0000

Nesse artigo vamos aprender, de forma simples e objetiva, a criar um segredo no serviço Key Vault, oferecido pelo Microsoft Azure.

Antes, uma breve explicação sobre o Azure Key Vault:

Azure Key Vault, em português Azure cofre de chaves, é um serviço em núvem do Microsoft Azure usado para centralizar o armazenamento e gerenciamento de chaves de API, chaves criptográficas, segredos e certificados que precisam ser controlados de forma simples e rígida.

Ao criar o serviço temos duas opções de armazenamento, sendo a camada standard e a premium. Na primeira camada, todo e qualquer segredo/chave/certificado será protegido por um software de segurança. A segunda camada, além de trazer a mesma segurança da primeira, da a opção de proteger chaves por módulo de segurança de hardware (Hardware Security Module).

O (Hardware Security Module) oferecido pela camada premium é responsável por trazer uma camada extra de segurança criptográfica para as chaves

Sobre chaves – Azure Key Vault | Microsoft Learn

Visão geral dos detalhes da interface REST e do desenvolvedor do Azure Key Vault para as chaves.

learn.microsoft.com

O administrador ou proprietário do Key Vault tem controle absoluto sobre o cofre. É possível criar novas chaves, altera-las, definir uma data de ativação e/ou expiração, monitorar os logs via gráficos através do Metrics, definir qual usuário ou aplicativo poderá acessar/administrar determinada chave, dentre outras funções.

Mão na massa

Temos uma aplicação (Azure Function) implantada no Azure que faz consultas a uma base de dados. Atualmente, no arquivo de configuração da aplicação, temos a string de conexão em seu valor original.
Vamos criar um serviço Azure Key Vault, gerar um segredo contendo o valor original da string de conexão e, no arquivo de configuração da aplicação, vamos substituir o valor original da string de conexão pelo segredo gerado no Key Vault.

Para este exemplo, você deve possuir

uma aplicação no ar

uma assinatura no Azure

1 - Ao acessar o menú Configuration do nosso app, podemos ver nossa string de conexão com seu valor original.

1.1 - Ao acessar nosso Key Vault, a opção Objects nos mostra nossas chaves, segredos e certificados. Como ainda não possuimos nenhum segredo gerado, vamos gerar um indo em + Generate/Import

Para criar o seu Azure Key Vault, selecione um grupo de recurso, procure por Key Vault e defina um nome, escolha uma região e selecione a camada que lhe atende.

1.2 - Defina um nome para sua string de conexão e cole em Secret value o valor original da sua string de conexão. Repare que é nesse momento que optamos ou não por uma data de ativação/expiração.

1.3 - Após termos nosso segredo gerado e clicarmos sobre ele, vamos notar que é possível gerarmos outras versões do mesmo segredo porém com valores e datas de ativação/expiração diferentes.

1.4 - Ao clicarmos sobre a versão do nosso segredo, podemos visualizar informações importantes, porém a mais relevante é a Secret identifier. Veja que é com essa URL que teremos acesso ao nosso segredo.

Formato da URL gerada pelo Key Vault: https://{nome-cofre}.vault.azure.net/segredo/nome-segredo/versão

Nesse momento temos nosso segredo gerado. O próximo passo é darmos permissão ao nosso app para que ele tenha permissão para acessar o valor do segredo.
Veja que interessante e o quão seguro é usar o Key Vault! Além de não mostrarmos o valor original da nossa string de conexão, ainda devemos dar permissão para que o app que vai consumir o segredo possar ler seu real valor!

Então vamos dar permissão ao app.

2 - Para que o nosso Key Vault consiga 'enxergar' a nossa aplicação, a mesma deve estar visível a outros serviços internos do Azure. Para isso confirme que este detalhe esteja habilitado.
No menu esquerdo da sua aplicação procure por Identity. Certifique-se que o seu Status seja On.

2.1 - Ainda no nosso Key Vault, no menú esquerdo, vá em Access policies. Podemos ver que o administrador/criador do serviço possui permissão geral sobre o segredo. Agora vamos criar uma nova permissão. Clique em Create.

2.2 - Na aba Permissions podemos configurar qual tipo de permissão queremos. Se tratando de uma string de conexão, optei por liberar apenas permissão de leitura.

2.3 - Na aba Principal podemos procurar pelo app que terá permissão de leitura do nosso segredo. Veja que nessa aba podemos procurar por um usuário para ter acesso ao segredo, e na aba seguinte Application (optional) podemos procurar por um app desse usuário.

2.4 - Após finalizado o processo de permissão, voltamos a página do Access policies e vemos que nosso app teve sua permissão criada com sucesso.

Substituindo nosso valor original da string de conexão pela URL do nosso segredo.

3 - Após ter copiado a URL do nosso segredo, volte ao seu app e acesse Configuration. Clique sobre a opção Advanced edit e substitua o valor original da string de conexão pela URL gerada pelo segredo.

 {
    "name": "ConnectionString",
    "value": "@Microsoft.KeyVault(SecretUri=https://authappkeyvault.vault.azure.net/secrets/ConnectionString/74oi52a2c95f4a87e4d9ee15d4e95aa0a82cc9f4)",
    "slotSetting": false
  }

Perceba que além da URL gerada pelo segredo, a Microsoft exige que seja incluído uma sintaxe de referência @Microsoft.KeyVault(SecretUri=https://myvault.vault.azure.net/secrets/mysecret/).

Usar referências de Key Vault - Azure App Service | Microsoft Learn

Saiba como configurar o Serviço de Aplicativo do Azure e o Azure Functions para usar referências do Azure Key Vault. Torne os segredos do Key Vault disponíveis para o código do aplicativo.

learn.microsoft.com

Após concluídos esses passos, o processo está completo.
Observe que é um processo muito simples e que entrega uma segurança gigantesca. Mais um ponto pro Microsoft Azure.