Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.

# Ejecutar múltiples aplicaciones y aplicaciones centrales ASP.NET con un manifiesto de implementación
<a name="dotnet-manifest"></a>

Puede utilizar un manifiesto de implementación para indicarle a Elastic Beanstalk cómo se va a implementar la aplicación. Al utilizar este método, no es necesario utilizar `MSDeploy` para generar un paquete de código fuente para una única aplicación ASP.NET que se ejecuta en la ruta raíz del sitio web. En su lugar, puede utilizar un archivo de manifiesto para ejecutar varias aplicaciones en rutas diferentes. O bien, puede indicarle a Elastic Beanstalk que implemente y ejecute la aplicación con ASP.NET Core. También puede utilizar un manifiesto de implementación para configurar un grupo de aplicaciones en el que ejecutará las aplicaciones.

Los manifiestos de implementación añaden compatibilidad con las [aplicaciones de .NET Core](#dotnet-manifest-dotnetcore) en Elastic Beanstalk. Puede implementar una aplicación.NET Framework sin un manifiesto de implementación. Sin embargo, las aplicaciones.NET Core requieren un manifiesto de implementación para ejecutarse en Elastic Beanstalk. Si utiliza un manifiesto de implementación, debe crear un archivo del sitio para cada aplicación y empaquetar todos ellos después en un segundo ZIP que contenga el manifiesto de implementación.

Los manifiestos de implementación también brindan la posibilidad de [ejecutar varias aplicaciones en diferentes rutas](#dotnet-manifest-multiapp). Un manifiesto de implementación define una serie de objetivos de implementación, cada uno de ellos con un archivo del sitio y una ruta en la que IIS debe ejecutarse. Por ejemplo, puede ejecutar una API web en la ruta `/api` para que atienda las solicitudes asincrónicas y una aplicación web en la ruta raíz que utilice la API.

Puede usar un manifiesto de implementación para [configurar sitios web de IIS con enlaces personalizados y rutas físicas](#dotnet-manifest-websites). Esto le permite configurar sitios web que escuchen los nombres de puertos o hosts específicos antes de implementar las aplicaciones.

También puede utilizar un manifiesto de implementación para [ejecutar varias aplicaciones mediante grupos de aplicaciones en IIS o Kestrel](#dotnet-manifest-apppool). Puede configurar un grupo de aplicaciones para reiniciar las aplicaciones periódicamente, ejecutar aplicaciones de 32 bits o utilizar una versión específica del entorno de ejecución de .NET Framework.

Para una personalización completa, puede [escribir sus propios scripts de implementación](#dotnet-manifest-custom) en Windows PowerShell e indicar a Elastic Beanstalk qué scripts debe ejecutar para instalar, desinstalar y reiniciar la aplicación.

El manifiesto de implementación y las características relacionadas requieren una plataforma de Windows Server [versión 1.2.0 o posterior](dotnet-v2migration.md).

Para obtener información detallada sobre todas las opciones de configuración, propiedades y características avanzadas disponibles, como omitir los restablecimientos de IIS, consulte [deployment manifest schema reference](dotnet-manifest-schema.md).

**Topics**
+ [Aplicaciones de .NET Core](#dotnet-manifest-dotnetcore)
+ [Ejecutar múltiples aplicaciones](#dotnet-manifest-multiapp)
+ [Configurar sitios web de IIS](#dotnet-manifest-websites)
+ [Uso de enrutamiento de solicitudes de aplicaciones (ARR)](#dotnet-manifest-arr)
+ [Configuración de grupos de aplicaciones](#dotnet-manifest-apppool)
+ [Definir implementaciones personalizadas](#dotnet-manifest-custom)
+ [Referencia del esquema del manifiesto de implementación](dotnet-manifest-schema.md)

## Aplicaciones de .NET Core
<a name="dotnet-manifest-dotnetcore"></a>

Puede utilizar un manifiesto de implementación para ejecutar aplicaciones .NET Core en Elastic Beanstalk. .NET Core es una versión multiplataforma de .NET que incluye una herramienta de línea de comandos (`dotnet`). Puede utilizarla para generar una aplicación, ejecutarla localmente y prepararla para su publicación.

Para ejecutar una aplicación de .NET Core en Elastic Beanstalk, puede ejecutar `dotnet publish` y empaquetar la salida en un archivo ZIP, sin incluir los directorios que contiene. Coloque el archivo del sitio en un paquete de código fuente con un manifiesto de implementación que tenga un destino de implementación de tipo `aspNetCoreWeb`.

El siguiente manifiesto de implementación ejecuta una aplicación de .NET Core desde un archivo del sitio llamado `dotnet-core-app.zip` situado en la ruta raíz.

**Example aws-windows-deployment-manifest.json: .NET core**  

```
{
  "manifestVersion": 1,
  "deployments": {
    "aspNetCoreWeb": [
      {
        "name": "my-dotnet-core-app",
        "parameters": {
          "archive": "dotnet-core-app.zip",
          "iisPath": "/"
        }
      }
    ]
  }
}
```

Empaquete el manifiesto y el archivo del sitio en un ZIP para crear un paquete de código fuente.

**Example dotnet-core-bundle.zip**  

```
.
|-- aws-windows-deployment-manifest.json
`-- dotnet-core-app.zip
```

El archivo del sitio contiene el código compilado de la aplicación, las dependencias y el archivo `web.config`.

**Example dotnet-core-app.zip**  

```
.
|-- Microsoft.AspNetCore.Hosting.Abstractions.dll
|-- Microsoft.AspNetCore.Hosting.Server.Abstractions.dll
|-- Microsoft.AspNetCore.Hosting.dll
|-- Microsoft.AspNetCore.Http.Abstractions.dll
|-- Microsoft.AspNetCore.Http.Extensions.dll
|-- Microsoft.AspNetCore.Http.Features.dll
|-- Microsoft.AspNetCore.Http.dll
|-- Microsoft.AspNetCore.HttpOverrides.dll
|-- Microsoft.AspNetCore.Server.IISIntegration.dll
|-- Microsoft.AspNetCore.Server.Kestrel.dll
|-- Microsoft.AspNetCore.WebUtilities.dll
|-- Microsoft.Extensions.Configuration.Abstractions.dll
|-- Microsoft.Extensions.Configuration.EnvironmentVariables.dll
|-- Microsoft.Extensions.Configuration.dll
|-- Microsoft.Extensions.DependencyInjection.Abstractions.dll
|-- Microsoft.Extensions.DependencyInjection.dll
|-- Microsoft.Extensions.FileProviders.Abstractions.dll
|-- Microsoft.Extensions.FileProviders.Physical.dll
|-- Microsoft.Extensions.FileSystemGlobbing.dll
|-- Microsoft.Extensions.Logging.Abstractions.dll
|-- Microsoft.Extensions.Logging.dll
|-- Microsoft.Extensions.ObjectPool.dll
|-- Microsoft.Extensions.Options.dll
|-- Microsoft.Extensions.PlatformAbstractions.dll
|-- Microsoft.Extensions.Primitives.dll
|-- Microsoft.Net.Http.Headers.dll
|-- System.Diagnostics.Contracts.dll
|-- System.Net.WebSockets.dll
|-- System.Text.Encodings.Web.dll
|-- dotnet-core-app.deps.json
|-- dotnet-core-app.dll
|-- dotnet-core-app.pdb
|-- dotnet-core-app.runtimeconfig.json
`-- web.config
```

## Ejecutar múltiples aplicaciones
<a name="dotnet-manifest-multiapp"></a>

Para ejecutar varias aplicaciones con un manifiesto de implementación, debe definir diferentes objetivos de implementación.

El manifiesto de implementación siguiente configura dos aplicaciones .NET Core. La aplicación `WebApiSampleApp` implementa una API web simple y sirve solicitudes asíncronas en la ruta `/api`. La aplicación `DotNetSampleApp` es una aplicación web que atiende solicitudes en la ruta raíz.

**Example aws-windows-deployment-manifest.json: múltiples aplicaciones**  

```
{
  "manifestVersion": 1,
  "deployments": {
    "aspNetCoreWeb": [
      {
        "name": "WebAPISample",
        "parameters": {
          "appBundle": "WebApiSampleApp.zip",
          "iisPath": "/api"
        }
      },
      {
        "name": "DotNetSample",
        "parameters": {
          "appBundle": "DotNetSampleApp.zip",
          "iisPath": "/"
        }
      }
    ]
  }
}
```

Aquí hay disponible una aplicación de muestra con varias aplicaciones:
+ **[Paquete de código fuente desplegable: -v2.zip dotnet-multiapp-sample-bundle](samples/dotnet-multiapp-sample-bundle-v2.zip)**
+ **Código fuente**[: -v2.zip dotnet-multiapp-sample-source](samples/dotnet-multiapp-sample-source-v2.zip)

## Configurar sitios web de IIS
<a name="dotnet-manifest-websites"></a>

Puede configurar sitios web de IIS con enlaces personalizados y rutas físicas mediante el manifiesto de implementación. Esto resulta útil cuando necesita configurar sitios web que escuchen en puertos específicos, usen nombres de host personalizados o publiquen contenido de directorios específicos.

El siguiente manifiesto de implementación configura un sitio web de IIS personalizado que escucha en HTTP con un número de puerto específico y una ruta física personalizada:

**Example aws-windows-deployment-manifest.json: configuración del sitio web de IIS**  

```
{
  "manifestVersion": 1,
  "iisConfig": {
    "websites": [
      {
        "name": "MyCustomSite",
        "physicalPath": "C:\inetpub\wwwroot\mysite",
        "bindings": [
          {
            "protocol": "http",
            "port": 8080,
            "hostName": "mysite.local"
          }
        ]
      }
    ]
  },
  "deployments": {
    "aspNetCoreWeb": [
      {
        "name": "my-dotnet-core-app",
        "parameters": {
          "appBundle": "dotnet-core-app.zip",
          "iisWebSite": "MyCustomSite",
          "iisPath": "/"
        }
      }
    ]
  }
}
```

En este ejemplo:
+ Se crea un sitio web denominado MyCustomSite "» con una ruta física personalizada
+ El sitio web tiene un enlace HTTP en el puerto 8080 con un nombre de host específico.
+ La aplicación ASP.NET Core se implementa en este sitio web personalizado mediante el parámetro `iisWebSite`.

## Uso de enrutamiento de solicitudes de aplicaciones (ARR)
<a name="dotnet-manifest-arr"></a>

Los módulos Application Request Routing (ARR) y URL Rewrite vienen preinstalados y están disponibles en Elastic Beanstalk Windows. AMIs Estos módulos permiten escenarios de enrutamiento avanzados y la manipulación de URL mediante la configuración de IIS con configuración de ebextensions o aplicaciones.

El siguiente ejemplo muestra un manifiesto de implementación simple que configura un sitio web con un puerto personalizado, combinado con una configuración de ebextensions que establece el enrutamiento de ARR básico:

**Example aws-windows-deployment-manifest.json: configuración ARR sencilla**  

```
{
  "manifestVersion": 1,
  "iisConfig": {
    "websites": [
      {
        "name": "ARRSite",
        "physicalPath": "C:\\inetpub\\wwwroot\\arrsite",
        "bindings": [
          {
            "protocol": "http",
            "port": 8080,
            "hostName": "localhost"
          }
        ]
      }
    ]
  },
  "deployments": {
    "aspNetCoreWeb": [
      {
        "name": "BackendApp",
        "parameters": {
          "appBundle": "backend-app.zip",
          "iisWebSite": "ARRSite",
          "iisPath": "/backend"
        }
      }
    ]
  }
}
```

La configuración de ARR se realiza a través de ebextensions. La siguiente configuración establece las reglas básicas de enrutamiento de ARR:

**Example .ebextensions/arr-config.config: configuración básica de ARR**  

```
files:
  "C:\\temp\\configure-arr.ps1":
    content: |
      # Enable ARR proxy at server level
      Set-WebConfigurationProperty -PSPath 'MACHINE/WEBROOT/APPHOST' -Filter 'system.webServer/proxy' -Name 'enabled' -Value 'True'
      
      # Clear any existing global rules to avoid conflicts
      Clear-WebConfiguration -PSPath 'MACHINE/WEBROOT/APPHOST' -Filter 'system.webServer/rewrite/globalRules'

      # Add global rule to route all requests to backend
      Add-WebConfigurationProperty -PSPath 'MACHINE/WEBROOT/APPHOST' `
        -Filter 'system.webServer/rewrite/globalRules' `
        -Name '.' `
        -Value @{
          name = 'Route_to_Backend'
          stopProcessing = 'True'
          match = @{ url = '^(?!backend/)(.*)' }
          action = @{
            type = 'Rewrite'
            url = 'http://localhost:8080/backend/{R:1}'
          }
        }

container_commands:
  01_configure_arr:
    command: powershell -ExecutionPolicy Bypass -File "C:\\temp\\configure-arr.ps1"
    waitAfterCompletion: 0
```

Esta configuración crea un sitio web en el puerto 8080 y configura ARR para enrutar todas las solicitudes entrantes a la aplicación de backend que se ejecuta en ese sitio.

## Configuración de grupos de aplicaciones
<a name="dotnet-manifest-apppool"></a>

Puede admitir varias aplicaciones en su entorno Windows. Hay dos enfoques disponibles:
+ Puede usar el modelo de out-of-process alojamiento con el servidor web Kestrel. Con este modelo, puede configurar varias aplicaciones para que se ejecuten en un grupo de aplicaciones.
+ Puede utilizar el modelo de alojamiento en proceso. Con este modelo, se utilizan varios grupos de aplicaciones para ejecutar varias aplicaciones con una sola aplicación en cada grupo. Si utiliza el servidor IIS y necesita ejecutar varias aplicaciones, debe utilizar este enfoque.

Si desea configurar Kestrel para que ejecute varias aplicaciones en un grupo de aplicaciones, agregue `hostingModel="OutofProcess"` en el archivo `web.config`. Considere los siguientes ejemplos:

**Example web.config: para el modelo de alojamiento de Kestrel out-of-process**  

```
<configuration>
<location path="." inheritInChildApplications="false">
<system.webServer>
<handlers>
<add 
    name="aspNetCore" 
    path="*" verb="*" 
    modules="AspNetCoreModuleV2" 
    resourceType="Unspecified" />
</handlers>
<aspNetCore 
    processPath="dotnet" 
    arguments=".\CoreWebApp-5-0.dll" 
    stdoutLogEnabled="false" 
    stdoutLogFile=".\logs\stdout" 
    hostingModel="OutofProcess" />
</system.webServer>
</location>
</configuration>
```

**Example aws-windows-deployment-manifest.json: múltiples aplicaciones**  

```
{
"manifestVersion": 1,
  "deployments": {"msDeploy": [
      {"name": "Web-app1",
        "parameters": {"archive": "site1.zip",
          "iisPath": "/"
        }
      },
      {"name": "Web-app2",
        "parameters": {"archive": "site2.zip",
          "iisPath": "/app2"
        }
      }
    ]
  }
}
```

IIS no admite varias aplicaciones en un grupo de aplicaciones porque utiliza el modelo de alojamiento en proceso. Por lo tanto, debe configurar varias aplicaciones mediante la asignación de cada aplicación a un grupo de aplicaciones. En otras palabras, asigne solo una aplicación a un grupo de aplicaciones.

Puede configurar IIS para que use diferentes grupos de aplicaciones en el archivo `aws-windows-deployment-manifest.json`. Realice las siguientes actualizaciones al consultar el siguiente archivo de ejemplo:
+ Agregue una sección `iisConfig` que incluya una subsección llamada `appPools`.
+ En el bloque `appPools`, enumere los grupos de aplicaciones. 
+ En la sección `deployments`, defina una sección `parameters` para cada aplicación.
+ Para cada aplicación, la sección `parameters` especifica un archivo, una ruta de acceso para ejecutarlo y una `appPool` en la que se ejecutará.

El siguiente manifiesto de implementación configura dos grupos de aplicaciones que reinician su aplicación cada 10 minutos. También adjuntan sus aplicaciones a una aplicación web .NET Framework que se ejecuta en la ruta especificada.

**Example aws-windows-deployment-manifest.json: una aplicación por grupo de aplicaciones**  

```
{
"manifestVersion": 1,
  "iisConfig": {"appPools": [
      {"name": "MyFirstPool",
       "recycling": {"regularTimeInterval": 10}
      },
      {"name": "MySecondPool",
       "recycling": {"regularTimeInterval": 10}
      }
     ]
    },
  "deployments": {"msDeploy": [
      {"name": "Web-app1",
        "parameters": {
           "archive": "site1.zip",
           "iisPath": "/",
           "appPool": "MyFirstPool"
           }
      },
      {"name": "Web-app2",
        "parameters": {
           "archive": "site2.zip",
           "iisPath": "/app2",
           "appPool": "MySecondPool"
          }
      }
     ]
    }
}
```

## Definir implementaciones personalizadas
<a name="dotnet-manifest-custom"></a>

Para tener aún más control, puede personalizar completamente la implementación de una aplicación y definir una *implementación personalizada*.

Este manifiesto de implementación indica a Elastic Beanstalk PowerShell que ejecute scripts en modo de 32 bits. [Especifica tres scripts: un `install` script (`siteInstall.ps1`) que se ejecuta durante el lanzamiento y las implementaciones de la instancia, un `uninstall` script (`siteUninstall.ps1`) que se ejecuta antes de instalar nuevas versiones durante las implementaciones y un `restart` script (`siteRestart.ps1`) que se ejecuta al seleccionar Restart App Server en la consola de administración.](environments-dashboard-actions.md) AWS 

**Example aws-windows-deployment-manifest.json: implementación personalizada**  

```
{
  "manifestVersion": 1,
  "deployments": {
    "custom": [
      {
        "name": "Custom site",
        "architecture" : 32,
        "scripts": {
          "install": {
            "file": "siteInstall.ps1"
          },
          "restart": {
            "file": "siteRestart.ps1"
          },
          "uninstall": {
            "file": "siteUninstall.ps1"
          }
        }
      }
    ]
  }
}
```

Incluya los artefactos necesarios para ejecutar la aplicación en el paquete de código fuente con el manifiesto y los scripts.

**Example Custom-site-bundle: .zip**  

```
.
|-- aws-windows-deployment-manifest.json
|-- siteInstall.ps1
|-- siteRestart.ps1
|-- siteUninstall.ps1
`-- site-contents.zip
```