Cara nodejs berinteraksi dengan data besar

Dengan perkembangan pesat Internet dan teknologi data, data besar secara beransur-ansur menjadi salah satu teras strategi pembangunan korporat. Dalam era dipacu data ini, cara memproses dan mengurus data besar-besaran dengan cekap telah menjadi isu penting yang dihadapi oleh perusahaan. Sebagai persekitaran berjalan JavaScript yang ringan, Nodejs juga telah mula digunakan secara meluas dalam bidang data besar, meningkatkan kecekapan pemprosesan data dan fleksibiliti perusahaan.

Bagaimana Nodejs berinteraksi dengan data besar?

Nodejs, sebagai persekitaran berjalan bahasa JavaScript, boleh berinteraksi dengan pelbagai sistem storan data melalui mekanisme modulnya yang berkuasa. Dalam bidang data besar, storan teragih, pengkomputeran teragih dan teknologi lain biasanya digunakan, seperti Hadoop, Spark, dll. Di bawah, kami akan menggunakan Hadoop sebagai contoh untuk memperkenalkan cara Nodejs berinteraksi dengan data besar.

1. Gunakan API HDFS untuk operasi fail

Sistem Fail Teragih Hadoop (HDFS) ialah salah satu komponen teras Hadoop, yang boleh menyimpan sejumlah besar data dalam pengedaran persekitaran , dan memprosesnya melalui model pengkomputeran MapReduce. Nodejs boleh berinteraksi secara langsung dengan HDFS melalui API HDFS untuk melaksanakan muat naik fail, muat turun fail, pemadaman fail dan operasi lain.

Berikut ialah contoh menggunakan API HDFS untuk memuat naik fail dalam Nodejs:

const WebHDFS = require('webhdfs');
const fs = require('fs');

const hdfs = WebHDFS.createClient({
  user: 'hadoop',
  host: 'hadoop-cluster',
  port: 50070,
  path: '/webhdfs/v1'
});

const localFile = 'test.txt';
const remoteFile = '/user/hadoop/test.txt';

fs.createReadStream(localFile)
  .pipe(hdfs.createWriteStream(remoteFile))
  .on('error', (err) => {
    console.error(`Error uploading file: ${err.message}`);
  })
  .on('finish', () => {
    console.log('File uploaded successfully');
  });

Dalam contoh ini, modul webhdfs digunakan untuk mencipta klien HDFS melalui URL dan port HDFS nombor, dan kemudian Gunakan modul fs yang disertakan dengan Nodejs untuk membaca fail daripada tempatan dan akhirnya memuat naiknya ke HDFS.

2. Menggunakan Penstriman Hadoop untuk pengkomputeran MapReduce

MapReduce ialah model pengkomputeran teragih untuk memproses set data yang besar dalam storan teragih. Rangka kerja MapReduce yang disertakan dalam Hadoop boleh membangunkan tugasan MapReduce menggunakan bahasa Java. Walau bagaimanapun, menggunakan rangka kerja MapReduce dalam Nodejs memerlukan perpustakaan kelas penyesuai, yang jelas mengurangkan kecekapan pembangunan. Oleh itu, menggunakan Hadoop Streaming boleh mengelakkan masalah ini.

Penstriman Hadoop ialah alat untuk memulakan tugasan MapReduce Ia boleh berinteraksi dengan tugasan MapReduce melalui input standard dan output standard. Nodejs boleh menggunakan modul child_process untuk mencipta proses anak dan lulus program MapReduce untuk dilaksanakan sebagai parameter baris arahan ke dalam proses anak. Untuk kaedah pelaksanaan khusus, sila rujuk kod contoh berikut:

// mapper.js
const readline = require('readline');

const rl = readline.createInterface({
  input: process.stdin,
  output: process.stdout,
  terminal: false
});

rl.on('line', (line) => {
  line
    .toLowerCase()
    .replace(/[.,?!]/g, '')
    .split(' ')
    .filter((word) => word.length > 0)
    .forEach((word) => console.log(`${word}\t1`));
});

// reducer.js
let count = 0;

process.stdin.resume();
process.stdin.setEncoding('utf-8');

process.stdin.on('data', (chunk) => {
  const lines = chunk.split('\n');
  lines.forEach((line) => {
    if (line.trim().length) {
      const [word, num] = line.split('\t');
      count += parseInt(num);
    }
  });
});

process.stdin.on('end', () => {
  console.log(`Total count: ${count}`);
});

Kod sampel di atas ialah program MapReduce yang ringkas. mapper.js memotong dan menapis teks dalam aliran input, dan akhirnya mengeluarkan hasil statistik kepada aliran output standard. reducer.js membaca data daripada aliran input standard, mengira nilai kunci yang sama secara kumulatif, dan akhirnya mengeluarkan hasilnya.

Program MapReduce ini boleh dilaksanakan melalui kod Nodejs berikut:

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

const mapper = spawn('/path/to/mapper.js');
const reducer = spawn('/path/to/reducer.js');

mapper.stdout.pipe(reducer.stdin);

reducer.stdout.on('data', (data) => {
  console.log(`Result: ${data}`);
});

mapper.stderr.on('data', (err) => {
  console.error(`Mapper error: ${err}`);
});

reducer.stderr.on('data', (err) => {
  console.error(`Reducer error: ${err}`);
});

reducer.on('exit', (code) => {
  console.log(`Reducer process exited with code ${code}`);
});

Dalam contoh ini, modul child_process digunakan untuk mencipta dua proses anak, satu untuk melaksanakan mapper.js dan satu untuk melaksanakan pengurang .js. Input dan output standard pemeta dan pengurang disambungkan untuk membentuk tugas MapReduce, dan hasil pengiraan akhirnya dikeluarkan kepada aliran keluaran standard.

Selain menggunakan API HDFS dan Penstriman Hadoop, Nodejs juga boleh berinteraksi dengan data besar dalam pelbagai cara lain, seperti melalui API RESTful, menggunakan pengumpul data, dsb. Sudah tentu, dalam aplikasi praktikal, kita perlu memilih kaedah interaksi yang paling sesuai mengikut senario tertentu.

Ringkasan

Artikel ini memperkenalkan cara Nodejs berinteraksi dengan data besar. Dengan menggunakan API HDFS dan Hadoop Streaming, operasi seperti membaca dan menulis data besar serta pengiraan MapReduce boleh dilaksanakan. Nodejs mempunyai kelebihan kecekapan yang ringan dan tinggi dalam bidang data besar, dan boleh membantu perusahaan mengurus dan memproses data besar-besaran dengan lebih baik.

Atas ialah kandungan terperinci Cara nodejs berinteraksi dengan data besar. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!