Node.js સાથે HTTP/2 સર્વર સ્થાપિત અને ટેસ્ટ કરવું.

પાછલા બ્લોગમાં, અમે Node.js નો ઉપયોગ કરીને HTTPS 1.1 સર્વર સેટઅપ કરવા કવર કર્યું હતું. જો તમે તેને હજુ સુધી નથી વાંચ્યું, તો તમે તેને અહીં શોધી શકો છો. આ બ્લોગમાં, આપણે એક પગલું આગળ જઈશું અને HTTP/2 સર્વર સેટઅપ કરશું, જે HTTP 1.1 કરતા મહત્વપૂર્ણ પ્રદર્શન સુધારાઓ આપે છે.

આવશ્યકતાઓ

• Node.js (વર્ઝન 20.04 અથવા વધુ)
• જાવાસ્ક્રિપ્ટ અને Node.js ની મૂળભૂત સમજણ.
• SSL સર્ટિફિકેટ્સ (તેમને જનરેટ કરવા માટે પહેલા બ્લોગનો સંદર્ભ લો)

પગલું 1: HTTP/2 સર્વર બનાવો.

અમારા HTTP/2 સર્વર માટે એક નવી સર્વર ફાઈલ બનાવશો. http2.js ડિરેક્ટરીમાં નીચેના કન્ટેન્ટ સાથે src/server ફાઇલ ઉમેરો:

import { createSecureServer } from 'node:http2';
import { createReadStream } from 'node:fs';
import { readFileSync } from 'node:fs';
import { extname, resolve } from 'node:path';
import mime from 'mime-types';
import zlib from 'node:zlib';

const http2Port = 8081;
const http2Host = '0.0.0.0';

const brotliOptions = {
  chunkSize: 32 * 1024,
  params: {
    [zlib.constants.BROTLI_PARAM_QUALITY]: 10,
  },
};

// SSL options
const options = {
  key: readFileSync(resolve('ssl', 'server-key.pem')),
  cert: readFileSync(resolve('ssl', 'server-cert.pem')),
  allowHTTP1: true
};
const html = readFileSync(resolve('src', 'index.html'), { encoding: 'utf-8' });

// Create the HTTP/2 server with TLS
const http2Server = createSecureServer(options, async (req, res) => {
  const filePath = resolve(req.url.substring(1));
  if (req.url === '/') {
    res.writeHead(200, {
      'Content-Type': 'text/html',
    });
    res.write(html);
    res.end();
    return;
  }
  try {
    const mimeType = mime.lookup(extname(filePath)) || 'application/octet-stream';

    res.writeHead(200, {
      'Content-Type': mimeType,
      'Content-Encoding': 'br'
    });

    const readStream = createReadStream(filePath);
    const brotliStream = zlib.createBrotliCompress(brotliOptions);
    readStream.pipe(brotliStream).pipe(res);
  } catch (error) {
    console.log(error);
    res.writeHead(404, { 'Content-Type': 'text/plain' });
    res.write('File not found');
    res.end();
  }
});

http2Server.listen(http2Port, http2Host, () => {
  console.log(`HTTP/2 server listening on: https://${http2Host}:${http2Port}`);
});

HTTP/2 અથવા h2 સર્વર કોડની સમજણ.

1. જરૂરી મોડ્યુલ્સ ઇમ્પોર્ટ કરો:

• અમે આવશ્યક મૉડ્યુલ્સ જેમ કે: createSecureServer થી node:http2, createReadStream, readFileSync થી node:fs, extname, resolve થી node:pathઅને mime થી mime-types.
• zlib wpml_ignored_tag > મૉડ્યુલનો ઉપયોગ પ્રતિસાદોને દબાવવા માટે થાય છે.

2. બ્રોટલી વિકલ્પો નિર્ધારિત કરો:

• અમારા પ્રદર્શનને સુધારવા માટે Brotli કૉમ્પ્રેશન વિકલ્પોને વ્યાખ્યાયિત કરીએ છીએ.

3. સર્વર પોર્ટ અને હોસ્ટ સેટ કરો:

• અમે પોર્ટ અને હોસ્ટ ની ચોક્કસતા કરીએ છીએ જ્યાં સર્વર સાંભળશે.

4. SSL વિકલ્પો:

• SSL વિકલ્પો, જેમાં કી અને સર્ટિફિકેટ શામેલ છે,ssl ડિરેક્ટરીમાંથી વાંચવામાં આવે છે.

5. HTTP/2 સર્વર બનાવો:

• અમે createSecureServer મેથડનો ઉપયોગ કરીને HTTP/2 સર્વર બનાવીએ છીએ.
• જો વિનંતી URL / હોય, તો સર્વર index.html ની સામગ્રી સાથે પ્રતિસાદ આપે છે.
• અન્ય URLs માટે, સર્વર વિનંતી કરેલી ફાઇલ સર્વ કરવાનો પ્રયાસ કરે છે. પ્રતિસાદ Brotli નો ઉપયોગ કરીને દબાવવામાં આવે છે.

સર્વર શરૂ કરો:

• સર્વર નિર્દિષ્ટ પોર્ટ અને હોસ્ટ પર સાંભળે છે, અને તે શરૂ થતાં અને કાર્યરત થતા સંદેશા લોગ કરે છે.

પગલું 2: HTTP/2 સર્વર ચલાવો.

સર્વર શરૂ કરવા માટે, ચલાવો:

node src/server/http2.js

તમે એક સંદેશો જોઈ શકશો જે સર્વર ચલાઈ રહ્યો છે તે દર્શાવે છે. તમારું બ્રાઉઝર ખોલો અને https://localhost:8081 પર જાઓ જેથી તમે સર્વર કાર્યરત જોઈ શકો. નોંધો કે તમારે સ્વ-હસ્તાક્ષરિત સર્ટિફિકેટ સ્વીકારવું પડશે.

સંદર્ભ

HTTPS 1.1 સર્વર સેટઅપ કરવા માટે, કૃપા કરીને અમારા અગાઉના બ્લોગનો સંદર્ભ લો: Node.js સાથે HTTPS 1.1 સર્વર સ્થાપિત અને પરીક્ષણ કરવું.

આ પગલાંઓને અનુસરીને, તમે હવે સફળતાપૂર્વક Node.js નો ઉપયોગ કરીને HTTP/2 સર્વર સેટઅપ અને ટેસ્ટ કર્યું છે. આ તમને તમારી એપ્લિકેશન્સમાં HTTP/2 ના ઉત્તમ ફીચર્સ અને પ્રદર્શન ફાયદાઓનો લાભ લેવા દેશે.

Developer Tools માં HTTP/2 સમજવું.

જ્યારે તમે બ્રાઉઝર ડેવલપર ટૂલ્સમાં તમારી નેટવર્ક રિક્વેસ્ટનું નિરીક્ષણ કરો છો, ત્યારે તમે જોઈ શકો છો કે HTTP/2 રિક્વેસ્ટ્સ “Protocol” કૉલમ હેઠળ “h2” દ્વારા દર્શાવવામાં આવે છે. HTTP/2, જેને “h2” તરીકે પણ ઓળખવામાં આવે છે, તે HTTP/1.1 કરતાં ઘણી સુધારણીઓ લાવે છે:

• મલ્ટિપ્લેક્સિંગ: એક જ કનેક્શન પર બહુવિધ રિક્વેસ્ટ્સ અને રિસ્પોન્સ એકસાથે મોકલી શકાય છે.
• હેડર કંપ્રેશન: HTTP હેડર્સનો ઓવરહેડ ઘટાડે છે.
• સર્વર પુષ: સર્વરને પહેલથી જ રિસોર્સ ક્લાયન્ટને મોકલવાની મંજૂરી આપે છે.
• સ્ટ્રીમ પ્રાથમિકતા: ઝડપી લોડ સમય માટે મહત્વપૂર્ણ રિસોર્સની પ્રાથમિકતા સક્ષમ કરે છે.

આ ફીચર્સ વધુ કાર્યક્ષમ અને ઝડપી વેબ બ્રાઉઝિંગ અનુભવમાં યોગદાન આપે છે.