Rövid útmutató: Az Azure Cache for Redis használata Node.js alkalmazással

Ebben a rövid útmutatóban az Azure Cache for Redist egy Node.js alkalmazásba építi be, amely egy biztonságos, dedikált gyorsítótárhoz való hozzáférést biztosít, amely az Azure bármely alkalmazásából elérhető.

Előfeltételek

• Azure-előfizetés. Hozzon létre egyet ingyen
• Telepített Node.js. A Node és az npm windowsos számítógépen való telepítéséről további információt a Windows Node.js telepítése című témakörben talál.

Gyorsítótár létrehozása

1. Gyorsítótár létrehozásához jelentkezzen be az Azure Portalra. A portál menüjében válassza az Erőforrás létrehozása lehetőséget.

   

2. Az Első lépések panelen írja be az Azure Cache for Redist a keresősávba. A keresési eredmények között keresse meg az Azure Cache for Redist, majd válassza a Létrehozás lehetőséget.

   

3. Az Új Redis Cache panel Alapszintű beállítások lapján konfigurálja a következő beállításokat a gyorsítótárhoz:

   Beállítás	Művelet	Leírás
   Előfizetés	Válassza ki az Azure-előfizetését.	Az Azure Cache for Redis új példányának létrehozásához használandó előfizetés.
   Erőforráscsoport	Jelöljön ki egy erőforráscsoportot, vagy válassza az Új létrehozása lehetőséget, és adjon meg egy új erőforráscsoportnevet.	Annak az erőforráscsoportnak a neve, amelyben létre szeretné hozni a gyorsítótárat és más erőforrásokat. Ha az összes alkalmazás-erőforrást egy erőforráscsoportba helyezi, egyszerűen kezelheti vagy törölheti őket.
   DNS-név	Adjon meg egy egyedi nevet.	A gyorsítótár nevének 1–63 karakterből álló sztringnek kell lennie, amely csak számokat, betűket és kötőjeleket tartalmaz. A névnek számmal vagy betűvel kell kezdődnie és végződnie, és nem tartalmazhat egymást követő kötőjeleket. A gyorsítótárpéldány gazdagépneve .\<DNS name>.redis.cache.windows.net
   Helyen	Válasszon ki egy helyet.	Olyan Azure-régió , amely a gyorsítótárat használó egyéb szolgáltatások közelében található.
   Gyorsítótár termékváltozata	Válasszon egy termékváltozatot.	Az termékváltozat határozza meg a gyorsítótár számára elérhető méretet, teljesítményt és funkcióparamétereket. További információ: Azure Cache for Redis – áttekintés.
   Gyorsítótár mérete	Válasszon egy gyorsítótárméretet.	További információ: Azure Cache for Redis – áttekintés.

4. Válassza a Hálózatkezelés lapot, vagy válassza a Tovább: Hálózatkezelés lehetőséget.

5. A Hálózatkezelés lapon válassza ki a gyorsítótárhoz használni kívánt kapcsolati módszert.

6. Válassza a Speciális lapot, vagy válassza a Tovább: Speciális lehetőséget.

7. A Speciális panelen ellenőrizze vagy válassza ki a hitelesítési módszert az alábbi információk alapján:

   

   • Alapértelmezés szerint egy új alapszintű, standard vagy prémium szintű gyorsítótár esetében a Microsoft Entra-hitelesítés engedélyezve van, és a hozzáférési kulcsok hitelesítése le van tiltva.
   • Alapszintű vagy standard gyorsítótárak esetén kiválaszthatja a nem TLS-portok kiválasztását.
   • Standard és Prémium szintű gyorsítótárak esetén engedélyezheti a rendelkezésre állási zónákat. A gyorsítótár létrehozása után nem tilthatja le a rendelkezésre állási zónákat.
   • Prémium szintű gyorsítótár esetén konfigurálja a nem TLS-port, a fürtözés, a felügyelt identitás és az adatmegőrzés beállításait.

   Fontos

   Az optimális biztonság érdekében azt javasoljuk, hogy a Microsoft Entra ID-t felügyelt identitásokkal használva engedélyezze a kéréseket a gyorsítótáron, ha lehetséges. A Microsoft Entra-azonosító és a felügyelt identitások használatával történő engedélyezés kiváló biztonságot és egyszerű használatot biztosít a megosztott hozzáférési kulcsok engedélyezésével szemben. A felügyelt identitások gyorsítótárral való használatáról további információt a Microsoft Entra ID használata gyorsítótár-hitelesítéshez című témakörben talál.

8. (Nem kötelező) Válassza a Címkék lapot, vagy válassza a Tovább: Címkék lehetőséget.

9. (Nem kötelező) A Címkék lapon adja meg a címke nevét és értékét, ha kategorizálni szeretné a gyorsítótár-erőforrást.

10. Válassza az Áttekintés + létrehozás lehetőséget.

    A Felülvizsgálat + létrehozás lapon az Azure automatikusan ellenőrzi a konfigurációt.

11. A zöld érvényesítési üzenet megjelenése után válassza a Létrehozás lehetőséget.

Az új gyorsítótár üzembe helyezése több perc alatt megtörténik. Az üzembe helyezés előrehaladását az Azure Cache for Redis Áttekintés panelen követheti nyomon. Amikor az állapot a Futtatás állapotot jeleníti meg, a gyorsítótár készen áll a használatra.

A node-redis ügyfélkódtár telepítése

A node-redis kódtár a Redis elsődleges Node.js ügyfele. Az ügyfelet az npm és a következő paranccsal telepítheti:

npm install redis

Node.js-alkalmazás létrehozása gyorsítótár eléréséhez

Hozzon létre egy Node.js alkalmazást, amely Microsoft Entra-azonosítót vagy hozzáférési kulcsokat használ az Azure Cache for Redishez való csatlakozáshoz. Javasoljuk, hogy a Microsoft Entra-azonosítót használja.

Microsoft Entra ID-hitelesítés (ajánlott)

A Microsoft Entra ID-hitelesítés engedélyezése a gyorsítótárban

Meglévő gyorsítótár esetén először ellenőrizze, hogy engedélyezve van-e a Microsoft Entra-hitelesítés. Ha nem, végezze el az alábbi lépéseket a Microsoft Entra-hitelesítés engedélyezéséhez. Javasoljuk, hogy a Microsoft Entra-azonosítót használja az alkalmazások hitelesítéséhez.

1. Az Azure Portalon válassza ki azt az Azure Cache for Redis-példányt, ahol a Microsoft Entra tokenalapú hitelesítést szeretné használni.

2. A szolgáltatás menü Beállítások területén válassza a Hitelesítés lehetőséget.

3. A Hitelesítés panelen ellenőrizze, hogy be van-e jelölve a Microsoft Entra-hitelesítés engedélyezése jelölőnégyzet. Ha igen, továbbléphet a következő szakaszra.

4. Ellenkező esetben jelölje be a Microsoft Entra-hitelesítés engedélyezése jelölőnégyzetet. Ezután adja meg egy érvényes felhasználó nevét. Válassza a Mentés lehetőséget. A megadott felhasználónevet a rendszer automatikusan hozzárendeli az adattulajdonosi hozzáférési szabályzathoz.

   A gyorsítótárhoz való csatlakozáshoz megadhat egy felügyelt identitást vagy egy szolgáltatásnevet is.

   

5. Egy párbeszédpanelen a rendszer megkérdezi, hogy frissíteni szeretné-e a konfigurációt, és a rendszer tájékoztatja, hogy a frissítés végrehajtása néhány percet vesz igénybe. Válassza az Igen lehetőséget.

   Fontos

   Ha az engedélyezési művelet befejeződött, a gyorsítótár csomópontjai újraindulnak az új konfiguráció betöltéséhez. Javasoljuk, hogy a szokásos karbantartási időszak alatt vagy a csúcsidőszakon kívül végezze el ezt a műveletet. A folyamat akár 30 percet is igénybe vehet.

A Microsoft Entra ID és az Azure CLI használatával kapcsolatos információkért tekintse meg az identitás-referenciaoldalakat.

Az Azure Identity JavaScripthez készült ügyfélkódtárának telepítése

A JavaScripthez készült Azure Identity-ügyfélkódtár a szükséges Microsoft Authentication Library (MSAL) használatával biztosítja a jogkivonat-hitelesítés támogatását. Telepítse a kódtárat az npm használatával:

npm install @azure/identity

Node.js-alkalmazás létrehozása a Microsoft Entra-azonosítóval

1. Adjon hozzá környezeti változókat az állomásnévhez és a szolgáltatásnév-azonosítóhoz.

   A szolgáltatásnév azonosítója a Microsoft Entra ID szolgáltatásnév vagy felhasználó objektumazonosítója. Az Azure Portalon ez az érték felhasználónévként jelenik meg.

   set AZURE_CACHE_FOR_REDIS_HOST_NAME=contosoCache
   set REDIS_SERVICE_PRINCIPAL_ID=XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
   

2. Hozzon létre egy redistest.js nevű szkriptfájlt.

3. Adja hozzá a következő példa JavaScriptet a fájlhoz. Ez a kód bemutatja, hogyan csatlakozhat egy Azure Cache for Redis-példányhoz a gyorsítótár-gazdagép nevének és a kulcsfontosságú környezeti változóknak a használatával. A kód emellett tárolja és lekéri gyorsítótár egyik sztringértékét. A rendszer a PING és a CLIENT LIST parancsot is végrehajtja. További példák a Redis node-redis-ügyféllel való használatára: Node-Redis.

   const { createClient } = require("redis");
   const { DefaultAzureCredential } = require("@azure/identity");
   
   async function main() {
     // Construct a Token Credential from Identity library, e.g. ClientSecretCredential / ClientCertificateCredential / ManagedIdentityCredential, etc.
     const credential = new DefaultAzureCredential();
     const redisScope = "https://redis.azure.com/.default";
   
     // Fetch a Microsoft Entra token to be used for authentication. This token will be used as the password.
     let accessToken = await credential.getToken(redisScope);
     console.log("access Token", accessToken);
   
     // Create redis client and connect to the Azure Cache for Redis over the TLS port using the access token as password.
     const cacheConnection = createClient({
       username: process.env.REDIS_SERVICE_PRINCIPAL_ID,
       password: accessToken.token,
       url: `redis://${process.env.AZURE_CACHE_FOR_REDIS_HOST_NAME}:6380`,
       pingInterval: 100000,
       socket: { 
         tls: true,
         keepAlive: 0 
       },
     });
   
     cacheConnection.on("error", (err) => console.log("Redis Client Error", err));
     await cacheConnection.connect();
   
     // PING command
     console.log("\nCache command: PING");
     console.log("Cache response : " + await cacheConnection.ping());
   
     // SET
     console.log("\nCache command: SET Message");
     console.log("Cache response : " + await cacheConnection.set("Message",
         "Hello! The cache is working from Node.js!"));
   
     // GET
     console.log("\nCache command: GET Message");
     console.log("Cache response : " + await cacheConnection.get("Message"));
   
     // Client list, useful to see if connection list is growing...
     console.log("\nCache command: CLIENT LIST");
     console.log("Cache response : " + await cacheConnection.sendCommand(["CLIENT", "LIST"]));
   
     cacheConnection.disconnect();
   
     return "Done"
   }
   
   main().then((result) => console.log(result)).catch(ex => console.log(ex));
   

4. Futtassa a szkriptet a Node.js használatával:

   node redistest.js
   

5. Ellenőrizze, hogy a kód kimenete az alábbi példához hasonlóan néz-e ki:

   Cache command: PING
   Cache response : PONG
   
   Cache command: GET Message
   Cache response : Hello! The cache is working from Node.js!
   
   Cache command: SET Message
   Cache response : OK
   
   Cache command: GET Message
   Cache response : Hello! The cache is working from Node.js!
   
   Cache command: CLIENT LIST
   Cache response : id=10017364 addr=76.22.73.183:59380 fd=221 name= age=1 idle=0 flags=N db=0 sub=0 psub=0 multi=-1 qbuf=26 qbuf-free=32742 argv-mem=10 obl=0 oll=0 omem=0 tot-mem=61466 ow=0 owmem=0 events=r cmd=client user=default numops=6
   
   Done
   

Újrahitelesítéssel rendelkező JavaScript-mintaalkalmazás létrehozása

A Microsoft Entra ID hozzáférési jogkivonatok élettartama körülbelül 75 perc. A gyorsítótárral való kapcsolat fenntartásához frissítenie kell a jogkivonatot.

Ez a példa bemutatja, hogyan frissítheti a jogkivonatot JavaScript használatával:

1. Hozzon létre egy redistestreauth.js nevű szkriptfájlt.

2. Adja hozzá a következő JavaScript-példát a fájlhoz:

    const { createClient } = require("redis");
    const { DefaultAzureCredential } = require("@azure/identity");
   
    async function returnPassword(credential) {
        const redisScope = "https://redis.azure.com/.default";
   
        // Fetch a Microsoft Entra token to be used for authentication. This token will be used as the password.
        return credential.getToken(redisScope);
    }
   
    async function main() {
      // Construct a Token Credential from Identity library, e.g. ClientSecretCredential / ClientCertificateCredential / ManagedIdentityCredential, etc.
      const credential = new DefaultAzureCredential();
      let accessToken = await returnPassword(credential);
   
      // Create redis client and connect to the Azure Cache for Redis over the TLS port using the access token as password.
      let cacheConnection = createClient({
        username: process.env.REDIS_SERVICE_PRINCIPAL_ID,
        password: accessToken.token,
        url: `redis://${process.env.AZURE_CACHE_FOR_REDIS_HOST_NAME}:6380`,
        pingInterval: 100000,
        socket: { 
          tls: true,
          keepAlive: 0 
        },
      });
   
      cacheConnection.on("error", (err) => console.log("Redis Client Error", err));
      await cacheConnection.connect();
   
      for (let i = 0; i < 3; i++) {
        try {
            // PING command
            console.log("\nCache command: PING");
            console.log("Cache response : " + await cacheConnection.ping());
   
            // SET
            console.log("\nCache command: SET Message");
            console.log("Cache response : " + await cacheConnection.set("Message",
                "Hello! The cache is working from Node.js!"));
   
            // GET
            console.log("\nCache command: GET Message");
            console.log("Cache response : " + await cacheConnection.get("Message"));
   
            // Client list, useful to see if connection list is growing...
            console.log("\nCache command: CLIENT LIST");
            console.log("Cache response : " + await cacheConnection.sendCommand(["CLIENT", "LIST"]));
          break;
        } catch (e) {
          console.log("error during redis get", e.toString());
          if ((accessToken.expiresOnTimestamp <= Date.now())|| (redis.status === "end" || "close") ) {
            await redis.disconnect();
            accessToken = await returnPassword(credential);
            cacheConnection = createClient({
              username: process.env.REDIS_SERVICE_PRINCIPAL_ID,
              password: accessToken.token,
              url: `redis://${process.env.AZURE_CACHE_FOR_REDIS_HOST_NAME}:6380`,
              pingInterval: 100000,
              socket: {
                tls: true,
                keepAlive: 0
              },
            });
          }
        }
      }
    }
   
    main().then((result) => console.log(result)).catch(ex => console.log(ex));
   

3. Futtassa a szkriptet a Node.js használatával:

   node redistestreauth.js
   

4. Ellenőrizze, hogy az alábbi példához hasonló kimenet jelenik-e meg:

    Cache command: PING
    Cache response : PONG
   
    Cache command: GET Message
    Cache response : Hello! The cache is working from Node.js!
   
    Cache command: SET Message
    Cache response : OK
   
    Cache command: GET Message
    Cache response : Hello! The cache is working from Node.js!
   
    Cache command: CLIENT LIST
    Cache response : id=10017364 addr=76.22.73.183:59380 fd=221 name= age=1 idle=0 flags=N db=0 sub=0 psub=0 multi=-1 qbuf=26 qbuf-free=32742 argv-mem=10 obl=0 oll=0 omem=0 tot-mem=61466 ow=0 owmem=0 events=r cmd=client user=default numops=6
   
   

Feljegyzés

További példák a Microsoft Entra ID használatával történő hitelesítésre a Redisben a node-redis könyvtáron keresztül, lásd a node-redis GitHub-adattárat.

Hozzáférési kulcs hitelesítése

A gazdagép nevének, portjának és hozzáférési kulcsának lekérése

Az Azure Cache for Redis-kiszolgálóhoz való csatlakozáshoz a gyorsítótár-ügyfélnek szüksége van a gyorsítótár gazdanevére, portjára és hozzáférési kulcsára. Egyes ügyfelek kissé eltérő nevek használatával hivatkozhatnak ezekre az elemekre. A gazdagép nevét, portját és kulcsait az Azure Portalon szerezheti be.

• Hozzáférési kulcs lekérése a gyorsítótárhoz:

  1. Az Azure Portalon nyissa meg a gyorsítótárat.
  2. A szolgáltatás menü Beállítások területén válassza a Hitelesítés lehetőséget.
  3. A Hitelesítés panelen válassza az Access-kulcsok lapot.
  4. A hozzáférési kulcs értékének másolásához válassza a Másolás ikont a kulcsmezőben.

  

• A gyorsítótár gazdagépnevének és portjának lekérése:

  1. Az Azure Portalon nyissa meg a gyorsítótárat.
  2. A szolgáltatás menüjében válassza az Áttekintés lehetőséget.
  3. A Gazdagép neve területen válassza a Másolás ikont a gazdagépnév értékének másolásához. A gazdagépnév értéke az űrlap <DNS name>.redis.cache.windows.net.
  4. Portok esetén válassza a Másolás ikont a portértékek másolásához.

  

Adjon hozzá környezeti változókat a gazdagép nevéhez és az elsődleges hozzáférési kulcshoz. Használja ezeket a változókat a kódból ahelyett, hogy közvetlenül a kódba szúrja be a bizalmas adatokat.

set AZURE_CACHE_FOR_REDIS_HOST_NAME=contosoCache
set AZURE_CACHE_FOR_REDIS_ACCESS_KEY=XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Csatlakozás a gyorsítótárhoz

Feljegyzés

Ne hozzon létre új kapcsolatot a kód minden egyes műveletéhez. Ehelyett a lehető legtöbbször hasznosítsa újra a kapcsolatokat.

Új Node.js-alkalmazás létrehozása

1. Hozzon létre egy redistest.js nevű új szkriptfájlt.

2. Adja hozzá a következő JavaScript-példát a fájlhoz:

   const redis = require("redis");
   
   // Environment variables for cache
   const cacheHostName = process.env.AZURE_CACHE_FOR_REDIS_HOST_NAME;
   const cachePassword = process.env.AZURE_CACHE_FOR_REDIS_ACCESS_KEY;
   
   if(!cacheHostName) throw Error("AZURE_CACHE_FOR_REDIS_HOST_NAME is empty")
   if(!cachePassword) throw Error("AZURE_CACHE_FOR_REDIS_ACCESS_KEY is empty")
   
   async function testCache() {
   
       // Connection configuration
       const cacheConnection = redis.createClient({
           // redis for TLS
           url: `redis://${cacheHostName}:6380`,
           password: cachePassword
       });
   
       // Connect to Redis
       await cacheConnection.connect();
   
       // PING command
       console.log("\nCache command: PING");
       console.log("Cache response : " + await cacheConnection.ping());
   
       // GET
       console.log("\nCache command: GET Message");
       console.log("Cache response : " + await cacheConnection.get("Message"));
   
       // SET
       console.log("\nCache command: SET Message");
       console.log("Cache response : " + await cacheConnection.set("Message",
           "Hello! The cache is working from Node.js!"));
   
       // GET again
       console.log("\nCache command: GET Message");
       console.log("Cache response : " + await cacheConnection.get("Message"));
   
       // Client list, useful to see if connection list is growing...
       console.log("\nCache command: CLIENT LIST");
       console.log("Cache response : " + await cacheConnection.sendCommand(["CLIENT", "LIST"]));
   
       // Disconnect
       cacheConnection.disconnect()
   
       return "Done"
   }
   
   testCache().then((result) => console.log(result)).catch(ex => console.log(ex));
   

   Ez a kód bemutatja, hogyan csatlakozhat egy Azure Cache for Redis-példányhoz a gyorsítótár-gazdagép nevének és a kulcsfontosságú környezeti változóknak a használatával. A kód emellett tárolja és lekéri gyorsítótár egyik sztringértékét. A rendszer a PING és a CLIENT LIST parancsot is végrehajtja. További példák a Redis node_redis-ügyféllel való használatára: Node-Redis.

3. Futtassa a szkriptet a Node.js használatával:

   node redistest.js
   

4. Ellenőrizze, hogy a kimenet az alábbi példához hasonló-e:

   Cache command: PING
   Cache response : PONG
   
   Cache command: GET Message
   Cache response : Hello! The cache is working from Node.js!
   
   Cache command: SET Message
   Cache response : OK
   
   Cache command: GET Message
   Cache response : Hello! The cache is working from Node.js!
   
   Cache command: CLIENT LIST
   Cache response : id=10017364 addr=76.22.73.183:59380 fd=221 name= age=1 idle=0 flags=N db=0 sub=0 psub=0 multi=-1 qbuf=26 qbuf-free=32742 argv-mem=10 obl=0 oll=0 omem=0 tot-mem=61466 ow=0 owmem=0 events=r cmd=client user=default numops=6
   
   Done
   

Az erőforrások eltávolítása

Ha továbbra is használni szeretné a cikkben létrehozott erőforrásokat, tartsa meg az erőforráscsoportot.

Ellenkező esetben az erőforrásokhoz kapcsolódó díjak elkerülése érdekében, ha befejezte az erőforrások használatát, törölheti a létrehozott Azure-erőforráscsoportot.

Figyelmeztetés

Az erőforráscsoport törlése nem vonható vissza. Erőforráscsoport törlésekor az erőforráscsoport összes erőforrása véglegesen törlődik. Figyeljen arra, hogy ne töröljön véletlenül erőforráscsoportot vagy erőforrásokat. Ha olyan meglévő erőforráscsoportban hozta létre az erőforrásokat, amelyekben meg szeretné tartani az erőforrásokat, az erőforráscsoport törlése helyett egyenként törölheti az egyes erőforrásokat.

Erőforráscsoport törlése

1. Jelentkezzen be az Azure Portalra, és válassza az Erőforráscsoportok elemet.

2. Jelölje ki a törölni kívánt erőforráscsoportot.

   Ha sok erőforráscsoport van, a Szűrő bármely mezőhöz mezőbe írja be a cikk végrehajtásához létrehozott erőforráscsoport nevét. A keresési eredmények listájában válassza ki az erőforráscsoportot.

   

3. Válassza az Erőforráscsoport törlése elemet.

4. Az Erőforráscsoport törlése panelen adja meg az erőforráscsoport nevét a megerősítéshez, majd válassza a Törlés lehetőséget.

   

Néhány percen belül az erőforráscsoport és annak összes erőforrása törlődik.

A mintakód letöltése

Szerezze be a Node.js gyorsútmutató-mintát a GitHubon.

Kapcsolódó tartalom

• Azure Cache for Redist használó ASP.NET webalkalmazás létrehozása