Azure İşlevleri Node.js geliştirici referansı

Bu referans, JavaScript ve TypeScript kullanarak @azure/functions npm paketiyle Azure İşlevleri'ın nasıl geliştirileceğini kapsar. Tüm dillerde paylaşılan Azure İşlevleri kavramlarının genel bir özeti için Azure İşlevleri geliştirici referansına bakınız.

Resource	Link
İlk JavaScript fonksiyonunuzu oluşturun	Visual Studio Code/CLI
İlk TypeScript fonksiyonunuzu oluşturun	Visual Studio Code/CLI
Senaryolar ve örnekler	JavaScript/TypeScript
API referansı	@azure/functions API

Not

Bu makale, sayfanın üstündeki seçici temelinde belirli bir programlama modeli versiyonu için içerik göstermektedir. Seçtiğiniz sürüm, npm paket versiyonunuzla @azure/functions uyumlu olmalı. V3 ve v4 fonksiyonlarını aynı uygulamada karıştıramazsınız. Paket package.json içinde yoksa, varsayılan sürüm v3'tür.

Programlama modeli

Azure İşlevleri for Node.js iki programlama modeli versiyonunu destekler. Yeni projeler v4 kullanmalı.

Özellik	v4 (önerilir)	v3
Durum	Georgia	GA (bakım)
@azure/functions Paket	4.x	3.x
İşlev kaydı	Kod merkezli (app.http(), app.timer())	Dosya tabanlı (function.json)
Dosya yapısı	Esnek	Düzeltildi (her fonksiyon için bir klasör)
İşlevler çalışma zamanı sürümü	4.25+	4.x
Node.js sürümleri	24.x, 22.x	24.x, 22.x

Node.js v4 programlama modelinde, @azure/functions içinden app nesnesini içe aktararak ve tetikleyiciye özgü yöntemleri çağırarak işlevleri kaydedersiniz. Fonksiyonlar doğrudan kodunuzda esnek bir dosya yapısı ile tanımlanır. Her fonksiyonun yürütülmesini başlatan tek bir tetikleyicisi vardır ve ayrıca girdi verilerini okumak veya çıktı verilerini yazmak için diğer hizmetlere yönelik bildirimsel bağlantılar olan bağlamalara da sahip olabilir. Daha fazla bilgi için Tetikleyiciler ve bağlamalar bölümüne bakınız.

V4 modelinde, siz:

• app.http(), app.timer() ve app.storageQueue() gibi tetikleyiciye özgü yöntemleri kullanarak işlevleri kaydedin.
• Tetikleyici girdisine ilk argüman olarak erişin (örneğin, HttpRequest).
• Birincil çıktıyı doğrudan handler fonksiyonundan geri döndür.
• Ek giriş bağlamalarından Blob Depolama gibi veri okumak için context.extraInputs.get() kullanın.
• context.extraOutputs.set(), kuyruklar gibi ek çıkış bağlamalarına yazmak için kullanın.
• Her fonksiyonun tam olarak bir tetikleyicisi vardır, ancak birden fazla ek giriş ve çıkış olabilir.
• Verileri, çağrılar arasında yeniden kullanmak üzere küresel değişkenlerde önbelleğe alabilirsiniz, ancak bu durumun kalıcı olacağına güvenmeyin. Çalışma süresi çalışanınızı istediğiniz zaman geri dönüştürebilir.

Node.js v3 programlama modelinde, her fonksiyonu bir function.json yapılandırma dosyası ve ilgili JavaScript veya TypeScript kodu kullanarak tanımlarsınız. Fonksiyonları belirli dosya yapılarıyla ayrı klasörlerde düzenliyorsunuz. Her işlevin yürütülmesini başlatan tek bir tetikleyicisi vardır ve ayrıca, girdi verilerini okumak veya çıktı verilerini yazmak için diğer hizmetlere yönelik bildirim temelli bağlantılar olan bağlamalara da sahip olabilir. Daha fazla bilgi için Tetikleyiciler ve bağlamalar bölümüne bakınız.

V3 modelinde siz:

• Bir function.json dosyada tetikleyicileri ve bağlayıcıları tanımlayın. Girişler için direction: "in", çıkışlar için direction: "out" kullanın.
• Tetikleyici girdisine işleyicinizin ikinci argümanı olarak erişin veya bunu context.bindings içinden okuyun.
• context.bindings değer atayarak çıktıları ayarlayın (örneğin, context.bindings.outputQueue). HTTP için context.res kullanın.
• TypeScript projeleri, derlenmiş JavaScript dosyasına işaret eden bir scriptFile özellik gerektirir function.json .
• Her fonksiyonun tam olarak bir tetikleyicisi vardır, ancak birden fazla giriş ve çıkış bağlaması olabilir.
• Verileri, çağrılar arasında yeniden kullanmak üzere küresel değişkenlerde önbelleğe alabilirsiniz, ancak bu durumun kalıcı olacağına güvenmeyin. Çalışma süresi çalışanınızı istediğiniz zaman geri dönüştürebilir.

Examples

Http isteğine yanıt veren basit bir işlev aşağıdadır:

JavaScript

const { app } = require('@azure/functions');

app.http('httpTrigger', {
    methods: ['GET', 'POST'],
    authLevel: 'anonymous',
    handler: async (request, context) => {
        const name = request.query.get('name') || 'World';
        context.log('HTTP trigger function processed a request.');

        return { body: `Hello, ${name}!` };
    }
});

TypeScript

import { app, HttpRequest, HttpResponseInit, InvocationContext } from '@azure/functions';

export async function httpTrigger(request: HttpRequest, context: InvocationContext): Promise<HttpResponseInit> {
    const name = request.query.get('name') || 'World';
    context.log('HTTP trigger function processed a request.');

    return { body: `Hello, ${name}!` };
}

app.http('httpTrigger', {
    methods: ['GET', 'POST'],
    authLevel: 'anonymous',
    handler: httpTrigger
});

Aşağıdaki HTTP dışı örnek zamanlayıcı tetikleyici kullanır:

JavaScript

const { app } = require('@azure/functions');

app.timer('cleanupTimer', {
  schedule: '0 */5 * * * *',
  handler: async (myTimer, context) => {
    context.log('Timer trigger function ran at', new Date().toISOString());
  }
});

TypeScript

import { app, InvocationContext, Timer } from '@azure/functions';

export async function cleanupTimer(myTimer: Timer, context: InvocationContext): Promise<void> {
  context.log('Timer trigger function ran at', new Date().toISOString());
}

app.timer('cleanupTimer', {
  schedule: '0 */5 * * * *',
  handler: cleanupTimer
});

Aşağıdaki örnek, kuyruk çıkış bağlamasına sahip bir HTTP tetikleyicisini gösterir:

JavaScript

const { app, output } = require('@azure/functions');

const queueOutput = output.storageQueue({
  queueName: 'work-items',
  connection: 'AzureWebJobsStorage'
});

app.http('submitWorkItem', {
  methods: ['POST'],
  extraOutputs: [queueOutput],
  handler: async (request, context) => {
    const body = await request.json();
    context.extraOutputs.set(queueOutput, JSON.stringify(body));
    return { status: 202, jsonBody: { accepted: true } };
  }
});

TypeScript

import { app, HttpRequest, HttpResponseInit, InvocationContext, output } from '@azure/functions';

const queueOutput = output.storageQueue({
  queueName: 'work-items',
  connection: 'AzureWebJobsStorage'
});

export async function submitWorkItem(request: HttpRequest, context: InvocationContext): Promise<HttpResponseInit> {
  const body = await request.json();
  context.extraOutputs.set(queueOutput, JSON.stringify(body));
  return { status: 202, jsonBody: { accepted: true } };
}

app.http('submitWorkItem', {
  methods: ['POST'],
  extraOutputs: [queueOutput],
  handler: submitWorkItem
});

Http isteğine yanıt veren basit bir işlev aşağıdadır:

JavaScript

{
  "bindings": [
    {
      "authLevel": "anonymous",
      "type": "httpTrigger",
      "direction": "in",
      "name": "req",
      "methods": ["get", "post"]
    },
    {
      "type": "http",
      "direction": "out",
      "name": "res"
    }
  ]
}

module.exports = async function (context, req) {
    const name = (req.query.name || (req.body && req.body.name)) || 'World';
    context.log('HTTP trigger function processed a request.');

    context.res = {
        body: `Hello, ${name}!`
    };
};

TypeScript

{
  "bindings": [
    {
      "authLevel": "anonymous",
      "type": "httpTrigger",
      "direction": "in",
      "name": "req",
      "methods": ["get", "post"]
    },
    {
      "type": "http",
      "direction": "out",
      "name": "res"
    }
  ],
  "scriptFile": "../dist/HttpTrigger1/index.js"
}

import { AzureFunction, Context, HttpRequest } from "@azure/functions";

const httpTrigger: AzureFunction = async function (context: Context, req: HttpRequest): Promise<void> {
    const name = (req.query.name || (req.body && req.body.name)) || 'World';
    context.log('HTTP trigger function processed a request.');

    context.res = {
        body: `Hello, ${name}!`
    };
};

export default httpTrigger;

Aşağıdaki HTTP dışı örnek zamanlayıcı tetikleyici kullanır:

JavaScript

{
  "bindings": [
    {
      "name": "myTimer",
      "type": "timerTrigger",
      "direction": "in",
      "schedule": "0 */5 * * * *"
    }
  ]
}

module.exports = async function (context, myTimer) {
    context.log('Timer trigger function ran at', new Date().toISOString());
};

TypeScript

{
  "bindings": [
    {
      "name": "myTimer",
      "type": "timerTrigger",
      "direction": "in",
      "schedule": "0 */5 * * * *"
    }
  ],
  "scriptFile": "../dist/TimerTrigger/index.js"
}

import { AzureFunction, Context } from '@azure/functions';

const timerTrigger: AzureFunction = async function (context: Context, myTimer: unknown): Promise<void> {
    context.log('Timer trigger function ran at', new Date().toISOString());
};

export default timerTrigger;

Aşağıdaki örnek, kuyruk çıkış bağlamasına sahip bir HTTP tetikleyicisini gösterir:

JavaScript

{
  "bindings": [
    {
      "authLevel": "function",
      "type": "httpTrigger",
      "direction": "in",
      "name": "req",
      "methods": ["post"]
    },
    {
      "type": "queue",
      "direction": "out",
      "name": "workItems",
      "queueName": "work-items",
      "connection": "AzureWebJobsStorage"
    },
    {
      "type": "http",
      "direction": "out",
      "name": "res"
    }
  ]
}

module.exports = async function (context, req) {
    const payload = req.body || {};
    context.bindings.workItems = JSON.stringify(payload);
    context.res = {
        status: 202,
        body: { accepted: true }
    };
};

TypeScript

{
  "bindings": [
    {
      "authLevel": "function",
      "type": "httpTrigger",
      "direction": "in",
      "name": "req",
      "methods": ["post"]
    },
    {
      "type": "queue",
      "direction": "out",
      "name": "workItems",
      "queueName": "work-items",
      "connection": "AzureWebJobsStorage"
    },
    {
      "type": "http",
      "direction": "out",
      "name": "res"
    }
  ],
  "scriptFile": "../dist/HttpTrigger/index.js"
}

import { AzureFunction, Context, HttpRequest } from '@azure/functions';

const httpTrigger: AzureFunction = async function (context: Context, req: HttpRequest): Promise<void> {
    const payload = req.body || {};
    context.bindings.workItems = JSON.stringify(payload);
    context.res = {
        status: 202,
        body: { accepted: true }
    };
};

export default httpTrigger;

İşlev uygulamanızı oluşturma

Bu bölüm, Node fonksiyon uygulamanızı @azure/functionsoluşturmak ve yapılandırmak için kütüphane, proje yapısı ve paket yönetimi gibi temel bileşenleri kapsar.

Kitaplık @azure/functions

TypeScript/JavaScript kütüphanesi, @azure/functions Azure İşlevleri çalışma zamanıyla etkileşim kurmak için kullandığınız temel türleri ve fonksiyonları sağlar. Kullanılabilir tüm türleri ve yöntemleri görmek için API'yi ziyaret edin@azure/functions.

İşlev kodunuz şunu yapmak için kullanabilir @azure/functions :

• Fonksiyonları kaydet ve tetikleyicileri tanımlayacak (v4 modeli).
• Güçlü tipli tetikleyici giriş verilerine erişin (örneğin, HttpRequest, Timer).
• Tiplenmiş çıktı değerleri oluşturun (örneğin HttpResponseInit).
• Çalışma zamanında sağlanan bağlam ve bağlama verileriyle etkileşime girin.

Uygulamanızda kullanıyorsanız @azure/functions , proje bağımlılıklarınıza dahil edin:

{
  "dependencies": {
    "@azure/functions": "^4.0.0"
  }
}

Not

Kütüphane @azure/functions Node.js Azure İşlevleri için programlama yüzeyini tanımlar, ancak bu genel amaçlı bir SDK değildir. Özellikle Azure İşlevleri çalışma zamanı içinde işlevleri yazmak ve çalıştırmak için kullanın.

TypeScript yapılandırması

En iyi TypeScript geliştirme deneyimi için, doğru yapılandırmayı dahil ettiğinizden emin tsconfig.json olun:

{
  "compilerOptions": {
    "module": "commonjs",
    "target": "es6",
    "outDir": "dist",
    "rootDir": ".",
    "sourceMap": true,
    "strict": false,
    "esModuleInterop": true,
    "skipLibCheck": true,
    "forceConsistentCasingInFileNames": true
  }
}

Klasör yapısı

JavaScript

Bir JavaScript projesi, aşağıdaki örnekte gösterilen klasör yapısını gerektirir:

<project_root>/
 | - .vscode/
 | - node_modules/
 | - myFirstFunction/
 | | - index.js
 | | - function.json
 | - mySecondFunction/
 | | - index.js
 | | - function.json
 | - .funcignore
 | - host.json
 | - local.settings.json
 | - package.json

<project_root> ana proje klasörü aşağıdaki dosyaları içerebilir:

• .vscode/: (İsteğe bağlı) Depolanan Visual Studio Code yapılandırmasını içerir. Daha fazla bilgi için bkz. Visual Studio Code settings.
• myFirstFunction/function.json: İşlevin tetikleyicisi, girişleri ve çıkışları için yapılandırmayı içerir. dizininin adı işlevinizin adını belirler.
• myFirstFunction/index.js: İşlev kodunuzu depolar. Bu varsayılan dosya yolunu değiştirmek için scriptFile kullanma konusuna bakınız.
• .funcignore: (İsteğe bağlı) Azure yayımlanmaması gereken dosyaları bildirir. Genellikle bu dosya, düzenleyici ayarlarınızı yok saymak için .vscode/, test durumlarını yok saymak için test/ ve yerel uygulama ayarlarının yayımlanmasını önlemek için local.settings.json içerir.
• host.json: İşlev uygulaması örneğindeki tüm işlevleri etkileyen yapılandırma seçeneklerini içerir. Bu dosya Azure'da yayınlanıyor. Yerel olarak çalıştırılırken tüm seçenekler desteklenmez. Daha fazla bilgi edinmek için bkz . host.json.
• local.settings.json: Yerel olarak çalışırken uygulama ayarlarını ve bağlantı dizesi depolamak için kullanılır. Bu dosya Azure yayımlanmaz. Daha fazla bilgi için bkz . local.settings.file.
• package.json: Paket bağımlılıkları listesi, ana giriş noktası ve betikler gibi yapılandırma seçenekleri içerir.

TypeScript

Bir TypeScript projesi aşağıdaki klasör yapısını gerektirir:

<project_root>/
 | - .vscode/
 | - dist/
 | - node_modules/
 | - myFirstFunction/
 | | - index.ts
 | | - function.json
 | - mySecondFunction/
 | | - index.ts
 | | - function.json
 | - .funcignore
 | - host.json
 | - local.settings.json
 | - package.json
 | - tsconfig.json

<project_root> ana proje klasörü aşağıdaki dosyaları içerebilir:

• .vscode/: (İsteğe bağlı) Depolanan Visual Studio Code yapılandırmasını içerir. Daha fazla bilgi için bkz. Visual Studio Code settings.
• dist/: Derlemeyi çalıştırdıktan sonra derlenmiş JavaScript kodunu içerir. Bu klasörün adını "tsconfig.json" dosyanızda ayarlayabilirsiniz. "function.json" dosyalarınızdaki scriptFile özelliğiyle eşleşmelidir.
• myFirstFunction/function.json: İşlevin tetikleyicisi, girişleri ve çıkışları için yapılandırmayı içerir. dizininin adı işlevinizin adını belirler. TypeScript projeleri için, bu dosya derlenmiş JavaScript'inize işaret eden bir scriptFile özellik içermelidir.
• myFirstFunction/index.ts: İşlev kodunuzu depolar. Bu varsayılan dosya yolunu değiştirmek için scriptFile kullanma konusuna bakınız.
• .funcignore: (İsteğe bağlı) Azure yayımlanmaması gereken dosyaları bildirir. Genellikle bu dosya, editör ayarlarınızı hariç tutmak için .vscode/, test durumlarını hariç tutmak için test/ ve yerel uygulama ayarlarının yayımlanmasını önlemek için local.settings.json içerir.
• host.json: İşlev uygulaması örneğindeki tüm işlevleri etkileyen yapılandırma seçeneklerini içerir. Bu dosya Azure'da yayınlanıyor. Yerel olarak çalıştırılırken tüm seçenekler desteklenmez. Daha fazla bilgi edinmek için bkz . host.json.
• local.settings.json: Yerel olarak çalışırken uygulama ayarlarını ve bağlantı dizesi depolamak için kullanılır. Bu dosya Azure yayımlanmaz. Daha fazla bilgi için bkz . local.settings.file.
• package.json: Paket bağımlılıkları listesi, ana giriş noktası ve betikler gibi yapılandırma seçenekleri içerir.
• tsconfig.json: Çıkış dizini gibi TypeScript derleyici seçeneklerini içerir.

JavaScript

Bir JavaScript projesi, aşağıdaki örnekte önerilen klasör yapısını takip eder:

<project_root>/
 | - .vscode/
 | - node_modules/
 | - src/
 | | - functions/
 | | | - myFirstFunction.js
 | | | - mySecondFunction.js
 | - test/
 | | - functions/
 | | | - myFirstFunction.test.js
 | | | - mySecondFunction.test.js
 | - .funcignore
 | - host.json
 | - local.settings.json
 | - package.json

<project_root> ana proje klasörü aşağıdaki dosyaları içerebilir:

• .vscode/: (İsteğe bağlı) Depolanan Visual Studio Code yapılandırmasını içerir. Daha fazla bilgi için bkz. Visual Studio Code settings.
• src/functions/: Tüm işlevler ve bunların ilgili tetikleyicileri ve bağlamaları için varsayılan konum.
• test/: (İsteğe bağlı) İşlev uygulamanızın test çalışmalarını içerir.
• .funcignore: (İsteğe bağlı) Azure yayımlanmaması gereken dosyaları bildirir. Genellikle bu dosya, düzenleyici ayarlarınızı yok saymak için .vscode/, test durumlarını yok saymak için test/ ve yerel uygulama ayarlarının yayımlanmasını önlemek için local.settings.json içerir.
• host.json: İşlev uygulaması örneğindeki tüm işlevleri etkileyen yapılandırma seçeneklerini içerir. Bu dosya Azure'da yayınlanıyor. Yerel olarak çalıştırılırken tüm seçenekler desteklenmez. Daha fazla bilgi edinmek için bkz . host.json.
• local.settings.json: Yerel olarak çalışırken uygulama ayarlarını ve bağlantı dizesi depolamak için kullanılır. Bu dosya Azure yayımlanmaz. Daha fazla bilgi için bkz . local.settings.file.
• package.json: Paket bağımlılıkları listesi, ana giriş noktası ve betikler gibi yapılandırma seçenekleri içerir.

TypeScript

Bir TypeScript projesi, aşağıdaki örnekte önerilen klasör yapısını takip eder:

<project_root>/
 | - .vscode/
 | - dist/
 | - node_modules/
 | - src/
 | | - functions/
 | | | - myFirstFunction.ts
 | | | - mySecondFunction.ts
 | - test/
 | | - functions/
 | | | - myFirstFunction.test.ts
 | | | - mySecondFunction.test.ts
 | - .funcignore
 | - host.json
 | - local.settings.json
 | - package.json
 | - tsconfig.json

<project_root> ana proje klasörü aşağıdaki dosyaları içerebilir:

• .vscode/: (İsteğe bağlı) Depolanan Visual Studio Code yapılandırmasını içerir. Daha fazla bilgi için bkz. Visual Studio Code settings.
• dist/: Derlemeyi çalıştırdıktan sonra derlenmiş JavaScript kodunu içerir. Bu klasörün adını "tsconfig.json" dosyanızda ayarlayabilirsiniz.
• src/functions/: Tüm işlevler ve bunların ilgili tetikleyicileri ve bağlamaları için varsayılan konum.
• test/: (İsteğe bağlı) İşlev uygulamanızın test çalışmalarını içerir.
• .funcignore: (İsteğe bağlı) Azure yayımlanmaması gereken dosyaları bildirir. Genellikle bu dosya, düzenleyici ayarlarınızı yok saymak için .vscode/, test durumlarını yok saymak için test/ ve yerel uygulama ayarlarının yayımlanmasını önlemek için local.settings.json içerir.
• host.json: İşlev uygulaması örneğindeki tüm işlevleri etkileyen yapılandırma seçeneklerini içerir. Bu dosya Azure'da yayınlanıyor. Yerel olarak çalıştırılırken tüm seçenekler desteklenmez. Daha fazla bilgi edinmek için bkz . host.json.
• local.settings.json: Yerel olarak çalışırken uygulama ayarlarını ve bağlantı dizesi depolamak için kullanılır. Bu dosya Azure yayımlanmaz. Daha fazla bilgi için bkz . local.settings.file.
• package.json: Paket bağımlılıkları listesi, ana giriş noktası ve betikler gibi yapılandırma seçenekleri içerir.
• tsconfig.json: Çıkış dizini gibi TypeScript derleyici seçeneklerini içerir.

Paket yönetimi

Etkili paket yönetimi Node.js Azure İşlevleri projeleri için çok önemlidir. Bu bölüm, bağımlılık yönetimi, paket yapılandırması ve fonksiyon uygulaması bağımlılıklarınızı sürdürmek için en iyi uygulamaları ele alır.

Bağımlılıkları yönetmek

Tüm Node.js Azure İşlevleri projeleri paket yönetimi için npm kullanır. Dosyanız package.json , fonksiyonlarınızı oluşturmak ve çalıştırmak için gereken proje yapılandırmasını, bağımlılıkları ve betikleri tanımlar.

Temel package.json yapısı:

{
  "name": "my-functions-app",
  "version": "1.0.0",
  "description": "Azure Functions Node.js app",
  "main": "src/index.js",
  "scripts": {
    "build": "tsc",
    "watch": "tsc -w",
    "prestart": "npm run build",
    "start": "func start",
    "test": "jest"
  },
  "dependencies": {
    "@azure/functions": "^4.0.0"
  },
  "devDependencies": {
    "@azure/functions-core-tools": "^4.0.4670",
    "@types/node": "^18.0.0",
    "typescript": "^4.0.0",
    "jest": "^29.0.0"
  }
}

Çalışma zamanı ve geliştirme bağımlılıkları

Bağımlılıklarınızı uygun şekilde ayırın:

Çalışma zamanı bağımlılıkları (dependencies):

• @azure/functions: Çekirdek Azure İşlevleri kütüphanesi
• İş mantığı kütüphaneleri (lodash, axios ve benzeri paketler)
• Veritabanı sürücüleri (mongodb, mssql ve benzeri paketler)
• Azure SDK paketleri (@azure/storage-blob, @azure/cosmosve benzeri paketler)

Geliştirme bağımlılıkları (devDependencies):

• TypeScript derleyicisi ve tür tanımları
• Çerçeveleri test etmek (Jest, Mocha)
• Aletler ve astarlar yap
• Azure İşlevleri Core Tools (yerel geliştirme için)

TypeScript'e özgü paketler

TypeScript projeleri için şu temel geliştirme bağımlılıklarını ekleyin:

{
  "devDependencies": {
    "@types/node": "^18.0.0",
    "typescript": "^4.0.0",
    "@typescript-eslint/eslint-plugin": "^5.0.0",
    "@typescript-eslint/parser": "^5.0.0"
  }
}

Güvenlik ve güncellemeler

Güvenlik açıklarını gidermek için bağımlılıklarınızı düzenli olarak güncelleyin:

# Check for outdated packages
npm outdated

# Update packages
npm update

# Audit for security issues
npm audit
npm audit fix

Çalıştırma ve hata ayıklama

Bu bölüm yerel geliştirme, hata ayıklama teknikleri ve Node.js Azure İşlevleri için test stratejilerini kapsar.

Yerel geliştirme kurulumu

Ön koşullar:

• Node.js 18.x veya 20.x sürümleri
• Azure İşlevleri Core Tools v4.x
• Azure CLI (isteğe bağlı)

Kurulum adımları:

1. Bağımlılıkları yükleme:

   npm install
   

2. TypeScript projeleri oluşturun:

   npm run build
   

3. Yerel çalışma süresini başlatın:

   npm start
   # or directly:
   func start
   

Ortam ayarları

Yerel geliştirme ortamınızı local.settings.json kullanarak yapılandırın:

{
  "IsEncrypted": false,
  "Values": {
    "AzureWebJobsStorage": "UseDevelopmentStorage=true",
    "FUNCTIONS_WORKER_RUNTIME": "node",
    "NODE_ENV": "development",
    "CUSTOM_ENV_VARIABLE": "local-value"
  },
  "Host": {
    "LocalHttpPort": 7071,
    "CORS": "*",
    "CORSCredentials": false
  }
}

Debugging

Visual Studio Code hata ayıklama:

Oluştur .vscode/launch.json:

{
  "version": "0.2.0",
  "configurations": [
    {
      "name": "Attach to Node Functions",
      "type": "node",
      "request": "attach",
      "port": 9229,
      "preLaunchTask": "func: host start"
    }
  ]
}

Oluştur .vscode/tasks.json:

{
  "version": "2.0.0",
  "tasks": [
    {
      "type": "func",
      "label": "func: host start",
      "command": "host start",
      "problemMatcher": "$func-node-watch",
      "isBackground": true,
      "options": {
        "cwd": "${workspaceFolder}"
      }
    }
  ]
}

Komut satırı hata ayıklaması:

# Start with debugging enabled
func start --p <port>

# For TypeScript, ensure you build first
npm run build
func start --p 9229

Deployment

Bu bölüm, Node.js Azure İşlevleri için dağıtım stratejileri, CI/CD entegrasyonu ve üretim en iyi uygulamalarını kapsar.

Dağıtım yöntemleri

1. Visual Studio Code dağıtımı:

• Azure İşlevleri uzantını kurun.
• Azure panelinde fonksiyon uygulamanıza sağ tıklayın.
• Fonksiyon Uygulamasına Dağıt seçeneğini seç.

2. Azure İşlevleri Core Tools:

# Deploy to Azure
func azure functionapp publish <FunctionAppName>

# Deploy with custom settings
func azure functionapp publish <FunctionAppName> --build local --publish-local-settings

3. Azure CLI dağıtımı:

# Deploy from local folder
az functionapp deployment source config-zip \
  --resource-group <ResourceGroupName> \
  --name <FunctionAppName> \
  --src <PathToZipFile>

Üretim yapılandırması

Azure'da uygulama ayarları:

Üretim için ortam değişkenlerini yapılandırmak:

• WEBSITE_NODE_DEFAULT_VERSION: ~18 veya ~20olarak ayarlayın.
• FUNCTIONS_WORKER_RUNTIME: node olarak ayarlayın.
• Bağlantı dizileri ve API anahtarları güvenli uygulama ayarları olarak kullanılıyor.
• NODE_ENV: production olarak ayarlayın.

Tetikleyiciler ve bağlamalar

Azure İşlevleri, işlevi yürütmeyi başlatmak için tetikleyicileri ve kodunuzu depolama, kuyruklar ve veritabanları gibi diğer hizmetlere bağlamak için bağlamaları kullanır. Node.js programlama modelinde, bağlamaları model sürümüne göre farklı şekilde ilan edersiniz.

İki ana bağlama türü vardır:

• Tetikleyiciler (işlevi başlatan giriş)
• Girişler ve çıkışlar (ek veri kaynakları veya hedefler)

Kullanılabilir tetikleyiciler ve bağlamalar hakkında daha fazla bilgi için bkz. Azure İşlevleri'nde Tetikleyiciler ve Bağlamalar.

Örnek: Blob Girişi ile Zamanlayıcı Tetikleyicisi

Bu fonksiyon her 10 dakikada bir tetiklenir, ek girdiler kullanarak bir Blob'dan okur ve blob içeriğini kaydeder.

JavaScript

const { app, input } = require('@azure/functions');

let CACHED_BLOB_DATA = null;

const blobInput = input.storageBlob({
    connection: 'BLOB_CONNECTION_SETTING',
    path: 'mycontainer/myblob.txt'
});

app.timer('TimerTriggerWithBlob', {
    schedule: '0 */10 * * * *',
    extraInputs: [blobInput],
    handler: async (myTimer, context) => {
        if (CACHED_BLOB_DATA === null) {
            // Read blob content and cache it
            CACHED_BLOB_DATA = context.extraInputs.get(blobInput);
            context.log(`Blob content cached: ${CACHED_BLOB_DATA?.substring(0, 100)}...`);
        }

        context.log(`Timer function executed at: ${new Date().toISOString()}`);
        context.log(`Using cached data of length: ${CACHED_BLOB_DATA?.length || 0}`);
    }
});

TypeScript

import { app, InvocationContext, Timer, input } from '@azure/functions';

let CACHED_BLOB_DATA: string | null = null;

const blobInput = input.storageBlob({
    connection: 'BLOB_CONNECTION_SETTING',
    path: 'mycontainer/myblob.txt'
});

async function timerTriggerWithBlob(myTimer: Timer, context: InvocationContext): Promise<void> {
    if (CACHED_BLOB_DATA === null) {
        // Read blob content and cache it
        CACHED_BLOB_DATA = context.extraInputs.get(blobInput) as string;
        context.log(`Blob content cached: ${CACHED_BLOB_DATA?.substring(0, 100)}...`);
    }

    context.log(`Timer function executed at: ${new Date().toISOString()}`);
    context.log(`Using cached data of length: ${CACHED_BLOB_DATA?.length || 0}`);
}

app.timer('TimerTriggerWithBlob', {
    schedule: '0 */10 * * * *',
    extraInputs: [blobInput],
    handler: timerTriggerWithBlob
});

Bu fonksiyon her 10 dakikada bir tetiklenir, bir Blob'dan bindings yapılandırmasını kullanarak okur ve blob içeriğini kaydeder.

JavaScript

{
  "scriptFile": "index.js",
  "bindings": [
    {
      "name": "myTimer",
      "type": "timerTrigger",
      "direction": "in",
      "schedule": "0 */10 * * * *"
    },
    {
      "name": "blobInput",
      "type": "blob",
      "direction": "in",
      "path": "mycontainer/myblob.txt",
      "connection": "AzureWebJobsStorage"
    }
  ]
}

let CACHED_BLOB_DATA = null;

module.exports = async function (context, myTimer) {
    if (CACHED_BLOB_DATA === null) {
        // Read blob content and cache it
        CACHED_BLOB_DATA = context.bindings.blobInput;
        context.log(`Blob content cached: ${CACHED_BLOB_DATA?.substring(0, 100)}...`);
    }

    context.log(`Timer function executed at: ${new Date().toISOString()}`);
    context.log(`Using cached data of length: ${CACHED_BLOB_DATA?.length || 0}`);
};

TypeScript

{
  "scriptFile": "../dist/TimerTriggerWithBlob/index.js",
  "bindings": [
    {
      "name": "myTimer",
      "type": "timerTrigger",
      "direction": "in",
      "schedule": "0 */10 * * * *"
    },
    {
      "name": "blobInput",
      "type": "blob",
      "direction": "in",
      "path": "mycontainer/myblob.txt",
      "connection": "AzureWebJobsStorage"
    }
  ]
}

import { AzureFunction, Context } from "@azure/functions";

let CACHED_BLOB_DATA: string | null = null;

const timerTriggerWithBlob: AzureFunction = async function (context: Context, myTimer: any): Promise<void> {
    if (CACHED_BLOB_DATA === null) {
        // Read blob content and cache it
        CACHED_BLOB_DATA = context.bindings.blobInput;
        context.log(`Blob content cached: ${CACHED_BLOB_DATA?.substring(0, 100)}...`);
    }

    context.log(`Timer function executed at: ${new Date().toISOString()}`);
    context.log(`Using cached data of length: ${CACHED_BLOB_DATA?.length || 0}`);
};

export default timerTriggerWithBlob;

Örnek: Kuyruk Çıkışlı HTTP Tetikleyicisi

Bu fonksiyon bir HTTP isteği üzerine tetiklenir, bir depolama kuyruğuna mesaj yazar ve HTTP yanıtı döndürür.

JavaScript

const { app, output } = require('@azure/functions');

const queueOutput = output.storageQueue({
    connection: 'AzureWebJobsStorage',
    queueName: 'myqueue'
});

app.http('httpTriggerWithQueue', {
    methods: ['GET', 'POST'],
    extraOutputs: [queueOutput],
    handler: async (request, context) => {
        const name = request.query.get('name') || 'World';
        const message = {
            id: context.invocationId,
            name: name,
            timestamp: new Date().toISOString()
        };

        // Write to queue output
        context.extraOutputs.set(queueOutput, JSON.stringify(message));
        context.log(`Message sent to queue: ${JSON.stringify(message)}`);

        return {
            body: `Hello, ${name}! Message queued successfully.`
        };
    }
});

TypeScript

import { app, HttpRequest, HttpResponseInit, InvocationContext, output } from '@azure/functions';

const queueOutput = output.storageQueue({
    connection: 'AzureWebJobsStorage',
    queueName: 'myqueue'
});

interface QueueMessage {
    id: string;
    name: string;
    timestamp: string;
}

async function httpTriggerWithQueue(
    request: HttpRequest,
    context: InvocationContext
): Promise<HttpResponseInit> {
    const name = request.query.get('name') || 'World';
    const message: QueueMessage = {
        id: context.invocationId,
        name: name,
        timestamp: new Date().toISOString()
    };

    // Write to queue output
    context.extraOutputs.set(queueOutput, JSON.stringify(message));
    context.log(`Message sent to queue: ${JSON.stringify(message)}`);

    return {
        body: `Hello, ${name}! Message queued successfully.`
    };
}

app.http('httpTriggerWithQueue', {
    methods: ['GET', 'POST'],
    extraOutputs: [queueOutput],
    handler: httpTriggerWithQueue
});

Bu fonksiyon bir HTTP isteği üzerine tetiklenir, bir depolama kuyruğuna mesaj yazar ve HTTP yanıtı döndürür.

JavaScript

{
  "scriptFile": "index.js",
  "bindings": [
    {
      "type": "httpTrigger",
      "direction": "in",
      "name": "req",
      "methods": ["get", "post"]
    },
    {
      "type": "http",
      "direction": "out",
      "name": "$return"
    },
    {
      "type": "queue",
      "direction": "out",
      "name": "outputQueue",
      "queueName": "myqueue",
      "connection": "AzureWebJobsStorage"
    }
  ]
}

module.exports = async function (context, req) {
    const name = (req.query.name || (req.body && req.body.name)) || 'World';
    const message = {
        id: context.invocationId,
        name: name,
        timestamp: new Date().toISOString()
    };

    // Write to queue output
    context.bindings.outputQueue = JSON.stringify(message);
    context.log(`Message sent to queue: ${JSON.stringify(message)}`);

    return {
        status: 200,
        body: `Hello, ${name}! Message queued successfully.`
    };
};

TypeScript

{
  "scriptFile": "../dist/HttpTriggerWithQueue/index.js",
  "bindings": [
    {
      "type": "httpTrigger",
      "direction": "in",
      "name": "req",
      "methods": ["get", "post"]
    },
    {
      "type": "http",
      "direction": "out",
      "name": "$return"
    },
    {
      "type": "queue",
      "direction": "out",
      "name": "outputQueue",
      "queueName": "myqueue",
      "connection": "AzureWebJobsStorage"
    }
  ]
}

import { AzureFunction, Context, HttpRequest } from "@azure/functions";

interface QueueMessage {
    id: string;
    name: string;
    timestamp: string;
}

const httpTriggerWithQueue: AzureFunction = async function (
    context: Context,
    req: HttpRequest
): Promise<any> {
    const name = (req.query.name || (req.body && req.body.name)) || 'World';
    const message: QueueMessage = {
        id: context.invocationId,
        name: name,
        timestamp: new Date().toISOString()
    };

    // Write to queue output
    context.bindings.outputQueue = JSON.stringify(message);
    context.log(`Message sent to queue: ${JSON.stringify(message)}`);

    return {
        status: 200,
        body: `Hello, ${name}! Message queued successfully.`
    };
};

export default httpTriggerWithQueue;

app, trigger, input ve output nesneleri, @azure/functions modülü tarafından dışarı aktarılan, çoğu tür için tipine özgü yöntemler sağlar. Desteklenmeyen tüm türler için yapılandırmayı el ile belirtmenize olanak sağlayan bir generic yöntem sağlanır. Türe özgü bir metot tarafından sağlanan varsayılan ayarları değiştirmek istiyorsanız, generic metodu da kullanılabilir.

Aşağıdaki örnek, türe özgü yöntemler yerine genel yöntemler kullanan basit bir HTTP ile tetiklenen işlevdir.

JavaScript

const { app, output, trigger } = require("@azure/functions");

app.generic("helloWorld1", {
  trigger: trigger.generic({
    type: "httpTrigger",
    methods: ["GET", "POST"],
  }),
  return: output.generic({
    type: "http",
  }),
  handler: async (request, context) => {
    context.log(`Http function processed request for url "${request.url}"`);

    return { body: `Hello, world!` };
  },
});

TypeScript

import {
  app,
  InvocationContext,
  HttpRequest,
  HttpResponseInit,
  output,
  trigger,
} from "@azure/functions";

async function helloWorld1(
  request: HttpRequest,
  context: InvocationContext
): Promise<HttpResponseInit> {
  context.log(`Http function processed request for url "${request.url}"`);

  return { body: `Hello, world!` };
}

app.generic("helloWorld1", {
  trigger: trigger.generic({
    type: "httpTrigger",
    methods: ["GET", "POST"],
  }),
  return: output.generic({
    type: "http",
  }),
  handler: helloWorld1,
});

::: bölge-son

Çağırma bağlamı

Fonksiyonunuzun her çağrısı bir context çağrı nesnesi alır. Bu nesneyi girdileri okumak, çıktıları ayarlamak, loglara yazmak ve çeşitli meta verilere erişmek için kullanın. V3 modelinde, bağlam nesnesini her zaman ilk argüman olarak yöneticinize iletirsiniz.

Nesne context aşağıdaki özellikleri içerir:

Özellik	Açıklama
invocationId	Geçerli işlev çağrısının kimliği.
executionContext	Bkz. yürütme bağlamı.
bindings	Bkz. bağlamalar.
bindingData	Bu çağrı için, değerin kendisi hariç, tetikleyici girdisine ilişkin meta veriler. Örneğin, bir olay merkezi tetikleyicisi özelliğine enqueuedTimeUtc sahiptir.
traceContext	Dağıtılmış izleme bağlamı. Daha fazla bilgi için bkz. Trace Context.
bindingDefinitions	girişlerinizin ve çıkışlarınızın yapılandırması, function.json'de tanımlandığı gibi.
req	Bkz. HTTP isteği.
res	Bkz. HTTP yanıtı.

context.yürütmeBağlamı

context.executionContext nesnesi aşağıdaki özelliklere sahiptir:

Özellik	Açıklama
invocationId	Geçerli işlev çağrısının kimliği.
functionName	Çağırdığınız fonksiyonun adı. dosyayı içeren function.json klasörün adı işlevin adını belirler.
functionDirectory	Dosyayı içeren function.json klasör.
retryContext	Bkz. yeniden deneme bağlamı.

context.executionContext.retryContext

context.executionContext.retryContext nesnesi aşağıdaki özelliklere sahiptir:

Özellik	Açıklama
retryCount	Geçerli yeniden deneme denemesini temsil eden bir sayı.
maxRetryCount	Yürütmenin yeniden denenme sayısının maksimumu. -1 süresiz olarak yeniden deneneceği anlamına gelir.
exception	Yeniden denemeye neden olan özel durum.

context.bindings

Nesneyi context.bindings girişleri okumak veya çıkışları ayarlamak için kullanın. Aşağıdaki örnek, bir depolama kuyruğu tetikleyicisidir; bu tetikleyici bir context.bindings bir depolama blob çıktısına kopyalamak için kullanılır. Kuyruk iletisinin içeriği, bir {queueTrigger} yardımıyla kopyalanacak dosya adı olarak ile değiştirilir.

{
    "name": "myQueueItem",
    "type": "queueTrigger",
    "direction": "in",
    "connection": "storage_APPSETTING",
    "queueName": "helloworldqueue"
},
{
    "name": "myInput",
    "type": "blob",
    "direction": "in",
    "connection": "storage_APPSETTING",
    "path": "helloworld/{queueTrigger}"
},
{
    "name": "myOutput",
    "type": "blob",
    "direction": "out",
    "connection": "storage_APPSETTING",
    "path": "helloworld/{queueTrigger}-copy"
}

JavaScript

module.exports = async function (context, myQueueItem) {
  const blobValue = context.bindings.myInput;
  context.bindings.myOutput = blobValue;
};

TypeScript

import { AzureFunction, Context } from "@azure/functions";

const queueTrigger1: AzureFunction = async function (
  context: Context,
  myQueueItem: string
): Promise<void> {
  const blobValue = context.bindings.myInput;
  context.bindings.myOutput = blobValue;
};

export default queueTrigger1;

bağlam.tamamlandı

context.done yöntemi kullanım dışıdır. Azure İşlevleri asenkron fonksiyonları desteklemeden önce, fonksiyonunuzun tamamlandığını şu adresle çağırarak context.done()işaret etmiştiniz:

JavaScript

module.exports = function (context, request) {
  context.log("this pattern is now deprecated");
  context.done();
};

TypeScript

import { AzureFunction, Context, HttpRequest } from "@azure/functions";

const httpTrigger: AzureFunction = function (
  context: Context,
  request: HttpRequest
): void {
  context.log("this pattern is now deprecated");
  context.done();
};

export default httpTrigger;

Çağrıyı kaldırın context.done(). Fonksiyonunuzu asenkron olarak işaretleyin ki bir söz versin (hiçbir şey yapmasanız await bile). İşleviniz tamamlanır tamamlanmaz (başka bir deyişle, döndürülen söz çözümlenir), v3 modeli işlevinizin tamam olduğunu bilir.

JavaScript

module.exports = async function (context, request) {
  context.log("you don't need context.done or an awaited call");
};

TypeScript

import { AzureFunction, Context, HttpRequest } from "@azure/functions";

const httpTrigger: AzureFunction = async function (
  context: Context,
  request: HttpRequest
): Promise<void> {
  context.log("you don't need context.done or an awaited call");
};

export default httpTrigger;

Fonksiyonunuzun her çağrısı bir context çağrı nesnesi alır. Bu nesne, çağrınız hakkında bilgi ve loging yöntemleri içerir. v4 modelinde genellikle nesneyi context ikinci argüman olarak yöneticinize iletiyorsunuz.

InvocationContext sınıfı aşağıdaki özellikleri içerir:

Özellik	Açıklama
invocationId	Geçerli işlev çağrısının kimliği.
functionName	İşlevin adı.
extraInputs	Ek girişlerin değerlerini almak için kullanılır. Daha fazla bilgi için bkz . ek girişler ve çıkışlar.
extraOutputs	Ek çıkışların değerlerini ayarlamak için kullanılır. Daha fazla bilgi için bkz . ek girişler ve çıkışlar.
retryContext	Bkz. yeniden deneme bağlamı.
traceContext	Dağıtılmış izleme bağlamı. Daha fazla bilgi için bkz. Trace Context.
triggerMetadata	Bu çağrı için tetikleyici girişiyle ilgili meta veriler, değerin kendisi hariç. Örneğin, bir olay merkezi tetikleyicisi özelliğine enqueuedTimeUtc sahiptir.
options	Fonksiyon kaydedilirken, doğrulandıktan ve varsayılan ayarlar açıkça belirtildikten sonra kullanılan seçenekler.

Bağlamı yeniden dene

retryContext nesnesi aşağıdaki özelliklere sahiptir:

Özellik	Açıklama
retryCount	Geçerli yeniden deneme denemesini temsil eden bir sayı.
maxRetryCount	Yürütmenin yeniden denenme sayısının maksimumu. -1 süresiz olarak yeniden deneneceği anlamına gelir.
exception	Yeniden denemeye neden olan özel durum.

Daha fazla bilgi için bkz. retry-policies.

Loglama

Azure İşlevleri'ta loglar yazmak için kullanılırcontext.log(). Azure İşlevleri, işlev uygulaması günlüklerinizi daha iyi yakalamak için Azure Uygulaması Insights ile tümleşir. Azure İzleyici parçası olan Application Insights, hem uygulama günlüklerinin hem de izleme çıkışlarınızın toplanması, görsel işlenmesi ve analizi için olanak sağlar. Daha fazla bilgi edinmek için bkz. monitoring Azure İşlevleri.

Not

Alternatif Node.js console.log yöntemini kullanırsanız, uygulama seviyesindeki loglar takip edilir ama belirli bir fonksiyonla ilişkilendirilmez. Tüm günlüklerin belirli bir işlevle ilişkilendirilmesi için, günlükleme amacıyla console yerine context kullanın.

Aşağıdaki örnek, çağrı kimliğini içererek varsayılan "bilgi" düzeyinde bir günlük yazmaktadır.

JavaScript

context.log(`Something has happened. Invocation ID: "${context.invocationId}"`);

TypeScript

context.log(`Something has happened. Invocation ID: "${context.invocationId}"`);

Günlük düzeyleri

Varsayılan context.log yönteme ek olarak, belirli seviyelerde loglar yazmak için aşağıdaki yöntemleri kullanın:

Metot	Açıklama
context.log.error()	Günlüklere hata düzeyinde bir olay yazar.
context.log.warn()	Günlüklere uyarı düzeyi bir olay yazar.
context.log.info()	Günlüklere bilgi düzeyinde bir olay yazar.
context.log.verbose()	Günlüklere izleme düzeyinde bir olay yazar.

Metot	Açıklama
context.trace()	Günlüklere izleme düzeyinde bir olay yazar.
context.debug()	Günlüklere hata ayıklama düzeyinde bir olay yazar.
context.info()	Günlüklere bilgi düzeyinde bir olay yazar.
context.warn()	Günlüklere uyarı düzeyi bir olay yazar.
context.error()	Günlüklere hata düzeyinde bir olay yazar.

Günlük düzeyini yapılandırma

Functions, logları izlemek ve görüntülemek için eşik seviyesini belirlemenizi sağlar. Eşiği ayarlamak için logging.logLevel özelliğini host.json dosyasında kullanın. Bu özellik, tüm fonksiyonlar için varsayılan bir seviye veya her fonksiyon için bir eşik tanımlamanızı sağlar. Daha fazla bilgi için bkz. Azure İşlevleri için izlemeyi yapılandırma.

Özel verileri izleme

Varsayılan olarak, Azure İşlevleri çıktıyı Application Insights'a izleme olarak yazar. Daha fazla kontrol için, Application Insights Node.js SDK'yı kullanarak Application Insights örneğinize özel loglar, metrikler ve bağımlılıklar gönderin.

Not

Application Insights Node.js SDK'sı yöntemleri zaman içinde değişebilir. Burada gösterilen örneklerden küçük söz dizimi farklılıkları olabilir. En son API kullanımı örnekleri için Application Insights Node.js SDK belgelerine bakın.

Node.js v4 programlama modelinde dağıtık takip için, Application Insights SDK yerine paketi @azure/functions-opentelemetry-instrumentation kullanın. Bu paket, Azure İşlevleri için OpenTelemetry tabanlı otomatik izleme sağlar. Daha fazla bilgi için OpenTelemetry Azure İşlevleri Node.js İçin Enstrümantasyon GitHub deposuna bakın.

JavaScript

const appInsights = require("applicationinsights");
appInsights.setup();
const client = appInsights.defaultClient;

module.exports = async function (context, request) {
  // Use this with 'tagOverrides' to correlate custom logs to the parent function invocation.
  var operationIdOverride = {
    "ai.operation.id": context.traceContext.traceparent,
  };

  client.trackEvent({
    name: "my custom event",
    tagOverrides: operationIdOverride,
    properties: { customProperty2: "custom property value" },
  });
  client.trackException({
    exception: new Error("handled exceptions can be logged with this method"),
    tagOverrides: operationIdOverride,
  });
  client.trackMetric({
    name: "custom metric",
    value: 3,
    tagOverrides: operationIdOverride,
  });
  client.trackTrace({
    message: "trace message",
    tagOverrides: operationIdOverride,
  });
  client.trackDependency({
    target: "http://dbname",
    name: "select customers proc",
    data: "SELECT * FROM Customers",
    duration: 231,
    resultCode: 0,
    success: true,
    dependencyTypeName: "ZSQL",
    tagOverrides: operationIdOverride,
  });
  client.trackRequest({
    name: "GET /customers",
    url: "http://myserver/customers",
    duration: 309,
    resultCode: 200,
    success: true,
    tagOverrides: operationIdOverride,
  });
};

TypeScript

import { AzureFunction, Context, HttpRequest } from "@azure/functions";
import * as appInsights from "applicationinsights";

appInsights.setup();
const client = appInsights.defaultClient;

const httpTrigger: AzureFunction = async function (
  context: Context,
  request: HttpRequest
): Promise<void> {
  // Use this with 'tagOverrides' to correlate custom logs to the parent function invocation.
  var operationIdOverride = {
    "ai.operation.id": context.traceContext.traceparent,
  };

  client.trackEvent({
    name: "my custom event",
    tagOverrides: operationIdOverride,
    properties: { customProperty2: "custom property value" },
  });
  client.trackException({
    exception: new Error("handled exceptions can be logged with this method"),
    tagOverrides: operationIdOverride,
  });
  client.trackMetric({
    name: "custom metric",
    value: 3,
    tagOverrides: operationIdOverride,
  });
  client.trackTrace({
    message: "trace message",
    tagOverrides: operationIdOverride,
  });
  client.trackDependency({
    target: "http://dbname",
    name: "select customers proc",
    data: "SELECT * FROM Customers",
    duration: 231,
    resultCode: 0,
    success: true,
    dependencyTypeName: "ZSQL",
    tagOverrides: operationIdOverride,
  });
  client.trackRequest({
    name: "GET /customers",
    url: "http://myserver/customers",
    duration: 309,
    resultCode: 200,
    success: true,
    tagOverrides: operationIdOverride,
  });
};

export default httpTrigger;

tagOverrides parametresi, işlevin çağrı kimliğine operation_Id ayarlar. Bu ayar, belirli bir fonksiyon çağrısı için otomatik olarak oluşturulan ve özel logları ilişkilendirmenizi sağlar.

HTTP tetikleyicileri

HTTP ve web kancası tetikleyicileri, HTTP iletilerini temsil etmek için istek ve yanıt nesnelerini kullanır.

HTTP ve webhook tetikleyicileri, HTTP iletilerini temsil etmek için HttpRequest ve HttpResponse nesnelerini kullanır. Sınıflar, Node.js'in paketini kullanarak getirme standardının bir alt kümesini temsil ederundici.

HTTP isteği

Talebe birkaç şekilde erişin:

• İşlevinizin ikinci bağımsız değişkeni olarak:

  JavaScript

  module.exports = async function (context, request) {
      context.log(`Http function processed request for url "${request.url}"`);
  

  TypeScript

  const httpTrigger: AzureFunction = async function (context: Context, request: HttpRequest): Promise<void> {
      context.log(`Http function processed request for url "${request.url}"`);
  

---

• Özelliğinden context.req :

  JavaScript

  module.exports = async function (context, request) {
      context.log(`Http function processed request for url "${context.req.url}"`);
  

  TypeScript

  const httpTrigger: AzureFunction = async function (context: Context, request: HttpRequest): Promise<void> {
      context.log(`Http function processed request for url "${context.req.url}"`);
  

---

• Adı verilen giriş bağlamalarından: Bu seçenek, HTTP dışı herhangi bir bağlama ile aynı şekilde çalışır. içindeki function.json bağlama adı, üzerindeki anahtarla context.bindingsveya aşağıdaki örnekteki "request1" ile eşleşmelidir:

  {
    "name": "request1",
    "type": "httpTrigger",
    "direction": "in",
    "authLevel": "anonymous",
    "methods": ["get", "post"]
  }
  

  JavaScript

  module.exports = async function (context, request) {
      context.log(`Http function processed request for url "${context.bindings.request1.url}"`);
  

  TypeScript

  const httpTrigger: AzureFunction = async function (context: Context, request: HttpRequest): Promise<void> {
      context.log(`Http function processed request for url "${context.bindings.request1.url}"`);
  

---

HttpRequest nesnesi aşağıdaki özelliklere sahiptir:

Özellik	Türü	Açıklama
method	string	Bu işlevi çağırmak için kullanılan HTTP istek yöntemi.
url	string	İstek URL'si.
headers	Record<string, string>	HTTP isteği başlıkları. Bu nesne büyük/küçük harfe duyarlıdır. Bunun yerine request.getHeader('header-name') kullanın; çünkü büyük/küçük harfe duyarlı değildir.
query	Record<string, string>	URL'den sorgu dizesi parametrelerinin anahtarları ve değerleri.
params	Record<string, string>	Rota parametre anahtarları ve değerleri.
user	HttpRequestUser \| null	İşlevler kimlik doğrulaması, SWA Kimlik Doğrulaması yoluyla veya böyle bir kullanıcı oturum açmamışsa "null" durumunda oturum açmış kullanıcıyı temsil eden nesne.
body	Buffer \| string \| any	Medya türü "application/octet-stream" veya "multipart/*" ise, body bir arabellek olur. Değer JSON ayrıştırma yapabilen bir dizeyse, body ayrıştırılan nesnedir. Aksi takdirde, body bir dizedir.
rawBody	string	Bir dize olarak gövde. Adı her ne kadar böyle olsa da, bu özellik bir arabellek döndürmez.
bufferBody	Buffer	Vücut bir tampon olarak.

İsteğe, HTTP tetiklenen bir fonksiyon için işleyicinize iletilen ilk argüman olarak erişebilirsiniz.

JavaScript

async (request, context) => {
    context.log(`Http function processed request for url "${request.url}"`);

TypeScript

async function helloWorld1(request: HttpRequest, context: InvocationContext): Promise<HttpResponseInit> {
    context.log(`Http function processed request for url "${request.url}"`);

HttpRequest nesnesi aşağıdaki özelliklere sahiptir:

Özellik	Türü	Açıklama
method	string	Bu işlevi çağırmak için kullanılan HTTP istek yöntemi.
url	string	İstek URL'si.
headers	Headers	HTTP isteği başlıkları.
query	URLSearchParams	URL'den sorgu dizesi parametrelerinin anahtarları ve değerleri.
params	Record<string, string>	Rota parametre anahtarları ve değerleri.
user	HttpRequestUser \| null	İşlevler kimlik doğrulaması, SWA Kimlik Doğrulaması yoluyla veya böyle bir kullanıcı oturum açmamışsa "null" durumunda oturum açmış kullanıcıyı temsil eden nesne.
body	ReadableStream \| null	Okunabilir bir akış olarak gövde.
bodyUsed	boolean	Gövdenin zaten okunup okunmadığını gösteren boole değeri.

Bir istek veya yanıtın gövdesine erişmek için aşağıdaki yöntemleri kullanın:

Metot	Dönüş Türü
arrayBuffer()	Promise<ArrayBuffer>
blob()	Promise<Blob>
formData()	Promise<FormData>
json()	Promise<unknown>
text()	Promise<string>

Not

Vücut fonksiyonlarını sadece bir kez çalıştırabilirsiniz. Sonraki çağrılar boş dizilerle veya ArrayBuffer'larla çözülür.

HTTP yanıtı

Yanıtı birkaç şekilde ayarlayabilirsiniz. Örneğin şunları kullanabilirsiniz:

• context.res Özelliğini ayarlayın:

  JavaScript

  module.exports = async function (context, request) {
      context.res = { body: `Hello, world!` };
  

  TypeScript

  const httpTrigger: AzureFunction = async function (context: Context, request: HttpRequest): Promise<void> {
      context.res = { body: `Hello, world!` };
  

---

• Yanıtı döndür: İşleviniz asenkron ise ve bağlama adını $return içinde function.json olarak belirlerseniz, yanıtı context üzerinde ayarlamak yerine doğrudan döndürebilirsiniz.

  {
    "type": "http",
    "direction": "out",
    "name": "$return"
  }
  

  JavaScript

  module.exports = async function (context, request) {
      return { body: `Hello, world!` };
  

  TypeScript

  const httpTrigger: AzureFunction = async function (context: Context, request: HttpRequest): Promise<HttpResponseSimple> {
      return { body: `Hello, world!` };
  

---

• Adlandırılmış çıktı bağlamasını ayarlayın: Bu seçenek, HTTP dışı herhangi bir bağlama ile aynı şekilde çalışır. içindeki function.json bağlama adı, aşağıdaki örnekteki context.bindingsveya "response1" üzerindeki anahtarla eşleşmelidir:

  {
    "type": "http",
    "direction": "out",
    "name": "response1"
  }
  

  JavaScript

  module.exports = async function (context, request) {
      context.bindings.response1 = { body: `Hello, world!` };
  

  TypeScript

  const httpTrigger: AzureFunction = async function (context: Context, request: HttpRequest): Promise<void> {
      context.bindings.response1 = { body: `Hello, world!` };
  

---

• Çağrı context.res.send(): Bu seçenek kullanım dışıdır. context.done() öğesini örtük biçimde çağırır ve asenkron bir işlevde kullanılamaz.

  JavaScript

  module.exports = function (context, request) {
      context.res.send(`Hello, world!`);
  

  TypeScript

  const httpTrigger: AzureFunction = function (context: Context, request: HttpRequest): void {
      context.res.send(`Hello, world!`);
  

---

Yanıtı ayarlarken yeni bir nesne oluşturursanız, bu nesne aşağıdaki özelliklere HttpResponseSimple sahip olan arabirimle eşleşmelidir:

Özellik	Türü	Açıklama
headers	Record<string, string> (isteğe bağlı)	HTTP yanıt üst bilgileri.
cookies	Cookie[] (isteğe bağlı)	HTTP yanıt çerezleri.
body	any (isteğe bağlı)	HTTP yanıt gövdesi.
statusCode	number (isteğe bağlı)	HTTP yanıt durum kodu. Ayarlanmadıysa, varsayılan olarak olur 200.
status	number (isteğe bağlı)	ile statusCodeaynıdır. statusCode ayarlanırsa bu özellik yoksayılır.

Nesnenin context.res üzerine yazmadan da değiştirebilirsiniz. Varsayılan context.res nesne, özelliklerine HttpResponseFull ek olarak aşağıdaki yöntemleri destekleyen arabirimini HttpResponseSimple kullanır:

Metot	Açıklama
status()	Durumu ayarlar.
setHeader()	Üst bilgi alanı ayarla. NOT:res.set() ve res.header() aynı şekilde destekleniyor ve aynı şeyi yapıyorlar.
getHeader()	Bir başlık alanı döndürür. NOT:res.get() aynı şekilde destekleniyor ve aynı şeyi yapıyor.
removeHeader()	Üst bilgiyi kaldırır.
type()	"content-type" üst bilgisini ayarlar.
send()	Bu yöntem kullanım dışıdır. Gövdeyi ayarlar ve senkronizasyon işlevinin bittiğini belirtmek için context.done() çağırır. NOT:res.end() aynı şekilde destekleniyor ve aynı şeyi yapıyor.
sendStatus()	Bu yöntem kullanım dışıdır. Durum kodunu ayarlar ve bir eşitleme işlevinin bittiğini belirtmek için context.done() çağırır.
json()	Bu yöntem kullanım dışıdır. "content-type" öğesini "application/json" olarak ayarlar, gövdeyi ayarlar ve eşitleme işlevinin bittiğini belirtmek için çağırır context.done() .

Yanıtı birkaç şekilde ayarlayabilirsiniz. Örneğin şunları kullanabilirsiniz:

• Tip HttpResponseInitile basit bir arayüz: Bu seçenek, yanıtları geri vermenin en özlü yoludur.

  JavaScript

  return { body: `Hello, world!` };
  

  TypeScript

  return { body: `Hello, world!` };
  

---

Arabirim HttpResponseInit aşağıdaki özelliklere sahiptir:

Özellik	Türü	Açıklama
body	BodyInit (isteğe bağlı)	HTTP yanıt gövdesi , ArrayBuffer, AsyncIterable<Uint8Array>, Blob, , FormData, Iterable<Uint8Array>, NodeJS.ArrayBufferView, URLSearchParamsnullveya stringşeklindedir.
jsonBody	any (isteğe bağlı)	JSON serileştirilebilir HTTP Yanıt gövdesi. Ayarlanırsa, HttpResponseInit.body özellik bu özellik için yoksayılır.
status	number (isteğe bağlı)	HTTP yanıt durum kodu. Ayarlanmadıysa, varsayılan olarak olur 200.
headers	HeadersInit (isteğe bağlı)	HTTP yanıt üst bilgileri.
cookies	Cookie[] (isteğe bağlı)	HTTP yanıt çerezleri.

• türüne HttpResponsesahip bir sınıf olarak: Bu seçenek, yanıtın üst bilgiler gibi çeşitli bölümlerini okumak ve değiştirmek için yardımcı yöntemler sağlar.

  JavaScript

  const response = new HttpResponse({ body: `Hello, world!` });
  response.headers.set("content-type", "application/json");
  return response;
  

  TypeScript

  const response = new HttpResponse({ body: `Hello, world!` });
  response.headers.set("content-type", "application/json");
  return response;
  

---

HttpResponse sınıfı, oluşturucusunun isteğe bağlı bağımsız değişkeni olarak HttpResponseInit kabul eder ve aşağıdaki özelliklere sahiptir:

Özellik	Türü	Açıklama
status	number	HTTP yanıt durum kodu.
headers	Headers	HTTP yanıt üst bilgileri.
cookies	Cookie[]	HTTP yanıt çerezleri.
body	ReadableStream | null	Okunabilir bir akış olarak gövde.
bodyUsed	boolean	Gövdenin zaten okunup okunmadığını gösteren boole değeri.

HTTP akışları

HTTP akışları, büyük verileri işlemeyi, OpenAI yanıtlarını akışla aktarmayı, dinamik içerik sunup diğer temel HTTP senaryolarını desteklemeyi kolaylaştıran bir özelliktir. Node.js işlev uygulamanızdaki HTTP uç noktalarına istekleri ve yanıtları akışla göndermenizi sağlar. Uygulamanızın http üzerinden istemci ve sunucu arasında gerçek zamanlı değişim ve etkileşim gerektirdiği senaryolarda HTTP akışlarını kullanın. HTTP kullanırken uygulamalarınız için en iyi performansı ve güvenilirliği elde etmek için HTTP akışlarını da kullanabilirsiniz.

Önemli

HTTP akışları v3 modelinde desteklenmez. HTTP akış özelliğini kullanmak için v4 modeline yükseltin. v4 programlama modelindeki mevcut HttpRequest ve HttpResponse türleri, akış olarak da dahil olmak üzere ileti gövdesini işlemenin çeşitli yollarını zaten destekler.

Önkoşullar

• @azure/functions npm paketi sürüm 4.3.0 veya üzeri.
• Azure İşlevleri runtime sürüm 4.28 veya üzeri.
• Azure İşlevleri Core Tools sürüm 4.0.5530 veya daha sonrası, doğru çalışma zamanı sürümünü içerir.

Akışları etkinleştirme

İşlev uygulamanızda Azure ve yerel projelerinizde HTTP akışlarını etkinleştirmek için şu adımları kullanın:

1. Büyük miktarlarda veri akışı yapmayı planlıyorsanız, Azure'da FUNCTIONS_REQUEST_BODY_SIZE_LIMIT ayarını değiştirin. Varsayılan maksimum gövde boyutu 104857600, bu da taleplerinizi yaklaşık 100 MB ile sınırlar.

2. Yerel geliştirme için FUNCTIONS_REQUEST_BODY_SIZE_LIMIT ögesini de local.settings.json dosyasına ekleyin.

3. Ana alanınıza dahil edilen herhangi bir dosyaya aşağıdaki kodu uygulamanıza ekleyin.

   JavaScript

   const { app } = require("@azure/functions");
   
   app.setup({ enableHttpStream: true });
   

   TypeScript

   import { app } from "@azure/functions";
   
   app.setup({ enableHttpStream: true });
   

---

Akış örnekleri

Aşağıdaki örnek, HTTP POST talebi aracılığıyla veri alan HTTP tetikleyici bir fonksiyonu göstermektedir. Fonksiyon, bu veriyi belirli bir çıktı dosyasına aktarır:

JavaScript

const { app } = require('@azure/functions');
const { createWriteStream } = require('fs');
const { Writable } = require('stream');

app.http('httpTriggerStreamRequest', {
    methods: ['POST'],
    authLevel: 'anonymous',
    handler: async (request, context) => {
        const writeStream = createWriteStream('<output file path>');
        await request.body.pipeTo(Writable.toWeb(writeStream));

        return { body: 'Done!' };
    },
});

TypeScript

import { app, HttpRequest, HttpResponseInit, InvocationContext } from '@azure/functions';
import { createWriteStream } from 'fs';
import { Writable } from 'stream';

export async function httpTriggerStreamRequest(
    request: HttpRequest,
    context: InvocationContext
): Promise<HttpResponseInit> {
    const writeStream = createWriteStream('<output file path>');
    await request.body.pipeTo(Writable.toWeb(writeStream));

    return { body: 'Done!' };
}

app.http('httpTriggerStreamRequest', {
    methods: ['POST'],
    authLevel: 'anonymous',
    handler: httpTriggerStreamRequest,
});

Aşağıdaki örnek, gelen HTTP GET taleplerine yanıt olarak dosyanın içeriğini akış olarak aktaran HTTP tetiklenen bir fonksiyonu göstermektedir:

JavaScript

const { app } = require('@azure/functions');
const { createReadStream } = require('fs');

app.http('httpTriggerStreamResponse', {
    methods: ['GET'],
    authLevel: 'anonymous',
    handler: async (request, context) => {
        const body = createReadStream('<input file path>');

        return { body };
    },
});

TypeScript

import { app, HttpRequest, HttpResponseInit, InvocationContext } from '@azure/functions';
import { createReadStream } from 'fs';

export async function httpTriggerStreamResponse(
    request: HttpRequest,
    context: InvocationContext
): Promise<HttpResponseInit> {
    const body = createReadStream('<input file path>');

    return { body };
}

app.http('httpTriggerStreamResponse', {
    methods: ['GET'],
    authLevel: 'anonymous',
    handler: httpTriggerStreamResponse,
});

Akış kullanan hazır bir örnek uygulama için GitHub'daki bu örneğe göz atın.

Akışla ilgili dikkat edilmesi gerekenler

• Akışlardan en iyi şekilde yararlanmak için request.body kullanın. Yine de request.text() gibi yöntemleri kullanabilirsiniz ve bunlar her zaman gövdeyi dize olarak döndürür.

Kancalar

V3 modeli kancaları desteklemiyor. Kancaları kullanmak için v4 modeline yükseltin.

Azure İşlevleri yaşam döngüsünün farklı noktalarında kod yürütmek için bir kanca kullanın. Hook'ları hangi sırayla kaydettiğiniz, hangi sırayla çalıştırılacaklarını belirler. Uygulamanızdaki herhangi bir dosyadan kancaları kaydedebilirsiniz. İki farklı kanca kapsamı vardır: "app" seviyesi ve "çağırma" seviyesi.

Çağırma kancaları

Çağrı kancaları, fonksiyonunuzun her çağrılışında bir kez çalışır. Bir preInvocation hook, fonksiyon çalışmadan önce çalışır, bir postInvocation hook ise fonksiyonun ardından çalışır. Varsayılan olarak, hookunuz tüm tetikleyici tipleri için çalıştırılır, ancak türe göre filtreleyebilirsiniz. Aşağıdaki örnekte bir çağırma kancasının nasıl kaydedildiği ve tetikleyici türüne göre nasıl filtreleneceği gösterilmektedir:

JavaScript

const { app } = require('@azure/functions');

// Pre-invocation hook with trigger filtering
app.hook.preInvocation('httpPreInvocation', async (context) => {
  context.hookData.startTime = Date.now();
  context.invocationContext.log(`Pre-invocation hook executed for ${context.invocationContext.functionName}`);

  // Add custom headers or modify function handler if needed
  if (context.functionHandler.name === 'httpTrigger') {
    context.invocationContext.log('HTTP function detected, preparing request processing');
  }
}, {
  filter: ['httpTrigger']
});

// Post-invocation hook
app.hook.postInvocation('httpPostInvocation', async (context) => {
  const duration = Date.now() - context.hookData.startTime;
  context.invocationContext.log(`Function ${context.invocationContext.functionName} completed in ${duration}ms`);

  // Log results or errors
  if (context.error) {
    context.invocationContext.log.error(`Function failed: ${context.error.message}`);
  } else {
    context.invocationContext.log(`Function succeeded with result: ${JSON.stringify(context.result)}`);
  }
}, {
  filter: ['httpTrigger']
});

TypeScript

import { app, PreInvocationContext, PostInvocationContext, HttpRequest, HttpResponseInit } from '@azure/functions';

// Pre-invocation hook with trigger filtering
app.hook.preInvocation('httpPreInvocation', async (context: PreInvocationContext) => {
  context.hookData.startTime = Date.now();
  context.invocationContext.log(`Pre-invocation hook executed for ${context.invocationContext.functionName}`);

  // Add custom headers or modify function handler if needed
  if (context.functionHandler.name === 'httpTrigger') {
    context.invocationContext.log('HTTP function detected, preparing request processing');
  }
}, {
  filter: ['httpTrigger']
});

// Post-invocation hook
app.hook.postInvocation('httpPostInvocation', async (context: PostInvocationContext) => {
  const duration = Date.now() - context.hookData.startTime;
  context.invocationContext.log(`Function ${context.invocationContext.functionName} completed in ${duration}ms`);

  // Log results or errors
  if (context.error) {
    context.invocationContext.log.error(`Function failed: ${context.error.message}`);
  } else {
    context.invocationContext.log(`Function succeeded with result: ${JSON.stringify(context.result)}`);
  }
}, {
  filter: ['httpTrigger']
});

Kanca işleyicisinin ilk bağımsız değişkeni, bu kanca türüne özgü bir bağlam nesnesidir.

PreInvocationContext nesnesi aşağıdaki özelliklere sahiptir:

Özellik	Açıklama
inputs	Çağrıya iletdiğiniz argümanlar.
functionHandler	Çağırma için işlev işleyicisi. Bu değerdeki değişiklikler işlevin kendisini etkiler.
invocationContext	çağırma bağlam nesnesi işleve geçirildi.
hookData	Aynı kapsamdaki kancalar arasında veri depolamak ve paylaşmak için önerilen konum. Diğer hookların verileriyle çakışmaması için benzersiz bir özellik adı kullanın.

PostInvocationContext nesnesi aşağıdaki özelliklere sahiptir:

Özellik	Açıklama
inputs	Çağrıya iletdiğiniz argümanlar.
result	İşlevin sonucu. Bu değerdeki değişiklikler işlevin genel sonucunu etkiler.
error	İşlev tarafından atılan hata veya hata yoksa null/undefined. Bu değerdeki değişiklikler işlevin genel sonucunu etkiler.
invocationContext	çağırma bağlam nesnesi işleve geçirildi.
hookData	Aynı kapsamdaki kancalar arasında veri depolamak ve paylaşmak için önerilen konum. Diğer hookların verileriyle çakışmaması için benzersiz bir özellik adı kullanın.

Uygulama kancaları

Çalışma zamanı, uygulamanızın her bir örneği için uygulama hook’larını bir kez çalıştırır. Başlatma sırasında appStart kancalarını, sonlandırma sırasında ise appTerminate kancalarını çalıştırır. Uygulama sonlandırma kancalarının yürütülmesi sınırlı bir süreye sahiptir ve tüm senaryolarda yürütülemez.

Azure İşlevleri çalışma zamanı şu anda çağrı dışında bağlam günlüğünü desteklemiyor. Uygulama düzeyi kancaları sırasında verileri günlüğe kaydetmek için Application Insights npm paketini kullanın.

Aşağıdaki örnek, uygulama kancalarını kaydeder.

JavaScript

const { app } = require('@azure/functions');
const appInsights = require('applicationinsights');

// Initialize Application Insights for app-level logging
appInsights.setup().start();
const client = appInsights.defaultClient;

// App start hook
app.hook.appStart('appStartup', async (context) => {
  context.hookData.appStartTime = Date.now();
  context.hookData.initializationData = {};

  // Initialize shared resources, database connections, etc.
  client.trackEvent({
    name: 'FunctionAppStarted',
    properties: {
      timestamp: new Date().toISOString(),
      nodeVersion: process.version
    }
  });

  // Set up global configurations
  process.env.APP_INITIALIZED = 'true';
});

// App terminate hook
app.hook.appTerminate('appShutdown', async (context) => {
  const uptime = Date.now() - context.hookData.appStartTime;

  // Cleanup resources, close connections, etc.
  client.trackEvent({
    name: 'FunctionAppTerminated',
    properties: {
      uptime: uptime,
      timestamp: new Date().toISOString()
    }
  });

  // Flush Application Insights data
  await new Promise((resolve) => client.flush({ callback: resolve }));
});

TypeScript

import { app, AppStartContext, AppTerminateContext } from '@azure/functions';
import * as appInsights from 'applicationinsights';

// Initialize Application Insights for app-level logging
appInsights.setup().start();
const client = appInsights.defaultClient;

interface AppHookData {
  appStartTime: number;
  initializationData: Record<string, any>;
}

// App start hook
app.hook.appStart('appStartup', async (context: AppStartContext) => {
  const hookData = context.hookData as AppHookData;
  hookData.appStartTime = Date.now();
  hookData.initializationData = {};

  // Initialize shared resources, database connections, etc.
  client.trackEvent({
    name: 'FunctionAppStarted',
    properties: {
      timestamp: new Date().toISOString(),
      nodeVersion: process.version
    }
  });

  // Set up global configurations
  process.env.APP_INITIALIZED = 'true';
});

// App terminate hook
app.hook.appTerminate('appShutdown', async (context: AppTerminateContext) => {
  const hookData = context.hookData as AppHookData;
  const uptime = Date.now() - hookData.appStartTime;

  // Cleanup resources, close connections, etc.
  client.trackEvent({
    name: 'FunctionAppTerminated',
    properties: {
      uptime: uptime,
      timestamp: new Date().toISOString()
    }
  });

  // Flush Application Insights data
  await new Promise<void>((resolve) => client.flush({ callback: resolve }));
});

Kanca işleyicisinin ilk bağımsız değişkeni, bu kanca türüne özgü bir bağlam nesnesidir.

Nesne AppStartContext aşağıdaki özelliğe sahiptir:

Özellik	Açıklama
hookData	Aynı kapsamdaki kancalar arasında veri depolamak ve paylaşmak için önerilen konum. Diğer hookların verileriyle çakışmaması için benzersiz bir özellik adı kullanın.

Nesne AppTerminateContext aşağıdaki özelliğe sahiptir:

Özellik	Açıklama
hookData	Aynı kapsamdaki kancalar arasında veri depolamak ve paylaşmak için önerilen konum. Diğer hookların verileriyle çakışmaması için benzersiz bir özellik adı kullanın.

Hook için en iyi uygulamalar

Azure İşlevleri'ınızda hook kullanırken, şu en iyi uygulamaları göz önünde bulundurun:

Performansla ilgili dikkat edilmesi gerekenler

• Fonksiyon performansını etkilememek için hook yürütme süresini minimuma endirin.
• Engellemeyi önlemek için mümkün olduğunca asenkron işlemler kullanın.
• Yüksek hacimli istekleri işlerken hook'ların ek yükünü göz önünde bulundurun.

Hata yönetimi

• Hook’larınızda her zaman uygun hata yönetimi kullanın.
• Kesinlikle gerekli olmadıkça, hook başarısızlıklarının işlev başarısızlıklarına neden olmasına izin vermeyin.
• Hata ayıklama için kanca hatalarını uygun şekilde kaydedin.

Veri paylaşımı

• hookData, çağrı öncesi ve sonrası kancalar arasında bilgi paylaşmak için kullanılır.
• Diğer hook’larla çakışmaları önlemek için benzersiz özellik adları kullanın.
• Artık gerekmediğinde bağlantı verilerini temizleyin, böylece bellek sızıntılarını önleyin.

Filtreleme

• Tetikleyici tipi filtreleme kullanarak kancaların yalnızca ilgili fonksiyonlar için çalışmasını sağlar.
• Performansı optimize etmek için filtrelerinizle ilgili dikkatli olun.

Ölçeklendirme ve eşzamanlılık

Varsayılan olarak, Azure İşlevleri uygulamanızdaki yükü otomatik olarak izler ve gerektiğinde Node.js için daha fazla konak örneği oluşturur. Azure İşlevleri, ne zaman örnek ekleneceğine karar vermek için, farklı tetikleyici türlerine yönelik yerleşik (kullanıcı tarafından yapılandırılamayan) eşikler kullanır; buna örnek olarak QueueTrigger için mesajların yaşı ve kuyruk boyutu verilebilir. Daha fazla bilgi için bkz . Tüketim ve Premium planları nasıl çalışır?

Bu ölçeklendirme davranışı birçok Node.js uygulaması için yeterlidir. CPU'ya bağlı uygulamalar için birden çok dil çalışanı işlemi kullanarak performansı daha da geliştirebilirsiniz. FUNCTIONS_WORKER_PROCESS_COUNT uygulama ayarını kullanarak konak başına çalışan işlemlerinin sayısını varsayılan değer olan 1'den en fazla 10'a kadar artırabilirsiniz. Azure İşlevleri sonra eş zamanlı işlev çağrılarını bu çalışanlara eşit olarak dağıtmaya çalışır. Bu davranış, YOĞUN CPU kullanan bir işlevin diğer işlevlerin çalışmasını engelleme olasılığını düşürür. Bu ayar, Azure İşlevleri talebi karşılamak için uygulamanızın ölçeğini genişletirken oluşturduğu her konak için geçerlidir.

Uyarı

FUNCTIONS_WORKER_PROCESS_COUNT Ayarı dikkatli kullanın. Aynı örnekte çalışan birden çok işlem öngörülemeyen davranışlara yol açabilir ve işlev yükleme sürelerini artırabilir. Bu ayarı kullanırsanız, bir paket dosyasından çalıştırmak bu dezavantajları dengeleyebilir.

Node.js sürümü

Herhangi bir işlevden günlüğe kaydederek process.version çalışma zamanının kullandığı geçerli sürümü görebilirsiniz. Her programlama modeli tarafından desteklenen Node.js sürümlerinin listesi için bkz supported versions .

Node sürümünü ayarlama

Node.js sürümünüzü yükseltme yönteminiz, işlev uygulamanızın çalıştığı işletim sistemine bağlıdır.

Windows

Windows üzerinde çalıştığında, uygulama ayarını kullanarak WEBSITE_NODE_DEFAULT_VERSION Node.js sürümü ayarlayın. Bu ayarı ya Azure CLI kullanarak ya da Azure portalında güncellebilirsiniz.

Linux

Fonksiyon uygulaması Linux'ta çalıştığında, linuxFxVersion sitesi ayarı Node.js sürümü belirler. Bu ayarı Azure CLI kullanarak güncelleyebilirsiniz.

Node.js sürümleri hakkında daha fazla bilgi için bkz . Desteklenen sürümler.

Node.js sürümünüzü yükseltmeden önce işlev uygulamanızın Azure İşlevleri çalışma zamanının en son sürümünde çalıştığından emin olun. Çalışma zamanı sürümünüzü yükseltmeniz gerekiyorsa bkz. 3.x Azure İşlevleri sürümden 4.x sürümüne uygulamaları dağıtma.

Azure CLI

Windows üzerinde çalışan işlev uygulamanızın Node.js sürümünü güncelleştirmek için Azure CLI az functionapp config appsettings set komutunu çalıştırın:

az functionapp config appsettings set  --settings WEBSITE_NODE_DEFAULT_VERSION=~22 \
 --name <FUNCTION_APP_NAME> --resource-group <RESOURCE_GROUP_NAME>

Bu komut, uygulama ayarınıWEBSITE_NODE_DEFAULT_VERSION desteklenen LTS sürümüne ~22ayarlıyor.

Azure portalı

Node.js sürümünü değiştirmek için aşağıdaki adımları kullanın:

1. Azure portalında işlev uygulamanızı bulun ve sol taraftaki Settings>Configuration öğesini seçin.

2. İşlev çalışma zamanı ayarları sekmesini seçin ve işlev uygulamanızın İşlevler çalışma zamanının en son sürümünde çalıştığını doğrulayın.

3. Genel ayarlar sekmesini seçin ve Node.js Sürümünü en son sürüme güncelleştirin. İdeal olarak, işlevlerinizin seçtiğiniz sürümde çalıştığını zaten yerel olarak doğruladınız.

4. Yeniden başlatma hakkında bildirim aldığınızda Devam'ı ve ardından Kaydet'i seçin.

Azure CLI

linux üzerinde çalışan işlev uygulamanızın Node.js sürümünü güncelleştirmek için Azure CLI az functionapp config set komutunu çalıştırın:

az functionapp config set --linux-fx-version "node|22" --name "<FUNCTION_APP_NAME>" \
 --resource-group "<RESOURCE_GROUP_NAME>"

Bu komut, Linux fonksiyon uygulamasının temel görüntüsünü Node.js sürüm 22'ye ayarlar.

Azure portalı

Not

Fonksiyon uygulamanız Linux'ta Tüketim planında çalışırken Azure portalında Node.js sürümü değiştiremezsiniz. Bunun yerine, Azure CLI'yı kullanın.

Premium ve Ayrılmış planlar için, Node.js sürümünü değiştirmek için aşağıdaki adımları kullanın:

1. Azure portalında işlev uygulamanızı bulun ve sol taraftaki Settings>Configuration öğesini seçin.

2. İşlev çalışma zamanı ayarları sekmesini seçin ve işlev uygulamanızın İşlevler çalışma zamanının en son sürümünde çalıştığını doğrulayın.

3. Genel ayarlar sekmesini seçin ve Node.js Sürümünü en son sürüme güncelleştirin. İdeal olarak, işlevlerinizin seçtiğiniz sürümde çalıştığını zaten yerel olarak doğruladınız.

4. Yeniden başlatma hakkında bildirim aldığınızda Devam'ı ve ardından Kaydet'i seçin.

Değişiklik yaptıktan sonra fonksiyon uygulamanız yeniden başlar. Node.js için İşlev desteği hakkında daha fazla bilgi edinmek için bkz . Dil çalışma zamanı destek ilkesi.

Ortam değişkenleri

Bağlantı dizeleri, anahtarlar ve uç noktalar gibi operasyonel sırları yönetmek için ortam değişkenlerini kullanın. Ayrıca çevresel ayarlar için de kullanın, örneğin değişkenlerin profillenmesi. Hem yerel hem de bulut ortamlarınızda ortam değişkenleri ekleyin ve fonksiyon kodunuz üzerinden erişin process.env .

Aşağıdaki örnek WEBSITE_SITE_NAME ortam değişkenini günlüğe kaydeder.

JavaScript

module.exports = async function (context) {
  context.log(`WEBSITE_SITE_NAME: ${process.env["WEBSITE_SITE_NAME"]}`);
};

TypeScript

const httpTrigger: AzureFunction = async function (
  context: Context,
  request: HttpRequest
): Promise<void> {
  context.log(`WEBSITE_SITE_NAME: ${process.env["WEBSITE_SITE_NAME"]}`);
};

JavaScript

async function timerTrigger1(myTimer, context) {
  context.log(`WEBSITE_SITE_NAME: ${process.env["WEBSITE_SITE_NAME"]}`);
}

TypeScript

async function timerTrigger1(
  myTimer: Timer,
  context: InvocationContext
): Promise<void> {
  context.log(`WEBSITE_SITE_NAME: ${process.env["WEBSITE_SITE_NAME"]}`);
}

Yerel geliştirme ortamında

Yerel olarak çalıştırdığınızda, işlev projeniz bir dosyasını içerir; bu dosyada, ortam değişkenlerinizi nesnesinde depolarsınız.

{
  "IsEncrypted": false,
  "Values": {
    "AzureWebJobsStorage": "",
    "FUNCTIONS_WORKER_RUNTIME": "node",
    "CUSTOM_ENV_VAR_1": "hello",
    "CUSTOM_ENV_VAR_2": "world"
  }
}

Azure bulut ortamında

Azure çalıştırdığınızda işlev uygulaması hizmet bağlantı dizeleri gibi Application ayarlarını ayarlamanıza ve kullanmanıza olanak tanır ve yürütme sırasında bu ayarları ortam değişkenleri olarak kullanıma sunar.

İşlev uygulaması ayarlarını eklemenin, güncelleştirmenin ve silmenin birkaç yolu vardır:

• Azure portalında
• Azure CLI kullanarak
• Azure PowerShell kullanarak

İşlev uygulaması ayarlarında yapılan değişiklikler, işlev uygulamanızın yeniden başlatılmasını gerektirir.

Çalışan ortamı değişkenleri

Node.js kendine özgü birkaç Fonksiyon ortam değişkeni vardır:

languageWorkers__node__arguments

Node.js sürecinizi başlatırken özel argümanları belirtmek için bu ayarı kullanın. Çoğu zaman, işçiyi hata ayıklama modunda başlatmak için yerel olarak kullanırsınız, ancak özel argümanlara ihtiyacınız varsa Azure'da da kullanabilirsiniz.

Uyarı

Mümkünse, Azure'da languageWorkers__node__arguments kullanmaktan kaçının çünkü soğuk başlatma sürelerini olumsuz etkileyebilir. Önceden ısıtılmış işleyicileri kullanmak yerine, çalışma zamanı özel argümanlarınızı kullanarak sıfırdan yeni bir işleyici başlatmak zorundadır.

logLevel Worker günlüğekaydetme

Bu ayarı kullanarak Node.jsözel çalışan günlükleri için varsayılan log seviyesini ayarlayın. Varsayılan olarak, yalnızca uyarı veya hata günlükleri gösterilir, ancak Node.js çalışanıyla ilgili sorunları tanılamaya yardımcı olmak için günlük seviyesini information veya debug olarak ayarlayabilirsiniz. Daha fazla bilgi için, günlük düzeylerini yapılandırma konusuna bakın.

ECMAScript modülleri (önizleme)

Not

ECMAScript modülleri şu anda Node.js 14 veya daha üzeri Azure İşlevleri'de önizleme özelliği olarak sunulmaktadır.

ECMAScript modülleri (ES modülleri), Node.js için yeni resmi standart modül sistemidir. Şimdiye kadar, bu makaledeki kod örnekleri CommonJS söz dizimini kullanır. Azure İşlevleri 14 veya daha yüksek Node.js çalıştırırken, fonksiyonlarınızı ES modüllerinin sözdizimi kullanarak yazmayı seçebilirsiniz.

ES modüllerini bir işlevde kullanmak için dosya adını uzantı kullanacak şekilde .mjs değiştirin. Aşağıdaki index.mjs dosya örneği, kitaplığı içeri aktarmak ve bir değer döndürmek için ES modülleri söz dizimini uuid kullanan HTTP ile tetiklenen bir işlevdir.

JavaScript

import { v4 as uuidv4 } from "uuid";

async function httpTrigger1(context, request) {
  context.res.body = uuidv4();
}

export default httpTrigger;

TypeScript

import { AzureFunction, Context } from "@azure/functions";
import { v4 as uuidv4 } from "uuid";

const httpTrigger: AzureFunction = async function (
  context: Context,
  request: HttpRequest
): Promise<void> {
  context.res.body = uuidv4();
};

export default httpTrigger;

JavaScript

import { v4 as uuidv4 } from "uuid";

async function httpTrigger1(request, context) {
  return { body: uuidv4() };
}

app.http("httpTrigger1", {
  methods: ["GET", "POST"],
  handler: httpTrigger1,
});

TypeScript

import {
  app,
  HttpRequest,
  HttpResponseInit,
  InvocationContext,
} from "@azure/functions";
import { v4 as uuidv4 } from "uuid";

async function httpTrigger1(
  request: HttpRequest,
  context: InvocationContext
): Promise<HttpResponseInit> {
  return { body: uuidv4() };
}

app.http("httpTrigger1", {
  methods: ["GET", "POST"],
  handler: httpTrigger1,
});

İşlev giriş noktasını yapılandırma

function.json Özellikleri scriptFile kullanın ve entryPoint dışa aktardığınız fonksiyonun konumunu ve adını ayarlayın. TypeScript kullandığınızda, scriptFile özelliğine ihtiyacınız vardır ve bu özellik derlenmiş JavaScript’i göstermelidir.

scriptFile’ı kullanma

Varsayılan olarak, bir JavaScript fonksiyonu 'den index.jsçalışır. Bu dosya, ilgili function.json dosyayla aynı ana dizini paylaşır.

Klasör yapınızı düzenlemek için kullanın scriptFile . Aşağıdaki örnek, klasörlerinizi kurmanın bir yolunu göstermektedir:

<project_root>/
 | - node_modules/
 | - myFirstFunction/
 | | - function.json
 | - lib/
 | | - sayHello.js
 | - host.json
 | - package.json

myFirstFunction için function.json dosyası, çalıştırılacak dışa aktarılan işlevi içeren dosyayı işaret eden bir scriptFile özelliği içermelidir.

{
  "scriptFile": "../lib/sayHello.js",
  "bindings": [
    ...
  ]
}

entryPoint’ı kullanma

v3 modelinde, fonksiyonun bulunup çalıştırılabilmesi için bir fonksiyonu dışa aktarmanız gerekir module.exports . Varsayılan olarak, tetiklendiğinde çalışan fonksiyon o dosyadan tek dışa aktarma yöntemidir. Ayrıca, run adlı dışa aktarma veya index adlı dışa aktarma olabilir. Aşağıdaki örnek, entryPoint, function.json içinde özel bir değer olan "logHello" olarak ayarlar:

{
  "entryPoint": "logHello",
  "bindings": [
    ...
  ]
}

JavaScript

async function logHello(context) {
  context.log("Hello, world!");
}

module.exports = { logHello };

TypeScript

import { AzureFunction, Context } from "@azure/functions";

const logHello: AzureFunction = async function (
  context: Context
): Promise<void> {
  context.log("Hello, world!");
};

export default { logHello };

Öneriler

Bu bölüm, takip etmeniz gereken Node.js uygulamalar için birkaç etkili kalıp tanımlıyor.

Tek vCPU App Service planlarını seçin

App Service planını kullanan bir fonksiyon uygulaması oluşturduğunuzda, birden fazla vCPU'lu plan yerine tek vCPU planı seçin. Günümüzde Functions, tek vCPU VM'lerde Node.js fonksiyonları daha verimli çalıştırıyor ve daha büyük VM'ler beklenen performans artışlarını getirmez. Gerekirse, daha fazla tek vCPU VM örneği ekleyerek ölçeklenebilir veya otomatik ölçeklendirmeyi etkinleştirebilirsiniz. Daha fazla bilgi için bkz . Örnek sayısını el ile veya otomatik olarak ölçeklendirme.

Paket dosyasından çalıştırma

Sunucusuz barındırma modelinde Azure İşlevleri geliştirdiğinizde, soğuk başlangıçlar bir gerçektir. Soğuk başlangıç , işlev uygulamanızın bir süre etkinlik dışı kalma süresinden sonra ilk kez başlatılmasını ve başlatılmasının daha uzun sürmesini ifade eder. Özellikle büyük bağımlılık ağaçları olan Node.js uygulamalar için soğuk başlangıç önemli olabilir. Soğuk başlatma işlemini hızlandırmak için mümkün olduğunda işlevlerinizi paket dosyası olarak çalıştırın. Birçok dağıtım yöntemi varsayılan olarak bu modeli kullanır, ancak büyük soğuk startlar yaşıyorsanız, bu şekilde çalıştığınızdan emin olun.

async ve await kullanın

Node.js’te Azure İşlevleri yazarken, kodunuzu async ve await anahtar sözcüklerini kullanarak yazın. Geri çağırmalar ya da Promises ile .then ve .catch kullanmak yerine async ve await kullanarak kod yazmak, iki yaygın sorundan kaçınmanıza yardımcı olur:

• Node.js işlemini çökertebilecek, diğer işlevlerin çalışmasını etkileyebilecek şekilde yakalanmamış özel durumlar oluşturma.
• Beklenmeyen davranışlar, düzgün şekilde beklenmeyen zaman uyumsuz çağrıların neden olduğu context.log eksik günlükler gibi.

Aşağıdaki örnekte, zaman uyumsuz yöntem fs.readFile ikinci parametresi olarak hata öncelikli geri çağırma işleviyle çağrılır. Bu kod, daha önce bahsedilen sorunların her ikisine de neden olur. Doğru kapsamda açıkça yakalanmamış bir özel durum tüm işlemi çökebilir (sorun #1). Geri dönüşün tamamlandığından emin olmadan geri dönmek, HTTP yanıtının bazen boş bir gövdeye sahip olması anlamına gelir (sorun #2).

JavaScript

// DO NOT USE THIS CODE
const { app } = require('@azure/functions');
const fs = require('fs');

app.http('httpTriggerBadAsync', {
    methods: ['GET', 'POST'],
    authLevel: 'anonymous',
    handler: async (request, context) => {
        let fileData;
        fs.readFile('./helloWorld.txt', (err, data) => {
            if (err) {
                context.error(err);
                // BUG #1: This will result in an uncaught exception that crashes the entire process
                throw err;
            }
            fileData = data;
        });
        // BUG #2: fileData is not guaranteed to be set before the invocation ends
        return { body: fileData };
    },
});

TypeScript

// DO NOT USE THIS CODE
import { app, HttpRequest, HttpResponseInit, InvocationContext } from '@azure/functions';
import * as fs from 'fs';

export async function httpTriggerBadAsync(request: HttpRequest, context: InvocationContext): Promise<HttpResponseInit> {
    let fileData: Buffer;
    fs.readFile('./helloWorld.txt', (err, data) => {
        if (err) {
            context.error(err);
            // BUG #1: This will result in an uncaught exception that crashes the entire process
            throw err;
        }
        fileData = data;
    });
    // BUG #2: fileData is not guaranteed to be set before the invocation ends
    return { body: fileData };
}

app.http('httpTriggerBadAsync', {
    methods: ['GET', 'POST'],
    authLevel: 'anonymous',
    handler: httpTriggerBadAsync,
});

Aşağıdaki örnekte, zaman uyumsuz yöntem fs.readFile ikinci parametresi olarak hata öncelikli geri çağırma işleviyle çağrılır. Bu kod, daha önce bahsedilen her iki soruna da yol açıyor. Doğru kapsamda açıkça yakalanmayan bir istisna tüm süreci çöktürebilir (sorun #1). Kullanımdan kaldırılmış context.done() yönteminin geri çağırımın kapsamı dışında çağrılması, dosya okunmadan önce işlevin tamamlandığına işaret edebilir (problem #2). Bu örnekte, context.done()'nün çok erken çağrılması, Data from file: ile başlayan günlük girdilerinin eksik olmasına neden olur.

JavaScript

// NOT RECOMMENDED PATTERN
const fs = require("fs");

module.exports = function (context) {
  fs.readFile("./hello.txt", (err, data) => {
    if (err) {
      context.log.error("ERROR", err);
      // BUG #1: This will result in an uncaught exception that crashes the entire process
      throw err;
    }
    context.log(`Data from file: ${data}`);
    // context.done() should be called here
  });
  // BUG #2: Data is not guaranteed to be read before the Azure Function's invocation ends
  context.done();
};

TypeScript

// NOT RECOMMENDED PATTERN
import { AzureFunction, Context } from "@azure/functions";
import * as fs from "fs";

const trigger1: AzureFunction = function (context: Context): void {
  fs.readFile("./hello.txt", (err, data) => {
    if (err) {
      context.log.error("ERROR", err);
      // BUG #1: This will result in an uncaught exception that crashes the entire process
      throw err;
    }
    context.log(`Data from file: ${data}`);
    // context.done() should be called here
  });
  // BUG #2: Data is not guaranteed to be read before the Azure Function's invocation ends
  context.done();
};

export default trigger1;

Bu iki sorundan kaçınmanıza yardımcı olmak için async ve await anahtar kelimelerini kullanın. Node.js ekosistemindeki çoğu API artık bir şekilde vaatleri destekliyor. Örneğin, 14. sürümden itibaren Node.js, geri çağrı API'sinin fs/promises yerine bir fs API sağlar.

Aşağıdaki örnekte, işlev yürütmesi sırasında oluşturulan işlenmeyen özel durumlar yalnızca özel durumu tetikleyen tek tek çağrıda başarısız olur. anahtar sözcüğü, await izleyen readFile adımların yalnızca tamamlandıktan sonra yürütülmesi anlamına gelir.

JavaScript

// Recommended pattern
const { app } = require('@azure/functions');
const fs = require('fs/promises');

app.http('httpTriggerGoodAsync', {
    methods: ['GET', 'POST'],
    authLevel: 'anonymous',
    handler: async (request, context) => {
        try {
            const fileData = await fs.readFile('./helloWorld.txt');
            return { body: fileData };
        } catch (err) {
            context.error(err);
            // This rethrown exception will only fail the individual invocation, instead of crashing the whole process
            throw err;
        }
    },
});

TypeScript

// Recommended pattern
import { app, HttpRequest, HttpResponseInit, InvocationContext } from '@azure/functions';
import * as fs from 'fs/promises';

export async function httpTriggerGoodAsync(
    request: HttpRequest,
    context: InvocationContext
): Promise<HttpResponseInit> {
    try {
        const fileData = await fs.readFile('./helloWorld.txt');
        return { body: fileData };
    } catch (err) {
        context.error(err);
        // This rethrown exception will only fail the individual invocation, instead of crashing the whole process
        throw err;
    }
}

app.http('httpTriggerGoodAsync', {
    methods: ['GET', 'POST'],
    authLevel: 'anonymous',
    handler: httpTriggerGoodAsync,
});

async ve await kullandığınızda, context.done() geri çağrısını çağırmanız gerekmez.

JavaScript

// Recommended pattern
const fs = require("fs/promises");

module.exports = async function (context) {
  let data;
  try {
    data = await fs.readFile("./hello.txt");
  } catch (err) {
    context.log.error("ERROR", err);
    // This rethrown exception will be handled by the Functions Runtime and will only fail the individual invocation
    throw err;
  }
  context.log(`Data from file: ${data}`);
};

TypeScript

// Recommended pattern
import { AzureFunction, Context } from "@azure/functions";
import * as fs from "fs/promises";

const trigger1: AzureFunction = async function (
  context: Context
): Promise<void> {
  let data: Buffer;
  try {
    data = await fs.readFile("./hello.txt");
  } catch (err) {
    context.log.error("ERROR", err);
    // This rethrown exception will be handled by the Functions Runtime and will only fail the individual invocation
    throw err;
  }
  context.log(`Data from file: ${data}`);
};

export default trigger1;

Sorun giderme

Node.js Sorun Giderme kılavuzuna bakın.

Sonraki adımlar

Daha fazla bilgi edinmek için aşağıdaki kaynaklara bakın:

• Azure İşlevleri için en iyi uygulamalar
• Azure İşlevleri geliştirici başvurusu
• Azure İşlevleri tetikleyicileri ve bağlamaları