Tutorial: Criar uma classificação cache-aside no ASP.NET

Artigo
10/24/2023

Neste tutorial, você atualiza o aplicativo Web ContosoTeamStats ---ASP.NET criado no início rápido do ASP.NET para o Cache do Azure para Redis---para incluir uma tabela de classificação que usa o padrão cache-aside com o Cache do Azure para Redis. O aplicativo de exemplo exibe uma lista de estatísticas da equipe de um banco de dados. Ele também demonstra diferentes maneiras de usar o Cache Redis do Azure para armazenar e recuperar dados do cache para melhorar o desempenho. Ao concluir o tutorial, você terá um aplicativo Web em execução que lê e grava em um banco de dados, otimizado com o Cache do Azure para Redis e hospedado no Azure.

Neste tutorial, irá aprender a:

Melhore a taxa de transferência de dados e reduza a carga do banco de dados armazenando e recuperando dados usando o Cache do Azure para Redis.
Utilizar um conjunto ordenado de Redis para obter as cinco melhores equipas.
Aprovisionar os recursos do Azure para a aplicação com um modelo do Resource Manager.
Publicar a aplicação no Azure com o Visual Studio.

Se não tiver uma subscrição do Azure, crie uma conta gratuita do Azure antes de começar.

Pré-requisitos

Para concluir este tutorial, deve ter os seguintes pré-requisitos:

Este tutorial continua de onde você parou em ASP.NET início rápido do Cache do Azure para Redis. Se ainda não o fez, siga este início rápido primeiro.
Instale o Visual Studio 2019 com as seguintes cargas de trabalho:
- Desenvolvimento ASP.NET e Web
- Desenvolvimento do Azure
- Desenvolvimento do ambiente de trabalho em .NET, com o SQL Server Express LocalDB ou o SQL Server 2017 Express Edition.

Adicione uma classificação ao projeto

Nesta secção do tutorial, vai configurar o projeto ContosoTeamStats com uma classificação que comunica as estatísticas das vitorias, derrotas e empates de uma lista de equipas fictícias.

Adicionar o Entity Framework ao projeto

No Visual Studio, abra a Solução ContosoTeamStats que você criou no início rápido do ASP.NET para o Cache do Azure para Redis.
Selecione Ferramentas NuGet Package Manager Package Manager Console (Ferramentas > NuGet Package Manager > PackageManager Console).
Emita o comando seguinte na janela da Consola do Gestor de Pacotes para instalar o EntityFramework:
```
Install-Package EntityFramework
```

Para mais informações sobre este pacote, consulte a página NuGet EntityFramework.

Adicionar o Modelo de equipa

Clique com o botão direito do rato em Modelos no Explorador de Soluções e escolha Adicionar, Classe.
Digite Team o nome da classe e selecione Adicionar.

Substitua as instruções using na parte superior do ficheiro Team.cs pelas seguintes instruções using:

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

Substitua a Team definição da classe pelo trecho de código a seguir que contém uma definição de classe atualizada Team e algumas outras classes auxiliares do Entity Framework. Neste tutorial, está a utilizar a primeira abordagem de código com o Entity Framework. Esta abordagem permite ao Entity Framework criar a base de dados a partir do código. Para obter mais informações sobre a abordagem Code First para o Entity Framework utilizado neste tutorial, veja Code first to a new database (Code First para criar uma nova base de dados).

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

No Explorador de Soluções, faça duplo clique em Web.config para abri-lo.

Adicione a seguinte secção connectionStrings dentro da secção configuration. O nome da cadeia de ligação tem de corresponder ao nome da classe de contexto da base de dados do Entity Framework, que é TeamContext.

Essa cadeia de conexão pressupõe que você atendeu aos pré-requisitos e instalou o SQL Server Express LocalDB que faz parte da carga de trabalho de desenvolvimento da área de trabalho .NET instalada com o Visual Studio 2019.

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

O exemplo seguinte mostra a nova secção connectionStrings depois de configSections dentro da secção 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>
    ...

Adicionar o TeamsController e as vistas

No Visual Studio, crie o projeto.
No Explorador de Soluções, clique com o botão direito do rato na pasta Controladores e escolha Adicionar, Controlador.
Escolha MVC 5 Controller com exibições, usando o Entity Framework, e selecione Adicionar. Se você receber um erro depois de selecionar Adicionar, certifique-se de ter criado o projeto primeiro.
Selecione Team (ContosoTeamStats.Models) na lista pendente Classe de modelo. Selecione TeamContext (ContosoTeamStats.Models) na lista pendente Classe de contexto de dados. Digite TeamsController a caixa de texto Nome do controlador (se ela não for preenchida automaticamente). Selecione Adicionar para criar a classe controller e adicionar as exibições padrão.
No Explorador de Soluções, expanda Global.asax e faça duplo clique em Global.asax.cs para abri-lo.
Adicione as duas instruções using seguintes na parte superior do ficheiro, sob as outras declarações using:
```
using System.Data.Entity;
using ContosoTeamStats.Models;
```
Adicione a seguinte linha de código no final do método Application_Start:
```
Database.SetInitializer<TeamContext>(new TeamInitializer());
```
No Explorador de Soluções, expanda App_Start e faça duplo clique em RouteConfig.cs.

No método RegisterRoutes, substitua controller = "Home" na rota Default por controller = "Teams", conforme mostrado no seguinte exemplo:

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

Configurar a vista do Esquema

No Explorador de Soluções, expanda a pasta Vistas, em seguida, a pasta Partilhado e faça duplo clique em _Layout.cshtml.
Altere o conteúdo do elemento title e substitua My ASP.NET Application por Contoso Team Stats, conforme mostrado no exemplo seguinte:
```
<title>@ViewBag.Title - Contoso Team Stats</title>
```
body Na seção , adicione a nova Html.ActionLink instrução a seguir para Contoso Team Stats logo abaixo do link para Cache do Azure para Teste Redis.
```
@Html.ActionLink("Contoso Team Stats", "Index", "Teams", new { area = "" }, new { @class = "navbar-brand" })`
```
Prima Ctrl+F5 para criar e executar a aplicação. Esta versão da aplicação lê os resultados diretamente na base de dados. Tenha em atenção que as ações Criar Nova, Editar, Detalhes e Eliminar foram automaticamente adicionadas à aplicação pela estrutura do Controlador 5 MVC com vistas através do Entity Framework. Na próxima seção do tutorial, você adicionará o Cache Redis do Azure para otimizar o acesso aos dados e fornecer mais recursos ao aplicativo.

Configurar o aplicativo para o Cache Redis do Azure

Nesta seção do tutorial, você configura o aplicativo de exemplo para armazenar e recuperar estatísticas da equipe da Contoso de uma instância do Cache do Azure para Redis usando o cliente de cache StackExchange.Redis .

Adicionar uma ligação de cache ao Controlador de Equipas

Já instalou o pacote da biblioteca de cliente StackExchange.Redis no início rápido. Também já configurou a definição da aplicação CacheConnection para ser utilizada localmente e com o Serviço de Aplicações publicado. Utilize esta mesma biblioteca de cliente e as informações de CacheConnection no TeamsController.

No Explorador de Soluções, expanda a pasta Controladores e faça duplo clique em TeamsController.cs para abri-la.
Adicione as duas instruções using seguintes ao TeamsController.cs:
```
using System.Configuration;
using StackExchange.Redis;
```

Adicione as duas propriedades seguintes à classe 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;
    }
}

Atualizar o TeamsController para ler a partir da cache ou da base de dados

Neste exemplo, as estatísticas da equipa podem ser obtidas a partir da base de dados ou da cache. As estatísticas da equipa são armazenadas na cache como uma List<Team> serializada e também como um conjunto ordenado que utiliza tipos de dados de Redis. Ao obter itens de um conjunto ordenado, poderá obter alguns, todos ou consultar determinados itens. Neste exemplo, você consultará o conjunto classificado para as cinco melhores equipes classificadas por número de vitórias.

Não é necessário armazenar as estatísticas da equipe em vários formatos no cache para usar o Cache do Azure para Redis. Este tutorial utiliza vários formatos para demonstrar as diferentes formas e os diferentes tipos de dados que pode utilizar para colocar dados em cache.

Adicione as seguintes instruções using na parte superior do ficheiro TeamsController.cs, juntamente com as outras instruções using:
```
using System.Diagnostics;
using Newtonsoft.Json;
```

Substitua a atual implementação de método public ActionResult Index() pela seguinte implementação:

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

Adicione os três métodos seguintes à classe TeamsController para implementar os tipos de ação playGames, clearCache e rebuildDB a partir da instrução switch adicionada ao fragmento de código anterior.

O método PlayGames atualiza as estatísticas da equipa simulando uma época de jogos, guarda os resultados na base de dados e limpa os dados agora desatualizados da 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();
}

O método RebuildDB reinicializa a base de dados com o conjunto de equipas predefinido, gera as estatísticas e limpa os dados agora desatualizados da 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();
}

O método ClearCachedTeams remove quaisquer estatísticas de equipa em cache da cache.

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

Adicione os quatro métodos seguintes à classe TeamsController para implementar as várias formas de obter as estatísticas da equipa a partir da cache e da base de dados. Cada um destes métodos devolve uma List<Team>, que é depois apresentada pela vista.

O método GetFromDB lê as estatísticas da equipa a partir da base de dados.

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

O método GetFromList lê as estatísticas da equipa a partir da cache, como uma List<Team> serializada. Se as estatísticas não estiverem presentes no cache, ocorrerá uma falha de cache. Se existir uma falha de acerto na cache, as estatísticas da equipa serão lidas a partir da base de dados e, em seguida, armazenadas para o próximo pedido. Neste exemplo, a serialização JSON.NET é utilizada para serializar os objetos .NET de/para a cache.

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

O método GetFromSortedSet lê as estatísticas da equipa a partir de um conjunto ordenado em cache. Se houver uma falha de cache, as estatísticas da equipe serão lidas do banco de dados e armazenadas no cache como um conjunto classificado.

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

O método GetFromSortedSetTop5 lê as cinco melhores equipas a partir do conjunto ordenado em cache. Começa por verificar se a chave teamsSortedSet existe na cache. Se essa chave não estiver presente, o GetFromSortedSet método será chamado para ler as estatísticas da equipe e armazená-las no cache. Em seguida, o conjunto ordenado em cache é consultado relativamente às cinco melhores equipas que são devolvidas.

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

Atualizar os métodos Criar, Editar e Eliminar para trabalhar com a cache

O código da estrtura gerado como parte deste exemplo inclui métodos para adicionar, editar e eliminar equipas. Sempre que uma equipa é adicionada, editada ou removida, os dados na cache ficam desatualizados. Nesta secção, vai modificar estes três métodos para limpar as equipas em cache para que a cache seja atualizada.

Navegue para o método Create(Team team), na classe TeamsController. Adicione uma chamada ao método ClearCachedTeams, conforme mostrado no seguinte exemplo:

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

Navegue para o método Edit(Team team), na classe TeamsController. Adicione uma chamada ao método ClearCachedTeams, conforme mostrado no seguinte exemplo:

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

Navegue para o método DeleteConfirmed(int id), na classe TeamsController. Adicione uma chamada ao método ClearCachedTeams, conforme mostrado no seguinte exemplo:

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

Adicionar métodos de colocação em cache para a vista Índice de Equipas

No Explorador de Soluções, expanda a pasta Vistas, em seguida, a pasta Equipas e faça duplo clique em Index.cshtml.

Perto da parte superior do ficheiro, procure o seguinte elemento de parágrafo:

Tabela de ações

Esta ligação cria uma nova equipa. Substitua o elemento de parágrafo pela seguinte tabela. Esta tabela tem ligações de ação para criar uma nova equipa, reproduzir uma nova época de jogos, limpar a cache, obter as equipas a partir da cache em vários formatos, obter as equipas a partir da base de dados e reconstruir a base de dados com novos dados de exemplo.

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

Role até a parte inferior do arquivo Index.cshtml e adicione o seguinte tr elemento para que ele seja a última linha na última tabela do arquivo:
```
<tr><td colspan="5">@ViewBag.Msg</td></tr>
```
Esta linha exibe o valor de , que contém um relatório de ViewBag.Msgstatus sobre a operação atual. O ViewBag.Msg é definido quando você seleciona qualquer um dos links de ação da etapa anterior.
Prima F6 para criar o projeto.

Executar a aplicação localmente

Execute a aplicação localmente no computador para verificar a funcionalidade que foi adicionada para suportar as equipas.

Neste teste, tanto a aplicação como a base de dados estão a ser executadas localmente. O Cache Redis do Azure não é local. Ele é hospedado remotamente no Azure. É por isso que o cache provavelmente terá um desempenho ligeiramente inferior ao do banco de dados. Para obter o melhor desempenho, o aplicativo cliente e a instância do Cache Redis do Azure devem estar no mesmo local.

Na próxima seção, você implanta todos os recursos no Azure para ver o desempenho aprimorado do uso de um cache.

Para executar a aplicação localmente:

Prima Ctrl+F5 para executar a aplicação.
Teste cada um dos novos métodos adicionados à vista. Uma vez que a cache nestes testes é remota, a base de dados deve superar ligeiramente o desempenho da cache.

Publicar e executar no Azure

Provisionar um banco de dados para o aplicativo

Nesta seção, você provisionará um novo banco de dados no Banco de dados SQL para o aplicativo usar enquanto hospedado no Azure.

No portal do Azure, selecione Criar um recurso no canto superior esquerdo do portal do Azure.
Na página Novo, selecione Banco de Dados SQL de Bancos de Dados>.

Utilize as seguintes definições para a nova Base de Dados SQL:

Cenário	Valor sugerido	Descrição
Nome da base de dados	ContosoTeamsDatabase	Para nomes de bases de dados válidos, veja Database Identifiers (Identificadores de Bases de Dados).
Subscrição	a sua subscrição	Selecione a mesma subscrição que utilizou para criar a cache e alojar o Serviço de Aplicações.
Grupo de recursos	TestResourceGroup	Selecione Usar existente e usar o mesmo grupo de recursos onde você colocou o cache e o Serviço de Aplicativo.
Selecionar origem	Base de dados vazia	Começar com uma base de dados vazia.

Em Servidor, selecione Configurar configurações>necessárias Criar um novo servidor e fornecer as seguintes informações e, em seguida, use o botão Selecionar:

Cenário	Valor sugerido	Descrição
Nome do servidor	Qualquer nome globalmente exclusivo	Para nomes de servidores válidos, veja Naming rules and restrictions (Atribuição de nomes de regras e restrições).
Início de sessão de administrador do servidor	Qualquer nome válido	Para nomes de início de sessão válidos, veja Database Identifiers (Identificadores de Bases de Dados).
Palavra-passe	Qualquer palavra-passe válida	A sua palavra-passe deve ter, pelo menos, oito carateres e deve conter carateres de três das seguintes categorias: carateres maiúsculos, carateres minúsculos, números e carateres não alfanuméricos.
Location	E.U.A. Leste	Selecione a mesma região onde criou a cache e o Serviço de Aplicações.

Selecione Fixar no painel e, em seguida, Criar para criar o novo banco de dados e servidor.
Depois que o novo banco de dados for criado, selecione Mostrar cadeias de conexão de banco de dados e copie a cadeia de conexão ADO.NET.
No portal do Azure, navegue até o Serviço de Aplicativo e selecione Configurações do Aplicativo e, em seguida , Adicionar nova cadeia de conexão na seção Cadeias de conexão.

Adicione uma nova cadeia de ligação com o nome TeamContext para corresponder à classe de contexto da base de dados do Entity Framework. Cole a cadeia de ligação para a nova base de dados como o valor. Certifique-se de substituir os seguintes espaços reservados na cadeia de conexão e selecione Salvar:

Marcador de Posição	Valor sugerido
{o_seu_nome_de_utilizador}	Use o login de administrador do servidor para o servidor que você acabou de criar.
{a_sua_palavra-passe}	Use a senha do servidor que você acabou de criar.

Ao adicionar o nome de utilizador e a palavra-passe como uma Configuração da Aplicação, o seu nome de utilizador e palavra-passe não são incluídos no seu código. Esta abordagem ajuda a proteger essas credenciais.

Publicar as atualizações da aplicação no Azure

Neste passo do tutorial, vai publicar as atualizações da aplicação no Azure e executá-las na cloud.

Selecione com o botão direito do mouse o projeto ContosoTeamStats no Visual Studio e escolha Publicar.
Selecione Publicar para usar o mesmo perfil de publicação criado no início rápido.

Após a conclusão da publicação, o Visual Studio inicia a aplicação no browser predefinido.

Cache adicionada

A tabela seguinte descreve cada ligação de ação da aplicação de exemplo:

Ação	Descrição
Criar Novo	Crie uma nova Equipa.
Reproduzir Época	Reproduza uma época de jogos, atualize as estatísticas da equipa e limpe quaisquer dados da equipa desatualizados da cache.
Limpar a Cache	Limpe as estatísticas da equipa na cache.
Lista na Cache	Obtenha as estatísticas da equipa a partir da cache. Se houver uma falha de cache, carregue as estatísticas do banco de dados e salve no cache para a próxima vez.
Conjunto Ordenado na Cache	Obtenha as estatísticas da equipa a partir da cache com um conjunto ordenado. Se houver uma falha de cache, carregue as estatísticas do banco de dados e salve no cache usando um conjunto classificado.
Cinco Melhores Equipas na Cache	Obtenha as cinco melhores equipas a partir da cache com um conjunto ordenado. Se houver uma falha de cache, carregue as estatísticas do banco de dados e salve no cache usando um conjunto classificado.
Carregar da Base de Dados	Obtenha as estatísticas da equipa a partir da base de dados.
Recriar Base de Dados	Recrie a base de dados e volte a carregá-la com os dados da equipa de exemplo.
Editar/Detalhes/Eliminar	Edite uma equipa, veja os detalhes de uma equipa, elimine uma equipa.

Selecione algumas das ações e experimente recuperar os dados das diferentes fontes. Repare nas diferenças existentes no tempo de obtenção dos dados a partir da base de dados e da cache.

Clean up resources (Limpar recursos)

Quando terminar o aplicativo de tutorial de exemplo, você poderá excluir os recursos do Azure para conservar custos e recursos. Todos os seus recursos devem estar contidos no mesmo grupo de recursos. Você pode excluí-los juntos em uma operação excluindo o grupo de recursos. As instruções neste artigo usaram um grupo de recursos chamado TestResources.

Importante

A eliminação de um grupo de recursos é irreversível e o grupo de recursos e todos os recursos contidos no mesmo serão permanentemente eliminados. Confirme que não elimina acidentalmente o grupo de recursos ou recursos errados. Se você criou os recursos para hospedar este exemplo dentro de um grupo de recursos existente, que contém recursos que você deseja manter, você pode excluir cada recurso individualmente à esquerda.

Inicie sessão no Portal do Azure e selecione Grupos de recursos.
Escreva o nome do seu grupo de recursos na caixa de texto Filtrar itens…
Selecione ... à direita do seu grupo de recursos e selecione Excluir grupo de recursos.
É-lhe pedido que confirme a eliminação do grupo de recursos. Digite o nome do grupo de recursos a ser confirmado e selecione Excluir.

Após alguns instantes, o grupo de recursos e todos os recursos contidos no mesmo são eliminados.

Próximos passos

Como dimensionar o Cache do Azure para Redis

Partilhar via