Aplicativos .NET Core Executar vários aplicativos Configurar sites do IIS Usando o Roteamento de Solicitação de Aplicativo (ARR)Configurar grupos de aplicativos Definir implantações personalizadas

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ê pode usar um manifesto de implantação para configurar sites do IIS com vinculações personalizadas e caminhos físicos. Isso permite que você configure sites que escutem portas ou nomes de host específicos antes de implantar seus aplicativos.

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 uma personalização completa, você pode escrever seus próprios scripts de implantação no Windows PowerShell e informar ao Elastic Beanstalk quais scripts executar para instalar, desinstalar e reiniciar seu aplicativo.

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.

Seções

Aplicativos .NET Core
Executar vários aplicativos
Configurar sites do IIS
Usando o Roteamento de Solicitação de Aplicativo (ARR)
Configurar grupos de aplicativos
Definir implantações personalizadas
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.

exemplo aws-windows-deployment-manifest.json - Núcleo.NET


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

exemplo dotnet-core-bundle.zip


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

exemplo 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

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.

exemplo aws-windows-deployment-manifest.json - vários aplicativos


{
  "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:

Pacote de origem implantável - -v2.zip dotnet-multiapp-sample-bundle
Código fonte - dotnet-multiapp-sample-source-v2.zip

Configurar sites do IIS

Você pode configurar sites do IIS com vinculações personalizadas e caminhos físicos usando o manifesto de implantação. Isso é útil quando você precisa configurar sites que escutam 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 escuta HTTP com um número de porta específico e um caminho físico personalizado:

exemplo aws-windows-deployment-manifest.json - Configuração do site 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": "/"
        }
      }
    ]
  }
}

Neste exemplo:

Um site chamado "MyCustomSite" é criado com um caminho físico personalizado
O site tem uma ligação HTTP na porta 8080 com um nome de host específico
O aplicativo ASP.NET Core é implantado nesse site personalizado usando o parâmetro iisWebSite

Usando o Roteamento de Solicitação de Aplicativo (ARR)

Os módulos Application Request Routing (ARR) e URL Rewrite estão pré-instalados e disponíveis no Elastic Beanstalk Windows. AMIs Esses módulos permitem cenários avançados de roteamento e manipulação de URL por meio da configuração do IIS usando ebextensions ou configuração de aplicativos.

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

exemplo aws-windows-deployment-manifest.json - Configuração simples de ARR


{
  "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 configura as regras básicas de roteamento ARR:

exemplo .ebextensions/arr-config.config - Configuração básica 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 o aplicativo de back-end executado 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:

Você pode usar o modelo de out-of-process hospedagem com o servidor web Kestrel. Com esse modelo, você configura várias aplicações para serem executadas em um grupo de aplicações.
Você pode usar o modelo de hospedagem no processo. Com esse modelo, você usa vários grupos de aplicações para executar várias aplicações com apenas uma aplicação em cada grupo. Se você estiver usando o servidor IIS e precisar executar várias aplicações, deverá usar essa abordagem.

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:

exemplo web.config - para o modelo de hospedagem 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>

exemplo aws-windows-deployment-manifest.json - vários aplicativos


{
"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:

Adicione uma iisConfig seção que inclua uma subseção chamada appPools.
No bloco appPools, liste os grupos de aplicações.
Na seção deployments, defina uma seção parameters para cada aplicação.
Para cada aplicação, a seção parameters especifica um arquivo, um caminho para executá-la e um appPool no qual executá-la.

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.

exemplo aws-windows-deployment-manifest.json - um aplicativo por pool de aplicativos


{
"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 PowerShell a executar scripts no modo de 32 bits. Ele especifica três scripts: um install script (siteInstall.ps1) que é executado durante a inicialização e as implantações da instância, um uninstall script (siteUninstall.ps1) que é executado antes de instalar novas versões durante as implantações e um restart script (siteRestart.ps1) que é executado quando você seleciona Reiniciar o App Server no console de gerenciamento. AWS

exemplo aws-windows-deployment-manifest.json - implantação personalizada


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

exemplo C ustom-site-bundle .zip


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

Atenção O Javascript está desativado ou não está disponível no seu navegador.

Para usar a documentação da AWS, o Javascript deve estar ativado. Consulte as páginas de Ajuda do navegador para obter instruções.

Convenções do documento

Migração de versão principal

Referência de esquema