처음 "서버리스"라는 말을 들었을 때 많은 사람들이 이런 생각을 해.
"서버가 없다고? 그럼 코드는 어디서 돌아가는 거야?" 😂

맞아, 완전히 합리적인 의문이야. 사실 서버리스는 서버가 없는 게 아니야.
정확히는 "개발자가 서버를 직접 관리하지 않아도 되는 방식"을 말해.
서버는 분명히 존재하는데, 그 서버를 클라우드 제공업체(여기서는 Microsoft Azure)가 알아서 관리해주는 거지.

전통적인 서버 방식을 생각해봐. 예전에는 웹 서비스를 만들려면 이런 과정이 필요했어:

서버리스는 이 모든 걸 클라우드 업체가 대신 해줘.
개발자는 그냥 함수(Function) 코드만 작성하면 돼.
그리고 그 함수는 특정 이벤트가 발생했을 때만 실행되고, 실행된 만큼만 비용을 내는 거야.
이런 방식을 FaaS(Function as a Service)라고 부르는데, Azure Functions가 바로 이 FaaS의 대표 주자야! ⚡

Azure Functions는 Microsoft Azure 클라우드에서 제공하는 서버리스 컴퓨팅 서비스야.
2016년에 처음 출시됐고, 지금은 엄청나게 성숙한 플랫폼이 됐어.
C#, JavaScript, Python, Java, PowerShell 등 다양한 언어를 지원하는데,
그 중에서도 C#은 Azure Functions와 가장 찰떡궁합인 언어야.
왜냐하면 Azure 자체가 Microsoft 제품이고, C#도 Microsoft가 만든 언어니까! 🎯

Azure Functions는 계속 발전해왔어. 현재 주요 버전을 알아보자:

C#으로 Azure Functions를 개발할 때 두 가지 모델 중 하나를 선택해야 해:

이론은 충분히 배웠으니 이제 직접 만들어보자!
CLI를 사용해서 프로젝트를 생성하는 방법부터 알아볼게.

# 새 Functions 프로젝트 생성
func init MyFirstFunctionApp --worker-runtime dotnet-isolated --target-framework net8.0

# 프로젝트 폴더로 이동
cd MyFirstFunctionApp

# HTTP 트리거 함수 추가
func new --name HelloFunction --template "HTTP trigger" --authlevel anonymous

위 명령어를 실행하면 프로젝트 구조가 생성돼. 어떤 파일들이 만들어지는지 살펴보자:

MyFirstFunctionApp/
├── HelloFunction.cs        ← 함수 코드
├── Program.cs              ← 앱 진입점 (Isolated 모델)
├── MyFirstFunctionApp.csproj  ← 프로젝트 파일
├── host.json               ← Functions 호스트 설정
└── local.settings.json     ← 로컬 개발 설정 (비밀값 포함, git에 올리지 마!)
    

Isolated Worker 모델에서는 Program.cs가 앱의 시작점이야.
ASP.NET Core와 비슷한 구조를 가지고 있어서 익숙할 거야:

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

var host = new HostBuilder()
    .ConfigureFunctionsWorkerDefaults()
    .ConfigureServices(services =>
    {
        // 의존성 주입 설정
        services.AddApplicationInsightsTelemetryWorkerService();
        services.ConfigureFunctionsApplicationInsights();
        
        // 커스텀 서비스 등록
        // services.AddScoped<IMyService, MyService>();
    })
    .Build();

host.Run();

이제 핵심인 함수 코드를 보자. 자동 생성된 코드를 살펴볼게:

using Microsoft.Azure.Functions.Worker;
using Microsoft.Azure.Functions.Worker.Http;
using Microsoft.Extensions.Logging;
using System.Net;

namespace MyFirstFunctionApp
{
    public class HelloFunction
    {
        private readonly ILogger<HelloFunction> _logger;

        // 생성자 주입 — 의존성 주입이 완벽하게 지원돼!
        public HelloFunction(ILogger<HelloFunction> logger)
        {
            _logger = logger;
        }

        [Function("HelloFunction")]
        public async Task<HttpResponseData> Run(
            [HttpTrigger(AuthorizationLevel.Anonymous, "get", "post")] 
            HttpRequestData req)
        {
            _logger.LogInformation("C# HTTP trigger function processed a request.");

            // 쿼리 파라미터에서 name 가져오기
            var queryParams = System.Web.HttpUtility.ParseQueryString(req.Url.Query);
            string? name = queryParams["name"];

            // 응답 생성
            var response = req.CreateResponse(HttpStatusCode.OK);
            response.Headers.Add("Content-Type", "text/plain; charset=utf-8");

            string responseMessage = string.IsNullOrEmpty(name)
                ? "안녕하세요! name 파라미터를 전달해주세요."
                : $"안녕하세요, {name}님! Azure Functions에 오신 걸 환영합니다! 🎉";

            await response.WriteStringAsync(responseMessage);
            return response;
        }
    }
}

# 로컬 실행
func start

# 또는 dotnet 명령어로
dotnet run

실행하면 이런 출력이 나와:

Azure Functions Core Tools
Core Tools Version: 4.x.x
Function Runtime Version: 4.x.x

Functions:
    HelloFunction: [GET,POST] http://localhost:7071/api/HelloFunction

For detailed output, run func with --verbose flag.
    

브라우저에서 http://localhost:7071/api/HelloFunction?name=개발자를 열면
"안녕하세요, 개발자님! Azure Functions에 오신 걸 환영합니다! 🎉"라는 응답이 나와.
첫 번째 서버리스 함수 완성! 🥳

Azure Functions에서 가장 중요한 개념이 바로 트리거(Trigger)와 바인딩(Binding)이야.
이 두 개념을 제대로 이해하면 Azure Functions의 80%는 이해한 거야!

매일 자정에 데이터를 정리하거나, 매 시간마다 리포트를 생성하는 작업에 딱이야.
CRON 표현식을 사용해서 실행 주기를 설정해:

using Microsoft.Azure.Functions.Worker;
using Microsoft.Extensions.Logging;

namespace MyFirstFunctionApp
{
    public class TimerFunction
    {
        private readonly ILogger<TimerFunction> _logger;

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

        // CRON 표현식: "0 0 * * * *" = 매 시간 정각에 실행
        // 형식: {초} {분} {시} {일} {월} {요일}
        [Function("TimerFunction")]
        public void Run([TimerTrigger("0 0 * * * *")] TimerInfo myTimer)
        {
            _logger.LogInformation($"타이머 함수 실행: {DateTime.Now}");
            
            if (myTimer.ScheduleStatus is not null)
            {
                _logger.LogInformation($"다음 실행 예정: {myTimer.ScheduleStatus.Next}");
            }
            
            // 여기에 정기 작업 로직 작성
            // 예: 오래된 데이터 삭제, 리포트 생성, 알림 발송 등
        }
    }
}

파일이 업로드되면 자동으로 처리하는 함수야.
이미지 리사이징, 문서 변환, 데이터 파싱 등에 완벽해:

using Microsoft.Azure.Functions.Worker;
using Microsoft.Extensions.Logging;

namespace MyFirstFunctionApp
{
    public class BlobFunction
    {
        private readonly ILogger<BlobFunction> _logger;

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

        [Function("BlobFunction")]
        public async Task Run(
            // 입력 바인딩: "uploads" 컨테이너에 파일이 올라오면 트리거
            [BlobTrigger("uploads/{name}", Connection = "AzureWebJobsStorage")] 
            Stream blobStream,
            string name,
            // 출력 바인딩: 처리된 파일을 "processed" 컨테이너에 저장
            [BlobOutput("processed/{name}", Connection = "AzureWebJobsStorage")]
            Stream outputBlob)
        {
            _logger.LogInformation($"파일 처리 시작: {name}, 크기: {blobStream.Length} bytes");
            
            // 파일 처리 로직 (예: 이미지 리사이징, 텍스트 변환 등)
            await blobStream.CopyToAsync(outputBlob);
            
            _logger.LogInformation($"파일 처리 완료: {name}");
        }
    }
}

메시지 큐에 메시지가 들어오면 처리하는 함수야.
비동기 작업 처리, 이메일 발송, 알림 처리 등에 많이 써:

using Microsoft.Azure.Functions.Worker;
using Microsoft.Extensions.Logging;
using System.Text.Json;

namespace MyFirstFunctionApp
{
    // 메시지 모델
    public record OrderMessage(
        string OrderId,
        string CustomerId,
        decimal Amount,
        DateTime CreatedAt
    );

    public class QueueFunction
    {
        private readonly ILogger<QueueFunction> _logger;

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

        [Function("QueueFunction")]
        public async Task Run(
            [QueueTrigger("orders-queue", Connection = "AzureWebJobsStorage")] 
            string messageContent)
        {
            _logger.LogInformation($"큐 메시지 수신: {messageContent}");
            
            // JSON 역직렬화
            var order = JsonSerializer.Deserialize<OrderMessage>(messageContent);
            
            if (order is null)
            {
                _logger.LogError("메시지 파싱 실패");
                return;
            }
            
            _logger.LogInformation($"주문 처리: OrderId={order.OrderId}, Amount={order.Amount:C}");
            
            // 주문 처리 로직
            await ProcessOrderAsync(order);
        }
        
        private async Task ProcessOrderAsync(OrderMessage order)
        {
            // 실제 주문 처리 로직
            await Task.Delay(100); // 시뮬레이션
            _logger.LogInformation($"주문 {order.OrderId} 처리 완료!");
        }
    }
}

Cosmos DB에 데이터가 추가되거나 변경될 때 자동으로 실행되는 함수야.
실시간 데이터 동기화, 이벤트 소싱 패턴에 많이 사용해:

using Microsoft.Azure.Functions.Worker;
using Microsoft.Extensions.Logging;

namespace MyFirstFunctionApp
{
    public class CosmosFunction
    {
        private readonly ILogger<CosmosFunction> _logger;

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

        [Function("CosmosFunction")]
        public void Run(
            [CosmosDBTrigger(
                databaseName: "MyDatabase",
                containerName: "MyContainer",
                Connection = "CosmosDBConnection",
                LeaseContainerName = "leases",
                CreateLeaseContainerIfNotExists = true)]
            IReadOnlyList<MyDocument> documents)
        {
            if (documents is null || documents.Count == 0) return;
            
            _logger.LogInformation($"변경된 문서 수: {documents.Count}");
            
            foreach (var doc in documents)
            {
                _logger.LogInformation($"변경된 문서 ID: {doc.Id}");
                // 변경 사항 처리 로직
            }
        }
    }
    
    public class MyDocument
    {
        public string Id { get; set; } = string.Empty;
        public string Name { get; set; } = string.Empty;
        // 기타 필드들...
    }
}

일반 Azure Functions는 무상태(Stateless)야. 실행이 끝나면 상태가 사라져.
하지만 Durable Functions를 사용하면 장기 실행 워크플로우를 구현할 수 있어!
주문 처리 파이프라인, 승인 워크플로우, 팬아웃/팬인 패턴 등에 완벽해.

using Microsoft.Azure.Functions.Worker;
using Microsoft.Azure.Functions.Worker.Http;
using Microsoft.DurableTask;
using Microsoft.DurableTask.Client;
using Microsoft.Extensions.Logging;

namespace MyFirstFunctionApp
{
    public class OrderProcessingOrchestrator
    {
        // 1. HTTP 트리거 — 오케스트레이션 시작
        [Function("StartOrderProcessing")]
        public static async Task<HttpResponseData> StartOrchestration(
            [HttpTrigger(AuthorizationLevel.Anonymous, "post")] HttpRequestData req,
            [DurableClient] DurableTaskClient client,
            FunctionContext executionContext)
        {
            var logger = executionContext.GetLogger("StartOrderProcessing");
            
            var orderData = await req.ReadFromJsonAsync<OrderData>();
            
            // 오케스트레이션 시작
            string instanceId = await client.ScheduleNewOrchestrationInstanceAsync(
                "OrderOrchestrator", 
                orderData);
            
            logger.LogInformation($"오케스트레이션 시작: {instanceId}");
            
            // 상태 확인 URL 반환
            return await client.CreateCheckStatusResponseAsync(req, instanceId);
        }

        // 2. 오케스트레이터 — 워크플로우 정의
        [Function("OrderOrchestrator")]
        public static async Task<string> RunOrchestrator(
            [OrchestrationTrigger] TaskOrchestrationContext context)
        {
            var logger = context.CreateReplaySafeLogger("OrderOrchestrator");
            var order = context.GetInput<OrderData>()!;
            
            logger.LogInformation($"주문 처리 시작: {order.OrderId}");
            
            // 순차적 활동 실행
            var paymentResult = await context.CallActivityAsync<bool>(
                "ProcessPayment", order);
            
            if (!paymentResult)
            {
                return "결제 실패";
            }
            
            // 병렬 실행 (팬아웃)
            var parallelTasks = new List<Task>
            {
                context.CallActivityAsync("SendConfirmationEmail", order),
                context.CallActivityAsync("UpdateInventory", order),
                context.CallActivityAsync("NotifyWarehouse", order)
            };
            
            await Task.WhenAll(parallelTasks);
            
            return $"주문 {order.OrderId} 처리 완료!";
        }

        // 3. 활동 함수들 — 실제 작업 수행
        [Function("ProcessPayment")]
        public static async Task<bool> ProcessPayment(
            [ActivityTrigger] OrderData order,
            FunctionContext executionContext)
        {
            var logger = executionContext.GetLogger("ProcessPayment");
            logger.LogInformation($"결제 처리: {order.OrderId}, 금액: {order.Amount:C}");
            
            // 실제 결제 처리 로직
            await Task.Delay(1000); // 시뮬레이션
            return true;
        }

        [Function("SendConfirmationEmail")]
        public static async Task SendConfirmationEmail(
            [ActivityTrigger] OrderData order,
            FunctionContext executionContext)
        {
            var logger = executionContext.GetLogger("SendConfirmationEmail");
            logger.LogInformation($"확인 이메일 발송: {order.CustomerEmail}");
            await Task.Delay(500);
        }
    }
    
    public record OrderData(
        string OrderId,
        string CustomerEmail,
        decimal Amount
    );
}

dotnet add package Microsoft.Azure.Functions.Worker.Extensions.DurableTask

Isolated Worker 모델의 또 다른 강점! ASP.NET Core처럼 미들웨어를 사용할 수 있어.
인증, 로깅, 예외 처리 같은 공통 로직을 미들웨어로 분리하면 코드가 훨씬 깔끔해져:

using Microsoft.Azure.Functions.Worker;
using Microsoft.Azure.Functions.Worker.Http;
using Microsoft.Azure.Functions.Worker.Middleware;
using Microsoft.Extensions.Logging;
using System.Net;
using System.Text.Json;

namespace MyFirstFunctionApp.Middleware
{
    public class ExceptionHandlingMiddleware : IFunctionsWorkerMiddleware
    {
        private readonly ILogger<ExceptionHandlingMiddleware> _logger;

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

        public async Task Invoke(FunctionContext context, FunctionExecutionDelegate next)
        {
            try
            {
                await next(context);
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "처리되지 않은 예외 발생: {FunctionName}", 
                    context.FunctionDefinition.Name);
                
                // HTTP 트리거인 경우 에러 응답 반환
                var httpReqData = await context.GetHttpRequestDataAsync();
                if (httpReqData is not null)
                {
                    var response = httpReqData.CreateResponse(HttpStatusCode.InternalServerError);
                    response.Headers.Add("Content-Type", "application/json");
                    
                    var errorResponse = new
                    {
                        error = "서버 내부 오류가 발생했습니다.",
                        traceId = context.InvocationId
                    };
                    
                    await response.WriteStringAsync(
                        JsonSerializer.Serialize(errorResponse));
                    
                    context.GetInvocationResult().Value = response;
                }
            }
        }
    }
}

var host = new HostBuilder()
    .ConfigureFunctionsWorkerDefaults(workerApp =>
    {
        // 미들웨어 등록 — 순서가 중요해!
        workerApp.UseMiddleware<ExceptionHandlingMiddleware>();
        // workerApp.UseMiddleware<AuthenticationMiddleware>();
        // workerApp.UseMiddleware<RequestLoggingMiddleware>();
    })
    .ConfigureServices(services =>
    {
        services.AddScoped<ExceptionHandlingMiddleware>();
    })
    .Build();

host.Run();

하나의 함수에서 여러 서비스에 동시에 데이터를 출력할 수 있어.
이걸 출력 바인딩(Output Binding)이라고 해:

using Microsoft.Azure.Functions.Worker;
using Microsoft.Azure.Functions.Worker.Http;
using System.Net;

namespace MyFirstFunctionApp
{
    public class MultiOutputFunction
    {
        [Function("MultiOutput")]
        public static async Task<MultiOutputResult> Run(
            [HttpTrigger(AuthorizationLevel.Anonymous, "post")] 
            HttpRequestData req)
        {
            var order = await req.ReadFromJsonAsync<OrderData>();
            
            var response = req.CreateResponse(HttpStatusCode.OK);
            await response.WriteStringAsync("주문이 접수되었습니다!");
            
            return new MultiOutputResult
            {
                // HTTP 응답
                HttpResponse = response,
                // Queue에 메시지 추가
                QueueMessage = $"{{\"orderId\":\"{order?.OrderId}\"}}",
                // Cosmos DB에 저장
                CosmosDocument = new OrderDocument 
                { 
                    Id = order?.OrderId ?? Guid.NewGuid().ToString(),
                    OrderData = order,
                    CreatedAt = DateTime.UtcNow
                }
            };
        }
    }
    
    // 출력 바인딩을 담는 클래스
    public class MultiOutputResult
    {
        [HttpResult]
        public HttpResponseData? HttpResponse { get; set; }
        
        [QueueOutput("orders-queue", Connection = "AzureWebJobsStorage")]
        public string? QueueMessage { get; set; }
        
        [CosmosDBOutput("MyDatabase", "Orders", Connection = "CosmosDBConnection")]
        public OrderDocument? CosmosDocument { get; set; }
    }
    
    public class OrderDocument
    {
        public string Id { get; set; } = string.Empty;
        public OrderData? OrderData { get; set; }
        public DateTime CreatedAt { get; set; }
    }
}

로컬에서 잘 돌아가는 걸 확인했으면 이제 Azure에 배포할 차례야!
여러 가지 방법이 있는데, 가장 많이 쓰는 방법들을 알아보자.

# Azure 로그인
az login

# 리소스 그룹 생성
az group create --name MyFunctionRG --location koreacentral

# 스토리지 계정 생성 (Functions에 필요)
az storage account create \
  --name myfunctionstorage2024 \
  --location koreacentral \
  --resource-group MyFunctionRG \
  --sku Standard_LRS

# Function App 생성
az functionapp create \
  --resource-group MyFunctionRG \
  --consumption-plan-location koreacentral \
  --runtime dotnet-isolated \
  --runtime-version 8 \
  --functions-version 4 \
  --name MyFirstFunctionApp2024 \
  --storage-account myfunctionstorage2024

# 코드 배포
func azure functionapp publish MyFirstFunctionApp2024

실무에서 가장 많이 쓰는 방법이야. 코드를 푸시하면 자동으로 배포돼:

name: Azure Functions 배포

on:
  push:
    branches: [ main ]
  pull_request:
    branches: [ main ]

env:
  AZURE_FUNCTIONAPP_NAME: 'MyFirstFunctionApp2024'
  AZURE_FUNCTIONAPP_PACKAGE_PATH: '.'
  DOTNET_VERSION: '8.0.x'

jobs:
  build-and-deploy:
    runs-on: ubuntu-latest
    
    steps:
    - name: 코드 체크아웃
      uses: actions/checkout@v4

    - name: .NET 설정
      uses: actions/setup-dotnet@v4
      with:
        dotnet-version: ${{ env.DOTNET_VERSION }}

    - name: 의존성 복원
      run: dotnet restore

    - name: 빌드
      run: dotnet build --configuration Release --no-restore

    - name: 테스트 실행
      run: dotnet test --no-restore --verbosity normal

    - name: 배포 패키지 생성
      run: dotnet publish --configuration Release --output ./output

    - name: Azure Functions 배포
      uses: Azure/functions-action@v1
      with:
        app-name: ${{ env.AZURE_FUNCTIONAPP_NAME }}
        package: './output'
        publish-profile: ${{ secrets.AZURE_FUNCTIONAPP_PUBLISH_PROFILE }}

Azure Functions는 세 가지 호스팅 플랜을 제공해. 상황에 맞게 선택해야 해: