Como crear un WebJob en Azure

Azure es una plataforma de servicios en la nube, que proporciona una serie de soluciones que nos permiten desarrollar productos de una forma más optimizada y dinámica.
Uno de estos servicios son los WebJobs.

¿Pero qué son los WebJobs? Este servicio es una automatización de procesos.¿Qué quiere decir esto?. Tenemos una aplicación en la nube que se ejecuta cuando nosotros la programemos. Básicamente lo podríamos definir como una especie de script que hace que se ejecute alguna aplicación que tenemos desplegada en la plataforma de azure.

En este post vas a aprender a como crear un webjob en Azure, como asociarlo a una aplicación y ver la ejecución de esta. Nuestro objetivo es recoger información de una api y guardarla en nuestra base de datos, para luego consultar los datos actualizados.

Requisitos previos

Para la realización de esta práctica vamos a utilizar/necesitar lo siguiente:
-Una cuenta y subscripción en Azure.
-Visual Studio 2019. Este ID nos permitirá crear la aplicación que será ejecutada cuando programemos el webjob.
-Navegador para poder ejecutar la aplicación.
-Base de datos en local o en la nube para guardar los registros.
-Microsoft SQL Server Management.(Gestor de la Base de datos).

Desarrollo

Lo primero que vamos a hacer es crear nuestra base de datos y crear la tabla donde vamos a almacenar nuestros registros. En mi caso voy a utilizar una api propia que tiene pistas de padel. Tú puedes utilizar la api que quieras, siempre que tenga métodos get con los que obtener registros.
Para esto voy a utilizar Sql Server.Te dejo un link de como instalar SqlServer y el Management:

https://docs.microsoft.com/es-es/sql/ssms/download-sql-server-management-studio-ssms?view=sql-server-ver15

Una vez tengamos la base de datos instalada, creamos un schema y una tabla.

Ahora vamos a crear una aplicación en la cual vamos a extraer una serie de datos y los vamos a almacenar en una base de datos. Utilizaremos el visual studio. Crearemos un projecto de tipo console.

Añadiremos al proyecto los siguientes nugets:
-Microsoft.EntityFrameworkCore.
-Microsoft.EntityFrameworkCore.SqlServer.
-Microsoft.Extensions.DependencyInjection.

Creamos sobre la carpeta Models, nuestro modelo con el que vamos a guardar en nuestra bbdd los datos de la api.

[Table("Pistas")]
   public class Pista
    {
        [Key]
        [Column("IdPista")]
        public int IdPista { get; set; }

        [Column("NombrePista")]
        public string NombrePista { get; set; }

        [Column("Descripcion")]
        public string Descripcion { get; set; }

    }

Añadimos la carpeta data y creamos el context.

public class PadelContext:DbContext
    {
        public PadelContext(DbContextOptions<PadelContext> options) : base(options) { }
        public DbSet<Pista> Pistas { get; set; }
    }

Crearmos la carpeta Repositories y dentro creamos la clase RepositoryPadel

public void InsertarPistas()
        {
                string url = @"https://apiproyectoazuredsc.azurewebsites.net/api/Campos/GetTodosCampos";
                HttpWebRequest request = (HttpWebRequest)WebRequest.Create(url);
                request.Accept = @"application/json";
                request.Referer = @"https://apiproyectoazuredsc.azurewebsites.net/";
                request.Headers.Add("Accept-Language", "es-ES");
                request.UserAgent = @"Mozilla/5.0 (compatible; MSIE 10.0; Windows NT 6.2; Trident/6.0)";
                
                HttpWebResponse response = (HttpWebResponse)
                request.GetResponse();
                string jsonpistas;
                using (StreamReader reader = new StreamReader(response.GetResponseStream()))
                {
                    jsonpistas = reader.ReadToEnd();
                }
                XDocument document = XDocument.Parse(jsonpistas);
                var consulta = from datos in document.Descendants("item")
                               select datos;
                List<Pista> pistas = new List<Pista>();
                int idpista = this.GetMaxIdPista();
                foreach (var elem in consulta)
                {
                    Pista pista = new Pista
                    {
                        IdPista = idpista
                    ,
                        NombrePista = elem.Element("nombreCampo").Value
                    ,
                        Descripcion = elem.Element("description").Value
                   
                    };
                    pistas.Add(pista);
                    idpista += 1;
                }
                //INSERTAMOS LOS CHOLLOS EN LA BBDD 
                foreach (Pista pista in pistas)
                {
                    this.context.Pistas.Add(pista);
                }
                this.context.SaveChanges();
            }

            private int GetMaxIdPista()
            {
                if (this.context.Pistas.Count() == 0)
                {
                    return 1;
                }
                else
                {
                    return this.context.Pistas.Max(z => z.IdPista) + 1;
                }
            }

        
    }

Lo que estamos haciendo aqui es recoger los datos de nuesta api e introducirlos en nuestra base de datos.

Ahora vamos a Resolver las dependencias en Program.cs

 static void Main(string[] args)
        {
            string cadena = "Data Source=localhost;Initial Catalog=Padel;User ID=sa;Password=MCSD2021";
            var provider = new ServiceCollection()
             .AddTransient<RepositoryPadel>()
            .AddDbContext<PadelContext>
            (options => options.UseSqlServer(cadena))
            .BuildServiceProvider();
            RepositoryPadel repo =
            provider.GetService<RepositoryPadel>();

            repo.InsertarPistas();

        }

Una vez realizado esta app, vamos a hacer la visual, es decir, el MVC. Con esta aplicación vermos los cambios realizados en nuestra base de datos.
Creamos un nuevo proyecto MVC en Visual Studio.

Añadimos los siguientes nugets a nuestro proyecto

Creamos el modelo como antes de pista.

[Table("Pistas")]
    public class Pista
    {
        [Key]
        [Column("IdPista")]
        public int IdPista { get; set; }

        [Column("NombrePista")]
        public string NombrePista { get; set; }

        [Column("Descripcion")]
        public string Descripcion { get; set; }

    }

Creeamos tambien el context.

   public class PadelContext : DbContext
    {
        public PadelContext(DbContextOptions<PadelContext> options) : base(options) { }
        public DbSet<Pista> Pistas { get; set; }
    }

Creamos el Repository.

public class RepositoryPadel
    {
        private PadelContext context;
         public RepositoryPadel(PadelContext context)
        {
            this.context = context;
        }
        public List<Pista> GetPistas()
        {
           return this.context.Pistas.ToList();
        }
}

Añadimos sobre la carpeta Controllers una clase PadelController.cs.

public class PadelController : Controller
    {
        private RepositoryPadel repo;
        public PadelController(RepositoryPadel repo)
        {
            this.repo = repo;
        }
        public IActionResult Index()
        {

            List<Pista> pistas =
                this.repo.GetPistas();
            return View(pistas);
        }
    }

Y creamos nuestra vista, donde vermos los datos de nuestra base de datos.

@model IEnumerable<MvcPostAzure.Models.Pista>

@{
    ViewData["Title"] = "Index";
}

<h1>Index</h1>

<p>
    <a asp-action="Create">Create New</a>
</p>
<table class="table table-info table-bordered">
    <thead>
        <tr>
            <th>
                @Html.DisplayNameFor(model => model.IdPista)
            </th>
            <th>
                @Html.DisplayNameFor(model => model.NombrePista)
            </th>
            <th>
                @Html.DisplayNameFor(model => model.Descripcion)
            </th>
            <th></th>
        </tr>
    </thead>
    <tbody>
@foreach (var item in Model) {
        <tr>
            <td>
                @Html.DisplayFor(modelItem => item.IdPista)
            </td>
            <td>
                @Html.DisplayFor(modelItem => item.NombrePista)
            </td>
            <td>
                @Html.DisplayFor(modelItem => item.Descripcion)
            </td>
        </tr>
}
    </tbody>
</table>

Añadimos nuestra cadena de conexión en appsettings.json.

Resolvemos las dependencias en Startup, en el método ConfigureServices.

public void ConfigureServices(IServiceCollection services)
        {
            string cadena = this.Configuration.GetConnectionString("bbdd");
            services.AddTransient<RepositoryPadel>();
            services.AddDbContext<PadelContext>
                (options => options.UseSqlServer(cadena));
            services.AddControllersWithViews();
        }

Añadimos en Layout un enlace a nuestra vista.

<li class="nav-item">
 <a class="nav-link text-dark" asp-area="" asp-controller="Padel" asp-     
    action="Index">
    Padel
</a>
</li>

Comprobamos que funciona nuestra aplicacion.
Como veremos nuestra tabla está vacia porque todavia no hemos ejecutado nuestro webjob con la app anterior que realizaba la carga de datos desde la api.

Una vez que vemos que nuestra app funciona(aunque no muestre datos, puesto que la base de datos está vacia) lo que vamos a hacer es publicarla en Azure.
Abrimos el portal de Azure y creamos un grupo de recursos.

Vamos a publicar el proyecto desde Visual Studio.
Le damos a publish.

Lo siguiente que harememos será crear el WebJob para que ejecute nuestra console app cada cierto tiempo y así va actualizando los datos nuevos en la bbdd.
Para esto vamos a necesitar crear un zip donde tengamos el ejecutable de nuestra console app, es decir:
-RutaHastaNuestroproyecto\ConsolePostAzure\ConsolePostAzure\ConsolePostAzure\bin
Desde esta ruta creamos el Zip.

Ahora nos vamos a la plataforma de Azure y hacemos lo siguiente. Buscamos nuestro proyecto MVC. Buscamos WebJobs y creamos uno.

Lo que hemos hecho aqui es decirle al web job que ejecute el fichero comprimido cada 15 minutos que contiene un rar con el ejecutable del programa que saca los datos de la api y los introduce a la base de datos.

¡Ahora te toca a ti!

Conclusión

Vamos a hacer una recapitulación de todo lo que hemos hecho para que te quede claro el proceso.
Lo primero es crear una base de datos donde guardar los registros.
Después creamos una app que se encargará de consultar a una api y guardar los registros nuevos en nuestra bbdd.
A continuación creamos nuestra aplicación visual que nos permitirá ver los datos que tiene nuestra base de datos, y esta la publicamos en Azure.
Por último, creamos el webjob para que ejecute cada X tiempo nuesta aplicación y actualice los registros.

Espero que este post te haya servido de ayuda para poder comprender como es el proceso que sigue un WebJob. Dejo el enlace de Github abajo, donde podrás ver los dos proyectos y por si tienes alguna duda puedes contactar conmigo a través de mi Linkedin. Gracias por tu atención.