Dica: Problemas com DNS em containers no Docker e OSX

Fala galera!

Continuando com as dicas sobre docker estava tendo problema com a geração de um container para o Sonarqube.

O problema ocorria na hora de baixar uma chave para o PGP. A mensagem de erro dizia que o host nÃo podia ser localizado. Aparentemente algo relacionado ao DNS.

Depois de bater cabeça verifiquei as configurações de DNS do meu Mac e verifiquei que o endereço estava com o do provedor e nÃo o do roteador. Resolvi então altera-lo para o do Google: 8.8.8.

Imediatamente as coisas comçaram a funcionar. Então se voce estiver tendo o mesmo problema fica a dica.

Até a próxima!

Dica: Limpando seu ambiente Docker

Fala galera!

Principalmente durante o nosso aprendizado de docker acabamos criando uma verdadeira bagunça de imagens e containers em nossa máquina.

Resolvi fazer uma faxina hoje e acabei me deparando com estes dois comandos bem úteis para fazer a tarefa.

Nota: Isto irá pagar todas as imagens e containers da sua máquina. Faça com cuidado para nÃo perder dados importantes.

docker rm $(docker ps -a -q)
docker rmi $(docker images -q)

A primeira linha remove todos os containers e a segunda as imagens.

Até a próxima!

[Video]: DDD Cenários e Polemicas

Fala galera!

Como o assunto é extenso e o primeiro vídeo gerou bastante discussão interessante com a galera compartilhando suas experiencias resolvemos gravar uma segunda ediçÃo abordando os pontos mais polemicos e trazendo cenários reais de implementação.

A discussão foi bem rica inclusive contando com uma provocação do Fabio Margarito sobre Micro Services.

Não deixe de conferir também o blog do Jimmy Bogard que irá enriquecer bastante sua bagagem.

Se voce gostou do primeiro vídeo não deixe de conferir este.

E como sempre curta o vídeo, assine o canal e compartilhe com a galera!

Até a próxima!

Lançado AutoMapper 4.2.0

Fala galera!

Eu

Recentemente foi lançada a versão 4.2.0 do AutoMapper framework de mapeamento de tipos que , desde que conheci, passou a integrar a minha caixa de ferramentas essenciais.

Caso voce não conheça o AutoMapper vem solucionar um dos tediosos problemas do desenvolvimento de sistemas em multiplas camadas: a conversão de Entidades do Domínio em DTOs (Data Transfer Objects) para comunicaçÃo entre estas camadas mantendo o encapsulamento do domínio.

A maior novidade desta última versão, além de diversas melhorias, foi a introdução de uma API não estática, o que facilita muito o uso com Containers de injeção de dependencia e aumenta a testabilidade.

DemonstraçÃo

Para demonstrar esta API e um pouco do poder do AutoMapper desenvolvi uma pequena aplicação que converte uma entidade de domínio em dois DTOs. distintos.

Crie um novo Console Application e adicione o pacote nuget do AutoMapper.

Comecemos com a declaração da nossa entidade:

public class Cliente
    {
        public string CNPJ { get; set; }
        public string RazaoSocial { get; set; }
        public string NomeFantasia { get; set; }
        public string InscricaoEstadual { get; set; }
        public Endereco Endereco { get; set; }
    }
public class Endereco
    {
        public string Logradouro { get; set; }
        public string Numero { get; set; }
        public string Complemento { get; set; }
        public string Bairro { get; set; }
        public string Cidade { get; set; }
        public string UF { get; set; }
        public string CEP { get; set; }
    }

Agora criaremos nossos dois DTOS:

public class ClienteDTO
    {
        public string CNPJ { get; set; }
        public string RazaoSocial { get; set; }
        public string NomeFantasia { get; set; }
        public string InscricaoEstadual { get; set; }
        public string EnderecoLogradouro { get; set; }
        public string EnderecoNumero { get; set; }
        public string EnderecoComplemento { get; set; }
        public string EnderecoBairro { get; set; }
        public string EnderecoCidade { get; set; }
        public string EnderecoUF { get; set; }
        public string EnderecoCEP { get; set; }
    }
public class EnvelopeDTO
    {
        public string Destinatario { get; set; }
        public string Linha1 { get; set; }
        public string Linha2 { get; set; }
        public string Linha3 { get; set; }
        public string CEP { get; set; }
    }

Notemos que no primeiro DTO estamos utilizando uma convençÃo do AutoMapper pra que ele consiga trabalhar de forma automatizada.

Para melhor organizar os mapeamentos gosto, mesmo que em projetos simples, de utilizar Profiles. Então em nosso exemplo ele ficará assim:

public class ClienteProfile: Profile
    {
        protected override void Configure()
        {
            CreateMap()
                .ForMember(dst => dst.InscricaoEstadual, opt => opt.NullSubstitute("Isento"));

            CreateMap()
                .ForMember(dst => dst.Destinatario, opt => opt.MapFrom(src => src.NomeFantasia))
                .ForMember(dst => dst.Linha1, opt => opt.MapFrom(src =>
                    src.Endereco.Logradouro + ", " + src.Endereco.Numero +
                    src.Endereco.Complemento ?? string.Empty))
                .ForMember(dst => dst.Linha2, opt => opt.MapFrom(src => src.Endereco.Bairro))
                .ForMember(dst => dst.Linha3, opt => opt.MapFrom(src =>
                    src.Endereco.Cidade + " - " + src.Endereco.UF))
                .ForMember(dst => dst.CEP, opt => opt.MapFrom(src => src.Endereco.CEP));
        }         
    }

Perceba o que fizemos em relação a Inscrição Estadual. Caso a mesma esteja nula será substituida pela palavra Isento.

Agora colocando tudo para funcionar:

class Program
    {
        private static IMapper mapper;

        static void Main(string[] args)
        {
            var config = new MapperConfiguration(cfg =>
            {
                cfg.AddProfile();
            });
            mapper = config.CreateMapper();

            Cliente_ClienteDTO();
            Cliente_EnvelopeDTO();
        }

        private static void Cliente_ClienteDTO()
        {
            System.Console.WriteLine("Convertendo um Cliente para ClienteDTO");
            var cliente = new Cliente()
            {
                CNPJ = "00.000.000/0001-0",
                RazaoSocial = "Razão Social",
                NomeFantasia = "Nome Fantasia",
                Endereco = new Endereco()
                {
                    Logradouro = "Rua",
                    Numero = "123",
                    Bairro = "Bairro",
                    Cidade = "Cidade",
                    UF = "SP",
                    CEP = "08209-000"
                }
            };

            var dto = mapper.Map(cliente);

            System.Console.WriteLine("Razão Social: {0}", dto.RazaoSocial);
            System.Console.WriteLine("Nome Fantasia:{0}", dto.EnderecoLogradouro);
            System.Console.WriteLine("CNPJ: {0}", dto.CNPJ);
            System.Console.WriteLine("Inscr. EStadual: {0}", dto.InscricaoEstadual);
            System.Console.WriteLine("Endereço: {0}, {1} {2}", dto.EnderecoLogradouro, dto.EnderecoNumero,
                dto.EnderecoComplemento);

            System.Console.WriteLine("Pressione ENTER para continuar.");
            System.Console.ReadLine();
        }

        private static void Cliente_EnvelopeDTO()
        {
            var cliente = new Cliente()
            {                                
                NomeFantasia = "Alexandre Santos Costa",
                Endereco = new Endereco()
                {
                    Logradouro = "Rua das Lendas",
                    Numero = "229",
                    Bairro = "Jardim das Na;óes",
                    Cidade = "Sáo Paulo",
                    UF = "SP",
                    CEP = "08209-000"
                }
            };

            var dto = mapper.Map(cliente);

            System.Console.WriteLine(dto.Destinatario);
            System.Console.WriteLine(dto.Linha1);
            System.Console.WriteLine(dto.Linha2);
            System.Console.WriteLine("{0} CEP: {1}", dto.Linha3, dto.CEP);

            System.Console.WriteLine("Pressione ENTER para continuar.");

            System.Console.ReadLine();
        }
    }

Até a próxima!

ASP.NET SignalR: Criando um Mural de Recados

Fala galera!

Conforme prometi no primeiro post da série vamos implementar um pequeno exemplo utilizando os Hubs do ASP.NET SignalR para fixar melhor os conceitos.

Recapitulando os Hubs abstraem toda a camada de comunicação entre o servidor e os clientes permitindo de forma facilitada a implementação de cenários de comunicação em tempo real como:

  • Notificação dos clientes quando da ocorrencia de eventos no servidor tais como conclusão de processos de longa duração, alteração de status em fluxos de trabalho, etc;
  • Comunicação entre aplicações, inclusive em diferentes plataformas, tais como jogos, chats, etc;

Durante este artigo iremos construir um pequeno mural de recados que permitiráque os usuários publiquem mensagens que atualizarão o painel em todos os clientes conectados naquele momento.

Criando nosso mural

A Solution será composta de dois projetos:

  • Mural.Server: aplicação console responsável por hospedar nosso servidor SignalR. Poderia ser uma aplicação Web mas escolhi este modelo apenas para efeito de demonstração da versatilidade deste tipo de solução;
  • Mural.WEb: é uma WEb Application vazia apenas pra hospedar nossa página HTML e seus scripts. Poderia ser qualquer tipo de aplicação mas também escolhi este modelo pela sua simplicidade;

Então para começar crie uma Blank Solution, adicione os dois projetos e vamos começar a implementa-los.

Mural.Server

Nossa aplicação console precise de apenas um pacote Nuget:

  • ASP.NET SignalR Self Host;

Este pacote instalará todo o core do SignalR e se utilizará do OWIN para hospedar uma aplicação Web no endereço: http://localhost:8080.

O SignalR trabalha com um mapeamento padrão em /signalr e disponibiliza o proxy para os hubs, em JavaScript no endpoint /signalr/hubs. Veremos isto em detalhes quando estivermos construindo nosso cliente.

Para que possamos configurar o servidor precisamos adicionar uma nova classe chamada Startup que deve ter a seguinte implementação:

public class Startup
    {
        public void Configuration(IAppBuilder app)
        {
            app.MapSignalR();
        }
    }

Com isto o SignalR irá se configurar automaticamente. Agora precisamos subir nosso servidor quando a aplicação for inicializada. Altere o método Main da classe Program para:

class Program
    {
        static void Main(string[] args)
        {
            using (WebApp.Start("http://localhost:8080/"))
            {
                Console.WriteLine("Server running at http://localhost:8080/");
                Console.ReadLine();
            }
        }
    }

E para finalizar o projeto de nosso servidor precisamos apenas criar o Hub. Isto é feito através da implementação de uma classe que herda de Hub e todos os seus métodos publicos estão disponíveis para serem chamados pelo cliente.

Já para acionarmos os clientes utilizamos a propriedade Clients e suas propriedades All para todos os clientes conectados, Caller para o chamador atual e Group para enviar para um grupo específico. Em um exemplo mais avançado abordaremos estes conceitos.

Dica: utilize a versão d Hub que recebe uma interface. Isto evitará erros de digitação muito comuns quando utilizamos objetos dynamic.

Logo nossa interface e Hub ficarão desse modo:

public interface IMuralHubClient
    {
        void OnMensagemRecebida(string mensagem);
    }
public class MuralHub: Hub
    {
        public void Publicar(string mensagem)
        {
            Console.WriteLine("Cliente {0} enviou {1} ...", Context.ConnectionId, mensagem);
            Clients.All.OnMensagemRecebida(mensagem);
        }

        public override Task OnConnected()
        {
            Console.WriteLine("Cliente {0} estabeleceu conexão ...", Context.ConnectionId);
            return base.OnConnected();
        }

        public override Task OnDisconnected(bool stopCalled)
        {
            Console.WriteLine("Cliente {0} desconectado ...", Context.ConnectionId);
            return base.OnDisconnected(stopCalled);
        }
    }

Voilá! Nosso servidor está pronto para ser utilizado. Caso voce queira ter certeza disto inicie o debug e aponte seu navegador para http://localhost:8080/signalr/hubs e veja que será retornado um JavaScript contendo toda implementaçÃo do cliente para nosso hub.

Mural.Web

Agora vamos criar nosso cliente. Adicione os seguintes pacotes Nuget:

  • Bootstrap;
  • ASP.NET SignalR.js;

O Bootstrap srá utilizado para dar uma ar mais profissional a interface do nosso mural, já o SignalR.js é o cliente do SignalR. Ele adicionará automaticamente o jQuery biblioteca necessária tanto pelo Bootstrap quando pelo SignalR.js.

Crie um novo arquivo chamado Index.html com o seguinte conteúdo:




    Mural de Recados
    
    



<div class="container">
    <div class="panel panel-default col-md-8 col-sm-12">
        <div class="panel-heading">Mural de Recados</div>
        <div class="panel-body">
            <ul class="media-list" id="mural">
            </ul>
        </div>
    </div>
    <div class="panel panel-default col-md-4 col-sm-12">
        <div class="panel-heading">Publicar Mensagem</div>
        <div class="panel-body">
            <div class="form-group">
                Mensagem
                <div class="form-group">
                    
                </div>
            </div>
            <div class="form-group">
                Publicar
            </div>
        </div>
    </div>
</div>




    




E codificaremos a interação com nosso hub no arquivo mural.js da seguinte forma:

(function($) {
    $.connection.hub.url = 'http://localhost:8080/signalr';
    var hub = $.connection.muralHub;
    hub.client.OnMensagemRecebida = function(mensagem) {
        var li = $("<li>");
        li.addClass("media")
        var body = $("<div>")
        body.addClass("media-body");
        body.text(mensagem);
        li.append(body);
        $("#mural").append(li);
    }

    $(function() {
        $("#publicar").click(function() {
            hub.server.publicar($("#mensagem").val());
            $("#mensagem").val('');
            $("#mensagem").focus();
        });

        $.connection.hub.start().done(function() {
            $("#mensagem").focus();
        });
    });
})(jQuery);

Observemos que no bloco JavaScript realizamos as seguintes etapas:

  • Definimos a url do servidor SignalR;
  • Criamos uma referencia para o nosso Hub;
  • Definimos uma unção anonima que será chamada quando o servidor chamar o método OnMensagemRecebida do cliente;
  • Fazemos chamadas ao método Publicar do servidor;
  • Inicializamos a conexÃo com o servidor;

O código é bem simples e auto explicativo mas caso tenha alguma duvida terei prazer em responde-las nos comentários.

Por enquanto é isto. Veremos se em postagens superiores criamos coisas mais avançadas e divertidas.

Até a próxima!

Vídeo: O que é Domain Driven Design

Fala galera!

Infelizmente minha conexão não colaborou ontem mas a galera se reuniu para falar deste tema tão em voga: Domain Driven Design.

Apesar de ser um tema exaustivamente discutido o DDD ainda traz muitos questionamentos em relação a sua aplicação e implementação.

E ai concorda com o que foi comentado/discutido? De sua opinião aqui nos comentários e não se esueça de curtir os vídeos, assinar o canal e compartilhar com a galera!

Até a próxima!

Big Data: Falando sobre arquitetura

Fala galera!

Dando continuidade aos nossos hangouts sobre Big Data cumprimos a promessa de discutir a arquitetura por trás das soluções que encontramos no mercado.

Para isto Jorge Fabre compartilhou conosco um material bem interessante com a big picture do que é, reforçou os conceitos e juntamente com Flavio Barros, estatístico e irmão do nosso amigo Fabio Margarito, explicou como funcionaria na prática uma solução utilizando algumas das tecnologias que já abordamos.

Gostou? Quer ser um Data Scientist? compartilhe com a gente suas impressões e experiencias aqui nos comentários, lá no vídeo e nunca esqueça de curtir, compartilhar e assinar o canal.

Até a próxima!

[Review]: Professional application Lifecycle Management with Visual Studio 2013

Fala galera!

Venho hoje compartilhar com voces o que em minha opinião foi a melhor leitura técnica dos últimos anos: Professional ALM with Visual Studio 2013 o qual terminei de ler hoje de manhã.

Foram cerca de dois meses empenhado em absorver todo o conteúdo deste extenso livro que cobre todas as etapas do ciclo de vida do desenvolvimento de aplicações utilizando-se da plataforma Microsoft entre elas:

O livro esta dividido em partes que abrangem:

  • Gestão de Projetos;
  • Gestão de Requisitos;
  • Desenvolvimento;
  • Testes e Qualidade;
  • Build e Deploy;
  • Gerenciamento de Laboratórios;

Todos os recursos Ão tratados com detalhe e muitas informaçõe extras são disponiblizadas através de links que enriquecem ainda mais o conteúdo.

Todo o código fonte é disponibilizado para download acelerando muito colocar em prática o que é aprendido e são poquíssimos pré-requisitos para ter tudo funcionando.

Se voce pretende utilizar a plataforma em sua totalidade é uma leitura obrigatória.

Muitos dos próximos posts serõ compartilhamentos do que aprendi e consegui colocar em prática quase que de imediato.

E voce, quais boas leituras tem feito recenetemente? Compartilhe com a gente aqui nos comentários.

Até a próxima!

ASP.NET SignalR e CORS

Fala galera!

Dando continuidade ao tema ASP.NET SignalR o qual comentei aqui já começo a série de exemplos com a configuraçÃo que utilizei me nosso projeto para permitir o uso entre diferentes domínios, o famoso CORS.

public partial class Startup
 {
 public void ConfigureSignalR(IAppBuilder app)
 {
 IContainer container = ContainerConfig.Configure();</p>

<pre><code>        var resolver = new Autofac.Integration.SignalR.AutofacDependencyResolver(container);
        GlobalHost.DependencyResolver = resolver;
        var config = new HubConfiguration()
        {
            Resolver = resolver,
            EnableDetailedErrors = true,
            EnableJSONP        = true
        };
        var cors = new CorsOptions()
        {
            PolicyProvider = new CorsPolicyProvider()
            {
                PolicyResolver = context =&gt;
                {
                    var policy = new CorsPolicy();
                    policy.Origins.Add(@&quot;http://nossaappweb.azurewebsites.net&quot;);
                    policy.AllowAnyMethod = true;
                    policy.AllowAnyHeader= true;
                    policy.SupportsCredentials = true;
                    return Task.FromResult(policy);
                }
            }
        };
        app.Map(&quot;/signalr&quot;, map =&gt;
        {               
           map.UseCors(cors);  
            map.RunSignalR(config);
        });

    }
}

Com este método estou fazendo as seguintes configurações:

  • Habilitando o SignalR e o uso de CORS para o endpoint /signalr;
    Habilitando JXP para browsers legados;
  • Habilitando a injeção de dependencia utilizando o Autofac;

No próximo post irei mostrar como ficou nosso Hub e uma dica para escapar do Singleton que é implementado por padrão para ele.

Até a próxima!

ASP.NET SignalR

Fala galera!

Este é um post introdutório sobre ASP.NET SignalR uma tecnologia para comunicação em tempo real entre aplic’ões Web e seus clientes.

O SignalR abstrai de maneira simples a chamada remota de procedimentos (RPC) do cliente para o servidor e vice-versa permitindo, por exemplo, a atualização em tempo real do cliente quando da ocorrenci de eventos no servidor.

Para isto ele faz de forma automática a seleção do melhor transporte a partir da analise da conexÃo do cliente, podendo optar entre:

  • WebSockets: cominicação TCP/IP e alto desempenho entre o servidor Web e o cliente. Neste modo a comunicaÇão é bidirecional através do uso de uma conexão persistente entre os envolvidos;
  • Long Pooling: Uma forma otimizada de pooling ao servidor Web para consulta de dados;
  • Pooling: Comunicação normal com o servidor WEb consultando de tempos em tempos se há novas requisiÇões para o cliente;

Além disto o SignalR permite dois modos de trabalho:

  • Hub: Abstração total da comunicação através da exposição de endpoints padronizados e um rica API para facilitar as chamadas RPC;
  • Persstent Connection: Neste modo é disponibilizada uma rica API de comunicação em baixo nível utilizado principalmene quando se quer ter mais controle da transmissÃo de dados criando-se protocolos personalizados e usando-se de técnicas como criptografia e compactaçÃo;

Em 90% dos casos o uso de Hubs é recomendado e atenderá a todas as suas necessidades mas é sempre bom saber qu podemos expandir nossas soluções caso precisemos de algo com maior controle.

O ASP.NET SignalR ja se aproveita de todos os beneficios ofereidos pelo uso do midleware OWIN introduzido inicialmente com o ASP.NET WebAPI o que nos pemite hospedar nossa aplica’ão não somente no IIS mas também em qualquer aplicação/serviço que desenvlvamos e isto tamb’m permite que o mecanismo por traz do SignalR tambem seja acilmente extendido, como o uso d filas ou de caches para otimização da comunicação quando prcisamos escalar o servidor.

Em postagens futuras irei abordar com exemplos cada um destes aspectos para que voces possam se familiarizar com esta tecnologia e usufruir de seus beneficios em suas aplicações.

Até a próxima!