Zelfstudie: Een cache-aside-leaderboard maken in ASP.NET

Artikel
06/01/2023

In deze zelfstudie werkt u de web-app ContosoTeamStats ASP.NET bij--- gemaakt in de quickstart ASP.NET voor Azure Cache voor Redis--- om een leaderboard op te nemen dat gebruikmaakt van het cache-aside-patroon met Azure Cache voor Redis. In de voorbeeldtoepassing wordt een lijst met teamstatistieken uit een database weergegeven. Het laat ook verschillende manieren zien om Azure Cache voor Redis te gebruiken om gegevens op te slaan en op te halen uit de cache om de prestaties te verbeteren. Wanneer u de zelfstudie hebt voltooid, hebt u een actieve web-app die leest en schrijft naar een database, geoptimaliseerd met Azure Cache voor Redis en gehost in Azure.

In deze zelfstudie leert u het volgende:

De doorvoer van gegevens verbeteren en de belasting van de database verminderen door gegevens op te slaan en op te halen met Azure Cache voor Redis.
Een in Redis gesorteerde set gebruiken om de beste vijf teams op te halen.
De Azure-resources voor de toepassing inrichten met een Resource Manager-sjabloon.
De toepassing publiceren in Azure met Visual Studio.

Als u geen Azure-abonnement hebt, kunt u een gratis Azure-account maken voordat u begint.

Vereisten

U hebt het volgende nodig om deze zelfstudie te voltooien:

Deze zelfstudie gaat verder waar u was gebleven in Quickstart van ASP.NET voor Azure Cache voor Redis. Als u dat nog niet hebt gedaan, volgt u eerst de snelstartgids.
Installeer Visual Studio 2019 met de volgende workloads:
- ASP.NET-ontwikkeling en webontwikkeling
- Azure-ontwikkeling
- .NET-desktopontwikkeling met SQL Server Express LocalDB of SQL Server 2017 Express-editie.

Een leaderboard aan het project toevoegen

In deze sectie van de zelfstudie configureert u het project ContosoTeamStats met een leaderboard waarin de winst-, verlies- en gelijkspelstatistieken worden aangegeven voor een lijst met fictieve teams.

Het Entity Framework toevoegen aan het project

Open in Visual Studio de oplossing ContosoTeamStats die u hebt gemaakt in de Quickstart van ASP.NET voor Azure Cache voor Redis.
Selecteer Tools > NuGet Pakketbeheer > Pakketbeheer Console.
Voer de volgende opdracht uit in het venster Package Manager Console om EntityFramework te installeren:
```
Install-Package EntityFramework
```

Meer informatie over dit pakket vindt u op de NuGet-pagina EntityFramework.

Het teammodel toevoegen

Klik in Solution Explorer met de rechtermuisknop op Models en kies Add, Class.
Voer Team de naam van de klasse in en selecteer Toevoegen.

Vervang de using-instructies boven aan het bestand Team.cs door de volgende using-instructies:

using System;
using System.Collections.Generic;
using System.Data.Entity;
using System.Data.Entity.SqlServer;

Vervang de definitie van de Team klasse door het volgende codefragment dat een bijgewerkte Team klassedefinitie en een aantal andere Entity Framework-helperklassen bevat. In deze zelfstudie wordt de methode 'code eerst' gebruikt met Entity Framework. Met deze methode kan Entity Framework de database maken op basis van uw code. Zie Code First naar een nieuwe database voor meer informatie over de Code First-aanpak voor Entity Framework die in deze zelfstudie wordt gebruikt.

public class Team
{
    public int ID { get; set; }
    public string Name { get; set; }
    public int Wins { get; set; }
    public int Losses { get; set; }
    public int Ties { get; set; }

    static public void PlayGames(IEnumerable<Team> teams)
    {
        // Simple random generation of statistics.
        Random r = new Random();

        foreach (var t in teams)
        {
            t.Wins = r.Next(33);
            t.Losses = r.Next(33);
            t.Ties = r.Next(0, 5);
        }
    }
}

public class TeamContext : DbContext
{
    public TeamContext()
        : base("TeamContext")
    {
    }

    public DbSet<Team> Teams { get; set; }
}

public class TeamInitializer : CreateDatabaseIfNotExists<TeamContext>
{
    protected override void Seed(TeamContext context)
    {
        var teams = new List<Team>
        {
            new Team{Name="Adventure Works Cycles"},
            new Team{Name="Alpine Ski House"},
            new Team{Name="Blue Yonder Airlines"},
            new Team{Name="Coho Vineyard"},
            new Team{Name="Contoso, Ltd."},
            new Team{Name="Fabrikam, Inc."},
            new Team{Name="Lucerne Publishing"},
            new Team{Name="Northwind Traders"},
            new Team{Name="Consolidated Messenger"},
            new Team{Name="Fourth Coffee"},
            new Team{Name="Graphic Design Institute"},
            new Team{Name="Nod Publishers"}
        };

        Team.PlayGames(teams);

        teams.ForEach(t => context.Teams.Add(t));
        context.SaveChanges();
    }
}

public class TeamConfiguration : DbConfiguration
{
    public TeamConfiguration()
    {
        SetExecutionStrategy("System.Data.SqlClient", () => new SqlAzureExecutionStrategy());
    }
}

Dubbelklik in Solution Explorer op web.config om het bestand te openen.

Voeg de volgende sectie connectionStrings toe aan de sectie configuration. De naam van de verbindingsreeks moet overeenkomen met de naam van de contextklasse van de Entity Framework-database. Dit is TeamContext.

In dit verbindingsreeks ervan uitgegaan dat u voldoet aan de vereisten en hebt geïnstalleerd dat SQL Server Express LocalDB deel uitmaakt van de workload voor .NET-desktopontwikkeling die is geïnstalleerd met Visual Studio 2019.

<connectionStrings>
    <add name="TeamContext" connectionString="Data Source=(LocalDB)\MSSQLLocalDB;AttachDbFilename=|DataDirectory|\Teams.mdf;Integrated Security=True" providerName="System.Data.SqlClient" />
</connectionStrings>

In het volgende voorbeeld ziet u de nieuwe sectie connectionStrings na configSections in de sectie configuration:

<configuration>
    <configSections>
    <section name="entityFramework" type="System.Data.Entity.Internal.ConfigFile.EntityFrameworkSection, EntityFramework, Version=6.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" requirePermission="false" />
    </configSections>
    <connectionStrings>
    <add name="TeamContext" connectionString="Data Source=(LocalDB)\MSSQLLocalDB;AttachDbFilename=|DataDirectory|\Teams.mdf;Integrated Security=True"     providerName="System.Data.SqlClient" />
    </connectionStrings>
    ...

De TeamsController en weergaven toevoegen

Maak het project in Visual Studio.
Klik in Solution Explorer met de rechtermuisknop op de map Controllers en kies vervolgens Add, Controller.
Kies MVC 5-controller met weergaven, met behulp van Entity Framework en selecteer Toevoegen. Als er een fout optreedt nadat u Toevoegen hebt geselecteerd, controleert u of u het project eerst hebt gemaakt.
Selecteer in de vervolgkeuzelijst Model class de optie Team (ContosoTeamStats.Models). Selecteer in de vervolgkeuzelijst Data context class de optie TeamContext (ContosoTeamStats.Models). Typ TeamsController het tekstvak Controllernaam (als deze niet automatisch wordt ingevuld). Selecteer Toevoegen om de controllerklasse te maken en voeg de standaardweergaven toe.
Vouw in Solution Explorer het bestand Global.asax uit en dubbelklik op Global.asax.cs om het te openen.
Voeg boven aan het bestand, onder de andere using-instructies, de volgende twee using-instructies toe:
```
using System.Data.Entity;
using ContosoTeamStats.Models;
```
Voeg de volgende regel code toe aan het einde van de Application_Start-methode:
```
Database.SetInitializer<TeamContext>(new TeamInitializer());
```
Vouw in Solution ExplorerApp_Start uit en dubbelklik op RouteConfig.cs.

Vervang controller = "Home" in de route Default in de RegisterRoutes-methode door controller = "Teams", zoals wordt weergegeven in het volgende voorbeeld:

routes.MapRoute(
    name: "Default",
    url: "{controller}/{action}/{id}",
    defaults: new { controller = "Teams", action = "Index", id = UrlParameter.Optional }
);

De indelingsweergave configuren

Vouw in Solution Explorer de map Views uit. Vouw vervolgens de map Shared uit en dubbelklik op _Layout.cshtml.
Wijzig de inhoud van het element title en vervang My ASP.NET Application door Contoso Team Stats, zoals weergegeven in het volgende voorbeeld:
```
<title>@ViewBag.Title - Contoso Team Stats</title>
```
Voeg in de sectie body de volgende nieuwe Html.ActionLink-instructie toe voor Contoso Team Stats net onder de koppeling voor Azure Cache voor Redis-test.
```
@Html.ActionLink("Contoso Team Stats", "Index", "Teams", new { area = "" }, new { @class = "navbar-brand" })`
```
Druk op Ctrl+F5 om de toepassing op te bouwen en uit te voeren. Deze versie van de toepassing leest de resultaten rechtstreeks uit de database. De acties Nieuw, Bewerken, Details en Verwijderen zijn automatisch aan de toepassing toegevoegd door de structuur MVC 5 Controller with views, using Entity Framework. In de volgende sectie van de zelfstudie voegt u Azure Cache voor Redis toe om de gegevenstoegang te optimaliseren en meer functies voor de toepassing te bieden.

De app voor Azure Cache voor Redis configureren

In dit gedeelte van de zelfstudie configureert u de voorbeeldtoepassing om met behulp van de cacheclient StackExchange.Redis Contoso-teamstatistieken op te slaan en op te halen uit een exemplaar van Azure Cache voor Redis.

Een cacheverbinding toevoegen aan de Teams-controller

U hebt het clientbibliotheekpakket StackExchange.Redis al geïnstalleerd in de snelstartgids. U hebt de app-instelling CacheConnection ook al zo geconfigureerd dat deze lokaal wordt gebruikt en met de gepubliceerde App Service. Gebruik deze zelfde clientbibliotheek en de CacheConnection-informatie in de TeamsController.

Vouw in Solution Explorer de map Controllers uit en dubbelklik op TeamsController.cs om dit bestand te openen.
Voeg de volgende twee using-instructies toe aan TeamsController.cs:
```
using System.Configuration;
using StackExchange.Redis;
```

Voeg de volgende twee eigenschappen toe aan de klasse TeamsController:

// Redis Connection string info
private static Lazy<ConnectionMultiplexer> lazyConnection = new Lazy<ConnectionMultiplexer>(() =>
{
    string cacheConnection = ConfigurationManager.AppSettings["CacheConnection"].ToString();
    return ConnectionMultiplexer.Connect(cacheConnection);
});

public static ConnectionMultiplexer Connection
{
    get
    {
        return lazyConnection.Value;
    }
}

De TeamsController zo bijwerken dat hiermee wordt gelezen uit de cache of de database

In dit voorbeeld worden teamstatistieken opgehaald uit de database of uit de cache. Teamstatistieken worden opgeslagen in de cache als een geserialiseerde List<Team> en ook als een gesorteerde set met Redis-gegevenstypen. Bij het ophalen van items uit een gesorteerde set kunt u een query uitvoeren voor sommige items, voor alle items of alleen voor bepaalde items. In dit voorbeeld voert u een query uit op de gesorteerde set voor de top vijf teams gerangschikt op aantal overwinningen.

Het is niet vereist om de teamstatistieken op te slaan in meerdere indelingen in de cache om Azure Cache voor Redis te gebruiken. In deze zelfstudie wordt gebruikgemaakt van meerdere indelingen ter illustratie van de verschillende manieren en gegevenstypen die u kunt gebruiken om gegevens in de cache op te slaan.

Voeg bovenaan, bij de andere using-instructies, de volgende using-instructies toe aan het TeamsController.cs-bestand:
```
using System.Diagnostics;
using Newtonsoft.Json;
```

Vervang de huidige implementatie van de public ActionResult Index()-methode door de volgende implementatie:

// GET: Teams
public ActionResult Index(string actionType, string resultType)
{
    List<Team> teams = null;

    switch(actionType)
    {
        case "playGames": // Play a new season of games.
            PlayGames();
            break;

        case "clearCache": // Clear the results from the cache.
            ClearCachedTeams();
            break;

        case "rebuildDB": // Rebuild the database with sample data.
            RebuildDB();
            break;
    }

    // Measure the time it takes to retrieve the results.
    Stopwatch sw = Stopwatch.StartNew();

    switch(resultType)
    {
        case "teamsSortedSet": // Retrieve teams from sorted set.
            teams = GetFromSortedSet();
            break;

        case "teamsSortedSetTop5": // Retrieve the top 5 teams from the sorted set.
            teams = GetFromSortedSetTop5();
            break;

        case "teamsList": // Retrieve teams from the cached List<Team>.
            teams = GetFromList();
            break;

        case "fromDB": // Retrieve results from the database.
        default:
            teams = GetFromDB();
            break;
    }

    sw.Stop();
    double ms = sw.ElapsedTicks / (Stopwatch.Frequency / (1000.0));

    // Add the elapsed time of the operation to the ViewBag.msg.
    ViewBag.msg += " MS: " + ms.ToString();

    return View(teams);
}

Voeg de volgende drie methoden voor de klasse TeamsController toe om de actietypen playGames, clearCache en rebuildDB te implementeren uit de switch-instructie die in het vorige codefragment is toegevoegd.

De PlayGames-methode werkt de teamstatistieken bij door een seizoen aan wedstrijden te simuleren, slaat de resultaten vervolgens op in de database en wist de nu verouderde gegevens uit de cache.

void PlayGames()
{
    ViewBag.msg += "Updating team statistics. ";
    // Play a "season" of games.
    var teams = from t in db.Teams
                select t;

    Team.PlayGames(teams);

    db.SaveChanges();

    // Clear any cached results
    ClearCachedTeams();
}

De RebuildDB-methode initialiseert de database opnieuw met de standaardset teams, genereert statistieken voor ze en wist de nu verouderde gegevens uit de cache.

void RebuildDB()
{
    ViewBag.msg += "Rebuilding DB. ";
    // Delete and re-initialize the database with sample data.
    db.Database.Delete();
    db.Database.Initialize(true);

    // Clear any cached results
    ClearCachedTeams();
}

De ClearCachedTeams-methode verwijdert opgeslagen teamstatistieken uit de cache.

void ClearCachedTeams()
{
    IDatabase cache = Connection.GetDatabase();
    cache.KeyDelete("teamsList");
    cache.KeyDelete("teamsSortedSet");
    ViewBag.msg += "Team data removed from cache. ";
}

Voeg de volgende vier methoden toe aan klasse TeamsController om de verschillende manieren voor het ophalen van teamstatistieken uit de cache en de database te implementeren. Alle methoden retourneren een List<Team>, die vervolgens wordt weergegeven in de weergave.

De GetFromDB-methode leest de teamstatistieken uit de database.

List<Team> GetFromDB()
{
    ViewBag.msg += "Results read from DB. ";
    var results = from t in db.Teams
        orderby t.Wins descending
        select t;

    return results.ToList<Team>();
}

De GetFromList-methode leest de teamstatistieken uit de cache als een geserialiseerde List<Team>. Als de statistieken niet aanwezig zijn in de cache, treedt er een cachemissing op. Bij een cachemisser worden de teamstatistieken gelezen uit de database en vervolgens voor de volgende aanvraag opgeslagen in de cache. In dit voorbeeld wordt gebruikgemaakt van JSON.NET-serialisatie om de .NET-objecten naar en uit de cache te serialiseren. Zie Werken met .NET-objecten in Azure Cache voor Redis voor meer informatie.

List<Team> GetFromList()
{
    List<Team> teams = null;

    IDatabase cache = Connection.GetDatabase();
    string serializedTeams = cache.StringGet("teamsList");
    if (!String.IsNullOrEmpty(serializedTeams))
    {
        teams = JsonConvert.DeserializeObject<List<Team>>(serializedTeams);

        ViewBag.msg += "List read from cache. ";
    }
    else
    {
        ViewBag.msg += "Teams list cache miss. ";
        // Get from database and store in cache
        teams = GetFromDB();

        ViewBag.msg += "Storing results to cache. ";
        cache.StringSet("teamsList", JsonConvert.SerializeObject(teams));
    }
    return teams;
}

De GetFromSortedSet-methode leest de teamstatistieken uit een in de cache opgeslagen gesorteerde set. Als er een cache ontbreekt, worden de teamstatistieken gelezen uit de database en opgeslagen in de cache als een gesorteerde set.

List<Team> GetFromSortedSet()
{
    List<Team> teams = null;
    IDatabase cache = Connection.GetDatabase();
    // If the key teamsSortedSet is not present, this method returns a 0 length collection.
    var teamsSortedSet = cache.SortedSetRangeByRankWithScores("teamsSortedSet", order: Order.Descending);
    if (teamsSortedSet.Count() > 0)
    {
        ViewBag.msg += "Reading sorted set from cache. ";
        teams = new List<Team>();
        foreach (var t in teamsSortedSet)
        {
            Team tt = JsonConvert.DeserializeObject<Team>(t.Element);
            teams.Add(tt);
        }
    }
    else
    {
        ViewBag.msg += "Teams sorted set cache miss. ";

        // Read from DB
        teams = GetFromDB();

        ViewBag.msg += "Storing results to cache. ";
        foreach (var t in teams)
        {
            Console.WriteLine("Adding to sorted set: {0} - {1}", t.Name, t.Wins);
            cache.SortedSetAdd("teamsSortedSet", JsonConvert.SerializeObject(t), t.Wins);
        }
    }
    return teams;
}

Met de GetFromSortedSetTop5-methode worden de beste vijf teams gelezen uit de in de cache opgeslagen, gesorteerde set. Deze methode begint met het controleren van de cache op de aanwezigheid van de teamsSortedSet-sleutel. Als deze sleutel niet aanwezig is, wordt de GetFromSortedSet methode aangeroepen om de teamstatistieken te lezen en op te slaan in de cache. Vervolgens wordt een query voor de beste vijf teams uitgevoerd op de in de cache opgeslagen, gesorteerde set, die worden geretourneerd.

List<Team> GetFromSortedSetTop5()
{
    List<Team> teams = null;
    IDatabase cache = Connection.GetDatabase();

    // If the key teamsSortedSet is not present, this method returns a 0 length collection.
    var teamsSortedSet = cache.SortedSetRangeByRankWithScores("teamsSortedSet", stop: 4, order: Order.Descending);
    if(teamsSortedSet.Count() == 0)
    {
        // Load the entire sorted set into the cache.
        GetFromSortedSet();

        // Retrieve the top 5 teams.
        teamsSortedSet = cache.SortedSetRangeByRankWithScores("teamsSortedSet", stop: 4, order: Order.Descending);
    }

    ViewBag.msg += "Retrieving top 5 teams from cache. ";
    // Get the top 5 teams from the sorted set
    teams = new List<Team>();
    foreach (var team in teamsSortedSet)
    {
        teams.Add(JsonConvert.DeserializeObject<Team>(team.Element));
    }
    return teams;
}

De methoden Maken, Bewerken en Verwijderen bijwerken voor gebruik met de cache

De ondersteuningscode die als onderdeel van dit voorbeeld is gegenereerd, bevat de methoden om teams toe te voegen, te bewerken en te verwijderen. Telkens wanneer er een team wordt toegevoegd, bewerkt of verwijderd, raken de gegevens in de cache verouderd. In deze sectie bewerkt u deze drie methoden, zodat de in de cache opgeslagen teams worden gewist en de cache wordt vernieuwd.

Blader naar de Create(Team team)-methode in de klasse TeamsController. Voeg een aanroep toe aan de ClearCachedTeams-methode, zoals wordt weergegeven in het volgende voorbeeld:

// POST: Teams/Create
// To protect from overposting attacks, please enable the specific properties you want to bind to, for 
// more details see https://go.microsoft.com/fwlink/?LinkId=317598.
[HttpPost]
[ValidateAntiForgeryToken]
public ActionResult Create([Bind(Include = "ID,Name,Wins,Losses,Ties")] Team team)
{
    if (ModelState.IsValid)
    {
        db.Teams.Add(team);
        db.SaveChanges();
        // When a team is added, the cache is out of date.
        // Clear the cached teams.
        ClearCachedTeams();
        return RedirectToAction("Index");
    }

    return View(team);
}

Blader naar de Edit(Team team)-methode in de klasse TeamsController. Voeg een aanroep toe aan de ClearCachedTeams-methode, zoals wordt weergegeven in het volgende voorbeeld:

// POST: Teams/Edit/5
// To protect from overposting attacks, please enable the specific properties you want to bind to, for 
// more details see https://go.microsoft.com/fwlink/?LinkId=317598.
[HttpPost]
[ValidateAntiForgeryToken]
public ActionResult Edit([Bind(Include = "ID,Name,Wins,Losses,Ties")] Team team)
{
    if (ModelState.IsValid)
    {
        db.Entry(team).State = EntityState.Modified;
        db.SaveChanges();
        // When a team is edited, the cache is out of date.
        // Clear the cached teams.
        ClearCachedTeams();
        return RedirectToAction("Index");
    }
    return View(team);
}

Blader naar de DeleteConfirmed(int id)-methode in de klasse TeamsController. Voeg een aanroep toe aan de ClearCachedTeams-methode, zoals wordt weergegeven in het volgende voorbeeld:

// POST: Teams/Delete/5
[HttpPost, ActionName("Delete")]
[ValidateAntiForgeryToken]
public ActionResult DeleteConfirmed(int id)
{
    Team team = db.Teams.Find(id);
    db.Teams.Remove(team);
    db.SaveChanges();
    // When a team is deleted, the cache is out of date.
    // Clear the cached teams.
    ClearCachedTeams();
    return RedirectToAction("Index");
}

Cachemethoden toevoegen aan de weergave Teamindex

Vouw in Solution Explorer de map Views uit. Vouw vervolgens de map Teams uit en dubbelklik op Index.cshtml.

Zoek boven in het bestand naar het volgende alinea-element:

Action table

Met deze koppeling wordt een nieuw team gemaakt. Vervang het alinea-element door de volgende tabel. Deze tabel bevat actiekoppelingen waarmee u een nieuw team kunt maken, een nieuw seizoen wedstrijden kunt spelen, de cache kunt wissen, de teams in verschillende indelingen kunt ophalen uit de cache, de teams kunt ophalen uit de database en de database opnieuw kunt opbouwen met de nieuwe voorbeeldgegevens.

<table class="table">
    <tr>
        <td>
            @Html.ActionLink("Create New", "Create")
        </td>
        <td>
            @Html.ActionLink("Play Season", "Index", new { actionType = "playGames" })
        </td>
        <td>
            @Html.ActionLink("Clear Cache", "Index", new { actionType = "clearCache" })
        </td>
        <td>
            @Html.ActionLink("List from Cache", "Index", new { resultType = "teamsList" })
        </td>
        <td>
            @Html.ActionLink("Sorted Set from Cache", "Index", new { resultType = "teamsSortedSet" })
        </td>
        <td>
            @Html.ActionLink("Top 5 Teams from Cache", "Index", new { resultType = "teamsSortedSetTop5" })
        </td>
        <td>
            @Html.ActionLink("Load from DB", "Index", new { resultType = "fromDB" })
        </td>
        <td>
            @Html.ActionLink("Rebuild DB", "Index", new { actionType = "rebuildDB" })
        </td>
    </tr>
</table>

Schuif naar de onderkant van het bestand Index.cshtml en voeg het volgende tr element toe, zodat dit de laatste rij in de laatste tabel in het bestand is:
```
<tr><td colspan="5">@ViewBag.Msg</td></tr>
```
Deze rij geeft de waarde weer van ViewBag.Msg, die een statusrapport over de huidige bewerking bevat. De ViewBag.Msg optie wordt ingesteld wanneer u een van de actiekoppelingen uit de vorige stap selecteert.
Druk op F6 om het project te bouwen.

De app lokaal uitvoeren

Voer de toepassing lokaal uit op uw computer om de functionaliteit te testen die is toegevoegd om de teams te ondersteunen.

In deze test worden de toepassing en de database beide lokaal uitgevoerd. De Azure Cache voor Redis is niet lokaal. Het wordt extern gehost in Azure. Daarom zal de cache de database waarschijnlijk iets te weinig uitvoeren. Voor optimale prestaties moeten de clienttoepassing en het exemplaar van Azure Cache voor Redis zich op dezelfde locatie bevinden.

In de volgende sectie implementeert u alle resources in Azure om de verbeterde prestaties te zien van het gebruik van een cache.

De app lokaal uitvoeren:

Druk op Ctrl+F5 om de toepassing uit te voeren.
Test alle nieuwe methoden die aan de weergave zijn toegevoegd. Omdat de cache in deze tests extern is, moet de database iets beter presteren dan de cache.

Publiceren en uitvoeren in Azure

Een database inrichten voor de app

In deze sectie richt u een nieuwe database in SQL Database in die de app gaat gebruiken terwijl deze wordt gehost in Azure.

Selecteer in Azure Portal een resource maken in de linkerbovenhoek van Azure Portal.
Selecteer op de pagina Nieuw de optie Databases>SQL-database.

Gebruik de volgende instellingen voor de nieuwe SQL-database:

Instelling	Voorgestelde waarde	Beschrijving
Databasenaam	ContosoTeamsDatabase	Zie Database-id's voor geldige databasenamen.
Abonnement	Uw abonnement	Selecteer hetzelfde abonnement dat u gebruikt om de cache te maken en de App Service te hosten.
Resourcegroep	TestResourceGroup	Selecteer Bestaande gebruiken en gebruik dezelfde resourcegroep waar u uw cache en App Service hebt geplaatst.
Bron selecteren	Lege database	Begin met een lege database.

Selecteer onder Server de optie Vereiste instellingen>configureren Maak een nieuwe server en geef de volgende informatie op en gebruik vervolgens de knop Selecteren:

Instelling	Voorgestelde waarde	Beschrijving
Servernaam	Een wereldwijd unieke naam	Zie Naming conventions (Naamgevingsconventies) voor geldige servernamen.
Aanmeldgegevens van serverbeheerder	Een geldige naam	Zie Database-id's voor geldige aanmeldingsnamen.
Wachtwoord	Een geldig wachtwoord	Uw wachtwoord moet uit ten minste 8 tekens bestaan en moet tekens bevatten uit drie van de volgende categorieën: hoofdletters, kleine letters, cijfers en niet-alfanumerieke tekens.
Locatie	VS - oost	Selecteer dezelfde regio als waarin u de cache en de App Service hebt gemaakt.

Selecteer Vastmaken aan dashboard en maakvervolgens de nieuwe database en server.
Zodra de nieuwe database is gemaakt, selecteert u Database-verbindingsreeks s weergeven en kopieert u de ADO.NET verbindingsreeks.
Navigeer in Azure Portal naar uw App Service en selecteer Application Instellingen en voeg vervolgens nieuwe verbindingsreeks toe onder de sectie Verbinding maken iontekenreeksen.

Voeg een nieuwe verbindingsreeks toe met de naam TeamContext die overeenkomt met de contextklasse van de Entity Framework-database. Plak de verbindingsreeks voor de nieuwe database als de waarde. Vervang de volgende tijdelijke aanduidingen in de verbindingsreeks en selecteer Opslaan:

Plaatsaanduiding	Voorgestelde waarde
{uw_gebruikersnaam}	Gebruik de aanmeldgegevens van de serverbeheerder voor de server die u zojuist hebt gemaakt.
{uw_wachtwoord}	Gebruik het wachtwoord voor de server die u zojuist hebt gemaakt.

Door de gebruikersnaam en het wachtwoord toe te voegen als toepassingsinstelling, worden uw gebruikersnaam en wachtwoord niet opgenomen in uw code. Met deze methode beschermt u deze referenties.

De toepassingsupdates publiceren in Azure

In deze stap van de zelfstudie publiceert u de toepassingsupdate in Azure om deze uit te voeren in de cloud.

Selecteer met de rechtermuisknop het Project ContosoTeamStats in Visual Studio en kies Publiceren.
Selecteer Publiceren om hetzelfde publicatieprofiel te gebruiken dat u in de quickstart hebt gemaakt.

Wanneer het publiceren is voltooid, wordt de app door Visual Studio in uw standaardwebbrowser gestart.

Cache added

De volgende tabel beschrijft elke actiekoppeling in de voorbeeldtoepassing:

Actie	Beschrijving
Nieuwe maken	Een nieuw team maken
Play Season	Speel een seizoen wedstrijden, werk de teamstatistieken bij en wis eventuele verouderde teamgegevens uit de cache.
Cache wissen	Wis de teamstatistieken uit de cache.
List from Cache	Haal de teamstatistieken op uit de cache. Als er een cache ontbreekt, laadt u de statistieken uit de database en slaat u deze de volgende keer op in de cache.
Sorted Set from Cache	Haal de teamstatistieken op uit de cache met behulp van een gesorteerde set. Als er een cache ontbreekt, laadt u de statistieken uit de database en slaat u deze op in de cache met behulp van een gesorteerde set.
Top 5 Teams from Cache	Haal de beste vijf teams op uit de cache met behulp van een gesorteerde set. Als er een cache ontbreekt, laadt u de statistieken uit de database en slaat u deze op in de cache met behulp van een gesorteerde set.
Load from DB	Haal de teamstatistieken op uit de database.
Rebuild DB	Bouw de database opnieuw en laad deze opnieuw met voorbeeldgegevens van de teams.
Edit/Details/Delete	Bewerk een team, geef details van een team weer en verwijder een team.

Selecteer enkele acties en experimenteer met het ophalen van de gegevens uit de verschillende bronnen. Let op de verschillen in de tijd die nodig is om de gegevens op de diverse manieren op te halen uit de database en de cache.

Resources opschonen

Wanneer u klaar bent met de voorbeeldtoepassing voor zelfstudies, kunt u de Azure-resources verwijderen om kosten en resources te besparen. Al uw resources moeten zich in dezelfde resourcegroep bevinden. U kunt ze in één bewerking verwijderen door de resourcegroep te verwijderen. In de instructies in dit artikel is een resourcegroep met de naam TestResources gebruikt.

Belangrijk

Het verwijderen van een resourcegroep kan niet ongedaan worden gemaakt. De resourcegroep en alle bijbehorende resources worden permanent 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.

Meld u aan bij de Azure-portal en selecteer Resourcegroepen.
Typ de naam van de resourcegroep in het tekstvak Items filteren....
Selecteer ... rechts van de resourcegroep en selecteer Resourcegroep verwijderen.
U wordt gevraagd om het verwijderen van de resourcegroep te bevestigen. Typ ter bevestiging de naam van de resourcegroep nogmaals en selecteer Verwijderen.

Na enkele ogenblikken worden de resourcegroep en alle resources in de groep verwijderd.

Volgende stappen

Het schalen van Azure Cache voor Redis