rychlý start: použití mezipaměti Azure pro Redis s webovou aplikací ASP.NET

v tomto rychlém startu použijete Visual Studio 2019 k vytvoření webové aplikace ASP.NET, která se připojuje ke službě Azure Cache pro Redis k ukládání a načítání dat z mezipaměti. Pak nasadíte aplikaci do Azure App Service.

Přeskočit na kód v GitHub

pokud chcete přeskočit přímo na kód, přečtěte si článek rychlý start ASP.NET v GitHub.

Požadavky

• Předplatné Azure – Vytvořte si ho zdarma .
• Visual Studio 2019 s úlohami pro vývoj ASP.NET a webu a vývoj pro Azure .

Vytvoření projektu sady Visual Studio

1. otevřete Visual Studio a pak vyberte soubor > nový > Project.

2. V dialogovém okně vytvořit nový projekt proveďte následující kroky:

   

   a. do vyhledávacího pole zadejte C# ASP.NET webové aplikace.

   b. vyberte ASP.NET webové aplikace (.NET Framework).

   c. Vyberte Další.

3. v poli Project název zadejte název projektu. V tomto příkladu jsme použili ContosoTeamStats.

4. ověřte, zda je vybrána možnost .NET Framework 4.6.1 nebo vyšší.

5. Vyberte Vytvořit.

6. Jako typ projektu vyberte MVC.

7. Ujistěte se, že v nastavení Ověřování je zadáno Bez ověřování. V závislosti na verzi sady Visual Studio může být výchozí hodnotou nastavení Ověřování něco jiného. Chcete-li ji změnit, vyberte Změnit ověřování a pak Bez ověřování.

8. Vyberte Vytvořit a vytvořte projekt.

Vytvoření mezipaměti

V dalším kroku vytvoříte pro aplikaci mezipaměť.

1. Pokud chcete vytvořit mezipaměť, přihlaste se k Azure Portal a vyberte Vytvořit prostředek.

   

2. Na stránce Nový vyberte Databáze a pak vyberte Azure Cache for Redis.

   

3. Na stránce Nový Redis Cache nakonfigurujte nastavení nové mezipaměti.

   Nastavení	Volba hodnoty	Popis
   Předplatné	Rozevírací seznam a vyberte své předplatné.	Předplatné, ve kterém chcete vytvořit tuto novou Azure Cache for Redis instance.
   Skupina prostředků	Rozevírací seznam a vyberte skupinu prostředků nebo vyberte Vytvořit novou a zadejte název nové skupiny prostředků.	Název skupiny prostředků, ve které chcete vytvořit mezipaměť a další prostředky. Když všechny prostředky aplikace dáte do jedné skupiny prostředků, můžete je snadno spravovat nebo odstraňovat společně.
   Název DNS	Zadejte jedinečný název.	Název mezipaměti musí být řetězec o 1 až 63 znacích, který obsahuje pouze číslice, písmena nebo pomlčky. Název musí začínět a končovat číslem nebo písmenem a nesmí obsahovat po sobě jdoucí pomlčky. Název hostitele instance mezipaměti bude <DNS name> .redis.cache.windows.net.
   Umístění	Rozevírací seznam a vyberte umístění.	Vyberte oblast blízko jiných služeb, které budou používat vaši mezipaměť.
   Typ mezipaměti	Rozevírací seznam a vyberte vrstvu.	Úroveň určuje velikost, výkon a funkce, které jsou pro mezipaměť k dispozici. Další informace najdete v tématu Azure Cache for Redis .

4. Vyberte kartu Sítě nebo vyberte tlačítko Sítě v dolní části stránky.

5. Na kartě Sítě vyberte metodu připojení.

6. Vyberte kartu Další: Upřesnit nebo vyberte tlačítko Další: Upřesnit v dolní části stránky.

7. Na kartě Upřesnit instance základní nebo standardní mezipaměti vyberte přepínač Povolit, pokud chcete povolit port, který není TLS. Můžete také vybrat, kterou verzi Redis chcete použít, a to buď 4, nebo 6.

   

8. Na kartě Upřesnit pro instanci služby Premium Cache nakonfigurujte nastavení pro porty bez TLS, clustering a trvalost dat. Můžete také vybrat, kterou verzi Redis chcete použít, a to buď 4, nebo 6.

9. Vyberte kartu Další: Značky nebo vyberte tlačítko Další: Značky v dolní části stránky.

10. Volitelně můžete na kartě Značky zadat název a hodnotu, pokud chcete prostředek kategorizovat.

11. Vyberte Zkontrolovat a vytvořit. Budete na kartě Zkontrolovat a vytvořit, kde Azure ověří vaši konfiguraci.

12. Jakmile se zobrazí zelená zpráva Ověření bylo předáno, vyberte Vytvořit.

Vytvoření mezipaměti chvíli trvá. Průběh můžete sledovat na Azure Cache for Redis přehledu. Když se stav zobrazí jako Spuštěno, je mezipaměť připravená k použití.

Načtení názvu hostitele, portů a přístupových klíčů z Azure Portal

Pro připojení k instanci Azure Cache for Redis potřebují klienti mezipaměti název hostitele, porty a klíč pro mezipaměť. Někteří klienti mohou tyto položky označovat trochu odlišnými názvy. Název hostitele, porty a klíče můžete získat z Azure Portal .

• Přístupové klíče získáte tak, že v levé navigaci v mezipaměti vyberete Přístupové klíče.

  

• Pokud chcete získat název hostitele a porty, v levém navigačním panelu mezipaměti vyberte Vlastnosti. Název hostitele má tvar <DNS name> .redis.cache.windows.net.

  

Úprava souboru CacheSecrets.config

1. Vytvořte v počítači soubor s názvem CacheSecrets.config. Umístěte ho do umístění, kde se nevrátí se změnami zdrojový kód ukázkové aplikace. V tomto rychlém startu je soubor CacheSecrets.config umístěný zde: C:\AppSecrets\CacheSecrets.config.

2. Upravte soubor CacheSecrets.config. Pak přidejte následující obsah:

   <appSettings>
       <add key="CacheConnection" value="<cache-name>.redis.cache.windows.net,abortConnect=false,ssl=true,allowAdmin=true,password=<access-key>"/>
   </appSettings>
   

3. <cache-name> nahraďte názvem hostitele mezipaměti.

4. <access-key> nahraďte primárním klíčem mezipaměti.

   Tip

   Při rotaci klíčů můžete použít sekundární přístupový klíč jako alternativní klíč během opětovného generování primárního přístupového klíče.

5. Soubor uložte.

Aktualizace aplikace MVC

V této části aktualizujete aplikaci tak, aby podporovala nové zobrazení, které zobrazuje jednoduchý test proti službě Azure cache pro Redis.

• Aktualizace souboru web.config o nastavení aplikace pro mezipaměť
• Konfigurace aplikace pro používání klienta StackExchange.Redis
• Aktualizace souboru HomeController a rozložení
• Přidání nového zobrazení RedisCache

Aktualizace souboru web.config o nastavení aplikace pro mezipaměť

Když aplikaci spouštíte místně, informace v CacheSecrets.config slouží k připojení ke službě Azure cache pro instanci Redis. Později tuto aplikaci nasadíte do Azure. Přitom nakonfigurujete nastavení aplikace v Azure tak, aby aplikace místo použití tohoto souboru načetla informace o připojení k mezipaměti.

Protože soubor CacheSecrets.config není nasazený v Azure společně s aplikací, použijete ho jen při místním testování aplikace. Tyto informace maximálně zabezpečte, abyste zabránili škodlivému přístupu k datům mezipaměti.

Aktualizace souboru web.config

1. V Průzkumníku řešení otevřete poklikáním soubor web.config.

   

2. V souboru web.config vyhledejte element <appSetting>. Potom přidejte tento atribut file. Pokud jste použili jiný název souboru nebo umístění, nahraďte těmito hodnotami hodnoty uvedené v příkladu.

• Před: <appSettings>
• Konci <appSettings file="C:\AppSecrets\CacheSecrets.config">

Modul runtime ASP.NET sloučí obsah externího souboru se značkami v elementu <appSettings>. Pokud zadaný soubor nelze nalézt, modul runtime atribut souboru ignoruje. Vaše tajné kódy (připojovací řetězce k mezipaměti) nejsou součástí zdrojového kódu aplikace. Když nasadíte webovou aplikaci do Azure, soubor CacheSecrets.config není nasazený.

Konfigurace aplikace pro používání StackExchange.Redis

1. Pokud chcete aplikaci nakonfigurovat tak, aby používala balíček NuGet StackExchange.Redis pro Visual Studio, vyberte Nástroje > Správce balíčků NuGet > Konzola Správce balíčků.

2. V okně Package Manager Console spusťte následující příkaz:

   Install-Package StackExchange.Redis
   

3. balíček NuGet stahuje a přidává požadované odkazy na sestavení pro vaši klientskou aplikaci pro přístup do mezipaměti azure pro Redis pomocí klienta StackExchange. azure cache pro Redis. Pokud upřednostňujete použití verze klientské knihovny StackExchange.Redis se silným názvem, nainstalujte balíček StackExchange.Redis.

Aktualizace souboru HomeController a rozložení

1. V Průzkumníku řešení rozbalte složku Kontrolery a otevřete soubor HomeController.cs.

2. Do using horní části souboru přidejte následující příkazy.

   using StackExchange.Redis;
   using System.Configuration;
   using System.Net.Sockets;
   using System.Text;
   using System.Threading;
   

3. Do třídy přidejte následující členy HomeController , aby podporovaly novou RedisCache akci, která spustí některé příkazy pro novou mezipaměť.

        public async Task<ActionResult> RedisCache()
       {
           ViewBag.Message = "A simple example with Azure Cache for Redis on ASP.NET.";
   
           if (Connection == null)
           {
               await InitializeAsync();
           }
   
           IDatabase cache = await GetDatabaseAsync();
   
           // Perform cache operations using the cache object...
   
           // Simple PING command
           ViewBag.command1 = "PING";
           ViewBag.command1Result = cache.Execute(ViewBag.command1).ToString();
   
           // Simple get and put of integral data types into the cache
           ViewBag.command2 = "GET Message";
           ViewBag.command2Result = cache.StringGet("Message").ToString();
   
           ViewBag.command3 = "SET Message \"Hello! The cache is working from ASP.NET!\"";
           ViewBag.command3Result = cache.StringSet("Message", "Hello! The cache is working from ASP.NET!").ToString();
   
           // Demonstrate "SET Message" executed as expected...
           ViewBag.command4 = "GET Message";
           ViewBag.command4Result = cache.StringGet("Message").ToString();
   
           // Get the client list, useful to see if connection list is growing...
           // Note that this requires allowAdmin=true in the connection string
           ViewBag.command5 = "CLIENT LIST";
           StringBuilder sb = new StringBuilder();
           var endpoint = (System.Net.DnsEndPoint)(await GetEndPointsAsync())[0];
           IServer server = await GetServerAsync(endpoint.Host, endpoint.Port);
           ClientInfo[] clients = await server.ClientListAsync();
   
           sb.AppendLine("Cache response :");
           foreach (ClientInfo client in clients)
           {
               sb.AppendLine(client.Raw);
           }
   
           ViewBag.command5Result = sb.ToString();
   
           return View();
       }
   
       private static long _lastReconnectTicks = DateTimeOffset.MinValue.UtcTicks;
       private static DateTimeOffset _firstErrorTime = DateTimeOffset.MinValue;
       private static DateTimeOffset _previousErrorTime = DateTimeOffset.MinValue;
   
       private static SemaphoreSlim _reconnectSemaphore = new SemaphoreSlim(initialCount: 1, maxCount: 1);
       private static SemaphoreSlim _initSemaphore = new SemaphoreSlim(initialCount: 1, maxCount: 1);
   
       private static ConnectionMultiplexer _connection;
       private static bool _didInitialize = false;
   
       // In general, let StackExchange.Redis handle most reconnects,
       // so limit the frequency of how often ForceReconnect() will
       // actually reconnect.
       public static TimeSpan ReconnectMinInterval => TimeSpan.FromSeconds(60);
   
       // If errors continue for longer than the below threshold, then the
       // multiplexer seems to not be reconnecting, so ForceReconnect() will
       // re-create the multiplexer.
       public static TimeSpan ReconnectErrorThreshold => TimeSpan.FromSeconds(30);
   
       public static TimeSpan RestartConnectionTimeout => TimeSpan.FromSeconds(15);
   
       public static int RetryMaxAttempts => 5;
   
       public static ConnectionMultiplexer Connection { get { return _connection; } }
   
       public static async Task InitializeAsync()
       {
           if (_didInitialize)
           {
               throw new InvalidOperationException("Cannot initialize more than once.");
           }
   
           _connection = await CreateConnectionAsync();
           _didInitialize = true;
       }
   
       // This method may return null if it fails to acquire the semaphore in time.
       // Use the return value to update the "connection" field
       private static async Task<ConnectionMultiplexer> CreateConnectionAsync()
       {
           if (_connection != null)
           {
               // If we already have a good connection, let's re-use it
               return _connection;
           }
   
           try
           {
               await _initSemaphore.WaitAsync(RestartConnectionTimeout);
           }
           catch
           {
               // We failed to enter the semaphore in the given amount of time. Connection will either be null, or have a value that was created by another thread.
               return _connection;
           }
   
           // We entered the semaphore successfully.
           try
           {
               if (_connection != null)
               {
                   // Another thread must have finished creating a new connection while we were waiting to enter the semaphore. Let's use it
                   return _connection;
               }
   
               // Otherwise, we really need to create a new connection.
               string cacheConnection = ConfigurationManager.AppSettings["CacheConnection"].ToString();
               return await ConnectionMultiplexer.ConnectAsync(cacheConnection);
           }
           finally
           {
               _initSemaphore.Release();
           }
       }
   
       private static async Task CloseConnectionAsync(ConnectionMultiplexer oldConnection)
       {
           if (oldConnection == null)
           {
               return;
           }
           try
           {
               await oldConnection.CloseAsync();
           }
           catch (Exception)
           {
               // Ignore any errors from the oldConnection
           }
       }
   
       /// <summary>
       /// Force a new ConnectionMultiplexer to be created.
       /// NOTES:
       ///     1. Users of the ConnectionMultiplexer MUST handle ObjectDisposedExceptions, which can now happen as a result of calling ForceReconnectAsync().
       ///     2. Call ForceReconnectAsync() for RedisConnectionExceptions and RedisSocketExceptions. You can also call it for RedisTimeoutExceptions,
       ///         but only if you're using generous ReconnectMinInterval and ReconnectErrorThreshold. Otherwise, establishing new connections can cause
       ///         a cascade failure on a server that's timing out because it's already overloaded.
       ///     3. The code will:
       ///         a. wait to reconnect for at least the "ReconnectErrorThreshold" time of repeated errors before actually reconnecting
       ///         b. not reconnect more frequently than configured in "ReconnectMinInterval"
       /// </summary>
       public static async Task ForceReconnectAsync()
       {
           var utcNow = DateTimeOffset.UtcNow;
           long previousTicks = Interlocked.Read(ref _lastReconnectTicks);
           var previousReconnectTime = new DateTimeOffset(previousTicks, TimeSpan.Zero);
           TimeSpan elapsedSinceLastReconnect = utcNow - previousReconnectTime;
   
           // If multiple threads call ForceReconnectAsync at the same time, we only want to honor one of them.
           if (elapsedSinceLastReconnect < ReconnectMinInterval)
           {
               return;
           }
   
           try
           {
               await _reconnectSemaphore.WaitAsync(RestartConnectionTimeout);
           }
           catch
           {
               // If we fail to enter the semaphore, then it is possible that another thread has already done so.
               // ForceReconnectAsync() can be retried while connectivity problems persist.
               return;
           }
   
           try
           {
               utcNow = DateTimeOffset.UtcNow;
               elapsedSinceLastReconnect = utcNow - previousReconnectTime;
   
               if (_firstErrorTime == DateTimeOffset.MinValue)
               {
                   // We haven't seen an error since last reconnect, so set initial values.
                   _firstErrorTime = utcNow;
                   _previousErrorTime = utcNow;
                   return;
               }
   
               if (elapsedSinceLastReconnect < ReconnectMinInterval)
               {
                   return; // Some other thread made it through the check and the lock, so nothing to do.
               }
   
               TimeSpan elapsedSinceFirstError = utcNow - _firstErrorTime;
               TimeSpan elapsedSinceMostRecentError = utcNow - _previousErrorTime;
   
               bool shouldReconnect =
                   elapsedSinceFirstError >= ReconnectErrorThreshold // Make sure we gave the multiplexer enough time to reconnect on its own if it could.
                   && elapsedSinceMostRecentError <= ReconnectErrorThreshold; // Make sure we aren't working on stale data (e.g. if there was a gap in errors, don't reconnect yet).
   
               // Update the previousErrorTime timestamp to be now (e.g. this reconnect request).
               _previousErrorTime = utcNow;
   
               if (!shouldReconnect)
               {
                   return;
               }
   
               _firstErrorTime = DateTimeOffset.MinValue;
               _previousErrorTime = DateTimeOffset.MinValue;
   
               ConnectionMultiplexer oldConnection = _connection;
               await CloseConnectionAsync(oldConnection);
               _connection = null;
               _connection = await CreateConnectionAsync();
               Interlocked.Exchange(ref _lastReconnectTicks, utcNow.UtcTicks);
           }
           finally
           {
               _reconnectSemaphore.Release();
           }
       }
   
       // In real applications, consider using a framework such as
       // Polly to make it easier to customize the retry approach.
       private static async Task<T> BasicRetryAsync<T>(Func<T> func)
       {
           int reconnectRetry = 0;
           int disposedRetry = 0;
   
           while (true)
           {
               try
               {
                   return func();
               }
               catch (Exception ex) when (ex is RedisConnectionException || ex is SocketException)
               {
                   reconnectRetry++;
                   if (reconnectRetry > RetryMaxAttempts)
                       throw;
                   await ForceReconnectAsync();
               }
               catch (ObjectDisposedException)
               {
                   disposedRetry++;
                   if (disposedRetry > RetryMaxAttempts)
                       throw;
               }
           }
       }
   
       public static Task<IDatabase> GetDatabaseAsync()
       {
           return BasicRetryAsync(() => Connection.GetDatabase());
       }
   
       public static Task<System.Net.EndPoint[]> GetEndPointsAsync()
       {
           return BasicRetryAsync(() => Connection.GetEndPoints());
       }
   
       public static Task<IServer> GetServerAsync(string host, int port)
       {
           return BasicRetryAsync(() => Connection.GetServer(host, port));
       }
   

4. V Průzkumníku řešení rozbalte složku Zobrazení > Sdílené. Potom otevřete soubor _Layout.cshtml.

   Nahraďte:

   @Html.ActionLink("Application name", "Index", "Home", new { area = "" }, new { @class = "navbar-brand" })
   

   textem:

   @Html.ActionLink("Azure Cache for Redis Test", "RedisCache", "Home", new { area = "" }, new { @class = "navbar-brand" })
   

Přidání nového zobrazení RedisCache

1. V Průzkumníku řešení rozbalte složku Zobrazení a klikněte pravým tlačítkem na složku Domů. Zvolit Přidat > zobrazení....

2. V dialogovém okně Přidat zobrazení jako název zobrazení zadejte RedisCache. Pak vyberte Přidat.

3. Kód v souboru RedisCache.cshtml nahraďte následujícím kódem:

   @{
       ViewBag.Title = "Azure Cache for Redis Test";
   }
   
   <h2>@ViewBag.Title.</h2>
   <h3>@ViewBag.Message</h3>
   <br /><br />
   <table border="1" cellpadding="10">
       <tr>
           <th>Command</th>
           <th>Result</th>
       </tr>
       <tr>
           <td>@ViewBag.command1</td>
           <td><pre>@ViewBag.command1Result</pre></td>
       </tr>
       <tr>
           <td>@ViewBag.command2</td>
           <td><pre>@ViewBag.command2Result</pre></td>
       </tr>
       <tr>
           <td>@ViewBag.command3</td>
           <td><pre>@ViewBag.command3Result</pre></td>
       </tr>
       <tr>
           <td>@ViewBag.command4</td>
           <td><pre>@ViewBag.command4Result</pre></td>
       </tr>
       <tr>
           <td>@ViewBag.command5</td>
           <td><pre>@ViewBag.command5Result</pre></td>
       </tr>
   </table>
   

Místní spuštění aplikace

ve výchozím nastavení je projekt konfigurován pro místní hostování aplikace v IIS Express pro účely testování a ladění.

Spuštění aplikace místně

1. v Visual Studio vyberte ladit > spustit ladění a sestavte a spusťte aplikaci místně pro účely testování a ladění.

2. V prohlížeči na navigačním panelu vyberte Azure cache for Redis test .

3. V následujícím příkladu Message měl klíč dříve hodnotu uloženou v mezipaměti, která byla nastavena pomocí konzoly Azure cache for Redis na portálu. Aplikace tuto hodnotu z mezipaměti aktualizovala. Aplikace rovněž spustila příkazy PING a CLIENT LIST.

   

Publikování a spuštění v Azure

Jakmile aplikaci úspěšně místně otestujete, můžete ji nasadit do Azure a spustit v cloudu.

Publikování aplikace do Azure

1. V sadě Visual Studio klikněte pravým tlačítkem na uzel projektu v Průzkumníku řešení. Potom vyberte Publikovat.

   

2. Vyberte Microsoft Azure App Service, dále Vytvořit nový a nakonec Publikovat.

   

3. V dialogovém okně Vytvořit plán App Service udělejte následující změny:

   Nastavení	Doporučená hodnota	Popis
   Název aplikace	Použijte výchozí hodnotu.	Po nasazení do Azure se název aplikace stane názvem hostitele této aplikace. Kvůli zachování jedinečnosti může být v případě potřeby tento název doplněný o časové razítko.
   Předplatné	Zvolte svoje předplatné Azure.	K tomuto předplatnému se účtují všechny související poplatky za hosting. Pokud máte několik předplatných Azure, zkontrolujte, že je vybrané to správné.
   Skupina prostředků	Použijte stejnou skupinu prostředků, ve které jste vytvořili mezipaměť (například TestResourceGroup).	Skupina prostředků vám pomůže spravovat všechny prostředky jako skupinu. Až budete později chtít aplikaci odstranit, stačí jen odstranit tuto skupinu.
   App Service plánu	Vyberte Nový a potom vytvořte nový plán služby App Service s názvem TestingPlan. Použijte stejné Umístění jako při vytváření mezipaměti. Jako velikost zvolte Free.	Plán služby App Service definuje sadu výpočetních prostředků pro provozování webové aplikace.

   

4. Až nakonfigurujete nastavení hostingu služby App Service, vyberte Vytvořit.

5. Sledujte okno Výstup v sadě Visual Studio, kde se zobrazuje stav publikování. Po publikování aplikace se zaprotokoluje adresa URL aplikace:

   

Přidání nastavení aplikace pro mezipaměť

Po publikování nové aplikace přidejte nové nastavení aplikace. Toto nastavení slouží k uložení informací o připojení k mezipaměti.

Přidání nastavení aplikace

1. Do panelu hledání nahoře na portálu Azure Portal zadejte název aplikace a vyhledejte novou aplikaci, kterou jste vytvořili.

   

2. Přidejte nové nastavení aplikace s názvem PřipojeníKMezipaměti, které aplikace použije pro připojení k mezipaměti. Použijte stejnou hodnotu, jakou jste pro CacheConnection nakonfigurovali v souboru TajnéKódyMezipaměti.config. Tato hodnota obsahuje název hostitele mezipaměti a přístupový klíč.

   

Spuštění aplikace v Azure

V prohlížeči přejděte na adresu URL aplikace. Tato adresa se zobrazuje ve výsledcích operace publikování v okně výstupu v sadě Visual Studio. Je také k dispozici na portálu Azure Portal na stránce přehledu aplikace, kterou jste vytvořili.

Na Azure Cache for Redis panelu vyberte Test a otestujte přístup k mezipaměti.

Vyčištění prostředků

Pokud budete pokračovat k dalšímu kurzu, můžete prostředky vytvořené v tomto rychlém startu zachovat a znovu je použít.

V opačném případě, pokud jste už s ukázkovou aplikací v tomto rychlém startu skončili, můžete prostředky Azure vytvořené v tomto rychlém startu odstranit, abyste se vyhnuli poplatkům.

Odstranění skupiny prostředků

1. Přihlaste se k portálu Azure Portal a potom vyberte Skupiny prostředků.

2. Do pole Filtrovat podle názvu zadejte název vaší skupiny prostředků. V pokynech v tomto článku se používala skupina prostředků TestResources. U skupiny prostředků ve výsledcích hledání vyberte ... a pak vyberte Odstranit skupinu prostředků.

   

Zobrazí se výzva k potvrzení odstranění skupiny prostředků. Potvrďte odstranění zadáním názvu vaší skupiny prostředků a vyberte Odstranit.

Po chvíli se skupina prostředků včetně všech prostředků, které obsahuje, odstraní.

Další kroky

V dalším kurzu použijete aplikaci Azure Cache for Redis realističtějším scénáři ke zlepšení výkonu aplikace. Tuto aplikaci aktualizujete tak, aby do mezipaměti ukládala tabulku výsledků s využitím principu s doplňováním mezipaměti aplikací pomocí ASP.NET a databáze.