Node.js-taustakehityksen bootcamp · Oppitunti

Node.js:n välimuististrategiat

Toteuttakaa erilaisia välimuistimekanismeja, kuten Redis, vastausaikojen lyhentämiseksi ja tietokantakuorman vähentämiseksi.

Oppitunti 1/412 vaihetta

Node.js:n välimuististrategiat on ilmainen Node.js-taustakehityksen bootcamp-oppitunti CoddyKitissä. Tämä on oppitunti 1/4. Voit lukea koko oppitunnin alta ilmaiseksi ja harjoitella sen jälkeen käytännössä selaimessa sisäänrakennetulla koodieditorilla ja ympäri vuorokauden käytettävissä olevan tekoälytuutorin avulla. Oppitunti kuuluu Node.js-taustakehityksen bootcamp-oppimispolkuun, ja edistymisesi synkronoituu verkon ja CoddyKit-sovelluksen välillä. Node.js-taustakehityksen bootcamp-kurssilla on yhteensä 4 oppituntia.

Mitä välimuistitus on?

Tervetuloa Node.js:n välimuistitusstrategioihin! Välimuistitus on perustavanlaatuinen tekniikka, jolla parannetaan sovelluksen suorituskykyä ja vähennetään taustapalveluihin kohdistuvaa kuormaa.

Kuvitelkaa, että sovellus pyytää usein samoja tietoja. Sen sijaan että tiedot haettaisiin joka kerta uudelleen, välimuistitus tallentaa kopion lähemmäs käyttäjää.
Nämä tallennetut tiedot eli ”cache” voidaan hakea paljon nopeammin kuin alkuperäisestä lähteestä, kuten tietokannasta.
Se on kuin helposti käytettävä pikareitti usein tarvittuihin tietoihin!

Node.js:n välimuististrategiat — kuvitus 1

Miksi käyttää välimuistia Node.js:ssä?

Node.js-sovellukset käsittelevät usein paljon pyyntöjä, ja tietokantaoperaatiot voivat olla hitaita. Välimuistitus auttaa merkittävästi:

Nopeammat vastausajat: Käyttäjät saavat tiedot nopeammin, mikä parantaa käyttökokemusta.
Pienempi tietokantakuormitus: Tietokantaan kohdistuu vähemmän pyyntöjä, mikä säästää resursseja ja ehkäisee pullonkauloja.
Parempi skaalautuvuus: Sovellus pystyy palvelemaan useampia käyttäjiä ilman, että tietokantaa tarvitsee skaalata yhtä voimakkaasti.

Se on keskeinen strategia suorituskykyisten Node.js-palveluiden rakentamisessa.

Miten välimuistitus toimii

Välimuistitusprosessi etenee yksinkertaisesti:

Saapuu tiettyjä tietoja koskeva pyyntö.
Sovellus tarkistaa ensin, ovatko tiedot saatavilla välimuistissa. Tätä kutsutaan välimuistiosumaksi eli ”cache hit” -tilanteeksi.
Jos kyseessä on cache hit, tiedot palautetaan heti välimuistista.
Jos kyseessä on cache miss eli tietoja ei löydy, sovellus hakee ne alkuperäisestä lähteestä (esimerkiksi tietokannasta).
Haun jälkeen tiedot tallennetaan välimuistiin tulevia pyyntöjä varten ja palautetaan käyttäjälle.

Muistinsisäinen välimuistitus

Yksi yksinkertaisimmista välimuistitusmenetelmistä on muistinsisäinen välimuistitus. Se tarkoittaa tietojen tallentamista suoraan Node.js-sovelluksen prosessimuistiin.

Se on erittäin nopeaa, koska verkkoliikenteestä ei aiheudu ylimääräistä kuormaa.
Toteutus on helppoa JavaScriptin perusobjektien tai Map-rakenteiden avulla.
Välimuistissa olevat tiedot kuitenkin menetetään, jos palvelin käynnistyy uudelleen.
Välimuistia ei jaeta Node.js-sovelluksen useiden instanssien kesken (esimerkiksi silloin, kun käytössä on useita prosesseja tai palvelimia).

Sopii parhaiten pieniin ja paikallisiin välimuisteihin.

Esimerkki muistinsisäisestä välimuistista

Tarkastellaan yksinkertaista muistinsisäistä välimuistia, joka käyttää JavaScriptin Map-rakennetta. Jäljittelemme hidasta tietokantakutsua.

const cache = new Map();

// Simulate a slow database call
function getProductFromDB(id) {
  console.log(`Fetching product ${id} from DB...`);
  return new Promise(resolve => {
    setTimeout(() => {
      resolve({ id: id, name: `Product ${id}`, price: 10 + id });
    }, 1000); // Simulate 1-second delay
  });
}

async function getProduct(id) {
  if (cache.has(id)) {
    console.log(`Cache hit for product ${id}`);
    return cache.get(id);
  }

  const product = await getProductFromDB(id);
  cache.set(id, product);
  console.log(`Cache miss, stored product ${id}`);
  return product;
}

// Test the caching
(async () => {
  console.log("First call (miss):");
  await getProduct(1);

  console.log("\nSecond call (hit):");
  await getProduct(1);

  console.log("\nThird call (new product):");
  await getProduct(2);
})();

Redis välimuistitusratkaisuna

Vankempaan ja paremmin skaalautuvaan välimuistitukseen, erityisesti hajautetuissa järjestelmissä, sopii erillinen välimuistivarasto, kuten Redis.

Redis on muistinsisäinen tietorakenteiden tallennusjärjestelmä, jota käytetään tietokantana, välimuistina ja viestinvälittäjänä.
Se on erittäin nopea ja tukee useita tietotyyppejä (merkkijonot, hajautustaulut, listat, joukot ja niin edelleen).
Redis voidaan ratkaisevasti suorittaa erillisenä palveluna, jolloin useat Node.js-instanssit voivat jakaa saman välimuistin.
Se tarjoaa myös pysyvyysasetuksia, joten tiedot eivät katoa uudelleenkäynnistyksen yhteydessä.

Node.js:n yhdistäminen Redisiin

Redisin käyttämiseen Node.js:ssä tarvitaan asiakaskirjasto. ioredis on suosittu valinta suorituskykynsä ja ominaisuuksiensa ansiosta.

Asentakaa se ensin: npm install ioredis

Yhdistäkää sitten Redis-palvelimeen ja suorittakaa perusoperaatioita, kuten SET (tietojen tallentaminen) ja GET (tietojen hakeminen).

const Redis = require('ioredis');
const redis = new Redis(); // Connects to localhost:6379 by default

(async () => {
  try {
    console.log("Connected to Redis!");

    // Store a value
    await redis.set('myKey', 'Hello from Redis!');
    console.log("Set 'myKey'");

    // Retrieve a value
    const value = await redis.get('myKey');
    console.log(`Retrieved 'myKey': ${value}`);

    // Try to get a non-existent key
    const nonExistent = await redis.get('nonExistentKey');
    console.log(`Retrieved 'nonExistentKey': ${nonExistent}`); // Will be null

  } catch (err) {
    console.error("Redis error:", err);
  } finally {
    redis.quit(); // Disconnect from Redis
  }
})();

API-vastausten välimuistitus Redisillä

Integroidaan Redis yksinkertaiseen Express.js-API-reittiin vastausten välimuistittamista varten. Tämä toimintamalli on hyvin yleinen usein käytettyjen tietojen yhteydessä.

const express = require('express');
const Redis = require('ioredis');
const app = express();
const port = 3000;

const redis = new Redis();

// Simulate a slow database call
const getExpensiveData = async (id) => {
  console.log(`Fetching data for ${id} from 'database'...`);
  return new Promise(resolve => {
    setTimeout(() => {
      resolve({ id: id, info: `Expensive data for ${id}` });
    }, 1500); // Simulate 1.5-second delay
  });
};

app.get('/data/:id', async (req, res) => {
  const dataId = req.params.id;
  const cacheKey = `data:${dataId}`;

  try {
    // 1. Check cache first
    const cachedData = await redis.get(cacheKey);
    if (cachedData) {
      console.log(`Cache hit for ${cacheKey}`);
      return res.json(JSON.parse(cachedData));
    }

    // 2. Cache miss, fetch from source
    console.log(`Cache miss for ${cacheKey}`);
    const data = await getExpensiveData(dataId);

    // 3. Store in cache (with expiration) and return
    await redis.setex(cacheKey, 60, JSON.stringify(data)); // Cache for 60 seconds
    res.json(data);

  } catch (error) {
    console.error('API error:', error);
    res.status(500).send('Server error');
  }
});

app.listen(port, () => {
  console.log(`Server running on http://localhost:${port}`);
  console.log("Try visiting http://localhost:3000/data/1 multiple times.");
});

Välimuistin mitätöintistrategiat

Välimuistituksen kannalta keskeistä on vanhentuneiden tietojen hallinta. Jos alkuperäiset tiedot muuttuvat, välimuistissa saattaa silti olla vanha versio. Tällöin tarvitaan mitätöintiä.

Time-to-Live (TTL): Välimuistissa olevien kohteiden automaattinen vanhentaminen määritetyn ajan kuluttua. Yksinkertaisin ja yleisin menetelmä.
Manuaalinen mitätöinti: Kohteen poistaminen välimuistista nimenomaisesti, kun sen lähdetiedot muuttuvat (esimerkiksi tietokantapäivityksen jälkeen).
Write-Through/Write-Back: Välimuistin päivittäminen samanaikaisesti tietokantaan kirjoitettaessa (write-through) tai sen jälkeen, kun tietokantakirjoitus on vahvistettu (write-back).

TTL:n toteuttaminen Redisillä

Redis helpottaa TTL:n toteuttamista komennoilla, kuten EXPIRE ja SETEX. SETEX on erityisen hyödyllinen, koska se asettaa avaimen ja sen vanhenemisajan yhtenä atomisena operaationa.

const Redis = require('ioredis');
const redis = new Redis();

(async () => {
  try {
    const key = 'temporary_message';
    const value = 'This message expires in 10 seconds.';
    const ttl = 10; // seconds

    console.log(`Setting '${key}' with TTL of ${ttl} seconds.`);
    await redis.setex(key, ttl, value);

    let retrievedValue = await redis.get(key);
    console.log(`Immediately after set: ${retrievedValue}`);

    console.log(`Waiting for ${ttl + 1} seconds...`);
    await new Promise(resolve => setTimeout(resolve, (ttl + 1) * 1000));

    retrievedValue = await redis.get(key);
    console.log(`After expiration: ${retrievedValue}`); // Should be null

  } catch (err) {
    console.error("Redis error:", err);
  } finally {
    redis.quit();
  }
})();

Välimuistitusstrategioiden testi

Mitä seuraavista hyödyistä saavutetaan toteuttamalla välimuistitus Node.js-sovelluksessa?

Vastaa interaktiivisessa oppitunnissa

Kertaus: välimuistitusstrategiat

Onnittelut! Olette tutustuneet Node.js:n keskeisiin välimuistitusstrategioihin.

Opimme, että välimuistitus parantaa suorituskykyä tallentamalla usein käytettyjä tietoja, vähentämällä tietokantapyyntöjä ja nopeuttamalla vastausaikoja.
Tutustuimme yksinkertaiseen muistinsisäiseen välimuistitukseen, joka tarjoaa nopean paikallisen pääsyn tietoihin.
Hajautetuissa ja skaalautuvissa ratkaisuissa Redis erottuu edukseen vankkojen ominaisuuksiensa ja useiden instanssien jakaman välimuistin ansiosta.
Lopuksi käsittelimme keskeisiä välimuistin mitätöintistrategioita, kuten TTL:ää, vanhentuneiden tietojen hallintaa varten.

Välimuistituksen hallitseminen on ratkaisevan tärkeää suorituskykyisten Node.js-sovellusten rakentamisessa.

Aloita maksutta

Opi JavaScript tekoälytuutorin avulla — ilmaiseksi

Kirjoita ja suorita oikeaa koodia selaimessa, saa välitöntä apua tekoälytuutorilta ympäri vuorokauden ja jatka siitä, mihin jäit, verkossa tai sovelluksessa.

Kurssit: 22
Oppitunnit: 92

Aloita opiskelu maksutta Näytä koko kurssi

Usein kysytyt kysymykset

Onko oppitunti ”Node.js:n välimuististrategiat” ilmainen?

Kyllä – oppitunnin ”Node.js:n välimuististrategiat” koko tekstin voi lukea täällä verkossa ilmaiseksi. Jos haluat harjoitella interaktiivisesti sisäänrakennetulla koodieditorilla ja ympäri vuorokauden käytettävissä olevan tekoälytuutorin avulla sekä avata koko Node.js-taustakehityksen bootcamp-kurssin, päivitä CoddyKit PROhon. Node.js-taustakehityksen bootcamp-kurssilla on yhteensä 4 oppituntia.

Mitä opin oppitunnilla ”Node.js:n välimuististrategiat”?

Toteuttakaa erilaisia välimuistimekanismeja, kuten Redis, vastausaikojen lyhentämiseksi ja tietokantakuorman vähentämiseksi. Harjoittelet Node.js-taustakehityksen bootcamp-aihetta koodilla, jonka suoritat suoraan selaimessa. Ympäri vuorokauden käytettävissä oleva tekoälytuutori vastaa kysymyksiisi oppitunnin aikana.

Tarvitsenko kokemusta aloittaakseni Node.js-taustakehityksen bootcamp-opiskelun?

Aiempi kokemus ei ole tarpeen. CoddyKitin Node.js-taustakehityksen bootcamp-oppimispolku sopii vasta-alkajista edistyneisiin, joten voit aloittaa tästä tai alusta ja edetä omaan tahtiisi. Tämä on oppitunti 1/4.

Kuinka kauan ”Node.js:n välimuististrategiat”-oppitunnin suorittaminen kestää?

Useimmat CoddyKitin oppitunnit kestävät noin 5–10 minuuttia. Jokainen oppitunti on lyhyt ja interaktiivinen, joten edistyt tasaisesti ja voit jatkaa siitä, mihin jäit – sekä verkossa että sovelluksessa.

Voinko kirjoittaa ja suorittaa koodia tällä Node.js-taustakehityksen bootcamp-oppitunnilla?

Kyllä. Jokainen Node.js-taustakehityksen bootcamp-oppitunti sisältää sisäänrakennetun koodieditorin, joten voit kirjoittaa ja suorittaa oikeaa koodia suoraan selaimessa ja saada välitöntä palautetta tekoälyltä – paikallista asennusta ei tarvita.

Kaikki tämän kurssin oppitunnit

Node.js:n välimuististrategiat
Node.js-sovellusten kuormantasaus
Node.js:n tapahtumasilmukan optimointi
Profilointi ja muistivuotojen havaitseminen

← Takaisin: Node.js-taustakehityksen bootcamp