Executar vários aplicativos e aplicativos ASP.NET Core com um manifesto de implantação

É possível usar um manifesto de implantação para informar o Elastic Beanstalk como implantar a aplicação. Ao usar esse método, você não precisa usar MSDeploy para gerar um pacote de origem para uma única aplicação ASP.NET que é executada no caminho raiz do seu site. Em vez disso, você pode usar um arquivo de manifesto para executar várias aplicações em caminhos diferentes. Ou, como alternativa, você pode dizer ao Elastic Beanstalk para implantar e executar a aplicação com o ASP.NET Core. Também é possível usar um manifesto de implantação para configurar um grupo de aplicações para executar suas aplicações.

Os manifestos de implantação adicionam suporte para aplicações .NET Core ao Elastic Beanstalk. Você pode implantar uma aplicação .NET Framework sem um manifesto de implantação. No entanto, as aplicações .NET Core exigem um manifesto de implantação para execução no Elastic Beanstalk. Ao usar um manifesto de implantação, você cria um arquivo do site para cada aplicação e, em seguida, empacota os arquivos do site em um segundo arquivo ZIP que contém o manifesto de implantação.

Os manifestos de implantação também adicionam a capacidade de executar vários aplicativos em diferentes caminhos. Um manifesto de implantação define um conjunto de alvos de implantação, cada um com um arquivamento do site e um caminho em que o IIS deve executá-lo. Por exemplo, você pode executar uma API da Web no caminho /api para atender a solicitações assíncronas e um aplicativo web no caminho raiz que consome a API.

Você também pode usar um manifesto de implantação para executar várias aplicações usando grupos de aplicações no IIS ou no Kestrel. Você pode configurar um grupo de aplicativos para reiniciar seus aplicativos periodicamente, executar aplicativos de 32 bits ou usar uma versão específica do tempo de execução do .NET Framework.

Para personalização completa, é possível escrever seus próprios scripts de implantação no Windows PowerShell e informar o Elastic Beanstalk quais scripts ele deve executar para instalar, desinstalar e reiniciar a aplicação.

Os manifestos de implantação e os recursos relacionados exigem uma plataforma do Windows Server versão 1.2.0 ou posterior.

Aplicativos .NET Core

É possível usar um manifesto de implantação para executar aplicações .NET Core no Elastic Beanstalk. .NET Core é uma versão multiplataforma do .NET que é fornecida com uma ferramenta de linha de comando (dotnet). Você pode usá-lo para gerar uma aplicação, executá-lo localmente e prepará-lo para publicação.

Para executar uma aplicação .NET Core no Elastic Beanstalk, execute dotnet publish e empacote a saída em um arquivo ZIP, sem incluir os diretórios. Coloque o arquivo do site em um pacote de origem com um manifesto de implantação com um destino de implantação do tipo aspNetCoreWeb.

O seguinte manifesto de implantação executa um aplicativo .NET Core em um arquivo de site chamado dotnet-core-app.zip no caminho raiz.

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

Inclua o arquivo de manifesto e de site em um arquivo ZIP para criar um pacote de origem.

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

O arquivo do site contém o código do aplicativo compilado, as dependências e o arquivo web.config.

.
|-- 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

Executar vários aplicativos

Você pode executar vários aplicativos com um manifesto de implantação definindo vários alvos de implantação.

O seguinte manifesto de implantação configura dois aplicativos .NET Core. A aplicação WebApiSampleApp implementa uma API simples da Web e atende a solicitações assíncronas no caminho /api. O aplicativo DotNetSampleApp é um aplicativo web que atende solicitações no caminho raiz.

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

Um aplicativo de exemplo com vários aplicativos está disponível em:

Configurar grupos de aplicativos

Você pode oferecer suporte a várias aplicações no seu ambiente Windows. Duas abordagens estão disponíveis:

Para configurar o Kestrel para executar várias aplicações em um grupo de aplicações, adicione hostingModel="OutofProcess" ao arquivo web.config. Considere os seguintes exemplos:

<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>

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

O IIS não suporta várias aplicações em um grupo de aplicações porque ele usa o modelo de hospedagem no processo. Portanto, você precisa configurar várias aplicações atribuindo cada aplicação a um grupo de aplicações. Em outras palavras, atribua apenas uma aplicação a um grupo de aplicações.

Você pode configurar o IIS para usar grupos de aplicações diferentes no arquivo aws-windows-deployment-manifest.json. Faça as seguintes atualizações conforme você se refere ao próximo arquivo de exemplo:

O manifesto de implantação a seguir configura dois grupos de aplicações que reiniciam sua aplicação a cada 10 minutos. Eles também anexam suas aplicações a uma aplicação web .NET Framework que é executada no caminho especificado.

{
"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 implantações personalizadas

Para controle ainda maior, você pode personalizar totalmente a implantação de um aplicativo definindo uma implantação personalizada.

O manifesto de implantação a seguir informa ao Elastic Beanstalk para executar um script install denominado siteInstall.ps1. Esse script instala o site durante a execução e as implantações da instância. Além disso, o manifesto de implantação também informa ao Elastic Beanstalk para executar um script uninstall antes de instalar uma nova versão durante uma implantação e um script restart para reiniciar a aplicação quando você escolhe Restart App Server (Reiniciar servidor de aplicações) no Console de Gerenciamento da AWS.

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

Inclua todos os artefatos necessários para executar o aplicativo em seu pacote de origem com o manifesto e os scripts.

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