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.

É possível usar um manifesto de implantação para configurar sites do IIS com vinculações personalizadas e caminhos físicos. Isso permite configurar sites que recepcionam portas ou nomes de host específicos antes de implantar aplicações.

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

Para obter informações detalhadas sobre todas as opções de configuração, propriedades e recursos avançados disponíveis, como ignorar redefinições do IIS, consulte a referência do esquema do manifesto de implantação.

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 sites do IIS

É possível configurar sites do IIS com vinculações personalizadas e caminhos físicos usando o manifesto de implantação. Isso é útil quando é necessário configurar sites que recepcionam em portas específicas, usam nomes de host personalizados ou veiculam conteúdo de diretórios específicos.

O manifesto de implantação a seguir configura um site personalizado do IIS que recepciona HTTP com um número de porta específico e um caminho físico personalizado:

{
  "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": "/"
        }
      }
    ]
  }
}

Neste exemplo:

Usar o Roteamento de solicitação de aplicação (ARR)

Os módulos de Roteamento de solicitação de aplicação (ARR) e Reescrita de URL estão pré-instalados e disponíveis nas AMIs do Elastic Beanstalk para Windows. Esses módulos permitem cenários avançados de roteamento e manipulação de URL por meio da configuração do IIS usando a configuração de ebextensions ou aplicações.

O exemplo a seguir mostra um manifesto de implantação simples que configura um site com uma porta personalizada, combinado com uma configuração ebextensions que configura o roteamento do ARR básico:

{
  "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"
        }
      }
    ]
  }
}

A configuração do ARR é feita por meio de ebextensions. A configuração a seguir define as regras básicas de roteamento do 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

Essa configuração cria um site na porta 8080 e configura o ARR para rotear todas as solicitações recebidas para a aplicação de backend executada nesse site.

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.

Esse manifesto de implantação instrui o Elastic Beanstalk a executar scripts do PowerShell no modo de 32 bits. Ele especifica três scripts: um script install (siteInstall.ps1) que é executado durante a inicialização e as implantações da instância, um script uninstall (siteUninstall.ps1) que é executado antes de instalar novas versões durante as implantações e um script restart (siteRestart.ps1) que é executado quando você seleciona Reiniciar servidor de aplicação no console de gerenciamento da AWS.

{
  "manifestVersion": 1,
  "deployments": {
    "custom": [
      {
        "name": "Custom site",
        "architecture" : 32,
        "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