Process boshqaruvi

Jarayonlarni boshqarish nima?

Node.js-dagi jarayonlarni boshqarish ilovangizning lifecycle’ini (hayotiy siklini) nazorat qilishdan iborat.

Bunga quyidagilar kiradi:

Ilovalarni ishga tushirish va to‘xtatish
Buzilishlardan keyin qayta ishga tushirish
Ishlash monitoringi
Tizim signallari bilan ishlash
Muhit o‘zgaruvchilarini boshqarish

Jarayon ma’lumotlariga kirish

process obyekti joriy Node.js jarayoni haqida ma’lumot beradi va uni nazorat qiladi.

Bu yerda ba’zi foydali xususiyatlar mavjud:

// Process identification
console.log('Process ID (PID):', process.pid);

// Platform information
console.log('Platform:', process.platform);
console.log('Node.js version:', process.version);

// Memory usage (in bytes)
console.log('Memory usage:', process.memoryUsage());

// Command line arguments
console.log('Arguments:', process.argv);

O‘zingiz sinab ko‘ring »

Jarayondan chiqish

Node.js dasturingiz quyidagi usullardan foydalanishni to‘xtatganda nazorat qilishingiz mumkin:

1. Oddiy chiqish

// Exit with success (status code 0)
process.exit();

// Or explicitly
process.exit(0);

2. Xato bilan chiqish

// Exit with error (status code 1)
process.exit(1);

3. Voqeadan chiqishdan oldin

// Run cleanup before exiting
process.on('beforeExit', (code) => {
console.log('About to exit with code:', code);
});

O‘zingiz sinab ko‘ring »

Jarayon hodisalarini boshqarish

Node.js jarayonlari tizim signallari va hodisalariga javob berishi mumkin.

Mana eng keng tarqalganlari:

1. Ctrl+C’ni qayta ishlash (SIGINT)

// Handle Ctrl+C
process.on('SIGINT', () => {
console.log('\nGot SIGINT. Press Control-D to exit.');
// Perform cleanup if needed
process.exit(0);

2. Jarayon tugatilishini qayta ishlash (SIGTERM)

process.on('SIGTERM', () => {
  console.log('Received SIGTERM. Cleaning up...');
  // Perform cleanup if needed
  process.exit(0);
});

2. Jarayon tugatilishini qayta ishlash (SIGTERM)

process.on('SIGTERM', () => {
  console.log('Received SIGTERM. Cleaning up...');
  server.close(() => {
    console.log('Server closed');
    process.exit(0);
  });
});

3. Qo‘lga olinmagan istisnolar

process.on('uncaughtException', (err) => {
  console.error('Uncaught Exception:', err);
  // Perform cleanup if needed
  process.exit(1); // Exit with error
});

Jarayon menejerlari

Ishlab chiqarish muhitlari uchun dasturingiz muammosiz ishlashini ta’minlash uchun jarayon menejeridan foydalaning.

PM2 eng mashhur tanlovdir:

1. PM2 ni global o‘rnating

npm install -g pm2

2. PM2 ning asosiy buyruqlari

# Start an application
pm2 start app.js

# List all running applications
pm2 list

# Monitor resources
pm2 monit

# View application logs
pm2 logs

# Stop an application
pm2 stop app_name

# Restart an application
pm2 restart app_name

# Delete an application from PM2
pm2 delete app_name

3. PM2 konfiguratsiyasi

Kengaytirilgan konfiguratsiya uchun ekotizim faylini yarating:

// ecosystem.config.js
module.exports = {
  apps: [{
    name: 'my-app',
    script: 'app.js',
    instances: 'max',
    autorestart: true,
    watch: false,
    max_memory_restart: '1G',
    env: {
      NODE_ENV: 'development',
    },
    env_production: {
      NODE_ENV: 'production',
    }
  }]
};

PM2 yuklarni muvozanatlash, monitoring va jurnallarni boshqarish kabi ko‘plab boshqa xususiyatlarni taqdim etadi.

Muhit o‘zgaruvchilari

Muhit o‘zgaruvchilari - bu turli muhitlarda ilovangiz xatti-harakatlarini sozlaydigan kalit-qiymat juftliklari.

Muhit o‘zgaruvchilariga kirish

// Get a specific environment variable
const apiKey = process.env.API_KEY;

// Set a default value if not defined
const port = process.env.PORT || 3000;

// Check if running in production
const isProduction = process.env.NODE_ENV === 'production';

// List all environment variables
console.log('Environment variables:', process.env);

.env faylidan muhit o‘zgaruvchilari yuklanmoqda

# Install dotenv package
npm install dotenv

// Load environment variables from .env file
require('dotenv').config();

// Now you can access variables from .env
console.log('Database URL:', process.env.DATABASE_URL);

Muhit o‘zgaruvchilari uchun eng yaxshi amaliyotlar:

Hech qachon maxfiy ma’lumotlarni versiya boshqaruviga topshirmang
Mahalliy rivojlanish uchun .env dan foydalaning
Xosting platformangiz orqali ishlab chiqarishda muhit o‘zgaruvchilarini o‘rnating
README-da barcha kerakli muhit o‘zgaruvchilarini hujjatlang

Bolalar jarayonlari

Node.js child_process moduli yordamida tizim buyruqlari va boshqa skriptlarni ishga tushirishi mumkin.

1. Oddiy buyruqni bajaring

const { exec } = require('child_process');

exec('ls -la', (error, stdout, stderr) => {
  if (error) {
    console.error(`Error: ${error.message}`);
    return;
  }
  if (stderr) {
    console.error(`stderr: ${stderr}`);
    return;
  }
  console.log(`Output: ${stdout}`);
});

2. Katta chiqish uchun spawndan foydalanish

const { spawn } = require('child_process');

// Better for large data output
const child = spawn('find', ['/', '-type', 'f']);
child.stdout.on('data', (data) => {
  console.log(`Found file: ${data}`);
});
child.stderr.on('data', (data) => {
  console.error(`Error: ${data}`);
});
child.on('close', (code) => {
  console.log(`Child process exited with code ${code}`);
});

Jarayon monitoringi va unumdorligi

1. Xotiradan foydalanish

// Get memory usage in MB
function getMemoryUsage() {
  const used = process.memoryUsage();
  return {
    rss: `${Math.round(used.rss / 1024 / 1024 * 100) / 100} MB`,
    heapTotal: `${Math.round(used.heapTotal / 1024 / 1024 * 100) / 100} MB`,
    heapUsed: `${Math.round(used.heapUsed / 1024 / 1024 * 100) / 100} MB`,
    external: `${Math.round(used.external / 1024 / 1024 * 100) / 100} MB`
  };
}

// Monitor memory usage every 5 seconds
setInterval(() => {
  console.log('Memory usage:', getMemoryUsage());
}, 5000);

2. CPU foydalanish

const startUsage = process.cpuUsage();

// Do some CPU-intensive work
for (let i = 0; i < 1000000000; i++) {}

const endUsage = process.cpuUsage(startUsage);
console.log('CPU usage (user):', endUsage.user / 1000, 'ms');
console.log('CPU usage (system):', endUsage.system / 1000, 'ms');

Asosiy xulosalar

Jarayon obyekti: tizim va jarayon ma’lumotlariga kirish
Jarayonlarni boshqarish: ilovani ishga tushirish, to‘xtatish va uning lifecycle’ini (hayotiy siklini) boshqarish
Muhit o‘zgaruvchilari: Turli muhitlarda ilova harakatini sozlang
Bola jarayonlar: Tizim buyruqlari va boshqa skriptlarni ishga tushirish
Xatolarni hal qilish: Tugallanmagan istisnolar va rad etishlarni boshqaring
Signallar: SIGINT va SIGTERM kabi tizim signallariga javob bering
PM2: ishlab chiqarish jarayonini boshqarish uchun zarur
Umumiylikni monitoring qilish: Xotira va protsessordan foydalanishni kuzatish

Ishonchli va barqaror Node.js ilovalarini yaratish uchun jarayonni samarali boshqarish, ayniqsa ishlab chiqarish muhitida juda muhimdir.

W3Schools Pathfinder

Yutuqlaringizni kuzating – bu bepul!

Ro'yxatdan o'tish Kirish