Node Functions 開発ガイド

Ethan Mercer

30 分読む

Spt 3, 2025

Node Functionsとは何ですか？

Node FunctionsはEdgeOneの包括的なサーバーレス関数ソリューションであり、開発者にシームレスな動的バックエンド機能を提供するために設計されています。プロジェクトの/node-functions ディレクトリ内にNode関数を作成するだけで、コードは自動的に強力なNode.jsベースのAPIエンドポイントに変換されます。

これらのエンドポイントは、データベースクエリ、サードパーティAPIの統合、フォーム送信、データ処理タスクなど、幅広いバックエンド操作を効率的に処理できます—すべてサーバー管理の複雑さを排除しながら。このサーバーレスアプローチにより、Node Functionsはスケーラブルでモダンなアプリケーションを構築するための完璧な基盤となります。

Node Functions統合の主な利点

フロントエンドとバックエンドのコード管理を統一した真のフルスタック開発を体験できます。 フロントエンドの静的アセットとバックエンドの関数ロジックを単一のGitリポジトリ内に配置し、構成、環境変数、デプロイメントパイプラインをシームレスに共有できます。「git push」コマンド一つでアプリケーションスタック全体をデプロイでき、開発ワークフローを大幅に合理化しながら、運用オーバーヘッドとメンテナンスの複雑さを最小限に抑えます。

膨大なnpmエコシステムの力をあなたの指先で活用できます。 データベースドライバー、ユーティリティライブラリ、SDKを含む何百万ものnpmパッケージをサーバーレス関数にシームレスに統合できます。この豊かなエコシステムにより、開発者は既存のソリューションを一から再構築する代わりに、革新的なビジネスロジックの作成に集中できます。

Node Functionsの10の重要なユースケースと機能

Node Functionsは従来のCRUD操作を超えて、開発者が高度なスケジュールタスクの実行、安全な決済処理、リアルタイム通知の配信、そして幅広い高度な機能の実装を可能にします。以下に10の最も実用的なユースケースを紹介します—それぞれがプロジェクトの機能とユーザー体験に変革的な価値と測定可能な改善をもたらすように設計されています。

以下のサンプルコードの完全な構造を含むリポジトリをご覧ください。

APIリクエスト処理と管理

APIリクエスト処理は、現代のWebアプリケーションの基礎的な要素として、様々なHTTPリクエスト（GET、POST、PUT、DELETE）をシームレスに受信し応答します。この重要な機能は、フロントエンドアプリケーション向けの堅牢なデータインターフェースサービスを提供し、フロントエンドとバックエンドのデータ通信のための安全で効率的な橋渡しを確立します。

以下に、合理化されたGETリクエスト実装の例を示します。

export async function onRequest(context) {
  const { request } = context;
  
  try {
    if (request.method === 'GET') {
      const users = [
        { id: 1, name: 'John', email: 'john@example.com' },
      ];
      return new Response(JSON.stringify(users), {
        headers: { 'Content-Type': 'application/json' }
      });
    }
    
    return new Response(JSON.stringify({ error: 'Resource not found' }), {
      status: 404,
      headers: { 'Content-Type': 'application/json' }
    });
  } catch (error) {
    // Handle errors
    return new Response(JSON.stringify({ error: 'Internal server error' }), {
      status: 500,
      headers: { 'Content-Type': 'application/json' }
    });
  }
}

OpenAI APIサービスの統合

Node.js環境では、ゼロコンフィギュレーションセットアップで標準OpenAI SDKをシームレスに統合し、強力なAI機能への即時アクセスを提供します。環境変数を活用してAPIキーを安全に管理することで、コードの柔軟性とデプロイの敏捷性を維持しながら、企業レベルのセキュリティ以下に、Deepseekテキスト生成モデル統合の例を示します。

import OpenAI from "openai";
import getRequestBody from '../getRequestBody.js';

export async function onRequest(context) {
  const { request } = context;
  
  try {
    // Parse request body
    const { prompt, maxTokens = 500 } = await getRequestBody(request);
    
    if (!prompt) {
      return new Response(JSON.stringify({ error: 'No prompt provided' }), { status: 400 });
    }
    
    // Initialize OpenAI client
    const openai = new OpenAI({
      baseURL: process.env.OPENAI_API_URL,
      apiKey: process.env.OPENAI_API_KEY
    });
    
    // Call API to generate text
    const completion = await openai.chat.completions.create({
      model: "deepseek-ai/DeepSeek-R1-0528",
      messages: [
        { role: "system", content: "You are a helpful AI assistant." },
        { role: "user", content: prompt }
      ],
      max_tokens: maxTokens
    });
    
    // Return generated text
    return new Response(JSON.stringify({
      generatedText: completion.choices[0].message.content
    }), {
      headers: { 'Content-Type': 'application/json' }
    });
    
  } catch (error) {
    return new Response(JSON.stringify({ error: error.message }), { status: 500 });
  }
}

データベースの統合と接続

関数内で様々なデータベース操作をシームレスに統合し、主要なデータベース接続とCRUD操作をサポートします。サーバーレスアーキテクチャにより、データの永続性、リアルタイムクエリ、複雑なデータ処理ロジックを容易に実装でき、動的なアプリケーションに包括的なバックエンドデータサポートを提供します。

データベース操作については、完全なフルスタックデータベースデプロイメントテンプレートを提供しており、直接使用するか、テンプレートコードを参照してプロジェクトを開発することができます。

ID認証とセッション制御

JWT Tokenを通じて関数内でステートレス認証を実装します。ユーザー登録、ログイン検証、トークン生成と検証などの主要機能をサポートし、クラウドデータベースサービスと連携してユーザー情報を保存したり、SupabaseなどのサードパーティAuth機構と統合してユーザー管理開発を加速できます。

以下に、合理化されたログイン認証実装を示します。

const JWT_SECRET = process.env.JWT_SECRET;
const JWT_EXPIRES_IN = '24h';

function hashPassword(password) {
  return crypto.createHash('sha256').update(password).digest('hex');
}

function generateToken(payload) {
  return jwt.sign(payload, JWT_SECRET, { expiresIn: JWT_EXPIRES_IN });
}

export async function onRequest(context) {
  const { request } = context;
  
  try {
    return await handleLogin(request);
  } catch (error) {
    // errors handling
  }
}


async function handleLogin(request) {
  const data = await getRequestBody(request);
  const { email, password } = data;
  
  if (!email || !password) {
    ...
  }
  
  const user = users.find(u => u.email === email);
  if (!user) {
    ...
  }
  
  const hashedPassword = hashPassword(password);
  if (user.password !== hashedPassword) {
    ...
  }
  
  const token = generateToken({ userId: user.id });
  
  const { password: _, ...userWithoutPassword } = user;
  return new Response(JSON.stringify({
    message: 'Login successful',
    user: userWithoutPassword,
    token
  }), {
    headers: { 'Content-Type': 'application/json' }
  });
}

メール/プッシュ通知配信

Resend、Nodemailer、SendGrid、AWS SESなどのメールサービスプロバイダーAPIを通じて、関数内でメール配信を実装し、HTMLリッチテキスト、添付ファイル、テンプレートレンダリングなどの機能をサポートします。さらに、SMSやプッシュ通知を含むマルチチャネルメッセージングサービスを統合し、ユーザー登録確認、注文通知、システムアラートなどのシナリオに適しています。

以下にResendの実装例を示します。

export async function onRequest(context) {
  const { request } = context;
  const resend = new Resend(process.env.RESEND_API_KEY);


  try {
    const requestBody = await getRequestBody(request);
    
    // Validate request parameters
    if (!requestBody || !requestBody.email) {
      return new Response(JSON.stringify({ error: 'Missing email address' }), {
        status: 400,
        headers: { 'Content-Type': 'application/json' }
      });
    }
    
    const { email } = requestBody;
    const name = requestBody.name || 'User';
    const subject = requestBody.subject || 'Welcome to our service';
    const customMessage = requestBody.message || '';
    
    // Send email
    const data = await resend.emails.send({
      from: 'noreply@wenyiqing: [email],
      subject: subject,
      html: `
        <div style="font-family: sans-serif; max-width: 600px; margin: 0 auto;">
          <h2>Hello, ${name}!</h2>
          <p>Thank you for using our service.</p>
          ${customMessage ? `<p>${customMessage}</p>` : ''}
          <p>If you have any questions, please feel free to contact us.</p>
          <p>Best regards,<br>The Team</p>
        </div>
      `
    });
    if(data.error) {
      // errors handling
    }
    // Return success response({ success: true, messageId: data.id }), {
      status: 200,
      headers: { 'Content-Type': 'application/json' }
    });
  } catch (error) {
    // errors handling
  }
}

データフォーマット変換

サーバーレス関数内で強力な汎用フォーマット変換機能を解き放ちましょう。xml2js、csv-parser、xlsx、pdfkitなどの業界実証済みライブラリを含むNode.jsの広範な解析エコシステムの可能性を最大限に活用し、ファイル処理、API統合、企業レポーティングシナリオにまたがる複雑なデータワークフローを容易に調整できます。

標準化されたフォーマット変換APIを提供する専用のデータ変換マイクロサービスとしてデプロイし、フロントエンドアプリケーションや外部システムを強化しながら、クロスプラットフォームデータ交換の複雑さを大幅に削減します。

この合理化されたCSVからXLSXへの変換例をご覧ください。

import getRequestBody from '../getRequestBody.js';
import * as XLSX from 'xlsx';

function convertCsvToExcel(csvData, options = {}) {
  	// Data conversion logic
}const { request } = context;
  
  try {
    // Get CSV data from request body
    const requestBody = await getRequestBody(request);
    const csvData = requestBody;
    
    // Get options from URL parameters
    ...
    const options = {...};
    
    // Convert CSV to Excel
    const excelBuffer = convertCsvToExcel(csvData, options);
    
    // Return Excel file as downloadable
    const filename = params.get('filename') || 'data.xlsx';
    return new Response(excelBuffer, {
      status: 200,
      headers: {
        'Content-Type': 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
        'Content-Disposition': `attachment; filename="${filename}"`
      }
    });
  } catch (error) {
    // Simple error response
    return new Response(JSON.stringify({ error: error.message }), { status: 400 });
  }
} omitted for brevity
// In production, you would validate CSV format before conversion

Webhookイベント処理

イベント駆動型アーキテクチャのパラダイムとシームレスに整合するように設計された、サーバーレス関数内にエンタープライズグレードの高可用性Webhookエンドポイントを構築します。GitHub、Stripeなどの主要プラットフォームからのリアルタイムイベントストリーミングを可能にしながら、暗号署名検証を実装して認証されたリクエスト元と防弾のセキュリティプロトコルを保証します。

Webhook処理機能を示すGitHubプッシュイベント統合の例をご覧ください。

export async function onRequest(context) {
  const { request, env } = context;
  try {
    const webhookSecret = env.GITHUB_WEBHOOK_SECRET;
    
    const clonedRequest = cloneRequest(request);
    const isSignatureValid = await verifyGitHubSignature(clonedRequest, webhookSecret);
    
    if (!isSignatureValid) {
      // errors handling
    }
    // Get event type
    const eventType = request.headers['x-github-event'];
    if (!eventType) {
      // errors handling
    }
    // Parse request body
    const payload = await await getRequestBody(request);
    // Process based on event type
    let result;
    switch (eventType) {
      case 'ping':
        result = { status: 'success', message: 'Pong! Webhook configured successfully' };
        break;
      case 'push':
        result = handlePushEvent(payload);
        break;
      case 'pull_request':
        result = handlePullRequestEvent(payload);
        break;
      case 'issues':
        result = handleIssueEvent(payload);
        break;
      default:
        result = { 
          status: 'received', 
          message: `Received ${eventType} event, but no handler implemented` 
        };
    }
    
    //.stringify(result), {
      status: 200,
      headers: {
        'Content-Type': 'application/json'
      }
    });
  } catch (error) {
    // errors handling
  }
}

ファイルアップロードと処理サービス

サーバーレス関数内に高性能のファイルアップロードインフラストラクチャを構築し、画像、ビデオ、ドキュメントなどの多様なメディアタイプのための包括的なmultipart/form-data処理機能を特徴とします。MulterやBusboyなどの業界標準のミドルウェアソ洗練されたアップロードストリーム解析を調整します。Tencent Cloud COS、AWS S3、Alibaba Cloud OSSなどの主要なクラウドストレージプラットフォームとシームレスに統合し、復元力のある永続ストレージソリューションを提供します。

このエンドツーエンドの実装を探索し、Node Functions アーキテクチャを通じてTencent Cloud COSと直接統合したシームレスなユーザーファイルアップロードを示します。

// COS Configuration (simplified)
const cos = new COS({...});

const MAX_FILE_SIZE = 100 * 1024 * 1024;

function generateSafeFilename(originalFilename, mimeType) {
	...
}

async function uploadToCOS(fileData, filename, mimeType) {
  // Tencent Cloud COS upload logic...
}

export async function onRequest(context) {
  const req = context.request;

  try {
    return new Promise((resolve, reject) => {
      const bb = busboy({ headers: req.headers });
      const uploadResults = [];
      
      // Process file fields
      bb.on('file', (fieldname, file, { filename, mimeType }) => {
        const chunks = [];
        let fileSize = 0;
        
        file.on('data', (data) => {
          chunks.push(data);
          fileSize += data.length;
          
          if (fileSize > MAX_FILE_SIZE) {
            file.resume(); // Stop receiving
          }
        });

        file.on('end', async () => {
          if (fileSize > MAX_FILE_SIZE) {
            return; // Skip oversized files
          }
          
          try {
            // Process and upload file
            const fileData = Buffer.concat(chunks);
            const safeFilename = generateSafeFilename(filename, mimeType);
            const result = await uploadToCOS(fileData, safeFilename, mimeType);
            
            uploadResults.push({
              fieldname,
              ...result
            });
          } catch (err) {
            console.error('Upload error:', err);
          }
        });
      });

      bb.on('finish', () => {stringify({
          success: true,
          files: uploadResults
        }), { status: 200 }));
      });

      req.pipe(bb);
    });
  } catch (error) {
    return new Response(JSON.stringify({ error: 'Upload failed' }), { status: 500 });
  }
}

画像と動画処理エンジン

サーバーレス関数内で業界をリードする画像処理ライブラリ—SharpとJimp—の可能性を最大限に活用し、精密なスケーリング、インテリジェントなクロッピング、動的ウォーターマーク、シームレスなフォーマット変換、適応型品質圧縮などの洗練された視覚変換を調整します。FFmpegとFluent-ffmpeg統合を通じて高度な動画処理機能をデプロイし、プロフェッショナルグレードの動画編集ワークフロー、高性能トランスコーディングパイプライン、インテリジェントなフレーム抽出、自動サムネイル生成システムを可能にします。

最適化された Node Functions アーキテクチャを通じたbase64画像取り込みを示すこの高度な例をご覧ください。

export async function onRequest(context) {
  const { request } = context;

  try {
    const requestBody = await getRequestBody(request);
    
    let base64Data = requestBody.image;
    if (base64Data.includes(';base64,')) {
      base64Data = base64Data.split(';base64,')[1];
    }
    
    const imageBuffer = Buffer.from(base64Data, 'base64');
    
    // Get watermark parameters
    const watermarkText = requestBody.text || 'Watermark Example';
    const opacity = parseFloat(requestBody.opacity || '0.5');
    const textColor = requestBody.textColor || 'white';
    const fontSize = parseInt(requestBody.fontSize || '36', 10);
    
    const imageInfo = await sharp(imageBuffer).metadata();
    const imageMimeType = `image/${imageInfo.format}`;
    
    const processedImageBuffer = await addTextWatermark(
      imageBuffer,
      watermarkText,
      opacity,
      textColor,
      fontSize
    );
    
    // Return processed image
    return new Response(processedImageBuffer, {
      status: 200,
      headers: { 'Content-Type': imageMimeType }
    });
  } catch (error) {
    // errors handling
  }
}

サーバー送信イベント

関数内にリアルタイム通信機能を構築し、Server-Sent Events（SSE）を通じて一方向データストリームプッシングを実装するか、WebSocketゲートウェイサービスと統合して双方向リアルタイム通信を実現します。

メッセージキュー（Redis Pub/Sub、Kafka、RabbitMQなど）を仲介として使用することで、関数は株価、スポーツスコア、注文ステータス、システムモニタリングなどのリアルタイムデータをサブスクライブしてプッシュできます。互換性要件のためのロングポーリングメカニズムをサポートし、関数チェーン呼び出しを通じてデータフィルタリング、集約、変換を実装してストリーム処理を行います。

以下は、SSEサーバーサイド機能の実装を示すコード例です。

const clients = new Set();

// Simulate message queue
const messageQueue = {
  subscribers: {},
  publish: function(channel, message) {
    ...
  },
  subscribe: function(channel, callback) {
    ...
  }
};

// Simulate stock data generator
function generateStockData() {
  ...
}

// Start simulated data publishing
let stockDataInterval;
function startStockDataSimulation() {
	// Send data every 2 seconds
	...
}

// Stop simulated data publishing
function stopStockDataSimulation() {
  if (stockDataInterval && clients.size === 0) {
    clearInterval(stockDataInterval);
    stockDataInterval = null;
  }
}

export async function onRequest(context) {
  const { request, env } = context;
  
  const url = new URL(request.url, 'http://www.example.com');
  const channel = url.searchParams.get('channel') || 'stocks';
  
  const responseStream = new TransformStream();
  const writer = responseStream.writable.getWriter();
  
  // Set SSE response headersresponseStream.readable, {
    headers: {
      'Content-Type': 'text/event-stream',
      'Cache-Control': 'no-cache',
      'Connection': 'keep-alive',
    }
  });
  
  // Create client object
  const clientId = Date.now().toString();
  const client = {
    id: clientId,
    writer
  };
  
  // Add client to connection collection
  clients.add(client);
  
  if (clients.size === 1) {
    startStockDataSimulation();
  }
  
  // Send connection success message
  const connectMessage = `event: connected\ndata: {"clientId":"${clientId}","message":"Connection successful"}\n\n`;
  await writer.write(new TextEncoder().encode(connectMessage));
  
  // unsubscribe = messageQueue.subscribe(channel, async (data) => {
    const eventData = `event: message\ndata: ${JSON.stringify(data)}\n\n`;
    await writer.write(new TextEncoder().encode(eventData));
  });
  
  // Listen for connection close
  context.waitUntil(
    (async () => {
      try {
        await request.signal.aborted;
      } catch (error) {
        // errors handling
      } finally {
        // Clean up resources
      }
    })()
  );
  
  return response;
}

このクライアント側の実装を使用して、シームレスな接続テスト用のリアルタイム通信インフラストラクチャを検証します。

const eventSource = new EventSource('/api/sse?channel=stocks');

// Listen for connection success event
eventSource.addEventListener('connected', (event) => {
  const data = JSON.parse(event.data);
  console.log('SSE connection successful:', data);
});

// Listen for message events
eventSource.addEventListener('message', (event) => {
  const stockData = JSON.parse(event.data);
  console.log('Received stock data:', stockData);
  // Update UI here
});

// Listen for errors
eventSource.onerror = (error) => {
  console.error('SSE connection error:', error);
  eventSource.close();
};

結論

Node Functions は現代のWeb開発パラダイムにおける進化の飛躍を体現しています。革命的なサーバーレスコンピューティングフレームワークを通じて、開発組織は従来のインフラストラクチャの制約を超越し—サーバープロビジョニングのオーバーヘッド、自動スケーリングの複雑さ、ロードバランシングのオーケストレーションを排除し—戦略的なビジネスロジックの実装とイノベーションの加速に集中することができます。

Node の機能は、合理化されたAPIマイクロサービスからAI統合、基盤となるデータ永続化アーキテクチャからリアルタイムイベントストリーミングインフラストラクチャ、イン