

Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

# Distribuzione di applicazioni.NET Windows con Elastic Beanstalk
<a name="create_deploy_NET"></a>

**Dai un'occhiata a *.NET on Developer Center AWS***  
  
Ti sei fermato al *nostro.Net Developer Center*? È il nostro sportello unico per tutto ciò che riguarda .NET AWS.  
Per ulteriori informazioni, consulta [.NET on AWS Developer Center](https://aws.amazon.com/developer/language/net).

Questo capitolo fornisce istruzioni per la configurazione e la distribuzione delle applicazioni Web ASP.NET e.NET Core per Windows su. AWS Elastic Beanstalk Elastic Beanstalk semplifica la distribuzione, la gestione e la scalabilità delle applicazioni Web.NET (Windows) utilizzando Amazon Web Services.

Puoi distribuire la tua applicazione in pochi minuti utilizzando l'Elastic Beanstalk Command Line Interface (EB CLI) o utilizzando la console Elastic Beanstalk. Dopo aver distribuito l'applicazione Elastic Beanstalk, è possibile continuare a utilizzare l'EB CLI per gestire l'applicazione e l'ambiente, oppure è possibile utilizzare la console Elastic Beanstalk o il. AWS CLI APIs

Questo capitolo fornisce i seguenti tutorial:
+ [QuickStart per.NET Core su Windows](dotnet-quickstart.md)— Step-by-step istruzioni per creare e distribuire un'applicazione Windows *Hello World* .NET Core utilizzando l'EB CLI.
+ [QuickStart per ASP.NET](aspnet-quickstart.md)— Step-by-step istruzioni per creare e distribuire un'applicazione *Hello World* ASP.NET utilizzando. AWS Toolkit for Visual Studio

Se hai bisogno di assistenza per lo sviluppo di applicazioni Windows.NET Core, puoi rivolgerti a diversi siti:
+  [Forum di sviluppo.NET](https://forums.aws.amazon.com/forum.jspa?forumID=61): pubblica le tue domande e ottieni feedback.
+ [.NET Developer Center](https://aws.amazon.com/net/): sportello unico per codice di esempio, documentazione, strumenti e risorse aggiuntive.
+ AWS Documentazione [SDK for .NET](https://aws.amazon.com/documentation/sdk-for-net/): leggi la configurazione dell'SDK e l'esecuzione di esempi di codice, le funzionalità dell'SDK e informazioni dettagliate sulle operazioni API per l'SDK.

**Nota**  
Questa piattaforma non supporta gli ambienti di lavoro. Per informazioni dettagliate, vedi [Ambienti worker Elastic Beanstalk](using-features-managing-env-tiers.md). 

**Topics**
+ [QuickStart: distribuzione di un'applicazione.NET Core su Windows su Elastic Beanstalk](dotnet-quickstart.md)
+ [QuickStart: distribuzione di un'applicazione ASP.NET su Elastic Beanstalk](aspnet-quickstart.md)
+ [Configurazione dell'ambiente di sviluppo .NET](dotnet-devenv.md)
+ [Utilizzo della piattaforma Windows Elastic Beanstalk .NET](create_deploy_NET.container.console.md)
+ [Aggiunta di un'istanza database Amazon RDS all'ambiente applicativo .NET](create_deploy_NET.rds.md)
+ [La AWS Toolkit for Visual Studio](dotnet-toolkit.md)
+ [Migrazione dell'applicazione.NET in locale a Elastic Beanstalk](dotnet-onpremmigration.md)
+ [Consigli per i componenti ritirati di Windows Server su Elastic Beanstalk](dotnet-deprecation-recommendations.md)

# QuickStart: distribuzione di un'applicazione.NET Core su Windows su Elastic Beanstalk
<a name="dotnet-quickstart"></a>

Questo QuickStart tutorial illustra il processo di creazione di un'applicazione.NET Core per Windows e la sua distribuzione in un AWS Elastic Beanstalk ambiente.

**Non per uso in produzione**  
Gli esempi sono solo a scopo dimostrativo. Non utilizzare applicazioni di esempio in produzione.

**Topics**
+ [Il tuo AWS account](#dotnet-quickstart-aws-account)
+ [Prerequisiti](#dotnet-quickstart-prereq)
+ [Passaggio 1: Creare un'applicazione.NET Core per Windows](#dotnet-quickstart-create-app)
+ [Passaggio 2: Esegui l'applicazione localmente](#dotnet-quickstart-run-local)
+ [Fase 3: Distribuire l'applicazione.NET Core su Windows con l'EB CLI](#dotnet-quickstart-deploy)
+ [Fase 4: Esegui l'applicazione su Elastic Beanstalk](#dotnet-quickstart-run-eb-ap)
+ [Fase 5: rimozione](#go-tutorial-cleanup)
+ [AWS risorse per la tua applicazione](#dotnet-quickstart-eb-resources)
+ [Fasi successive](#dotnet-quickstart-next-steps)
+ [Esegui la distribuzione con la console Elastic Beanstalk](#dotnet-quickstart-console)

## Il tuo AWS account
<a name="dotnet-quickstart-aws-account"></a>

Se non sei già un AWS cliente, devi creare un AWS account. La registrazione ti consente di accedere a Elastic Beanstalk AWS e ad altri servizi di cui hai bisogno.

Se hai già un AWS account, puoi passare a. [Prerequisiti](#dotnet-quickstart-prereq)

### Crea un AWS account
<a name="dotnet-quickstart-aws-account-procedure"></a>

#### Registrati per un Account AWS
<a name="sign-up-for-aws"></a>

Se non ne hai uno Account AWS, completa i seguenti passaggi per crearne uno.

**Per iscriverti a un Account AWS**

1. Apri la [https://portal.aws.amazon.com/billing/registrazione.](https://portal.aws.amazon.com/billing/signup)

1. Segui le istruzioni online.

   Nel corso della procedura di registrazione riceverai una telefonata o un messaggio di testo e ti verrà chiesto di inserire un codice di verifica attraverso la tastiera del telefono.

   Quando ti iscrivi a un Account AWS, *Utente root dell'account AWS*viene creato un. L’utente root dispone dell’accesso a tutte le risorse e tutti i Servizi AWS nell’account. Come best practice di sicurezza, assegna l’accesso amministrativo a un utente e utilizza solo l’utente root per eseguire [attività che richiedono l’accesso di un utente root](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_root-user.html#root-user-tasks).

AWS ti invia un'email di conferma dopo il completamento della procedura di registrazione. In qualsiasi momento, puoi visualizzare l'attività corrente del tuo account e gestirlo accedendo a [https://aws.amazon.com/](https://aws.amazon.com/)e scegliendo **Il mio account**.

#### Crea un utente con accesso amministrativo
<a name="create-an-admin"></a>

Dopo esserti registrato Account AWS, proteggi Utente root dell'account AWS AWS IAM Identity Center, abilita e crea un utente amministrativo in modo da non utilizzare l'utente root per le attività quotidiane.

**Proteggi i tuoi Utente root dell'account AWS**

1.  Accedi [Console di gestione AWS](https://console.aws.amazon.com/)come proprietario dell'account scegliendo **Utente root** e inserendo il tuo indirizzo Account AWS email. Nella pagina successiva, inserisci la password.

   Per informazioni sull’accesso utilizzando un utente root, consulta la pagina [Accedere come utente root](https://docs.aws.amazon.com/signin/latest/userguide/console-sign-in-tutorials.html#introduction-to-root-user-sign-in-tutorial) nella *Guida per l’utente di Accedi ad AWS *.

1. Abilita l’autenticazione a più fattori (MFA) per l’utente root.

   Per istruzioni, consulta [Abilitare un dispositivo MFA virtuale per l'utente Account AWS root (console)](https://docs.aws.amazon.com/IAM/latest/UserGuide/enable-virt-mfa-for-root.html) nella Guida per l'*utente IAM*.

**Crea un utente con accesso amministrativo**

1. Abilita il Centro identità IAM.

   Per istruzioni, consulta [Abilitazione del AWS IAM Identity Center](https://docs.aws.amazon.com//singlesignon/latest/userguide/get-set-up-for-idc.html) nella *Guida per l’utente di AWS IAM Identity Center *.

1. Nel Centro identità IAM, assegna l’accesso amministrativo a un utente.

   Per un tutorial sull'utilizzo di IAM Identity Center directory come fonte di identità, consulta [Configurare l'accesso utente con l'impostazione predefinita IAM Identity Center directory](https://docs.aws.amazon.com//singlesignon/latest/userguide/quick-start-default-idc.html) nella *Guida per l'AWS IAM Identity Center utente*.

**Accesso come utente amministratore**
+ Per accedere come utente del Centro identità IAM, utilizza l’URL di accesso che è stato inviato al tuo indirizzo e-mail quando hai creato l’utente del Centro identità IAM.

  Per informazioni sull'accesso utilizzando un utente IAM Identity Center, consulta [AWS Accedere al portale di accesso](https://docs.aws.amazon.com/signin/latest/userguide/iam-id-center-sign-in-tutorial.html) nella *Guida per l'Accedi ad AWS utente*.

**Assegnazione dell’accesso ad altri utenti**

1. Nel Centro identità IAM, crea un set di autorizzazioni conforme alla best practice per l’applicazione di autorizzazioni con il privilegio minimo.

   Segui le istruzioni riportate nella pagina [Creazione di un set di autorizzazioni](https://docs.aws.amazon.com//singlesignon/latest/userguide/get-started-create-a-permission-set.html) nella *Guida per l’utente di AWS IAM Identity Center *.

1. Assegna al gruppo prima gli utenti e poi l’accesso con autenticazione unica (Single Sign-On).

   Per istruzioni, consulta [Aggiungere gruppi](https://docs.aws.amazon.com//singlesignon/latest/userguide/addgroups.html) nella *Guida per l’utente di AWS IAM Identity Center *.

## Prerequisiti
<a name="dotnet-quickstart-prereq"></a>

Per seguire le procedure in questa guida, devi usare un terminale a riga di comando o una shell per eseguire i comandi. I comandi vengono visualizzati in elenchi preceduti da un simbolo di prompt (>) e dal nome della directory corrente, se appropriato.

```
C:\eb-project> this is a command
this is output
```

### CLI EB
<a name="dotnet-quickstart-prereq.ebcli"></a>

Questo tutorial utilizza l'interfaccia a riga di comando di Elastic Beanstalk (CLI EB). Per istruzioni dettagliate su come configurare e utilizzare la CLI EB, consulta [Installa EB CLI con lo script di configurazione (consigliato)](eb-cli3.md#eb-cli3-install) e [Configurazione dell'interfaccia a riga di comando EB](eb-cli3-configuration.md).

### .NET Core su Windows
<a name="dotnet-quickstart-prereq.runtime"></a>

Se non hai installato .NET SDK sul tuo computer locale, puoi installarlo seguendo il link [Download.NET](https://dotnet.microsoft.com/en-us/download) sul sito Web della [documentazione .NET](https://learn.microsoft.com/en-us/dotnet/).

Verifica l'installazione di.NET SDK eseguendo il comando seguente.

```
C:\> dotnet --info
```

## Passaggio 1: Creare un'applicazione.NET Core per Windows
<a name="dotnet-quickstart-create-app"></a>

Crea una directory di progetto.

```
C:\> mkdir eb-dotnetcore
C:\> cd eb-dotnetcore
```

Quindi, crea un esempio di applicazione di servizio RESTful web Hello World eseguendo i seguenti comandi.

```
C:\eb-dotnetcore> dotnet new web --name HelloElasticBeanstalk
C:\eb-dotnetcore> cd HelloElasticBeanstalk
```

## Passaggio 2: Esegui l'applicazione localmente
<a name="dotnet-quickstart-run-local"></a>

Esegui il comando seguente per eseguire l'applicazione localmente.

```
C:\eb-dotnetcore\HelloElasticBeasntalk> dotnet run
```

L'output dovrebbe avere un aspetto simile al testo seguente.

```
info: Microsoft.Hosting.Lifetime[14]
      Now listening on: https://localhost:7222
info: Microsoft.Hosting.Lifetime[14]
      Now listening on: http://localhost:5228
info: Microsoft.Hosting.Lifetime[0]
      Application started. Press Ctrl+C to shut down.
info: Microsoft.Hosting.Lifetime[0]
      Hosting environment: Development
info: Microsoft.Hosting.Lifetime[0]
      Content root path: C:\Users\Administrator\eb-dotnetcore\HelloElasticBeanstalk
```

**Nota**  
Il `dotnet` comando seleziona una porta a caso quando si esegue l'applicazione localmente. In questo esempio la porta è 5228. Quando distribuisci l'applicazione nell'ambiente Elastic Beanstalk, l'applicazione verrà eseguita sulla porta 5000.

Inserisci l'indirizzo URL `http://localhost:port` nel tuo browser web. Per questo esempio specifico, il comando è`http://localhost:5228`. Il browser web dovrebbe visualizzare «Hello World\$1».

## Fase 3: Distribuire l'applicazione.NET Core su Windows con l'EB CLI
<a name="dotnet-quickstart-deploy"></a>

Esegui i seguenti comandi per creare un ambiente Elastic Beanstalk per questa applicazione.

 

**Per creare un ambiente e distribuire l'applicazione.NET Core su Windows**

1. Esegui i seguenti comandi nella `HelloElasticBeanstalk` directory per pubblicare e comprimere l'applicazione.

   ```
   C:\eb-dotnetcore\HelloElasticBeasntalk> dotnet publish -o site
   C:\eb-dotnetcore\HelloElasticBeasntalk> cd site
   C:\eb-dotnetcore\HelloElasticBeasntalk\site> Compress-Archive -Path * -DestinationPath ../site.zip
   C:\eb-dotnetcore\HelloElasticBeasntalk\site> cd ..
   ```

1. Crea un nuovo file nel file `HelloElasticBeanstalk` chiamato `aws-windows-deployment-manifest.json` con il seguente contenuto: 

   ```
   {
       "manifestVersion": 1,
       "deployments": {
           "aspNetCoreWeb": [
           {
               "name": "test-dotnet-core",
               "parameters": {
                   "appBundle": "site.zip",
                   "iisPath": "/",
                   "iisWebSite": "Default Web Site"
               }
           }
           ]
       }
   }
   ```

1. Inizializza il repository della CLI EB con il comando **eb init**.

   ```
   C:\eb-dotnetcore\HelloElasticBeasntalk> eb init -p iis dotnet-windows-server-tutorial --region us-east-2
   ```

   Questo comando crea un'applicazione denominata `dotnet-windows-server-tutorial` e configura il repository locale per creare ambienti con l'ultima versione della piattaforma server Windows.

1. Crea un ambiente e distribuisci in esso l'applicazione con **eb create**: Elastic Beanstalk crea automaticamente un file zip per l'applicazione e lo avvia sulla porta 5000.

   ```
   C:\eb-dotnetcore\HelloElasticBeasntalk> eb create dotnet-windows-server-env
   ```

   Elastic Beanstalk impiega circa cinque minuti per creare l'ambiente.

## Fase 4: Esegui l'applicazione su Elastic Beanstalk
<a name="dotnet-quickstart-run-eb-ap"></a>

Una volta completato il processo di creazione dell'ambiente, apri il sito Web con. **eb open**

```
C:\eb-dotnetcore\HelloElasticBeasntalk> eb open
```

Complimenti\$1 Hai distribuito un'applicazione.NET Core su Windows con Elastic Beanstalk\$1 Si aprirà una finestra del browser che utilizza il nome di dominio creato per l'applicazione.

## Fase 5: rimozione
<a name="go-tutorial-cleanup"></a>

Puoi chiudere il tuo ambiente quando finisci di lavorare con l'applicazione. Elastic Beanstalk AWS interrompe tutte le risorse associate all'ambiente.

Per terminare l'ambiente Elastic Beanstalk con l'EB CLI, esegui il comando seguente.

```
C:\eb-dotnetcore\HelloElasticBeasntalk> eb terminate
```

## AWS risorse per la tua applicazione
<a name="dotnet-quickstart-eb-resources"></a>

Hai appena creato un'applicazione a istanza singola. Funge da semplice applicazione di esempio con una singola istanza EC2, quindi non richiede il bilanciamento del carico o la scalabilità automatica. Per le applicazioni a istanza singola Elastic Beanstalk crea le seguenti risorse: AWS 
+ **Istanza EC2**: una macchina virtuale di Amazon EC2 configurata per eseguire applicazioni Web sulla piattaforma selezionata.

  Ogni piattaforma esegue un insieme diverso di software, file di configurazione e script per supportare una versione della lingua, un framework, un container Web specifici o una determinata combinazione di tutti questi elementi. La maggior parte delle piattaforme utilizza Apache o nginx come proxy inverso che elabora il traffico web su cui viene eseguita l'app Web, inoltra le richieste all'app, fornisce asset statici e genera log degli accessi e di errore.
+ **Gruppo di sicurezza istanze**: un gruppo di sicurezza di Amazon EC2 configurato per abilitare il traffico in entrata sulla porta 80. Questa risorsa consente al traffico TTP proveniente dal load balancer di raggiungere l'istanza EC2 in esecuzione sull'app Web. Per impostazione predefinita, il traffico non è consentito su altre porte.
+ **Bucket Amazon S3**: posizione di storage per il codice sorgente, i log e altri artefatti creati quando si utilizza Elastic Beanstalk.
+ ** CloudWatch Allarmi Amazon**: due CloudWatch allarmi che monitorano il carico sulle istanze nel tuo ambiente e vengono attivati se il carico è troppo alto o troppo basso. Quando viene attivato un allarme, il gruppo Auto Scaling aumenta o diminuisce di conseguenza.
+ **CloudFormation stack**: Elastic CloudFormation Beanstalk utilizza per avviare le risorse nell'ambiente e propagare le modifiche alla configurazione. Le risorse sono definite in un modello, visualizzabile nella [console CloudFormation](https://console.aws.amazon.com/cloudformation).
+  **Nome di dominio***: un nome di dominio che indirizza alla tua app Web nel modulo. *subdomain* *region*.elasticbeanstalk.com*. 

Elastic Beanstalk gestisce tutte queste risorse. Quando arresti l'ambiente, Elastic Beanstalk termina tutte le risorse che contiene.

## Fasi successive
<a name="dotnet-quickstart-next-steps"></a>

Quando disponi di un'applicazione in esecuzione in un ambiente, puoi distribuire una nuova versione dell'applicazione o un'applicazione diversa in qualsiasi momento. La distribuzione di una nuova versione dell'applicazione è molto veloce perché non richiede il provisioning o il riavvio delle istanze EC2. Puoi anche esplorare il tuo nuovo ambiente utilizzando la console Elastic Beanstalk. Per i passaggi dettagliati, consulta [Esplora il tuo ambiente](GettingStarted.md#GettingStarted.Explore) nel capitolo *Guida introduttiva* di questa guida.

**Prova altri tutorial**  
Se desideri provare altri tutorial con diverse applicazioni di esempio, consulta. [QuickStart per ASP.NET](aspnet-quickstart.md)

Dopo aver distribuito una o due applicazioni di esempio e essere pronti per iniziare a sviluppare ed eseguire localmente .NET Core su applicazioni Windows, vedi [Configurazione dell'ambiente di sviluppo .NET](dotnet-devenv.md) 

## Esegui la distribuzione con la console Elastic Beanstalk
<a name="dotnet-quickstart-console"></a>

Puoi anche utilizzare la console Elastic Beanstalk per avviare l'applicazione di esempio. Per i passaggi dettagliati, consulta [Creare un'applicazione di esempio](GettingStarted.md#GettingStarted.CreateApp) nel capitolo *Guida introduttiva* di questa guida.

# QuickStart: distribuzione di un'applicazione ASP.NET su Elastic Beanstalk
<a name="aspnet-quickstart"></a>

Questo QuickStart tutorial illustra il processo di creazione di un'applicazione ASP.NET e la sua distribuzione in un ambiente. AWS Elastic Beanstalk 

**Non per uso in produzione**  
Gli esempi sono solo a scopo dimostrativo. Non utilizzare applicazioni di esempio in produzione.

**Topics**
+ [Il tuo AWS account](#aspnet-quickstart-aws-account)
+ [Prerequisiti](#aspnet-quickstart-prereq)
+ [Passaggio 1: Creare un'applicazione ASP.NET](#aspnet-quickstart-create-app)
+ [Passaggio 2: Esegui l'applicazione localmente](#aspnet-quickstart-run-local)
+ [Passaggio 3: distribuisci l'applicazione ASP.NET con AWS Toolkit for Visual Studio](#aspnet-quickstart-deploy)
+ [Fase 4: Esegui l'applicazione su Elastic Beanstalk](#aspnet-quickstart-run-eb-ap)
+ [Fase 5: rimozione](#aspnet-quickstart-cleanup)
+ [AWS risorse per la tua applicazione](#aspnet-quickstart-eb-resources)
+ [Fasi successive](#aspnet-quickstart-next-steps)
+ [Esegui la distribuzione con la console Elastic Beanstalk](#aspnet-quickstart-console)

## Il tuo AWS account
<a name="aspnet-quickstart-aws-account"></a>

Se non sei già AWS cliente, devi creare un AWS account. La registrazione ti consente di accedere a Elastic Beanstalk AWS e ad altri servizi di cui hai bisogno.

Se hai già un AWS account, puoi passare a. [Prerequisiti](#aspnet-quickstart-prereq)

### Crea un AWS account
<a name="aspnet-quickstart-aws-account-procedure"></a>

#### Registrati per un Account AWS
<a name="sign-up-for-aws"></a>

Se non ne hai uno Account AWS, completa i seguenti passaggi per crearne uno.

**Per iscriverti a un Account AWS**

1. Apri la [https://portal.aws.amazon.com/billing/registrazione.](https://portal.aws.amazon.com/billing/signup)

1. Segui le istruzioni online.

   Nel corso della procedura di registrazione riceverai una telefonata o un messaggio di testo e ti verrà chiesto di inserire un codice di verifica attraverso la tastiera del telefono.

   Quando ti iscrivi a un Account AWS, *Utente root dell'account AWS*viene creato un. L’utente root dispone dell’accesso a tutte le risorse e tutti i Servizi AWS nell’account. Come best practice di sicurezza, assegna l’accesso amministrativo a un utente e utilizza solo l’utente root per eseguire [attività che richiedono l’accesso di un utente root](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_root-user.html#root-user-tasks).

AWS ti invia un'email di conferma dopo il completamento della procedura di registrazione. In qualsiasi momento, puoi visualizzare l'attività corrente del tuo account e gestirlo accedendo a [https://aws.amazon.com/](https://aws.amazon.com/)e scegliendo **Il mio account**.

#### Crea un utente con accesso amministrativo
<a name="create-an-admin"></a>

Dopo esserti registrato Account AWS, proteggi Utente root dell'account AWS AWS IAM Identity Center, abilita e crea un utente amministrativo in modo da non utilizzare l'utente root per le attività quotidiane.

**Proteggi i tuoi Utente root dell'account AWS**

1.  Accedi [Console di gestione AWS](https://console.aws.amazon.com/)come proprietario dell'account scegliendo **Utente root** e inserendo il tuo indirizzo Account AWS email. Nella pagina successiva, inserisci la password.

   Per informazioni sull’accesso utilizzando un utente root, consulta la pagina [Accedere come utente root](https://docs.aws.amazon.com/signin/latest/userguide/console-sign-in-tutorials.html#introduction-to-root-user-sign-in-tutorial) nella *Guida per l’utente di Accedi ad AWS *.

1. Abilita l’autenticazione a più fattori (MFA) per l’utente root.

   Per istruzioni, consulta [Abilitare un dispositivo MFA virtuale per l'utente Account AWS root (console)](https://docs.aws.amazon.com/IAM/latest/UserGuide/enable-virt-mfa-for-root.html) nella Guida per l'*utente IAM*.

**Crea un utente con accesso amministrativo**

1. Abilita il Centro identità IAM.

   Per istruzioni, consulta [Abilitazione del AWS IAM Identity Center](https://docs.aws.amazon.com//singlesignon/latest/userguide/get-set-up-for-idc.html) nella *Guida per l’utente di AWS IAM Identity Center *.

1. Nel Centro identità IAM, assegna l’accesso amministrativo a un utente.

   Per un tutorial sull'utilizzo di IAM Identity Center directory come fonte di identità, consulta [Configurare l'accesso utente con l'impostazione predefinita IAM Identity Center directory](https://docs.aws.amazon.com//singlesignon/latest/userguide/quick-start-default-idc.html) nella *Guida per l'AWS IAM Identity Center utente*.

**Accesso come utente amministratore**
+ Per accedere come utente del Centro identità IAM, utilizza l’URL di accesso che è stato inviato al tuo indirizzo e-mail quando hai creato l’utente del Centro identità IAM.

  Per informazioni sull'accesso utilizzando un utente IAM Identity Center, consulta [AWS Accedere al portale di accesso](https://docs.aws.amazon.com/signin/latest/userguide/iam-id-center-sign-in-tutorial.html) nella *Guida per l'Accedi ad AWS utente*.

**Assegnazione dell’accesso ad altri utenti**

1. Nel Centro identità IAM, crea un set di autorizzazioni conforme alla best practice per l’applicazione di autorizzazioni con il privilegio minimo.

   Segui le istruzioni riportate nella pagina [Creazione di un set di autorizzazioni](https://docs.aws.amazon.com//singlesignon/latest/userguide/get-started-create-a-permission-set.html) nella *Guida per l’utente di AWS IAM Identity Center *.

1. Assegna al gruppo prima gli utenti e poi l’accesso con autenticazione unica (Single Sign-On).

   Per istruzioni, consulta [Aggiungere gruppi](https://docs.aws.amazon.com//singlesignon/latest/userguide/addgroups.html) nella *Guida per l’utente di AWS IAM Identity Center *.

## Prerequisiti
<a name="aspnet-quickstart-prereq"></a>

Questo QuickStart tutorial illustra come creare un'applicazione «Hello World» e distribuirla in un ambiente Elastic Beanstalk con Visual Studio e il. AWS Toolkit for Visual Studio

### Visual Studio
<a name="aspnet-quickstart-prereq.vs"></a>

[Per scaricare e installare Visual Studio, segui le istruzioni nella pagina di download di Visual Studio.](https://visualstudio.microsoft.com/downloads/) Questo esempio utilizza Visual Studio 2022. Durante l'installazione di Visual Studio, seleziona questi elementi specifici:
+ Nella scheda **Carichi di lavoro**, seleziona **ASP.NET e sviluppo web**.
+ Nella scheda **Componenti individuali**, seleziona gli **strumenti di sviluppo.NET Framework 4.8** e i modelli di **progetti.NET Framework e** di elementi.

### AWS Toolkit for Visual Studio
<a name="aspnet-quickstart-prereq.aws-vs-tk"></a>

Per scaricare e configurare, AWS Toolkit for Visual Studio segui le istruzioni nell'argomento Guida [introduttiva](https://docs.aws.amazon.com/toolkit-for-visual-studio/latest/user-guide/getting-set-up.html) della Guida per l' AWS Toolkit for Visual Studio utente. 

## Passaggio 1: Creare un'applicazione ASP.NET
<a name="aspnet-quickstart-create-app"></a>

Successivamente, crea un'applicazione da distribuire in un ambiente Elastic Beanstalk. Creeremo un'applicazione web ASP.NET «Hello World».

**Per creare un'applicazione ASP.NET**

1. Avvia Visual Studio. Nel menu **File**, seleziona **Nuovo**, quindi **Progetto**.

1. Viene visualizzata la finestra di dialogo **Crea un nuovo progetto**. Seleziona **l'applicazione Web ASP.NET (.NET Framework)**, quindi seleziona **Avanti**.

1. Nella finestra di dialogo **Configura il nuovo progetto**, inserisci `eb-aspnet` il **nome del progetto**. **Dal menu a discesa **Framework** **seleziona.NET Framework 4.8**, quindi seleziona Crea.**

   Nota la directory del progetto. In questo esempio, la directory del progetto è`C:\Users\Administrator\source\repos\eb-aspnet\eb-aspnet`.

1. Viene visualizzata la finestra di dialogo **Crea una nuova applicazione Web ASP.NET**. Seleziona il modello **vuoto**. Quindi seleziona **Crea**.

   A questo punto, hai creato un progetto di applicazione Web ASP.NET vuoto utilizzando Visual Studio. Successivamente, creeremo un modulo Web che fungerà da punto di ingresso per l'applicazione Web ASP.NET.

1. Dal menu **Progetto**, seleziona **Aggiungi nuovo elemento**. Nella pagina **Aggiungi nuovo elemento**, seleziona **Modulo Web** e assegnagli un nome`Default.aspx`. Quindi seleziona **Aggiungi**.

1. Aggiungi quanto segue a `Default.aspx:`

   ```
   <%@ Page Language="C#" AutoEventWireup="true" CodeBehind="Default.aspx.cs" Inherits="eb_aspnet.Default" %>
   
   <!DOCTYPE html>
   
   <html xmlns="https://www.w3.org/1999/xhtml">
   <head runat="server">
       <title>Hello Elastic Beanstalk!</title>
   </head>
   <body>
       <form id="body" runat="server">
           <div>
               Hello Elastic Beanstalk! This is an ASP.NET on Windows Server application.
           </div>
       </form>
   </body>
   </html>
   ```

## Passaggio 2: Esegui l'applicazione localmente
<a name="aspnet-quickstart-run-local"></a>

In Visual Studio, dal menu **Debug** seleziona **Avvia debug** per eseguire l'applicazione localmente. La pagina dovrebbe mostrare «Hello Elastic Beanstalk\$1 Si tratta di un'applicazione ASP.NET su Windows Server».

## Passaggio 3: distribuisci l'applicazione ASP.NET con AWS Toolkit for Visual Studio
<a name="aspnet-quickstart-deploy"></a>

Segui questi passaggi per creare un ambiente Elastic Beanstalk e distribuirvi la nuova applicazione.

**Per creare un ambiente e distribuire l'applicazione ASP.NET**

1. In **Solution Explorer**, fai clic con il pulsante destro del mouse sull'applicazione, quindi seleziona **Pubblica su**. AWS Elastic Beanstalk

1. Scegli un nome per la tua nuova applicazione e ambiente Elastic Beanstalk.

1. Oltre questo punto, puoi procedere con le impostazioni predefinite fornite da Elastic Beanstalk o modificare le opzioni e le impostazioni a tuo piacimento.

1. ****Nella pagina di revisione, seleziona Distribuisci.**** Questo comprimerà la tua applicazione Web ASP.NET e la distribuirà su Elastic Beanstalk.

   Elastic Beanstalk impiega circa cinque minuti per creare l'ambiente. La funzione di distribuzione di Elastic Beanstalk monitorerà il tuo ambiente esistente finché non sarà disponibile con il codice appena distribuito. Nella scheda **Env: < **environment name** >**, vedrai lo stato del tuo ambiente.

## Fase 4: Esegui l'applicazione su Elastic Beanstalk
<a name="aspnet-quickstart-run-eb-ap"></a>

Una volta completato il processo di creazione dell'ambiente, la scheda **Env: < **environment name** >** mostra le informazioni sull'ambiente e sull'applicazione, incluso l'URL del dominio per avviare l'applicazione. Seleziona questo URL in questa scheda o copialo e incollalo nel tuo browser web.

Complimenti\$1 Hai distribuito un'applicazione ASP.NET con Elastic Beanstalk\$1

## Fase 5: rimozione
<a name="aspnet-quickstart-cleanup"></a>

Quando hai finito di lavorare con l'applicazione, puoi chiudere il tuo ambiente in. AWS Toolkit for Visual Studio

**Per terminare l'ambiente**

1. Espandi il nodo Elastic Beanstalk e il nodo applicazione in **AWS Explorer**. Fai clic con il pulsante destro del mouse sull'ambiente dell'applicazione e seleziona **Terminate Environment (Termina ambiente)**.

1. Quando richiesto, seleziona **Yes (Sì)** per confermare che intendi terminare l'ambiente. Elastic Beanstalk impiegherà alcuni minuti per AWS terminare le risorse in esecuzione nell'ambiente.

## AWS risorse per la tua applicazione
<a name="aspnet-quickstart-eb-resources"></a>

Hai appena creato un'applicazione a istanza singola. Funge da semplice applicazione di esempio con una singola istanza EC2, quindi non richiede il bilanciamento del carico o la scalabilità automatica. Per le applicazioni a istanza singola Elastic Beanstalk crea le seguenti risorse: AWS 
+ **Istanza EC2**: una macchina virtuale di Amazon EC2 configurata per eseguire applicazioni Web sulla piattaforma selezionata.

  Ogni piattaforma esegue un insieme diverso di software, file di configurazione e script per supportare una versione della lingua, un framework, un container Web specifici o una determinata combinazione di tutti questi elementi. La maggior parte delle piattaforme utilizza Apache o nginx come proxy inverso che elabora il traffico web su cui viene eseguita l'app Web, inoltra le richieste all'app, fornisce asset statici e genera log degli accessi e di errore.
+ **Gruppo di sicurezza istanze**: un gruppo di sicurezza di Amazon EC2 configurato per abilitare il traffico in entrata sulla porta 80. Questa risorsa consente al traffico TTP proveniente dal load balancer di raggiungere l'istanza EC2 in esecuzione sull'app Web. Per impostazione predefinita, il traffico non è consentito su altre porte.
+ **Bucket Amazon S3**: posizione di storage per il codice sorgente, i log e altri artefatti creati quando si utilizza Elastic Beanstalk.
+ ** CloudWatch Allarmi Amazon**: due CloudWatch allarmi che monitorano il carico sulle istanze nel tuo ambiente e vengono attivati se il carico è troppo alto o troppo basso. Quando viene attivato un allarme, il gruppo Auto Scaling aumenta o diminuisce di conseguenza.
+ **CloudFormation stack**: Elastic CloudFormation Beanstalk utilizza per avviare le risorse nell'ambiente e propagare le modifiche alla configurazione. Le risorse sono definite in un modello, visualizzabile nella [console CloudFormation](https://console.aws.amazon.com/cloudformation).
+  **Nome di dominio***: un nome di dominio che indirizza alla tua app Web nel modulo. *subdomain* *region*.elasticbeanstalk.com*. 

Elastic Beanstalk gestisce tutte queste risorse. Quando arresti l'ambiente, Elastic Beanstalk termina tutte le risorse che contiene.

## Fasi successive
<a name="aspnet-quickstart-next-steps"></a>

Quando disponi di un'applicazione in esecuzione in un ambiente, puoi distribuire una nuova versione dell'applicazione o un'applicazione diversa in qualsiasi momento. La distribuzione di una nuova versione dell'applicazione è molto veloce perché non richiede il provisioning o il riavvio delle istanze EC2. Puoi anche esplorare il tuo nuovo ambiente utilizzando la console Elastic Beanstalk. Per i passaggi dettagliati, consulta [Esplora il tuo ambiente](GettingStarted.md#GettingStarted.Explore) nel capitolo *Guida introduttiva* di questa guida.

**Prova altri tutorial**  
Se desideri provare altri tutorial con diverse applicazioni di esempio, consulta. [QuickStart per.NET Core su Windows](dotnet-quickstart.md)

Dopo aver distribuito una o due applicazioni di esempio e essere pronti per iniziare a sviluppare ed eseguire applicazioni ASP.NET localmente, vedi [Configurazione dell'ambiente di sviluppo .NET](dotnet-devenv.md) 

## Esegui la distribuzione con la console Elastic Beanstalk
<a name="aspnet-quickstart-console"></a>

Puoi anche utilizzare la console Elastic Beanstalk per avviare l'applicazione di esempio. Per i passaggi dettagliati, consulta [Creare un'applicazione di esempio](GettingStarted.md#GettingStarted.CreateApp) nel capitolo *Guida introduttiva* di questa guida.

# Configurazione dell'ambiente di sviluppo .NET
<a name="dotnet-devenv"></a>

Questo argomento fornisce istruzioni per configurare un ambiente di sviluppo.NET Windows per testare l'applicazione localmente prima di distribuirla su. AWS Elastic Beanstalk Fa inoltre riferimento a siti Web che forniscono istruzioni di installazione per strumenti utili.

**Topics**
+ [Installazione di un IDE](#dotnet-devenv-ide)
+ [Installazione di AWS Toolkit for Visual Studio](#dotnet-devenv-toolkit)

Se devi gestire AWS le risorse dall'interno dell'applicazione, installa l' AWS SDK for .NET. Ad esempio, è possibile usare Amazon S3 per archiviare e recuperare i dati.

Con AWS SDK for .NET, puoi iniziare in pochi minuti con un unico pacchetto scaricabile completo di modelli di progetto di Visual Studio, libreria.NET, AWS esempi di codice C\$1 e documentazione. In C\$1 vengono forniti esempi pratici su come utilizzare le librerie per creare applicazioni. Tutorial video e documentazione di riferimento vengono forniti online per aiutarti a scoprire come utilizzare le librerie e gli esempi di codice.

Visita la [homepage di SDK AWS per .NET](https://aws.amazon.com/sdk-for-net/) per ulteriori informazioni e istruzioni di installazione.

## Installazione di un IDE
<a name="dotnet-devenv-ide"></a>

Gli ambienti di sviluppo integrati (IDEs) offrono un'ampia gamma di funzionalità che facilitano lo sviluppo di applicazioni. Se non hai utilizzato un IDE per lo sviluppo .NET, prova Visual Studio Community per iniziare.

Visita la pagina di [Visual Studio Community](https://www.visualstudio.com/vs/community/) per scaricare e installare Visual Studio Community.

## Installazione di AWS Toolkit for Visual Studio
<a name="dotnet-devenv-toolkit"></a>

[AWS Toolkit for Visual Studio](dotnet-toolkit.md)Si tratta di un plug-in open source per l'IDE di Visual Studio che semplifica lo sviluppo, il debug e la distribuzione di applicazioni.NET utilizzando. AWS Visita la [home page di Toolkit for Visual Studio](https://aws.amazon.com/visualstudio/) per le istruzioni di installazione.

# Utilizzo della piattaforma Windows Elastic Beanstalk .NET
<a name="create_deploy_NET.container.console"></a>

Questo argomento descrive come configurare, creare ed eseguire le applicazioni Web ASP.NET e.NET Core Windows su Elastic Beanstalk.

AWS Elastic Beanstalk supporta diverse piattaforme per diverse versioni del framework di programmazione .NET e di Windows Server. Consulta la sezione relativa a [.NET su Windows Server con IIS](https://docs.aws.amazon.com/elasticbeanstalk/latest/platforms/platforms-supported.html#platforms-supported.net) nel documento sulle *piattaforme AWS Elastic Beanstalk * per un elenco completo.

Elastic [Beanstalk offre](command-options.md) opzioni di configurazione che puoi utilizzare per personalizzare il software che viene eseguito EC2 sulle istanze nell'ambiente Elastic Beanstalk. Puoi configurare le variabili di ambiente necessarie all'applicazione, attivare la rotazione dei log in Amazon S3 e configurare le impostazioni del framework .NET.

Sono disponibili opzioni di configurazione specifiche della piattaforma nella console Elastic Beanstalk per la [modifica della configurazione di un ambiente in esecuzione](environment-configuration-methods-after.md). Per conservare la configurazione dell'ambiente una volta terminata, puoi utilizzare [configurazioni salvate](environment-configuration-savedconfig.md) per salvare le impostazioni e applicarle successivamente a un altro ambiente.

Per salvare le impostazioni nel codice sorgente, puoi includere i [file di configurazione](ebextensions.md). Le impostazioni nei file di configurazione vengono applicate ogni volta che crei un ambiente o distribuisci l'applicazione. Puoi inoltre utilizzare i file di configurazione per installare pacchetti, eseguire script o altre operazioni di personalizzazione delle istanze durante le distribuzioni.

Le impostazioni applicate nella console Elastic Beanstalk sostituiscono le stesse impostazioni nei file di configurazione, se esistenti. Ciò ti consente di disporre di impostazioni predefinite nei file di configurazione, sostituibili con impostazioni specifiche per l'ambiente nella console. Per ulteriori informazioni sulla precedenza e altri metodi di modifica delle impostazioni, consulta [Opzioni di configurazione](command-options.md).

## Configurazione dell'ambiente.NET nella console Elastic Beanstalk
<a name="dotnet-console"></a>

Puoi utilizzare la console Elastic Beanstalk per attivare la rotazione dei log in Amazon S3, configurare variabili che l'applicazione è in grado di leggere dall'ambiente e modificare le impostazioni del framework .NET.

**Per configurare l'ambiente.NET nella console Elastic Beanstalk**

1. Apri la console [Elastic Beanstalk](https://console.aws.amazon.com/elasticbeanstalk) e, **nell'elenco Regioni, seleziona la tua**. Regione AWS

1. Nel pannello di navigazione selezionare **Environments** (Ambienti), quindi selezionare il nome dell'ambiente dall'elenco.

1. Nel riquadro di navigazione, seleziona **Configuration** (Configurazione).

1. Nella categoria di configurazione **Updates, monitoring, and logging** (Aggiornamenti, monitoraggio e registrazione), scegli **Edit** (Modifica).

### Opzioni del contenitore
<a name="dotnet-console-framework"></a>
+ **Target .NET runtime (Runtime target .NET)**: impostare questa opzione su `2.0` per eseguire CLR v2.
+ **Enable 32-bit applications (Abilita le applicazioni a 32 bit)**: impostare questa opzione su `True` per eseguire applicazioni a 32 bit.

### Opzioni di log
<a name="dotnet-console-logs"></a>

La sezione Log Options (Opzioni di log) ha due impostazioni:
+ **Instance profile** (Profilo dell'istanza): specifica il profilo dell'istanza che dispone dell'autorizzazione ad accedere al bucket Amazon S3 associato all'applicazione.
+ **Abilita la rotazione dei file di registro su Amazon S3**: specifica se i file di log per le EC2 istanze Amazon dell'applicazione vengono copiati nel bucket Amazon S3 associato all'applicazione.

### Proprietà dell'ambiente
<a name="dotnet-console-properties"></a>

La sezione **Environment Properties** consente di specificare le impostazioni di configurazione dell'ambiente sulle EC2 istanze Amazon su cui è in esecuzione l'applicazione. Queste impostazioni sono passate come coppie chiave-valore all'applicazione. Utilizza `System.GetEnvironmentVariable` per leggerle. In `web.config` e nelle proprietà dell'ambiente possono esservi chiavi identiche. Utilizza lo spazio dei nomi `System.Configuration` per leggere i valori da `web.config`.

```
NameValueCollection appConfig = ConfigurationManager.AppSettings;
string endpoint = appConfig["API_ENDPOINT"];
```

Per ulteriori informazioni, consulta [Variabili di ambiente e altre impostazioni software](environments-cfg-softwaresettings.md).

## Spazio dei nomi aws:elasticbeanstalk:container:dotnet:apppool
<a name="dotnet-namespaces"></a>

Puoi utilizzare un [file di configurazione](ebextensions.md) per impostare le opzioni di configurazione ed eseguire alte attività di configurazione delle istanze durante le distribuzioni. Le opzioni di configurazione possono essere [specifiche della piattaforma](command-options-specific.md) o essere applicate a [tutte le piattaforme](command-options-general.md) del servizio Elastic Beanstalk nel suo complesso. *Le opzioni di configurazione sono organizzate in namespace.*

La piattaforma .NET definisce le opzioni nel namespace `aws:elasticbeanstalk:container:dotnet:apppool` che puoi utilizzare per configurare il runtime .NET.

Il seguente file di configurazione di esempio mostra le impostazioni per ognuna delle opzioni disponibili in questo namespace:

**Example .ebextensions/dotnet-settings.config**  

```
option_settings:
  aws:elasticbeanstalk:container:dotnet:apppool:
    Target Runtime: 2.0
    Enable 32-bit Applications: True
```

In Elastic Beanstalk sono disponibili varie opzioni di configurazione per la personalizzazione dell'ambiente. Oltre ai file di configurazione, puoi impostare le opzioni di configurazione tramite la console, le configurazioni salvate, la CLI EB o AWS CLI. Per ulteriori informazioni, consulta [Opzioni di configurazione](command-options.md).

# Migrazione tra le versioni principali della piattaforma server Windows di Elastic Beanstalk
<a name="dotnet-v2migration"></a>

AWS Elastic Beanstalk ha avuto diverse versioni principali della sua piattaforma Windows Server. Questa pagina descrive i miglioramenti più significativi per ogni versione principale e cosa occorre considerare prima di eseguire la migrazione a una versione più recente.

La versione corrente della piattaforma Windows Server è la versione 2 (v2). Se l'applicazione usa qualsiasi versione della piattaforma Windows Server precedente a v2, ti consigliamo di eseguire la migrazione a v2.

## Novità delle versioni principali della piattaforma Windows Server
<a name="dotnet-v2migration.diffs"></a>

### Piattaforma Windows Server V2
<a name="dotnet-v2migration.diffs.v2"></a>

La versione 2 (v2) della piattaforma Windows Server di Elastic Beanstalk è stata resa [disponibile a febbraio 2019](https://docs.aws.amazon.com/elasticbeanstalk/latest/relnotes/release-2019-02-21-windows-v2.html). La versione V2 avvicina il funzionamento della piattaforma Windows Server a quello delle piattaforme basate su Linux di Elastic Beanstalk in molti modi importanti. La versione V2 è completamente compatibile con la versione v1 e questo semplifica la migrazione dalla versione v1.

La piattaforma Windows Server ora supporta quanto segue:
+ *Funzione Versioni multiple*: ogni versione ottiene un nuovo numero di versione e puoi fare riferimento alle versioni precedenti, ancora disponibili, quando crei e gestisci gli ambienti.
+ *Integrità migliorata*: per informazioni dettagliate, consulta [Reportistica e monitoraggio dello stato di salute migliorati in Elastic Beanstalk](health-enhanced.md).
+ Distribuzioni *Non modificabile* e *In sequenza con un batch aggiuntivo* – Per informazioni dettagliate sulle policy di distribuzione, consulta [Distribuzione di applicazioni in ambienti Elastic Beanstalk](using-features.deploy-existing-version.md).
+ *Aggiornamenti non modificabili*: per informazioni dettagliate sui tipi di aggiornamento, consulta [Modifiche di configurazione](environments-updating.md).
+ *Aggiornamenti gestiti della piattaforma*: per informazioni dettagliate, consulta [Aggiornamenti gestiti della piattaforma](environment-platform-update-managed.md).

**Nota**  
Le nuove caratteristiche di distribuzione e aggiornamento dipendono dallo stato avanzato. Abilita stato avanzato per utilizzarle. Per informazioni dettagliate, consulta [Abilitazione del reporting dello stato avanzato Elastic Beanstalk](health-enhanced-enable.md).

### Piattaforma Windows Server V1
<a name="dotnet-v2migration.diffs.v1"></a>

La versione 1.0.0 (v1) della piattaforma Windows Server di Elastic Beanstalk è stata resa disponibile a ottobre 2015. Questa versione cambia l'ordine in cui Elastic Beanstalk elabora i comandi nei [file di configurazione](ebextensions.md) durante la creazione dell'ambiente e gli aggiornamenti.

Le versioni precedenti della piattaforma non dispongono di un numero di versione nel nome dello stack della soluzione:
+ Windows Server 2012 R2 (64 bit) con IIS 8.5 in esecuzione
+ Windows Server Core 2012 R2 (64 bit) con IIS 8.5 in esecuzione
+ Windows Server 2012 (64 bit) con IIS 8 in esecuzione
+ Windows Server 2008 R2 (64 bit) con IIS 7.5 in esecuzione

Nelle versioni precedenti l'ordine di elaborazione per i file di configurazione è incoerente. Durante la creazione dell'ambiente, `Container Commands` viene eseguito dopo che il codice sorgente dell'applicazione viene distribuito su IIS. Durante una distribuzione in un ambiente di esecuzione, i comandi del container vengono eseguiti prima della distribuzione della nuova versione. Durante un aumento del dimensionamento, i file di configurazione non vengono elaborati.

Oltre a questo, IIS viene avviato prima dell'esecuzione dei comandi del container. Questo comportamento ha portato alcuni clienti a implementare soluzioni alternative nei comandi dei container, con una pausa del server IIS prima dell'esecuzione dei comandi e con un avvio successivo al completamento.

La versione 1 corregge l'incoerenza e avvicina il comportamento della piattaforma Windows Server a quello delle piattaforme basate su Linux di Elastic Beanstalk. Nella piattaforma v1, Elastic Beanstalk esegue sempre i comandi dei container prima di avviare il server IIS.

La soluzione della piattaforma v1 specifica `v1` dopo la versione di Windows Server:
+ Windows Server 2012 R2 (64 bit) v1.1.0 con IIS 8.5 in esecuzione
+ Windows Server Core 2012 R2 (64 bit) v1.1.0 con IIS 8.5 in esecuzione
+ Windows Server 2012 (64 bit) v1.1.0 con IIS 8 in esecuzione
+ Windows Server 2008 R2 (64 bit) v1.1.0 con IIS 7.5 in esecuzione

Inoltre, la piattaforma v1 estrae il contenuto del bundle di origine dell'applicazione in `C:\staging\` prima dell'esecuzione dei comandi dei container. Quando i comandi container hanno completato l'operazione, i contenuti di questa cartella vengono compressi in un file .zip e distribuiti in IIS. Questo flusso di lavoro consente di modificare i contenuti del tuo bundle di origine dell'applicazione con comandi o con uno script prima della distribuzione.

## Migrazione da versioni principali della piattaforma Windows Server
<a name="dotnet-v2migration.migration"></a>

Questa sezione contiene alcune considerazioni sulla migrazione di cui tenere conto prima di aggiornare l'ambiente. Per aggiornare la piattaforma dell'ambiente a una versione più recente, consulta [Aggiornamento della versione della piattaforma dell'ambiente Elastic Beanstalk](using-features.platform.upgrade.md).

### Da V1 verso V2
<a name="dotnet-v2migration.migration.fromv1"></a>

La piattaforma Windows Server v2 non supporta .NET Core 1.x e 2.0. Se esegui la migrazione dell'applicazione da Windows Server v1 a v2 e l'applicazione utilizza una di queste versioni .NET Core, aggiorna l'applicazione a una versione .NET Core supportata da v2. Per un elenco delle versioni supportate, consulta [.NET su Windows Server con IIS](https://docs.aws.amazon.com/elasticbeanstalk/latest/platforms/platforms-supported.html#platforms-supported.net) in *Piattaforme AWS Elastic Beanstalk *.

Se l'applicazione utilizza una Amazon Machine Image (AMI) personalizzata, crea una nuova AMI personalizzata in base all’AMI della piattaforma di Windows Server v2. Per ulteriori informazioni, vedi [Utilizzo di un'immagine Amazon Machine Image (AMI) personalizzata nell'ambiente Elastic Beanstalk](using-features.customenv.md).

**Nota**  
Le caratteristiche di distribuzione e aggiornamento che sono nuove per Windows Server v2 dipendono dallo stato avanzato. Quando si esegue la migrazione di un ambiente a v2, lo stato avanzato è disabilitato. Abilitarlo per utilizzare queste caratteristiche. Per informazioni dettagliate, consulta [Abilitazione del reporting dello stato avanzato Elastic Beanstalk](health-enhanced-enable.md).

### Da versioni precedenti alla versione V1
<a name="dotnet-v2migration.migration.fromv0"></a>

Oltre alle considerazioni sulla migrazione da v1, se esegui la migrazione dell'applicazione da uno stack di soluzioni Windows Server che è precedente alla versione v1 e usi attualmente comandi dei container, rimuovi tutti i comandi aggiunti per risolvere le incoerenze di elaborazione quando esegui la migrazione a una versione più recente. A partire da v1, i comandi del container vengono sicuramente eseguiti completamente prima dell'origine dell'applicazione che viene distribuita e prima dell'avvio di IIS. Questo consente di apportare eventuali modifiche all'origine in `C:\staging` e modificare i file di configurazione IIS durante questa fase senza problemi.

Ad esempio, puoi utilizzare per AWS CLI scaricare un file DLL nella sorgente dell'applicazione da Amazon S3:

`.ebextensions\copy-dll.config`

```
container_commands:
  copy-dll:
    command: aws s3 cp s3://amzn-s3-demo-bucket/dlls/large-dll.dll .\lib\
```

Per ulteriori informazioni sull'utilizzo dei file di configurazione, consulta [Personalizzazione avanzata dell'ambiente con i file di configurazione (`.ebextensions`)](ebextensions.md).

# Esecuzione di più applicazioni e delle applicazioni ASP.NET Core con un manifest di distribuzione
<a name="dotnet-manifest"></a>

È possibile utilizzare un manifest di distribuzione per indicare a Elastic Beanstalk come distribuire l'applicazione. Utilizzando questo metodo, non è necessario utilizzare `MSDeploy` per generare un bundle di origine per una singola applicazione ASP.NET che viene eseguita nel percorso root del sito Web. Piuttosto, è possibile utilizzare un file manifest per eseguire più applicazioni in percorsi diversi. In alternativa, puoi chiedere a Elastic Beanstalk di distribuire ed eseguire l'app con ASP.NET Core. È inoltre possibile utilizzare un manifest di distribuzione per configurare un pool di applicazioni in cui eseguire le applicazioni.

I manifest di distribuzione aggiungono il supporto per [Applicazioni .NET Core](#dotnet-manifest-dotnetcore) su Elastic Beanstalk. È possibile distribuire un'applicazione .NET Framework senza un manifest di distribuzione. Tuttavia, le applicazioni .NET Core richiedono un manifest di distribuzione per essere eseguite su Elastic Beanstalk. Quando utilizzi un manifest di distribuzione, è necessario creare un archivio del sito per ogni applicazione e quindi raggruppare gli archivi del sito in un secondo archivio ZIP che contiene il manifest di distribuzione.

I manifest di distribuzione aggiungono anche la possibilità di [eseguire più applicazioni in diversi percorsi](#dotnet-manifest-multiapp). Un manifest di distribuzione definisce una gamma di obiettivi di distribuzione, ognuno con un archivio del sito e un percorso su cui IIS dovrebbe eseguirlo. Ad esempio, è possibile eseguire un'API Web nel percorso `/api` per servire richieste asincrone e un'app Web nel percorso root che utilizza l'API.

È possibile utilizzare un manifesto di distribuzione per [configurare i siti Web IIS con collegamenti e percorsi fisici personalizzati](#dotnet-manifest-websites). Ciò consente di configurare siti Web che ascoltano su porte o nomi host specifici prima di distribuire le applicazioni.

È inoltre possibile utilizzare un manifest di distribuzione per [eseguire più applicazioni utilizzando pool di applicazioni in IIS o Kestrel](#dotnet-manifest-apppool). È possibile configurare un pool di applicazioni per riavviare le proprie applicazioni periodicamente, eseguire applicazioni a 32 bit o utilizzare una versione specifica del runtime di .NET Framework.

Per una personalizzazione completa, puoi [scrivere i tuoi script di distribuzione](#dotnet-manifest-custom) in Windows PowerShell e indicare a Elastic Beanstalk quali script eseguire per installare, disinstallare e riavviare l'applicazione.

I manifest di distribuzione e le relative caratteristiche richiedono una piattaforma Windows Server [versione 1.2.0 o più recente](dotnet-v2migration.md).

[Per informazioni dettagliate su tutte le opzioni di configurazione, le proprietà e le funzionalità avanzate disponibili, come ignorare le reimpostazioni di IIS, consulta il riferimento allo schema del manifesto di distribuzione.](dotnet-manifest-schema.md)

**Topics**
+ [App .NET Core](#dotnet-manifest-dotnetcore)
+ [Esecuzione di più applicazioni](#dotnet-manifest-multiapp)
+ [Configurazione dei siti Web IIS](#dotnet-manifest-websites)
+ [Utilizzo dell'Application Request Routing (ARR)](#dotnet-manifest-arr)
+ [Configurazione dei pool delle applicazioni](#dotnet-manifest-apppool)
+ [Definizione delle distribuzioni personalizzate](#dotnet-manifest-custom)
+ [Riferimento allo schema del manifesto di distribuzione](dotnet-manifest-schema.md)

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

È possibile utilizzare un manifest di implementazione per eseguire applicazioni .NET Core su Elastic Beanstalk. .NET Core è una versione multipiattaforma di .NET fornita con uno strumento a riga di comando (`dotnet`). È possibile utilizzarlo per generare un'applicazione, eseguirla in locale e prepararla per la pubblicazione.

Per eseguire un'applicazione .NET Core su Elastic Beanstalk, esegui `dotnet publish` e raggruppa l'output in un archivio ZIP senza includere le directory. Posiziona l'archivio del sito in un bundle di origine con un manifest di distribuzione con una destinazione di distribuzione di tipo `aspNetCoreWeb`.

Il seguente manifest di distribuzione esegue un'applicazione .NET Core da un archivio del sito denominato `dotnet-core-app.zip` al percorso root.

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

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

Raggruppa il manifest e l'archivio del sito in un archivio ZIP per creare un bundle di origine.

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

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

L'archivio del sito contiene il codice compilato dell'applicazione, le dipendenze e il file `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
```

## Esecuzione di più applicazioni
<a name="dotnet-manifest-multiapp"></a>

È possibile eseguire più applicazioni con un manifest di distribuzione definendo più target di distribuzione.

Il seguente manifesto di distribuzione configura due applicazioni .NET Core. L'`WebApiSampleApp`applicazione implementa una semplice API web e serve richieste asincrone sul percorso. `/api` `DotNetSampleApp` è un'applicazione Web che fornisce richieste al percorso root.

**Example aws-windows-deployment-manifest.json: più app**  

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

Un'applicazione di esempio con più applicazioni è disponibile qui:
+ **[Pacchetto sorgente distribuibile - -v2.zip dotnet-multiapp-sample-bundle](samples/dotnet-multiapp-sample-bundle-v2.zip)**
+ **[Codice sorgente: -v2.zip dotnet-multiapp-sample-source](samples/dotnet-multiapp-sample-source-v2.zip)**

## Configurazione dei siti Web IIS
<a name="dotnet-manifest-websites"></a>

È possibile configurare i siti Web IIS con collegamenti e percorsi fisici personalizzati utilizzando il manifesto di distribuzione. Ciò è utile quando è necessario configurare siti Web che ascoltano su porte specifiche, utilizzano nomi host personalizzati o forniscono contenuti da directory specifiche.

Il seguente manifesto di distribuzione configura un sito Web IIS personalizzato che ascolta su HTTP con un numero di porta specifico e un percorso fisico personalizzato:

**Example aws-windows-deployment-manifest.json - configurazione del sito Web 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": "/"
        }
      }
    ]
  }
}
```

In questo esempio:
+ Un sito Web denominato "MyCustomSite" viene creato con un percorso fisico personalizzato
+ Il sito Web ha un'associazione HTTP sulla porta 8080 con un nome host specifico
+ L'applicazione ASP.NET Core viene distribuita su questo sito Web personalizzato utilizzando il parametro `iisWebSite`

## Utilizzo dell'Application Request Routing (ARR)
<a name="dotnet-manifest-arr"></a>

I moduli Application Request Routing (ARR) e URL Rewrite sono preinstallati e disponibili in Elastic Beanstalk Windows. AMIs Questi moduli consentono scenari di routing avanzati e la manipolazione degli URL tramite la configurazione IIS utilizzando ebextensions o la configurazione dell'applicazione.

L'esempio seguente mostra un semplice manifesto di distribuzione che configura un sito Web con una porta personalizzata, combinato con una configurazione ebextensions che imposta il routing ARR di base:

**Example aws-windows-deployment-manifest.json: configurazione ARR semplice**  

```
{
  "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 configurazione ARR viene eseguita tramite ebextensions. La seguente configurazione imposta le regole di routing ARR di base:

**Example .ebextensions/arr-config.config - Configurazione ARR di base**  

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

Questa configurazione crea un sito Web sulla porta 8080 e configura ARR per indirizzare tutte le richieste in arrivo all'applicazione di backend in esecuzione su quel sito.

## Configurazione dei pool delle applicazioni
<a name="dotnet-manifest-apppool"></a>

È possibile supportare più applicazioni nell'ambiente Windows. Sono disponibili due approcci:
+ È possibile utilizzare il modello di out-of-process hosting con il server web Kestrel. Con questo modello, è possibile configurare più applicazioni per l'esecuzione in un unico pool di applicazioni.
+ È possibile utilizzare il modello di hosting in-process. Con questo modello, è possibile utilizzare più pool di applicazioni per eseguire più applicazioni con una sola applicazione in ogni pool. Se utilizzi il server IIS e desideri eseguire più applicazioni, devi utilizzare questo approccio.

Per configurare Kestrel ed eseguire più applicazioni in un pool di applicazioni, aggiungi `hostingModel="OutofProcess"` nel file `web.config`. Considera i seguenti esempi:

**Example web.config - per il modello di hosting 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: più applicazioni**  

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

IIS non supporta più applicazioni in un pool di applicazioni perché utilizza il modello di hosting in-process. Pertanto, è necessario configurare più applicazioni assegnando ciascuna applicazione a un pool di applicazioni. In altre parole, assegnare una sola applicazione a un pool di applicazioni.

È possibile configurare IIS per utilizzare diversi pool di applicazioni nel file `aws-windows-deployment-manifest.json`. Apporta i seguenti aggiornamenti consultando il file di esempio successivo:
+ Aggiungi una sezione `iisConfig` che includa una sottosezione denominata `appPools`.
+ Nel blocco `appPools`, elenca i pool di applicazioni. 
+ Nella sezione `deployments`, definisci una sezione `parameters` per ogni applicazione.
+ Per ogni applicazione, la sezione `parameters` specifica un archivio, un percorso per eseguirla e un `appPool` in cui eseguirla.

Il seguente manifest di distribuzione consente di configurare due pool di applicazioni che riavviano l'applicazione ogni 10 minuti. Essi inoltre allegano le loro applicazioni a un'applicazione Web .NET Framework che viene eseguita nel percorso specificato.

**Example aws-windows-deployment-manifest.json: un'applicazione per pool di applicazioni**  

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

## Definizione delle distribuzioni personalizzate
<a name="dotnet-manifest-custom"></a>

Per un maggiore controllo, è possibile personalizzare completamente la distribuzione di un'applicazione definendo una *distribuzione personalizzata*.

Questo manifesto di distribuzione indica a Elastic Beanstalk PowerShell di eseguire gli script in modalità a 32 bit. [Specifica tre script: `install` uno script (`siteInstall.ps1`) che viene eseguito durante l'avvio e la distribuzione dell'istanza, uno `uninstall` script (`siteUninstall.ps1`) che viene eseguito prima di installare nuove versioni durante le distribuzioni e uno `restart` script (`siteRestart.ps1`) che viene eseguito quando si seleziona Riavvia App Server nella console di gestione.](environments-dashboard-actions.md) AWS 

**Example aws-windows-deployment-manifest.json: distribuzione personalizzata**  

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

Include eventuali artefatti necessari per eseguire l'applicazione nel bundle di origine con il manifest e gli script.

**Example C - .zip ustom-site-bundle**  

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

# Riferimento allo schema del manifesto di distribuzione
<a name="dotnet-manifest-schema"></a>

Il manifesto di distribuzione è un file JSON che definisce in che modo Elastic Beanstalk deve distribuire e configurare le applicazioni Windows. Questa sezione fornisce un riferimento completo per tutte le proprietà e le opzioni di configurazione supportate nello schema del manifesto.

## Struttura del manifesto
<a name="dotnet-manifest-schema-structure"></a>

Il manifesto di distribuzione segue uno schema JSON specifico con la seguente struttura di primo livello:

**Example Struttura del manifesto di base**  

```
{
  "manifestVersion": 1,
  "skipIISReset": false,
  "iisConfig": {
    "websites": [...],
    "appPools": [...]
  },
  "deployments": {
    "msDeploy": [...],
    "aspNetCoreWeb": [...],
    "custom": [...]
  }
}
```

### Proprietà di primo livello
<a name="dotnet-manifest-schema-top-level"></a>

`manifestVersion`(richiesto)  
*Tipo*: numero  
*Impostazione predefinita*: 1  
*Valori validi:* 1  
Speciifica la versione dello schema del manifesto. Attualmente è supportata solo la versione 1.

`skipIISReset` (facoltativo)  
*Tipo*: Booleano  
*Di default:* false  
Controlla se IIS viene ripristinato durante le distribuzioni delle applicazioni. Questo flag influisce su entrambi i tipi `msDeploy` di `aspNetCoreWeb` distribuzione.  
*Comportamento:*  
+ *Non specificato o `false` (impostazione predefinita):* le reimpostazioni di IIS vengono eseguite durante le operazioni di installazione, disinstallazione e aggiornamento. Questo è il comportamento tradizionale.
+ *`true`:* le reimpostazioni IIS vengono ignorate durante le operazioni di distribuzione.
*Vantaggi:*  
+ Tempi di *inattività ridotti*: le applicazioni subiscono interruzioni del servizio più brevi durante le implementazioni.
+ *Implementazioni più rapide*: elimina il tempo necessario a IIS per riavviare e reinizializzare completamente IIS.
Durante l'utilizzo`skipIISReset`, l'[RestartAppServer](https://docs.aws.amazon.com/elasticbeanstalk/latest/api/API_RestartAppServer.html)operazione esegue un ripristino di IIS indipendentemente dall'impostazione di questa bandiera.
*Esempio*:  

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

`deployments`(obbligatorio)  
*Tipo:* oggetto  
Contiene le configurazioni di distribuzione per le tue applicazioni. Questo oggetto può includere `msDeploy` e `aspNetCoreWeb` tipi di `custom` distribuzione.

`iisConfig` (facoltativo)  
*Tipo:* oggetto  
Definisce le impostazioni di configurazione IIS da applicare prima di distribuire le applicazioni. Supporta la configurazione del sito Web e del pool di applicazioni.

## Configurazione IIS
<a name="dotnet-manifest-schema-iis-config"></a>

La `iisConfig` sezione consente di configurare le impostazioni IIS prima di distribuire le applicazioni. Ciò include la configurazione di pool di applicazioni con configurazioni specifiche e la configurazione di siti Web IIS con associazioni personalizzate.

### Siti Web IIS
<a name="dotnet-manifest-schema-websites"></a>

I siti Web IIS consentono di configurare impostazioni personalizzate dei siti Web, inclusi percorsi fisici e collegamenti di rete, prima di distribuire le applicazioni.

**Considerazioni importanti per la creazione di diversi siti Web IIS**  
*Ordine di configurazione dei siti Web:* i siti Web vengono configurati in sequenza nell'ordine in cui appaiono nell'`websites`array. La piattaforma elabora ogni configurazione del sito Web in sequenza, quindi assicurati un ordine corretto in caso di dipendenze tra i siti Web.
*Firewall e accesso alle porte:* solo la porta 80 viene esposta automaticamente tramite la configurazione firewall Windows Elastic Beanstalk predefinita. Se si configurano siti Web per utilizzare porte non standard, è necessario definire regole firewall personalizzate tramite ebextensions o script di distribuzione personalizzati per consentire l'accesso esterno a queste porte.

**Example Configurazione del sito Web**  

```
{
  "iisConfig": {
    "websites": [
      {
        "name": "MyCustomSite",
        "physicalPath": "C:\inetpub\wwwroot\mysite",
        "bindings": [
          {
            "protocol": "http",
            "port": 8080,
            "hostName": "mysite.local"
          },
          {
            "protocol": "https",
            "port": 8443
          }
        ]
      }
    ]
  }
}
```Proprietà del sito Web

`name`(richiesto)  
▬*Tipo:* stringa  
Il nome del sito Web IIS. Questo nome viene utilizzato per identificare il sito Web in IIS Manager e deve essere univoco all'interno della configurazione IIS.

`physicalPath`(richiesto)  
▬*Tipo:* stringa  
Il percorso fisico sul server in cui sono archiviati i file del sito Web. Questo percorso deve essere accessibile al processo di lavoro IIS.

`bindings`(obbligatorio)  
*Tipo*: matrice  
*Numero minimo di articoli:* 1  
Una serie di configurazioni vincolanti che definiscono il modo in cui il sito Web risponde alle richieste di rete. Ogni associazione specifica un protocollo, una porta e un nome host opzionale.

#### Associazioni a siti Web
<a name="dotnet-manifest-schema-bindings"></a>

Le associazioni ai siti Web definiscono gli endpoint di rete in cui il sito Web IIS ascolterà le richieste in arrivo.

`protocol`(richiesto)  
▬*Tipo:* stringa  
*Valori validi:* «http», «https»  
Il protocollo utilizzato per l'associazione.

`port`(richiesto)  
*Tipo*: integer  
*Intervallo valido: 1-65535*  
Il numero di porta su cui il sito Web ascolterà le richieste.

`hostName` (facoltativo)  
▬*Tipo:* stringa  
Il nome host (nome di dominio) per l'associazione.

### Pool di applicazioni
<a name="dotnet-manifest-schema-app-pools"></a>

I pool di applicazioni forniscono l'isolamento tra le applicazioni e consentono di configurare le impostazioni di runtime per gruppi di applicazioni.

**Example Configurazione del pool di applicazioni**  

```
{
  "iisConfig": {
    "appPools": [
      {
        "name": "MyAppPool",
        "enable32Bit": false,
        "managedPipelineMode": "Integrated",
        "managedRuntimeVersion": "v4.0",
        "queueLength": 1000,
        "cpu": {
          "limitPercentage": 80,
          "limitAction": "Throttle",
          "limitMonitoringInterval": 5
        },
        "recycling": {
          "regularTimeInterval": 1440,
          "requestLimit": 10000,
          "memory": 1048576,
          "privateMemory": 524288
        }
      }
    ]
  }
}
```Proprietà del pool di applicazioni

`name`(richiesto)  
▬*Tipo:* stringa  
Il nome del pool di applicazioni. Questo nome viene utilizzato per fare riferimento al pool nelle configurazioni di distribuzione.

`enable32Bit` (facoltativo)  
*Tipo*: Booleano  
Consente l'esecuzione di un'applicazione a 32 bit su una versione a 64 bit di Windows. Impostato su `true` per le applicazioni legacy che richiedono la compatibilità a 32 bit.

`managedPipelineMode` (facoltativo)  
▬*Tipo:* stringa  
*Valori validi:* «Integrato», «Classico»  
Speciifica la modalità di elaborazione delle richieste per il pool di applicazioni.

`managedRuntimeVersion` (facoltativo)  
▬*Tipo:* stringa  
*Valori validi:* «No Managed Code», «v2.0", «v4.0"  
Speciifica la versione.NET Framework per il pool di applicazioni.

`queueLength` (facoltativo)  
*Tipo*: integer  
Numero massimo di richieste che HTTP.sys mette in coda per il pool di applicazioni prima di rifiutare richieste aggiuntive.

#### Configurazione della CPU
<a name="dotnet-manifest-schema-cpu-config"></a>

L'`cpu`oggetto configura i limiti di utilizzo della CPU e il monitoraggio per il pool di applicazioni.

`limitPercentage` (facoltativo)  
*Tipo*: numero  
Percentuale massima di tempo di CPU che i processi di lavoro nel pool di applicazioni possono consumare.

`limitAction` (facoltativo)  
▬*Tipo:* stringa  
*Valori validi:* "NoAction«, «killW3WP», «Throttle», "» ThrottleUnderLoad  
Azione da intraprendere quando viene raggiunto il limite della CPU.

`limitMonitoringInterval` (facoltativo)  
*Tipo*: numero  
Periodo di ripristino (in minuti) per il monitoraggio della CPU e i limiti di limitazione.

#### Configurazione del riciclaggio
<a name="dotnet-manifest-schema-recycling-config"></a>

L'`recycling`oggetto configura quando e come i processi di lavoro del pool di applicazioni vengono riciclati.

`regularTimeInterval` (facoltativo)  
*Tipo*: integer  
Intervallo di tempo (in minuti) dopo il quale il pool di applicazioni viene riciclato. Impostare su 0 per disabilitare il riciclo basato sul tempo.

`requestLimit` (facoltativo)  
*Tipo*: integer  
Numero massimo di richieste elaborate dal pool di applicazioni prima del riciclaggio.

`memory` (facoltativo)  
*Tipo*: integer  
Quantità di memoria virtuale (in kilobyte) che attiva il riciclaggio dei processi di lavoro.

`privateMemory` (facoltativo)  
*Tipo*: integer  
Quantità di memoria privata (in kilobyte) che attiva il riciclaggio dei processi di lavoro.

## Tipi di implementazione
<a name="dotnet-manifest-schema-deployments"></a>

L'`deployments`oggetto contiene matrici di configurazioni di distribuzione per diversi tipi di applicazioni. Ogni tipo di distribuzione ha proprietà e casi d'uso specifici.

### MSDeploy distribuzioni
<a name="dotnet-manifest-schema-msdeploy"></a>

MSDeploy le distribuzioni vengono utilizzate per le tradizionali applicazioni.NET Framework che possono essere distribuite utilizzando Web Deploy (). MSDeploy

**Example MSDeploy configurazione di distribuzione**  

```
{
  "deployments": {
    "msDeploy": [
      {
        "name": "WebApp",
        "description": "Main web application",
        "parameters": {
          "appBundle": "webapp.zip",
          "iisPath": "/",
          "appPool": "DefaultAppPool"
        }
      }
    ]
  }
}
```MSDeploy proprietà di distribuzione

`name`(richiesto)  
▬*Tipo:* stringa  
Nome univoco per la distribuzione. Questo nome deve essere univoco in tutte le distribuzioni del manifesto.

`description` (facoltativo)  
▬*Tipo:* stringa  
Descrizione della distribuzione in formato leggibile dall'uomo.

`parameters`(richiesto)  
*Tipo:* oggetto  
Parametri di configurazione per l' MSDeploy operazione.

`scripts` (facoltativo)  
*Tipo:* oggetto  
PowerShell script da eseguire in varie fasi del ciclo di vita dell'implementazione.

#### MSDeploy parametri
<a name="dotnet-manifest-schema-msdeploy-parameters"></a>

`appBundle`(richiesto)  
▬*Tipo:* stringa  
Percorso del pacchetto dell'applicazione (file ZIP) relativo al file manifest. Questo pacchetto contiene i file dell'applicazione da distribuire.

`iisWebSite` (facoltativo)  
▬*Tipo:* stringa  
*Predefinito:* «Sito Web predefinito»  
Il sito Web IIS su cui distribuire l'applicazione. Per impostazione predefinita, le applicazioni vengono distribuite nel «Sito Web predefinito». Facoltativamente, è possibile specificare un nome di sito Web diverso, ad esempio quello configurato nella `iisConfig.websites` sezione.

`iisPath` (facoltativo)  
▬*Tipo:* stringa  
*Predefinito:* «/»  
Percorso della directory virtuale in IIS in cui verrà distribuita l'applicazione. Usa «/» per il percorso principale o «/api» per una sottodirectory.

`appPool` (facoltativo)  
▬*Tipo:* stringa  
Nome del pool di applicazioni per eseguire questa applicazione.

### Distribuzioni ASP.NET Core
<a name="dotnet-manifest-schema-aspnetcore"></a>

Le distribuzioni ASP.NET Core sono progettate specificamente per le applicazioni.NET Core e.NET 5\$1.

**Example Configurazione della distribuzione di ASP.NET Core**  

```
{
  "deployments": {
    "aspNetCoreWeb": [
      {
        "name": "CoreAPI",
        "description": "ASP.NET Core Web API",
        "parameters": {
          "appBundle": "coreapi.zip",
          "iisPath": "/api",
          "appPool": "CoreAppPool"
        }
      }
    ]
  }
}
```

Le distribuzioni ASP.NET Core utilizzano la stessa struttura di proprietà delle MSDeploy distribuzioni, con la differenza fondamentale nell'ambiente di runtime e nel modello di hosting utilizzati per l'applicazione.Parametri di distribuzione di ASP.NET Core

`appBundle`(richiesto)  
▬*Tipo:* stringa  
Percorso del bundle dell'applicazione relativo al file manifest. Può trattarsi di un archivio ZIP o di un percorso di directory contenente l'applicazione ASP.NET Core pubblicata.

`iisWebSite` (facoltativo)  
▬*Tipo:* stringa  
*Predefinito:* «Sito Web predefinito»  
Il sito Web IIS su cui distribuire l'applicazione ASP.NET Core. Per impostazione predefinita, le applicazioni vengono distribuite nel «Sito Web predefinito». Facoltativamente, è possibile specificare un nome di sito Web diverso, ad esempio quello configurato nella `iisConfig.websites` sezione.

`iisPath` (facoltativo)  
▬*Tipo:* stringa  
*Predefinito:* «/»  
Percorso della directory virtuale in IIS per l'applicazione ASP.NET Core.

`appPool` (facoltativo)  
▬*Tipo:* stringa  
Pool di applicazioni per l'applicazione ASP.NET Core. Il pool verrà configurato in modo appropriato per l'hosting ASP.NET Core.

### Distribuzioni personalizzate
<a name="dotnet-manifest-schema-custom"></a>

Le distribuzioni personalizzate forniscono il controllo completo sul processo di distribuzione tramite script. PowerShell Questo tipo di distribuzione è utile per scenari complessi che richiedono installazione, configurazione o logica di distribuzione personalizzate.

**Example Configurazione di distribuzione personalizzata**  

```
{
  "deployments": {
    "custom": [
      {
        "name": "CustomService",
        "description": "Custom Windows service deployment",
        "architecture": 32,
        "scripts": {
          "install": {
            "file": "install-service.ps1"
          },
          "restart": {
            "file": "restart-service.ps1"
          },
          "uninstall": {
            "file": "uninstall-service.ps1",
            "ignoreErrors": true
          }
        }
      }
    ]
  }
}
```Proprietà di distribuzione personalizzate

`name`(obbligatorio)  
▬*Tipo:* stringa  
Nome univoco per la distribuzione personalizzata.

`description` (facoltativo)  
▬*Tipo:* stringa  
Descrizione della distribuzione personalizzata.

`architecture` (facoltativo)  
*Tipo*: integer  
Valore *predefinito:* 32  
*Valori validi:* 32, 64  
Le specifiche di architettura per la modalità di esecuzione degli script PowerShell

`scripts`(richiesto)  
*Tipo:* oggetto  
PowerShell script che definiscono il comportamento di distribuzione. Le distribuzioni personalizzate supportano tipi di script aggiuntivi rispetto ad altri tipi di distribuzione.

## Script di distribuzione
<a name="dotnet-manifest-schema-scripts"></a>

Gli script di distribuzione sono PowerShell script che vengono eseguiti in momenti specifici durante il ciclo di vita della distribuzione. Diversi tipi di distribuzione supportano diversi set di eventi di script.

### Eventi di script
<a name="dotnet-manifest-schema-script-events"></a>

I seguenti eventi di script sono disponibili a seconda del tipo di distribuzione:Script di distribuzione standard (MSDeploy e Web) aspNetCore

`preInstall`  
Viene eseguito prima dell'installazione o dell'aggiornamento dell'applicazione.

`postInstall`  
Viene eseguito dopo l'installazione o l'aggiornamento dell'applicazione.

`preRestart`  
Viene eseguito prima del riavvio dell'applicazione.

`postRestart`  
Viene eseguito dopo il riavvio dell'applicazione.

`preUninstall`  
Viene eseguito prima della disinstallazione dell'applicazione.

`postUninstall`  
Viene eseguito dopo la disinstallazione dell'applicazione.Script di distribuzione personalizzati (solo distribuzioni personalizzate)

`install`  
Script di installazione principale per distribuzioni personalizzate. Questo script è responsabile dell'installazione dell'applicazione o del servizio.

`restart`  
Script per riavviare l'applicazione o il servizio. Chiamato al riavvio dell'ambiente.

`uninstall`  
Script per disinstallare l'applicazione o il servizio. Chiamato durante la chiusura dell'ambiente o la rimozione dell'applicazione.

### Proprietà dello script
<a name="dotnet-manifest-schema-script-properties"></a>

Ogni script è definito come un oggetto con le seguenti proprietà:

`file`(obbligatorio)  
▬*Tipo:* stringa  
Percorso del file di PowerShell script relativo al file manifest. Lo script deve avere un'`.ps1`estensione.

`ignoreErrors` (facoltativo)  
*Tipo*: Booleano  
*Di default:* false  
Se impostato su`true`, la distribuzione continua anche se lo script fallisce. Utilizzalo per script o operazioni di pulizia non critici.

**Example Esempio di configurazione dello script**  

```
{
  "scripts": {
    "preInstall": {
      "file": "backup-config.ps1",
      "ignoreErrors": true
    },
    "postInstall": {
      "file": "configure-app.ps1"
    }
  }
}
```

# Utilizzo di EC2 Fast Launch con i rami della piattaforma Windows
<a name="dotnet-ec2fastlaunch"></a>

La funzionalità EC2 Fast Launch riduce i tempi di avvio delle istanze Windows negli ambienti Elastic Beanstalk. Lo scopo di questo argomento è di guidarti nell'utilizzo di questa funzionalità con i tuoi ambienti Elastic Beanstalk. A partire dalla versione 2.16.2 della piattaforma Windows, rilasciata il [22 gennaio 2025](https://docs.aws.amazon.com/elasticbeanstalk/latest/relnotes/release-2025-01-22-windows.html), le versioni della piattaforma Elastic Beanstalk includono la versione base con Fast Launch abilitato. AMIs EC2 

## Disponibilità predefinita di Fast Launch EC2
<a name="dotnet-ec2fastlaunch-default"></a>

Le ultime versioni della piattaforma Elastic Beanstalk Windows AMIs includono una EC2 base con Fast Launch abilitato automaticamente, senza costi aggiuntivi. Tuttavia, quando vengono rilasciate versioni più recenti della piattaforma, EC2 Fast Launch potrebbe non rimanere abilitato automaticamente sulla base delle versioni precedenti AMIs della piattaforma.

Si consiglia di eseguire l'aggiornamento alla versione più recente della piattaforma Windows per utilizzare la versione base AMIs con EC2 Fast Launch abilitato automaticamente. Tuttavia, se è necessario continuare a utilizzare la versione della piattaforma esistente, è possibile abilitare manualmente EC2 Fast Launch sull'AMI di base del proprio ambiente. Per istruzioni, consulta [Configurazione manuale di EC2 Fast Launch](#dotnet-ec2fastlaunch-manual).

## Configurazione manuale di EC2 Fast Launch
<a name="dotnet-ec2fastlaunch-manual"></a>

**Nota**  
L'attivazione manuale di EC2 Fast Launch può comportare costi aggiuntivi rispetto all'utilizzo di versioni della piattaforma con EC2 Fast Launch abilitato automaticamente. Per ulteriori informazioni sui costi di EC2 Fast Launch, consulta la pagina [delle risorse sottostanti per Manage costs for EC2 Fast Launch](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/win-fast-launch-manage-costs.html) nella *Amazon EC2 User Guide*.

Segui questi passaggi per abilitare EC2 Fast Launch su un'AMI di base Windows utilizzata dall'ambiente Elastic Beanstalk:

**Per abilitare manualmente EC2 Fast Launch per il tuo ambiente Elastic Beanstalk**

1. Identifica l'AMI di base del tuo ambiente:

   Segui i passaggi descritti in [Creazione di un'AMI personalizzata](using-features.customenv.md) per identificare l'ID AMI di base del tuo ambiente. Tieni presente che non è necessario creare un AMI personalizzato: devi solo seguire i passaggi per individuare l'ID AMI di base corrente.

1. Abilita l'avvio EC2 rapido sull'AMI:

   Utilizza le istruzioni in [Enable EC2 Fast Launch](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/win-fast-launch-configure.html) nella *Amazon EC2 User Guide* per configurare EC2 Fast Launch per la tua AMI.

# Aggiunta di un'istanza database Amazon RDS all'ambiente applicativo .NET
<a name="create_deploy_NET.rds"></a>

Questo argomento fornisce istruzioni per creare un Amazon RDS utilizzando la console Elastic Beanstalk. Puoi utilizzare un'istanza database Amazon Relational Database Service (Amazon RDS) per archiviare i dati raccolti e modificati dall'applicazione. Il database può essere accoppiato all'ambiente e gestito da Elastic Beanstalk oppure può essere creato e gestito esternamente da un altro servizio. In queste istruzioni il database è accoppiato all'ambiente e gestito da Elastic Beanstalk. Per ulteriori informazioni sull'integrazione di un Amazon RDS con Elastic Beanstalk, consulta [Aggiunta di un database all'ambiente Elastic Beanstalk](using-features.managing.db.md).

**Topics**
+ [Aggiunta di un'istanza database all'ambiente](#dotnet-rds-create)
+ [Download di un driver](#dotnet-rds-drivers)
+ [Connessione a un database](#dotnet-rds-connect)

## Aggiunta di un'istanza database all'ambiente
<a name="dotnet-rds-create"></a>

**Per aggiungere un'istanza database al tuo ambiente**

1. Apri la console [Elastic Beanstalk](https://console.aws.amazon.com/elasticbeanstalk) e, **nell'elenco Regioni, seleziona la tua**. Regione AWS

1. Nel pannello di navigazione selezionare **Environments** (Ambienti), quindi selezionare il nome dell'ambiente dall'elenco.

1. Nel pannello di navigazione, selezionare **Configuration** (Configurazione).

1. Nella categoria di configurazione del **Database**, scegliere **Edit (Modifica)**.

1. Scegliere un motore di database e immettere un nome utente e una password.

1. Per salvare le modifiche scegli **Apply** (Applica) nella parte inferiore della pagina.

L'aggiunta di un'istanza database richiede circa 10 minuti. Quando l'aggiornamento dell'ambiente è completo, il nome host dell'istanza database e altre informazioni di connessione sono disponibili per la tua applicazione tramite le seguenti proprietà dell'ambiente:


| Nome proprietà | Descrizione | Valore proprietà | 
| --- | --- | --- | 
|  `RDS_HOSTNAME`  |  Il nome host dell'istanza DB.  |  Nella scheda **Connectivity & security** (Connettività e sicurezza) della console Amazon RDS: **Endpoint**.  | 
|  `RDS_PORT`  |  La porta su cui l'istanza database accetta le connessioni. Il valore predefinito varia tra i motori di database.  |  Nella scheda **Connectivity & security (Connettività e sicurezza)** della console Amazon RDS: **Port (Porta)**.  | 
|  `RDS_DB_NAME`  |  Il nome del database, **ebdb**.  |  Nella scheda **Configuration (Configurazione)** della console Amazon RDS: **DB Name (Nome DB)**.  | 
|  `RDS_USERNAME`  |  Il nome utente configurato per il database.  |  Nella scheda **Configuration (Configurazione)** della console Amazon RDS: **Master username (Nome utente master)**.  | 
|  `RDS_PASSWORD`  |  La password configurata per il database.  |  Non disponibile per riferimento nella console Amazon RDS.  | 

Per ulteriori informazioni sulla configurazione di un'istanza di database accoppiata a un ambiente Elastic Beanstalk, consulta [Aggiunta di un database all'ambiente Elastic Beanstalk](using-features.managing.db.md).

## Download di un driver
<a name="dotnet-rds-drivers"></a>

Scarica e installa il pacchetto `EntityFramework` e un driver di database per l'ambiente di sviluppo con `NuGet`.

**Provider di database Entity Framework comuni per. NET**
+ **SQL Server** – `Microsoft.EntityFrameworkCore.SqlServer`
+ **MySQL** – `Pomelo.EntityFrameworkCore.MySql`
+ **PostgreSQL** – `Npgsql.EntityFrameworkCore.PostgreSQL`

## Connessione a un database
<a name="dotnet-rds-connect"></a>

Elastic Beanstalk fornisce informazioni di connessione per le istanze database collegate nelle proprietà dell'ambiente. Utilizza `ConfigurationManager.AppSettings` per leggere le proprietà e configurare una connessione di database.

**Example Helpers.cs: metodo della stringa di connessione**  

```
using System;
using System.Collections.Generic;
using System.Configuration;
using System.Linq;
using System.Web;

namespace MVC5App.Models
{
  public class Helpers
  {
    public static string GetRDSConnectionString()
    {
      var appConfig = ConfigurationManager.AppSettings;

      string dbname = appConfig["RDS_DB_NAME"];

      if (string.IsNullOrEmpty(dbname)) return null;

      string username = appConfig["RDS_USERNAME"];
      string password = appConfig["RDS_PASSWORD"];
      string hostname = appConfig["RDS_HOSTNAME"];
      string port = appConfig["RDS_PORT"];

      return "Data Source=" + hostname + ";Initial Catalog=" + dbname + ";User ID=" + username + ";Password=" + password + ";";
    }
  }
}
```

Utilizza la stringa di connessione per inizializzare il contesto del database.

**Example DBContext.cs**  

```
using System.Data.Entity;
using System.Security.Claims;
using System.Threading.Tasks;
using Microsoft.AspNet.Identity;
using Microsoft.AspNet.Identity.EntityFramework;

namespace MVC5App.Models
{
  public class RDSContext : DbContext
  { 
    public RDSContext()
      : base(GetRDSConnectionString())
    {
    }

    public static RDSContext Create()
    {
      return new RDSContext();
    }
  }
}
```

# La AWS Toolkit for Visual Studio
<a name="dotnet-toolkit"></a>

Visual Studio fornisce modelli per differenti tipi di applicazioni e linguaggi di programmazione. Puoi iniziare con uno qualsiasi di questi modelli. Il AWS Toolkit for Visual Studio fornisce anche tre modelli di progetto che avviano lo sviluppo dell'applicazione AWS : Console Project AWS , Web Project AWS ed Empty Project. In questo esempio, creerai una nuova applicazione Web ASP.NET.

**Creazione di un nuovo progetto di applicazione Web ASP.NET**

1. In Visual Studio, nel menu **File**, fai clic su **Nuovo**, quindi su **Progetto**.

1. Nella finestra di dialogo **Nuovo progetto**, fai clic su **Modelli installati**, su **Visual C\$1**, quindi su **Web**. Fai clic su **Applicazione Web ASP.NET vuota**, digita un nome di progetto, quindi fai clic su **OK**. 

**Esecuzione di un progetto**

Scegliere una delle seguenti operazioni:

1. Premi **F5**.

1. Seleziona **Avvia debug** dal menu **Debug**.

## Test in locale
<a name="create_deploy_NET.sdlc.testlocal"></a>

Visual Studio semplifica il test in locale delle applicazioni. Per testare o eseguire le applicazioni Web ASP.NET, devi disporre di un server Web. Visual Studio offre varie opzioni, ad esempio Internet Information Services (IIS), IIS Express o il server di sviluppo Visual Studio integrato. Per informazioni su ognuna di queste opzioni e per stabilire qual è la più appropriata per le tue esigenze, consulta [Server Web in Visual Studio per progetti Web ASP.NET](http://msdn.microsoft.com/en-us/library/58wxa9w5.aspx).

## Creazione di un ambiente Elastic Beanstalk
<a name="create_deploy_NET.sdlc.deploy"></a>

Dopo aver testato l'applicazione, puoi distribuirla su Elastic Beanstalk.

**Nota**  
Il [file di configurazione](ebextensions.md) deve far parte del progetto per essere incluso nell'archivio. In alternativa, anziché includere i file di configurazione nel progetto, puoi utilizzare Visual Studio per distribuire tutti i file nella cartella di progetto. In **Esplora soluzioni**, fai cli con il pulsante destro del mouse sul nome del progetto e scegli **Proprietà**. Fai clic sulla scheda **Pubblicazione/creazione pacchetto Web**. Nella sezione **Elementi da distribuire**, seleziona **Tutti i file nella cartella del progetto** dall'elenco a discesa.

**Per distribuire l'applicazione su Elastic AWS Beanstalk utilizzando il toolkit per Visual Studio**

1. **In **Solution Explorer**, fai clic con il pulsante destro del mouse sull'applicazione e seleziona Pubblica su. AWS**

1. Nella procedura guidata **Publish to (Pubblica su) AWS**, inserisci le informazioni sul tuo account.

   1. Per **AWS account to use for deployment (account da utilizzare per l'implementazione)**, seleziona il tuo account oppure **Other (Altro)** per inserire le informazioni su un altro account. 

   1. In **Region (Regione)**, seleziona la regione in cui vuoi distribuire l'applicazione. Per informazioni sulle AWS regioni disponibili, consulta [AWS Elastic Beanstalk Endpoints and Quotas](https://docs.aws.amazon.com/general/latest/gr/elasticbeanstalk.html) in. *Riferimenti generali di AWS* Se selezioni una regione non supportata da Elastic Beanstalk, l'opzione per la distribuzione in Elastic Beanstalk non sarà disponibile.

   1.  Fai clic su **Deploy new application with template (Distribuisci nuova applicazione con modello)** e seleziona **Elastic Beanstalk**. Fai clic su **Next (Successivo)**.  
![\[Pubblica nella procedura guidata AWS 1\]](http://docs.aws.amazon.com/it_it/elasticbeanstalk/latest/dg/images/aeb-vs-create-newapp-template.png)

1. Nella pagina **Application (Applicazione)**, immetti i dettagli sull'applicazione.

   1. In **Name (Nome)**, digita il nome dell'applicazione.

   1. In **Description (Descrizione)**, digita una descrizione dell'applicazione. Questa operazione è facoltativa.

   1. L'etichetta versione dell'applicazione viene visualizzata automaticamente in **Deployment version label (Etichetta versione distribuzione)**.

   1. Seleziona **Deploy application incrementally (Distribuisci applicazione in modo incrementale)** per distribuire solo i file modificati. Una distribuzione incrementale è più veloce in quanto vengono aggiornati solo i file modificati e non tutti i file. Se scegli questa opzione, una versione dell'applicazione verrà definita a partire dall'ID di commit Git. Se scegli di non distribuire l'applicazione in modo incrementale, puoi aggiornare l'etichetta versione nella casella **Deployment version label (Etichetta versione distribuzione)**.   
![\[Procedura guidata 2 Publish to Beanstalk Wizard (Pubblica in Beanstalk)\]](http://docs.aws.amazon.com/it_it/elasticbeanstalk/latest/dg/images/aeb-vs-publish-beanstalk1.png)

   1. Fare clic su **Next (Successivo)**.

1. Nella pagina **Environment (Ambiente)**, digita i dettagli sull'ambiente.

   1. Seleziona **Create a new environment for this application (Crea nuovo ambiente per questa applicazione)**.

   1. In **Name (Nome)**, digita un nome per il tuo ambiente.

   1. In **Description (Descrizione)**, digita una descrizione dell'ambiente. Questa operazione è facoltativa.

   1. In **Type (Tipo)**, seleziona il tipo di ambiente.

      Puoi selezionare un ambiente **Load balanced, auto scaled (Carico bilanciato, dimensionamento automatico)** oppure **Single instance (Singola istanza)**. Per ulteriori informazioni, consulta [Tipi di ambiente](using-features-managing-env-types.md).

       
**Nota**  
Per gli ambienti con una singola istanza, le impostazioni relative a bilanciamento del carico, Auto Scaling e URL per il controllo dello stato non sono disponibili.

   1. L'URL dell'ambiente viene visualizzato automaticamente in **Environment URL (URL ambiente)** quando sposti il cursore su quella casella.

   1. Fai clic su **Check availability (Verifica disponibilità)** per verificare che l'URL dell'ambiente sia disponibile.  
![\[Procedura guidata 3 Publish to Beanstalk Wizard (Pubblica in Beanstalk)\]](http://docs.aws.amazon.com/it_it/elasticbeanstalk/latest/dg/images/aeb-vs-publish-beanstalk2.png)

   1. Fare clic su **Next (Successivo)**.

1. Nella pagina **AWS Options (Opzioni)**, configura ulteriori opzioni e informazioni per l'implementazione. 

   1.  In **Container Type (Tipo contenitore)**, seleziona **64bit Windows Server 2012 running IIS 8 (Windows Server 2012 a 64 bit con IIS 8)** o **64bit Windows Server 2008 running IIS 7.5 (Windows Server 2008 a 64 bit con IIS 7.5)**.

   1. In **Instance Type (Tipo di istanza)**, seleziona **Micro**. 

   1. In **Key pair (Coppia di chiavi)**, seleziona **Create new key pair (Crea nuova coppia di chiavi)**. Digita un nome per la nuova coppia di chiavi, in questo esempio **myuswestkeypair**, quindi fai clic su **OK**. Una coppia di key pair consente l'accesso da desktop remoto alle tue istanze Amazon EC2 . Per ulteriori informazioni sulle coppie di EC2 chiavi Amazon, consulta [Using Credentials](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-credentials.html) nella *Amazon Elastic Compute Cloud User Guide*. 

   1. Seleziona un profilo dell'istanza.

      Se non disponi di un profilo dell'istanza, seleziona **Create a default instance profile (Crea profilo dell'istanza di default)**. Per informazioni sull'utilizzo dei profili dell'istanza con Elastic Beanstalk, consulta [Gestione dei profili dell'istanza Elastic Beanstalk](iam-instanceprofile.md).

   1. Se hai un VPC personalizzato che desideri utilizzare con l'ambiente, fai clic su **Launch into VPC (Avvia in VPC)**. Puoi configurare le informazioni sul VPC nella pagina successiva. Per ulteriori informazioni su Amazon VPC, consulta [Amazon Virtual Private Cloud (Amazon VPC)](https://aws.amazon.com/vpc/). Per un elenco di tipi di container non legacy supportati, consultare [Perché alcune versioni di piattaforma sono contrassegnate come legacy?](using-features.migration.md#using-features.migration.why)  
![\[Procedura guidata 4 Publish to Beanstalk Wizard (Pubblica in Beanstalk)\]](http://docs.aws.amazon.com/it_it/elasticbeanstalk/latest/dg/images/aeb-vs-publish-beanstalk3b_iam.png)

   1.  Fare clic su **Next (Successivo)**. 

1. Se hai scelto di avviare l'ambiente in un VPC, viene visualizzata la pagina **VPC Options (Opzioni VPC)**; in caso contrario, viene visualizzata la pagina **Additional Options (Opzioni aggiuntive)**. In questa pagina, puoi configurare le opzioni relative al VPC.  
![\[Opzioni VPC per ambiente scalabile e con bilanciamento del carico\]](http://docs.aws.amazon.com/it_it/elasticbeanstalk/latest/dg/images/aeb-vs-publish-beanstalk3b_vpc.png)  
![\[Opzioni VPC per ambiente con una singola istanza\]](http://docs.aws.amazon.com/it_it/elasticbeanstalk/latest/dg/images/aeb-vs-publish-beanstalk3b_vpc-single.png)

   1. Seleziona l'ID del VPC in cui desideri avviare l'ambiente. 

   1. Per un ambiente con bilanciamento del carico e dimensionabile, seleziona **private (privato)** per **ELB Scheme (Schema ELB)** se non vuoi che Elastic Load Balancer sia disponibile su Internet.

      Per un ambiente con una singola istanza, questa opzione non è applicabile in quanto l'ambiente non dispone di un sistema di bilanciamento del carico. Per ulteriori informazioni, consulta [Tipi di ambiente](using-features-managing-env-types.md).

   1. Per un ambiente scalabile e con bilanciamento del carico, seleziona le sottoreti per il bilanciamento del carico elastico e le istanze. EC2 Se hai creato sottoreti pubbliche e private, assicurati che il bilanciamento del carico elastico e le istanze siano associati alla sottorete corretta. EC2 Per impostazione predefinita, Amazon VPC crea una sottorete pubblica di default utilizzando 10.0.0.0/24 e una sottorete privata utilizzando 10.0.1.0/24. Puoi visualizzare le sottoreti esistenti nella console Amazon VPC all'indirizzo. [https://console.aws.amazon.com/vpc/](https://console.aws.amazon.com/vpc/)

      Per un ambiente con una singola istanza, il VPC richiede solo una sottorete pubblica per l'istanza. La selezione di una sottorete per il sistema di bilanciamento del carico non è possibile in quanto l'ambiente non dispone di un sistema di bilanciamento del carico. Per ulteriori informazioni, consulta [Tipi di ambiente](using-features-managing-env-types.md).

   1. Per un ambiente con bilanciamento del carico e dimensionabile, seleziona il gruppo di sicurezza creato per le istanze, se applicabile.

      Per un ambiente con una singola istanza, non è necessario specificare un dispositivo NAT. Seleziona il gruppo di sicurezza di default. Elastic Beanstalk assegna un indirizzo IP elastico all'istanza per l'accesso a Internet.

   1. Fare clic su **Next (Successivo)**.

1. Nella pagina **Application Options (Opzioni applicazione)**, configura le opzioni dell'applicazione. 

   1. In Target framework, seleziona **.NET Framework 4.0**. 

   1. Elastic Load Balancing utilizza un controllo dello stato per determinare se le EC2 istanze Amazon che eseguono l'applicazione sono integre. Il controllo dello stato determina lo stato dell'istanza sondando un URL specificato secondo l'intervallo definito. Puoi sostituire l'URL di default con un URL di una risorsa esistente nella tua applicazione (ad esempio, `/myapp/index.aspx`) immettendolo nella casella **Application health check URL (URL controllo dello stato applicazione)**. Per ulteriori informazioni sui controlli dello stato per le applicazioni, consulta [Controllo dell’integrità](environments-cfg-clb.md#using-features.managing.elb.healthchecks). 

   1. Digita un indirizzo e-mail per ricevere le notifiche di Amazon Simple Notification Service (Amazon SNS) relative a importanti eventi che riguardano la tua applicazione.

   1. La sezione **Ambiente applicativo** consente di specificare le variabili di ambiente sulle EC2 istanze Amazon su cui è in esecuzione l'applicazione. Questa impostazione fornisce una maggiore portabilità eliminando la necessità di ricompilare il codice sorgente quando si passa da un ambiente all'altro.

   1. Seleziona l'opzione relativa alle credenziali applicazione che desideri utilizzare per distribuire l'applicazione.  
![\[Procedura guidata 6 Publish to Beanstalk Wizard (Pubblica in Beanstalk)\]](http://docs.aws.amazon.com/it_it/elasticbeanstalk/latest/dg/images/aeb-vs-publish-beanstalk3a.png)

   1. Fare clic su **Next (Successivo)**.

1. Se hai già configurato un database Amazon RDS, si apre la pagina **Amazon RDS DB Security Group (Gruppo di sicurezza DB Amazon RDS)**. Se desideri collegare il tuo ambiente Elastic Beanstalk all'istanza database di Amazon RDS, seleziona uno o più gruppi di sicurezza. In caso contrario, passa alla fase successiva. Quando sei pronto, fai clic su **Next (Successivo)**.  
![\[Procedura guidata 7 Publish to Beanstalk Wizard (Pubblica in Beanstalk)\]](http://docs.aws.amazon.com/it_it/elasticbeanstalk/latest/dg/images/aeb-vs-publish-beanstalk6b.png)

1.  Verifica le opzioni di distribuzione. Se non devi apportare alcuna modifica, fai clic su **Deploy (Distribuisci)**.   
![\[Procedura guidata 8 Publish to Beanstalk Wizard (Pubblica in Beanstalk)\]](http://docs.aws.amazon.com/it_it/elasticbeanstalk/latest/dg/images/aeb-vs-publish-beanstalk4.png)

   Il progetto ASP.NET verrà esportato come file di distribuzione Web, caricato in Amazon S3 e registrato come una nuova versione dell'applicazione con Elastic Beanstalk. La funzione di distribuzione di Elastic Beanstalk monitorerà il tuo ambiente esistente finché non sarà disponibile con il codice appena distribuito. Nella scheda env:<environment name> (amb:<nome ambiente>), viene indicato lo stato dell'ambiente.   
![\[Stato dell'ambiente\]](http://docs.aws.amazon.com/it_it/elasticbeanstalk/latest/dg/images/aeb-vs-env-status.png)

## Terminazione di un ambiente
<a name="create_deploy_NET.terminating"></a>

Per evitare di incorrere in addebiti per AWS le risorse non utilizzate, puoi terminare un ambiente in esecuzione utilizzando Toolkit for AWS Visual Studio.

**Nota**  
 Puoi sempre avviare un nuovo ambiente utilizzando la stessa versione in un secondo momento. 

**Per terminare un ambiente**

1.  Espandi il nodo Elastic Beanstalk e il nodo applicazione in **AWS Explorer**. Fai clic con il pulsante destro del mouse sull'ambiente dell'applicazione e seleziona **Terminate Environment (Termina ambiente)**.

1. Quando richiesto, fai clic su **Yes (Sì)** per confermare che intendi terminare l'ambiente. Elastic Beanstalk impiegherà alcuni minuti per AWS terminare le risorse in esecuzione nell'ambiente.  
![\[Finestra di dialogo Terminate Environment (Termina ambiente) di Elastic Beanstalk\]](http://docs.aws.amazon.com/it_it/elasticbeanstalk/latest/dg/images/aeb-vs-terminate-confirm.png)
**Nota**  
Quando termini l'ambiente, il CNAME associato all'ambiente terminato diventa disponibile e può essere utilizzato da un altro utente. 

# Distribuzione nell'ambiente
<a name="create_deploy_NET.sdlc.create.edit"></a>

Ora che hai testato la tua applicazione, è facile modificare e ridistribuire l'applicazione e visualizzare i risultati in pochi istanti. 

 **Per modificare e ridistribuire l'applicazione Web ASP.NET ** 

1.  In **Solution Explorer**, fate clic con il pulsante destro del mouse sull'applicazione, quindi fate clic su **Ripubblica in ambiente < *your environment name* >**. Viene visualizzata la procedura guidata **Re-publish to (Ripubblica su) AWS Elastic Beanstalk**.  
![\[Procedura guidata 1 Publish to Beanstalk Wizard (Pubblica in Beanstalk)\]](http://docs.aws.amazon.com/it_it/elasticbeanstalk/latest/dg/images/aeb-vs-republish-beanstalk-sameenv.png)

1.  Consulta i dettagli relativi alla distribuzione, quindi fai clic su **Deploy (Distribuisci)**. 
**Nota**  
Se desideri modificare le impostazioni, fai clic su **Cancel (Annulla)** e utilizza la procedura guidata **Publish to (Pubblica su) AWS**. Per istruzioni, consulta [Creazione di un ambiente Elastic Beanstalk](dotnet-toolkit.md#create_deploy_NET.sdlc.deploy).

   Il progetto Web aggiornato ASP.NET verrà esportato come file di distribuzione Web con una nuova etichetta versione, caricato in Amazon S3 e registrato come una nuova versione dell'applicazione con Elastic Beanstalk. La funzione di distribuzione di Elastic Beanstalk monitora il tuo ambiente esistente finché non sarà disponibile con il codice appena distribuito. Nella scheda **env: < *environment name* >**, vedrai lo stato del tuo ambiente. 

Puoi anche distribuire un'applicazione esistente in un ambiente esistente se, ad esempio, è necessario eseguire il rollback a una versione precedente dell'applicazione. 

**Per distribuire una versione dell'applicazione in un ambiente esistente**

1. Fai clic con il pulsante destro del mouse sull'applicazione Elastic Beanstalk espandendo il nodo Elastic Beanstalk in **AWS Explorer**. Seleziona **View Status (Visualizza stato)**. 

1. Nella scheda **App: < *application name* >**, fai clic su **Versioni**.   
![\[Versioni delle applicazioni\]](http://docs.aws.amazon.com/it_it/elasticbeanstalk/latest/dg/images/aeb-vs-publish-app-version.png)

1. Seleziona la versione dell'applicazione che desideri distribuire e fai clic su **Publish Version (Pubblica versione)**.

1.  Nella procedura guidata **Publish Application Version (Pubblica versione applicazione)**, fai clic su **Next (Successivo)**.  
![\[Procedura guidata 1 Publish Application Version (Pubblica versione applicazione)\]](http://docs.aws.amazon.com/it_it/elasticbeanstalk/latest/dg/images/aeb-vs-republish-beanstalk2a.png)

1.  Rivedi le opzioni di distribuzione, quindi fai clic su **Deploy (Distribuisci)**.   
![\[Procedura guidata 2 Publish Application Version (Pubblica versione applicazione)\]](http://docs.aws.amazon.com/it_it/elasticbeanstalk/latest/dg/images/aeb-vs-publish-app-version-wizard3.png)

   Il tuo progetto ASP.NET verrà esportato come un file di distribuzione Web e caricato su Amazon S3. La funzione di distribuzione di Elastic Beanstalk monitorerà il tuo ambiente esistente finché non sarà disponibile con il codice appena distribuito. Nella scheda **env: < *environment name* >**, vedrai lo stato del tuo ambiente. 

# Gestione degli ambienti applicativi Elastic Beanstalk
<a name="create_deploy_NET.managing"></a>

Con AWS Toolkit for Visual Studio e AWS Management Console, puoi modificare il provisioning e la configurazione delle AWS risorse utilizzate dagli ambienti applicativi. Per informazioni su come gestire gli ambienti applicativi utilizzando la Console di AWS gestione, consulta. [Gestione degli ambienti Elastic Beanstalk](using-features.managing.md) Questa sezione illustra le impostazioni specifiche del servizio che puoi modificare in AWS Toolkit for Visual Studio come parte della configurazione dell'ambiente applicativo.

## Modifica delle impostazioni di configurazione dell'ambiente
<a name="create_deploy_NET.managing.env"></a>

Quando distribuisci la tua applicazione, Elastic Beanstalk configura una serie di servizi di cloud computing. AWS È possibile controllare la configurazione di questi singoli servizi utilizzando AWS Toolkit for Visual Studio.

**Per modificare le impostazioni dell'ambiente di un'applicazione**
+ Espandi il nodo Elastic Beanstalk e il nodo dell'applicazione. In **AWS Explorer**, fai clic con il pulsante destro del mouse sull'ambiente Elastic Beanstalk. Seleziona **View Status (Visualizza stato)**. 

  È ora possibile configurare le impostazioni per i componenti seguenti:
  + Server
  + Bilanciamento del carico
  + Auto Scaling
  + Notifiche
  + Proprietà dell'ambiente

# Configurazione delle istanze EC2 del server utilizzando il AWS toolkit per Visual Studio
<a name="create_deploy_NET.managing.ec2"></a>

Amazon Elastic Compute Cloud (Amazon EC2) è un servizio Web che usi per avviare e gestire istanze di server nei data center di Amazon. Puoi utilizzare le istanze EC2 del server Amazon in qualsiasi momento, per tutto il tempo necessario e per qualsiasi scopo legale. Le istanze sono disponibili in diverse dimensioni e configurazioni. Per ulteriori informazioni, vai [su Amazon EC2](https://aws.amazon.com/ec2/).

Puoi modificare la **configurazione** dell'istanza Amazon dell'ambiente Elastic Beanstalk con EC2 la scheda Server all'interno della AWS scheda Ambiente applicativo in Toolkit for Visual Studio. 

![\[Pannello di configurazione dei server Elastic Beanstalk\]](http://docs.aws.amazon.com/it_it/elasticbeanstalk/latest/dg/images/aeb-vs-server.png)


## Tipi di EC2 istanze Amazon
<a name="create_deploy_NET.managing.ec2.instancetypes"></a>

L'opzione **Tipo di istanza** visualizza i tipi di istanza disponibili per l'applicazione Elastic Beanstalk. Cambia il tipo di istanza per selezionare un server con le caratteristiche (come quantità di memoria e potenza della CPU) più adatte alla tua applicazione. Ad esempio, le applicazioni con operazioni intensive e di lunga durata possono richiedere più memoria o CPU.

Per ulteriori informazioni sui tipi di EC2 istanze Amazon disponibili per la tua applicazione Elastic Beanstalk[, consulta Instance](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/instance-types.html) Types nella *Amazon Elastic Compute Cloud User* Guide.

## Gruppi EC2 di sicurezza Amazon
<a name="create_deploy_NET.managing.ec2.securitygroups"></a>

Puoi controllare l'accesso alla tua applicazione Elastic Beanstalk *utilizzando EC2 * un Amazon Security Group. Un gruppo di sicurezza definisce le regole del firewall per le proprie istanze. Tali regole specificano quale traffico di rete in entrata deve essere distribuito sulla tua istanza. Tutto il restante traffico in entrata verrà eliminato. Puoi modificare le regole per un gruppo in qualsiasi momento. Le nuove regole vengono automaticamente applicate per tutte le istanze in esecuzione e le istanze avviate in futuro. 

Puoi configurare i gruppi di EC2 sicurezza Amazon utilizzando la Console di AWS gestione o il AWS Toolkit for Visual Studio. **Puoi specificare quali gruppi di EC2 sicurezza Amazon controllano l'accesso alla tua applicazione Elastic Beanstalk inserendo i nomi di uno o più nomi di gruppi di sicurezza EC2 Amazon (delimitati da virgole) nella casella di testo Security Groups. EC2 ** 

**Nota**  
Verifica che la porta 80 (HTTP) sia accessibile da 0.0.0.0/0 come intervallo CIDR sorgente se desideri abilitare i controlli dello stato per l'applicazione. Per altre informazioni sui controlli dello stato, consulta [Controlli dello stato](create_deploy_NET.managing.elb.md#create_deploy_NET.managing.elb.healthchecks).

**Per creare un gruppo di sicurezza utilizzando il toolkit per Visual Studio AWS**

1.  In Visual Studio, in **AWS Explorer**, espandi il EC2 nodo **Amazon**, quindi fai doppio clic su **Gruppi di sicurezza**. 

1.  Fai clic su **Create Security Group (Crea gruppi di sicurezza)**, quindi immetti un nome e una descrizione per il gruppo di sicurezza. 

1.  Fare clic su **OK**. 

Per ulteriori informazioni su Amazon EC2 Security Groups, consulta [Using Security Groups](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-network-security.html) nella *Amazon Elastic Compute Cloud User Guide*.

## Coppie di EC2 chiavi Amazon
<a name="create_deploy_NET.managing.ec2.keypair"></a>

Puoi accedere in modo sicuro alle EC2 istanze Amazon fornite per la tua applicazione Elastic Beanstalk con una coppia di chiavi Amazon. EC2 

**Importante**  
Devi creare una coppia di EC2 chiavi Amazon e configurare le istanze Amazon con provisioning di Elastic Beanstalk per utilizzare la EC2 coppia di chiavi Amazon prima di poter accedere alle EC2 istanze Amazon fornite da Elastic Beanstalk. EC2 Puoi creare la tua coppia di chiavi utilizzando la AWS procedura guidata **Publish to** all'interno di AWS Toolkit for Visual Studio quando distribuisci l'applicazione su Elastic Beanstalk. Per creare ulteriori coppie di chiavi utilizzando il Toolkit, segui le fasi descritte qui di seguito. In alternativa, puoi configurare le tue coppie di EC2 chiavi Amazon utilizzando la [console di AWS gestione](https://console.aws.amazon.com/). Per istruzioni sulla creazione di una coppia di key pair per Amazon EC2, consulta la [Amazon Elastic Compute Cloud Getting Started Guide](https://docs.aws.amazon.com/AWSEC2/latest/GettingStartedGuide/). 

 La casella **di testo Existing Key Pair** ti consente di specificare il nome di una coppia di EC2 chiavi Amazon che puoi utilizzare per accedere in modo sicuro alle EC2 istanze Amazon che eseguono la tua applicazione Elastic Beanstalk. 

**Per specificare il nome di una coppia di EC2 chiavi Amazon**

1. Espandi il EC2 nodo **Amazon** e fai doppio clic su **Key Pairs**.

1.  Fai clic su **Create Key Pair (Crea coppia di chiavi)** e inserisci il nome della coppia di chiavi. 

1.  Fare clic su **OK**. 

Per ulteriori informazioni sulle coppie di EC2 chiavi Amazon, consulta [Using Amazon EC2 Credentials](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-credentials.html) nella *Amazon Elastic Compute Cloud User* Guide. Per ulteriori informazioni sulla connessione alle EC2 istanze Amazon, consulta[Creazione di elenchi e connessioni alle istanze dei server](create_deploy_NET.ec2connect.md). 

## Intervallo di monitoraggio
<a name="create_deploy_NET.managing.monitoring"></a>

 Per impostazione predefinita, sono abilitate solo le CloudWatch metriche Amazon di base. che restituiscono dati in periodi di cinque minuti. Puoi abilitare CloudWatch metriche più granulari di un minuto selezionando **1 minuto** per l'**intervallo di monitoraggio** nella sezione **Server** della scheda **Configurazione** per il tuo ambiente in. AWS Toolkit for Eclipse

**Nota**  
I costi CloudWatch del servizio Amazon possono essere applicati per metriche a intervalli di un minuto. CloudWatchPer ulteriori informazioni, consulta [Amazon](https://aws.amazon.com/cloudwatch/).

## ID AMI personalizzata
<a name="create_deploy_NET.managing.customami"></a>

 Puoi sostituire l'AMI predefinita utilizzata per le tue EC2 istanze Amazon con la tua AMI personalizzata inserendo l'identificatore dell'AMI personalizzato nella casella **ID AMI** personalizzato nella sezione **Server** della scheda **Configurazione** per il tuo ambiente in. AWS Toolkit for Eclipse

**Importante**  
L'utilizzo di un'AMI personalizzata è un'attività avanzata che devi completare con estrema attenzione. Se hai bisogno di un'AMI personalizzata, ti consigliamo di iniziare con l'AMI predefinita di Elastic Beanstalk e di modificarla. Per essere considerate affidabili, Elastic Beanstalk EC2 si aspetta che le istanze Amazon soddisfino una serie di requisiti, tra cui un host manager funzionante. Se questi requisiti non vengono soddisfatti, il tuo ambiente potrebbe non funzionare in modo corretto.

# Configurazione di Elastic Load Balancing utilizzando AWS il toolkit per Visual Studio
<a name="create_deploy_NET.managing.elb"></a>

Elastic Load Balancing è un servizio Web Amazon che aiuta a migliorare la disponibilità e la scalabilità della tua applicazione. Questo servizio semplifica la distribuzione dei carichi di applicazioni tra due o più EC2 istanze Amazon. Elastic Load Balancing consente la disponibilità attraverso la ridondanza e supporta l'aumento di traffico per la tua applicazione. 

 Elastic Load Balancing distribuisce e bilancia automaticamente il traffico di applicazioni in ingresso tra tutte le istanze in esecuzione. Il servizio, inoltre, consente di aggiungere nuove istanze per aumentare la capacità di un'applicazione.

 Elastic Beanstalk effettua automaticamente il provisioning di Elastic Load Balancing quando distribuisci un'applicazione. Puoi modificare la configurazione dell'istanza Amazon dell'ambiente EC2 Elastic Beanstalk con **la scheda Load Balancer all'interno della** scheda dell'ambiente applicativo in Toolkit for AWS Visual Studio.

![\[Pannello di configurazione del sistema Elastic Load Balancing per Elastic Beanstalk\]](http://docs.aws.amazon.com/it_it/elasticbeanstalk/latest/dg/images/aeb-vs-loadbalancer.png)


 Le seguenti sezioni descrivono i parametri di Elastic Load Balancing che puoi configurare per la tua applicazione.

## Porte
<a name="create_deploy_NET.managing.elb.ports"></a>

Il sistema di bilanciamento del carico predisposto per gestire le richieste per l'applicazione Elastic Beanstalk invia le richieste alle istanze EC2 Amazon che eseguono l'applicazione. Il sistema di bilanciamento del carico fornito può ascoltare le richieste sulle porte HTTP e HTTPS e instradare le richieste verso le EC2 istanze Amazon dell'applicazione. AWS Elastic Beanstalk Per impostazione predefinita, il sistema di bilanciamento del carico gestisce le richieste sulla porta HTTP. Almeno una delle porte (HTTP o HTTPS) deve essere attiva.

![\[Configurazione del sistema Elastic Load Balancing per Elastic Beanstalk - Porte\]](http://docs.aws.amazon.com/it_it/elasticbeanstalk/latest/dg/images/aeb-vs-loadbalancer-ports.png)


**Importante**  
Verifica che la porta specificata non sia bloccata; in caso contrario, gli utenti non saranno in grado di connettersi alla tua applicazione Elastic Beanstalk.

### Controllo della porta HTTP
<a name="create_deploy_NET.managing.elb.ports.http"></a>

Per disattivare la porta HTTP, seleziona **OFF** per **HTTP Listener Port (Porta HTTP del listener)**. Per attivare la porta HTTP, seleziona una porta HTTP (ad esempio, **80**) dall'elenco.

**Nota**  
Per accedere al tuo ambiente utilizzando una porta diversa dalla porta 80 predefinita, come la porta 8080, aggiungi un listener al sistema di bilanciamento del carico esistente e configura il nuovo listener per l'ascolto su quella porta.  
Ad esempio, utilizzando il comando [AWS CLI for Classic load balancer](https://docs.aws.amazon.com/cli/latest/reference/elb/create-load-balancer-listeners.html), digita il seguente comando, sostituendolo *LOAD\$1BALANCER\$1NAME* con il nome del tuo load balancer per Elastic Beanstalk.  

```
aws elb create-load-balancer-listeners --load-balancer-name LOAD_BALANCER_NAME --listeners "Protocol=HTTP, LoadBalancerPort=8080, InstanceProtocol=HTTP, InstancePort=80"
```
Ad esempio, utilizzando [AWS CLI for Application Load Balancers](https://docs.aws.amazon.com/cli/latest/reference/elbv2/create-listener.html), digita il comando seguente, sostituendolo *LOAD\$1BALANCER\$1ARN* con l'ARN del tuo load balancer per Elastic Beanstalk.  

```
aws elbv2 create-listener --load-balancer-arn LOAD_BALANCER_ARN --protocol HTTP --port 8080
```
Se desideri che Elastic Beanstalk monitori il tuo ambiente, non rimuovere il listener sulla porta 80.

### Controllo della porta HTTPS
<a name="create_deploy_NET.managing.elb.ports.https"></a>

Elastic Load Balancing supporta il HTTPS/TLS protocollo per abilitare la crittografia del traffico per le connessioni dei client al sistema di bilanciamento del carico. Le connessioni dal load balancer alle EC2 istanze utilizzano la crittografia in chiaro. Per impostazione predefinita, la porta HTTPS non è attiva.

**Per attivare la porta HTTPS**

1. Crea un nuovo certificato utilizzando AWS Certificate Manager (ACM) o carica un certificato e una chiave su (IAM). AWS Identity and Access Management Per ulteriori informazioni sulla richiesta di un certificato ACM, consulta [Richiesta di un certificato](https://docs.aws.amazon.com/acm/latest/userguide/gs-acm-request.html) nella *Guida per l'utente di AWS Certificate Manager *. Per ulteriori informazioni sull'importazione di certificati di terza parte in ACM, consulta [Importazione di certificati](https://docs.aws.amazon.com/acm/latest/userguide/import-certificate.html) nella *Guida per l'utente di AWS Certificate Manager *. Se ACM non è [disponibile nella tua regione](https://docs.aws.amazon.com/general/latest/gr/acm.html), utilizza AWS Identity and Access Management (IAM) per caricare un certificato di terze parti. I servizi ACM e IAM archiviano il certificato e forniscono un Amazon Resource Name (ARN) per il certificato SSL. Per ulteriori informazioni sulla creazione e sul caricamento dei certificati in IAM, consulta l'argomento relativo all'[utilizzo dei certificati server](https://docs.aws.amazon.com/IAM/latest/UserGuide/ManagingServerCerts.html) nella *Guida per l'utente di IAM*.

1. Specifica la porta HTTPS selezionando una porta per **HTTPS Listener Port (Porta HTTPS del listener)**.  
![\[Configurazione del sistema Elastic Load Balancing per Elastic Beanstalk - SSL\]](http://docs.aws.amazon.com/it_it/elasticbeanstalk/latest/dg/images/aeb-vs-elb-ssl.png)

1. In **SSL Certificate ID (ID certificato SSL)** immetti l'Amazon Resources Name (ARN) del certificato SSL. Ad esempio, **arn:aws:iam::123456789012:server-certificate/abc/certs/build** o **arn:aws:acm:us-east-2:123456789012:certificate/12345678-12ab-34cd-56ef-12345678**. Usa il certificato SSL creato o caricato nella fase 1.

Per disattivare la porta HTTPS, seleziona **OFF** per **HTTPS Listener Port (Porta HTTPS del listener)**.

## Controlli dello stato
<a name="create_deploy_NET.managing.elb.healthchecks"></a>

La definizione di controllo dello stato include un URL a cui inviare una query per lo stato dell'istanza. Per impostazione predefinita, Elastic Beanstalk usa TCP: 80 per container non legacy e HTTP: 80 per container legacy. Puoi sostituire l'URL di default con un URL di una risorsa esistente nella tua applicazione (ad esempio, `/myapp/default.aspx`) immettendolo nella casella **Application Health Check URL (URL controllo dello stato applicazione)**. Se ignori l'URL predefinito, Elastic Beanstalk utilizza HTTP per eseguire le query sulla risorsa. Per verificare se stai utilizzando un tipo di container legacy, consulta [Perché alcune versioni di piattaforma sono contrassegnate come legacy?](using-features.migration.md#using-features.migration.why)

 Puoi controllare le impostazioni per il controllo dello stato utilizzando la sezione **EC2 Instance Health Check** del pannello **Load Balancing**.

![\[Configurazione del sistema Elastic Load Balancing per Elastic Beanstalk - controlli dello stato\]](http://docs.aws.amazon.com/it_it/elasticbeanstalk/latest/dg/images/aeb-vs-loadbalancer-healthcheck.png)


La definizione di controllo dello stato include un URL a cui inviare una query per lo stato dell'istanza. Sostituisci l'URL di default con un URL di una risorsa esistente nella tua applicazione (ad esempio, `/myapp/index.jsp`) immettendolo nella casella **Application Health Check URL (URL controllo dello stato applicazione)**. 

Di seguito sono descritti i parametri di controllo dello stato che puoi impostare per l'applicazione. 
+ Per **Health Check Interval (secondi)**, inserisci il numero di secondi di attesa di Elastic Load Balancing tra i controlli di integrità per le istanze Amazon dell'applicazione. EC2 
+  In **Health Check Timeout (Timeout del controllo dello stato (secondi))**, specifica il numero di secondi che Elastic Load Balancing deve aspettare per avere una risposta prima di ritenere che l'istanza non risponda.
+ In **Healthy Check Count Threshold (Soglia di conteggio dei controlli integri)** e **Unhealthy Check Count Threshold (Soglia di conteggio dei controlli non integri)**, specifica il numero di sondaggi URL consecutivi riusciti o non riusciti prima che Elastic Load Balancing modifichi lo stato di integrità dell'istanza. Ad esempio, specificando **5** nella casella **Unhealthy Check Count Threshold (Soglia di conteggio dei controlli non integri)**, l'URL restituisce un messaggio di errore o di timeout per cinque volte consecutive prima che Elastic Load Balancing consideri il controllo dello stato come non riuscito.

## Sessioni
<a name="create_deploy_NET.managing.elb.sessions"></a>

Per impostazione predefinita, un sistema di bilanciamento del carico prevede l'instradamento di ogni richiesta in modo indipendente all'istanza del server con il carico minore. In confronto, una sticky session associa una sessione utente a una determinata istanza del server, in modo che tutte le richieste provenienti dall'utente durante la sessione siano inviate alla stessa istanza del server. 

 Elastic Beanstalk utilizza i cookie HTTP generati dal sistema di bilanciamento del carico quando le sticky session sono attivate per un'applicazione. Il sistema di bilanciamento del carico utilizza un cookie speciale generato dal sistema di bilanciamento del carico per monitorare l'istanza dell'applicazione per ogni richiesta. Quando il sistema di bilanciamento del carico riceve una richiesta, verifica innanzitutto se questo cookie è presente nella richiesta. In questo caso, la richiesta viene inviata all'istanza dell'applicazione specificata nel cookie. Se non vengono trovati cookie, il sistema di bilanciamento del carico sceglie un'istanza delle applicazioni basata su algoritmo di bilanciamento del carico esistente. Un cookie è inserito nella risposta per le richieste successive vincolanti dallo stesso utente per quell'istanza dell'applicazione. La configurazione della policy definisce la scadenza di un cookie che stabilisce la durata di validità per ogni cookie. 

Puoi utilizzare la sezione **Sessions (Sessioni)** nella scheda **Load Balancer (Sistema di bilanciamento del carico)** per specificare se il sistema di bilanciamento del carico della tua applicazione consente l'adesione della sessione.

![\[Configurazione del sistema Elastic Load Balancing per Elastic Beanstalk - Sessioni\]](http://docs.aws.amazon.com/it_it/elasticbeanstalk/latest/dg/images/aeb-vs-loadbalancer-sessions.png)


 Per ulteriori informazioni su Elastic Load Balancing, consulta [Guida per sviluppatori di Elastic Load Balancing](https://docs.aws.amazon.com/ElasticLoadBalancing/latest/DeveloperGuide/). 

# Configurazione dell'Auto Scaling utilizzando AWS il toolkit per Visual Studio
<a name="create_deploy_NET.managing.as"></a>

Amazon EC2 Auto Scaling è un servizio web Amazon progettato per avviare o terminare automaticamente le istanze EC2 Amazon in base a trigger definiti dall'utente. Gli utenti possono configurare *gruppi Auto Scaling* e associare *trigger* a questi gruppi per scalare automaticamente le risorse di calcolo basate su parametri come l'utilizzo della banda o della CPU. Amazon EC2 Auto Scaling collabora con Amazon CloudWatch per recuperare i parametri per le istanze del server che eseguono la tua applicazione.

Amazon EC2 Auto Scaling ti consente di prendere un gruppo di EC2 istanze Amazon e impostare vari parametri per aumentare o diminuire automaticamente il numero di questo gruppo. Amazon EC2 Auto Scaling può aggiungere o rimuovere EC2 istanze Amazon da quel gruppo per aiutarti a gestire senza problemi le variazioni del traffico della tua applicazione. 

 Amazon EC2 Auto Scaling monitora anche lo stato di ogni EC2 istanza Amazon che avvia. Se un'istanza si interrompe in modo imprevisto, Amazon EC2 Auto Scaling rileva la chiusura e avvia un'istanza sostitutiva. Questa funzionalità consente di mantenere automaticamente un numero fisso e desiderato di EC2 istanze Amazon. 

Elastic Beanstalk fornisce EC2 Amazon Auto Scaling per la tua applicazione. Puoi modificare la configurazione dell'istanza Amazon dell'ambiente EC2 Elastic Beanstalk con **la scheda Auto** Scaling all'interno della scheda Ambiente applicativo in Toolkit for AWS Visual Studio.

![\[Pannello di configurazione di Auto Scaling per Elastic Beanstalk\]](http://docs.aws.amazon.com/it_it/elasticbeanstalk/latest/dg/images/aeb-vs-autoscaling.png)


La seziona seguente illustra come configurare i parametri di Auto Scaling per la tua applicazione. 

## Avvio della configurazione
<a name="create_deploy_NET.managing.as.launchconfig"></a>

Puoi modificare la configurazione di avvio per controllare il modo in cui l'applicazione Elastic Beanstalk fornisce le risorse EC2 Amazon Auto Scaling.

Le caselle **Minimum Instance Count (Conteggio istanze minimo)** e **Maximum Instance Count (Conteggio istanze massimo)** consentono di specificare la dimensione minima e massima del gruppo Auto Scaling usato dall'applicazione Elastic Beanstalk.

![\[Finestra per impostare la configurazione di avvio di Auto Scaling di Elastic Beanstalk\]](http://docs.aws.amazon.com/it_it/elasticbeanstalk/latest/dg/images/aeb-vs-autoscaling-launchconfig.png)


**Nota**  
Per mantenere un numero fisso di EC2 istanze Amazon, imposta Numero **minimo di istanze e Numero** **massimo di istanze** sullo stesso valore.

La casella **Zone di disponibilità** ti consente di specificare il numero di zone di disponibilità in cui desideri che si trovino le tue EC2 istanze Amazon. È importante impostare questo numero se desideri creare applicazioni con tolleranza ai guasti. Se una zona di disponibilità non è raggiungibile, le istanze saranno ancora in esecuzione in altre zone di disponibilità. 

**Nota**  
Al momento, non è possibile specificare in quale zona di disponibilità si trova l'istanza. 

## Triggers
<a name="create_deploy_NET.managing.as.trigger"></a>

Un *trigger* è un meccanismo di Amazon EC2 Auto Scaling impostato per indicare al sistema quando aumentare (*scalare* in orizzontale) il numero di istanze e quando diminuire (*scalare in* avanti) il numero di istanze. Puoi configurare i trigger in modo che si *attivino* su qualsiasi metrica pubblicata su Amazon CloudWatch, come l'utilizzo della CPU, e determinare se le condizioni specificate sono state soddisfatte. Quando le soglie superiori o inferiori delle condizioni specificate per il parametro sono state violate per il periodo di tempo specificato, il trigger avvia un processo di lunga durata denominato *attività di dimensionamento*.

Puoi definire un trigger di scalabilità per la tua applicazione Elastic Beanstalk utilizzando Toolkit AWS for Visual Studio.

![\[Trigger di Auto Scaling per Elastic Beanstalk\]](http://docs.aws.amazon.com/it_it/elasticbeanstalk/latest/dg/images/aeb-vs-autoscaling-triggers.png)


I trigger di Amazon EC2 Auto Scaling funzionano osservando una CloudWatch metrica Amazon specifica per un'istanza. I trigger includono l'utilizzo della CPU, il traffico di rete e l'attività del disco. Utilizza l'impostazione **Trigger Measurement (Misurazione del trigger)** per selezionare un parametro per il trigger.

L'elenco seguente descrive i parametri di attivazione che puoi configurare utilizzando la AWS Console di gestione.
+ Puoi specificare le statistiche che il trigger deve utilizzare. Puoi selezionare **Minimum (Minimo)**, **Maximum (Massimo)**, **Sum (Somma)** o **Average (Media)** per **Trigger Statistic (Statistica trigger)**.
+ In **Unit of Measurement (Unità di misura)**, specifica l'unità per la misurazione del trigger.
+ Il valore nella casella **Periodo di misurazione** specifica la frequenza con cui Amazon CloudWatch misura le metriche relative al trigger. **Breach Duration (Durata della violazione)** specifica la quantità di tempo in cui un parametro può essere oltre il limite definito (specificato in **Upper Treshold (Soglia superiore)** e in **Lower Threshold (Soglia inferiore)**) prima che il trigger si attivi.
+ Per **Upper Breach Scale Increment** e **Lower Breach Scale Increment**, specifica quante EC2 istanze Amazon aggiungere o rimuovere durante l'esecuzione di un'attività di scalabilità. 

Per ulteriori informazioni su Amazon EC2 Auto Scaling, consulta la sezione *Amazon Auto EC2 Scaling* nella documentazione di [Amazon Elastic](https://aws.amazon.com/documentation/ec2/) Compute Cloud.

# Configurazione delle notifiche utilizzando AWS il toolkit per Visual Studio
<a name="create_deploy_NET.container.sns"></a>

Elastic Beanstalk utilizza Amazon Simple Notification Service (Amazon SNS) per la notifica di eventi importanti che interessano l'applicazione. Per abilitare le notifiche di Amazon SNS, è sufficiente inserire il tuo indirizzo e-mail nella casella **Email Address (Indirizzo e-mail)**. Per disabilitare queste notifiche, elimina il tuo indirizzo e-mail dalla casella di testo.

![\[Finestra delle notifiche di Elastic Beanstalk\]](http://docs.aws.amazon.com/it_it/elasticbeanstalk/latest/dg/images/aeb-vs-notifications.png)


# Configurazione dei contenitori.NET utilizzando il AWS toolkit per Visual Studio
<a name="create_deploy_NET.container"></a>

 Il pannello **Container/.NET Options** consente di ottimizzare il comportamento delle EC2 istanze Amazon e abilitare o disabilitare la rotazione dei log di Amazon S3. Puoi usare AWS Toolkit for Visual Studio per configurare le informazioni sul contenitore.

**Nota**  
È possibile modificare le impostazioni di configurazione senza tempi di inattività scambiando il CNAME per i tuoi ambienti. Per ulteriori informazioni, consulta [Distribuzioni blu/verde con Elastic Beanstalk](using-features.CNAMESwap.md).

Se desideri, è possibile estendere il numero di parametri. Per informazioni sull'estensione dei parametri consulta [Impostazioni opzioni](ebextensions-optionsettings.md).

**Per accedere al pannello delle opzioni Container/.NET dell'applicazione Elastic Beanstalk**

1. In AWS Toolkit for Visual Studio, espandi il nodo Elastic Beanstalk e il nodo dell'applicazione. 

1. In **AWS Explorer**, fai doppio clic sull'ambiente Elastic Beanstalk.

1. Nella parte inferiore del riquadro **Overview (Panoramica)**, fai clic sulla scheda **Configuration (Configurazione)**.

1. In **Container**, puoi configurare le opzioni relative al container.   
![\[Pannello del container Elastic Beanstalk\]](http://docs.aws.amazon.com/it_it/elasticbeanstalk/latest/dg/images/aeb-vs-container.png)

## Opzioni del container .NET
<a name="create_deploy_NET.container.vs.options"></a>

È possibile scegliere la versione di .NET Framework per la tua applicazione. Scegli 2.0 o 4.0 per **Target runtime (Runtime target)**. Seleziona **Enable 32-bit Applications (Abilita le applicazioni a 32 bit)** per abilitare le applicazioni a 32 bit.

## Impostazioni applicazioni
<a name="create_deploy_NET.container.vs.options.envprop"></a>

La sezione **Application Settings (Impostazioni applicazione)** consente di specificare variabili di ambiente che puoi leggere dal codice dell'applicazione. 

![\[Pannello del container Elastic Beanstalk\]](http://docs.aws.amazon.com/it_it/elasticbeanstalk/latest/dg/images/aeb-vs-container-envproperties.png)


# Gestione degli account
<a name="create_deploy_NET.accounts"></a>

## 
<a name="create_deploy_NET.accounts.details"></a>

Se desideri configurare AWS account diversi per eseguire attività diverse, come test, gestione temporanea e produzione, puoi aggiungere, modificare ed eliminare account utilizzando AWS Toolkit for Visual Studio.

**Gestione di più account**

1.  In Visual Studio, nel menu **View (Visualizza)**, fai clic su **AWS Explorer**.

1.  Accanto all'elenco **Account**, fai clic sul pulsante **Add account (Aggiungi account)**.   
![\[AWS scheda Explorer\]](http://docs.aws.amazon.com/it_it/elasticbeanstalk/latest/dg/images/aeb-aws-explorer-tab.png)

    Si apre la finestra di dialogo **Add account (Aggiungi account)**.   
![\[Finestra di dialogo Add account (Aggiungi account)\]](http://docs.aws.amazon.com/it_it/elasticbeanstalk/latest/dg/images/aeb-vs-add-account.png)

1. Inserisci le informazioni richieste. 

1.  Le informazioni sul tuo account ora appaiono nella scheda **AWS Explorer**. Quando pubblichi su Elastic Beanstalk, è possibile selezionare l'account da utilizzare. 

# Creazione di elenchi e connessioni alle istanze dei server
<a name="create_deploy_NET.ec2connect"></a>

Puoi visualizzare un elenco di EC2 istanze Amazon che eseguono il tuo ambiente applicativo Elastic Beanstalk tramite Toolkit AWS for Visual Studio o dalla console di gestione. AWS Puoi connetterti a queste istanze utilizzando la connessione al desktop remoto. Per informazioni su come elencare e connettersi alle istanze del server utilizzando la console di gestione, consulta. AWS [Creazione di elenchi e connessioni alle istanze dei server](using-features.ec2connect.md) La sezione seguente illustra come visualizzare e connettere l'utente alle istanze del server utilizzando AWS Toolkit for Visual Studio.

**Per visualizzare e connettersi alle EC2 istanze Amazon per un ambiente**

1.  In Visual Studio, in **AWS Explorer**, espandi il EC2 nodo **Amazon** e fai doppio clic su **Istanze**. 

1.  Fai clic con il pulsante destro del mouse sull'ID dell' EC2 istanza Amazon in esecuzione nel sistema di bilanciamento del carico dell'applicazione nella colonna **Istanza** e seleziona **Open Remote Desktop** dal menu contestuale.   
![\[Finestra di dialogo Open Remote Desktop (Apri desktop remoto)\]](http://docs.aws.amazon.com/it_it/elasticbeanstalk/latest/dg/images/aeb-vs-rdp-login.png)

1.  Seleziona **Usa EC2 coppia di chiavi per accedere** e incolla il contenuto del file di chiave privata che hai usato per distribuire l'applicazione nella casella Chiave **privata**. In alternativa, immetti il tuo nome utente e la password nelle caselle di testo **User name (Nome utente)** e **Password**.
**Nota**  
Se la coppia di chiavi viene archiviata all'interno del Toolkit, la casella di testo non viene visualizzata.

1. Fare clic su **OK**.

# Monitoraggio dello stato dell'applicazione
<a name="create_deploy_NET.healthstatus"></a>

Quando esegui un sito Web di produzione, è importante sapere che la tua applicazione è disponibile e risponde alle richieste. Per facilitare il monitoraggio della reattività dell'applicazione, Elastic Beanstalk fornisce caratteristiche che consentono di controllare le statistiche sull'applicazione e creare avvisi che vengono attivati al superamento delle soglie.

Per informazioni sul monitoraggio dello stato fornito da Elastic Beanstalk, consulta [Report dello stato di base](using-features.healthstatus.md).

È possibile accedere alle informazioni operative sull'applicazione utilizzando il AWS Toolkit for Visual Studio o AWS la Console di gestione.

Il kit di strumenti mostra lo stato dell'ambiente e delle applicazioni nel campo **Status (Stato)**.

![\[Stato di integrità di Elastic Beanstalk\]](http://docs.aws.amazon.com/it_it/elasticbeanstalk/latest/dg/images/aeb-vs-env-status.png)


**Per monitorare lo stato dell'applicazione**

1. In AWS Toolkit for Visual Studio, **AWS in** Explorer, espandi il nodo Elastic Beanstalk, quindi espandi il nodo dell'applicazione. 

1. Fai clic con il pulsante destro del mouse sull'ambiente Elastic Beanstalk, quindi fai clic su **View Status (Visualizza stato)**.

1. Nella scheda dell'ambiente dell'applicazione, fai clic su **Monitoring (Monitoraggio)**.

   Il pannello **Monitoring (Monitoraggio)** include un set di grafici che mostrano l'utilizzo delle risorse per un ambiente applicativo specifico.  
![\[Pannello di monitoraggio di Elastic Beanstalk\]](http://docs.aws.amazon.com/it_it/elasticbeanstalk/latest/dg/images/aeb-vs-monitoring.png)
**Nota**  
Per impostazione predefinita, l'intervallo di tempo è impostato sull'ultima ora. Per modificare questa impostazione, nell'elenco **Time Range (Intervallo tempo)** fai clic su un altro intervallo temporale.

È possibile utilizzare AWS Toolkit for Visual Studio o AWS la Console di gestione per visualizzare gli eventi associati all'applicazione.

**Per visualizzare gli eventi dell'applicazione**

1. Nel AWS Toolkit for Visual Studio, **AWS in** Explorer, espandi il nodo Elastic Beanstalk e il nodo dell'applicazione. 

1. Fai clic con il pulsante destro del mouse sull'ambiente Elastic Beanstalk in **AWS Explorer**, quindi fai clic su **View Status (Visualizza stato)**. 

1. Nella scheda dell'ambiente dell'applicazione, fai clic su **Events (Eventi)**.  
![\[Pannello degli eventi di Elastic Beanstalk\]](http://docs.aws.amazon.com/it_it/elasticbeanstalk/latest/dg/images/aeb-vs-events.png)

# Distribuzione di applicazioni Elastic Beanstalk in.NET utilizzando strumenti di distribuzione AWS
<a name="deploy_NET_standalone_tool"></a>

AWS offre due strumenti da riga di comando per distribuire applicazioni.NET Core e ASP.NET Core su Elastic Beanstalk:
+ **AWS Strumento di distribuzione.NET**: un moderno strumento a riga di comando che semplifica la distribuzione di applicazioni.NET nei AWS servizi, incluso Elastic Beanstalk. Questo strumento offre un'esperienza interattiva ed è in grado di rilevare automaticamente il servizio migliore AWS per l'applicazione. Per ulteriori informazioni, consulta [lo strumento di AWS distribuzione.NET](https://github.com/aws/aws-dotnet-deploy?tab=readme-ov-file#aws-net-deployment-tool).
+ **AWS Estensioni per .NET CLI**: un insieme di estensioni CLI.NET che forniscono comandi per la distribuzione di applicazioni.NET Core su Elastic Beanstalk e altri servizi. AWS Queste estensioni si integrano con il flusso di lavoro standard dell'interfaccia CLI.NET. Per ulteriori informazioni, consulta [AWS Extensions for .NET CLI](https://github.com/aws/aws-extensions-for-dotnet-cli?tab=readme-ov-file#aws-elastic-beanstalk-amazonelasticbeanstalktools).

# Migrazione dell'applicazione.NET in locale a Elastic Beanstalk
<a name="dotnet-onpremmigration"></a>

AWS Elastic Beanstalk fornisce un percorso di migrazione semplificato per le applicazioni Windows in esecuzione su Internet Information Services (IIS) tramite l'Elastic Beanstalk Command Line Interface (EB CLI). Il **eb migrate** comando rileva automaticamente i siti, le applicazioni e le directory virtuali IIS, ne preserva le configurazioni e li distribuisce nel cloud. AWS 

Questa funzionalità di migrazione integrata offre un approccio più semplice che riduce la complessità e il tempo tipicamente associati alle migrazioni cloud. Il processo di migrazione aiuta a mantenere la funzionalità dell'applicazione e l'integrità della configurazione durante la transizione a. AWS

Per istruzioni complete e dettagliate sulla migrazione delle applicazioni IIS a AWS Elastic Beanstalk, consulta il [Migrazione delle applicazioni IIS su Elastic Beanstalk](dotnet-migrating-applications.md) capitolo di questa guida.

# Consigli per i componenti ritirati di Windows Server su Elastic Beanstalk
<a name="dotnet-deprecation-recommendations"></a>

Questo argomento fornisce consigli se le applicazioni sono attualmente in esecuzione sui rami della piattaforma Windows Server 2012 R2 ritirati. Riguarda anche il supporto obsoleto per le versioni dei protocolli TLS 1.0 e 1.1 sugli endpoint delle nostre API di AWS servizio e sui rami della piattaforma interessati.

## Ramificazioni della piattaforma Windows Server 2012 R2 ritirate
<a name="dotnet-retired-branches"></a>

Elastic Beanstalk ha ritirato le [filiali della piattaforma Windows Server 2012 R2 il 4 dicembre](https://docs.aws.amazon.com/elasticbeanstalk/latest/relnotes/release-2023-12-04-windows-2012-retire.html) 2023 e AMIs ha reso private quelle associate a tali piattaforme il 10 aprile 2024. Questa azione impedisce l'avvio di istanze negli ambienti Windows Server 2012 che utilizzano l'AMI Beanstalk predefinita.

Se disponi di ambienti in esecuzione su rami della piattaforma Windows ritirati, ti consigliamo di migrarli su una delle seguenti piattaforme Windows Server, che sono attuali e completamente supportate:
+ Windows Server 2022 con IIS 10.0 versione 2.x
+ Windows Server 2019 con IIS 10.0 versione 2.x

Per considerazioni complete sulla migrazione, consulta [Migrazione da versioni principali della piattaforma Windows Server](dotnet-v2migration.md#dotnet-v2migration.migration).

Per informazioni sulla dichiarazione della piattaforma come obsolete, consulta [Policy di supporto per la piattaforma Elastic Beanstalk](platforms-support-policy.md).

**Nota**  
Se non riesci a migrare verso queste piattaforme completamente supportate, ti consigliamo di utilizzare un'immagine personalizzata AMIs creata con Windows Server 2012 R2 o Windows Server 2012 R2 Core AMIs come immagine di base, se non l'hai già fatto. Per istruzioni dettagliate, vedi [Preservare l'accesso a una Amazon Machine Image (AMI) per una piattaforma ritirata](using-features.customenv-env-copy.md). Rivolgiti al [AWS Support Center](https://console.aws.amazon.com/support/home#/) se hai bisogno di accedere temporaneamente a un'AMI mentre esegui una di queste fasi di migrazione.

## Compatibilità con TLS 1.2
<a name="tls-1-2-enforcement."></a>

A partire dal 31 dicembre 2023, AWS ha iniziato a applicare completamente TLS 1.2 su tutti gli endpoint AWS API. Questa azione ha rimosso la possibilità di utilizzare le versioni TLS 1.0 e 1.1 con tutti. AWS APIs Queste informazioni sono state originariamente comunicate [il 28 giugno 2022](https://aws.amazon.com/blogs/security/tls-1-2-required-for-aws-endpoints/). Per evitare il rischio di un impatto sulla disponibilità, aggiorna tutti gli ambienti che eseguono le versioni della piattaforma qui identificate a una versione più recente il prima possibile, se non l'hai già fatto.

**Impatto potenziale**  
Le versioni delle piattaforme Elastic Beanstalk che eseguono TLS v1.1 o precedenti ne risentono. Questa modifica influisce sulle azioni ambientali che includono, a titolo esemplificativo ma non esaustivo: distribuzioni di configurazione, distribuzione di applicazioni, scalabilità automatica, lancio di un nuovo ambiente, rotazione dei log, report sullo stato migliorati e pubblicazione dei log delle applicazioni nel bucket Amazon S3 associato alle tue applicazioni.

**Versioni della piattaforma Windows interessate**  
Si consiglia ai clienti con ambienti Elastic Beanstalk sulle versioni della piattaforma riportate di seguito di aggiornare ciascuno degli ambienti corrispondenti alla versione della piattaforma Windows 2.8.3 o successiva, rilasciata il [18 febbraio 2022](https://docs.aws.amazon.com/elasticbeanstalk/latest/relnotes/release-2022-02-18-windows.html).
+ Windows Server 2019: versione della piattaforma 2.8.2 o versioni precedenti

Si consiglia ai clienti con ambienti Elastic Beanstalk sulle versioni della piattaforma riportate di seguito di aggiornare ciascuno degli ambienti corrispondenti alla versione della piattaforma Windows 2.10.7 o successiva, rilasciata il [28 dicembre 2022](https://docs.aws.amazon.com/elasticbeanstalk/latest/relnotes/release-2022-12-28-windows.html).
+ Windows Server 2016: versione della piattaforma 2.10.6 o versioni precedenti
+ [Windows Server 2012: tutte le versioni della piattaforma; questa piattaforma è stata ritirata il 4 dicembre 2023](https://docs.aws.amazon.com/elasticbeanstalk/latest/relnotes/release-2023-12-04-windows-2012-retire.html) 
+ Windows Server 2008: tutte le versioni della piattaforma; questa piattaforma è stata ritirata [il 28 ottobre 2019](https://docs.aws.amazon.com/elasticbeanstalk/latest/relnotes/release-2019-10-28-windows.html) 

Per un elenco delle versioni della piattaforma di Windows Server più recenti e supportate, consulta la pagina [Piattaforme supportate](https://docs.aws.amazon.com/elasticbeanstalk/latest/platforms/platforms-supported.html#platforms-supported.net) nella guida *Piattaforme AWS Elastic Beanstalk *. 

Per dettagli e procedure consigliate sull'aggiornamento dell'ambiente, consulta [Aggiornamento della versione della piattaforma dell'ambiente Elastic Beanstalk](using-features.platform.upgrade.md).