.NET Core Saturday – Campinas

Olá pessoal,

No último sábado 13/07 participei do .NET Core Saturday – Campinas, evento no qual ajudei tanto na organização quanto palestrando. No total tivemos um público de 50 pessoas.

Os slides utilizados na minha palestra, sobre Utilizando o Azure Cache for Redis com ASP.NET Core 2.2 você confere logo abaixo:

E para quem quiser os códigos utilizados na palestra, é só baixar através desses links:

Deixo aqui também três artigos que já publiquei como referência ao conteúdo apresentado.

Open Source Roadshow 2019 – Piracicaba-SP

Olá pessoal,

No último sábado dia 11/05 participei do Open Source Roadshow 2019 – Piracicaba-SP, evento no qual ajudei tanto na organização quanto palestrando. As inscrições do evento foram efetuadas pelo Sympla e tivemos um publico de 50 pessoas.

Os slides utilizados na minha palestra, sobre Utilizando o Azure Cache for Redis com ASP.NET Core 2 você confere logo abaixo:

E para quem quiser os códigos utilizados na palestra, é só baixar através desses links:

Deixo aqui também três artigos que já publiquei como referência ao conteúdo apresentado.

Abaixo algumas fotos do evento.

Open source Roadshow 2019 – Piracicaba
Open source Roadshow 2019 – Piracicaba

Global Azure Bootcamp 2019 – Campinas

Olá pessoal,

No último sábado dia 27/04 participei do Global Azure Bootcamp 2019 – Campinas, evento no qual ajudei na organização, palestrando e também ministrando um workshop (este último em parceria com o Robson Rocha). As incrições do evento foram efetuadas pelo Sympla e tivemos um publico de 70 pessoas.

Os slides utilizados na minha palestra, sobre como Desenvolver “offline” no Azure você confere logo abaixo:

E para quem quiser o código utilizado, é só baixar através desse link

Já sobre o Workshop dos 5 Serviços do Azure que todo o Desenvolvedor precisa conhecer, os slides você confere logo abaixo e o código utilizado através desse link

Abaixo algumas fotos do evento.

Global Azure Bootcamp 2019
Global Azure Bootcamp 2019

MVP Conf Latam 2019

Olá pessoal,

Na última sexta-feira dia 12/04 participei do MVP Conf Latam 2019 palestrando sobre os Cinco Serviços do Azure que todo desenvolvedor precisa conhecer.

Este evento contou com mais de 2.000 pessoas inscritas e todo o valor arrecadado na venda dos ingressos foi destinado a intituições de caridade, uma em cada região do Brasil.

Os slides utilizados na palestra você confere logo abaixo:

Deixo aqui também o código fonte utilizado através desse link.

Algumas fotos da minha palestra e do evento:

MVP Conf
MVP Conf Latam 2019
MVP Conf
MVP Conf Latam 2019
MVP Conf
MVP Conf Latam 2019

Série Redis on Azure – Salvando um objeto no Redis com a Interface IDistributedCache e publicando no Azure

Seguindo a nossa série sobre como utilizar o Redis no Azure, neste artigo salvaremos um objeto complexo ao invés de uma simples string utilizando a Interface IDistributedCache.

Como exemplo, vamos utilizar a API da NASA que nos fornece uma foto nova do espaço todo dia. Caso tenha perdido o artigo anterior, ele pode ser acessado através deste link.

Vale lembrar que, caso você ainda não tenha uma subscription no Azure, será necessário criar uma (caso queira um passo a passo, clique aqui).

NASA API

Conforme mencionado na introdução, neste artigo vamos utilizar a API da NASA como exemplo. Entretanto, a API possui uma série de limitações quanto ao numero de acessos, e obviamente não queremos que alguém acesse nosso site e encontre uma mensagem de erro – é aí que o Redis passa a ser fundamental para a aplicação.

Através dele vamos criar um cache do objeto retornado pela API, que terá como validade apenas o dia atual, expirando na sequência para que o conteúdo seja atualizado.

Sendo assim, primeiramente, caso você ainda não tenha acesso a API da NASA, clique aqui e faça seu cadastro (Free) para receber uma chave de acesso.

Feito isso, vamos consumir a API para coletar os dados que ele vai nos fornecer e salvar o conteúdo no nosso cache para garantir que ele esteja sempre disponível.

Todo o código da aplicação está disponível no meu GitHub e está devidamente comentado para melhor entendimento.

e está devidamente comentado para melhor entendimento.

Redis on Azure

Caso ainda não tenha uma instância do Redis no Azure, será necessário criar uma. No link do meu artigo anterior, temos um passo a passo bastante detalhado caso seja necessário.

Publicando no Azure

Agora, como último passo, vamos publicar nossa aplicação e vê-la em pleno funcionamento. Isso, graças a facilidade que o Azure, juntamente com Visual Studio nos oferece. E acredite, será a parte mais simples de se fazer.

Primeiramente clicaremos com o botão direito em nossa solution, e em seguida em Publish > Publish to Azure, conforme nos mostra a imagem abaixo:

Redis on Azure
Figura 1

Feito isso, vamos criar nosso App Service no Azure, então primeiramente forneça um nome para sua aplicação (lembrando que esse nome é único). Depois, selecione sua subscription do Azure, selecione ou crie um novo Resource Group e selecione também o Service Plan, lembrando que essa última opção refere-se a “configuração” da máquina que você deseja hospedar a sua aplicação (note na figura 2, abaixo, que eu selecionei a versão Free que o Azure oferece) e depois clique em Create.

Redis on Azure
Figura 2

Após a criação dos serviços (em torno de três minutos), selecione o App Service que você acabou de criar e clique em Publish, conforme a figura abaixo:

Redis on Azure
Figura 3

Após o termino da publicação da sua aplicação, acesse a mesma através do browser e após o acesso da sua aplicação pela primeira vez, acesse também o Redis através do Portal do Azure ou de qualquer outra ferramenta de sua preferência.

Note que o nosso cache estará salvo lá, conforme nos mostra a figura 4:

Redis on Azure
Figura 4

Agora, até o final do dia todos os seus Requests virão do conteúdo armazenado no cache do Redis, e assim finalizo a série Redis on Azure. Espero que tenham gostado e até a próxima.

Obrigado!

Série Redis on Azure – Criando nossa base Redis e desenvolvendo nosso primeiro Cache

Seguindo a nossa série sobre a utilização do Redis no Azure, nesse artigo vamos criar nossa base Redis e vamos desenvolver um exemplo. Caso tenha perdido o artigo anterior, ele pode ser acessado através deste link.

Vale lembrar que, caso ainda não tenha uma subscription no Azure, será necessário criar uma (caso queira um passo a passo, clique aqui).

Criando nosso Redis no Azure

Primeiro vamos acessar o Portal do Azure através do link: https://portal.azure.com e efetuar o nosso login. Já no portal do Azure, vamos clicar em “Create a Resource>Databases>Redis Cache“, conforme na figura abaixo:

Redis on Azure
Figura 1

Feito isso, vamos preencher os dados e depois clicar em “Create” para a criação do nosso serviço de cache, conforme nos mostra a figura 2 abaixo:

Redis on Azure
Figura 2

O processo para finalizar a criação do serviço leva em média 15 minutos, e assim que ele terminar, acesse o Redis e clique em “Keys“. Em seguida, copie o endereço da Primary connection string, conforme nos mostra a figura abaixo:

Redis on Azure
Figura 3

Agora vamos esquecer por um breve momento o Azure e vamos criar uma aplicação do tipo Web API utilizando o ASP.NET Core 2. Se estiver usando o Visual Studio Code, é só abrir o terminal, navegar até a pasta desejada e digitar o comando:

dotnet new webapi

Após o termino da criação do projeto, abra o arquivo appsettings.json e crie uma conexão com a string de conexão do Redis que copiamos anteriormente, conforme o código abaixo:

"ConnectionStrings": {
    "RedisConn": "conexão do seu redis"
}

Agora no nosso arquivo Startup.cs, vamos adicionar o seguinte código:

services.AddDistributedRedisCache(options =>
{
    options.Configuration = Configuration.GetConnectionString("RedisConn");
    options.InstanceName = "ericsonfInstance";
});

E por último, vamos criar um Controller chamado RedisCacheController e dentro dele no método Get, vamos criar nosso cache através da Interface IDistributedCache, utilizando o código abaixo (comentários no próprio código para melhor entendimento):

public class RedisCacheController : Controller
{
    private readonly IDistributedCache _distributedCache;

    public RedisCacheController(IDistributedCache distributedCache)
    {
        _distributedCache = distributedCache;
    }

    // GET api/RedisCache
    [HttpGet]
    public string Get()
    {
        //Variável que vai receber uma data
        var date = string.Empty;
        //Key utilizada para armazenarmos o nosso cache (que será a data)
        var key = "distributedCacheKey";

        //Verifico se o cahce já existe
        date = _distributedCache.GetString(key);
        //Se existir exibo o texto Data cache com a data cacheada.
        if (!string.IsNullOrEmpty(date))
        {
            return string.Concat("Data cache: ", date);
        }
        //Senão criamos nosso cache com a data atual
        else
        {
            date = DateTime.Now.ToString();
            /* Nesta linha diz que o cache permanecera ativo para sempre desde que num periodo de 10 segundos alguém acesse ele.
            Caso você deseje que o cache desapareça em um determinado periodo de tempo independentemente de acesso,
            troque o comando SetSlidingExpiration para SetAbsoluteExpiration. */
            var cacheExpiration = new DistributedCacheEntryOptions().SetSlidingExpiration(TimeSpan.FromSeconds(10));
            //Cache sendo criado
            _distributedCache.SetString(key, date, cacheExpiration);
            //Retorno a Data atual pois ainda não havia nenhum cache com a key distributedCacheKey
            return string.Concat("Data atual: ", date);
        }
    }
}

Agora execute o projeto e veja que inicialmente ele trouxe a Data atual. Se você atualizar seu browser, verá que ele mudará o texto para Data cache sem alterar a data em si.

Para você visualizar o cache em si salvo no Redis, volte novamente para o Portal do Azure e clique em >_ Console, para abrir o console do Redis e nele digite monitor. Feito isso, execute novamente a aplicação e observe a sua Key e a data cacheada conforme mostram as figuras abaixo:

Redis on Azure
Figura 4
Redis on Azure
Figura 5

Como você pode observar, o mesmo data cacheado na tela é o mesmo que está salvo no Redis.

No próximo artigo da série utilizaremos outras maneiras de criar nosso cache e de administra-lo. E assim termino mais um artigo, espero que tenham gostado e até o próximo.

Série Redis on Azure – O que é Redis e para que serve

Neste artigo pretendo iniciar uma série de artigos que vão focar em como utilizar o Redis no Azure através de exemplos práticos para os mais diversos cenários. E para iniciar essa série, vamos primeiramente entender o que é o Redis e para que ele serve de fato.

Redis

O Redis (REmote DIctionary Server) é uma estrutura de armazenamento em memória, NoSQL de chave-valor e open source. Apesar de possuir diversas utilidades (discutiremos elas mais adiante) o Redis é costumeiramente utilizado para armazenamento de cache visando sempre melhorar o desempenho de sistemas que dependem de uma grande quantidade de dados vindos do back-end.

Pelo fato do seu armazenamento ser feito em memória, ele é extremamente rápido, chegando a performance de 110.000 SETs e 81.000 GETs por segundo.

Outros dois pontos importantíssimos, são:

  • Suas operações são atômicas, ou seja, uma operação sempre retornará sucesso ou falha obrigatoriamente.
  • O Redis é single-threaded, e nesse caso, um fator que vale a pena mencionar é que um processador rápido com bastante cache se sobressai, se comparado com um processador de muitos núcleos com pouco cache.

Apesar de ser uma estrutura chave-valor, o Redis possui um conjunto bem rico de tipos de dados, sendo os principais:

  • Strings: tipo mais básico do Redis. Eles são binários, e com isso, o tipo String pode conter qualquer tipo de dado como, por exemplo, uma imagem. Vale pontuar que o tamanho máximo da String é 512 mb.
  • Lists: esse tipo nada mais é do que uma lista de Strings, classificadas por ordem de inserção. O Redis suporta uma lista de strings contendo até aproximadamente 4 bilhões de elementos.
  • Sets: é uma colação não ordenada de Strings. Por padrão, os Sets não permitem elementos repetidos, sendo que adicionando o mesmo elemento várias vezes resultará em um outro conjunto com uma cópia unica desse elemento. Assim como as Lists, os Sets também podem armazenar aproximadamente 4 bilhões de elementos.
  • Sorted Sets: semelhante aos Sets, porém com o recurso de serem ordenados, cada elemento é associado a um Score, sendo que a ordenação é feita sobre ele.
  • Hash: utilizado majoritariamente para representar um objeto, sendo que ele mapeia um atributo e seu respectivo valor (assim como em um objeto).

A respeito de sua aplicabilidade, conforme mencionado no inicio do artigo, o Redis é bastante versátil, se saindo bem nos mais variados cenários, sendo os principais:

  • Armazenamento em cache (cache de conteúdo): nesse cenário o Redis serve para armazenar conteúdos que raramente são alterados, trazendo maior velocidade e consequentemente melhorando o desempenho das aplicações. Com isso, podemos poupar por requisições desnecessárias no servidor.
  • Gerenciamento de Sessão (cache de sessão): aqui, o Redis pode armazenar sessões com um tempo de vida já definido, sendo perfeito para armazenar informações de um usuário logado na sua aplicação, bem como um carrinho de compras e etc.
  • Classificações em Real-Time (cache-aside): usando o sorted set, você pode criar um rank e atualizá-lo conforme demanda (cache-aside) garantindo que sua aplicação mostre uma classificação em tempo real.
  • Filas: Sendo single-threaded e suas operações atômicas, o Redis é uma ótima opção para ser usado como um agente de mensagens.

Agora que temos uma boa base sobre como Redis funciona e seus principais cenários de aplicação, no nosso próximo artigo vamos por a mão na massa e criar nosso servidor no Azure e então, começar a implementar alguns exemplos abordados nesse primeiro artigo.

Espero que tenham gostado e até o próximo artigo!

Obrigado.

Convertendo consultas T-SQL em LINQ

Se você já teve e/ou tem bastante vivência com a linguagem T-SQL e hoje se depara com o um software que tenha um ORM para fazer as transações com o banco de dados, pode ser que aparecem algumas dúvidas sobre como “converter” uma querie T-SQL na “linguagem” que o ORM entende.

Se você se deparar com essa situação e tiver alguma dúvida quanto a alguma consulta que precisa converter, esse post é destinado a você.

Nesse post vamos utilizar o Entity Framework como ORM e a linguagem LINQ to Entities que permite aos desenvolvedores escreverem consultas nesse modelo usando VB ou C#.

Abaixo segue o modelo que utilizei para facilitar o entendimento das consultas.

Figura 1

SELECT COM UM TOP

T-SQL:  SELECT TOP 2 Nome FROM Artista;

LINQ:   var result = (from a in context.Artista select a.Nome).Take(2);

LAMBDA: var result = context.Artista.Select(a => a.Nome).Take(2);

SELECT COM UM WHERE

T-SQL:  SELECT Nome FROM Artista WHERE Nome = ‘Led Zeppelin’;

LINQ:   var result = (from a in context.Artista 
                    where a.Nome.Equals(“Led Zeppelin”) 
                    select a.Nome).ToList();

LAMBDA: var result = context.Artista
                    .Where(a => a.Nome.Equals(“Led Zeppelin”))
                    .Select(a => a.Nome).ToList();

SELECT COM UM INNER JOIN

T-SQL: 	SELECT a.Nome, al.Titulo FROM Artista a 
       	    INNER JOIN Album al ON al.ArtistaId = a.ArtistaId;

LINQ:   var result = (from a in context.Artista
            join al in context.Album on a.ArtistaId equals al.ArtistaId
            select new
            {
                a.Nome,
                al.Titulo
            }).ToList();

LAMBDA: var result = context.Artista
            .Join(context.Album, artista => artista.ArtistaId, album => album.ArtistaId,
            (artista, album) => new { Artista = artista, Album = album })
            .Select(a => new { 
                Nome = a.Artista.Nome, 
                Titulo = a.Album.Titulo 
            }).ToList();

SELECT COM DUAS CONDIÇÕES NO MESMO INNER JOIN

T-SQL:  SELECT DISTINCT a.Nome, al.Titulo FROM Artista a 
            INNER JOIN Album al ON al.ArtistaId = a.ArtistaId AND al.Titulo = a.Nome;

LINQ:   var result = (from a in context.Artista
            join al in context.Album on
            new { C1 = a.ArtistaId, C2 = a.Nome } equals 
            new { C1 = al.ArtistaId, C2 = al.Titulo }
            select new
            {
                a.Nome,
                al.Titulo
            }).ToList();

LAMBDA: var result = context.Artista
        .Join(context.Album, artista => new { C1 = artista.ArtistaId, C2 = artista.Nome }, 
            album => new { C1 = album.ArtistaId, C2 = album.Titulo },
            (artista, album) => new { Artista = artista, Album = album })
        .Select(a => new { 
            Nome = a.Artista.Nome, 
            Titulo = a.Album.Titulo 
        }).ToList();

SELECT COM DOIS INNER JOINS

T-SQL:  SELECT a.Nome, al.Titulo, f.Nome FROM Artista a
            INNER JOIN Album al ON al.ArtistaId = a.ArtistaId
            INNER JOIN Faixa f ON f.AlbumId = al.AlbumId;

LINQ:   var result = (from a in context.Artista
        join al in context.Album on a.ArtistaId equals al.ArtistaId
        join f in context.Faixa on al.AlbumId equals f.AlbumId
        select new
        {
            Artista = a.Nome,
            Album = al.Titulo,
            Faixa = f.Nome
         }).ToList();

LAMBDA: var result = context.Artista
        .Join(context.Album, artista => artista.ArtistaId, album => album.ArtistaId,
            (artista, album) => new { Artista = artista, Album = album })
        .Join(context.Faixa, album => album.Album.AlbumId, faixa => faixa.AlbumId,
            (album, faixa) => new { Album = album, Faixa = faixa })
        .Select(a => new { 
            Nome = a.Album.Artista.Nome, 
            Titulo = a.Album.Album.Titulo, 
            Faixa = a.Faixa.Nome 
        }).ToList();

SELECT COM UM LEFT JOIN

T-SQL:  SELECT a.Nome, al.Titulo FROM Artista a
            LEFT JOIN Album al ON al.ArtistaId = a.ArtistaId;

LINQ:   var result = (from a in context.Artista
            join al in context.Album on a.ArtistaId equals al.ArtistaId 
                into All from al in All.DefaultIfEmpty()
            select new
            {
                a.Nome,
                al.Titulo
            }).ToList();

LAMBDA: var result = context.Artista
            .GroupJoin(context.Album, artista => artista.ArtistaId, album => album.ArtistaId,
                (artista, album) => new { Artista = artista, Album = album.DefaultIfEmpty() })
            .SelectMany(a => a.Album, (a, album) => new { 
                a.Artista.Nome, 
                album.Titulo 
            }).ToList();

SELECT COM DOIS LEFT JOINS, GROUP BY e COUNT

T-SQL:  SELECT DISTINCT a.Nome, (SELECT COUNT(*) AS Album FROM Album WHERE ArtistaId = a.ArtistaId) AS Album, 
            	COUNT(f.FaixaId) AS Faixa 
        	FROM Artista a
            LEFT JOIN Album al ON al.ArtistaId = a.ArtistaId
            LEFT JOIN Faixa f ON f.AlbumId = al.AlbumId
            GROUP BY a.Nome, a.ArtistaId;

LINQ:   var result = (from a in context.Artista
        join al in context.Album on a.ArtistaId equals al.ArtistaId 
            into All1 from al in All1.DefaultIfEmpty()
        join f in context.Faixa on al.AlbumId equals f.AlbumId 
            into All2
        from f in All2.DefaultIfEmpty()
        group a by a into grouped
        let totalAlbuns = grouped.Key.Album.Count()
        let totalFaixas = grouped.Count(x => x.Album.Count > 0)
        select new
        {
            Artista = grouped.Key.Nome,
            Albuns = totalAlbuns,
            Faixas = totalFaixas
        }).ToList();

LAMBDA: var result = context.Artista
            .GroupJoin(context.Album, artista => artista.ArtistaId, album => album.ArtistaId,
                (artista, album) => album.Select(x => new { 
                                                    Artista = artista, 
                                                    Album = x 
                                                })
            .DefaultIfEmpty(new { 
                Artista = artista, 
                Album = (Albuns)null 
            }))
            .SelectMany(x => x)
            .GroupJoin(context.Faixa, 
                album => album.Album.AlbumId, 
                faixa => faixa.Album.AlbumId,
               	    (album, faixa) => faixa.Select(y => new { 
                                                Artista = album.Artista, 
                                                Album = album.Album, 
                                                Faixa = y 
                                            })
            .DefaultIfEmpty(new { 
                Artista = album.Artista, 
                Album = album.Album, 
                Faixa = (Faixas)null 
            }))
            .SelectMany(y => y)
            .GroupBy(grouped => new { grouped.Artista })
            .Select(g => new
            {
                Artista = g.Key.Artista.Nome,
                Albuns = g.Key.Artista.Album.Count(),
                Faixas = g.Count(x => x.Album.Faixa.Count > 0)
            }).ToList();

Como vocês puderam ver a ideia desse artigo foi de ser o mais direto ao ponto possível. Obviamente, é impossivel cobrir todos os cenários possíveis de se fazer consultas T-SQL, então tentei  colocar desde um exemplo simples até um exemplo um pouco mais complexo.

Espero que tenham gostado e até a próxima.

Microsoft Connect(); 2019

Olá pessoal,

No último sábado dia 19/01 participei do Microsoft Connect(); 2019 tanto na organização do evento quanto na palestra que fiz juntamente com o Robson Rocha, falando sobre os 5 serviços do Microsoft Azure que todo desenvolvedor .NET precisa conhecer.

Os slides utilizados na palestra você confere logo abaixo:

Também deixo aqui meu muito obrigado para o prof. João Cunha pelo apoio no local do evento.

Abaixo, fotos do evento

Microsoft Connect 2019 01
Microsoft Connect 2019
Microsoft Connect 2019 02
Microsoft Connect 2019
Microsoft Connect 2019 03
Microsoft Connect 2019

II Semana de Cursos de TI da UniMetrocamp | Wyden

Bom dia pessoal,

No último dia 11/10 participei da II Semana de Cursos de TI na UniMetrocamp | Wyden juntamente com o Robson Rocha, falando sobre os 5 serviços do Microsoft Azure que todo desenvolvedor .NET precisa conhecer.

Deixo aqui meu muito obrigado para o prof. João Cunha pelo convite.

Abaixo uma foto do evento.

II-semana-de-cursos-de-ti-da-unimetrocamp-wyden