Quickstart: Azure Cache voor Redis met ASP.NET-web-app gebruiken

Artikel
11/25/2021
15 minuten om te lezen

In deze snelstartgids gebruikt u Visual Studio 2019 om een ASP.NET-web-app die verbinding maakt met Azure Cache voor Redis om gegevens op te slaan en op te halen uit de cache. U kunt de app vervolgens in Azure App Service implementeren.

Als u direct naar de code wilt gaan, bekijkt u ASP.NET quickstart over GitHub.

Vereisten

Azure-abonnement: u kunt een gratis abonnement nemen
Visual Studio 2019 met de workloads ASP.NET and web development en Azure development.

Het Visual Studio-project maken

Open Visual Studio en selecteer bestand > Nieuw > Project.
Ga als volgt te werk in het dialoogvenster Een nieuw project maken:

a. Voer in het zoekvak C# in ASP.NET Web Application.

b. Selecteer ASP.NET Web Application (.NET Framework).

c. Selecteer Volgende.
Geef in Project naam het project een naam. In dit voorbeeld wordt de naam ContosoTeamStats gebruikt.
Controleer of .NET Framework 4.6.1 of hoger is geselecteerd.
Selecteer Maken.
Selecteer MVC als het projecttype.
Zorg ervoor dat Geen verificatie is opgegeven voor de instellingen bij Verificatie. Afhankelijk van uw versie van Visual Studio wijkt de standaardinstelling voor Verificatie mogelijk af. Als u dit wilt wijzigen, selecteert u Verificatie wijzigen en vervolgens Geen verificatie.
Selecteer Maken om het project te maken.

Een cache maken

Maak vervolgens de cache voor de app.

Als u een cache wilt maken, meldt u zich aan bij de Azure-portal en selecteert u Een resource maken.
Selecteer op de pagina Nieuw de optie Databases en selecteer vervolgens Azure Cache voor Redis.

Configureer op de pagina Nieuwe Redis-cache de instellingen voor de nieuwe cache.

Instelling	Een waarde kiezen	Beschrijving
Abonnement	Open de vervolgkeuzelijst en selecteer uw abonnement.	Het abonnement waarmee dit nieuwe Azure Cache voor Redis-exemplaar wordt gemaakt.
Resourcegroep	Open de vervolgkeuzelijst en selecteer een resourcegroep of kies Nieuwe maken en geef een naam voor de nieuwe resourcegroep op.	Naam voor de resourcegroep waarin de cache en andere resources moeten worden gemaakt. Door al uw app-resources in één resourcegroep te plaatsen, kunt u ze eenvoudig beheren of verwijderen.
DNS-naam	Voer een unieke naam in.	De cachenaam moet een tekenreeks tussen 1 en 63 tekens zijn die alleen cijfers, letters of afbreekstreetes bevat. De naam moet beginnen en eindigen met een cijfer of letter en mag geen opeenvolgende afbreekstreepjes bevatten. De hostnaam van uw cache-exemplaar wordt <DNS name>.redis.cache.windows.net.
Locatie	Open de vervolgkeuzelijst en selecteer een locatie.	Selecteer een regio in de buurt van andere services die gaan gebruikmaken van de cache.
Cachetype	Selecteer een laag in de vervolgkeuzecategorie.	De grootte, prestaties en functies die beschikbaar zijn voor de cache, zijn afhankelijk van de gekozen laag. Zie het Azure Cache voor Redis-overzicht voor meer informatie.

Selecteer het tabblad Netwerken of selecteer de knop Netwerken onder aan de pagina.
Selecteer uw verbindingsmethode op het tabblad Netwerk.
Selecteer het tabblad Volgende: Geavanceerd of selecteer de knop Volgende: Geavanceerd onderaan de pagina.
Selecteer in het tabblad Geavanceerd voor een basic of standard cache-exemplaar de schakeloptie inschakelen als u een niet-TLS-poort wilt inschakelen. U kunt ook selecteren welke Redis-versie u wilt gebruiken, 4 of 6.
Configureer in het tabblad Geavanceerd voor premium cache-exemplaar de instellingen voor een niet-TLS-poort, clustering en gegevenspersistentie. U kunt ook selecteren welke Redis-versie u wilt gebruiken, 4 of 6.
Selecteer het tabblad Volgende: Tags of selecteer de knop Volgende: Tags onderaan de pagina.
Voer desgewenst in het tabblad Tags de naam en waarde in om de resource te categoriseren.
Selecteer Controleren + maken. Het tabblad Beoordelen + maken wordt weergegeven, waar uw configuratie wordt gevalideerd in Azure.
Selecteer Maken nadat het groene bericht Validatie geslaagd verschijnt.

Het duurt even voor de cache is gemaakt. U kunt de voortgang bekijken op de overzichtspagina van Azure Cache voor Redis. Als u bij Status Wordt uitgevoerd ziet staan, kunt u de cache gebruiken.

Hostnaam, poorten en toegangssleutels ophalen uit Azure Portal

Cache-clients hebben de hostnaam, poorten en sleutels van de cache nodig om verbinding te maken met een Azure Cache for Redis-instantie. Sommige clients kunnen enigszins andere namen gebruiken om naar deze items te verwijzen. U kunt de hostnaam, poorten en toegangssleutels ophalen uit Azure Portal.

Als u de toegangssleutels wilt ophalen, selecteert u in de linkernavigatie van de cache de optie Toegangssleutels.
Als u de hostnaam en poorten wilt ophalen, selecteert u in de linkernavigatie van de cache de optie Eigenschappen. De hostnaam heeft de indeling <DNS name>.redis.cache.windows.net.

Het bestand CacheSecrets.config bewerken

Maak op de computer een bestand met de naam CacheSecrets.config. Sla dit bestand op een locatie op waar het niet wordt ingecheckt met de broncode van de voorbeeldtoepassing. Voor deze snelstart bevindt het bestand CacheSecrets.config zich op C:\AppSecrets\CacheSecrets.config.

Bewerk het bestand CacheSecrets.config. Voeg nu de volgende inhoud toe:

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

Vervang <cache-name> door de hostnaam van uw cache.
Vervang <access-key> door de primaire sleutel voor uw cache.

Tip

U kunt de secundaire toegangssleutel tijdens sleutelroulatie gebruiken als een alternatieve sleutel terwijl u de primaire toegangssleutel opnieuw genereert.
Sla het bestand op.

De MVC-toepassing bijwerken

In deze sectie werkt u de toepassing bij voor de ondersteuning van een nieuwe weergave waarin een eenvoudige test wordt weergegeven op basis van Azure Cache voor Redis.

Het web.config-bestand bijwerken met een app-instelling voor de cache
De toepassing configureren voor gebruik van de StackExchange.Redis-client
De HomeController en lay-out bijwerken
Een nieuwe RedisCache-weergave toevoegen

Het web.config-bestand bijwerken met een app-instelling voor de cache

Als u de toepassing lokaal uitvoert, wordt de informatie in CacheSecrets.config gebruikt om verbinding te maken met uw instantie van Azure Cache voor Redis. Later implementeert u deze toepassing in Azure. Op dat moment configureert u een app-instelling in Azure die in de toepassing wordt gebruikt om de cacheverbindingsinformatie op te halen in plaats van dit bestand.

Omdat het bestand CacheSecrets.config niet in Azure wordt geïmplementeerd met uw toepassing, gebruikt u het alleen tijdens het lokaal testen van de toepassing. Houd deze informatie zo veilig mogelijk om schadelijke toegang tot de gegevens in de cache te voorkomen.

Het bestand web.config bijwerken

Dubbelklik in Solution Explorer op het bestand web.config om het te openen.
Ga in het bestand web.config naar het element <appSetting>. Voeg vervolgens het volgende file-kenmerk toe. Als u een andere bestandsnaam of -locatie gebruikt, vervangt u deze waarden door de waarden die in het voorbeeld worden weergegeven.

Voor: <appSettings>
Na: <appSettings file="C:\AppSecrets\CacheSecrets.config">

De ASP.NET-runtime voegt de inhoud van het externe bestand samen met de opmaak van het element <appSettings>. Als het opgegeven bestand niet kan worden gevonden, negeert de runtime het bestandskenmerk. Uw geheimen (de verbindingsreeks naar uw cache) worden niet opgenomen in de broncode van de toepassing. Wanneer u de web-app implementeert in Azure, wordt het bestand CacheSecrets.config niet geïmplementeerd.

De toepassing configureren voor het gebruik van StackExchange.Redis

Als u de app wilt configureren voor gebruik van het NuGet-pakket StackExchange.Redis voor Visual Studio, selecteert u Tools > NuGet Package Manager > Package Manager Console.
Voer de volgende opdracht uit vanuit het venster Package Manager Console:
```
Install-Package StackExchange.Redis
```
Met het NuGet-pakket downloadt u de vereiste assembly-verwijzingen voor de clienttoepassing en voegt u deze toe om met de StackExchange.Azure Cache voor Redis-client toegang te krijgen tot Azure Cache voor Redis. Als u een versie met een sterke naam van de StackExchange.Redis-clientbibliotheek verkiest, installeert u het StackExchange.Redis-pakket.

De HomeController en lay-out bijwerken

Vouw in Solution Explorer de map Controllers uit en open vervolgens het bestand HomeController.cs.

Voeg bovenaan using het bestand de volgende -instructies toe.

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

Voeg de volgende leden toe aan de HomeController klasse ter ondersteuning van een nieuwe actie die enkele opdrachten op de nieuwe cache wordt RedisCache uitgevoerd.

     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));
    }

Vouw in Solution Explorer de map Views > Shared uit. Open vervolgens het bestand _Layout.cshtml.

Vervang:

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

door:

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

Een nieuwe RedisCache-weergave toevoegen

Vouw in Solution Explorer de map Views uit en klik met de rechtermuisknop op de map Home. Kies Add > View... .
Voer in het dialoogvenster Add View als weergavenaam in: RedisCache. Selecteer vervolgens Toevoegen.

Vervang de code in het bestand RedisCache.cshtml door de volgende code:

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

De app lokaal uitvoeren

Het project is standaard geconfigureerd voor het lokaal hosten van de app in IIS Express voor testen en foutopsporing.

De app lokaal uitvoeren

Selecteer in Visual Studio Debug > Start Debugging om de app lokaal te bouwen en te starten voor testen en foutopsporing.
Selecteer in de browser Azure Cache voor Redis Test op de navigatiebalk.
In het volgende voorbeeld ziet u dat de Message-sleutel eerder een waarde in de cache had, die was ingesteld met behulp van de Azure Cache voor Redis-console in de portal. De app heeft die waarde in de cache bijgewerkt. De app heeft ook de opdrachten PING en CLIENT LIST uitgevoerd.

Publiceren en uitvoeren in Azure

Nadat het lokaal testen van de app is geslaagd, implementeert u de app in Azure en voert u deze uit in de cloud.

De app publiceren in Azure

Klik in Visual Studio met de rechtermuisknop op het projectknooppunt in Solution Explorer. Selecteer vervolgens Publiceren.
Selecteer Microsoft Azure App Service, selecteer Nieuwe maken en selecteer vervolgens Publiceren.

Breng in het dialoogvenster App Service maken de volgende wijzigingen aan:

Instelling	Aanbevolen waarde	Beschrijving
Naam van app	Gebruik de standaard.	De app-naam is de hostnaam voor de app wanneer deze is geïmplementeerd in Azure. Aan de naam is mogelijk een tijdstempel als achtervoegsel toegevoegd om deze uniek te maken, indien nodig.
Abonnement	Kies uw Azure-abonnement.	Voor dit abonnement worden eventuele gerelateerde hostingkosten in rekening gebracht. Als u meerdere Azure-abonnementen hebt, controleert u of het gewenste abonnement is geselecteerd.
Resourcegroep	Gebruik dezelfde resourcegroep waar u de cache hebt gemaakt. (Bijvoorbeeld, TestResourceGroup.)	Met een resourcegroep kunt u alle resources als een groep beheren. Als u de app later wilt verwijderen, verwijdert u gewoon de groep.
App Service-plan	Selecteer Nieuw en maak vervolgens een nieuw App Service-plan met de naam TestingPlan. Gebruik dezelfde locatie die u hebt gebruikt bij het maken van uw cache. Kies Vrij voor de grootte.	Een App Service-plan definieert een set van rekenresources waarmee een web-app wordt uitgevoerd.

Dialoogvenster App Service

Nadat u de instellingen voor App Service-hosting hebt geconfigureerd, selecteert u Maken.
Controleer het venster Uitvoer in Visual Studio om de publicatiestatus te zien. Nadat de app is gepubliceerd, wordt de URL voor de app geregistreerd:

De app-instelling voor de cache toevoegen

Nadat de nieuwe app is gepubliceerd, voegt u een nieuwe app-instelling toe. Deze instelling wordt gebruikt om de verbindingsgegevens van de cache op te slaan.

De app-instelling toevoegen

Typ de app-naam in de zoekbalk boven aan Azure Portal om te zoeken naar de nieuwe app die u hebt gemaakt.
Voeg een nieuwe app instelling met de naam CacheConnection toe die de app kan gebruiken om verbinding te maken met de cache. Gebruik dezelfde waarde die u hebt geconfigureerd voor CacheConnection in het bestand CacheSecrets.config. De waarde bevat de hostnaam en toegangssleutel van de cache.

De app in Azure uitvoeren

Ga in de browser naar de URL voor de app. De URL wordt weergegeven in de resultaten van de publicatiebewerking in het uitvoervenster van Visual Studio. Deze is ook beschikbaar in Azure Portal op de overzichtspagina van de app die u hebt gemaakt.

Selecteer op de navigatiebalk Azure Cache voor Redis Test om toegang tot de cache te testen.

Eenvoudige test voltooid in Azure

Resources opschonen

Als u verder wilt gaan met de volgende zelfstudie, kunt u de resources die u in deze snelstart hebt gemaakt, behouden en opnieuw gebruiken.

Als klaar bent met de voorbeeldtoepassing uit de snelstart, kunt u de Azure-resources die u in deze snelstart hebt gemaakt, verwijderen om kosten te voorkomen.

Belangrijk

Het verwijderen van een resourcegroep kan niet ongedaan worden gemaakt. Wanneer u een resourcegroep verwijdert, worden alle resources in de groep definitief verwijderd. Zorg ervoor dat u niet per ongeluk de verkeerde resourcegroep of resources verwijdert. Als u de resources hebt gemaakt voor het hosten van dit voorbeeld in een bestaande resourcegroep die resources bevat die u wilt behouden, kunt u elke resource afzonderlijk aan de linkerkant verwijderen in plaats van de resourcegroep te verwijderen.

Een resourcegroep verwijderen

Meld u aan bij Azure Portal en selecteer vervolgens Resourcegroepen.
Typ in het vak Filteren op naam... de naam van de resourcegroep. In de instructies voor dit artikel is een resourcegroep met de naam TestResources gebruikt. Selecteer in de resourcegroep, in de resultatenlijst, de optie ... . Selecteer vervolgens Resourcegroep verwijderen.

U wordt gevraagd om het verwijderen van de resourcegroep te bevestigen. Typ ter bevestiging de naam van de resourcegroep. Selecteer vervolgens Verwijderen.

Na enkele ogenblikken worden de resourcegroep en alle bijbehorende resources verwijderd.

Volgende stappen

In de volgende zelfstudie gebruikt u Azure Cache voor Redis in een realistischer scenario om de prestaties van een app te verbeteren. U werkt deze toepassing bij zodat leaderboardresultaten in de cache worden geplaatst met behulp van het cache-aside-patroon met ASP.NET en een database.

Een 'cache-aside' leaderboard maken in ASP.NET

Quickstart: Azure Cache voor Redis met ASP.NET-web-app gebruiken

Beoordeel uw ervaring

Ga naar de code op GitHub

Vereisten

Het Visual Studio-project maken

Een cache maken

Hostnaam, poorten en toegangssleutels ophalen uit Azure Portal

Het bestand CacheSecrets.config bewerken

De MVC-toepassing bijwerken

Het web.config-bestand bijwerken met een app-instelling voor de cache

Het bestand web.config bijwerken

De toepassing configureren voor het gebruik van StackExchange.Redis

De HomeController en lay-out bijwerken

Een nieuwe RedisCache-weergave toevoegen

De app lokaal uitvoeren

De app lokaal uitvoeren

Publiceren en uitvoeren in Azure

De app publiceren in Azure

De app-instelling voor de cache toevoegen

De app-instelling toevoegen

De app in Azure uitvoeren

Resources opschonen

Een resourcegroep verwijderen

Volgende stappen