Configuración de Visual Studio Code y WSL para el desarrollo MPI


Muchos planes de estudios requieren que se realicen pequeños programas con  MPI como parte del curso de Computación paralela, por lo que en este post   intentaremos ver como hacer la configuración de WSL (Subsistema de Windows para Linux) y Visual Studio Code para el desarrollo de MPI, que se ejecuta en Ubuntu WSL Distro de Microsoft Store

Configuración de WSL

En las versiones recientes de Windows, WSL está habilitado de forma predeterminada y todo lo que necesita hacer es instalar una distribución debajo de él.

Comenzaremos descargando la distribución de Ubuntu de Microsoft Store. Abra la tienda desde el menú de inicio y busque Ubuntu 18.04 o haga clic aquí

Imagen para publicación
Toca “Obtener” para instalar la distribución de Ubuntu de WSL

después de  instalarlo, ábralo y siga todas las instrucciones para ingresar su nombre de usuario y contraseña predeterminados, etcétera.

Instalación de OpenMPI y herramientas de compilación para OpenMPI

Ahora debería estar mirando una ventana de línea de comandos, ejecutando bash, con el logotipo de ubuntu como el icono de la aplicación en la barra de tareas. Si ve esto, significa que ha instalado con éxito la distribución de Ubuntu en WSL

Ahora escriba el siguiente comando para instalar OpenMPI. En el caso de la siguiente captura de pantalla, ya se ha instalado.

sudo apt update && sudo apt install openmpi-bin libopenmpi-dev

Después de esto, inmediatamente podrá usar mpicc y mpirun para ejecutar y compilar programas que usen MPI, pero pronto verá este mensaje.

WARNING: Linux kernel CMA support was requested via thebtl_vader_single_copy_mechanism MCA variable, but CMA support isnot available due to restrictive ptrace settings.

Esto se debe a uno de los parámetros con los que WSL está configurado de forma predeterminada. Para resolver esto, necesitamos ejecutar este comando

  echo 0 | sudo tee /proc/sys/kernel/yama/ptrace_scope

Después de esto, la advertencia simplemente desaparecerá.

Para compilar con MPI  simplemente debemos usr el compilador mpicc  , como por ejemplo:

>mpicc -o ejemplo ejemplo.c

Y para ejecutarlo usaremos mpirun  pasándole con el argumento -n el numero de procesadores:

mpirun -n 2 ./ejemplo

Ahora veamos un ejemplo sencillo para probar mpi :

 

#include<stdio.h>

#include<mpi.h>

int main( int argc, char* argv[] ) {

    int rank, size;

  

    // Paralelismo

    MPI_Init( &argc, &argv );

    // Indice del proceso

    MPI_Comm_size( MPI_COMM_WORLD, &size );

    // Tamano del comunicador seleccionado

    MPI_Comm_rank( MPI_COMM_WORLD, &rank );

    printf( "Hola mundo! Soy el proceso numero %d. En total somos %d procesos.\n", rank, size );




    MPI_Finalize();

}

 

 Para poder ejecutar con más procesadores  de los que físicamente tiene el equipo al usar  mpirun  pasándole con el argumento -n (el numero de procesadores) , nos dará un error :
>mpirun -n 4 ./ejemplo
There are not enough slots available in the system to satisfy the 3slots that were requested by the application:
  ./Step6-SendReceive
Either request fewer slots for your application, or make more slotsavailable for use.
A "slot" is the Open MPI term for an allocatable unit where we canlaunch a process.  The number of slots available are defined by theenvironment in which Open MPI processes are run:
  1. Hostfile, via "slots=N" clauses (N defaults to number of     processor cores if not provided)  2. The --host command line parameter, via a ":N" suffix on the     hostname (N defaults to 1 if not provided)  3. Resource manager (e.g., SLURM, PBS/Torque, LSF, etc.)  4. If none of a hostfile, the --host command line parameter, or an     RM is present, Open MPI defaults to the number of processor cores
In all the above cases, if you want Open MPI to default to the numberof hardware threads instead of the number of processor cores, use the--use-hwthread-cpus option.
Alternatively, you can use the --oversubscribe option to ignore thenumber of available slots when deciding the number of processes tolaunch.

Como no es difícil de adivinar el error advierte de que intentamos ejecutar  en mas procesadores los que realmente se tienen en nuestra máquina .Para simular los procesadores que no se tiene podemos utilizar el flag –oversubscribe

 
Sería así:
mpirun -np 4 –oversubscribe ./programa

 

 

Si solo desea ejecutar programas en el terminal y no necesitar configurar Visual Studio Code, ahora puede hacerlo usando mpicc y mpirun desde la consola .De lo contrario, siga leyendo para descubrir cómo configurar VSCode para la tarea.

Configuración de VSCode

Suponemos que ya tiene VSCode instalado, si no, descárguelos de su sitio web .

Necesitaremos instalar WSL Remote desde su página de Extensiones de Visual Studio , después de eso, haga clic en el nuevo ícono en la parte inferior izquierda para iniciar una nueva sesión de WSL.

Imagen para publicación

Después de eso, le pedirá que elija un directorio que desea abrir. Continúe y abra el directorio en el que planea realizar su desarrollo.

Para habilitar el resaltado de sintaxis, intellisense y otras características conscientes del lenguaje, también necesitamos configurar el soporte C / C ++ en VSCode. Para eso, vaya al panel de extensiones e instálelo

Imagen para publicación

Ahora, por defecto, VSCode no va a poder encontrar mpi.h, lo cual es fundamental para poder brindar sugerencias para Interfaces MPI, para eso necesitaremos configurar el includePath y la ruta ejecutable en el C / C ++ Ajustes.

 

Probablemente tenga  un archivo llamado c_ccp_properties.json en la carpeta .vscode en su directorio del programa 
    "configurations": [

        {

            "name": "Win32",

            "includePath": [

                "${workspaceFolder}/**", "C:\\Program Files (x86)\\Microsoft SDKs\\MPI\\Lib\\"

            ],

            "defines": [

                "_DEBUG",

                "UNICODE",

                "_UNICODE"

            ],

            "compilerPath": "C:\\MinGW\\bin\\gcc.exe",

            "cStandard": "gnu11",

            "cppStandard": "gnu++14",

            "intelliSenseMode": "windows-gcc-x86"

        }

    ],

    "version": 4

}

 Modifique ese archivo llamado c_ccp_properties.json en la carpeta .vscode en su directorio del programa MPI para poderlo  ejecutar desde Linux :

{

    "configurations": [

        {

            "name": "Linux",

            "includePath": [

                "${workspaceFolder}/**",

                "/usr/lib/x86_64-linux-gnu/openmpi/include"

            ],

            "defines": [],

            "compilerPath": "/usr/bin/mpicc",

            "cStandard": "c11",

            "cppStandard": "c++17",

            "intelliSenseMode": "clang-x64"

        }

    ],

    "version": 4

}
 
Se puede conseguir auto construcción y ejecución  por lo que además  de lo anteriror, si desea poder compilar y ejecutar directamente desde VSCode, debemos agregar las siguientes tareas de compilación y lanzamiento
 
fichero=launch.json
{
"version": "0.2.0",
"configurations": [
{
"name": "(mpirun) Launch",
"type": "cppdbg",
"request": "launch",
"program": "/usr/bin/mpirun",
"args": ["-np", "4", "${fileDirname}/${fileBasenameNoExtension}.out"],
"stopAtEntry": false,
"cwd": "${workspaceFolder}",
"environment": [],
"externalConsole": false,

}
]
}

fichero task.json

 
{

    "version": "2.0.0",

    "tasks": [

        {

            "type": "shell",

            "label": "gcc build active file",

            "command": "/usr/bin/gcc",

            "args": [

                "-g",

                "${file}",

                "-o",

                "${fileDirname}/${fileBasenameNoExtension}"

            ],

            "options": {

                "cwd": "/usr/bin"

            },

            "problemMatcher": [

                "$gcc"

            ],

            "group": "build"

        },

        {

            "type": "shell",

            "label": "mpicc build active file",

            "command": "/usr/bin/mpicc",

            "args": [

                "-g",

                "${file}",

                "-o",

                "${fileDirname}/${fileBasenameNoExtension}.out"

            ],

            "options": {

                "cwd": "/usr/bin"

            },

            "problemMatcher": [

                "$gcc"

            ],

            "group": {

                "kind": "build",

                "isDefault": true

            }

        },

    ]

}

Con esa configuración, debería poder usar sus atajos de teclado predeterminados para Ejecutar sin depurar (Ctrl + F5) y Generar (Ctrl + Shift + B) para construir y ejecutar sus programas MPI.

Generación manual de una clave SSH en Windows


 

En Windows se puede crear claves SSH de muchas formas. En este post debería aclaranos un poco como utilizar dos aplicaciones SSH, PuTTY y Git Bash .

Muchos proveedores recomiendan claves RSA porque los programas CLI de node-manta funcionan con claves RSA tanto localmente como con el agente ssh y las claves DSA solo funcionarán si la clave privada está en el mismo sistema que la CLI y no está protegida por contraseña.

Putty

PuTTY es un cliente SSH para Windows. Puede utilizar PuTTY para generar claves SSH. PuTTY es un emulador de terminal de código abierto gratuito que funciona de manera muy similar a la aplicación Terminal en macOS en un entorno Windows. Esta sección le muestra cómo generar y cargar manualmente una clave SSH cuando trabaja con PuTTY en el entorno de Windows.

 

PuTTY es un cliente SSH para Windows que utilizará para generar sus claves SSH. Puede descargar PuTTY desde www.chiark.greenend.org.uk .

Cuando instala el cliente PuTTY, también instala la utilidad PuTTYgen. PuTTYgen es lo que usará para generar su clave SSH para una VM de Windows.

Generando una clave SSH

Para generar una clave SSH con PuTTYgen, siga estos pasos:

  1. Abra el programa PuTTYgen.
  2. Para Tipo de clave a generar , seleccione SSH-2 RSA .
  3. Haga clic en el botón Generar .
  4. Mueva el mouse en el área debajo de la barra de progreso. Cuando la barra de progreso está llena, PuTTYgen genera su par de claves.
  5. Escriba una frase de contraseña en el campo Frase de contraseña de clave . Escriba la misma contraseña en el campo Confirmar contraseña . Puede utilizar una clave sin una frase de contraseña, pero no se recomienda.
  6. Haga clic en el botón Guardar clave privada para guardar la clave privada. ¡Advertencia!Usted debe guardar la clave privada. Lo necesitará para conectarse a su máquina.
  7. Haga clic con el botón derecho en el campo de texto etiquetado como Clave pública para pegar en el archivo de claves autorizadas de OpenSSH y elija Seleccionar todo .
  8. Vuelva a hacer clic derecho en el mismo campo de texto y elija Copiar .

Importando su clave SSH

Ahora debe importar la clave SSH copiada al portal.

  1. Después de copiar la clave SSH al portapapeles, regrese a la página de su cuenta de su proveedor .
  2. Elija Importar clave pública y pegue su clave SSH en el campo Clave pública.
  3. En el campo Nombre de clave , proporcione un nombre para la clave. Nota : aunque proporcionar un nombre de clave es opcional, es una buena práctica para facilitar la administración de varias claves SSH.
  4. Agrega la clave. Ahora aparecerá en su tabla de claves bajo SSH.
La tabla de claves SSH

¡Advertencia!PuTTY y OpenSSH usan diferentes formatos de claves SSH públicas. Si el texto que pegó en la clave SSH comienza con —— BEGIN SSH2 PUBLIC KEY, está en el formato incorrecto. Asegúrese de seguir las instrucciones cuidadosamente. Tu clave debe comenzar con ssh-rsa AAAA….

Una vez que cargue su clave SSH en el portal, puede conectarse a su máquina virtual desde Windows a través de una sesión PuTTY.

Git Bash

El paquete de instalación de Git viene con SSH. Con Git Bash, que es la herramienta de línea de comandos de Git, puede generar pares de claves SSH. Git Bash tiene un cliente SSH que le permite conectarse e interactuar con los contenedores de Triton en Windows.

Para instalar Git:

  1. (Descargue e inicie el instalador de Git] ( https://git-scm.com/download/win ).
  2. Cuando se le solicite, acepte los componentes predeterminados haciendo clic en Siguiente .
  3. Elija el editor de texto predeterminado. Si tiene Notepad ++ instalado, seleccione Notepad ++ y haga clic en Siguiente .
  4. Seleccione Usar Git en el símbolo del sistema de Windows y haga clic en Siguiente .
  5. Seleccione Usar la biblioteca OpenSSL y haga clic en Siguiente .
  6. Seleccione Checkout Windows-style, confirme los finales de línea de estilo Unix y haga clic en Siguiente .
  7. Seleccione Usar MinTTY (el terminal predeterminado de mYSYS2) y haga clic en Siguiente .
  8. Acepte la configuración de opción adicional predeterminada haciendo clic en Instalar .

Cuando se complete la instalación, es posible que deba reiniciar Windows.

Lanzamiento de GitBash

Para abrir Git Bash, recomendamos iniciar la aplicación desde el símbolo del sistema de Windows:

  1. En Windows, presione Inicio + R para abrir el cuadro de diálogo Ejecutar .
  2. Escribe C:\Program Files\Git\bin\bash.exey presiona Enter .

Generando claves SSH

Primero, cree el directorio SSH y luego genere el par de claves SSH.

Una suposición es que el perfil de Windows que está utilizando está configurado con privilegios administrativos. Dado esto, creará el directorio SSH en la raíz de su perfil, por ejemplo:

C:\Users\joetest
  1. En la línea de comando de Git Bash, cambie a su directorio raíz y escriba.
mkdir .ssh
  1. Cambie al directorio .ssh C:\Users\joetest\.ssh
  2. Para crear las claves, escriba:
ssh-keygen.exe
  1. Cuando se le solicite una contraseña, escriba una contraseña para completar el proceso. Cuando termine, el resultado será similar a:
Ssh-keygen.exe
Generating public/private rsa key pair.
Enter file in which to save the key (/c/Users/joetest/.ssh/id_rsa): /c/Users/joetest/.ssh/
Enter passphrase (empty for no passphrase):
Enter same passphrase again:
Your identification has been saved in /c/Users/joetest/.ssh/
Your public key has been saved in /c/Users/joetest/.ssh/
The key fingerprint is:
SHA256:jieniOIn20935n0awtn04n002HqEIOnTIOnevHzaI5nak [email protected]
The key's randomart image is:

 +---[RSA 2048]----+
 |*= =+.           |
 |O*=.B            |
 |+*o* +           |
 |o +o.  .         |
 | ooo  + S        |
 | .o.ooo* o       |
 |  .+o+*oo .      |
 |   .=+..         |
 |   Eo            |
 +----[SHA256]-----+

$ dir .ssh
id_rsa  id_rsa.pub   

Subiendo una clave SSH

Para cargar la clave SSH pública en su cuenta de  su proveedor :

  1. Abra el portal del servicio , seleccione Cuenta para abrir la página Resumen de cuenta .
  2. En la sección SSH , seleccione Importar clave pública .
  3. Ingrese un nombre de clave . Aunque nombrar una clave es opcional, las etiquetas son una práctica recomendada para administrar varias claves SSH.
  4. Agrega tu clave SSH pública.

Cuando Triton finaliza el proceso de agregar o cargar, la clave SSH pública aparece en la lista de claves SSH.

Autenticacion de usuarios en asp.net


En ciertas ocasiones, necesitamos que nuestra aplicación web ASP.NET disponga de un sistema de autenticación básica de usuarios para realizar, por ejemplo, tareas administrativas de configuración a través de un módulo de administración integrado que solo sea accesible para usuarios autenticados. Para este escenario en concreto, bastaría con implementar un simple sistema de Login para que el o los encargados de administrar la aplicación puedan autenticarse mediante su usuario y contraseña en el sistema.

En este Post veremos cómo crear un sistema de Login basado en FormsAuthentication con encriptado de contraseña, y como integrarlo en una aplicación web ASP.NET MVC. También veremos como solucionar los problemas derivados de publicar nuestra aplicación en un Web hosting en clúster con balanceo de carga.

Nota: Antes de comenzar a desarrollar el Post, comentar que este ejemplo está desarrollado en ASP.NET MVC4 Framework 4.0 aunque también es perfectamente compatible con aplicaciones ASP.NET MVC5  Framework 4.5.

FormsAuthentication (Web.config)

En primer lugar crearemos el o los usuarios administradores de la aplicación. Este proceso lo realizamos en el elemento <authentication/>, dentro de la sección <system.web/> del archivo de configuración Web.config de la aplicación.

<authentication mode="Forms">
  <forms name=".ASPXAUTH" loginUrl="~/Login" timeout="10000">
    <credentials passwordFormat="SHA1">
      <user name="usuario" password="contraseña-encriptada" />
      <!-- Otros usuarios aquí... -->          
    </credentials>
  </forms>
</authentication>

mode="Forms": Habilita la autenticación mediante formularios.

name=".ASPXAUTH": Nombre de la Cookie que contendrá el Ticket de autenticación.

loginUrl="~/Login":  URL de redirección, en el caso de que ASP.NET no encuentre la Cookie de autenticación.

timeout="10000": Tiempo de expiración de la Cookie de autenticación expresado en minutos.

passwordFormat="SHA1": Algoritmo de encriptación de las contraseñas de usuario (SHA1 hash).

name="admin": Nombre del usuario.

password="contraseña-encriptada": Contraseña del usuario encriptada en formato SHA1 (más adelante veremos como realizar el proceso de encriptación).

El Controlador y las Vistas

A continuación crearemos la infraestructura necesaria para desarrollar el sistema de autenticación y administración de la aplicación.

Creamos un Controlador básico con las Acciones necesarias para el sistema de Login y las tareas administrativas (posteriormente implementaremos el código para cada una de estas Acciones).

    public class AdminController : Controller
    {
        // GET: Admin
        public ActionResult Index()
        {
            // Aquí acceso al módulo de administración...
            return View();
        }

        // GET: Admin/Login
        public ActionResult Login()
        {
            // Aquí acceso a la 'Vista' de Login...
            return View();
        }

        // POST: Admin/Login
        [HttpPost]
        public ActionResult Login(string usr, string pwd, string rme)
        {
            // Aquí lógica de autenticación...
            return View();
        }

        // GET: Admin/Logout
        public ActionResult Logout()
        {
            // Aquí lógica de desconexión...
            return View();
        }
    }

Creamos también las Vistas (por supuesto siempre dentro del directorio de referencia del ControladorViews\Admin\). Para este ejemplo necesitaremos 2 Vistas: Login.cshtml e Index.cshtml.

Login.cshtml: Vista que contendrá el formulario de autenticación de usuarios. Este sería un ejemplo básico de Login mediante usuario y contraseña con la opción Remember me, basado en Bootstrap 3.2:

<div class="container-fluid">
    <div class="row">
        <div class="col-sm-6 col-md-4 col-md-offset-4">
            <div class="text-center">
                <div class="text-center">
                    <img class="img-thumbnail" src="~/Images/admin.png" width="128">
                </div>
                <br />
                @using (Html.BeginForm("Login","Admin"))
                {                
                    <input type="text" class="form-control" name="usr" 
                           placeholder="Usuario" required autofocus>
                    <br />
                    <input type="password" class="form-control" name="pwd" 
                           placeholder="Contraseña" required>
                    <br />
                    <button class="btn btn-lg btn-primary btn-block" type="submit">
                        Iniciar sesión
                    </button>
                    <label class="checkbox pull-left">
                        <input type="checkbox" name="rme" checked="">
                        <label>Remember me</label>
                    </label>                
                }
            </div>
        </div>
    </div>
</div>

Index.cshtml: Esta sería la Vista principal del módulo de administración. En un caso práctico podría ser un panel de control al estilo AdminLTE.

El código para la autenticación

Por último, solo quedaría codificar las Acciones del Controlador para dar la funcionalidad de autenticación al sistema de Login.

Esto lo haremos a través de la clase FormsAuthentication del espacio de nombres System.Web.Security. Esta clase proporciona una serie de métodos estáticos que interactuan con la configuración anteriormente establecida en el Web.config <authentication/>.

A continuación el código:

    public class AdminController : Controller
    {
        // GET: Admin
        public ActionResult Index()
        {
            if (this.Request.IsAuthenticated)
            {
                // Si el usuario está autenticado 
                // retorna la Vista de administración.
                return View();
            }
            else
            {
                // Si no, retorna la Vista de Login.
                return RedirectToAction("Login", "Admin");
            }
        }

        // GET: Admin/Login
        public ActionResult Login()
        {
            // Retorna la Vista de Login
            return View();
        }

        // POST: Admin/Login
        [HttpPost]
        public ActionResult Login(string usr, string pwd, string rme)
        {
            if (string.IsNullOrEmpty(usr) || string.IsNullOrEmpty(pwd))
            {
                return View();
            }
            else
            {
                bool _rememberMe = rme == "on" ? true : false;

                // Valida el usuario con los registrados en la
                // seccion <authentication/> del Web.config
                if (FormsAuthentication.Authenticate(usr, pwd))
                {
                    // Crea la Cookie con el Ticket de autenticación 
                    // para el usuario.
                    FormsAuthentication.SetAuthCookie(usr, _rememberMe);
                    // Redirige a la Accion 'Index'
                    return RedirectToAction("Index");
                }
                else
                {
                    // Si no es un usuario válido, retorna la
                    // Vista de Login.
                    return View();
                }
            }
        }

        // GET: Admin/Logout
        public ActionResult Logout()
        {
            // Elimina la Cookie con el Ticket de autenticación 
            // para el usuario.
            FormsAuthentication.SignOut();
            // Redirige a la Accion 'Index'
            return this.RedirectToAction("Index");
        }
    }

Encriptado de contraseña

Siempre es una buena práctica encriptar las contraseñas y datos sensibles de nuestra aplicación, a la hora de publicarla en un Web hosting externo a nuestra infraestructura corporativa. En el caso que nos ocupa, habíamos configurado la sección <authentication/> para utilizar contraseñas de usuario en formato SHA1 hash. Un ejemplo real con nombre de usuario ‘admin‘ y contraseña ‘admin‘, sería el siguiente:

<credentials passwordFormat="SHA1">
   <user name="admin" password="D033E22AE348AEB5660FC2140AEC35850C4DA997" />
</credentials>

Existen infinidad de páginas en Internet que generan online la cadena encriptada de caracteres SHA1 a partir de un texto dado, http://www.sha1-online.com es un ejemplo de estas.

Publicando nuestra aplicación (Web hosting)

En este punto ya hemos integrado el sistema de autenticación a nuestra aplicación ASP.NET MVC y todo funciona correctamente en nuestro servidor IIS local o de desarrollo. Es la hora entonces de publicar la aplicación en los servidores web de nuestro proveedor de hosting

Comenzamos a testear la aplicación, nos autenticamos en el sistema (Login), navegamos a través de las páginas que requieren usuarios autenticados, y en pocos minutos (o segundos) vemos como hemos perdido la autenticación y la aplicación nos redirige a la página de Login. Afortunadamente este es un problema muy común y de fácil solución.

El problema

Los proveedores de servicios de hosting funcionan con granjas de servidores web (Clustering) que implementan balanceo de carga para maximizar el rendimiento de las peticiones http y minimizar la carga de trabajo.

Cuando nos autenticamos en nuestra aplicación (Login), el servidor que atiende la petición crea un Ticket de autenticación que se almacena en una cookie que es enviada a nuestro navegador y nos permite navegar por las páginas que requieren usuarios autenticados.

Este Ticket de autenticación es creado a partir de que lo se llama un machineKey (clave de máquina). Cuando nuestra aplicación arranca por primera vez en un servidor web, un machineKey es creado automáticamente. Al autenticarnos, este machineKey es utilizado para firmar digitalmente el Ticket de autenticación. Por otra parte, cuando navegamos a una página que requiere usuarios autenticados, el servidor utiliza el machineKey para desencriptar el Ticket de autenticación de la Cookie para validar el usuario. 

El problema surge cuando es un servidor diferente (por el balanceo de carga) el que atiende la petición de autenticación, e intenta desencriptar el Ticket de autenticación con un machineKey diferente. El resultado de esta acción causaría la invalidación del Ticket de autenticación original (y de la Cookie), y la redirección del usuario a la página de Login.

La solución

ASP.NET nos permite definir un machineKey personalizado para cada una de nuestras aplicaciones web. Esto implica que los servidores donde se ejecute la aplicación, no auto-generen uno propio y utilicen el que la aplicación les propone.

La configuración del machineKey se realiza dentro de la sección <system.web/> del archivo de configuración Web.config de la aplicación:

<machineKey validationKey="B2A3A7ED71A85AC9BCBBBAD8407F9642EEFA3B17FD2583CFD66A3BAF407900D2C45A85379FA2B4BE2397BECF14650306B6292C96418B772055F01E1EE751E434"
decryptionKey="E60EC68AB3752322D236E5727370620398818355316FB5FDFBF00EE4344AE7B7"
validation="SHA1" decryption="AES" /> 

Es recomendable generar un machineKey aleatorio (y diferente) para cada una de la aplicaciones que queramos publicar en nuestro Web hostingDesde este sitio web: ASP.Net MachineKey Generator podemos generar nuestros machineKey en función del Framework ASP.NET que estemos utilizando.