[Tutorial] TypeScript | Javascript – Parte 1

He notado que al ingresar un persona nueva a nuestro equipo y comienza a trabajar con Angular, React o Vue.js, sin haberlo tocado nunca, la inducción es bastante difícil. Me ha dado un buen resulta que antes de Angular u otras tecnologías similares, invertir tiempo en el aprendizaje de base, en este caso TypeScript, como se usa y cual es su filosofía.

Objetivo

El objetivo de esta publicación es tocar los temas: ¿Que es TypeScript?, ¿Como se usa TypeScript?, qué herramientas tenemos y ver un ejemplo de su uso. También trataremos sus beneficios y qué puntos debemos tener en cuenta para su uso.

Audiencia

Este documento está dirigido a personas que conocen muy poco o nada sobre el tema.o personas que desarrollan tareas de consultoría de desarrollo o que simplemente están interesados en leer e investigar sobre la tecnología alcanzada por esta publicación.

Desarrollo

¿Que es TypeScript?

TypeScript es uno de los lenguajes de programación más nuevos que han aparecido. Es de código abierto, desarrollado y mantenido por Microsoft. Microsoft lo denomina como SuperSet de javascript. ¿Que quiere decir esto? Básicamente busca extender las características de un lenguaje tipado a JavaScript y puede ser usado desde aplicaciones pequeñas o en aplicaciones muy grandes.

Esto no significa que los navegadores van a entender TypeScript , TypeScript lo que hace es convertir nuestro código, transpilarlo, a código javascript que el navegador va a ejecutar. Algo que la gente de TypeScript hizo fuerte hincapié es que cualquier codigo escrito en javascript debe funcionar en TypeScript. Si tenemos codigo ya escrito debe funcionar sin problemas.

Javascript está basado en las especificaciones de ECMA Script que actualmente se encuentra en la versión 6. Estas especificaciones se mueven mucho más rápido de que los desarrolladores puedan adquirir el conocimiento, o la velocidad con la cual podemos actualizar nuestras aplicaciones. Inclusive la implementación de los fabricantes en los navegadores, servidores o sistemas operativos.  Existe un GAP que podemos ver en la siguiente imágen:

A pesar de ser antiguar, el gap de implementación comparadas entre 2015 y 2016 existía, hoy existe y seguirá existiendo.

Aquí es donde TypeScript es un herramienta realmente poderosa debido a que el resultado final que es JavaScript puede transformarse en la versión de ECMA Script que deseemos. Esto aumentando la compatibilidad de nuestras aplicaciones y reduce el impacto de sus actualizaciones.

Al ser un lenguaje basado tipos y POO, si poseemos este conocimiento de cualquier otro lenguaje basado en estos principios como .Net C#, Java o PHP, TypeScript nos parece bastante familiar solamente nos quedará entender su sintaxis.

Para hacer una comparación entre TypeScript y Javascript diremos que el primero es de tipo estático y el segundo dinámico lo veremos en la siguiente tabla:

Ahora veremos cuales son las características principales de TypeScript:

  • Cualquier código JavaScript debe funcionar sin problemas en TypeScript.
  • Como en la tabla anterior, tipado estático.
  • Se pueden utilizar clases y módulos.
  • Constructores, propiedades, funciones.
  • Podemos usar interfaces.
  • Expresiones especiales como Fat arrows =>.
  • Intellisense y comprobación de sintaxis en tiempo real en la gran mayoría de las herramientas.

Por último podemos ver en el último gráfico la adopción de TypeScript a nivel desarrolladores y empresas que nos demuestra lo importante de su utilización.

¿Que necesitamos para empezar?

Lo primero que necesitamos tener instalado es Node.JS, puede ser decargado desde aqui https://nodejs.org/en/. Podemos usar cualquier procesador moderno, yo usare Visual Studio Code que puede ser descargado des aqui https://code.visualstudio.com/.

Una vez instalada estas 2 herramientas, desde el visual studio y su consola, debemos instalar TypeScript. Esto lo hacemos desde un paquete npm con el siguiente comando.

npm install -g typescript

Una vez instalada podemos validar la versión y la ayuda con los siguientes comandos.

tsc --version
tsc --help

Conclusión

En esta primera parte vimos que es y algunos de sus beneficios. También vimos la importancia de la adopción de este lenguaje de programación como un buen lenguaje al mejor estilo C# o Java. En próximos post de este tutorial iremos entrando más en detalle sobre el tema.

 

[HowTo] VS Code | Crear una WebApi con Asp.Net Core en Linux

Como comente en post anterior Microsoft está entrando fuertemente al mundo OpenSource. Por esta razon hoy podemos disfrutar de Asp.Net Core en la plataforma Linux, en mi caso KUbuntu, junto a algunas herramientas muy poderosas com VS Code.

Objetivo

El objetivo de esta publicación tiene un tutorial de como debemos preparar nuestro linux para hacer uso de Asp.Net junto a una aplicacion del tipo WebApi que usaremos en post futuros.

Audiencia

Este documento está dirigido a personas que conocen muy poco o nada sobre el tema o personas que desarrollan tareas de consultoría de desarrollo o que simplemente están interesados en leer e investigar sobre la tecnología alcanzada por esta publicación.

Desarrollo

Para empezar lo que haremos es instalar Net Core es nuestro linux. Lo haré sobre mi distribución preferida que es KUbuntu. Primero necesitamos instalar las llaves de producto y actualizar el listado de paquetes en nuestra distribución linux. Abriremos una consola y ejecutamos los siguiente comandos estos 4 comandos en este orden:

curl https://packages.microsoft.com/keys/microsoft.asc | gpg --dearmor > microsoft.gpg
sudo mv microsoft.gpg /etc/apt/trusted.gpg.d/microsoft.gpg
sudo sh -c 'echo "deb [arch=amd64] https://packages.microsoft.com/repos/microsoft-ubuntu-zesty-prod zesty main" > /etc/apt/sources.list.d/dotnetdev.list'
sudo apt-get update

 

Ya ejecutado todo estamos listos para instalar:

sudo apt-get install dotnet-sdk-2.0.0

Una vez que instalamos todo y configurado estamos listso. Vamos a crear nuestra primera aplicación en linux. Crearemos una carpeta y ejecutaremos el comando dotnet que nos ayuda a crear la plantilla:

mkdir MvcMyApp
cd MvcMyApp
dotnet new mvc

Ahora podemos abrir desde VS Code que instalamos en un post anterior. Con Solo escribir “code .” se abrirar el VS Code en la carpeta donde estamos parados. Ahora necesitaremos instalar VS Code C# extensión. Lo haremos desde el icono de VS Code, lo buscaremos y lo instalaremos.

Luego de instalarlo recargamos la ventana y comenzará a instalarse algunos componentes necesarios que nos permitirá usar la depuración en VS Code.

Ahora solo nos queda presionar F5 y guala!

 

Una WebApi para ejemplos

Lo que haremos ahora es crear una WebApi Rest que la usaremo en futuros ejemplos en un el tutorial de TypeScript. Vamos a necesitar tener instalado:

  • DB Browser for Sqlite (podemos instalarlos desde el gestor de software que viene con KUbuntu.
  • Postman (podemos descargarlo desde aqui https://www.getpostman.com/)

Empezaremos con crear una carpeta DemoApi y dentro ejecutaremos los comandos de creación y lo abriremos, solo hay que seguir los siguientes comando en orden:

mkdir DemoService
cd DemoService
dotnet new webapi
code .

Nuevamente nos aparecerán los warning a los que debemos darle yes.

Crearemos la base de datos con Sql DB Browser dentro de una carpeta data. La base de Datos la llamaremos DBDemoServices y corremos el script que dejare en el github dentro de la carpeta data se llama base.txt. Este script creará 2 tablas e insertara datos para hacer el demo.

En nuestro servicio usaremos Entity Framework Core como herramienta de acceso a datos. No ayudará con nuestra base de datos Sqlite. Agregaremos las siguientes lineas en nuestro archivo DemoService.csproj:

<PackageReference Include="Microsoft.EntityFrameworkCore.Sqlite" Version="2.0.0" />
<PackageReference Include="Microsoft.EntityFrameworkCore.Tools" Version="2.0.0"/>

Desde la consola ejecutaremos dotnet restore para actualizar nuestros paquetes:

Comenzaremos creando nuestros modelos y nuestro DBContext. Crearemos 3 archivos, Customer.cs, CustomerType y DemoServiceContext.cs. Todos dentro de una carpeta Models con la siguiente clases dentro:

Customer.cs

using System;
using System.Collections.Generic;

namespace DemoService.Models
{
public partial class Customers
{
public int CustomerId { get; set; }
public string FirstName { get; set; }
public string MiddleName { get; set; }
public string SurName { get; set; }
public string EmailAddress { get; set; }
public int? CustomerTypeId { get; set; }
public string Notes { get; set; }

public virtual CustomersTypes CustomerType { get; set; }
}
}

CustomerType.cs

using System;
using System.Collections.Generic;

namespace DemoService.Models
{
public partial class CustomersTypes
{

public CustomersTypes()
{
Customers = new HashSet<Customers>();
}

public int CustomerTypeId { get; set; }
public string Description { get; set; }

public virtual ICollection<Customers> Customers { get; set; }

}

}

DemoServiceContext.Typecs

using Microsoft.EntityFrameworkCore;
using DemoService.Models;

namespace DemoService.Models
{
public class DemoDBContext : DbContext
{
public DemoDBContext(DbContextOptions<DemoDBContext> options)
: base(options)
{
}
public virtual DbSet<Customers> Customers { get; set; }
public virtual DbSet<CustomersTypes> CustomersTypes{ get; set; }

protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
{
optionsBuilder.UseSqlite("Filename=BDemoSevice.db;");
}

protected override void OnModelCreating(ModelBuilder modelBuilder)
{
modelBuilder.Entity<Customers>(entity =>
{
entity.HasKey(e => e.CustomerId)
.HasName("PK_Customers");

entity.Property(e => e.EmailAddress).HasColumnType("varchar(150)");

entity.Property(e => e.FirstName).HasColumnType("varchar(50)");

entity.Property(e => e.MiddleName).HasColumnType("varchar(50)");

entity.Property(e => e.Notes).HasColumnType("varchar(5000)");

entity.Property(e => e.SurName).HasColumnType("varchar(50)");

entity.HasOne(d => d.CustomerType)
.WithMany(p => p.Customers)
.HasForeignKey(d => d.CustomerTypeId)
.HasConstraintName("FK_Customers_CustomersTypes");
});

modelBuilder.Entity<CustomersTypes>(entity =>
{
entity.HasKey(e => e.CustomerTypeId)
.HasName("PK_CustomersTypes");

entity.Property(e => e.CustomerTypeId).ValueGeneratedNever();

entity.Property(e => e.Description).HasColumnType("varchar(50)");
});
}

}
}

Debemos agregar en nuestro archivo Startup.cs la inyección de nuestra base de datos.

public void ConfigureServices(IServiceCollection services){
services.AddMvc();
services.AddDbContext<DemoDBContext>();
}

Ahora que tenemos todo configurado crearemos dentro de la carpeta Controllers un archivo llamado customers.cs donde tendremos nuestra api:

CustomersControllers.cs

using System.Collections.Generic;
using Microsoft.AspNetCore.Mvc;
using DemoService.Models;
using System.Linq;

namespace DemoService.Controllers
{
[Route("api/[controller]")]
public class CustomersController : Controller
{
private readonly DemoDBContext _context;

public CustomersController(DemoDBContext context)
{
_context = context;
}

[HttpGet]
public IEnumerable<Customers> GetAll()
{
return _context.Customers.ToList();
}

}
}

Para comprobar que funciona correctamente ejecutaremos la aplicación presionando F5 y lo invocamos con el Postman:

Bien está funcionando correctamente. Agregamos los métodos de crear, editar y eliminar y también agregaremos el CustomersTypesController.cs y un modelo que será ModeCustomerPage.cs que será para devolver páginas de Customers.

Models/ViewModelPage.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using DemoService.Models;

namespace DemoService.Models
{
public class ViewModelPage
{
public int CountPages { get; set; }
public int CountCustomers { get; set; }
public int ActualPage { get; set; }
public IList<Customers> customers { get; set; }
}
}

CustomersControllers.cs

using System.Collections.Generic;
using Microsoft.AspNetCore.Mvc;
using DemoService.Models;
using System.Linq;
using System.Threading.Tasks;
using Microsoft.EntityFrameworkCore;

namespace DemoService.Controllers
{
[Route("api/[controller]")]
public class CustomersController : Controller
{
private readonly DemoDBContext _context;

public CustomersController(DemoDBContext context)
{
_context = context;
}

[HttpGet]
public IEnumerable<Customers> GetCustomers()
{
return _context.Customers;
}

[HttpGet("{id}")]
public async Task<IActionResult> GetCustomers([FromRoute] int id)
{
if (!ModelState.IsValid)
{
return BadRequest(ModelState);
}

var customers = await _context.Customers.SingleOrDefaultAsync(m => m.CustomerId == id);

if (customers == null)
{
return NotFound();
}

return Ok(customers);
}

[HttpGet]
[Route("{numberPage}/{perPage}")]
public ViewModelPage GetCustomerPaging(int numberPage, int perPage)
{

int _customersCount = GetCustomers().Count();
int _countPages = (_customersCount / perPage) + ( _customersCount % perPage == 0 ? 0 : 1);

var page = new ViewModelPage();
page.ActualPage = numberPage;
page.CountCustomers = GetCustomers().Count();
page.CountPages = _countPages;
page.customers = GetCustomers().Skip(numberPage * perPage).Take(perPage).ToList();

return page;
}

[HttpPut("{id}")]
public async Task<IActionResult> PutCustomers([FromRoute] int id, [FromBody] Customers customers)
{
if (!ModelState.IsValid)
{
return BadRequest(ModelState);
}

if (id != customers.CustomerId)
{
return BadRequest();
}

_context.Entry(customers).State = EntityState.Modified;

try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!CustomersExists(id))
{
return NotFound();
}
else
{
throw;
}
}

return NoContent();
}

[HttpPost]
public  IActionResult PostCustomers([FromBody] Customers customers)
{
if (!ModelState.IsValid)
{
return BadRequest(ModelState);
}

_context.Customers.Add(customers);
_context.SaveChanges();

return CreatedAtAction("GetCustomers", new { id = customers.CustomerId }, customers);
}

[HttpDelete("{id}")]
public async Task<IActionResult> DeleteCustomers([FromRoute] int id)
{
if (!ModelState.IsValid)
{
return BadRequest(ModelState);
}

var customers = await _context.Customers.SingleOrDefaultAsync(m => m.CustomerId == id);
if (customers == null)
{
return NotFound();
}

_context.Customers.Remove(customers);
await _context.SaveChangesAsync();

return Ok(customers);
}

private bool CustomersExists(int id)
{
return _context.Customers.Any(e => e.CustomerId == id);
}

}
}

CustomersTypesControllers.cs


using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using Microsoft.EntityFrameworkCore;
using DemoService.Models;

namespace DemoService.Controllers
{

[Route("api/[controller]")]
public class CustomersTypesController : Controller
{
private readonly DemoDBContext _context;

public CustomersTypesController(DemoDBContext context)
{
_context = context;
}

[HttpGet]
public IEnumerable<CustomersTypes> GetCustomersTypes()
{
return _context.CustomersTypes;
}

[HttpGet("{id}")]
public async Task<IActionResult> GetCustomersTypes([FromRoute] int id)
{
if (!ModelState.IsValid)
{
return BadRequest(ModelState);
}

var customersTypes = await _context.CustomersTypes.SingleOrDefaultAsync(m => m.CustomerTypeId == id);

if (customersTypes == null)
{
return NotFound();
}

return Ok(customersTypes);
}

[HttpPut("{id}")]
public async Task<IActionResult> PutCustomersTypes([FromRoute] int id, [FromBody] CustomersTypes customersTypes)
{
if (!ModelState.IsValid)
{
return BadRequest(ModelState);
}

if (id != customersTypes.CustomerTypeId)
{
return BadRequest();
}

_context.Entry(customersTypes).State = EntityState.Modified;

try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!CustomersTypesExists(id))
{
return NotFound();
}
else
{
throw;
}
}

return NoContent();
}

[HttpPost]
public async Task<IActionResult> PostCustomersTypes([FromBody] CustomersTypes customersTypes)
{
if (!ModelState.IsValid)
{
return BadRequest(ModelState);
}

_context.CustomersTypes.Add(customersTypes);
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateException)
{
if (CustomersTypesExists(customersTypes.CustomerTypeId))
{
return new StatusCodeResult(StatusCodes.Status409Conflict);
}
else
{
throw;
}
}

return CreatedAtAction("GetCustomersTypes", new { id = customersTypes.CustomerTypeId }, customersTypes);
}

[HttpDelete("{id}")]
public async Task<IActionResult> DeleteCustomersTypes([FromRoute] int id)
{
if (!ModelState.IsValid)
{
return BadRequest(ModelState);
}

var customersTypes = await _context.CustomersTypes.SingleOrDefaultAsync(m => m.CustomerTypeId == id);
if (customersTypes == null)
{
return NotFound();
}

_context.CustomersTypes.Remove(customersTypes);
await _context.SaveChangesAsync();

return Ok(customersTypes);
}

private bool CustomersTypesExists(int id)
{
return _context.CustomersTypes.Any(e => e.CustomerTypeId == id);
}
}
}

Listo nuestra aplicación está completa ahora probaremos un post con el postman.

Conclusión

Hemos instalado y configurado .Net Core y Asp.Net Core en nuestro linux. También hicimos una pequeña base de datos y nos conectamos a ella por medio de WebApi para tener servicio Rest. Estos servicios rest los usaremos en otros post para algunos ejemplo. Pueden descargar el código complete de GitHub desde esta url https://github.com/withoutdebugger/DemoService

 

 

[HowTo] Visual Studio Code | En Linux

Microsoft en estos últimos tiempos está apostando al OpenSource. Una de las cosas que ha impulsado es el uso de sus herramientas en este caso el editor liviano pero extremadamente potente VS Code.

Objetivo

El objetivo de esta publicación tiene un tutorial de como podemos instalar Visual Studio Code en linux.

Audiencia

Este documento está dirigido a personas que conocen muy poco o nada sobre el tema o personas que desarrollan tareas de consultoría de desarrollo o que simplemente están interesados en leer e investigar sobre la tecnología alcanzada por esta publicación.

Desarrollo

Visual Studio Code es un editor de código ligero y muy potente el cual podemos ejecutarlo en cualquier plataforma como Windows, MacOs o Linux. Viene con soporte Intellisense y para varios lenguajes de forma nativa. También podemos utilizar controladores de código fuente como Git o TFS. Por último, la característica que más me gusta, es totalmente extensible. Gracias a esto última característica tenemos una gran cantidad de plugin que podemos instalar para cualquier lenguaje que utilicemos.

Yo he elegido, solo por gusto personal, la distribución Kubuntu. No por nada en particular solo me gusta mas KDE. Lo primero que debemos hacer es descargar el paquete desde la página con la extensión .deb. Pueden hacerlo desde este link  https://code.visualstudio.com/

Una vez que lo tenemos descargado debemos abrir una consola, ir a la carpeta donde descargamos los archivos. En KUbuntu tenemos la posibilidad de instalarlo por medio de QApt:

Y listo! tenemos nuestro VS Code instalado

Para los más audaces podemos instalarlo por medio de consola completamente. Comencemos:

curl https://packages.microsoft.com/keys/microsoft.asc | gpg --dearmor > microsoft.gpg
sudo mv microsoft.gpg /etc/apt/trusted.gpg.d/microsoft.gpg
sudo sh -c 'echo "deb [arch=amd64] https://packages.microsoft.com/repos/vscode stable main" > /etc/apt/sources.list.d/vscode.list'

“Nota: puede ser que no tengamos curl instalado por esta razón primero deberemos instalarlo con el siguiente comando apt-get install curl“

Si no hemos tenido ningún problema, el siguiente paso es actualizar nuestro repositorio de paquetes para esto usaremos el siguiente comando

sudo apt-get update

Por último, lo que nos queda es instalar el VS Code desde el repositorio.

sudo apt-get install code

Ya lo tenemos instalado y listo para comenzar disfrutar de esta gran herramienta.

Conclusión

Hemos instalado VS Code en nuestro linux de una forma muy sencilla. En próximos post veremos como hacer una aplicación .Net.

[Article] Azure | ¿Que es Docker?

Continuando el tema de micro-servicios y cómo podemos implementarlo vamos tocar el tema de Docker. Seguramente hemos escuchado de Docker en alguna conferencia o de algún compañero de trabajo pero no nunca llegamos a comprender del todo que es y en que podría ayudarnos esta tecnología.

Objetivo

El objetivo de esta publicación es tocar las posibles utilizaciones y el alcance de dockers. Ver cómo podemos utilizarlo en una arquitectura de microservicios. Sus beneficios como también que puntos debemos tener en cuenta para poder llevarla adelante.  El objetivo principal es entender de una forma clara y sencilla que es Docker.

Audiencia

Este documento está dirigido a personas que conocen muy poco o nada sobre el tema. No nos meteremos en aspectos técnicos, tampoco como ejecutarlo o como se debe usar.

Desarrollo

Básicamente Docker nos da la posibilidad de crear contenedores muy livianos y fácilmente portables para nuestras aplicaciones. Independiente del sistema operativo que utilicemos podremos ejecutar un contenedor Docker en cualquier máquina. Esta característica nos facilita mucho el despliegue de nuestras aplicaciones.

Seguramente se preguntaran, ¿Pero… que es un contenedor? el concepto viene originalmente de la plataforma linux, no es realmente un concepto nuevo, pero hoy muy de moda. La idea viene de los contenedores que llevan los barcos para transportar productos que pueden ser o no del mismo tipo.

Docker nos permite meter todo lo que necesitamos para ejecutar nuestra aplicación en un contenedor e inclusive la propia aplicación. Supongamos que queremos implementar un micro-servicio que está desarrollado con .Net Framework. Dentro del contenedor podremos poner todos los componentes necesarios para la ejecución del servicio, el servidor web, componentes de terceros sin preocuparnos de las versiones de software que tiene instalada, si las tiene instalada, si están lo componentes necesarios en nuestra máquina donde se alojara el contenedor.

¿Y en qué nos beneficia?

Docker puede ser utilizado en cualquier entorno de IT. Puede dar soporte a equipos de desarrollo o equipos de infraestructura ayudando a que las aplicaciones y ejecuten fácilmente y aumentando nuestra capacidad de despliegue de estas.

Desde mi punto de vista, como desarrollador, me permite olvidarme si el la aplicación que estoy construyendo funcionara correctamente en la máquina que va a ser ejecutada permitiendo enfocarme completamente en dicha construcción.

Vamos a dar un ejemplo bastante usado en internet:

  • Matías tiene en su computadora instalado la versión de .Net Framework 4.5 y se encuentra programando una micro-servicio con funcionalidades específicas de esta versión.
  • Florencia en su máquina tiene instalado las versión de .Net Framework 3.5 debido a que está trabajando en un proyecto distinto. Matías quiere que Florencia pruebe su micro-servicio en su máquina pero si ella no instala .Net Framework 4.5 la aplicación no funcionará.

Si estamos usando Docker no tendremos este inconveniente.  Matias creará un contenedor con todo lo necesario para que el micro-servicio funcione y se lo pasará a Florencia. Como Florencia tiene instalado en su máquina Docker podrá ejecutar la aplicación sin necesidad de instalar nada.

Algo para lo cual usamos mucho Docker es para hacer testing. Es muy fácil crear o eliminar un contenedor. Al ser muy livianos podemos usar varios contenedores en la misma máquina y el contenedor funcionara en cualquier maquina que tenga instalado docker sea Windows, Linux, MacOs o Inclusive en la Nube como Azure. También al contenedor es ser más liviano que una máquina virtual puede reducir mucho el hardware que utilizaremos

Docker Vs Máquina Virtual

Podemos tener varios contenedores en la misma máquina, pero… ¿en qué se diferencia de una máquina virtual si también podemos tener varias? Es muy similar en algunas cosas pero la gran diferencia es que en una máquina virtual necesitamos instalar un sistema operativo y en un contenedor no.

Algunas características específicas de los sistemas operativos pueden causar problemas cuando queremos portar nuestras aplicaciones en diferentes entornos. Un contenedor de Docker toma los aspectos básicos de funcionamiento de un sistema operativo donde se encuentra ejecutándose este.

Cosas que tenemos en Docker

Tenemos varios elementos que tenemos disponibles en docker. Cada elemento nos brinda un serie de beneficios dependiendo de cómo los usemos. Los más fuertes son Imágenes y Contenedores.

Imágenes

Las imágenes son muy parecido a un snapshot de una máquina virtual pero no olvidemos que es mucho más liviano. Los usaremos como una plantilla para nuestros contenedores. Estas imágenes las utilizaremos para crear nuestros contenedores.

Hay mucho repositorios públicos donde podemos obtener imágenes para crear contenedores siendo un buen punto de partida para crear los nuestros e ir agregando las cosas que necesitemos. Podemos empezar buscado aqui https://hub.docker.com

Contenedores

Podemos decir que son instancias de nuestras imágenes y son finalmente lo que ejecutan nuestras aplicaciones y de una imagen podemos ejecutar varios contenedores. Supongamos que necesitamos escalar nuestra aplicación porque aumentó su consumo. A partir de la imagen podríamos ir creando contenedores para atender las solicitudes.

Con Docker podemos ir administrado las versiones como si fuera una herramienta de control de versiones. Hacemos unos cambios, damos commit y se nos guardarán los cambios. Esto nos permitirá volver a versiones anterior por algún inconveniente que tengamos.

Conclusión

Docker puede darnos una gran ayuda en una arquitectura de micro-servicios. Nos facilitará no solo el desarrollo y el testing si no que nos garantizara una gran capacidad de despliegue con tiempo muy cortos. También, puede reducirse mucho los costos de infraestructura ya que son mucho más livianos que una máquina virtual. En el futuro vamos a ver una implementación de docker en Azure.