Бессерверный JavaScript: Разработка масштабируемых API с AWS Lambda

exports.handler = async (event, context) => {
  // Логика функции
  return {
    statusCode: 200,
    body: JSON.stringify({ message: "Hello, World!" }),
  };
};

// Пример политики IAM для Lambda функции в формате JSON
{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Allow",
      "Action": [
        "dynamodb:GetItem",
        "dynamodb:Query"
      ],
      "Resource": "arn:aws:dynamodb:region:account-id:table/my-table"
    },
    {
      "Effect": "Allow",
      "Action": [
        "sqs:SendMessage"
      ],
      "Resource": "arn:aws:sqs:region:account-id:my-queue"
    }
  ]
}

// Использование переменных окружения в коде функции
exports.handler = async (event) => {
  // API_KEY хранится в зашифрованных переменных окружения
  const apiKey = process.env.API_KEY;
  
  // Использование API ключа для внешнего запроса
  const response = await fetch('https://api.example.com/data', {
    headers: {
      'Authorization': [INLINE]Bearer ${apiKey}[/INLINE]
    }
  });
  
  // Обработка ответа
  const data = await response.json();
  return data;
};

// Вызов другой Lambda функции из JavaScript
const AWS = require('aws-sdk');
const lambda = new AWS.Lambda();
 
exports.handler = async (event) => {
  const params = {
    FunctionName: 'my-other-function',
    InvocationType: 'RequestResponse',
    Payload: JSON.stringify({ data: 'some data' })
  };
  
  const result = await lambda.invoke(params).promise();
  return JSON.parse(result.Payload);
};

// Пример Lambda авторизатора для API Gateway
exports.handler = async (event) => {
  const token = event.authorizationToken;
  
  try {
    // Проверка токена (может включать вызов внешних сервисов)
    const decodedToken = verifyToken(token);
    
    // Формирование политики доступа
    const policyDocument = {
      Version: '2012-10-17',
      Statement: [
        {
          Action: 'execute-api:Invoke',
          Effect: decodedToken ? 'Allow' : 'Deny',
          Resource: event.methodArn
        }
      ]
    };
    
    return {
      principalId: decodedToken?.sub || 'anonymous',
      policyDocument,
      context: {
        // Дополнительные данные, которые будут переданы целевой Lambda
        userId: decodedToken?.sub
      }
    };
  } catch (err) {
    // В случае ошибки при проверке токена запрещаем доступ
    return {
      principalId: 'anonymous',
      policyDocument: {
        Version: '2012-10-17',
        Statement: [
          {
            Action: 'execute-api:Invoke',
            Effect: 'Deny',
            Resource: event.methodArn
          }
        ]
      }
    };
  }
};

exports.handler = async (event) => {
  const name = event.queryStringParameters?.name || "гость";
  
  return {
    statusCode: 200,
    headers: {
      "Content-Type": "application/json"
    },
    body: JSON.stringify({
      message: `Привет, ${name}!`,
      timestamp: new Date().toISOString()
    })
  };
};

// webpack.config.js
const path = require('path');
 
module.exports = {
  target: 'node',
  mode: 'production',
  entry: './index.js',
  output: {
    path: path.resolve(__dirname, 'dist'),
    filename: 'index.js',
    libraryTarget: 'commonjs2'
  },
  // Исключаем AWS SDK из бандла, так как он доступен в среде Lambda
  externals: ['aws-sdk']
};

exports.handler = async (event) => {
  // Получаем параметры запроса
  const page = parseInt(event.queryStringParameters?.page || '1');
  const limit = parseInt(event.queryStringParameters?.limit || '10');
  
  try {
    // Здесь логика получения данных (например, из DynamoDB)
    const users = await fetchUsers(page, limit);
    
    return {
      statusCode: 200,
      headers: {
        "Content-Type": "application/json"
      },
      body: JSON.stringify({
        users,
        pagination: {
          page,
          limit,
          totalPages: Math.ceil(users.total / limit)
        }
      })
    };
  } catch (error) {
    console.error('Error fetching users:', error);
    
    return {
      statusCode: 500,
      headers: {
        "Content-Type": "application/json"
      },
      body: JSON.stringify({
        error: "Произошла ошибка при получении данных"
      })
    };
  }
};

const AWS = require('aws-sdk');
const dynamoDB = new AWS.DynamoDB.DocumentClient();
 
// Функция для получения пользователя по ID
async function getUser(userId) {
  const params = {
    TableName: 'Users',
    Key: {
      id: userId
    }
  };
  
  try {
    const result = await dynamoDB.get(params).promise();
    return result.Item;
  } catch (error) {
    console.error('Error getting user:', error);
    throw error;
  }
}
 
// Lambda-функция
exports.handler = async (event) => {
  const userId = event.pathParameters?.id;
  
  if (!userId) {
    return {
      statusCode: 400,
      body: JSON.stringify({ error: 'ID пользователя не указан' })
    };
  }
  
  try {
    const user = await getUser(userId);
    
    if (!user) {
      return {
        statusCode: 404,
        body: JSON.stringify({ error: 'Пользователь не найден' })
      };
    }
    
    return {
      statusCode: 200,
      body: JSON.stringify(user)
    };
  } catch (error) {
    return {
      statusCode: 500,
      body: JSON.stringify({ error: 'Внутренняя ошибка сервера' })
    };
  }
};

const { Pool } = require('pg');
 
// Соединение инициализируется один раз, при загрузке модуля
const pool = new Pool({
  host: process.env.DB_HOST,
  user: process.env.DB_USER,
  password: process.env.DB_PASSWORD,
  database: process.env.DB_NAME,
});
 
// Проверяем соединение при инициализации
let isConnected = false;
pool.connect()
  .then(() => {
    isConnected = true;
    console.log('Соединение с базой данных установлено');
  })
  .catch(err => {
    console.error('Ошибка подключения к базе данных:', err);
  });
 
exports.handler = async (event) => {
  // Используем существующее соединение
  if (!isConnected) {
    await pool.connect();
    isConnected = true;
  }
  
  // Код для работы с базой данных
  const result = await pool.query('SELECT * FROM users LIMIT 10');
  
  return {
    statusCode: 200,
    body: JSON.stringify(result.rows)
  };
};

exports.handler = async (event) => {
  // event.Records содержит массив сообщений из SQS
  const records = event.Records;
  
  for (const record of records) {
    try {
      // Получаем тело сообщения
      const messageBody = JSON.parse(record.body);
      
      // Обрабатываем сообщение в зависимости от его типа
      switch (messageBody.type) {
        case 'USER_REGISTERED':
          await sendWelcomeEmail(messageBody.user);
          break;
        case 'ORDER_PLACED':
          await processOrder(messageBody.order);
          break;
        default:
          console.warn(`Неизвестный тип сообщения: ${messageBody.type}`);
      }
    } catch (error) {
      // Логируем ошибку, но продолжаем обработку других сообщений
      console.error('Ошибка обработки сообщения:', error);
      console.error('Проблемное сообщение:', record.body);
    }
  }
  
  // Возвращаем успешный результат
  return {
    batchItemFailures: [] // Если нужно отметить конкретные сообщения как необработанные
  };
};
 
async function sendWelcomeEmail(user) {
  // Логика отправки письма
  console.log(`Отправка приветственного письма для ${user.email}`);
}
 
async function processOrder(order) {
  // Логика обработки заказа
  console.log(`Обработка заказа №${order.id} на сумму ${order.total}`);
}

exports.handler = async (event) => {
  // event.Records содержит записи из Kinesis
  for (const record of event.Records) {
    // Данные закодированы в Base64
    const payload = Buffer.from(record.kinesis.data, 'base64').toString('utf-8');
    
    try {
      const data = JSON.parse(payload);
      
      // Обработка данных
      await processMetric(data);
      
    } catch (error) {
      console.error('Ошибка обработки записи Kinesis:', error);
    }
  }
};
 
async function processMetric(data) {
  // Логика обработки метрики
  console.log(`Обработка метрики: ${data.metricName}, значение: ${data.value}`);
  
  // Например, сохранение в базу данных или агрегация
}

// Для асинхронного вызова Lambda можно настроить обработку ошибок
const AWS = require('aws-sdk');
const lambda = new AWS.Lambda();
 
exports.handler = async (event) => {
  const params = {
    FunctionName: 'target-function',
    InvocationType: 'Event', // Асинхронный вызов
    Payload: JSON.stringify({
      data: 'some-data'
    })
  };
  
  try {
    await lambda.invoke(params).promise();
    return { success: true };
  } catch (error) {
    console.error('Ошибка вызова Lambda:', error);
    return { success: false, error: error.message };
  }
};

// Пример идемпотентной обработки платежа
exports.handler = async (event) => {
  const { paymentId, amount } = JSON.parse(event.Records[0].body);
  
  // Проверяем, не был ли платеж уже обработан
  const existingPayment = await checkPaymentExists(paymentId);
  
  if (existingPayment) {
    console.log(`Платеж ${paymentId} уже был обработан ранее, пропускаем`);
    return { success: true };
  }
  
  // Обрабатываем платеж
  await processPayment(paymentId, amount);
  
  // Сохраняем запись о успешной обработке
  await markPaymentAsProcessed(paymentId);
  
  return { success: true };
};

// Пример конфигурации в serverless.yml
provider:
  name: aws
  memorySize: 1024 // Выделение 1 ГБ памяти также дает больше CPU

// Настройка в CloudFormation:
Resources:
  MyLambdaFunction:
    Type: AWS::Lambda::Function
    Properties:
      ...
 
  MyProvisionedConcurrency:
    Type: AWS::Lambda::ProvisionedConcurrencyConfig
    Properties:
      FunctionName: !Ref MyLambdaFunction
      ProvisionedConcurrentExecutions: 5
      Qualifier: LIVE

// Вместо этого
const AWS = require('aws-sdk');
const s3 = new AWS.S3();
const dynamodb = new AWS.DynamoDB.DocumentClient();
 
// Используйте это
const { S3, DynamoDB } = require('aws-sdk');
const s3 = new S3();
const dynamodb = new DynamoDB.DocumentClient();
 
// Или еще лучше, импортируйте только нужные сервисы
// Например, если вам нужен только S3:
const { S3 } = require('aws-sdk');
const s3 = new S3();

// Использование esbuild для оптимизации пакета Lambda
const esbuild = require('esbuild');
 
esbuild.build({
  entryPoints: ['index.js'],
  bundle: true,
  minify: true,
  sourcemap: false,
  platform: 'node',
  target: ['node14'],
  outfile: 'dist/index.js',
  external: ['aws-sdk'], // AWS SDK доступен в среде Lambda
}).catch(() => process.exit(1));

// Вместо последовательного выполнения
async function getDataSequential(userId) {
  const userData = await getUserData(userId);
  const userOrders = await getUserOrders(userId);
  const userPreferences = await getUserPreferences(userId);
  
  return { userData, userOrders, userPreferences };
}
 
// Используйте параллельное выполнение
async function getDataParallel(userId) {
  const [userData, userOrders, userPreferences] = await Promise.all([
    getUserData(userId),
    getUserOrders(userId),
    getUserPreferences(userId)
  ]);
  
  return { userData, userOrders, userPreferences };
}

// Не эффективно: множественные запросы к DynamoDB
async function getMultipleItemsInefficient(ids) {
  const results = [];
  
  for (const id of ids) {
    const params = {
      TableName: 'MyTable',
      Key: { id }
    };
    
    const result = await dynamodb.get(params).promise();
    if (result.Item) results.push(result.Item);
  }
  
  return results;
}
 
// Оптимизировано: один запрос BatchGetItem
async function getMultipleItemsOptimized(ids) {
  const params = {
    RequestItems: {
      'MyTable': {
        Keys: ids.map(id => ({ id }))
      }
    }
  };
  
  const result = await dynamodb.batchGet(params).promise();
  return result.Responses.MyTable || [];
}

// Пример с использованием MessagePack
const msgpack = require('msgpack');
 
exports.handler = async (event) => {
  // Получаем данные
  const data = { /* большой объект данных */ };
  
  // Сериализуем в компактный бинарный формат
  const binaryData = msgpack.pack(data);
  
  // Кодируем в Base64 для передачи по HTTP
  const base64Data = Buffer.from(binaryData).toString('base64');
  
  return {
    statusCode: 200,
    headers: {
      'Content-Type': 'application/octet-stream'
    },
    body: base64Data,
    isBase64Encoded: true
  };
};

// Простой кэш с временем жизни (TTL)
const cache = {};
 
function getCachedData(key, ttlMs, fetchFunction) {
  const now = Date.now();
  
  if (cache[key] && cache[key].expiry > now) {
    console.log(`Используем кэшированные данные для ключа ${key}`);
    return Promise.resolve(cache[key].data);
  }
  
  console.log(`Получаем свежие данные для ключа ${key}`);
  return fetchFunction().then(data => {
    cache[key] = {
      data,
      expiry: now + ttlMs
    };
    return data;
  });
}
 
exports.handler = async (event) => {
  const userId = event.pathParameters?.userId;
  
  const userData = await getCachedData(
    [INLINE]user_${userId}[/INLINE],
    60000, // TTL: 1 минута
    () => fetchUserFromDatabase(userId)
  );
  
  return {
    statusCode: 200,
    body: JSON.stringify(userData)
  };
};

# Пример настройки кэширования в Terraform
resource "aws_api_gateway_stage" "example" {
  rest_api_id = aws_api_gateway_rest_api.example.id
  stage_name  = "prod"
  
  cache_cluster_enabled = true
  cache_cluster_size    = "0.5"  # Размер кэша в ГБ (возможные значения: 0.5, 1.6, 6.1, 13.5, 28.4, 58.2, 118, 237)
}
 
# Настройка кэширования для конкретного метода
resource "aws_api_gateway_method_settings" "example" {
  rest_api_id = aws_api_gateway_rest_api.example.id
  stage_name  = aws_api_gateway_stage.example.stage_name
  method_path = "*/*"  # Можно указать конкретный путь, например "resource/GET"
  
  settings {
    cache_data_encrypted      = true
    cache_ttl_in_seconds      = 300  # Время жизни кэша (5 минут)
    caching_enabled           = true
  }
}

// Включение X-Ray трассировки в Lambda
const AWSXRay = require('aws-xray-sdk-core');
const AWS = AWSXRay.captureAWS(require('aws-sdk'));
 
// Теперь все вызовы AWS сервисов будут трассироваться
const dynamoDB = new AWS.DynamoDB.DocumentClient();

const AWS = require('aws-sdk');
const cloudwatch = new AWS.CloudWatch();
 
async function sendMetric(name, value, unit = 'Count') {
  const params = {
    MetricData: [
      {
        MetricName: name,
        Value: value,
        Unit: unit,
        Dimensions: [
          {
            Name: 'FunctionName',
            Value: process.env.AWS_LAMBDA_FUNCTION_NAME
          }
        ],
        Timestamp: new Date()
      }
    ],
    Namespace: 'MyApplicationMetrics'
  };
  
  return cloudwatch.putMetricData(params).promise();
}
 
exports.handler = async (event) => {
  const startTime = process.hrtime();
  
  try {
    // Бизнес-логика
    const result = await processData(event);
    
    // Отправляем метрику успешного выполнения
    await sendMetric('SuccessfulExecution', 1);
    
    // Измеряем время выполнения
    const [seconds, nanoseconds] = process.hrtime(startTime);
    const duration = seconds * 1000 + nanoseconds / 1000000;
    await sendMetric('ProcessingTime', duration, 'Milliseconds');
    
    return result;
  } catch (error) {
    // Отправляем метрику ошибки
    await sendMetric('FailedExecution', 1);
    throw error;
  }
};

const AWS = require('aws-sdk');
const sharp = require('sharp');
const s3 = new AWS.S3();
 
exports.handler = async (event) => {
  // Получаем информацию о загруженном файле
  const bucket = event.Records[0].s3.bucket.name;
  const key = decodeURIComponent(event.Records[0].s3.object.key.replace(/\+/g, ' '));
  
  // Игнорируем уже обработанные файлы
  if (key.includes('thumbnail_') || key.includes('watermark_')) {
    console.log('Файл уже обработан, пропускаем');
    return;
  }
  
  try {
    // Получаем изображение из S3
    const imageData = await s3.getObject({ Bucket: bucket, Key: key }).promise();
    
    // Создаём миниатюру
    const thumbnail = await sharp(imageData.Body)
      .resize(200, 200, { fit: 'inside' })
      .toBuffer();
    
    // Создаём версию с водяным знаком
    const watermark = await sharp(imageData.Body)
      .composite([{
        input: Buffer.from('<svg>...</svg>'), // Водяной знак в формате SVG
        gravity: 'southeast'
      }])
      .toBuffer();
    
    // Загружаем обработанные изображения обратно в S3
    await Promise.all([
      s3.putObject({
        Bucket: bucket,
        Key: [INLINE]thumbnail_${key}[/INLINE],
        Body: thumbnail,
        ContentType: imageData.ContentType
      }).promise(),
      s3.putObject({
        Bucket: bucket,
        Key: [INLINE]watermark_${key}[/INLINE],
        Body: watermark,
        ContentType: imageData.ContentType
      }).promise()
    ]);
    
    console.log(`Успешно обработано изображение: ${key}`);
    
  } catch (error) {
    console.error(`Ошибка обработки ${key}: ${error.message}`);
    throw error;
  }
};

const AWS = require('aws-sdk');
const { v4: uuidv4 } = require('uuid');
const dynamoDB = new AWS.DynamoDB.DocumentClient();
const sns = new AWS.SNS();
 
exports.handler = async (event) => {
  // Парсим тело запроса
  const body = JSON.parse(event.body);
  const { amount, cardToken, customerId } = body;
  
  // Идентификатор транзакции для идемпотентности
  const transactionId = body.transactionId || uuidv4();
  
  try {
    // Проверяем, не обработана ли уже транзакция
    const existingTx = await dynamoDB.get({
      TableName: 'Transactions',
      Key: { id: transactionId }
    }).promise();
    
    if (existingTx.Item) {
      return {
        statusCode: 200,
        body: JSON.stringify({
          success: true,
          transactionId,
          message: 'Транзакция уже была обработана',
          status: existingTx.Item.status
        })
      };
    }
    
    // Обрабатываем платеж через платежный шлюз
    // В реальности здесь был бы код интеграции с Stripe, PayPal и т.д.
    const paymentResult = await processPayment(amount, cardToken);
    
    // Сохраняем результат в базу данных
    await dynamoDB.put({
      TableName: 'Transactions',
      Item: {
        id: transactionId,
        customerId,
        amount,
        status: paymentResult.status,
        processorId: paymentResult.id,
        createdAt: new Date().toISOString()
      }
    }).promise();
    
    // Отправляем уведомление о платеже
    await sns.publish({
      TopicArn: process.env.PAYMENT_NOTIFICATION_TOPIC,
      Message: JSON.stringify({
        transactionId,
        customerId,
        amount,
        status: paymentResult.status
      })
    }).promise();
    
    return {
      statusCode: 200,
      body: JSON.stringify({
        success: true,
        transactionId,
        status: paymentResult.status
      })
    };
    
  } catch (error) {
    console.error(`Ошибка при обработке платежа: ${error.message}`);
    
    // В случае ошибки сохраняем информацию о неудачной попытке
    await dynamoDB.put({
      TableName: 'Transactions',
      Item: {
        id: transactionId,
        customerId,
        amount,
        status: 'ERROR',
        error: error.message,
        createdAt: new Date().toISOString()
      }
    }).promise();
    
    return {
      statusCode: 500,
      body: JSON.stringify({
        success: false,
        message: 'Не удалось обработать платеж',
        transactionId
      })
    };
  }
};

// Функция запуска процесса
exports.startProcessing = async (event) => {
  const { dataId } = JSON.parse(event.body);
  
  // Запускаем Step Functions
  const stepFunctions = new AWS.StepFunctions();
  const result = await stepFunctions.startExecution({
    stateMachineArn: process.env.STATE_MACHINE_ARN,
    input: JSON.stringify({ dataId })
  }).promise();
  
  return {
    statusCode: 202, // Accepted
    body: JSON.stringify({
      message: 'Процесс начат',
      executionArn: result.executionArn
    })
  };
};
 
// Одна из функций в процессе
exports.processChunk = async (event) => {
  const { dataId, chunkNumber, totalChunks } = event;
  
  // Обработка одной части данных
  await processDataChunk(dataId, chunkNumber);
  
  if (chunkNumber < totalChunks) {
    // Возвращаем результат для следующей итерации
    return {
      dataId,
      chunkNumber: chunkNumber + 1,
      totalChunks
    };
  } else {
    // Обработка завершена
    return {
      dataId,
      status: 'completed'
    };
  }
};

// serverless.yml
provider:
  name: aws
  runtime: nodejs14.x
 
layers:
  commonLibs:
    path: layers/common
    description: Общие библиотеки для всех функций
 
functions:
  api:
    handler: src/api.handler
    layers:
      - {Ref: CommonLibsLambdaLayer}
    package:
      individually: true
      exclude:
        - node_modules/[B]
        - layers/[/B]
        - package.json
        - package-lock.json
      include:
        - src/api.js

const serverless = require('serverless-http');
const express = require('express');
const app = express();
 
// Определяем маршруты
app.get('/users', async (req, res) => {
  // Логика получения пользователей
  res.json({ users: [...] });
});
 
app.post('/users', async (req, res) => {
  // Логика создания пользователя
  res.json({ success: true, userId: '123' });
});
 
// Экспортируем обработчик для Lambda
module.exports.handler = serverless(app);

// Было в монолите
const sessions = {};
 
app.get('/login', (req, res) => {
  const sessionId = generateId();
  sessions[sessionId] = { userId: req.body.userId };
  res.cookie('sessionId', sessionId);
  res.redirect('/dashboard');
});
 
// Стало в бессерверной версии
const AWS = require('aws-sdk');
const dynamoDB = new AWS.DynamoDB.DocumentClient();
 
app.get('/login', async (req, res) => {
  const sessionId = generateId();
  await dynamoDB.put({
    TableName: 'Sessions',
    Item: {
      sessionId,
      userId: req.body.userId,
      expiresAt: Math.floor(Date.now() / 1000) + 86400 // 24 часа
    }
  }).promise();
  
  res.cookie('sessionId', sessionId);
  res.redirect('/dashboard');
});