Npm

Npm es el gestor de paquetes de Node.js; el equivalente de Nuget para Visual Studio. Los paquetes que instala son ficheros de Javascript; por lo que nos aporta la capacidad de añadir dependencias de Javascript en nuestros proyectos Web. Por defecto se instala con Visual Studio 2017; aunque podemos instalarlo manualmente al instalar Node.js.

Se describen los pasos para añadir a un proyecto Web existente:

  • 1.- Abrir el interprete de comandos (Command Prompt)
  • 2.- Ubicarse en el directorio del proyecto
  • 3.- Ejecutar npm init -y. Esto genera el fichero de depedencias package.json (El equivalente al packages.config de Nuget).
  • 4.- Incorporar el fichero de dependencias en nuestro proyecto Web.

Para descargar los paquetes de Javascript:

  • 1.- Abrir el interprete de comandos (Command Prompt)
  • 2.- Ubicarse en el directorio del proyecto
  • 3.- Ejecutar npm install paquete –save. El parametro –save añade la dependencia en el fichero de depedencias package.json.
  • 4.- En el directorio node_modules ha descargado el paquete y sus paquetes dependientes.

Comandos Utiles

  • npm install: Descarga todos los paquetes definidos en el package.json.
  • npm run task: En el package.json podemos definir una sección scripts con comandos a ejecutar. Por ejemplo npm run build:
      {
        "dependencies": {
             "cldr-data": "^31.0.2",
             "globalize": "^1.3.0",
             "webpack": "^3.4.1"
        },
        "scripts": {
             "test": "echo \"Error: no test specified\" && exit 1",
             "build": "webpack -p --color"
        }
      }
    
  • npm ls: Muestra las versiones de los paquetes actualmente decargados.
  • npm update: Descarga las ultimas versiones de los paquetes disponibles.

Integración con Build in Visual Studio Team Services

Normalmente npm se utiliza con otros frameworks de ejecución de Tareas como Gulp, Bower, WebPack… Vamos a explicar el método más simple que disponemos npm para incorporar esta plataforma en los CI builds en Visual Studio Team Services sin usar estos frameworks.

  • 1.- Añadir tarea npm install para descargar los paquetes en el entorno build.

  • 2.- Añadir una tarea de copia para copiar la parte de los paquetes que nos interese en un directorio.
  • 3.- Subir el directorio a producción con una tarea de Azure App Service Deploy. Al deployar como Web Deploy desmarcamos el eliminar los ficheros en el destino. 😉
Publicado en web | Deja un comentario

Azure Key Vault

Que es Azure Key Vault

Es un servicio de Azure donde podemos almacenar información sensible como claves, passwords, cadenas de conexión, certificados…

Existen dos tipos de claves:

  • Keys: Claves criptográficas con la clave publica y privada (JSON Web Key). Este tipo de claves nos permiten firmar, verificar, cifrar o descifrar datos.
  • Secrets: Datos sensibles como contraseñas o certificados.

Pasos para Usar en una Web App

Azure Key Vault nos permite almacenar la información sensible que normalmente existe en nuestros web.config de un modo más seguro.

  • 1.- Crear una aplicación.
  • 2.- Dar derechos a la aplicación creada para acceder al servicio de Azure.
  • 3.- Instalar el paquete de NuGet Microsoft.Azure.KeyVault en nuestra aplicación.
  • 4.- Añadir la siguiente clase en la aplicación.
        public class SecretService
        {
            public static async Task<string> GetToken(string authority, string resource, string scope)
            {
                var authContext = new AuthenticationContext(authority);
                ClientCredential clientCred = new ClientCredential(WebConfigurationManager.AppSettings["ApplicationId"],
                            WebConfigurationManager.AppSettings["ApplicationSecret"]);
                AuthenticationResult result = await authContext.AcquireTokenAsync(resource, clientCred);
    
                if (result == null)
                    throw new InvalidOperationException("Failed to obtain the JWT token");
    
                return result.AccessToken;
            }
            public string GetSecret(String secretName)
            {
                var kv = new KeyVaultClient(new KeyVaultClient.AuthenticationCallback(GetToken));
                var secretUri = WebConfigurationManager.AppSettings["SecretUri"] + secretName;
                var sec = kv.GetSecretAsync(secretUri).Result;
                return sec.Value;
            }
        }
    
  • 5.- Configurar en el Application Settings del Web App, las siguientes variables

    También se podrían añadir en web.config aunque es menos recomendable, ya que ofrece menor seguridad 😉

Publicado en Azure, Seguridad, web | Deja un comentario

Glosario de Docker

Docker nos proporciona un entorno de trabajo donde podemos ejecutar nuestras aplicaciones o realizar trabajos. Es decir, un sistema operativo más solamente los paquetes o servicios dependientes que requiera nuestro entorno de trabajo. También podemos incluso usarlo como un entorno de trabajo interactivo para evitar instalar nada en nuestro ordenador.

Componentes de Docker

Container Image

Es la maquina base sobre la que se ejecuta nuestra aplicación. Disponemos para NET principalmente tres tipos y para entornos de desarrollo (build) o producción (runtime):

  • Windows Nano Server para NET Core.
  • Linux (Debian o Alpine) para NET Core.
  • Estas maquinas se obtienen repositorios (Docker Hub, Azure Continer Registry…) donde mediante un tag obtenemos una Container Image en concreto.

    Container

    Es la instancia creada en base al Container Image. A esta instancia se puede asociar unos datos temporales (overlay file system). Ya que en las instancias no deben contener datos persistentes.

    DockerFile

    Fichero con instrucciones para aplicar en la Container Image al crear el Container. Indica tareas adicionales como abrir puertos, acabar de configurar servicios… El proceso de creación del Container se llama build. También hay la posibilidad del Container construido incorporarlo a un repositorio, como Docker Hub.

    docker-compose.yml

    Fichero con instrucciones que indica con que recursos y políticas se ejecutan los Containers. Indica datos como memoria, numero de instancias, reinicio ante caídas, relacionar containers….

    Docker Host

    Es el Servicio que se instala en el Servidor que contiene los Containers.

    • Linux Docker Host sólo soporta Container Images basadas en Linux.
    • Windows Docker Host sólo soporta Container Images basadas en Linux o Windows.

    Cluster

    Es una colección Docker Host; esto nos permite escalar horizontalmente nuestros Container para obtener mayor nivel de servicio. Su gestión se realiza mediante Orquestadores. Los Clusters más conocidos son:

    • Docker Swarm
    • Kubernetes
    • Mesosphere DC/OS
    • Azure Container Service que no tiene su propio Orquestador sino utiliza uno de los anteriores).
    • Azure Service Fabric
    Publicado en DevOps | Deja un comentario

    Build in Visual Studio Team Services

    Visual Studio Team Services nos permite crear un Build que es básicamente un proceso que define una serie de tareas para realizar continuos delevery (devops). Este Build se puede lanzar a demanda o también cuando se realiza un Checkin en el código (Continuos integration).

    Tareas


    Realizan acciones simples; en el siguiente en enlace se describen. Las más destacadas son:

    • Get Resources: Descarga el código fuente del repositorio.
    • NutGet Restore: Obtiene las dependencias de NutGet.
    • Build Solution: Compila el código. Si nuestra aplicación incorpora WebJobs hemos de añadir el parámetro /p:_DestinationType=AzureWebSite en el msbuild.
    • Test: Verifica los test unitarios definidos en el código.
    • Azure App Service Deploy: Copia el paquete de la aplicación a Azure.
    • Publish sysmbols path: Añade información adicional para poder debugar en remoto la aplicación.
    • Publish Artifact: Despliega el paquete de la aplicación.

    Services EndPoint

    Muchas tareas requieren de la conexión a servicios externos; en este enlace se definen los parámetros de conexión para los diferentes conectores. Estos Services Enpooints se definen para cada proyecto.
    Para el caso de un subscripción de Azure tal como describe el enlace, primero debemos ejecutar un script de PowerShell. Este script crea una aplicación con permisos que se usará en el EndPoint para acceder a la subscripción.

    Publicado en DevOps, Visual Studio | 1 Comentario

    Azure Sdk For Net

    La librería Azure Sdk For Net nos permite realizar operaciones en C# sobre Azure; idénticamente a las que haríamos en el Portal de Azure. Esta libreria es el código fuente de los paquetes de Nuget Microsoft.Azure.Management.*.

    Autenticación en la librería

    Hay dos opciones para autenticarse para gestionar los recursos de Azure:

    • Con certificados (ASM): Únicamente funciona para recursos del Portal de Azure clásico.
    • Mediante el Directorio Activo de Azure (ARM): Accediendo vía credencial de usuario o aplicación.

    Utilizaremos la segunda opción por ser la mayor proyección y futuro 😉

    • 1.- En nuestra aplicación de directorio activo añadir los permisos necesarios para acceder Windows Azure Service Management API.
    • 2.- Dar derecho en la Subscripción para acceder medinante la aplicación, previo registro previo de la aplicación en el tenant.
    • 3.- Obtener el token de Acceso a la librería. Mediante una credencial de usuario:
                  var user = "usuario@contoso.com";
                  var password = "password" 
                  var guidApplication = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxx"; //App Nativa
                  UserCredential userCredentials = new UserCredential(user, password);
                  var addAuthority = new UriBuilder("https://login.microsoftonline.com/")
                  {
                      Path = "common"
                  };
                  AuthenticationContext authContext = new AuthenticationContext(addAuthority.Uri.AbsoluteUri);
      
                  AuthenticationResult userAuthResult = authContext.AcquireToken(
                      "https://management.core.windows.net/",
                      guidApplication,
                      userCredentials);
                  var token = userAuthResult.CreateAuthorizationHeader().Substring("Bearer ".Length);
                  var credentials = new TokenCloudCredentials(subscriptionId, token);
      

      o mediante una credencial de aplicación:

                  var applicationId= "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxx";  //App Nativa o Web
                  var clientSecret = "password" 
                  var clientCredential = new ClientCredential(applicationId,clientSecret);
                  var addAuthority = new UriBuilder("https://login.microsoftonline.com/")
                  {
                      Path = domain
                  };
                  AuthenticationContext authContext = new AuthenticationContext(addAuthority.Uri.AbsoluteUri);
      
                  AuthenticationResult userAuthResult = authContext.AcquireToken(
                      "https://management.core.windows.net/",
                      clientCredential);
                  var token = userAuthResult.CreateAuthorizationHeader().Substring("Bearer ".Length);
                  var credentials = new TokenCloudCredentials(subscriptionId, token);
      

    Uso de la librería

    Como ejemplo de gestión de un recurso de Azure; vamos a usar la parte la parte de la librería que gestiona el Azure Automation que describimos en una entrada anterior. Esta parte corresponde al paquete de Nuget Microsoft.Azure.Management.Automation.

    //Obtenemos la lista de RunBooks
    var client = new AutomationManagementClient(credentials);
    var runbooksList = automationClient.Runbooks.List("ResourceName", "AutomationAccount");
    
    Publicado en Azure, Desarrollo | Etiquetado , | Deja un comentario

    Graph Api y Autenticación

    Graph Api

    La librería Azure Active Directory Graph API permite realizar operaciones sobre los objetos existentes en el directorio activo.

    • Operaciones sobre Usuarios y Contactos (Usuarios Externos): Leer información de perfil así como actualizarla, creación y eliminación.
    • Operaciones sobre Roles, Grupos o Aplicaciones: creación, modificación y eliminación.
    • Operaciones sobre Dominios y Políticas.

    Autenticación en Graph Api

    En la entrada anterior Glosario de Directorio Activo Azure se describió la configuración de aplicaciones en el directorio activo. En esta entrada se va describir
    diferentes maneras de obtener los token de autenticación vía las aplicaciones para poder realizar llamadas a la Graph Api. Existen diversas posibilidades:

    • Aplicación Nativa con Credenciales de Usuario:
                  var appId = [Id of Application Native];
                  var user = [User Id of AD];
                  var password= [User Password of AD];
                  var tenantId = [Id of AD];
                  UserCredential userCredentials = new UserCredential(user, password);
                  var addAuthority = new Uri(new Uri("https://login.microsoftonline.com/"), tenantId);
                  AuthenticationContext authContext = new AuthenticationContext(addAuthority.AbsoluteUri);ddAuthority.Uri.AbsoluteUri);
                  AuthenticationResult userAuthResult = authContext.AcquireToken(
                      "https://graph.windows.net",
                      appId,
                      userCredentials);
                  Uri serviceRoot = new Uri(new Uri("https://graph.windows.net"), userTenantId);
                  ActiveDirectoryClient userAdClient = new ActiveDirectoryClient(serviceRoot, async () => await Task.FromResult(userAuthResult.AccessToken));
      
    • Aplicación Nativa solicitando usuario y contraseña en una ventana del Navegador.
                  var appId = [Id of Application Native];
                  var returnUrl = [returnUrl of Aplication Web Native]
                  var tenantId = [Id of AD];
                  var addAuthority = new Uri(new Uri("https://login.microsoftonline.com/"), tenantId);
                  AuthenticationContext authContext = new AuthenticationContext(addAuthority.AbsoluteUri);
                  AuthenticationResult userAuthResult = authContext.AcquireToken(
                      "https://graph.windows.net",
                      appId,
                      new Uri(returnUrl)
                   );
                  Uri serviceRoot = new Uri(new Uri("https://graph.windows.net"), userTenantId);
                  ActiveDirectoryClient userAdClient = new ActiveDirectoryClient(serviceRoot, async () => await Task.FromResult(userAuthResult.AccessToken));</li>
      
    • Aplicación Web App/Web Api con Credenciales de Aplicación
                  var appId = [Id of Aplication Web App];
                  var appSecret = [Secret of Application Web App];
                  var tenantId = [Id of AD];
                  var clientCredential = new ClientCredential(appId, appSecret);
                  var addAuthority = new Uri(new Uri("https://login.microsoftonline.com/"), tenantId);
                  AuthenticationContext authContext = new AuthenticationContext(addAuthority.AbsoluteUri);
                  AuthenticationResult userAuthResult = authContext.AcquireToken(
                      "https://graph.windows.net",
                      clientCredential);
                  Uri serviceRoot = new Uri(new Uri("https://graph.windows.net"), tenantId);
                  ActiveDirectoryClient userAdClient = new ActiveDirectoryClient(serviceRoot, async () => await Task.FromResult(userAuthResult.AccessToken));
      

    Uso Grap Api

    La Graph es una Api Rest que podemos acceder mediante llamadas HTTP con la cookie de Authorization (Bearer Token). En nuestro caso usamos un .NET Client Library que encapsula estas llamadas.
    Por ejemplo obtenemos los roles y grupos de un usuario.

    var userMemberships = userAdClient.Users.GetByObjectId(UserObjectId).MemberOf.ExecuteAsync().Result;
    
    Publicado en Azure, Seguridad | Deja un comentario

    Que es un token web?

    Que es un token Web?

    Al autenticarnos en un proveedor de identidad, se genera un token. Este token es como una llave que nos permite acceder a servicios. El token Web esta ideado para acceder a servicios Web.

    Estructura de un token Web

    Este token esta compuesto de 3 cadenas en base64 separadas por puntos con el objetivo de ser compacto y compatible con el formato de Url. Estas 3 cadenas corresponden a 3 bloques:

    • Cabecera: Es un objecto Json que contiene la información del toquen.
      • alg: El algoritmo utilizado para encriptar/descencriptar la firma del token. El RS256 es el asimétrico y el HS256 es el simétrico.
      • typ: tipo del token, normalemente JWT.
    • Datos: Es un objecto Json que tiene la información que transmite el token. Esta parte se suele conocer como el conjunto de Claims. Hay unas claims reservadas que son estandards pero podemos añadir las nuestras.
      • iis/(Issuer): quien genera el token.
      • exp (Expiration): el tiempo que es valido el token.
      • sub (Subject): subconjunto con claims que identifican al usuario y su rol.
      • aud (Audience): indica la servicio web que quiere ser accedido.
    • Firma: Es un hash que nos permite validar el token y asegurar que la información contenida en el mismo no ha sido manipulada.

    Para ampliar información, hay una especificación detallada.

    Ejemplo de Creación de token en NET en el proveedor de Identidad

    Utilizando el algoritmo de clave Simetrica.

    public String GetToken()        {
    var secretKey = "[Insertar el Password]"
    var signingKey = new InMemorySymmetricSecurityKey(Encoding.ASCII.GetBytes(secretKey));
    var signingCredentials = new SigningCredentials(signingKey,
    SecurityAlgorithms.HmacSha256Signature, SecurityAlgorithms.Sha256Digest);
    var claimsIdentity = new ClaimsIdentity(new List<Claim>()
    {
    	new Claim(ClaimTypes.NameIdentifier, "AutoritherUser"),
    	new Claim(ClaimTypes.Role, "Author"),
    }, "Custom");
    
    var now = DateTime.UtcNow;
    var securityTokenDescriptor = new SecurityTokenDescriptor()
    {
    	AppliesToAddress = "https://servicio.accedido.com",
    	TokenIssuerName = "https://provedoor.token.com",
    	Subject = claimsIdentity,
    	SigningCredentials = signingCredentials,
    };
    var tokenHandler = new JwtSecurityTokenHandler();
    var plainToken = tokenHandler.CreateToken(securityTokenDescriptor);
    var signedAndEncodedToken = tokenHandler.WriteToken(plainToken);
    return  signedAndEncodedToken;
    }
    

    Ejemplo de Validación del token en NET en el servicio web

    public void SecurizeApi(String signedAndEncodedToken)      {
                // https://vosseburchttechblog.azurewebsites.net/index.php/2015/09/19/generating-and-consuming-json-web-tokens-with-net/
    try
    {
    
    	var secretKey = "[Insertar el Password]"   //Debe se la misma que en el ejemplo anterior.
    	var signingKey = new InMemorySymmetricSecurityKey(Encoding.ASCII.GetBytes(secretKey));
    	var tokenValidationParameters = new TokenValidationParameters()
    	{
    		ValidAudiences = new string[]
    		{
    		 "https://servicio.accedido.com"
    		},
    		ValidIssuers = new string[]
    		{
    		"https://provedoor.token.com"
    		},
    		IssuerSigningKey = signingKey,
    	};
    	var tokenHandler = new JwtSecurityTokenHandler();
    	SecurityToken validatedToken;
    	tokenHandler.ValidateToken(signedAndEncodedToken,
    		tokenValidationParameters, out validatedToken);
    }
    catch (Exception)
    {
    	throw new HttpException(403, "You don't have access to this resource.");
    };
    }
    

    Servicios Utiles

    Publicado en net, Seguridad | Etiquetado , | Deja un comentario