hızlı başlangıç: ASP.NET web uygulamasıyla redsıs için Azure önbelleğini kullanma

bu hızlı başlangıçta, önbellekteki verileri depolamak ve almak üzere redsıs için Azure önbelleğine bağlanan bir ASP.NET web uygulaması oluşturmak için Visual Studio 2019 ' i kullanırsınız. Ardından uygulamayı Azure App Service ' ye dağıtırsınız.

GitHub koda atlayın

koda doğrudan atlamak istiyorsanız GitHub ASP.NET hızlı başlangıç bölümüne bakın.

Önkoşullar

• Azure aboneliği- ücretsiz olarak bir tane oluşturun
• ASP.NET ve web geliştirme ve Azure geliştirme iş yükleriyle Visual Studio 2019 .

Visual Studio projesini oluşturma

1. Visual Studio açın ve sonra dosya > yeni > Project' ni seçin.

2. Yeni proje oluştur iletişim kutusunda aşağıdaki adımları uygulayın:

   

   a. arama kutusuna C# ASP.NET Web uygulaması girin.

   b. ASP.NET Web uygulaması ' nı (.NET Framework) seçin.

   c. İleri’yi seçin.

3. Project adı kutusunda, projeye bir ad verin. Bu örnekte biz ContosoTeamStats kullandık.

4. .NET Framework 4.6.1 veya üzeri bir sürümü seçildiğini doğrulayın.

5. Oluştur’u seçin.

6. Proje türü olarak MVC’yi seçin.

7. Kimlik Doğrulama ayarları için Kimlik Doğrulaması Yok seçeneğinin belirtildiğinden emin olun. Visual Studio sürümünüze bağlı olarak, varsayılan Kimlik Doğrulama ayarı farklı olabilir. Değiştirmek için Kimlik Doğrulamasını Değiştir’i ve ardından Kimlik Doğrulaması Yok’u seçin.

8. Projeyi oluşturmak için Oluştur'u seçin.

Bir önbellek oluşturma

Daha sonra, uygulama için önbellek oluşturursunuz.

1. Önbellek oluşturmak için Azure Portal oturum açın ve kaynak oluştur' u seçin.

   

2. Yeni sayfada veritabanları ' nı seçin ve ardından redsıs için Azure önbelleği' ni seçin.

   

3. Yeni Redis Cache sayfasında, yeni önbelleğiniz için ayarları yapılandırın.

   Ayar	Değer seçme	Açıklama
   Abonelik	Açılır ve aboneliğinizi seçin.	Redsıs örneği için bu yeni Azure önbelleğinin oluşturulacağı abonelik.
   Kaynak grubu	Açılır ve bir kaynak grubu seçin veya Yeni oluştur ' u seçin ve yeni bir kaynak grubu adı girin.	Önbelleğinizin ve diğer kaynaklarınızın oluşturulacağı kaynak grubunun adı. Tüm uygulama kaynaklarınızı tek bir kaynak grubuna yerleştirerek, bunları birlikte kolayca yönetebilir veya silebilirsiniz.
   DNS adı	Benzersiz bir ad girin.	Önbellek adı yalnızca rakam, harf veya kısa çizgi içeren 1 ile 63 karakter arasında bir dize olmalıdır. Ad bir sayı veya harfle başlamalı ve bitmeli ve ardışık kısa çizgi içeremez. Önbellek örneğinizin ana bilgisayar adı <DNS name> . Redis.cache.Windows.net olacaktır.
   Konum	Açılır ve bir konum seçin.	Önbelleğinizi kullanacak diğer hizmetlerin yakınında bir bölge seçin.
   Önbellek türü	Açılır ve bir Katmanseçin.	Katman, önbellek için kullanılabilen boyut, performans ve özellikleri belirler. Daha fazla bilgi için bkz. redsıs Için Azure önbelleği 'Ne genel bakış.

4. Ağ sekmesini seçin veya sayfanın altındaki ağ düğmesini seçin.

5. Ağ sekmesinde, bağlantı yönteminizi seçin.

6. İleri: Gelişmiş sekmesini seçin veya sayfanın altındaki İleri: Gelişmiş düğmesini seçin.

7. Bir temel veya standart önbellek örneğinin Gelişmiş SEKMESINDE, TLS olmayan bir bağlantı noktasını etkinleştirmek istiyorsanız geçişi etkinleştir ' i seçin. Ayrıca, 4 veya 6 ' da kullanmak istediğiniz redo sürümünü seçebilirsiniz.

   

8. Premium önbellek örneğinin Gelişmiş SEKMESINDE, TLS olmayan bağlantı noktası, kümeleme ve veri kalıcılığı için ayarları yapılandırın. Ayrıca, 4 veya 6 ' da kullanmak istediğiniz redo sürümünü seçebilirsiniz.

9. Sonraki: Etiketler sekmesini seçin veya sayfanın altındaki Sonraki: Etiketler düğmesini seçin.

10. İsteğe bağlı olarak, Etiketler sekmesinde, kaynağı sınıflandırmak istiyorsanız ad ve değeri girin.

11. Gözden geçir ve oluştur’u seçin. Azure 'un yapılandırmanızı doğruladığı, gözden geçir + Oluştur sekmesine götürülürsünüz.

12. Yeşil doğrulama başarılı iletisi göründüğünde Oluştur' u seçin.

Önbelleğin oluşturulması biraz zaman alır. Redsıs genel bakış sayfasında ilerlemeyi izleyebilirsiniz. Durum çalışıyor olarak görüntülendiğinde, önbellek kullanıma hazırdır.

Azure portal ana bilgisayar adı, bağlantı noktaları ve erişim anahtarlarını alın

Redsıs örneği için bir Azure önbelleğine bağlanmak üzere önbellek istemcilerinin, önbellek için ana bilgisayar adı, bağlantı noktaları ve bir anahtar olması gerekir. Bazı istemciler bu öğelere biraz daha farklı adlarla başvurabilir. Ana bilgisayar adı, bağlantı noktaları ve anahtarları Azure Portaledinebilirsiniz.

• Önbellek sol gezininizden erişim anahtarlarını almak için erişim tuşları' nı seçin.

  

• Ana bilgisayar adını ve bağlantı noktalarını, önbellek sol gezininizden almak için Özellikler' i seçin. Ana bilgisayar adı <DNS name> . Redis.cache.Windows.net biçimindedir.

  

CacheSecrets.config dosyasını düzenlemek için

1. Bilgisayarınızda CacheSecrets.config adlı bir dosya oluşturun. Örnek uygulamanızın kaynak koduyla iade edilmeyeceği bir konuma koyun. Bu hızlı başlangıç için CacheSecrets.config dosyası şu konumda bulunur: C:\AppSecrets\CacheSecrets.config.

2. CacheSecrets.config dosyasını düzenleyin. Ardından aşağıdaki içeriği ekleyin:

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

3. <cache-name> adını, önbellek ana bilgisayar adınızla değiştirin.

4. <access-key> adını, önbelleğinizin birincil anahtarıyla değiştirin.

   İpucu

   Birincil erişim anahtarını yeniden oluştururken anahtar döndürme sırasında alternatif anahtar olarak ikincil erişim anahtarını kullanabilirsiniz.

5. Dosyayı kaydedin.

MVC uygulamasını güncelleştirme

Bu bölümde, Redsıs için Azure önbelleğine yönelik basit bir testi görüntüleyen yeni bir görünümü destekleyecek şekilde uygulamayı güncelliyoruz.

• Önbellek için uygulama ayarı ile web.config dosyasını güncelleştirme
• StackExchange.Redis istemcisini kullanmak için uygulamayı yapılandırma
• HomeController ve Düzeni güncelleştirme
• Yeni RedisCache görünümü ekleme

Önbellek için uygulama ayarı ile web.config dosyasını güncelleştirme

Uygulamayı yerel olarak çalıştırdığınızda CacheSecrets.config Içindeki bilgiler redsıs örneği Için Azure önbelleğinize bağlanmak için kullanılır. Daha sonra bu uygulamayı Azure’a dağıtırsınız. O aşamada, uygulamanın bu dosya yerine önbellek bağlantı bilgilerini almak için kullandığı Azure’daki bir uygulama ayarını yapılandırırsınız.

CacheSecrets.config dosyası uygulamanızla Azure’a dağıtılmadığından bunu yalnızca uygulamayı yerel olarak test ederken kullanırsınız. Önbellek verilerinize kötü amaçlı erişimi önlemek için bu bilgileri olabildiğince güvende tutun.

Web.config dosyasını güncelleştirmek için

1. Çözüm Gezgini’nde, web.config dosyasına çift tıklayarak dosyayı açarsınız.

   

2. Web.config dosyasında <appSetting> öğesini bulun. Ardından, aşağıdaki file özniteliğini ekleyin. Farklı bir dosya adı veya konumu kullandıysanız, örnekte gösterilenlerin yerine bu değerleri koyun.

• Önce: <appSettings>
• Sonra <appSettings file="C:\AppSecrets\CacheSecrets.config">

ASP.NET çalışma zamanı, <appSettings> öğesindeki biçimlendirmeye sahip harici dosyasının içeriğini birleştirir. Belirtilen dosya bulunamazsa, çalışma zamanı dosya özniteliğini yok sayar. Gizli anahtarlarınız (önbelleğinize bağlantı dizisi) uygulamanız için kaynak kodun bir parçası olarak dahil edilmez. Web uygulamanızı Azure 'a dağıttığınızda CacheSecrets.config dosyası dağıtılmaz.

Uygulamayı StackExchange.Redis kullanacak şekilde yapılandırmak için

1. Visual Studio’da StackExchange.Redis NuGet paketi kullanmak üzere uygulamayı yapılandırmak için Araçlar > NuGet Paket Yöneticisi > Paket Yöneticisi Konsolu'nu seçin.

2. Package Manager Console penceresinden aşağıdaki komutu çalıştırın:

   Install-Package StackExchange.Redis
   

3. NuGet paketi indirilir ve istemci uygulamanız için gerekli derleme başvurularını, stackexchange. redsıs istemcisi için azure önbelleği ile redsıs 'e erişmek üzere ekler. StackExchange.Redis istemci kitaplığının tanımlayıcı adlı bir sürümünü kullanmak istiyorsanız StackExchange.Redis paketini yükleyin.

HomeController ve Layout'u güncelleştirmek için

1. Çözüm Gezgini’nde, Denetleyiciler klasörünü genişletin ve ardından HomeController.cs dosyasını açın.

2. Aşağıdaki using deyimlerini dosyanın en üstüne ekleyin.

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

3. HomeController RedisCache Yeni önbellekte bazı komutları çalıştıran yeni bir eylemi desteklemek için aşağıdaki üyeleri sınıfına ekleyin.

        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. Çözüm Gezgini'nde, Görünümler > Paylaşılan klasörünü genişletin. Ardından _Layout.cshtml dosyasını açın.

   Değiştir:

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

   Yeni değer:

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

Yeni RedisCache görünümü eklemek için

1. Çözüm Gezgini’nde Görünümler klasörünü genişletin ve Giriş klasörüne sağ tıklayın. Görünüm Ekle > ... seçeneğini belirleyin.

2. Görünüm Ekle iletişim kutusunda Görünüm Adı olarak RedisCache girin. Ardından Ekle'yi seçin.

3. RedisCache.cshtml dosyasındaki kodu aşağıdaki kodla değiştirin:

   @{
       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>
   

Uygulamayı yerel olarak çalıştırma

varsayılan olarak, proje, uygulamayı test ve hata ayıklama için IIS Express yerel olarak barındıracak şekilde yapılandırılmıştır.

Uygulamayı yerel olarak çalıştırmak için

1. Visual Studio, > test ve hata ayıklama için uygulamayı yerel olarak derlemek ve başlatmak üzere hata ayıklamayı başlat ' ı seçin.

2. Tarayıcıda, gezinti çubuğunda Redsıs testi Için Azure önbelleği ' ni seçin.

3. Aşağıdaki örnekte, Message daha önce, portalda redsıs konsolu Için Azure önbelleği kullanılarak ayarlanan, önceden önbelleğe alınmış bir değer vardı. Uygulama, önbelleğe alınan bu değeri güncelleştirdi. Ayrıca uygulama, PING ve CLIENT LIST komutlarını da yürüttü.

   

Azure’da yayımlama ve çalıştırma

Uygulamayı yerel olarak başarıyla test ettikten sonra Azure’a dağıtabilir ve bulutta çalıştırabilirsiniz.

Uygulamayı Azure’da yayımlamak için

1. Visual Studio’da, Çözüm Gezgini’ndeki proje düğümüne sağ tıklayın. Ardından Yayımla’yı seçin.

   

2. Microsoft Azure App Service’i, sonra Yeni Oluştur'u ve Yayımla’yı seçin.

   

3. Uygulama Hizmetini Oluştur iletişim kutusunda aşağıdaki değişiklikleri yapın:

   Ayar	Önerilen değer	Açıklama
   Uygulama adı	Varsayılan değeri kullanın.	Uygulama adı, Azure’a dağıtıldığında uygulamanın ana bilgisayar adı olur. Gerekirse adı benzersiz hale getirmek için ada bir zaman damgası soneki eklenebilir.
   Abonelik	Azure aboneliğinizi seçin.	Tüm ilgili barındırma maliyetleri bu aboneliğe yansıtılır. Birden çok Azure aboneliğiniz varsa, istediğiniz aboneliğin seçildiğini doğrulayın.
   Kaynak grubu	Önbelleği oluşturduğunuz aynı kaynak grubunu kullanın (örneğin, TestResourceGroup).	Kaynak grubu, tüm kaynakları bir grup olarak yönetmenize yardımcı olur. Daha sonra uygulamayı silmek istediğinizde, grubu silmeniz yeterli olacaktır.
   App Service planı	Yeni’yi seçin ve TestingPlan adlı yeni bir App Service planı oluşturun. Önbelleğinizi oluştururken kullandığınız aynı Konumu kullanın. Boyut için Serbest’i seçin.	App Service planı, bir web uygulamasının birlikte çalıştırılacağı işlem kaynakları kümesini tanımlar.

   

4. App Service barındırma ayarlarını yapılandırdıktan sonra Oluştur'u seçin.

5. Yayımlama durumunu görmek için Visual Studio’da Çıkış penceresini izleyin. Uygulama yayımlandıktan sonra uygulamanın URL'si günlüğe kaydedilir:

   

Önbellek için uygulama ayarını ekleme

Yeni uygulama yayımlandıktan sonra, yeni uygulama ayarını ekleyin. Bu ayar, önbellek bağlantı bilgilerini depolamak için kullanılır.

Uygulama ayarını eklemek için

1. Oluşturduğunuz yeni uygulamayı bulmak için Azure portalının üst kısmındaki arama çubuğuna uygulama adını yazın.

   

2. Önbelleğe bağlanmak için kullanılacak uygulama için CacheConnection adlı yeni bir uygulama ayarı ekleyin. CacheSecrets.config dosyanızda, CacheConnection için yapılandırdığınız aynı değeri kullanın. Değer, önbellek ana bilgisayar adını ve erişim anahtarını içerir.

   

Azure’da uygulamayı çalıştırma

Tarayıcınızda, uygulamanın URL'sine gidin. URL, Visual Studio çıkış penceresindeki yayımlama işleminin sonuçlarında gösterilir. Ayrıca Azure portalında, oluşturduğunuz uygulamanın Genel Bakış sayfasında da sağlanır.

Önbellek Redis için Azure Cache test etmek için gezinti çubuğunda Test'i seçin.

Kaynakları temizleme

Sonraki öğreticiyle devam ediyorsanız, bu hızlı başlangıçta oluşturulan kaynakları tutabilir ve sonraki öğreticide yeniden kullanabilirsiniz.

Aksi takdirde, hızlı başlangıç örnek uygulamasını tamamladıysanız ücret yansıtılmaması için bu hızlı başlangıçta oluşturulan Azure kaynaklarını silebilirsiniz.

Kaynak grubunu silmek için

1. Azure portalında oturum açın ve Kaynak grupları’nı seçin.

2. Ada göre filtrele... kutusuna kaynak grubunuzun adını girin. Bu makaledeki yönergelerde TestResources adlı bir kaynak grubu kullanılmıştır. Sonuç listesindeki kaynak grubunuzda ... düğmesini ve sonra Kaynak grubunu sil’i seçin.

   

Kaynak grubunun silinmesini onaylamanız istenir. Onaylamak için kaynak grubunuzun adını yazın ve ardından Sil’i seçin.

Birkaç dakika sonra kaynak grubu ve bu gruptaki kaynakların tümü silinir.

Sonraki adımlar

Sonraki öğreticide, bir Redis için Azure Cache performansını geliştirmek için daha gerçekçi bir senaryoda Redis için Azure Cache'leri kullan. ASP.NET ve veritabanı ile edilgen önbellekli düzeni kullanarak puan tablosu sonuçlarını önbelleğe almak için bu uygulamayı güncelleştirirsiniz.