USER
User: const { gpt, gptweb } = require("./API/gpt");
const { dalle } = require("./API/dalle");
const { gpt4o } = require("./API/gpt4o");
const { gpt3 } = require("./API/gpt3.5");
const { prompts } = require("./API/gpt-prompts");
const { blackbox } = require("./API/blackbox");
const { qwen } = require("./API/qwen");
const { gemini } = require("./API/gemini");
const WebSocket = require('ws');
const Bottleneck = require('bottleneck');
const { stats, scheduleDailyReset, resetStatistics } = require('./stats'); // Импортируем модуль статистики
const fs = require('fs');
const path = require('path');
const Ajv = require('ajv');
// Создаем экземпляр Ajv (проверка входящей переписки на соответствие схеме)
const ajv = new Ajv();
// Объект для хранения действий и состояния каждого клиента
const clientActions = {};
// Объект для хранения ограничителей по каждому клиенту
const limiters = {};
// Замените на ваш домен
const allowedOrigin = 'http://gpt.loc';
// Создайте WebSocket-сервер
const wss = new WebSocket.Server({ port: 3000 });
wss.on('connection', (ws, req) => {
const urlParams = new URLSearchParams(req.url.split('?')[1]);
const userId = urlParams.get('token'); // Получаем UUID из URL
const userIP = req.socket.remoteAddress;
//console.log("IP-адрес - ", userIP, "Время подключения - ", new Date().toISOString());
const userHeaders = req.headers;
// Проверяем Origin
if (!checkOrigin(userHeaders.origin, ws)) {
return; // Если отклонено, выходим из обработчика
}
// Увеличиваем общий счетчик подключений
stats.totalConnections++;
console.log('Client connected with user ID:', userId, 'Домен - ', userHeaders.origin);
// Инициализируем состояние клиента, если его еще нет
if (!clientActions[userId]) {
clientActions[userId] = {
actions: [], // Массив для хранения действий
connected: true, // Статус подключения
};
}
else
clientActions[userId].connected = true;
if (!limiters[userId]) {
// Создаем экземпляр Bottleneck для каждого клиента (ограничение на количество запросов по Id)
limiters[userId] = new Bottleneck({
maxConcurrent: 1, // Максимальное количество одновременных задач
minTime: 1000, // Минимальное время между запросами в миллисекундах
highWater: 0 // Не разрешать в очереди больше 0 запросов (игнорировать)
});
}
ws.on('message', (message) => {
// Проверяем, является ли сообщение экземпляром Buffer
if (Buffer.isBuffer(message))
message = message.toString();
try {
// Преобразуем строку JSON обратно в объект
message = JSON.parse(message);
//Получаем историю чата из запроса
let messages = message.messages;
let model = message.model;
console.log('Модель - ', model);
// Выполняем валидацию сообщений
messages = validateMessages(messages);
// Проверяем, остались ли сообщения после валидации
if (messages.length === 0) {
const response = { code: 2, message: "Нет валидных сообщений для обработки." };
sendMessage(ws, response);
return;
}
// Урезаем последнее сообщение до 2000 символов, если оно от клиента
if (messages[messages.length - 1].role === 'user') {
messages[messages.length - 1].content = messages[messages.length - 1].content.substring(0, 2000000);
}
// Увеличиваем общий счетчик запросов
stats.totalRequests++;
// Используем Bottleneck для управления количеством запросов
limiters[userId].schedule(() => {
// Отправка запроса на сервер чата
if (model == 'gpt-4o')
return callGPT4o(messages, ws);
else if (model == 'gemini-pro')
return callGemini(messages, ws);
else if (model == 'qwen')
return callQwen(messages, ws);
else if (model == 'blackbox')
return callBlackbox(messages, ws);
else if (model == 'gpt-3.5-turbo')
return callGPT35Turbo(messages, ws);
}).catch(error => {
stats.totalIPBlocks++;
//console.error('Rate limit exceeded, message ignored:', error);
const response = { code: 2, message: "Превышен лимит запросов. Пожалуйста, попробуйте позже." };
// Отправка ответа клиенту
//sendMessage(ws, response);
});
} catch (error) {
console.error('Error parsing JSON:', error);
const response = { code: 2, message: "Произошла ошибка. Попробуйте еще раз."};
console.log(response);
// Отправка ответа клиенту
sendMessage(ws, response);
}
});
ws.on('close', () => {
clientActions[userId].connected = false; // Обновление статуса подключения
delete clientActions[userId]; // Удаление состояния клиента
delete limiters[userId]; // Удаление ограничителя для данного клиента
console.log('Client ',userId, ' disconnected');
});
});
// Запускаем планировщик для статистики
scheduleDailyReset();
// Очистка старых соединений раз в минуту (по желанию)
setInterval(() => {
Object.keys(clientActions).forEach(userId => {
if (!clientActions[userId].connected) {
delete clientActions[userId]; // Удаляем пользователя из памяти, если он отключен
delete limiters[userId];
}
});
}, 10 * 60 * 1000); // Очистка каждые 10 минут
function checkOrigin(origin, socket) {
if (origin !== allowedOrigin) {
console.log('Недопустимый домен. Соединение разорвано: ', origin);
socket.close(); // Закрываем соединение, если домен не разрешен
return false; // Возвращаем false для индикатора отклонения
}
return true; // Возвращаем true, если домен разрешен
}
// Отправляет ответ клиенту
function sendMessage(ws, message) {
if (ws.readyState === WebSocket.OPEN) {
ws.send(JSON.stringify(message));
} else {
console.warn(`Trying to send message to a closed WebSocket connection.`);
}
}
// Удаление из массива сообщений не соответствующих схеме
function validateMessages(messages) {
// Определяем схему для сообщений
const schema = {
type: 'object',
properties: {
role: { type: 'string' },
content: { type: 'string' }
},
required: ['role', 'content'],
additionalProperties: false
};
// Фильтруем массив, оставляя только корректные сообщения
return messages.filter(message => ajv.validate(schema, message));
}
console.log('WebSocket сервер запущен через порт 3000');
//============== ВЫЗОВ API МОДЕЛЕЙ =================================================
//==================================================================================
//==================================================================================
//==================================================================================
// GPT4o
async function callGPT4o(messages, ws) {
try {
let fullResponse = ""; // Переменная для результата
console.log('Запрос клиента:', messages[messages.length - 1]);
//throw new Error("Намеренная ошибка для тестирования catch");
gpt4o({
messages: messages,
markdown: false
}, (result) => {
// Обработка результата внутри колбэка
if (result.error) {
throw new Error(result.error); // Обрабатываем ошибку, если она есть
}
try {
if (!result.finish) {
// Запоминаем только последний ответ чата (он будет полный, промежуточные ответы - это накопления)
fullResponse = result.message || "";
//console.log(result);
} else {
// Если завершено, выводим полный ответ
let response = { code: 1, message: fullResponse};
console.log('Ответ чата: ', response);
// Отправка ответа клиенту
sendMessage(ws, response);
}
}
catch (callbackError) {
console.error('Error processing callback result:', callbackError);
let response = { code: 2, message: "Произошла ошибка. Попробуйте еще раз." };
// Отправка ответа клиенту
sendMessage(ws, response);
}
});
} catch (error) {
console.error('Error:', error);
let response = { code: 2, message: "Произошла ошибка. Попробуйте еще раз."};
// Отправка ответа клиенту
sendMessage(ws, response);
}
}
// GPT3.5-Turbo
async function callGPT35Turbo(messages, ws) {
try {
let fullResponse = ""; // Переменная для результата
console.log('Запрос клиента:', messages[messages.length - 1]);
//throw new Error("Намеренная ошибка для тестирования catch");
gpt3({
messages: messages,
markdown: false
}, (result) => {
// Обработка результата внутри колбэка
if (result.error) {
throw new Error(result.error); // Обрабатываем ошибку, если она есть
}
try {
if (!result.finish) {
// Запоминаем только последний ответ чата (он будет полный, промежуточные ответы - это накопления)
fullResponse = result.message || "";
//console.log(result);
} else {
// Если завершено, выводим полный ответ
let response = { code: 1, message: fullResponse};
console.log('Ответ чата: ', response);
// Отправка ответа клиенту
sendMessage(ws, response);
}
}
catch (callbackError) {
console.error('Error processing callback result:', callbackError);
let response = { code: 2, message: "Произошла ошибка. Попробуйте еще раз." };
// Отправка ответа клиенту
sendMessage(ws, response);
}
});
} catch (error) {
console.error('Error:', error);
let response = { code: 2, message: "Произошла ошибка. Попробуйте еще раз."};
// Отправка ответа клиенту
sendMessage(ws, response);
}
}
// Gemini
async function callGemini(messages, ws) {
try {
let fullResponse = ""; // Переменная для результата
console.log('Запрос клиента:', messages[messages.length - 1]);
//throw new Error("Намеренная ошибка для тестирования catch");
gemini({
messages: messages
}, (result) => {
// Обработка результата внутри колбэка
if (result.error) {
throw new Error(result.error); // Обрабатываем ошибку, если она есть
}
try {
if (!result.finish) {
// Запоминаем только последний ответ чата (он будет полный, промежуточные ответы - это накопления)
fullResponse = result.message || "";
//console.log(result);
} else {
// Если завершено, выводим полный ответ
let response = { code: 1, message: fullResponse};
console.log('Ответ чата: ', response);
// Отправка ответа клиенту
sendMessage(ws, response);
}
}
catch (callbackError) {
console.error('Error processing callback result:', callbackError);
let response = { code: 2, message: "Произошла ошибка. Попробуйте еще раз." };
// Отправка ответа клиенту
sendMessage(ws, response);
}
});
} catch (error) {
console.error('Error:', error);
let response = { code: 2, message: "Произошла ошибка. Попробуйте еще раз."};
// Отправка ответа клиенту
sendMessage(ws, response);
}
}
// Qwen
async function callQwen(messages, ws) {
try {
let fullResponse = ""; // Переменная для результата
console.log('Запрос клиента:', messages[messages.length - 1]);
//throw new Error("Намеренная ошибка для тестирования catch");
qwen({
messages: messages,
markdown: false
}, (result) => {
// Обработка результата внутри колбэка
if (result.error) {
throw new Error(result.error); // Обрабатываем ошибку, если она есть
}
try {
if (!result.finish) {
// Запоминаем только последний ответ чата (он будет полный, промежуточные ответы - это накопления)
fullResponse = result.message || "";
//console.log(result);
} else {
// Если завершено, выводим полный ответ
let response = { code: 1, message: fullResponse};
console.log('Ответ чата: ', response);
// Отправка ответа клиенту
sendMessage(ws, response);
}
}
catch (callbackError) {
console.error('Error processing callback result:', callbackError);
let response = { code: 2, message: "Произошла ошибка. Попробуйте еще раз." };
// Отправка ответа клиенту
sendMessage(ws, response);
}
});
} catch (error) {
console.error('Error:', error);
let response = { code: 2, message: "Произошла ошибка. Попробуйте еще раз."};
// Отправка ответа клиенту
sendMessage(ws, response);
}
}
// Blackbox
async function callBlackbox(messages, ws) {
try {
let fullResponse = ""; // Переменная для результата
console.log('Запрос клиента:', messages[messages.length - 1]);
//throw new Error("Намеренная ошибка для тестирования catch");
blackbox({
messages: messages,
markdown: false,
websearch: false,
llama: false
}, (result) => {
// Обработка результата внутри колбэка
if (result.error) {
throw new Error(result.error); // Обрабатываем ошибку, если она есть
}
try {
if (!result.finish) {
// Запоминаем только последний ответ чата (он будет полный, промежуточные ответы - это накопления)
fullResponse = result.message || "";
//console.log(result);
} else {
// Если завершено, выводим полный ответ
let response = { code: 1, message: fullResponse};
console.log('Ответ чата: ', response);
// Отправка ответа клиенту
sendMessage(ws, response);
}
}
catch (callbackError) {
console.error('Error processing callback result:', callbackError);
let response = { code: 2, message: "Произошла ошибка. Попробуйте еще раз." };
// Отправка ответа клиенту
sendMessage(ws, response);
}
});
} catch (error) {
console.error('Error:', error);
let response = { code: 2, message: "Произошла ошибка. Попробуйте еще раз."};
// Отправка ответа клиенту
sendMessage(ws, response);
}
}
//============== ВЫЗОВ API МОДЕЛЕЙ (КОНЕЦ) ======================
На мой сайт большая нагрузка, много клиентов. Нужно добавить балансировку для распределения нагрузки между серверами. Что тут сделать?
Assistant: добавления балансировки нагрузки между серверами, вы можете рассмотреть несколько подходов. Вот основные шаги и рекомендации, как это можно сделать:
### 1. **Использование балансировщика нагрузки**:
- **Аппаратный балансировщик нагрузки**: Если у вас есть ресурсы, вы можете использовать устройства типа F5 или аналогичные, которые предлагают функции балансировки нагрузки.
- **Программные решения**: Рассмотрите использование программных балансировщиков нагрузки, таких как NGINX или HAProxy. Они могут распределять входящие соединения между несколькими экземплярами вашего приложения на разных серверах.
### 2. **Настройка NGINX как балансировщика нагрузки**:
Если вы выберете NGINX, вот пример его настройки для балансировки нагрузки:
```nginx
http {
upstream app_servers {
server app_server_1:3000;
server app_server_2:3000;
server app_server_3:3000;
}
server {
listen 80;
location / {
proxy_pass http://app_servers;
proxy_http_version 1.1;
proxy_set_header Upgrade $http_upgrade;
proxy_set_header Connection 'upgrade';
proxy_set_header Host $host;
proxy_cache_bypass $http_upgrade;
}
}
}
```
В этом примере `app_server_1`, `app_server_2`, и `app_server_3` – это адреса ваших серверов, на которых развернуто приложение.
### 3. **Создание кластеров приложения**:
В случае Node.js вы можете использовать `cluster` или `pm2` для создания кластеров вашего приложения, что позволит задействовать все ядра вашего сервера.
### 4. **Использование Docker и Kubernetes**:
Если вы используете контейнеризацию, Kubernetes может помочь в автоматизации развертывания и настройки балансировщика нагрузки. Использование служб типа **LoadBalancer** в Kubernetes может автоматически выделить внешний IP и маршрутизировать трафик.
### 5. **Мониторинг и управление**:
- Следите за распределением нагрузки с помощью мониторинга. Инструменты как Prometheus, Grafana могут помочь в визуализации нагрузки и производительности.
- Имейте систему для отката, если один из серверов вызывает проблемы.
### 6. **Кэширование**:
Реализуйте кэширование для частых запросов. Это может помочь уменьшить нагрузку. Используйте такие решения, как Redis или Memcached.
### 7. **Подход с микросервисами**:
Если ваше приложение имеет множество различных функций, рассмотрите возможность его разбивки на микросервисы, которые могут быть разбросаны по различным серверам, каждый из которых хорошо подходит для его задачи.
### 8. **Backend API Gateway**:
Подумайте об использовании API Gateway для управления горизонтальной масштабируемостью. Это может также давать возможность маршрутизировать запросы к различным сервисам.
### 9. **Обработка ошибок иRetries**:
Настройте обработку ошибок и перезапросы в случае отказов. Это особенно важно, если один из серверов становится недоступен.
### 10. **Тестирование под нагрузкой**:
После всех изменений обязательно проведите тестирование под нагрузкой (например, с использованием JMeter или k6), чтобы убедиться, что ваше решение работает эффективно под реальной нагрузкой.
Эти рекомендации помогут вам настроить балансировку нагрузки и обеспечить более стабильную работу вашего приложения при высокой нагрузке.
User: 3. Создание кластеров приложения:
В случае Node.js вы можете использовать cluster или pm2 для создания кластеров вашего приложения, что позволит задействовать все ядра вашего сервера.
подробнее, с использованием pm2
Assistant: ование `pm2` для создания кластеров приложения на Node.js — это отличный способ задействовать все доступные ядра процессора на сервере и улучшить масштабируемость вашего приложения.
### Установка PM2
Если у вас еще не установлен `pm2`, вы можете установить его глобально через npm:
```bash
npm install -g pm2
```
### Запуск приложения в режиме кластера
С `pm2` вы можете запустить ваше приложение в режиме кластера с помощью команды:
```bash
pm2 start yourApp.js -i max
```
- `yourApp.js` — файл вашего приложения, который содержит код Node.js.
- `-i max` — это параметр, который запускает максимальное количество экземпляров вашего приложения в зависимости от количества доступных процессоров на сервере. Вы также можете задать конкретное количество экземпляров, указав, например, `-i 4` для запуска четырех экземпляров.
### Пример настройки
1. **Создайте файл приложения (app.js)**:
```javascript
const express = require('express');
const app = express();
const port = process.env.PORT || 3000;
app.get('/', (req, res) => {
res.send('Hello World!');
});
app.listen(port, () => {
console.log(`App running on port ${port}`);
});
```
2. **Запустите приложение в режиме кластера**:
```bash
pm2 start app.js -i max
```
3. **Проверьте статус ваших процессов**:
```bash
pm2 list
```
Эта команда покажет вам список всех запущенных экземпляров вашего приложения, их статус, количество перезагрузок и т. д.
4. **Обработка ошибок и перезапуск**:
`pm2` также позволяет вам настроить автоматический перезапуск ваших процессов в случае сбоев. Например, вы можете установить максимальное количество перезагрузок перед тем, как процесс будет помечен как "неисправный":
```bash
pm2 start app.js -i max --max-restarts 5
```
5. **Логи**:
Для просмотра логов вашего приложения вы можете использовать команду:
```bash
pm2 logs
```
Это откроет консоль с логами всех ваших экземпляров приложения. Чтобы увидеть логи только для одного экземпляра, используйте:
```bash
pm2 logs <process_id>
```
где `<process_id>` — это идентификатор вашего процесса.
6. **Экспортирование конфигурации**:
Вы можете создать файл конфигурации `ecosystem.config.js`, чтобы управлять приложениями `pm2`. Пример файла:
```javascript
module.exports = {
apps: [{
name: 'myApp',
script: 'app.js',
instances: 'max',
exec_mode: 'cluster',
watch: true
}]
}
```
И запустить его с помощью:
```bash
pm2 start ecosystem.config.js
```
7. **Мониторинг и управление**:
`pm2` также предоставляет инструменты для мониторинга вашего приложения и управления им. Например, вы можете использовать команду:
```bash
pm2 monit
```
Это откроет простой интерфейс мониторинга в консоли.
### Устойчивость при перезагрузке
Для того чтобы ваши приложения автоматически перезапускались после перезагрузки сервера, выполните следующую команду:
```bash
pm2 startup
```
Это сгенерирует и покажет вам команду, которую необходимо выполнить с правами администратора, чтобы включить автозапуск.
Чтобы сохранить текущие процессы, запущенные в `pm2`, выполните:
```bash
pm2 save
```
### Заключение
Использование `pm2` для создания кластеров значительно упрощает управление приложениями Node.js и улучшает их производительность. Это позволяет вам легко и быстро масштабировать ваше приложение, а также управлять им без лишних хлопот.
User: Теперь на примере моего приложения. Сейчас я запускаю так pm2 start call.js --name server
вот сам call.js
const { gpt, gptweb } = require("./API/gpt");
const { dalle } = require("./API/dalle");
const { gpt4o } = require("./API/gpt4o");
const { gpt3 } = require("./API/gpt3.5");
const { prompts } = require("./API/gpt-prompts");
const { blackbox } = require("./API/blackbox");
const { qwen } = require("./API/qwen");
const { gemini } = require("./API/gemini");
const WebSocket = require('ws');
const Bottleneck = require('bottleneck');
const { stats, scheduleDailyReset, resetStatistics } = require('./stats'); // Импортируем модуль статистики
const fs = require('fs');
const path = require('path');
const Ajv = require('ajv');
// Создаем экземпляр Ajv (проверка входящей переписки на соответствие схеме)
const ajv = new Ajv();
// Объект для хранения действий и состояния каждого клиента
const clientActions = {};
// Объект для хранения ограничителей по каждому клиенту
const limiters = {};
// Замените на ваш домен
const allowedOrigin = 'http://gpt.loc';
// Создайте WebSocket-сервер
const wss = new WebSocket.Server({ port: 3000 });
wss.on('connection', (ws, req) => {
const urlParams = new URLSearchParams(req.url.split('?')[1]);
const userId = urlParams.get('token'); // Получаем UUID из URL
const userIP = req.socket.remoteAddress;
//console.log("IP-адрес - ", userIP, "Время подключения - ", new Date().toISOString());
const userHeaders = req.headers;
// Проверяем Origin
if (!checkOrigin(userHeaders.origin, ws)) {
return; // Если отклонено, выходим из обработчика
}
// Увеличиваем общий счетчик подключений
stats.totalConnections++;
console.log('Client connected with user ID:', userId, 'Домен - ', userHeaders.origin);
// Инициализируем состояние клиента, если его еще нет
if (!clientActions[userId]) {
clientActions[userId] = {
actions: [], // Массив для хранения действий
connected: true, // Статус подключения
};
}
else
clientActions[userId].connected = true;
if (!limiters[userId]) {
// Создаем экземпляр Bottleneck для каждого клиента (ограничение на количество запросов по Id)
limiters[userId] = new Bottleneck({
maxConcurrent: 1, // Максимальное количество одновременных задач
minTime: 1000, // Минимальное время между запросами в миллисекундах
highWater: 0 // Не разрешать в очереди больше 0 запросов (игнорировать)
});
}
ws.on('message', (message) => {
// Проверяем, является ли сообщение экземпляром Buffer
if (Buffer.isBuffer(message))
message = message.toString();
try {
// Преобразуем строку JSON обратно в объект
message = JSON.parse(message);
//Получаем историю чата из запроса
let messages = message.messages;
let model = message.model;
console.log('Модель - ', model);
// Выполняем валидацию сообщений
messages = validateMessages(messages);
// Проверяем, остались ли сообщения после валидации
if (messages.length === 0) {
const response = { code: 2, message: "Нет валидных сообщений для обработки." };
sendMessage(ws, response);
return;
}
// Урезаем последнее сообщение до 2000 символов, если оно от клиента
if (messages[messages.length - 1].role === 'user') {
messages[messages.length - 1].content = messages[messages.length - 1].content.substring(0, 2000000);
}
// Увеличиваем общий счетчик запросов
stats.totalRequests++;
// Используем Bottleneck для управления количеством запросов
limiters[userId].schedule(() => {
// Отправка запроса на сервер чата
if (model == 'gpt-4o')
return callGPT4o(messages, ws);
else if (model == 'gemini-pro')
return callGemini(messages, ws);
else if (model == 'qwen')
return callQwen(messages, ws);
else if (model == 'blackbox')
return callBlackbox(messages, ws);
else if (model == 'gpt-3.5-turbo')
return callGPT35Turbo(messages, ws);
}).catch(error => {
stats.totalIPBlocks++;
//console.error('Rate limit exceeded, message ignored:', error);
const response = { code: 2, message: "Превышен лимит запросов. Пожалуйста, попробуйте позже." };
// Отправка ответа клиенту
//sendMessage(ws, response);
});
} catch (error) {
console.error('Error parsing JSON:', error);
const response = { code: 2, message: "Произошла ошибка. Попробуйте еще раз."};
console.log(response);
// Отправка ответа клиенту
sendMessage(ws, response);
}
});
ws.on('close', () => {
clientActions[userId].connected = false; // Обновление статуса подключения
delete clientActions[userId]; // Удаление состояния клиента
delete limiters[userId]; // Удаление ограничителя для данного клиента
console.log('Client ',userId, ' disconnected');
});
});
// Запускаем планировщик для статистики
scheduleDailyReset();
// Очистка старых соединений раз в минуту (по желанию)
setInterval(() => {
Object.keys(clientActions).forEach(userId => {
if (!clientActions[userId].connected) {
delete clientActions[userId]; // Удаляем пользователя из памяти, если он отключен
delete limiters[userId];
}
});
}, 10 * 60 * 1000); // Очистка каждые 10 минут
function checkOrigin(origin, socket) {
if (origin !== allowedOrigin) {
console.log('Недопустимый домен. Соединение разорвано: ', origin);
socket.close(); // Закрываем соединение, если домен не разрешен
return false; // Возвращаем false для индикатора отклонения
}
return true; // Возвращаем true, если домен разрешен
}
// Отправляет ответ клиенту
function sendMessage(ws, message) {
if (ws.readyState === WebSocket.OPEN) {
ws.send(JSON.stringify(message));
} else {
console.warn(`Trying to send message to a closed WebSocket connection.`);
}
}
// Удаление из массива сообщений не соответствующих схеме
function validateMessages(messages) {
// Определяем схему для сообщений
const schema = {
type: 'object',
properties: {
role: { type: 'string' },
content: { type: 'string' }
},
required: ['role', 'content'],
additionalProperties: false
};
// Фильтруем массив, оставляя только корректные сообщения
return messages.filter(message => ajv.validate(schema, message));
}
console.log('WebSocket сервер запущен через порт 3000');
//============== ВЫЗОВ API МОДЕЛЕЙ =================================================
//==================================================================================
//==================================================================================
//==================================================================================
// GPT4o
async function callGPT4o(messages, ws) {
try {
let fullResponse = ""; // Переменная для результата
console.log('Запрос клиента:', messages[messages.length - 1]);
//throw new Error("Намеренная ошибка для тестирования catch");
gpt4o({
messages: messages,
markdown: false
}, (result) => {
// Обработка результата внутри колбэка
if (result.error) {
throw new Error(result.error); // Обрабатываем ошибку, если она есть
}
try {
if (!result.finish) {
// Запоминаем только последний ответ чата (он будет полный, промежуточные ответы - это накопления)
fullResponse = result.message || "";
//console.log(result);
} else {
// Если завершено, выводим полный ответ
let response = { code: 1, message: fullResponse};
console.log('Ответ чата: ', response);
// Отправка ответа клиенту
sendMessage(ws, response);
}
}
catch (callbackError) {
console.error('Error processing callback result:', callbackError);
let response = { code: 2, message: "Произошла ошибка. Попробуйте еще раз." };
// Отправка ответа клиенту
sendMessage(ws, response);
}
});
} catch (error) {
console.error('Error:', error);
let response = { code: 2, message: "Произошла ошибка. Попробуйте еще раз."};
// Отправка ответа клиенту
sendMessage(ws, response);
}
}
// GPT3.5-Turbo
async function callGPT35Turbo(messages, ws) {
try {
let fullResponse = ""; // Переменная для результата
console.log('Запрос клиента:', messages[messages.length - 1]);
//throw new Error("Намеренная ошибка для тестирования catch");
gpt3({
messages: messages,
markdown: false
}, (result) => {
// Обработка результата внутри колбэка
if (result.error) {
throw new Error(result.error); // Обрабатываем ошибку, если она есть
}
try {
if (!result.finish) {
// Запоминаем только последний ответ чата (он будет полный, промежуточные ответы - это накопления)
fullResponse = result.message || "";
//console.log(result);
} else {
// Если завершено, выводим полный ответ
let response = { code: 1, message: fullResponse};
console.log('Ответ чата: ', response);
// Отправка ответа клиенту
sendMessage(ws, response);
}
}
catch (callbackError) {
console.error('Error processing callback result:', callbackError);
let response = { code: 2, message: "Произошла ошибка. Попробуйте еще раз." };
// Отправка ответа клиенту
sendMessage(ws, response);
}
});
} catch (error) {
console.error('Error:', error);
let response = { code: 2, message: "Произошла ошибка. Попробуйте еще раз."};
// Отправка ответа клиенту
sendMessage(ws, response);
}
}
// Gemini
async function callGemini(messages, ws) {
try {
let fullResponse = ""; // Переменная для результата
console.log('Запрос клиента:', messages[messages.length - 1]);
//throw new Error("Намеренная ошибка для тестирования catch");
gemini({
messages: messages
}, (result) => {
// Обработка результата внутри колбэка
if (result.error) {
throw new Error(result.error); // Обрабатываем ошибку, если она есть
}
try {
if (!result.finish) {
// Запоминаем только последний ответ чата (он будет полный, промежуточные ответы - это накопления)
fullResponse = result.message || "";
//console.log(result);
} else {
// Если завершено, выводим полный ответ
let response = { code: 1, message: fullResponse};
console.log('Ответ чата: ', response);
// Отправка ответа клиенту
sendMessage(ws, response);
}
}
catch (callbackError) {
console.error('Error processing callback result:', callbackError);
let response = { code: 2, message: "Произошла ошибка. Попробуйте еще раз." };
// Отправка ответа клиенту
sendMessage(ws, response);
}
});
} catch (error) {
console.error('Error:', error);
let response = { code: 2, message: "Произошла ошибка. Попробуйте еще раз."};
// Отправка ответа клиенту
sendMessage(ws, response);
}
}
// Qwen
async function callQwen(messages, ws) {
try {
let fullResponse = ""; // Переменная для результата
console.log('Запрос клиента:', messages[messages.length - 1]);
//throw new Error("Намеренная ошибка для тестирования catch");
qwen({
messages: messages,
markdown: false
}, (result) => {
// Обработка результата внутри колбэка
if (result.error) {
throw new Error(result.error); // Обрабатываем ошибку, если она есть
}
try {
if (!result.finish) {
// Запоминаем только последний ответ чата (он будет полный, промежуточные ответы - это накопления)
fullResponse = result.message || "";
//console.log(result);
} else {
// Если завершено, выводим полный ответ
let response = { code: 1, message: fullResponse};
console.log('Ответ чата: ', response);
// Отправка ответа клиенту
sendMessage(ws, response);
}
}
catch (callbackError) {
console.error('Error processing callback result:', callbackError);
let response = { code: 2, message: "Произошла ошибка. Попробуйте еще раз." };
// Отправка ответа клиенту
sendMessage(ws, response);
}
});
} catch (error) {
console.error('Error:', error);
let response = { code: 2, message: "Произошла ошибка. Попробуйте еще раз."};
// Отправка ответа клиенту
sendMessage(ws, response);
}
}
// Blackbox
async function callBlackbox(messages, ws) {
try {
let fullResponse = ""; // Переменная для результата
console.log('Запрос клиента:', messages[messages.length - 1]);
//throw new Error("Намеренная ошибка для тестирования catch");
blackbox({
messages: messages,
markdown: false,
websearch: false,
llama: false
}, (result) => {
// Обработка результата внутри колбэка
if (result.error) {
throw new Error(result.error); // Обрабатываем ошибку, если она есть
}
try {
if (!result.finish) {
// Запоминаем только последний ответ чата (он будет полный, промежуточные ответы - это накопления)
fullResponse = result.message || "";
//console.log(result);
} else {
// Если завершено, выводим полный ответ
let response = { code: 1, message: fullResponse};
console.log('Ответ чата: ', response);
// Отправка ответа клиенту
sendMessage(ws, response);
}
}
catch (callbackError) {
console.error('Error processing callback result:', callbackError);
let response = { code: 2, message: "Произошла ошибка. Попробуйте еще раз." };
// Отправка ответа клиенту
sendMessage(ws, response);
}
});
} catch (error) {
console.error('Error:', error);
let response = { code: 2, message: "Произошла ошибка. Попробуйте еще раз."};
// Отправка ответа клиенту
sendMessage(ws, response);
}
}
//============== ВЫЗОВ API МОДЕЛЕЙ (КОНЕЦ) ======================
Assistant: запустить ваше Node.js приложение в режиме кластера с помощью `pm2`, вы можете использовать несколько простых шагов. Я покажу вам, как адаптировать ваши команды для `pm2`, чтобы запустить файл `call.js` в кластерном режиме, используя `pm2`.
### Шаги для запуска приложения в режиме кластера с использованием PM2
1. **Убедитесь, что PM2 установлен**:
Если вы еще не установили `pm2`, выполните следующую команду:
```bash
npm install -g pm2
```
2. **Запустите ваше приложение в кластерном режиме**:
Поскольку вы сейчас запускаете ваше приложение с помощью следующей команды:
```bash
pm2 start call.js --name server
```
Измените команду так:
```bash
pm2 start call.js --name server -i max
```
Здесь `-i max` указывает `pm2` запустить количество экземпляров, равное количеству доступных ядер вашего процессора. Это поможет использовать весь потенциал вашего серверного оборудования.
3. **Проверяйте статус вашего приложения**:
После запуска вы можете просмотреть статус вашего приложения и запущенных процессов с помощью:
```bash
pm2 list
```
4. **Логи приложения**:
Чтобы просмотреть логи вашего приложения, используйте:
```bash
pm2 logs server
```
5. **Автозапуск приложения**:
Чтобы ваше приложение автоматически перезапускалось после перезагрузки сервера, выполните команду:
```bash
pm2 startup
```
После этого вам будет предложено выполнить команду с правами администратора, чтобы завершить настройку.
6. **Сохранение текущих процессов**:
Сохраните текущее состояние ваших процессов с помощью:
```bash
pm2 save
```
### Пример полного запуска
Вот команда, которую вы используете для запуска `call.js` в кластере:
```bash
pm2 start call.js --name server -i max
```
### Объяснение
- `-i max`: Эта опция запускает ваше приложение в режиме кластера, создавая экземпляры равным количеству ядер в вашем сервере. Это помогает максимизировать использование ресурса CPU.
- `--name server`: Это позволяет вам задать специфичное имя для вашего приложения в `pm2`, чтобы из списка процессов было легко его идентифицировать.
Теперь ваше Node.js приложение будет запущено в кластерном режиме с помощью `pm2`, и оно будет автоматически масштабироваться в зависимости от доступных ядер. Это должно помочь справиться с высоким трафиком и значительно улучшить производительность вашего приложения.
User: Если у меня VPS с 8 ядрами на процессоре и я запускаю сервер командой pm2 start call.js --name server, значит я всегда использую только одно ядро?, Т.е. мощность процессора всегда используется только на 12,5% ? И если это ядро будет максимально нагружено, то другие ядра не подключатся к работе?
Assistant: , вы правы. Если вы запускаете ваше приложение Node.js с помощью команды:
```bash
pm2 start call.js --name server
```
то, по умолчанию, ваше приложение будет работать только в одном экземпляре и использовать одно ядро процессора. Поскольку ваш процессор имеет 8 ядер, это означает, что вы используете только 12,5% мощности процессора. В случае, если это одно ядро будет сильно нагружено, другие ядра не будут задействованы для выполнения задач вашего приложения.
### Как использовать все ядра?
Чтобы задействовать все доступные ядра и улучшить производительность вашего приложения, вы должны запустить его в кластерном режиме. Это можно сделать с помощью `pm2`, указав количество экземпляров, равное количеству доступных ядер, или просто указав `max`, чтобы `pm2` сам определил оптимальное количество:
```bash
pm2 start call.js --name server -i max
```
### Преимущества использования кластера
1. **Балансировка нагрузки**: Каждый экземпляр будет работать на своем отдельном ядре, что позволит вашему приложению обрабатывать больший объем одновременных подключений и улучшит общую производительность.
2. **Устойчивость**: Если один экземпляр упадет, остальные продолжат обрабатывать запросы, что делает вашу систему более устойчивой.
3. **Производительность**: Вы сможете использовать доступные ресурсы процессора более эффективно, что может привести к увеличению пропускной способности и уменьшению времени отклика.
### Ресурсы в случае нагрузки
Если вы используете команду `pm2 start call.js --name server -i max`, это позволит процессам вашего приложения распределяться по всем доступным ядрам, что сделает использование серверных ресурсов более эффективным. Если одно ядро будет нагружено, другие экземпляры вашего приложения на других ядрах смогут продолжать обрабатывать запросы, тем самым минимизируя влияние нагрузки на общее производительность системы.
Если бы вы запустили свое приложение только на одном экземпляре (одном ядре), то при повышенной загрузке одного ядра вы бы фактически ограничили производительность вашего приложения, так как другие ядра останутся бездействующими. Использование кластера помогает предотвратить этот сценарий.
User: при таком подходе достаточно увеличивать количество ядер и размер оперативной памяти на сервере и можно не использовать несколько серверов?
Assistant: , при использовании кластера в вашем приложении Node.js и увеличении количества ядер и объема оперативной памяти на сервере, вы можете значительно улучшить производительность и масштабируемость вашего приложения, не прибегая к многосерверной архитектуре. Однако, есть некоторые аспекты, которые стоит учитывать:
### Преимущества использования одного сервера с многими ядрами
1. **Увеличенная производительность**: Закладывая на сервер больше процессорных ядер и оперативной памяти, вы можете обрабатывать больше одновременно подключенных пользователей и выполнять больше операций. Ваша система сможет поддерживать высокую нагрузку без необходимости в распределенной архитектуре.
2. **Упрощенная архитектура**: Обслуживание одного сервера проще, чем многосерверная система. Вам не нужно беспокоиться о синхронизации данных, межсерверном взаимодействии и других сложных аспектах инфраструктуры.
3. **Снижение затрат**: В некоторых случаях может быть более экономически выгодно увеличить ресурсы одного сервера, чем использовать несколько серверов.
### Когда стоит рассмотреть многосерверную архитектуру?
Несмотря на множество преимуществ одного сервера с высоким уровнем ресурсов, в некоторых случаях многосерверная архитектура может быть более целесообразной:
1. **Географическое распределение**: Если ваши пользователи находятся в разных регионах мира, использование нескольких серверов в разных географических точках может снизить задержку и улучшить производительность.
2. **Избыточность и отказоустойчивость**: Многосерверная архитектура позволяет создать избыточность, что обеспечивает большую отказоустойчивость. Если один сервер выходит из строя, другие могут продолжать обслуживать запросы.
3. **Специфические нагрузки**: Если ваше приложение требует обработки больших объемов данных (например, аналитика в реальном времени или машинное обучение), распределенная архитектура может лучше поддерживать различные нагрузки и сегментировать задачи по специализированным серверам.
4. **Управляемые сервисы**: Использование облачных провайдеров и контейнеризации позволяет использовать масштабируемые решения, которые можно легко наращивать и уменьшать в зависимости от необходимости.
### Заключение
Ваша архитектура будет зависеть от конкретных потребностей вашего приложения и бизнеса. В начальных этапах, когда вы можете предсказать, что ваше приложение не достигнет экстремально высокой нагрузки, может быть разумно сначала оптимизировать его на одном сервере с хорошими ресурсами. Однако, как только вы начнете сталкиваться с проблемами производительности, вам стоит рассмотреть возможность перехода к многосерверной архитектуре или распределенным решениям, которые смогут обеспечить дальнейшее масштабирование.
User: Мой сайт - это только доступ к chatgpt. Есть ли смысл в многосерверной архитектуре или достаточно увеличивать мощности сервера?
Assistant: