HOT Hover Over Technologies

Posteé un primer artículo en el el blog de Southworks. Siguiendo la costumbre de este blog, la idea es postear aquí en castellano por lo que voy a intentar traducirme. Puede considerarse cross-posting.

Primeras semanas

Van pasando mis primeras semanas en Southworks, tuve diferentes desafios. Uno de ellos fue estresar un WorkerRole service localmente y en WindowsAzure.
Un WorkerRole es un rol para desarrollos generales y puede realizar procesamiento background para un web role. Una vez deployado localmente obtenemos una URL a nuestro servicio WCF.
Trabajando con esta arquitectura necesitamos estresar los request a este servicio para verificar distintos comportamientos de Windows Azure. El principal objetivo de el stress test es descubrir la recuperabilidad de el servicio o el server testeado.

Stress test usando Pylot

Existe una multiplicidad de herramientas caras para estresar web services. Decidimos utilizar una muy buena solución open source realizada en Python llamada Pylot.

Instalando Pylot

Pylot es un script Pyhton y utiliza librerias wxPython para la interfaz gráfica, NumPy and MatPlotLib para reportes y gráficos.

Usando Pylot

Usar la GUI de Pylot es elemental. Debemos crear un xml con los casos de prueba.

   1: <case>    

   2:      <url>http://www.goldb.org/foo</url>

   3:     <verify>Copyright.*Corey Goldberg</verify>

   4:     <verify_negative>Error</verify_negative>

   5: <case>

Visual Studio 2010 Stress tests

Más allá de la solución de Pylot, en algunos casos necesitamos una pequeña aplicación para solucionar temas particulares. StressService es un servicio realizado en c#. Podemos estresar nuestro server con este simple contrato.

Utilizaremos el Load Test de Visual Studio 2010 para crear el stress test. Para hacer esto crearemos un unit test que realice la acción que queremos estresar.

   1: [ServiceContract]

   2: public interface IStresserService

   3: {

   4:         [OperationContract]

   5:         int SimpleRequest(string url);

   6:  

   7:         [OperationContract]

   8:         List<int> Stress(int workers, string url);

   9: }

Implementación del contrato.

   1: public class StresserService : IStresserService

   2: {

   3:     public int SimpleRequest(string url)

   4:     {

   5:         if (string.IsNullOrEmpty(url))

   6:             throw new ArgumentOutOfRangeException("url");

   7:         HttpWebRequest request = (HttpWebRequest)WebRequest.Create(url);

   8:         HttpWebResponse response;

   9:         try

  10:         {

  11:             response = (HttpWebResponse)request.GetResponse();

  12:         }

  13:         catch (WebException e)

  14:         {

  15:             return (int)((HttpWebResponse)e.Response).StatusCode;

  16:         }

  17:         return (int)response.StatusCode;

  18:     }

  19:  

  20:     public List<int> Stress(int workers, string url)

  21:     {

  22:         var results = new List<int>();

  23:         Parallel.For(0, workers, t =>

  24:         {

  25:             results.Add(SimpleRequest(url));

  26:  

  27:         });

  28:         Thread.Sleep(10000);

  29:         return results;

  30:     }

  31: }

   1: [TestMethod]

   2: public void ItShouldCreateNStressers()

   3: {

   4:     IStresserService service = new StresserService();

   5:     var results = service.Stress(100, @"http://localhost/");

   6:  

   7:     Assert.AreEqual(100, results.Count());

   8: }

Creamos el Load Test para estresar utilizando muchos usuarios durante un tiempo T.

Próximos pasos: escalar la solución.

Podemos escalar la solución comenzando nuevos servicios en otras máquinas y sincronizando los diferentes workers creando un manager.

Requerimientos desde diferentes dominios

La solución está estresando desde el mismo dominio. Podemos tener diferentes problemas (por ej. D.O.S.) que se pueden sobrellevar utilizando otros servicios como  Gomez