

Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

# Bereitstellen von.NET-Windows-Anwendungen mit Elastic Beanstalk
<a name="create_deploy_NET"></a>

**Schauen Sie sich *das.NET im AWS Developer Center an***  
  
Haben Sie schon einmal in unserem *.Net Developer Center vorbeigeschaut*? Es ist unsere zentrale Anlaufstelle für alles, was mit .NET zu tun hat AWS.  
Weitere Informationen finden Sie [unter.NET on AWS Developer Center](https://aws.amazon.com/developer/language/net).

Dieses Kapitel enthält Anweisungen zur Konfiguration und Bereitstellung Ihrer ASP.NET- und .NET Core-Windows-Webanwendungen für AWS Elastic Beanstalk. Elastic Beanstalk macht es einfach, Ihren.NET-Webanwendungen (Windows) mithilfe von Amazon Web Services bereitzustellen, zu verwalten und zu skalieren.

Sie können Ihre Anwendung in nur wenigen Minuten mithilfe der Elastic Beanstalk Command Line Interface (EB CLI) oder der Elastic Beanstalk Beanstalk-Konsole bereitstellen. Nachdem Sie Ihre Elastic Beanstalk Beanstalk-Anwendung bereitgestellt haben, können Sie weiterhin die EB-CLI verwenden, um Ihre Anwendung und Umgebung zu verwalten, oder Sie können die Elastic Beanstalk Beanstalk-Konsole verwenden, AWS CLI oder die. APIs

Dieses Kapitel enthält die folgenden Tutorials:
+ [QuickStart für .NET Core unter Windows](dotnet-quickstart.md)— Step-by-step Anweisungen zum Erstellen und Bereitstellen einer *Hello World* .NET Core-Windows-Anwendung mithilfe der EB CLI.
+ [QuickStart für ASP.NET](aspnet-quickstart.md)— Step-by-step Anweisungen zum Erstellen und Bereitstellen einer *Hello World-ASP.NET-Anwendung* mit dem AWS Toolkit for Visual Studio.

Wenn Sie Hilfe bei der Entwicklung von Windows .NET Core-Anwendungen benötigen, können Sie sich an mehrere Stellen wenden:
+  [.NET-Entwicklungsforum](https://forums.aws.amazon.com/forum.jspa?forumID=61) — Stellen Sie Ihre Fragen und erhalten Sie Feedback.
+ [.NET Developer Center](https://aws.amazon.com/net/) — Eine zentrale Anlaufstelle für Beispielcode, Dokumentation, Tools und zusätzliche Ressourcen.
+ [AWS SDK for .NET für.NET-Dokumentation](https://aws.amazon.com/documentation/sdk-for-net/) — Lesen Sie mehr über das Einrichten des SDK und das Ausführen von Codebeispielen, Funktionen des SDK und detaillierte Informationen zu den API-Vorgängen für das SDK.

**Anmerkung**  
Diese Plattform unterstützt keine Arbeitsumgebungen. Details hierzu finden Sie unter [Elastic-Beanstalk-Worker-Umgebungen](using-features-managing-env-tiers.md). 

**Topics**
+ [QuickStart: Stellen Sie eine.NET-Core-Anwendung für Windows auf Elastic Beanstalk bereit](dotnet-quickstart.md)
+ [QuickStart: Stellen Sie eine ASP.NET-Anwendung auf Elastic Beanstalk bereit](aspnet-quickstart.md)
+ [Einrichten der .NET-Entwicklungsumgebung](dotnet-devenv.md)
+ [Verwendung der Elastic Beanstalk .NET Windows-Plattform](create_deploy_NET.container.console.md)
+ [Hinzufügen einer Amazon RDS-DB-Instance zur .NET-Anwendungsumgebung](create_deploy_NET.rds.md)
+ [Die AWS Toolkit for Visual Studio](dotnet-toolkit.md)
+ [Migrieren Ihrer lokalen .NET-Anwendung zu Elastic Beanstalk](dotnet-onpremmigration.md)
+ [Empfehlungen für ausrangierte Windows Server-Komponenten auf Elastic Beanstalk](dotnet-deprecation-recommendations.md)

# QuickStart: Stellen Sie eine.NET-Core-Anwendung für Windows auf Elastic Beanstalk bereit
<a name="dotnet-quickstart"></a>

 QuickStart In diesem Tutorial erfahren Sie, wie Sie eine.NET Core-Anwendung für Windows erstellen und in einer AWS Elastic Beanstalk Umgebung bereitstellen.

**Nicht für Produktionszwecke**  
Beispiele dienen nur zur Veranschaulichung. Verwenden Sie keine Beispielanwendungen in der Produktion.

**Topics**
+ [Ihr AWS Konto](#dotnet-quickstart-aws-account)
+ [Voraussetzungen](#dotnet-quickstart-prereq)
+ [Schritt 1: Erstellen Sie eine.NET Core-Anwendung für Windows](#dotnet-quickstart-create-app)
+ [Schritt 2: Führen Sie Ihre Anwendung lokal aus](#dotnet-quickstart-run-local)
+ [Schritt 3: Stellen Sie Ihre.NET Core on Windows-Anwendung mit der EB CLI bereit](#dotnet-quickstart-deploy)
+ [Schritt 4: Führen Sie Ihre Anwendung auf Elastic Beanstalk aus](#dotnet-quickstart-run-eb-ap)
+ [Schritt 5: Bereinigen](#go-tutorial-cleanup)
+ [AWS Ressourcen für Ihre Anwendung](#dotnet-quickstart-eb-resources)
+ [Nächste Schritte](#dotnet-quickstart-next-steps)
+ [Bereitstellung mit der Elastic Beanstalk Beanstalk-Konsole](#dotnet-quickstart-console)

## Ihr AWS Konto
<a name="dotnet-quickstart-aws-account"></a>

Wenn Sie noch kein AWS Kunde sind, müssen Sie ein AWS Konto erstellen. Wenn Sie sich registrieren, können Sie auf Elastic Beanstalk und andere AWS Dienste zugreifen, die Sie benötigen.

Wenn Sie bereits ein AWS Konto haben, können Sie weitermachen zu. [Voraussetzungen](#dotnet-quickstart-prereq)

### Erstellen Sie ein AWS Konto
<a name="dotnet-quickstart-aws-account-procedure"></a>

#### Melde dich an für ein AWS-Konto
<a name="sign-up-for-aws"></a>

Wenn Sie noch keine haben AWS-Konto, führen Sie die folgenden Schritte aus, um eine zu erstellen.

**Um sich für eine anzumelden AWS-Konto**

1. Öffnen Sie [https://portal.aws.amazon.com/billing/die Anmeldung.](https://portal.aws.amazon.com/billing/signup)

1. Folgen Sie den Online-Anweisungen.

   Während der Anmeldung erhalten Sie einen Telefonanruf oder eine Textnachricht und müssen einen Verifizierungscode über die Telefontasten eingeben.

   Wenn Sie sich für eine anmelden AWS-Konto, *Root-Benutzer des AWS-Kontos*wird eine erstellt. Der Root-Benutzer hat Zugriff auf alle AWS-Services und Ressourcen des Kontos. Als bewährte Sicherheitsmethode weisen Sie einem Benutzer Administratorzugriff zu und verwenden Sie nur den Root-Benutzer, um [Aufgaben auszuführen, die Root-Benutzerzugriff erfordern](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_root-user.html#root-user-tasks).

AWS sendet Ihnen nach Abschluss des Anmeldevorgangs eine Bestätigungs-E-Mail. Du kannst jederzeit deine aktuellen Kontoaktivitäten einsehen und dein Konto verwalten, indem du zu [https://aws.amazon.com/](https://aws.amazon.com/)gehst und **Mein Konto** auswählst.

#### Erstellen eines Benutzers mit Administratorzugriff
<a name="create-an-admin"></a>

Nachdem Sie sich für einen angemeldet haben AWS-Konto, sichern Sie Ihren Root-Benutzer des AWS-Kontos AWS IAM Identity Center, aktivieren und erstellen Sie einen Administratorbenutzer, sodass Sie den Root-Benutzer nicht für alltägliche Aufgaben verwenden.

**Sichern Sie Ihre Root-Benutzer des AWS-Kontos**

1.  Melden Sie sich [AWS-Managementkonsole](https://console.aws.amazon.com/)als Kontoinhaber an, indem Sie **Root-Benutzer** auswählen und Ihre AWS-Konto E-Mail-Adresse eingeben. Geben Sie auf der nächsten Seite Ihr Passwort ein.

   Hilfe bei der Anmeldung mit dem Root-Benutzer finden Sie unter [Anmelden als Root-Benutzer](https://docs.aws.amazon.com/signin/latest/userguide/console-sign-in-tutorials.html#introduction-to-root-user-sign-in-tutorial) im *AWS-Anmeldung -Benutzerhandbuch* zu.

1. Aktivieren Sie die Multi-Faktor-Authentifizierung (MFA) für den Root-Benutzer.

   Anweisungen finden Sie unter [Aktivieren eines virtuellen MFA-Geräts für Ihren AWS-Konto Root-Benutzer (Konsole)](https://docs.aws.amazon.com/IAM/latest/UserGuide/enable-virt-mfa-for-root.html) im *IAM-Benutzerhandbuch*.

**Erstellen eines Benutzers mit Administratorzugriff**

1. Aktivieren Sie das IAM Identity Center.

   Anweisungen finden Sie unter [Aktivieren AWS IAM Identity Center](https://docs.aws.amazon.com//singlesignon/latest/userguide/get-set-up-for-idc.html) im *AWS IAM Identity Center -Benutzerhandbuch*.

1. Gewähren Sie einem Administratorbenutzer im IAM Identity Center Benutzerzugriff.

   *Ein Tutorial zur Verwendung von IAM-Identity-Center-Verzeichnis als Identitätsquelle finden Sie IAM-Identity-Center-Verzeichnis im Benutzerhandbuch unter [Benutzerzugriff mit der Standardeinstellung konfigurieren](https://docs.aws.amazon.com//singlesignon/latest/userguide/quick-start-default-idc.html).AWS IAM Identity Center *

**Anmelden als Administratorbenutzer**
+ Um sich mit Ihrem IAM-Identity-Center-Benutzer anzumelden, verwenden Sie die Anmelde-URL, die an Ihre E-Mail-Adresse gesendet wurde, als Sie den IAM-Identity-Center-Benutzer erstellt haben.

  Hilfe bei der Anmeldung mit einem IAM Identity Center-Benutzer finden Sie [im *AWS-Anmeldung Benutzerhandbuch* unter Anmeldung beim AWS Access-Portal](https://docs.aws.amazon.com/signin/latest/userguide/iam-id-center-sign-in-tutorial.html).

**Weiteren Benutzern Zugriff zuweisen**

1. Erstellen Sie im IAM-Identity-Center einen Berechtigungssatz, der den bewährten Vorgehensweisen für die Anwendung von geringsten Berechtigungen folgt.

   Anweisungen hierzu finden Sie unter [ Berechtigungssatz erstellen](https://docs.aws.amazon.com//singlesignon/latest/userguide/get-started-create-a-permission-set.html) im *AWS IAM Identity Center -Benutzerhandbuch*.

1. Weisen Sie Benutzer einer Gruppe zu und weisen Sie der Gruppe dann Single Sign-On-Zugriff zu.

   Eine genaue Anleitung finden Sie unter [ Gruppen hinzufügen](https://docs.aws.amazon.com//singlesignon/latest/userguide/addgroups.html) im *AWS IAM Identity Center -Benutzerhandbuch*.

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

Um die Verfahren in diesem Leitfaden zu befolgen, benötigen Sie ein Befehlszeilen-Terminal oder eine Shell für die Ausführung der Befehle. Befehle werden in Auflistungen angezeigt, denen ein Eingabeaufforderungssymbol (>) und gegebenenfalls der Name des aktuellen Verzeichnisses vorangestellt sind.

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

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

Dieses Tutorial verwendet die Befehlszeilenschnittstelle Elastic Beanstalk Command Line Interface (EB CLI). Detaillierte Anweisungen zum Installieren und Konfigurieren der EB CLI finden Sie unter [EB CLI mit Setup-Skript installieren (empfohlen)](eb-cli3.md#eb-cli3-install) und [Konfigurieren der EB CLI](eb-cli3-configuration.md).

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

Wenn Sie das .NET SDK nicht auf Ihrem lokalen Computer installiert haben, können Sie es installieren, indem Sie auf der Website mit der [.NET-Dokumentation auf den Link .NET](https://learn.microsoft.com/en-us/dotnet/) [herunterladen](https://dotnet.microsoft.com/en-us/download) klicken.

Überprüfen Sie Ihre .NET SDK-Installation, indem Sie den folgenden Befehl ausführen.

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

## Schritt 1: Erstellen Sie eine.NET Core-Anwendung für Windows
<a name="dotnet-quickstart-create-app"></a>

Erstellen Sie ein Projektverzeichnis.

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

Erstellen Sie als Nächstes eine Hello RESTful World-Beispiel-Webdienstanwendung, indem Sie die folgenden Befehle ausführen.

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

## Schritt 2: Führen Sie Ihre Anwendung lokal aus
<a name="dotnet-quickstart-run-local"></a>

Führen Sie den folgenden Befehl aus, um Ihre Anwendung lokal auszuführen.

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

Die Ausgabe sollte etwa wie der folgende Text aussehen.

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

**Anmerkung**  
Der `dotnet` Befehl wählt zufällig einen Port aus, wenn die Anwendung lokal ausgeführt wird. In diesem Beispiel ist der Port 5228. Wenn Sie die Anwendung in Ihrer Elastic Beanstalk Beanstalk-Umgebung bereitstellen, wird die Anwendung auf Port 5000 ausgeführt.

Geben Sie die URL-Adresse `http://localhost:port` in Ihren Webbrowser ein. Für dieses spezielle Beispiel lautet der Befehl`http://localhost:5228`. Der Webbrowser sollte „Hello World\$1“ anzeigen.

## Schritt 3: Stellen Sie Ihre.NET Core on Windows-Anwendung mit der EB CLI bereit
<a name="dotnet-quickstart-deploy"></a>

Führen Sie die folgenden Befehle aus, um eine Elastic Beanstalk Beanstalk-Umgebung für diese Anwendung zu erstellen.

 

**Um eine Umgebung zu erstellen und Ihre Anwendung für.NET Core unter Windows bereitzustellen**

1. Führen Sie die folgenden Befehle im `HelloElasticBeanstalk` Verzeichnis aus, um Ihre Anwendung zu veröffentlichen und zu komprimieren.

   ```
   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. Erstellen Sie im `HelloElasticBeanstalk` aufgerufenen Ordner eine neue Datei `aws-windows-deployment-manifest.json` mit dem folgenden Inhalt: 

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

1. Initialisieren Sie mit dem Befehl **eb init** das EB CLI-Repository.

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

   Dieser Befehl erstellt eine Anwendung mit dem Namen `dotnet-windows-server-tutorial` und konfiguriert Ihr lokales Repository so, dass Umgebungen mit der neuesten Version der Windows-Serverplattform erstellt werden.

1. Verwenden Sie **eb create**, um eine Umgebung zu erstellen und die Anwendung darin bereitzustellen. Elastic Beanstalk erstellt automatisch eine Zip-Datei für Ihre Anwendung und startet sie auf Port 5000.

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

   Es dauert etwa fünf Minuten, bis Elastic Beanstalk Ihre Umgebung erstellt hat.

## Schritt 4: Führen Sie Ihre Anwendung auf Elastic Beanstalk aus
<a name="dotnet-quickstart-run-eb-ap"></a>

Wenn der Prozess zur Erstellung Ihrer Umgebung abgeschlossen ist, öffnen Sie Ihre Website mit. **eb open**

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

Herzlichen Glückwunsch\$1 Sie haben eine.NET-Core-Anwendung für Windows mit Elastic Beanstalk bereitgestellt\$1 Es wird ein Browserfenster mit dem für die Anwendung erstellten Domainnamen geöffnet.

## Schritt 5: Bereinigen
<a name="go-tutorial-cleanup"></a>

Sie können Ihre Umgebung beenden, wenn Sie mit der Arbeit an Ihrer Anwendung fertig sind. Elastic Beanstalk beendet alle AWS Ressourcen, die mit Ihrer Umgebung verknüpft sind.

Führen Sie den folgenden Befehl aus, um Ihre Elastic Beanstalk Beanstalk-Umgebung mit der EB-CLI zu beenden.

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

## AWS Ressourcen für Ihre Anwendung
<a name="dotnet-quickstart-eb-resources"></a>

Sie haben gerade eine Einzelinstanzanwendung erstellt. Es dient als einfache Beispielanwendung mit einer einzigen EC2-Instance, sodass kein Lastenausgleich oder auto Skalierung erforderlich sind. Für Einzelinstanzanwendungen erstellt Elastic Beanstalk die folgenden Ressourcen: AWS 
+ **EC2 instance (EC2-Instance)** – Eine virtuelle Amazon EC2-Maschine zum Ausführen von Webanwendungen auf der von Ihnen ausgewählten Plattform.

  Jede Plattform führt eine andere Gruppe von Software, Konfigurationsdateien und Skripts zur Unterstützung einer bestimmten Sprachversion, eines Framework, Webcontainers oder einer Kombination daraus aus. Die meisten Plattformen verwenden entweder Apache oder nginx als Reverse-Proxy, der Web-Datenverkehr vor Ihrer Web-App verarbeitet, Anforderungen an sie weiterleitet, statische Komponenten verarbeitet und Zugriffs- und Fehlerprotokolle generiert.
+ **Instance security group (Instance-Sicherheitsgruppe)** – Eine Amazon EC2-Sicherheitsgruppe, die so konfiguriert ist, dass eingehender Datenverkehr auf Port 80 zugelassen wird. Mit dieser Ressource kann HTTP-Datenverkehr vom Load Balancer die EC2-Instance mit Ihrer Web-App erreichen. Standardmäßig ist Datenverkehr ist auf anderen Ports nicht zulässig.
+ **Amazon S3-Bucket** – Ein Speicherort für Ihren Quellcode, Protokolle und andere Artefakte, die bei der Verwendung von Elastic Beanstalk erstellt werden.
+ ** CloudWatch Amazon-Alarme** — Zwei CloudWatch Alarme, die die Auslastung der Instances in Ihrer Umgebung überwachen und ausgelöst werden, wenn die Last zu hoch oder zu niedrig ist. Wenn ein Alarm ausgelöst wird, wird Ihre Auto Scaling-Gruppe nach oben oder nach unten skaliert.
+ **CloudFormation stack** — Elastic Beanstalk verwendet CloudFormation , um die Ressourcen in Ihrer Umgebung zu starten und Konfigurationsänderungen zu propagieren. Die Ressourcen werden in einer Vorlage definiert, die Sie in der [CloudFormation -Konsole](https://console.aws.amazon.com/cloudformation) anzeigen können.
+  **Domainname** *— Ein Domainname, der in der Form an Ihre Web-App weitergeleitet wird. *subdomain* *region*.elasticbeanstalk.com*. 

Elastic Beanstalk verwaltet all diese Ressourcen. Wenn Sie die Umgebung beenden, werden alle darin enthaltenen Ressourcen von Elastic Beanstalk beendet.

## Nächste Schritte
<a name="dotnet-quickstart-next-steps"></a>

Nachdem Sie eine Umgebung erstellt haben, in der eine Anwendung ausgeführt wird, können Sie jederzeit eine neue Version der Anwendung oder eine andere Anwendung bereitstellen. Das Bereitstellen einer neuen Anwendungsversion geht sehr schnell, da keine EC2-Instances bereitgestellt oder neu gestartet werden müssen. Sie können Ihre neue Umgebung auch mit der Elastic Beanstalk Beanstalk-Konsole erkunden. Ausführliche Schritte finden [Sie unter Erkunden Sie Ihre Umgebung](GettingStarted.md#GettingStarted.Explore) im Kapitel *Erste Schritte* dieses Handbuchs.

**Probieren Sie weitere Tutorials aus**  
Wenn Sie andere Tutorials mit anderen Beispielanwendungen ausprobieren möchten, finden Sie weitere Informationen unter[QuickStart für ASP.NET](aspnet-quickstart.md).

Nachdem Sie ein oder zwei Beispielanwendungen bereitgestellt haben und bereit sind, .NET Core lokal auf Windows-Anwendungen zu entwickeln und auszuführen, finden Sie weitere Informationen unter [Einrichten der .NET-Entwicklungsumgebung](dotnet-devenv.md) 

## Bereitstellung mit der Elastic Beanstalk Beanstalk-Konsole
<a name="dotnet-quickstart-console"></a>

Sie können die Beispielanwendung auch mit der Elastic Beanstalk Beanstalk-Konsole starten. Ausführliche Schritte finden Sie unter [Erstellen einer Beispielanwendung](GettingStarted.md#GettingStarted.CreateApp) im Kapitel *Erste Schritte* dieses Handbuchs.

# QuickStart: Stellen Sie eine ASP.NET-Anwendung auf Elastic Beanstalk bereit
<a name="aspnet-quickstart"></a>

 QuickStart In diesem Tutorial erfahren Sie, wie Sie eine ASP.NET-Anwendung erstellen und in einer Umgebung bereitstellen. AWS Elastic Beanstalk 

**Nicht für Produktionszwecke**  
Beispiele dienen nur zur Veranschaulichung. Verwenden Sie keine Beispielanwendungen in der Produktion.

**Topics**
+ [Ihr AWS Konto](#aspnet-quickstart-aws-account)
+ [Voraussetzungen](#aspnet-quickstart-prereq)
+ [Schritt 1: Erstellen Sie eine ASP.NET-Anwendung](#aspnet-quickstart-create-app)
+ [Schritt 2: Führen Sie Ihre Anwendung lokal aus](#aspnet-quickstart-run-local)
+ [Schritt 3: Stellen Sie Ihre ASP.NET-Anwendung mit dem bereit AWS Toolkit for Visual Studio](#aspnet-quickstart-deploy)
+ [Schritt 4: Führen Sie Ihre Anwendung auf Elastic Beanstalk aus](#aspnet-quickstart-run-eb-ap)
+ [Schritt 5: Bereinigen](#aspnet-quickstart-cleanup)
+ [AWS Ressourcen für Ihre Anwendung](#aspnet-quickstart-eb-resources)
+ [Nächste Schritte](#aspnet-quickstart-next-steps)
+ [Bereitstellung mit der Elastic Beanstalk Beanstalk-Konsole](#aspnet-quickstart-console)

## Ihr AWS Konto
<a name="aspnet-quickstart-aws-account"></a>

Wenn Sie noch kein AWS Kunde sind, müssen Sie ein AWS Konto erstellen. Wenn Sie sich registrieren, können Sie auf Elastic Beanstalk und andere AWS Dienste zugreifen, die Sie benötigen.

Wenn Sie bereits ein AWS Konto haben, können Sie weitermachen zu. [Voraussetzungen](#aspnet-quickstart-prereq)

### Erstellen Sie ein AWS Konto
<a name="aspnet-quickstart-aws-account-procedure"></a>

#### Melde dich an für ein AWS-Konto
<a name="sign-up-for-aws"></a>

Wenn Sie noch keine haben AWS-Konto, führen Sie die folgenden Schritte aus, um eine zu erstellen.

**Um sich für eine anzumelden AWS-Konto**

1. Öffnen Sie [https://portal.aws.amazon.com/billing/die Anmeldung.](https://portal.aws.amazon.com/billing/signup)

1. Folgen Sie den Online-Anweisungen.

   Während der Anmeldung erhalten Sie einen Telefonanruf oder eine Textnachricht und müssen einen Verifizierungscode über die Telefontasten eingeben.

   Wenn Sie sich für eine anmelden AWS-Konto, *Root-Benutzer des AWS-Kontos*wird eine erstellt. Der Root-Benutzer hat Zugriff auf alle AWS-Services und Ressourcen des Kontos. Als bewährte Sicherheitsmethode weisen Sie einem Benutzer Administratorzugriff zu und verwenden Sie nur den Root-Benutzer, um [Aufgaben auszuführen, die Root-Benutzerzugriff erfordern](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_root-user.html#root-user-tasks).

AWS sendet Ihnen nach Abschluss des Anmeldevorgangs eine Bestätigungs-E-Mail. Du kannst jederzeit deine aktuellen Kontoaktivitäten einsehen und dein Konto verwalten, indem du zu [https://aws.amazon.com/](https://aws.amazon.com/)gehst und **Mein Konto** auswählst.

#### Erstellen eines Benutzers mit Administratorzugriff
<a name="create-an-admin"></a>

Nachdem Sie sich für einen angemeldet haben AWS-Konto, sichern Sie Ihren Root-Benutzer des AWS-Kontos AWS IAM Identity Center, aktivieren und erstellen Sie einen Administratorbenutzer, sodass Sie den Root-Benutzer nicht für alltägliche Aufgaben verwenden.

**Sichern Sie Ihre Root-Benutzer des AWS-Kontos**

1.  Melden Sie sich [AWS-Managementkonsole](https://console.aws.amazon.com/)als Kontoinhaber an, indem Sie **Root-Benutzer** auswählen und Ihre AWS-Konto E-Mail-Adresse eingeben. Geben Sie auf der nächsten Seite Ihr Passwort ein.

   Hilfe bei der Anmeldung mit dem Root-Benutzer finden Sie unter [Anmelden als Root-Benutzer](https://docs.aws.amazon.com/signin/latest/userguide/console-sign-in-tutorials.html#introduction-to-root-user-sign-in-tutorial) im *AWS-Anmeldung -Benutzerhandbuch* zu.

1. Aktivieren Sie die Multi-Faktor-Authentifizierung (MFA) für den Root-Benutzer.

   Anweisungen finden Sie unter [Aktivieren eines virtuellen MFA-Geräts für Ihren AWS-Konto Root-Benutzer (Konsole)](https://docs.aws.amazon.com/IAM/latest/UserGuide/enable-virt-mfa-for-root.html) im *IAM-Benutzerhandbuch*.

**Erstellen eines Benutzers mit Administratorzugriff**

1. Aktivieren Sie das IAM Identity Center.

   Anweisungen finden Sie unter [Aktivieren AWS IAM Identity Center](https://docs.aws.amazon.com//singlesignon/latest/userguide/get-set-up-for-idc.html) im *AWS IAM Identity Center -Benutzerhandbuch*.

1. Gewähren Sie einem Administratorbenutzer im IAM Identity Center Benutzerzugriff.

   *Ein Tutorial zur Verwendung von IAM-Identity-Center-Verzeichnis als Identitätsquelle finden Sie IAM-Identity-Center-Verzeichnis im Benutzerhandbuch unter [Benutzerzugriff mit der Standardeinstellung konfigurieren](https://docs.aws.amazon.com//singlesignon/latest/userguide/quick-start-default-idc.html).AWS IAM Identity Center *

**Anmelden als Administratorbenutzer**
+ Um sich mit Ihrem IAM-Identity-Center-Benutzer anzumelden, verwenden Sie die Anmelde-URL, die an Ihre E-Mail-Adresse gesendet wurde, als Sie den IAM-Identity-Center-Benutzer erstellt haben.

  Hilfe bei der Anmeldung mit einem IAM Identity Center-Benutzer finden Sie [im *AWS-Anmeldung Benutzerhandbuch* unter Anmeldung beim AWS Access-Portal](https://docs.aws.amazon.com/signin/latest/userguide/iam-id-center-sign-in-tutorial.html).

**Weiteren Benutzern Zugriff zuweisen**

1. Erstellen Sie im IAM-Identity-Center einen Berechtigungssatz, der den bewährten Vorgehensweisen für die Anwendung von geringsten Berechtigungen folgt.

   Anweisungen hierzu finden Sie unter [ Berechtigungssatz erstellen](https://docs.aws.amazon.com//singlesignon/latest/userguide/get-started-create-a-permission-set.html) im *AWS IAM Identity Center -Benutzerhandbuch*.

1. Weisen Sie Benutzer einer Gruppe zu und weisen Sie der Gruppe dann Single Sign-On-Zugriff zu.

   Eine genaue Anleitung finden Sie unter [ Gruppen hinzufügen](https://docs.aws.amazon.com//singlesignon/latest/userguide/addgroups.html) im *AWS IAM Identity Center -Benutzerhandbuch*.

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

Dieses QuickStart Tutorial führt Sie durch die Erstellung einer „Hello World“ -Anwendung und deren Bereitstellung in einer Elastic Beanstalk Beanstalk-Umgebung mit Visual Studio und dem. AWS Toolkit for Visual Studio

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

Folgen Sie den Anweisungen auf der Visual Studio-Downloadseite, um Visual Studio [herunterzuladen](https://visualstudio.microsoft.com/downloads/) und zu installieren. In diesem Beispiel wird Visual Studio 2022 verwendet. Wählen Sie während der Visual Studio-Installation die folgenden spezifischen Elemente aus:
+ Wählen Sie auf der Registerkarte **Workloads** die Option **ASP.NET und Webentwicklung** aus.
+ Wählen Sie auf der Registerkarte **Einzelne Komponenten** die **Entwicklungstools für .NET Framework 4.8** sowie **Projekt- und Elementvorlagen für .NET Framework** aus.

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

 AWS Toolkit for Visual Studio Folgen Sie zum Herunterladen und Einrichten den Anweisungen im Abschnitt [Erste Schritte](https://docs.aws.amazon.com/toolkit-for-visual-studio/latest/user-guide/getting-set-up.html) des AWS Toolkit for Visual Studio Benutzerhandbuchs. 

## Schritt 1: Erstellen Sie eine ASP.NET-Anwendung
<a name="aspnet-quickstart-create-app"></a>

Als Nächstes erstellen Sie eine Anwendung, die Sie in einer Elastic Beanstalk Beanstalk-Umgebung bereitstellen. Wir erstellen eine ASP.NET-Webanwendung „Hello World“.

**Um eine ASP.NET-Anwendung zu erstellen**

1. Starten Sie Visual Studio. Wählen Sie im Menü **Datei** die Option **Neu** und dann **Projekt** aus.

1. Das Dialogfeld **Neues Projekt erstellen** wird angezeigt. Wählen Sie **ASP.NET-Webanwendung (.NET Framework)** und dann **Weiter** aus.

1. Geben **`eb-aspnet`Sie im Dialogfeld „Neues Projekt konfigurieren**“ Ihren **Projektnamen** ein. Wählen Sie **im Dropdownmenü Framework** die Option **.NET Framework 4.8** und dann **Create** aus.

   Notieren Sie sich das Projektverzeichnis. In diesem Beispiel ist das Projektverzeichnis`C:\Users\Administrator\source\repos\eb-aspnet\eb-aspnet`.

1. Das Dialogfeld **Neue ASP.NET-Webanwendung erstellen** wird angezeigt. Wählen Sie die Vorlage **Leer** aus. Wählen Sie als Nächstes **Erstellen** aus.

   Zu diesem Zeitpunkt haben Sie mit Visual Studio ein leeres ASP.NET-Webanwendungsprojekt erstellt. Als Nächstes erstellen wir ein Webformular, das als Einstiegspunkt für die ASP.NET-Webanwendung dient.

1. Wählen Sie im Menü **Projekt** die Option **Neues Element hinzufügen** aus. Wählen Sie auf der Seite **Neues Element hinzufügen** die Option **Webformular** aus und geben Sie dem Objekt einen Namen`Default.aspx`. Wählen Sie als Nächstes **Hinzufügen** aus.

1. Fügen Sie Folgendes hinzu `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>
   ```

## Schritt 2: Führen Sie Ihre Anwendung lokal aus
<a name="aspnet-quickstart-run-local"></a>

Wählen Sie in Visual Studio im Menü **Debug** die Option **Debugging starten** aus, um Ihre Anwendung lokal auszuführen. Auf der Seite sollte „Hello Elastic Beanstalk\$1 Dies ist eine ASP.NET-Anwendung auf Windows Server.“

## Schritt 3: Stellen Sie Ihre ASP.NET-Anwendung mit dem bereit AWS Toolkit for Visual Studio
<a name="aspnet-quickstart-deploy"></a>

Gehen Sie wie folgt vor, um eine Elastic Beanstalk Beanstalk-Umgebung zu erstellen und Ihre neue Anwendung darin bereitzustellen.

**Um eine Umgebung zu erstellen und Ihre ASP.NET-Anwendung bereitzustellen**

1. Klicken Sie im **Solution Explorer** mit der rechten Maustaste auf Ihre Anwendung und wählen Sie dann **Veröffentlichen in AWS Elastic Beanstalk** aus.

1. Wählen Sie einen Namen für Ihre neue Elastic Beanstalk Beanstalk-Anwendung und Umgebung.

1. Danach können Sie mit den von Elastic Beanstalk bereitgestellten Standardeinstellungen fortfahren oder die Optionen und Einstellungen nach Ihren Wünschen ändern.

1. **Wählen Sie auf der Seite „**Überprüfen“ die Option Bereitstellen** aus.** Dadurch wird Ihre ASP.NET-Webanwendung gepackt und auf Elastic Beanstalk bereitgestellt.

   Es dauert etwa fünf Minuten, bis Elastic Beanstalk Ihre Umgebung erstellt hat. Mit der Bereitstellungsfunktion von Elastic Beanstalk wird die Umgebung überwacht, bis sie mit dem neu bereitgestellten Code verfügbar ist. Auf der Registerkarte **Env: < **environment name** >** sehen Sie den Status Ihrer Umgebung.

## Schritt 4: Führen Sie Ihre Anwendung auf Elastic Beanstalk aus
<a name="aspnet-quickstart-run-eb-ap"></a>

Wenn der Prozess zur Erstellung Ihrer Umgebung abgeschlossen ist, werden auf der Registerkarte **Env: < **environment name** >** Informationen zu Ihrer Umgebung und Anwendung angezeigt, einschließlich der Domain-URL zum Starten Ihrer Anwendung. Wählen Sie diese URL auf dieser Registerkarte aus oder kopieren Sie sie und fügen Sie sie in Ihren Webbrowser ein.

Herzlichen Glückwunsch\$1 Sie haben eine ASP.NET-Anwendung mit Elastic Beanstalk bereitgestellt\$1

## Schritt 5: Bereinigen
<a name="aspnet-quickstart-cleanup"></a>

Wenn Sie mit der Arbeit an Ihrer Anwendung fertig sind, können Sie Ihre Umgebung im beenden. AWS Toolkit for Visual Studio

**So beenden Sie Ihre Umgebung**

1. Erweitern Sie den Elastic-Beanstalk-Knoten und den Anwendungsknoten in **AWS Explorer**. Klicken Sie mit der rechten Maustaste auf die Anwendungsumgebung und wählen Sie **Terminate Environment (Umgebung beenden)** aus.

1. Wenn Sie dazu aufgefordert werden, wählen Sie **Ja**, um zu bestätigen, dass Sie die Umgebung beenden möchten. Es wird einige Minuten dauern, bis Elastic Beanstalk die in der Umgebung laufenden AWS Ressourcen beendet hat.

## AWS Ressourcen für Ihre Anwendung
<a name="aspnet-quickstart-eb-resources"></a>

Sie haben gerade eine Einzelinstanzanwendung erstellt. Es dient als einfache Beispielanwendung mit einer einzigen EC2-Instance, sodass kein Lastenausgleich oder auto Skalierung erforderlich sind. Für Einzelinstanzanwendungen erstellt Elastic Beanstalk die folgenden Ressourcen: AWS 
+ **EC2 instance (EC2-Instance)** – Eine virtuelle Amazon EC2-Maschine zum Ausführen von Webanwendungen auf der von Ihnen ausgewählten Plattform.

  Jede Plattform führt eine andere Gruppe von Software, Konfigurationsdateien und Skripts zur Unterstützung einer bestimmten Sprachversion, eines Framework, Webcontainers oder einer Kombination daraus aus. Die meisten Plattformen verwenden entweder Apache oder nginx als Reverse-Proxy, der Web-Datenverkehr vor Ihrer Web-App verarbeitet, Anforderungen an sie weiterleitet, statische Komponenten verarbeitet und Zugriffs- und Fehlerprotokolle generiert.
+ **Instance security group (Instance-Sicherheitsgruppe)** – Eine Amazon EC2-Sicherheitsgruppe, die so konfiguriert ist, dass eingehender Datenverkehr auf Port 80 zugelassen wird. Mit dieser Ressource kann HTTP-Datenverkehr vom Load Balancer die EC2-Instance mit Ihrer Web-App erreichen. Standardmäßig ist Datenverkehr ist auf anderen Ports nicht zulässig.
+ **Amazon S3-Bucket** – Ein Speicherort für Ihren Quellcode, Protokolle und andere Artefakte, die bei der Verwendung von Elastic Beanstalk erstellt werden.
+ ** CloudWatch Amazon-Alarme** — Zwei CloudWatch Alarme, die die Auslastung der Instances in Ihrer Umgebung überwachen und ausgelöst werden, wenn die Last zu hoch oder zu niedrig ist. Wenn ein Alarm ausgelöst wird, wird Ihre Auto Scaling-Gruppe nach oben oder nach unten skaliert.
+ **CloudFormation stack** — Elastic Beanstalk verwendet CloudFormation , um die Ressourcen in Ihrer Umgebung zu starten und Konfigurationsänderungen zu propagieren. Die Ressourcen werden in einer Vorlage definiert, die Sie in der [CloudFormation -Konsole](https://console.aws.amazon.com/cloudformation) anzeigen können.
+  **Domainname** *— Ein Domainname, der in der Form an Ihre Web-App weitergeleitet wird. *subdomain* *region*.elasticbeanstalk.com*. 

Elastic Beanstalk verwaltet all diese Ressourcen. Wenn Sie die Umgebung beenden, werden alle darin enthaltenen Ressourcen von Elastic Beanstalk beendet.

## Nächste Schritte
<a name="aspnet-quickstart-next-steps"></a>

Nachdem Sie eine Umgebung erstellt haben, in der eine Anwendung ausgeführt wird, können Sie jederzeit eine neue Version der Anwendung oder eine andere Anwendung bereitstellen. Das Bereitstellen einer neuen Anwendungsversion geht sehr schnell, da keine EC2-Instances bereitgestellt oder neu gestartet werden müssen. Sie können Ihre neue Umgebung auch mit der Elastic Beanstalk Beanstalk-Konsole erkunden. Ausführliche Schritte finden [Sie unter Erkunden Sie Ihre Umgebung](GettingStarted.md#GettingStarted.Explore) im Kapitel *Erste Schritte* dieses Handbuchs.

**Probieren Sie weitere Tutorials aus**  
Wenn Sie andere Tutorials mit anderen Beispielanwendungen ausprobieren möchten, finden Sie weitere Informationen unter[QuickStart für .NET Core unter Windows](dotnet-quickstart.md).

Nachdem Sie eine oder zwei Beispielanwendungen bereitgestellt haben und bereit sind, ASP.NET-Anwendungen lokal zu entwickeln und auszuführen, finden Sie weitere Informationen unter [Einrichten der .NET-Entwicklungsumgebung](dotnet-devenv.md) 

## Bereitstellung mit der Elastic Beanstalk Beanstalk-Konsole
<a name="aspnet-quickstart-console"></a>

Sie können die Beispielanwendung auch mit der Elastic Beanstalk Beanstalk-Konsole starten. Ausführliche Schritte finden Sie unter [Erstellen einer Beispielanwendung](GettingStarted.md#GettingStarted.CreateApp) im Kapitel *Erste Schritte* dieses Handbuchs.

# Einrichten der .NET-Entwicklungsumgebung
<a name="dotnet-devenv"></a>

Dieses Thema enthält Anweisungen zum Einrichten einer.NET-Windows-Entwicklungsumgebung, in der Sie Ihre Anwendung lokal testen können, bevor Sie sie bereitstellen AWS Elastic Beanstalk. Außerdem wird auf Websites verwiesen, die Installationsanweisungen für nützliche Tools bereitstellen.

**Topics**
+ [Installieren einer IDE](#dotnet-devenv-ide)
+ [Installation des AWS Toolkit for Visual Studio](#dotnet-devenv-toolkit)

Wenn Sie AWS Ressourcen von Ihrer Anwendung aus verwalten müssen, installieren Sie das AWS SDK for .NET. Beispielsweise können Sie mit Amazon S3 Daten speichern und abrufen.

Mit dem AWS SDK for .NET können Sie in wenigen Minuten mit einem einzigen herunterladbaren Paket mit Visual Studio-Projektvorlagen, der AWS .NET-Bibliothek, C\$1-Codebeispielen und Dokumentation loslegen. Praktische Beispiele dazu, wie mit den Bibliotheken Anwendungen erstellt werden können, sind in C\$1 enthalten. Online-Videotutorials und Referenzdokumentationen werden bereitgestellt, um Sie dabei zu unterstützen, die Verwendung der Bibliotheken und Beispielcodes zu erlernen.

Weitere Informationen und Installationsanleitungen finden Sie auf der [AWS SDK for .NET-Homepage](https://aws.amazon.com/sdk-for-net/).

## Installieren einer IDE
<a name="dotnet-devenv-ide"></a>

Integrierte Entwicklungsumgebungen (IDEs) bieten eine Vielzahl von Funktionen, die die Anwendungsentwicklung erleichtern. Wenn Sie noch nie eine IDE für die .NET-Entwicklung verwendet haben, können Sie mit Visual Studio Community erste Schritte unternehmen.

Besuchen Sie die [Visual Studio Community](https://www.visualstudio.com/vs/community/)-Webseite, um Visual Studio Community herunterzuladen und zu installieren.

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

Das [AWS Toolkit for Visual Studio](dotnet-toolkit.md)ist ein Open-Source-Plug-In für die Visual Studio-IDE, das Entwicklern das Entwickeln, Debuggen und Bereitstellen von.NET-Anwendungen erleichtert. AWS Installationsanleitungen finden Sie auf der [Toolkit for Visual Studio-Homepage](https://aws.amazon.com/visualstudio/).

# Verwendung der Elastic Beanstalk .NET Windows-Plattform
<a name="create_deploy_NET.container.console"></a>

In diesem Thema wird beschrieben, wie Sie Ihre ASP.NET- und .NET Core-Windows-Webanwendungen auf Elastic Beanstalk konfigurieren, erstellen und ausführen.

AWS Elastic Beanstalk unterstützt eine Reihe von Plattformen für verschiedene Versionen des.NET-Programmierframeworks und Windows Server. Eine komplette Liste finden Sie unter [.NET on Windows Server mit IIS](https://docs.aws.amazon.com/elasticbeanstalk/latest/platforms/platforms-supported.html#platforms-supported.net) im Dokument *AWS Elastic Beanstalk -Plattformen*.

Elastic Beanstalk bietet [Konfigurationsoptionen](command-options.md), mit denen Sie die Software anpassen können, die auf den EC2 Instances in Ihrer Elastic Beanstalk Beanstalk-Umgebung ausgeführt wird. Sie können die für Ihre Anwendung erforderlichen Umgebungsvariablen konfigurieren, die Protokollrotation an Amazon S3 aktivieren und .NET-Framework-Einstellungen festlegen.

In der Elastic Beanstalk-Konsole sind Konfigurationsoptionen für das [Ändern der Konfiguration einer ausgeführten Umgebung](environment-configuration-methods-after.md) verfügbar. Um zu verhindern, dass die Umgebungskonfiguration beim Beenden verloren geht, können Sie [gespeicherte Konfigurationen](environment-configuration-savedconfig.md) verwenden, um Ihre Einstellungen zu speichern und sie später für eine andere Umgebung zu übernehmen.

Zum Speichern der Einstellungen im Quellcode können Sie [Konfigurationsdateien](ebextensions.md) einschließen. Die Einstellungen in Konfigurationsdateien werden jedes Mal verwendet, wenn Sie eine Umgebung erstellen oder Ihre Anwendung bereitstellen. Mit Konfigurationsdateien können Sie auch Pakete installieren, Skripts ausführen und andere Instance-Anpassungen bei Bereitstellungen vornehmen.

Die in der Elastic Beanstalk-Konsole angewendeten Einstellungen überschreiben die entsprechenden Einstellungen in Konfigurationsdateien, wenn vorhanden. So sind Standardeinstellungen in Konfigurationsdateien möglich, die Sie mit umgebungsspezifischen Einstellungen in der Konsole überschreiben können. Für weitere Informationen zur Rangfolge und zu anderen Methoden zum Ändern der Einstellungen siehe [Konfigurationsoptionen](command-options.md).

## Konfigurieren Ihrer .NET-Umgebung in der Elastic Beanstalk-Konsole
<a name="dotnet-console"></a>

Mit der Elastic Beanstalk-Konsole können Sie die Protokollrotation für Amazon S3 aktivieren, Variablen konfigurieren, die die Anwendung in der Umgebung lesen kann, und die .NET-Framework-Einstellungen ändern.

**So konfigurieren Sie Ihre .NET-Umgebung in der Elastic Beanstalk-Konsole**

1. Öffnen Sie die [Elastic Beanstalk Beanstalk-Konsole](https://console.aws.amazon.com/elasticbeanstalk) und wählen Sie in der Liste **Regionen** Ihre aus. AWS-Region

1. Wählen Sie im Navigationsbereich **Environments (Umgebungen)** aus und wählen Sie dann in der Liste den Namen Ihrer Umgebung aus.

1. Wählen Sie im Navigationsbereich **Configuration (Konfiguration)** aus.

1. Wählen Sie in der Konfigurationskategorie **Updates, monitoring and logging ** (Updates, Überwachung und Protokolle) die Option **Edit** (Bearbeiten) aus.

### Container-Optionen
<a name="dotnet-console-framework"></a>
+ **Target .NET runtime (.NET-Ziellaufzeit)** – Legen Sie den Wert `2.0` fest, um CLR v2 auszuführen.
+ **Enable 32-bit applications (32-Bit-Anwendungen aktivieren)** – Legen Sie den Wert `True` fest, um 32-Bit-Anwendungen auszuführen.

### Protokolloptionen
<a name="dotnet-console-logs"></a>

Im Abschnitt mit den Protokolloptionen sind zwei Einstellungen vorhanden:
+ **Instance profile (Instance-Profil)** – Gibt das Instance-Profil an, das zum Zugriff auf den entsprechenden Amazon S3-Bucket der Anwendung berechtigt ist.
+ **Rotation der Protokolldateien nach Amazon S3 aktivieren** — Gibt an, ob Protokolldateien für die EC2 Amazon-Instances Ihrer Anwendung in den Amazon S3-Bucket kopiert werden, der Ihrer Anwendung zugeordnet ist.

### Umgebungseigenschaften
<a name="dotnet-console-properties"></a>

Im Abschnitt **Umgebungseigenschaften** können Sie die Umgebungskonfigurationseinstellungen für die EC2 Amazon-Instances angeben, auf denen Ihre Anwendung ausgeführt wird. Diese Einstellungen werden als Schlüssel-Wert-Paare an die Anwendung weitergeleitet. Verwenden Sie `System.GetEnvironmentVariable`, um diese zu lesen. Identische Schlüssel können in `web.config` und als Umgebungseigenschaften vorhanden sein. Verwenden Sie den `System.Configuration`-Namespace zum Lesen von Werten aus `web.config`.

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

Weitere Informationen finden Sie unter [Umgebungsvariablen und andere Softwareeinstellungen](environments-cfg-softwaresettings.md).

## Der Namespace aws:elasticbeanstalk:container:dotnet:apppool
<a name="dotnet-namespaces"></a>

Mithilfe einer [Konfigurationsdatei](ebextensions.md) können Sie im Rahmen der Bereitstellung Konfigurationsoptionen festlegen und andere Instance-Konfigurationsaufgaben ausführen. Die Konfigurationsoptionen können [plattformspezifisch](command-options-specific.md) sein oder für [alle Plattformen](command-options-general.md) im Elastic Beanstalk-Service als Ganzes gelten. *Die Konfigurationsoptionen sind in Namespaces organisiert.*

Über die .NET-Plattform werden Optionen im Namespace `aws:elasticbeanstalk:container:dotnet:apppool` festgelegt, mithilfe derer Sie die .NET-Laufzeitumgebung konfigurieren können.

In der folgenden Beispielkonfigurationsdatei werden die Einstellungen der einzelnen Optionen angezeigt, die in diesem Namespace verfügbar sind:

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

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

Elastic Beanstalk bietet zahlreiche Konfigurationsoptionen für die Anpassung Ihrer Umgebung. Neben den Konfigurationsdateien können Sie die Konfigurationsoptionen auch unter Verwendung der Konsole, gespeicherter Konfigurationen, der EB CLI oder der AWS CLI einrichten. Weitere Informationen finden Sie unter [Konfigurationsoptionen](command-options.md).

# Migration über die Hauptversionen der Elastic Beanstalk-Windows Server-Plattform hinweg
<a name="dotnet-v2migration"></a>

AWS Elastic Beanstalk hatte mehrere Hauptversionen seiner Windows Server-Plattform. Diese Seite geht auf die wichtigsten Verbesserungen für jede Hauptversion und darauf ein, was Sie bedenken müssen, bevor Sie auf eine neuere Version migrieren.

Die Windows Server-Plattform liegt derzeit in Version 2 (v2) vor. Wenn Ihre Anwendung eine Version der Windows Server-Plattform vor v2 verwendet, empfehlen wir die Migration auf v2.

## Neues in den Hauptversionen der Windows Server-Plattform
<a name="dotnet-v2migration.diffs"></a>

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

Version 2 (v2) der Elastic Beanstalk Windows Server Plattform wurde [im Februar 2019 veröffentlicht](https://docs.aws.amazon.com/elasticbeanstalk/latest/relnotes/release-2019-02-21-windows-v2.html). Mit V2 ist das Verhalten der Windows Server-Plattform in mehreren wichtigen Punkten demjenigen der Linux-basierten Plattformen von Elastic Beanstalk ähnlicher. V2 ist vollständig abwärtskompatibel zu v1, wodurch die Migration von v1 ganz einfach ist.

Die Windows Server-Plattform unterstützt jetzt Folgendes:
+ *Versioning* – Jede Version erhält eine neue Versionsnummer, und Sie können auf frühere Versionen (die noch verfügbar sind) verweisen, wenn Sie Umgebungen erstellen und verwalten.
+ *Erweiterter Zustandsbericht* – Weitere Informationen finden Sie unter [Verbesserte Gesundheitsberichterstattung und Überwachung in Elastic Beanstalk](health-enhanced.md).
+ Bereitstellungen, die *unveränderlich* und *fortlaufend mit zusätzlichem Batch* sind – Weitere Informationen zu Bereitstellungsrichtlinien finden Sie unter [Anwendungen in Elastic Beanstalk-Umgebungen bereitstellen](using-features.deploy-existing-version.md).
+ *Unveränderliche Updates* – Weitere Informationen zu den Update-Typen finden Sie unter [Konfigurationsänderungen](environments-updating.md).
+ *Verwaltete Plattformaktualisierungen* – Weitere Informationen finden Sie unter [Verwaltete Plattformaktualisierungen](environment-platform-update-managed.md).

**Anmerkung**  
Die neuen Bereitstellungs- und Update-Funktionen sind vom erweiterten Zustandsbericht abhängig. Um sie verwenden zu können, müssen Sie den erweiterten Zustandsbericht aktivieren. Details hierzu finden Sie unter [Aktivieren der erweiterten Elastic-Beanstalk-Integritätsberichte](health-enhanced-enable.md).

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

Version 1.0.0 (v1) der Elastic Beanstalk-Windows Server-Plattform wurde im Oktober 2015 veröffentlicht. In dieser Version ändert sich die Reihenfolge, in der die Elastic Beanstalk-Prozesse Befehle in [Konfigurationsdateien](ebextensions.md) bei der Erstellung und Aktualisierungen der Umgebung verarbeitet werden.

Vorherige Plattformversionen haben keine Versionsnummer im Lösungs-Stack-Namen:
+ Windows Server 2012 R2 mit 64 Bit und IIS 8.5
+ Windows Server Core 2012 R2 mit 64 Bit und IIS 8.5
+ Windows Server 2012 mit 64 Bit und IIS 8
+ Windows Server 2008 R2 mit 64 Bit und IIS 7.5

In früheren Versionen war die Verarbeitungsreihenfolge für Konfigurationsdateien inkonsistent. Während der Umgebungserstellung wurde `Container Commands` ausgeführt, nachdem die Anwendungsquelle für IIS bereitgestellt wurde. Bei einer Bereitstellung in einer ausgeführten Umgebung werden Container-Befehle ausgeführt, bevor die neue Version bereitgestellt wird. Bei einer Skalierung nach oben werden Konfigurationsdateien nicht verarbeitet.

Darüber hinaus wird IIS gestartet, bevor Container-Befehle ausgeführt werden. Dieses Verhalten hat einige Kunden zur Implementierung von Umgehungslösungen in Container-Befehlen veranlasst, wobei der IIS-Server angehalten wird, bevor Befehle ausgeführt werden, und nach Abschluss wieder gestartet wird.

Version 1 behebt die Inkonsistenzen. Damit ist das Verhalten der Windows Server-Plattform demjenigen der Linux-basierten Plattformen von Elastic Beanstalk ähnlicher. Bei der v1-Plattform führt Elastic Beanstalk immer Container-Befehle vor dem Start des IIS-Servers aus.

Die Lösungs-Stacks der v1-Plattform haben ein `v1` nach der Windows Server-Version:
+ Windows Server 2012 R2 v1.1.0 mit 64 Bit und IIS 8.5
+ Windows Server Core 2012 R2 v1.1.0 mit 64 Bit und IIS 8.5
+ Windows Server 2012 v1.1.0 mit 64 Bit und IIS 8
+ Windows Server 2008 R2 v1.1.0 mit 64 Bit und IIS 7.5

Außerdem extrahiert die v1-Plattform den Inhalt Ihres Anwendungs-Quell-Bundles in `C:\staging\`, bevor Container-Befehle ausgeführt werden. Nachdem die Container-Befehle abgeschlossen wurden, wird der Inhalt dieses Ordners als ZIP-Datei komprimiert und für IIS bereitgestellt. In diesem Workflow können Sie den Inhalt Ihres Anwendungs-Quell-Bundles mit Befehlen oder einem Skript vor der Bereitstellung ändern.

## Migration von früheren Hauptversionen der Windows Server-Plattform
<a name="dotnet-v2migration.migration"></a>

Lesen Sie diesen Abschnitt mit Hinweisen zur Migration, bevor Sie Ihre Umgebung aktualisieren. Weitere Informationen zur Aktualisierung Ihrer Umgebungsplattform auf eine neuere Version finden Sie unter [Aktualisieren der Plattformversion für die Elastic Beanstalk-Umgebung](using-features.platform.upgrade.md).

### Kopieren von V1 in V2
<a name="dotnet-v2migration.migration.fromv1"></a>

.NET Core 1.x und 2.0 werden von der v2-Plattform von Windows Server nicht unterstützt. Wenn Sie Ihre Anwendung von Windows Server v1 auf v2 migrieren und Ihre Anwendung eine dieser .NET Core-Versionen nutzt, aktualisieren Sie Ihre Anwendung auf eine .NET-Core Version, die von v2 unterstützt wird. Eine Liste der unterstützten Versionen finden Sie unter [.NET mit Windows Server und IIS](https://docs.aws.amazon.com/elasticbeanstalk/latest/platforms/platforms-supported.html#platforms-supported.net) in den *AWS Elastic Beanstalk Plattformen*.

Wenn Ihre Anwendung ein benutzerdefiniertes Amazon Machine Image (AMI) verwendet, erstellen Sie ein neues benutzerdefiniertes AMI basierend auf einer Windows Server-Plattform v2 AMI. Weitere Informationen hierzu finden Sie unter [Verwenden eines benutzerdefinierten Amazon Machine Images (AMI) in Ihrer Elastic Beanstalk Beanstalk-Umgebung](using-features.customenv.md).

**Anmerkung**  
Welche Bereitstellungs- und Update-Funktionen in Windows Server v2 neu sind, ist vom erweiterten Zustandsbericht abhängig. Wenn Sie eine Umgebung auf v2 migrieren, ist der erweiterte Zustandsbericht deaktiviert. Sie müssen sie aktivieren, um diese Funktionen verwenden zu können. Details hierzu finden Sie unter [Aktivieren der erweiterten Elastic-Beanstalk-Integritätsberichte](health-enhanced-enable.md).

### Von Pre-V1-Versionen
<a name="dotnet-v2migration.migration.fromv0"></a>

Wenn Sie Ihre Anwendung von einem Windows Server-Lösungs-Stack vor v1 migrieren und derzeit Containerbefehle verwenden, müssen Sie zusätzlich zu den Überlegungen, die auf eine Migration von v1 zutreffen, alle Befehle entfernen, die Sie hinzugefügt haben, um die Verarbeitungsinkonsistenzen beim Migrieren auf eine neuere Version zu umgehen. Ab v1 werden Container-Befehle garantiert vollständig ausgeführt, bevor die Anwendungsquelle bereitgestellt und bevor IIS gestartet wird. Auf diese Weise können Sie Änderungen an der Quelle in `C:\staging` durchführen und IIS-Konfigurationsdateien in diesem Schritt ohne Probleme ändern.

Sie können beispielsweise die verwenden, AWS CLI um eine DLL-Datei von Amazon S3 in Ihre Anwendungsquelle herunterzuladen:

`.ebextensions\copy-dll.config`

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

Weitere Informationen zur Verwendung von Konfigurationsdateien finden Sie unter [Erweiterte Umgebungsanpassung mit Konfigurationsdateien (`.ebextensions`)](ebextensions.md).

# Ausführen mehrerer Anwendungen und ASP.NET Core-Anwendungen mit einem Bereitstellungsmanifest
<a name="dotnet-manifest"></a>

Sie können mit einem Bereitstellungsmanifest Elastic Beanstalk anweisen, wie Ihre Anwendung bereitgestellt werden soll. Wenn Sie diese Methode verwenden, müssen Sie kein `MSDeploy` für eine einzelne ASP.NET-Anwendung generieren, die im Root-Pfad Ihrer Website ausgeführt wird. Stattdessen können Sie eine Manifestdatei verwenden, um mehrere Anwendungen auf verschiedenen Pfaden auszuführen. Alternativ können Sie Elastic Beanstalk anweisen, die App mit ASP.NET Core bereitzustellen und auszuführen. Sie können ein Bereitstellungsmanifest auch zum Konfigurieren eines Anwendungspools verwenden, in dem Sie Ihre Anwendungen ausführen.

Bereitstellungsmanifeste fügen Unterstützung für [.NET Core-Anwendungen](#dotnet-manifest-dotnetcore) zu Elastic Beanstalk hinzu. Sie können eine .NET Framework-Anwendung ohne Bereitstellungsmanifest bereitstellen. .NET-Core-Anwendungen benötigen jedoch ein Bereitstellungsmanifest, um auf Elastic Beanstalk ausgeführt zu werden. Wenn Sie ein Bereitstellungsmanifest verwenden, können Sie ein Website-Archiv für jede erstellen und die Website-Archive dann in einem zweiten ZIP-Archiv mit dem Bereitstellungsmanifest bündeln.

Bereitstellungsmanifeste bieten auch die Möglichkeit, [mehrere Anwendungen auf verschiedenen Pfaden auszuführen](#dotnet-manifest-multiapp). Ein Bereitstellungsmanifest definiert eine Reihe von Bereitstellungszielen, jeweils mit einem Website-Archiv und einem Pfad, auf dem IIS es ausführen soll. Sie können beispielsweise einen Web-API auf dem `/api`-Pfad ausführen, um asynchrone Anfragen zu verarbeiten, und eine Web-App auf dem Stammpfad ausführen, die die API in Anspruch nimmt.

Sie können ein Bereitstellungsmanifest verwenden, um [IIS-Websites mit benutzerdefinierten Bindungen und physischen Pfaden zu konfigurieren](#dotnet-manifest-websites). Auf diese Weise können Sie Websites einrichten, die bestimmte Ports oder Hostnamen abhören, bevor Sie Ihre Anwendungen bereitstellen.

Sie können ein Bereitstellungsmanifest auch verwenden, um [mehrere Anwendungen mit Anwendungspools in IIS oder Kestrel auszuführen](#dotnet-manifest-apppool). Sie können einen Anwendungspool so konfigurieren, dass Ihre Anwendungen in regelmäßigen Abständen neu gestartet werden, 32-Bit-Anwendungen ausführen oder eine bestimmte Version der .NET Framework-Laufzeit verwenden.

Für eine vollständige Anpassung können Sie [Ihre eigenen Deployment-Skripts in Windows schreiben](#dotnet-manifest-custom) PowerShell und Elastic Beanstalk mitteilen, welche Skripts ausgeführt werden müssen, um Ihre Anwendung zu installieren, zu deinstallieren und neu zu starten.

Bereitstellungsmanifeste und verwandte Funktionen erfordern als Windows Server-Plattformkonfiguration [Version 1.2.0 oder höher](dotnet-v2migration.md).

Detaillierte Informationen zu allen verfügbaren Konfigurationsoptionen, Eigenschaften und erweiterten Funktionen wie dem Überspringen von IIS-Resets finden Sie in der Schemareferenz für das [Deployment-Manifest](dotnet-manifest-schema.md).

**Topics**
+ [.NET Core-Apps](#dotnet-manifest-dotnetcore)
+ [Ausführen mehrerer Anwendungen](#dotnet-manifest-multiapp)
+ [Konfigurieren Sie IIS-Websites](#dotnet-manifest-websites)
+ [Verwenden von Application Request Routing (ARR)](#dotnet-manifest-arr)
+ [Konfigurieren der Anwendungspools](#dotnet-manifest-apppool)
+ [Definieren von benutzerdefinierten Bereitstellungen](#dotnet-manifest-custom)
+ [Schemareferenz für das Bereitstellungsmanifest](dotnet-manifest-schema.md)

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

Sie können ein Bereitstellungsmanifest verwenden, um .NET-Core-Anwendungen auf Elastic Beanstalk auszuführen. .NET-Core-Version ist eine plattformübergreifende Version von .NET, die ein Befehlszeilentool (`dotnet`) enthält. Sie können damit eine Anwendung generieren, lokal ausführen und für die Veröffentlichung vorbereiten.

Zum Ausführen einer .NET-Core-Anwendung auf Elastic Beanstalk können Sie `dotnet publish` ausführen und die Ausgabe in ein ZIP-Archiv (ohne enthaltene Verzeichnisse) packen. Platzieren Sie das Website-Archiv in einem Quell-Bundle mit einem Bereitstellungsmanifest mit einem Bereitstellungsziel des Typs `aspNetCoreWeb`.

Das folgende Bereitstellungsmanifest führt eine .NET Core-Anwendung von einem Website-Archiv mit dem Namen `dotnet-core-app.zip` auf dem Stammpfad aus.

**Example aws-windows-deployment-manifest.json — .NET-Kern**  

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

Bündeln Sie das Manifest und Website-Archiv in einem ZIP-Archiv zum Erstellen eines Quell-Bundle.

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

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

Die Website-Archiv enthält den kompilierten Anwendungscode, Abhängigkeiten und `web.config`-Dateien.

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

## Ausführen mehrerer Anwendungen
<a name="dotnet-manifest-multiapp"></a>

Sie können mehrere Anwendungen mit einem Bereitstellungsmanifest ausführen, indem Sie mehrere Bereitstellungsziele definieren.

Das folgende Bereitstellungsmanifest konfiguriert zwei .NET Core-Anwendungen. Die `WebApiSampleApp` Anwendung implementiert eine einfache Web-API und bedient asynchrone Anfragen im `/api` Pfad. Die `DotNetSampleApp`-Anwendung ist eine Webanwendung, die Anfragen im Root-Pfad bedient.

**Example aws-windows-deployment-manifest.json — mehrere Apps**  

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

Eine Beispielanwendung mit mehreren Anwendungen finden Sie hier:
+ **Bereitstellbares Quellpaket** [— -v2.zip dotnet-multiapp-sample-bundle](samples/dotnet-multiapp-sample-bundle-v2.zip)
+ **Quellcode** [- -v2.zip dotnet-multiapp-sample-source](samples/dotnet-multiapp-sample-source-v2.zip)

## Konfigurieren Sie IIS-Websites
<a name="dotnet-manifest-websites"></a>

Mithilfe des Bereitstellungsmanifests können Sie IIS-Websites mit benutzerdefinierten Bindungen und physischen Pfaden konfigurieren. Dies ist nützlich, wenn Sie Websites einrichten müssen, die bestimmte Ports abhören, benutzerdefinierte Hostnamen verwenden oder Inhalte aus bestimmten Verzeichnissen bereitstellen.

Das folgende Bereitstellungsmanifest konfiguriert eine benutzerdefinierte IIS-Website, die HTTP mit einer bestimmten Portnummer und einem benutzerdefinierten physischen Pfad abhört:

**Example aws-windows-deployment-manifest.json — Konfiguration der IIS-Website**  

```
{
  "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 diesem Beispiel:
+ Eine Website mit dem Namen MyCustomSite "" wird mit einem benutzerdefinierten physischen Pfad erstellt
+ Die Website hat eine HTTP-Bindung an Port 8080 mit einem bestimmten Hostnamen
+ Die ASP.NET Core-Anwendung wird mithilfe des Parameters auf dieser benutzerdefinierten Website bereitgestellt `iisWebSite`

## Verwenden von Application Request Routing (ARR)
<a name="dotnet-manifest-arr"></a>

Die Module Application Request Routing (ARR) und URL Rewrite sind vorinstalliert und in Elastic Beanstalk Windows verfügbar. AMIs Diese Module ermöglichen erweiterte Routing-Szenarien und URL-Manipulation über die IIS-Konfiguration mithilfe von EExtensions oder Anwendungskonfiguration.

Das folgende Beispiel zeigt ein einfaches Bereitstellungsmanifest, das eine Website mit einem benutzerdefinierten Port konfiguriert, kombiniert mit einer EExtensions-Konfiguration, die das grundlegende ARR-Routing einrichtet:

**Example aws-windows-deployment-manifest.json — Einfache ARR-Einrichtung**  

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

Die ARR-Konfiguration erfolgt über EExtensions. Die folgende Konfiguration richtet grundlegende ARR-Routing-Regeln ein:

**Example .ebextensions/arr-config.config — Grundlegende ARR-Konfiguration**  

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

Diese Konfiguration erstellt eine Website auf Port 8080 und richtet ARR so ein, dass alle eingehenden Anfragen an die Backend-Anwendung weitergeleitet werden, die auf dieser Site ausgeführt wird.

## Konfigurieren der Anwendungspools
<a name="dotnet-manifest-apppool"></a>

Sie können mehrere Anwendungen in Ihrer Windows-Umgebung unterstützen. Es stehen zwei Ansätze zur Verfügung:
+ Sie können das out-of-process Hosting-Modell mit dem Kestrel-Webserver verwenden. Bei diesem Modell konfigurieren Sie mehrere Anwendungen für die Ausführung in einem Anwendungspool.
+ Sie können das In-Process-Hosting-Modell verwenden. Bei diesem Modell verwenden Sie mehrere Anwendungspools, um mehrere Anwendungen mit nur einer Anwendung in jedem Pool auszuführen. Wenn Sie den IIS-Server verwenden und mehrere Anwendungen ausführen müssen, müssen Sie diesen Ansatz verwenden.

Um Kestrel für die Ausführung mehrerer Anwendungen in einem Anwendungspool zu konfigurieren, fügen Sie `hostingModel="OutofProcess"` zur Datei `web.config` hinzu. Betrachten Sie die folgenden Beispiele:

**Example web.config — für das Kestrel-Hosting-Modell 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 — mehrere Anwendungen**  

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

IIS unterstützt nicht mehrere Anwendungen in einem Anwendungspool, da es das In-Process-Hosting-Modell verwendet. Daher müssen Sie mehrere Anwendungen konfigurieren, indem Sie jede Anwendung einem Anwendungspool zuweisen. Mit anderen Worten: Weisen Sie einem Anwendungspool nur eine Anwendung zu.

Sie können IIS so konfigurieren, dass verschiedene Anwendungspools in der Datei `aws-windows-deployment-manifest.json` verwendet werden. Nehmen Sie die folgenden Aktualisierungen vor, wenn Sie auf die nächste Beispieldatei verweisen:
+ Fügen Sie einen Abschnitt `iisConfig` hinzu, der einen Unterabschnitt mit dem Namen `appPools` enthält.
+ Listen Sie im Block `appPools` die Anwendungspools auf. 
+ Definieren Sie im Abschnitt `deployments` einen Abschnitt `parameters` für jede Anwendung.
+ Für jede Anwendung gibt der Abschnitt `parameters` ein Archiv, einen Pfad zum Ausführen und einen `appPool` an, in dem die Ausführung erfolgt.

Das folgende Bereitstellungsmanifest konfiguriert zwei Anwendungspools, die ihre Anwendung alle 10 Minuten neu starten. Sie hängen ihre Anwendungen auch an eine .NET Framework-Webanwendung an, die unter dem angegebenen Pfad ausgeführt wird.

**Example aws-windows-deployment-manifest.json — eine Anwendung pro Anwendungspool**  

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

## Definieren von benutzerdefinierten Bereitstellungen
<a name="dotnet-manifest-custom"></a>

Für noch mehr Kontrolle können Sie eine Anwendungsbereitstellung komplett anpassen, indem Sie eine *benutzerdefinierte Bereitstellung* definieren.

Dieses Deployment-Manifest weist Elastic Beanstalk an, PowerShell Skripts im 32-Bit-Modus auszuführen. Es spezifiziert drei Skripte: ein `install` Skript (`siteInstall.ps1`), das beim Start und bei der Bereitstellung von Instances ausgeführt wird, ein `uninstall` Skript (`siteUninstall.ps1`), das vor der Installation neuer Versionen während der Bereitstellung ausgeführt wird, und ein `restart` Skript (`siteRestart.ps1`), das ausgeführt wird, wenn Sie [App Server neu starten in der Managementkonsole](environments-dashboard-actions.md) auswählen. AWS 

**Example aws-windows-deployment-manifest.json — benutzerdefinierte Bereitstellung**  

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

Fügen Sie alle Artefakte hinzu, die erforderlich sind, um die Anwendung in Ihrem Quell-Bundle mit dem Manifest und Skripts auszuführen.

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

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

# Schemareferenz für das Bereitstellungsmanifest
<a name="dotnet-manifest-schema"></a>

Das Deployment-Manifest ist eine JSON-Datei, die definiert, wie Elastic Beanstalk Ihre Windows-Anwendungen bereitstellen und konfigurieren soll. Dieser Abschnitt enthält eine umfassende Referenz für alle unterstützten Eigenschaften und Konfigurationsoptionen im Manifestschema.

## Manifest-Struktur
<a name="dotnet-manifest-schema-structure"></a>

Das Bereitstellungsmanifest folgt einem bestimmten JSON-Schema mit der folgenden Struktur auf oberster Ebene:

**Example Grundlegende Manifeststruktur**  

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

### Eigenschaften der obersten Ebene
<a name="dotnet-manifest-schema-top-level"></a>

`manifestVersion` (Erforderlich)  
*Typ*: Zahl  
*Standard*: 1  
*Gültige Werte: 1*  
Gibt die Version des Manifestschemas an. Derzeit wird nur Version 1 unterstützt.

`skipIISReset` (optional)  
*Typ*: Boolesch  
*Standard:* false  
Steuert, ob IIS während der Anwendungsbereitstellung zurückgesetzt wird. Dieses Flag betrifft sowohl Bereitstellungstypen als `msDeploy` auch `aspNetCoreWeb` Bereitstellungstypen.  
*Verhalten:*  
+ *Nicht angegeben oder `false` (Standard):* IIS-Resets werden bei Installations-, Deinstallations- und Aktualisierungsvorgängen durchgeführt. Dies ist das traditionelle Verhalten.
+ *`true`:* IIS-Resets werden bei Bereitstellungsvorgängen übersprungen.
*Vorteile:*  
+ *Geringere Ausfallzeiten* — Bei Anwendungen kommt es während der Bereitstellung zu kürzeren Serviceunterbrechungen.
+ *Schnellere Bereitstellungen* — Eliminiert die Zeit, die IIS benötigt, um vollständig neu zu starten und neu zu initialisieren.
Bei Verwendung `skipIISReset` führt der [RestartAppServer](https://docs.aws.amazon.com/elasticbeanstalk/latest/api/API_RestartAppServer.html)Vorgang unabhängig von dieser Flag-Einstellung einen IIS-Reset durch.
*Beispiel:*  

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

`deployments` (Erforderlich)  
*Typ:* Objekt  
Enthält die Bereitstellungskonfigurationen für Ihre Anwendungen. Dieses Objekt kann `custom` Bereitstellungstypen `msDeploy``aspNetCoreWeb`, und enthalten.

`iisConfig` (optional)  
*Typ:* Objekt  
Definiert IIS-Konfigurationseinstellungen, die vor der Bereitstellung von Anwendungen angewendet werden sollen. Unterstützt sowohl die Website- als auch die Anwendungspoolkonfiguration.

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

In `iisConfig` diesem Abschnitt können Sie IIS-Einstellungen konfigurieren, bevor Sie Ihre Anwendungen bereitstellen. Dazu gehören die Einrichtung von Anwendungspools mit bestimmten Konfigurationen und die Konfiguration von IIS-Websites mit benutzerdefinierten Bindungen.

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

IIS-Websites ermöglichen es Ihnen, benutzerdefinierte Website-Einstellungen, einschließlich physischer Pfade und Netzwerkbindungen, zu konfigurieren, bevor Sie Ihre Anwendungen bereitstellen.

**Wichtige Überlegungen zur Erstellung verschiedener IIS-Websites**  
*Reihenfolge der Einrichtung der Website:* Websites werden sequentiell in der Reihenfolge konfiguriert, in der sie im `websites` Array erscheinen. Die Plattform verarbeitet jede Website-Konfiguration der Reihe nach. Achten Sie daher auf die richtige Reihenfolge, wenn Sie Abhängigkeiten zwischen Websites haben.
*Firewall und Portzugriff:* Nur Port 80 wird durch die standardmäßige Windows-Firewallkonfiguration von Elastic Beanstalk automatisch verfügbar gemacht. Wenn Sie Websites so konfigurieren, dass sie nicht standardmäßige Ports verwenden, müssen Sie mithilfe von EExtensions oder benutzerdefinierten Deployment-Skripten benutzerdefinierte Firewall-Regeln definieren, um externen Zugriff auf diese Ports zu ermöglichen.

**Example Konfiguration der Website**  

```
{
  "iisConfig": {
    "websites": [
      {
        "name": "MyCustomSite",
        "physicalPath": "C:\inetpub\wwwroot\mysite",
        "bindings": [
          {
            "protocol": "http",
            "port": 8080,
            "hostName": "mysite.local"
          },
          {
            "protocol": "https",
            "port": 8443
          }
        ]
      }
    ]
  }
}
```Eigenschaften der Website

`name` (Erforderlich)  
*Typ:* Zeichenfolge  
Der Name der IIS-Website. Dieser Name wird zur Identifizierung der Website im IIS-Manager verwendet und muss innerhalb der IIS-Konfiguration eindeutig sein.

`physicalPath` (Erforderlich)  
*Typ:* Zeichenfolge  
Der physische Pfad auf dem Server, auf dem die Website-Dateien gespeichert sind. Dieser Pfad muss für den IIS-Arbeitsprozess zugänglich sein.

`bindings` (Erforderlich)  
*Typ*: Array  
*Mindestanzahl der Artikel:* 1  
Eine Reihe von Bindungskonfigurationen, die definieren, wie die Website auf Netzwerkanfragen reagiert. Jede Bindung spezifiziert ein Protokoll, einen Port und einen optionalen Hostnamen.

#### Webseiten-Bindungen
<a name="dotnet-manifest-schema-bindings"></a>

Website-Bindungen definieren die Netzwerkendpunkte, an denen Ihre IIS-Website auf eingehende Anfragen wartet.

`protocol` (Erforderlich)  
*Typ:* Zeichenfolge  
*Gültige Werte:* „http“, „https“  
Das für die Bindung verwendete Protokoll.

`port` (Erforderlich)  
*Typ*: Ganzzahl  
*Gültiger Bereich: 1-65535*  
Die Portnummer, über die die Website Anfragen abhört.

`hostName` (optional)  
*Typ:* Zeichenfolge  
Der Hostname (Domainname) für die Bindung.

### Anwendungspools
<a name="dotnet-manifest-schema-app-pools"></a>

Anwendungspools bieten eine Isolierung zwischen Anwendungen und ermöglichen es Ihnen, Laufzeiteinstellungen für Anwendungsgruppen zu konfigurieren.

**Example Konfiguration des Anwendungspools**  

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

`name` (Erforderlich)  
*Typ:* Zeichenfolge  
Der Name des Anwendungspools. Dieser Name wird verwendet, um in Bereitstellungskonfigurationen auf den Pool zu verweisen.

`enable32Bit` (optional)  
*Typ*: Boolesch  
Ermöglicht die Ausführung einer 32-Bit-Anwendung auf einer 64-Bit-Version von Windows. Wird `true` für ältere Anwendungen, die 32-Bit-Kompatibilität erfordern, auf gesetzt.

`managedPipelineMode` (optional)  
*Typ:* Zeichenfolge  
*Gültige Werte:* „Integrated“, „Classic“  
Gibt den Modus zur Anforderungsverarbeitung für den Anwendungspool an.

`managedRuntimeVersion` (optional)  
*Typ:* Zeichenfolge  
*Gültige Werte:* „Kein verwalteter Code“, „v2.0", „v4.0"  
Gibt die .NET Framework-Version für den Anwendungspool an.

`queueLength` (optional)  
*Typ*: Ganzzahl  
Maximale Anzahl von Anfragen, die HTTP.sys für den Anwendungspool in die Warteschlange stellt, bevor weitere Anfragen zurückgewiesen werden.

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

Das `cpu` Objekt konfiguriert die CPU-Nutzungslimits und die Überwachung für den Anwendungspool.

`limitPercentage` (optional)  
*Typ*: Zahl  
Maximaler Prozentsatz der CPU-Zeit, den Arbeitsprozesse im Anwendungspool verbrauchen können.

`limitAction` (optional)  
*Typ:* Zeichenfolge  
*Gültige Werte:* "NoAction„, „KillW3WP“, „Throttle“, "“ ThrottleUnderLoad  
Aktion, die ergriffen werden soll, wenn das CPU-Limit erreicht ist.

`limitMonitoringInterval` (optional)  
*Typ*: Zahl  
Reset-Zeitraum (in Minuten) für CPU-Überwachungs- und Drosselungsgrenzwerte.

#### Konfiguration recyceln
<a name="dotnet-manifest-schema-recycling-config"></a>

Das `recycling` Objekt konfiguriert, wann und wie Worker-Prozesse im Anwendungspool wiederverwendet werden.

`regularTimeInterval` (optional)  
*Typ*: Ganzzahl  
Zeitintervall (in Minuten), nach dem der Anwendungspool wiederverwendet wird. Auf 0 setzen, um das zeitbasierte Recycling zu deaktivieren.

`requestLimit` (optional)  
*Typ*: Ganzzahl  
Maximale Anzahl von Anfragen, die der Anwendungspool vor dem Recycling verarbeitet.

`memory` (optional)  
*Typ*: Ganzzahl  
Menge an virtuellem Speicher (in Kilobyte), die das Recycling von Arbeitsprozessen auslöst.

`privateMemory` (optional)  
*Typ*: Ganzzahl  
Menge an privatem Speicher (in Kilobyte), der das Recycling von Arbeitsprozessen auslöst.

## Bereitstellungstypen
<a name="dotnet-manifest-schema-deployments"></a>

Das `deployments` Objekt enthält Arrays von Bereitstellungskonfigurationen für verschiedene Anwendungstypen. Jeder Bereitstellungstyp hat spezifische Eigenschaften und Anwendungsfälle.

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

MSDeploy Bereitstellungen werden für herkömmliche.NET-Framework-Anwendungen verwendet, die mit Web Deploy () MSDeploy bereitgestellt werden können.

**Example MSDeploy Bereitstellungskonfiguration**  

```
{
  "deployments": {
    "msDeploy": [
      {
        "name": "WebApp",
        "description": "Main web application",
        "parameters": {
          "appBundle": "webapp.zip",
          "iisPath": "/",
          "appPool": "DefaultAppPool"
        }
      }
    ]
  }
}
```MSDeploy Eigenschaften der Bereitstellung

`name` (Erforderlich)  
*Typ:* Zeichenfolge  
Eindeutiger Name für die Bereitstellung. Dieser Name muss für alle Bereitstellungen im Manifest eindeutig sein.

`description` (optional)  
*Typ:* Zeichenfolge  
Für Menschen lesbare Beschreibung der Bereitstellung.

`parameters` (Erforderlich)  
*Typ:* Objekt  
Konfigurationsparameter für den MSDeploy Vorgang.

`scripts` (optional)  
*Typ:* Objekt  
PowerShell Skripts, die in verschiedenen Phasen des Bereitstellungslebenszyklus ausgeführt werden.

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

`appBundle` (Erforderlich)  
*Typ:* Zeichenfolge  
Pfad zum Anwendungspaket (ZIP-Datei) relativ zur Manifestdatei. Dieses Paket enthält die Anwendungsdateien, die bereitgestellt werden sollen.

`iisWebSite` (optional)  
*Typ:* Zeichenfolge  
*Standard:* „Standardwebsite“  
Die IIS-Website, auf der die Anwendung bereitgestellt werden soll. Standardmäßig werden Anwendungen auf der „Standardwebsite“ bereitgestellt. Optional können Sie einen anderen Namen für die Website angeben, z. B. einen, der im `iisConfig.websites` Abschnitt konfiguriert wurde.

`iisPath` (optional)  
*Typ:* Zeichenfolge  
*Standard:* „/“  
Virtueller Verzeichnispfad in IIS, in dem die Anwendung bereitgestellt wird. Verwenden Sie „/“ für den Stammpfad oder „/api“ für ein Unterverzeichnis.

`appPool` (optional)  
*Typ:* Zeichenfolge  
Name des Anwendungspools, in dem diese Anwendung ausgeführt werden soll.

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

ASP.NET Core-Bereitstellungen wurden speziell für .NET Core- und .NET 5\$1-Anwendungen entwickelt.

**Example Konfiguration der ASP.NET Core-Bereitstellung**  

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

ASP.NET Core-Bereitstellungen verwenden dieselbe Eigenschaftsstruktur wie MSDeploy Bereitstellungen, wobei der Hauptunterschied in der für die Anwendung verwendeten Laufzeitumgebung und dem Hostingmodell besteht.ASP.NET Core-Bereitstellungsparameter

`appBundle` (Erforderlich)  
*Typ:* Zeichenfolge  
Pfad zum Anwendungspaket relativ zur Manifestdatei. Dies kann entweder ein ZIP-Archiv oder ein Verzeichnispfad sein, der die veröffentlichte ASP.NET Core-Anwendung enthält.

`iisWebSite` (optional)  
*Typ:* Zeichenfolge  
*Standard:* „Standardwebsite“  
Die IIS-Website, auf der die ASP.NET Core-Anwendung bereitgestellt werden soll. Standardmäßig werden Anwendungen auf der „Standardwebsite“ bereitgestellt. Optional können Sie einen anderen Namen für die Website angeben, z. B. einen, der im `iisConfig.websites` Abschnitt konfiguriert wurde.

`iisPath` (optional)  
*Typ:* Zeichenfolge  
*Standard:* „/“  
Virtueller Verzeichnispfad in IIS für die ASP.NET Core-Anwendung.

`appPool` (optional)  
*Typ:* Zeichenfolge  
Anwendungspool für die ASP.NET Core-Anwendung. Der Pool wird entsprechend für das ASP.NET Core-Hosting konfiguriert.

### Benutzerdefinierte Bereitstellungen
<a name="dotnet-manifest-schema-custom"></a>

Benutzerdefinierte Bereitstellungen bieten mithilfe PowerShell von Skripten die vollständige Kontrolle über den Bereitstellungsprozess. Dieser Bereitstellungstyp ist für komplexe Szenarien nützlich, die eine benutzerdefinierte Installation, Konfiguration oder Bereitstellungslogik erfordern.

**Example Benutzerdefinierte Bereitstellungskonfiguration**  

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

`name` (Erforderlich)  
*Typ:* Zeichenfolge  
Eindeutiger Name für die benutzerdefinierte Bereitstellung.

`description` (optional)  
*Typ:* Zeichenfolge  
Beschreibung der benutzerdefinierten Bereitstellung.

`architecture` (optional)  
*Typ*: Ganzzahl  
*Standard:* 32  
*Gültige Werte:* 32, 64  
Die Architekturspezifikation für den Ausführungsmodus von Powershell-Skripten

`scripts` (Erforderlich)  
*Typ:* Objekt  
PowerShell Skripten, die das Bereitstellungsverhalten definieren. Benutzerdefinierte Bereitstellungen unterstützen im Vergleich zu anderen Bereitstellungstypen zusätzliche Skripttypen.

## Bereitstellungsskripte
<a name="dotnet-manifest-schema-scripts"></a>

 PowerShell Bereitstellungsskripten sind Skripten, die zu bestimmten Zeitpunkten während des Bereitstellungszyklus ausgeführt werden. Verschiedene Bereitstellungstypen unterstützen unterschiedliche Gruppen von Skriptereignissen.

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

Die folgenden Skriptereignisse sind je nach Bereitstellungstyp verfügbar:Standardbereitstellungsskripts (MSDeploy und aspNetCore Web)

`preInstall`  
Wird ausgeführt, bevor die Anwendung installiert oder aktualisiert wird.

`postInstall`  
Wird ausgeführt, nachdem die Anwendung installiert oder aktualisiert wurde.

`preRestart`  
Wird ausgeführt, bevor die Anwendung neu gestartet wird.

`postRestart`  
Wird ausgeführt, nachdem die Anwendung neu gestartet wurde.

`preUninstall`  
Wird ausgeführt, bevor die Anwendung deinstalliert wird.

`postUninstall`  
Wird ausgeführt, nachdem die Anwendung deinstalliert wurde.Benutzerdefinierte Bereitstellungsskripten (nur benutzerdefinierte Bereitstellungen)

`install`  
Primäres Installationsskript für benutzerdefinierte Bereitstellungen. Dieses Skript ist für die Installation der Anwendung oder des Dienstes verantwortlich.

`restart`  
Skript zum Neustarten der Anwendung oder des Dienstes. Wird aufgerufen, wenn die Umgebung neu gestartet wird.

`uninstall`  
Skript zur Deinstallation der Anwendung oder des Dienstes. Wird beim Beenden der Umgebung oder beim Entfernen der Anwendung aufgerufen.

### Eigenschaften des Skripts
<a name="dotnet-manifest-schema-script-properties"></a>

Jedes Skript ist als Objekt mit den folgenden Eigenschaften definiert:

`file` (Erforderlich)  
*Typ:* Zeichenfolge  
Pfad zur PowerShell Skriptdatei relativ zur Manifestdatei. Das Skript sollte eine `.ps1` Erweiterung haben.

`ignoreErrors` (optional)  
*Typ*: Boolesch  
*Standard:* false  
Wenn diese Option auf gesetzt ist`true`, wird die Bereitstellung auch dann fortgesetzt, wenn das Skript fehlschlägt. Verwenden Sie diese Option für unkritische Skripts oder Bereinigungsvorgänge.

**Example Beispiel für eine Skriptkonfiguration**  

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

# Verwenden von EC2 Fast Launch mit Windows-Plattformzweigen
<a name="dotnet-ec2fastlaunch"></a>

Die EC2 Schnellstartfunktion reduziert die Startzeiten von Windows-Instances in Ihren Elastic Beanstalk Beanstalk-Umgebungen. In diesem Thema erfahren Sie, wie Sie diese Funktion in Ihren Elastic Beanstalk Beanstalk-Umgebungen verwenden können. Beginnend mit der Windows-Plattformversion 2.16.2, veröffentlicht am [22. Januar 2025,](https://docs.aws.amazon.com/elasticbeanstalk/latest/relnotes/release-2025-01-22-windows.html) enthalten Elastic Beanstalk-Plattformversionen Basisversionen AMIs mit EC2 aktiviertem Fast Launch.

## Standardmäßige Verfügbarkeit von Fast Launch EC2
<a name="dotnet-ec2fastlaunch-default"></a>

Die neuesten Versionen der Elastic Beanstalk Windows-Plattform enthalten eine Basisversion AMIs mit automatisch aktiviertem EC2 Fast Launch, ohne dass zusätzliche Kosten anfallen. Wenn jedoch neuere Plattformversionen veröffentlicht werden, bleibt EC2 Fast Launch möglicherweise nicht automatisch auf der Basis AMIs älterer Plattformversionen aktiviert.

Wir empfehlen, auf die neueste Windows-Plattformversion zu aktualisieren, um die Basisversion AMIs mit automatisch aktiviertem EC2 Fast Launch zu verwenden. Wenn Sie jedoch Ihre bestehende Plattformversion weiterhin verwenden müssen, können Sie EC2 Fast Launch auf dem Basis-AMI Ihrer Umgebung manuell aktivieren. Detaillierte Anweisungen finden Sie unter [Manuelles Konfigurieren von EC2 Fast Launch](#dotnet-ec2fastlaunch-manual).

## Manuelles Konfigurieren von EC2 Fast Launch
<a name="dotnet-ec2fastlaunch-manual"></a>

**Anmerkung**  
Die manuelle Aktivierung von EC2 Fast Launch kann im Vergleich zur Verwendung von Plattformversionen mit automatisch aktiviertem EC2 Fast Launch zusätzliche Kosten verursachen. Weitere Informationen zu den EC2 Fast Launch-Kosten finden Sie auf der Seite [Kosten für EC2 Fast Launch verwalten](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/win-fast-launch-manage-costs.html) im * EC2 Amazon-Benutzerhandbuch*.

Gehen Sie wie folgt vor, um EC2 Fast Launch auf einem Windows-Basis-AMI zu aktivieren, das von Ihrer Elastic Beanstalk Beanstalk-Umgebung verwendet wird:

**So aktivieren Sie EC2 Fast Launch manuell für Ihre Elastic Beanstalk Beanstalk-Umgebung**

1. Identifizieren Sie das Basis-AMI Ihrer Umgebung:

   Folgen Sie den Schritten unter [Benutzerdefiniertes AMI erstellen](using-features.customenv.md), um die Basis-AMI-ID Ihrer Umgebung zu ermitteln. Beachten Sie, dass Sie kein benutzerdefiniertes AMI erstellen müssen — Sie müssen nur die Schritte befolgen, um Ihre aktuelle Basis-AMI-ID zu finden.

1. Aktivieren Sie EC2 Fast Launch auf dem AMI:

   Verwenden Sie die Anweisungen unter [Enable EC2 Fast Launch](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/win-fast-launch-configure.html) im * EC2 Amazon-Benutzerhandbuch*, um EC2 Fast Launch für Ihr AMI zu konfigurieren.

# Hinzufügen einer Amazon RDS-DB-Instance zur .NET-Anwendungsumgebung
<a name="create_deploy_NET.rds"></a>

Dieses Thema enthält Anweisungen zum Erstellen eines Amazon RDS mit der Elastic-Beanstalk-Konsole. Sie können eine DB-Instance von Amazon Relational Database Service (Amazon RDS) verwenden, um Daten zu speichern, die von Ihrer Anwendung gesammelt und geändert wurden. Die Datenbank kann an Ihre Umgebung gekoppelt sein und von Elastic Beanstalk verwaltet werden oder sie kann als entkoppelte Datenbank erstellt und extern von einem anderen Service verwaltet werden. In dieser Anleitung wird die Datenbank an Ihre Umgebung gekoppelt und von Elastic Beanstalk verwaltet. Weitere Informationen zur Integration eines Amazon RDS mit Elastic Beanstalk finden Sie unter [Hinzufügen einer Datenbank zu Ihrer Elastic Beanstalk-Umgebung](using-features.managing.db.md).

**Topics**
+ [Hinzufügen einer DB-Instance zu Ihrer Umgebung](#dotnet-rds-create)
+ [Herunterladen eines Treibers](#dotnet-rds-drivers)
+ [Verbinden mit einer Datenbank](#dotnet-rds-connect)

## Hinzufügen einer DB-Instance zu Ihrer Umgebung
<a name="dotnet-rds-create"></a>

**So fügen Sie eine DB-Instance zu Ihrer Umgebung hinzu**

1. Öffnen Sie die [Elastic Beanstalk Beanstalk-Konsole](https://console.aws.amazon.com/elasticbeanstalk) und wählen Sie in der Liste **Regionen** Ihre aus. AWS-Region

1. Wählen Sie im Navigationsbereich **Environments (Umgebungen)** aus und wählen Sie dann in der Liste den Namen Ihrer Umgebung aus.

1. Wählen Sie im Navigationsbereich **Configuration (Konfiguration)** aus.

1. Wählen Sie in der Konfigurationskategorie **Database (Datenbank)** die Option **Edit (Bearbeiten)**.

1. Wählen Sie eine DB-Engine aus und geben Sie Benutzernamen und Passwort ein.

1. Wählen Sie unten auf der Seite die Option **Apply** (Anwenden) aus, um die Änderungen zu speichern.

Das Hinzufügen einer DB-Instance dauert ca. 10 Minuten. Sobald die Umgebungsaktualisierung abgeschlossen ist, stehen der Hostname der DB-Instance und andere Verbindungsinformationen über die folgenden Umgebungseigenschaften zur Verfügung:


| Eigenschaftenname | Beschreibung | Eigenschaftenwert | 
| --- | --- | --- | 
|  `RDS_HOSTNAME`  |  Der Hostname der DB-Instance.  |  Auf der Registerkarte **Connectivity & security (Konnektivität und Sicherheit)** in der Amazon RDS-Konsole: **Endpoint (Endpunkt)**.  | 
|  `RDS_PORT`  |  Der Port, über den die DB-Instance Verbindungen annimmt. Die DB-Engines haben unterschiedliche Standardwerte.  |  Auf der Registerkarte **Connectivity & security (Konnektivität und Sicherheit)** auf der Amazon RDS-Konsole: **Port**.  | 
|  `RDS_DB_NAME`  |  Der Datenbanknam, **ebdb**.  |  Auf der Registerkarte **Configuration (Konfiguration)** der Amazon RDS-Konsole: **DB-Name**.  | 
|  `RDS_USERNAME`  |  Der Benutzername, der für die Datenbank konfiguriert wurde.  |  Auf der Registerkarte **Configuration (Konfiguration)** in der Amazon RDS-Konsole: **Master username (Master-Benutzername)**.  | 
|  `RDS_PASSWORD`  |  Das Passwort, das für die Datenbank konfiguriert wurde.  |  Es ist in der Amazon RDS-Konsole nicht als Referenz angegeben.  | 

Weitere Informationen zur Konfiguration einer Datenbank-Instance in Verbindung mit einer Elastic-Beanstalk-Umgebung finden Sie unter [Hinzufügen einer Datenbank zu Ihrer Elastic Beanstalk-Umgebung](using-features.managing.db.md).

## Herunterladen eines Treibers
<a name="dotnet-rds-drivers"></a>

Laden Sie das `EntityFramework`-Paket und einen Datenbanktreiber für Ihre Entwicklungsumgebung mit `NuGet` herunter und installieren sie es bzw. ihn.

**Gängige Entitäts-Framework-Datenbankanbieter für .NET**
+ **SQL Server** – `Microsoft.EntityFrameworkCore.SqlServer`
+ **MySQL** – `Pomelo.EntityFrameworkCore.MySql`
+ **PostgreSQL** – `Npgsql.EntityFrameworkCore.PostgreSQL`

## Verbinden mit einer Datenbank
<a name="dotnet-rds-connect"></a>

Elastic Beanstalk stellt Verbindungsinformationen für zugehörige DB-Instances in Umgebungseigenschaften bereit. Mit `ConfigurationManager.AppSettings` können Sie die Eigenschaften lesen und eine Datenbankverbindung konfigurieren.

**Example Helpers.cs – Verbindungszeichenfolgen-Methode**  

```
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 + ";";
    }
  }
}
```

Verwenden Sie die Verbindungszeichenfolge, um Ihren Datenbankkontext zu initialisieren.

**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();
    }
  }
}
```

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

Visual Studio bietet Vorlagen für verschiedene Programmiersprachen und Anwendungstypen. Sie können mit einer beliebigen Vorlage beginnen. Das AWS Toolkit for Visual Studio bietet außerdem drei Projektvorlagen, die die Entwicklung Ihrer Anwendung beschleunigen: AWS Console Project, AWS Web Project und AWS Empty Project. In diesem Beispiel erstellen Sie eine neue ASP.NET-Webanwendung.

**So erstellen Sie ein neues ASP.NET-Webanwendungsprojekt:**

1. Klicken Sie in Visual Studio im Menü **Datei** auf **Neu** und dann auf **Projekt**.

1. Klicken Sie im Dialogfeld **Neues Projekt** auf **Installierte Vorlagen**, auf **Visual C\$1** und auf **Web**. Klicken Sie auf **Leere ASP.NET-Webanwendung**, geben Sie einen Projektnamen ein und klicken Sie auf **OK**. 

**So führen Sie ein Projekt aus**

Führen Sie eine der folgenden Aufgaben aus:

1. Drücken Sie **F5**.

1. Wählen Sie im Menü **Debuggen** die Option **Debuggen starten** aus.

## Ausführen lokaler Tests
<a name="create_deploy_NET.sdlc.testlocal"></a>

Mit Visual Studio können Sie die Anwendung einfach lokal testen. Zum Testen oder Ausführen von ASP.NET-Webanwendungen ist ein Webserver erforderlich. Visual Studio bietet mehrere Optionen, z. B. Internet Information Services (IIS), IIS Express oder den integrierten Visual Studio Development Server. Für weitere Informationen zu den einzelnen Optionen und zur Auswahl der am besten für Sie geeigneten Option rufen Sie [Webserver in Visual Studio für ASP.NET-Webprojekte ](http://msdn.microsoft.com/en-us/library/58wxa9w5.aspx)auf.

## Erstellen einer Elastic Beanstalk-Umgebung
<a name="create_deploy_NET.sdlc.deploy"></a>

Nachdem Sie die Anwendung getestet haben, können Sie diese nun in Elastic Beanstalk bereitstellen.

**Anmerkung**  
Die [Konfigurationsdatei](ebextensions.md) muss Teil des Projekts sein und in das Archiv eingebunden werden. Anstatt die Konfigurationsdateien in das Projekt einzubinden, können Sie mit Visual Studio alternativ alle Dateien im Projektordner bereitstellen. Klicken Sie im **Projektmappen-Explorer** mit der rechten Maustaste auf den Projektnamen und klicken Sie dann auf **Eigenschaften**. Klicken Sie auf die Registerkarte **Web packen/veröffentlichen**. Wählen Sie unter **Bereitzustellende Elemente** in der Dropdown-Liste die Option **Alle Dateien in diesem Projektordner** aus.

**So stellen Sie Ihre Anwendung mithilfe des AWS Toolkits für Visual Studio auf Elastic Beanstalk bereit**

1. **Klicken Sie im **Solution Explorer** mit der rechten Maustaste auf Ihre Anwendung und wählen Sie dann Veröffentlichen in. AWS**

1. Geben Sie im Assistenten **In AWS veröffentlichen** Ihre Kontoinformationen ein.

   1. Wählen Sie unter **AWS -Konto für Bereitstellung** Ihr Konto aus. Alternativ wählen Sie **Anderes** aus, um neue Kontoinformationen anzugeben. 

   1. Wählen Sie unter **Region** die Region aus, in der die Anwendung bereitgestellt werden soll. Informationen zu verfügbaren AWS Regionen finden Sie unter [AWS Elastic Beanstalk Endpunkte und Kontingente](https://docs.aws.amazon.com/general/latest/gr/elasticbeanstalk.html) in der *Allgemeine AWS-Referenz*. Wenn Sie eine Region auswählen, die nicht von Elastic Beanstalk unterstützt wird, ist die Option zur Bereitstellung in Elastic Beanstalk nicht verfügbar.

   1.  Klicken Sie auf **Deploy new application with template (Neue Anwendung mit Vorlage bereitstellen)** und wählen Sie **Elastic Beanstalk** aus. Klicken Sie dann auf **Next (Weiter)**.  
![\[Im AWS Assistenten 1 veröffentlichen\]](http://docs.aws.amazon.com/de_de/elasticbeanstalk/latest/dg/images/aeb-vs-create-newapp-template.png)

1. Geben Sie auf der Seite **Application (Anwendung)** die Anwendungsdetails an.

   1. Geben Sie im Feld **Name** den Namen der Anwendung ein.

   1. Geben Sie im Feld **Description** eine Beschreibung der Anwendung ein. Dieser Schritt ist optional.

   1. Die Versionsbezeichnung der Anwendung wird automatisch im Feld **Deployment version label (Versionsbezeichnung der Bereitstellung)** angezeigt.

   1. Wählen Sie **Deploy application incrementally (Anwendung inkrementell bereitstellen)** aus, wenn nur die geänderten Dateien bereitgestellt werden sollen. Eine inkrementelle Bereitstellung ist schneller, da anstelle von allen Dateien nur solche aktualisiert werden, die geändert wurden. Bei Auswahl dieser Option wird die Anwendungsversion über die Git-Commit-ID festgelegt. Soll die Anwendung nicht inkrementell bereitgestellt werden, können Sie die Versionsbezeichnung im Feld **Deployment version label (Versionsbezeichnung der Bereitstellung)** aktualisieren.   
![\[Publish to Beanstalk-Assistent 2\]](http://docs.aws.amazon.com/de_de/elasticbeanstalk/latest/dg/images/aeb-vs-publish-beanstalk1.png)

   1. Klicken Sie auf **Weiter**.

1. Beschreiben Sie auf der Seite **Environment (Umgebung)** die Details der Umgebung.

   1. Wählen Sie **Create a new environment for this application (Neue Umgebung für diese Anwendung erstellen)** aus.

   1. Geben Sie unter **Name** einen Namen für die Umgebung ein.

   1. Geben Sie im Feld **Description (Beschreibung)** eine Beschreibung der Umgebung ein. Dieser Schritt ist optional.

   1. Wählen Sie unter **Type (Typ)** den gewünschten Umgebungstyp aus.

      Sie können als Umgebungstyp entweder **Load balanced, auto scaled (lastenverteilt, automatisch skaliert)** oder **Single instance (Einzelne Instance)** auswählen. Weitere Informationen finden Sie unter [Typen von Umgebungen](using-features-managing-env-types.md).

       
**Anmerkung**  
Die Einstellungen für Lastausgleich, Auto Scaling und Integritätsprüfungs-URL können nicht auf Single-Instance-Umgebungen angewendet werden.

   1. Im Feld **Environment URL (Umgebungs-URL)** wird die Umgebungs-URL automatisch angezeigt, sobald Sie den Mauszeiger zu diesem Feld bewegen.

   1. Klicken Sie auf **Check availability (Verfügbarkeit prüfen)**, um sicherzustellen, dass die URL verfügbar ist.  
![\[Publish to Beanstalk-Assistent 3\]](http://docs.aws.amazon.com/de_de/elasticbeanstalk/latest/dg/images/aeb-vs-publish-beanstalk2.png)

   1. Klicken Sie auf **Weiter**.

1. Konfigurieren Sie auf der Seite **AWS -Optionen** zusätzliche Optionen und Sicherheitsinformationen für die Bereitstellung. 

   1.  Wählen Sie im Feld **Container Type (Container-Typ)** den Eintrag **64bit Windows Server 2012 running IIS 8 (Windows Server 2012 mit 64 Bit und IIS 8)** oder **64bit Windows Server 2008 running IIS 7.5 (Windows Server 2008 mit 64 Bit und IIS 7.5)** aus.

   1. Wählen Sie im Feld **Instance Type (Instance-Typ)** die Option **Micro** aus. 

   1. Wählen Sie im Feld **Key pair (Schlüsselpaar)** die Option **Create new key pair (Neues Schlüsselpaar erstellen)** aus. Geben Sie einen Namen für das neue Schlüsselpaar ein – in diesem Beispiel wird **myuswestkeypair** verwendet – und klicken Sie auf **OK**. Ein key pair ermöglicht den Remote-Desktop-Zugriff auf Ihre EC2 Amazon-Instances. Weitere Informationen zu EC2 Amazon-Schlüsselpaaren finden Sie unter [Using Credentials](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-credentials.html) im *Amazon Elastic Compute Cloud-Benutzerhandbuch*. 

   1. Wählen Sie ein Instance-Profil aus.

      Falls Sie nicht über ein Instance-Profil verfügen, wählen Sie **Instance-Standardprofil erstellen** aus. Weitere Informationen zum Verwenden von Instance-Profilen in Elastic Beanstalk finden Sie unter [Elastic Beanstalk Instance-Profile verwalten](iam-instanceprofile.md).

   1. Wenn Sie eine benutzerdefinierte VPC mit der Umgebung nutzen möchten, klicken Sie auf **Launch into VPC (In VPC starten)**. Sie können die VPC-Informationen auf der nächsten Seite konfigurieren. Weitere Informationen zu Amazon VPC finden Sie unter [Amazon Virtual Private Cloud (Amazon VPC)](https://aws.amazon.com/vpc/). Eine Liste mit unterstützten aktuellen Containertypen finden Sie unter [Warum sind einige Plattformversionen als Legacy gekennzeichnet?](using-features.migration.md#using-features.migration.why)  
![\[Publish to Beanstalk-Assistent 4\]](http://docs.aws.amazon.com/de_de/elasticbeanstalk/latest/dg/images/aeb-vs-publish-beanstalk3b_iam.png)

   1.  Klicken Sie auf **Weiter**. 

1. Wenn Sie ausgewählt haben, dass die Umgebung in einer VPC gestartet werden soll, wird die Seite **VPC Options (VPC-Optionen)** eingeblendet. Andernfalls wird die Seite **Additional Options (Weitere Optionen)** angezeigt. Hier können Sie die VPC-Optionen konfigurieren.  
![\[VPC-Optionen für skalierbare Umgebungen mit Lastausgleich\]](http://docs.aws.amazon.com/de_de/elasticbeanstalk/latest/dg/images/aeb-vs-publish-beanstalk3b_vpc.png)  
![\[VPC-Optionen für eine Umgebung mit einer einzelnen Instance\]](http://docs.aws.amazon.com/de_de/elasticbeanstalk/latest/dg/images/aeb-vs-publish-beanstalk3b_vpc-single.png)

   1. Wählen Sie die VPC-ID der VPC aus, in der die Umgebung gestartet werden soll. 

   1. Für eine skalierbare Umgebung mit Lastausgleich wählen Sie im Feld **ELB Scheme (ELB-Schema)** die Option **private (privat)** aus, wenn der Elastic Load Balancer nicht für das Internet verfügbar sein soll.

      Bei einer Umgebung mit einer einzelnen Instance ist diese Option nicht auswählbar, da kein Load Balancer vorhanden ist. Weitere Informationen finden Sie unter [Typen von Umgebungen](using-features-managing-env-types.md).

   1. Wählen Sie für eine skalierbare Umgebung mit Lastenausgleich die Subnetze für den Elastic Load Balancer und die Instances aus. EC2 Wenn Sie öffentliche und private Subnetze erstellt haben, stellen Sie sicher, dass der Elastic Load Balancer und die EC2 Instances dem richtigen Subnetz zugeordnet sind. Standardmäßig erstellt Amazon VPC ein öffentliches Standardsubnetz unter 10.0.0.0/24 und ein privates Subnetz unter 10.0.1.0/24. Sie können Ihre vorhandenen Subnetze in der Amazon VPC-Konsole unter einsehen. [https://console.aws.amazon.com/vpc/](https://console.aws.amazon.com/vpc/)

      Bei einer Umgebung mit einer einzelnen Instance benötigt die VPC nur ein öffentliches Subnetz für die Instance. Die Auswahl eines Subnetzes für den Load Balancer ist nicht möglich, da für diese Umgebung kein Load Balancer vorhanden ist. Weitere Informationen finden Sie unter [Typen von Umgebungen](using-features-managing-env-types.md).

   1. Für eine skalierbare Umgebung mit Lastausgleich wählen Sie die Sicherheitsgruppe aus, die Sie für Ihre Instances erstellt haben (wenn zutreffend).

      Für eine Umgebung mit einer einzelnen Instance ist kein NAT-Gerät erforderlich. Wählen Sie die Standardsicherheitsgruppe aus. Elastic Beanstalk weist der Instance eine Elastic IP-Adresse zu, sodass sie Zugang zum Internet hat.

   1. Klicken Sie auf **Weiter**.

1. Konfigurieren Sie auf der Seite **Application Options (Anwendungsoptionen)** die Anwendungsoptionen. 

   1. Wählen Sie im Feld "Target framework" die Option **.NET Framework 4.0** aus. 

   1. Elastic Load Balancing verwendet eine Zustandsprüfung, um festzustellen, ob die EC2 Amazon-Instances, auf denen Ihre Anwendung ausgeführt wird, fehlerfrei sind. Bei der Zustandsprüfung wird der Instance-Zustand durch Überprüfung einer vorgegebenen URL in festgelegten Intervallen bestimmt. Sie können die Standard-URL überschreiben, sodass sie mit einer vorhandenen Ressource der Anwendung übereinstimmt (z. B. `/myapp/index.aspx`). Dazu geben Sie diese im Feld **Application health check URL (Zustandsprüfungs-URL für die Anwendung)** ein. Weitere Informationen zu Anwendungszustandsprüfungen finden Sie unter [Gesundheitscheck](environments-cfg-clb.md#using-features.managing.elb.healthchecks). 

   1. Geben Sie eine E-Mail-Adresse an, wenn Sie Amazon Simple Notification Service (Amazon SNS)-Benachrichtigungen zu wichtigen Ereignissen für die Anwendung erhalten möchten.

   1. Im Abschnitt **Anwendungsumgebung** können Sie Umgebungsvariablen für die EC2 Amazon-Instances angeben, auf denen Ihre Anwendung ausgeführt wird. Diese Einstellung ermöglicht eine bessere Portabilität, da der Quellcode beim Wechseln zwischen den Umgebungen nicht neu kompiliert werden muss.

   1. Wählen Sie die für die Anwendungsbereitstellung zu verwendende Option für die Anmeldeinformationen aus.  
![\[Publish to Beanstalk-Assistent 6\]](http://docs.aws.amazon.com/de_de/elasticbeanstalk/latest/dg/images/aeb-vs-publish-beanstalk3a.png)

   1. Klicken Sie auf **Weiter**.

1. Sofern Sie bereits eine Amazon RDS-Datenbank eingerichtet haben, wird die Seite **Amazon RDS DB Security Group (Amazon RDS DB-Sicherheitsgruppe)** angezeigt. Wenn die Elastic Beanstalk-Umgebung mit der Amazon RDS-DB-Instance verbunden werden soll, wählen Sie eine oder mehrere Sicherheitsgruppen aus. Andernfalls fahren Sie mit dem nächsten Schritt fort. Sobald Sie fertig sind, klicken Sie auf **Next (Weiter)**.  
![\[Publish to Beanstalk-Assistent 7\]](http://docs.aws.amazon.com/de_de/elasticbeanstalk/latest/dg/images/aeb-vs-publish-beanstalk6b.png)

1.  Überprüfen Sie die Bereitstellungsoptionen. Wenn alles korrekt ist, klicken Sie auf **Deploy (Bereitstellen)**.   
![\[Publish to Beanstalk-Assistent 8\]](http://docs.aws.amazon.com/de_de/elasticbeanstalk/latest/dg/images/aeb-vs-publish-beanstalk4.png)

   Das ASP.NET-Projekt wird als Webbereitstellungsdatei exportiert, in Amazon S3 hochgeladen und als neue Anwendungsversion in Elastic Beanstalk registriert. Mit der Bereitstellungsfunktion von Elastic Beanstalk wird die Umgebung überwacht, bis sie mit dem neu bereitgestellten Code verfügbar ist. Auf der Registerkarte "env (Umg.:):<environment name (Umgebungsname)>" können Sie den Status der Umgebung anzeigen.   
![\[Umgebungsstatus\]](http://docs.aws.amazon.com/de_de/elasticbeanstalk/latest/dg/images/aeb-vs-env-status.png)

## Beenden einer Umgebung
<a name="create_deploy_NET.terminating"></a>

Um zu vermeiden, dass Gebühren für ungenutzte AWS Ressourcen anfallen, können Sie eine laufende Umgebung mit dem AWS Toolkit for Visual Studio beenden.

**Anmerkung**  
 Sie können zu einem späteren Zeitpunkt problemlos eine neue Umgebung mit derselben Version starten. 

**So beenden Sie eine Umgebung**

1.  Erweitern Sie den Elastic-Beanstalk-Knoten und den Anwendungsknoten in **AWS Explorer**. Klicken Sie mit der rechten Maustaste auf die Anwendungsumgebung und wählen Sie **Terminate Environment (Umgebung beenden)** aus.

1. Wenn Sie aufgefordert werden, klicken Sie auf **Ja**, um zu bestätigen, dass die Umgebung beendet werden soll. Es dauert einige Minuten, bis Elastic Beanstalk die in der Umgebung laufenden AWS Ressourcen beendet.  
![\[Elastic Beanstalk-Dialogfeld „Beenden einer Umgebung“\]](http://docs.aws.amazon.com/de_de/elasticbeanstalk/latest/dg/images/aeb-vs-terminate-confirm.png)
**Anmerkung**  
Nachdem die Umgebung beendet ist, steht ihr zugehöriger CNAME wieder zur Verfügung und kann von allen verwendet werden. 

# Bereitstellen für Ihre Umgebung
<a name="create_deploy_NET.sdlc.create.edit"></a>

Nachdem Sie Ihre Anwendung getestet haben, können Sie Ihre Anwendung einfach bearbeiten und erneut bereitstellen und die Ergebnisse in wenigen Augenblicken anzeigen. 

 **So bearbeiten Sie Ihre ASP.NET-Webanwendung und stellen Sie erneut bereit ** 

1.  Klicken Sie im **Solution Explorer** mit der rechten Maustaste auf Ihre Anwendung, und klicken Sie dann auf In **Umgebung erneut veröffentlichen < *your environment name* >**. Der Assistent **Erneut in AWS Elastic Beanstalk veröffentlichen** wird geöffnet.  
![\[Assistent für die Veröffentlichung zu Beanstalk 1\]](http://docs.aws.amazon.com/de_de/elasticbeanstalk/latest/dg/images/aeb-vs-republish-beanstalk-sameenv.png)

1.  Überprüfen Sie die Bereitstellungsdetails und klicken Sie dann auf **Deploy (Bereitstellen)**. 
**Anmerkung**  
Wenn Sie Ihre Einstellungen ändern möchten, klicken Sie auf **Abbrechen** und verwenden Sie stattdessen den **In AWS veröffentlichen**-Assistenten. Detaillierte Anweisungen finden Sie unter [Erstellen einer Elastic Beanstalk-Umgebung](dotnet-toolkit.md#create_deploy_NET.sdlc.deploy).

   Ihr aktualisiertes ASP.NET-Webprojekt wird als Webbereitstellungsdatei mit der neuen Versionsbezeichnung exportiert, in Amazon S3 hochgeladen und als neue Anwendungsversion in Elastic Beanstalk registriert. Mit der Bereitstellungsfunktion von Elastic Beanstalk wird die vorhandene Umgebung überwacht, bis sie mit dem neu bereitgestellten Code verfügbar ist. Auf der Registerkarte **env: < *environment name* >** sehen Sie den Status Ihrer Umgebung. 

Sie können auch eine vorhandene Anwendung in einer vorhandenen Umgebung bereitstellen, wenn Sie zum Beispiel auf eine frühere Anwendungsversion zurücksetzen. 

**So stellen Sie eine Anwendungsversion in einer vorhandenen Umgebung bereit**

1. Klicken Sie mit der rechten Maustaste auf Ihre Elastic-Beanstalk-Anwendung, indem Sie den Elastic-Beanstalk-Knoten in **AWS Explorer** erweitern. Wählen Sie **View Status (Status anzeigen)** aus. 

1. Klicken Sie auf der Registerkarte **App: < *application name* >** auf **Versionen**.   
![\[Anwendungsversionen\]](http://docs.aws.amazon.com/de_de/elasticbeanstalk/latest/dg/images/aeb-vs-publish-app-version.png)

1. Klicken Sie auf die Anwendungsversion, die Sie bereitstellen möchten, und dann auf **Publish Version (Version veröffentlichen)**.

1.  Klicken Sie im Assistenten **Publish Application Version (Anwendungsversion veröffentlichen)** auf **Next (Weiter)**.  
![\[Assistent für die Veröffentlichung von Anwendungsversionen 1\]](http://docs.aws.amazon.com/de_de/elasticbeanstalk/latest/dg/images/aeb-vs-republish-beanstalk2a.png)

1.  Überprüfen Sie die Bereitstellungsoptionen und klicken Sie dann auf **Deploy (Bereitstellen)**.   
![\[Assistent für die Veröffentlichung von Anwendungsversionen 2\]](http://docs.aws.amazon.com/de_de/elasticbeanstalk/latest/dg/images/aeb-vs-publish-app-version-wizard3.png)

   Ihr ASP.NET-Projekt wird als eine Webbereitstellungsdatei exportiert und in Amazon S3 hochgeladen. Mit der Bereitstellungsfunktion von Elastic Beanstalk wird die Umgebung überwacht, bis sie mit dem neu bereitgestellten Code verfügbar ist. Auf der Registerkarte **env: < *environment name* >** sehen Sie den Status Ihrer Umgebung. 

# Verwalten Ihrer Elastic Beanstalk-Anwendungsumgebungen
<a name="create_deploy_NET.managing"></a>

Mit dem AWS Toolkit for Visual Studio und der AWS Management Console können Sie die Bereitstellung und Konfiguration der von Ihren AWS Anwendungsumgebungen verwendeten Ressourcen ändern. Informationen zur Verwaltung Ihrer Anwendungsumgebungen mithilfe der AWS Management Console finden Sie unter. [Elastic Beanstalk Beanstalk-Umgebungen verwalten](using-features.managing.md) In diesem Abschnitt werden die spezifischen Service-Einstellungen beschrieben, die Sie im AWS Toolkit for Visual Studio als Teil Ihrer Anwendungsumgebungs-Konfiguration bearbeiten können.

## Ändern der Umgebungskonfigurationseinstellungen
<a name="create_deploy_NET.managing.env"></a>

Wenn Sie Ihre Anwendung bereitstellen, konfiguriert Elastic Beanstalk eine Reihe von AWS Cloud-Computing-Diensten. Sie können mit dem AWS Toolkit for Visual Studio steuern, wie diese einzelnen Dienste konfiguriert werden.

**So bearbeiten Sie die Umgebungseinstellungen einer Anwendung**
+ Erweitern Sie den Elastic Beanstalk-Knoten und Ihren Anwendungsknoten. Klicken Sie anschließend im **AWS -Explorer** mit der rechten Maustaste auf Ihre Elastic-Beanstalk-Umgebung. Wählen Sie **View Status (Status anzeigen)** aus. 

  Sie können nun Einstellungen für Folgendes konfigurieren:
  + herstellen
  + Load Balancing
  + Auto Scaling
  + Benachrichtigungen
  + Umgebungseigenschaften

# Konfiguration von EC2 Serverinstanzen mit dem AWS Toolkit für Visual Studio
<a name="create_deploy_NET.managing.ec2"></a>

Amazon Elastic Compute Cloud (Amazon EC2) ist ein Webservice, mit dem Sie Server-Instances in den Rechenzentren von Amazon starten und verwalten. Sie können EC2 Amazon-Server-Instances jederzeit, so lange Sie benötigen und für jeden legalen Zweck verwenden. Instances sind in verschiedenen Größen und Konfigurationen verfügbar. Weitere Informationen finden Sie auf [Amazon EC2](https://aws.amazon.com/ec2/).

Sie können die EC2 Amazon-Instance-Konfiguration der Elastic Beanstalk Beanstalk-Umgebung mit der Registerkarte **Server** innerhalb Ihrer Anwendungsumgebung im AWS Toolkit for Visual Studio bearbeiten. 

![\[Elastic Beanstalk-Server-Konfigurationsbereich\]](http://docs.aws.amazon.com/de_de/elasticbeanstalk/latest/dg/images/aeb-vs-server.png)


## EC2 Amazon-Instance-Typen
<a name="create_deploy_NET.managing.ec2.instancetypes"></a>

**Instance type (Instance-Typ)** zeigt die für Ihre Elastic Beanstalk-Anwendung verfügbaren Instance-Typen an. Ändern Sie den Instance-Typ, um einen Server mit den Merkmalen (einschließlich Speichergröße und CPU-Leistung) auszuwählen, die für Ihre Anwendung am besten geeignet sind. Anwendungen mit aufwändigen und lange dauernden Operationen erfordern mehr CPU oder Speicher.

Weitere Informationen zu den EC2 Amazon-Instance-Typen, die für Ihre Elastic Beanstalk Beanstalk-Anwendung verfügbar sind, finden Sie unter [Instance-Typen](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/instance-types.html) im *Amazon Elastic Compute Cloud-Benutzerhandbuch*.

## EC2 Amazon-Sicherheitsgruppen
<a name="create_deploy_NET.managing.ec2.securitygroups"></a>

Sie können den Zugriff auf Ihre Elastic Beanstalk Beanstalk-Anwendung mithilfe einer *Amazon EC2 Security Group* kontrollieren. Eine Sicherheitsgruppe definiert Firewall-Regeln für Ihre Instances. Diese Regeln legen fest, welcher eingehende Netzwerkverkehr an Ihre Instance übertragen werden soll. Anderer eingehender Datenverkehr wird verworfen. Sie können die Regeln für eine Gruppe jederzeit ändern. Die neuen Regeln werden automatisch für alle laufenden und künftigen Instances durchgesetzt. 

Sie können Ihre EC2 Amazon-Sicherheitsgruppen mit der AWS Management Console oder mit dem AWS Toolkit for Visual Studio einrichten. **Sie können angeben, welche EC2 Amazon-Sicherheitsgruppen den Zugriff auf Ihre Elastic Beanstalk Beanstalk-Anwendung kontrollieren, indem Sie die Namen einer oder mehrerer EC2 Amazon-Sicherheitsgruppen (durch Kommas getrennt) in das EC2 Textfeld Sicherheitsgruppen eingeben.** 

**Anmerkung**  
Stellen Sie sicher, dass Port 80 (HTTP) über 0.0.0.0/0 als Quell-CIDR-Bereich zugreifbar ist, wenn Sie Zustandsprüfungen für Ihre Anwendung aktivieren möchten. Weitere Informationen zu Zustandsprüfungen finden Sie unter [Zustandsprüfungen](create_deploy_NET.managing.elb.md#create_deploy_NET.managing.elb.healthchecks).

**Um eine Sicherheitsgruppe mit dem Toolkit für Visual Studio zu erstellen AWS**

1.  Erweitern Sie in Visual Studio im **AWS Explorer** den ** EC2Amazon-Knoten**, und doppelklicken Sie dann auf **Sicherheitsgruppen**. 

1.  Klicken Sie auf **Create Security Group (Sicherheitsgruppe erstellen)** und geben Sie einen Namen und eine Beschreibung für Ihre Sicherheitsgruppe ein. 

1.  Klicken Sie auf **OK**. 

Weitere Informationen zu Amazon EC2 Security Groups finden Sie unter [Using Security Groups](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-network-security.html) im *Amazon Elastic Compute Cloud-Benutzerhandbuch*.

## EC2 Amazon-Schlüsselpaare
<a name="create_deploy_NET.managing.ec2.keypair"></a>

Sie können sich mit einem Amazon-Schlüsselpaar sicher bei den EC2 Amazon-Instances anmelden, die für Ihre Elastic Beanstalk Beanstalk-Anwendung bereitgestellt wurden. EC2 

**Wichtig**  
Sie müssen ein EC2 Amazon-Schlüsselpaar erstellen und Ihre von Elastic Beanstalk bereitgestellten EC2 Amazon-Instances so konfigurieren, dass sie das EC2 Amazon-Schlüsselpaar verwenden, bevor Sie auf Ihre von Elastic Beanstalk bereitgestellten Amazon-Instances zugreifen können. EC2 Sie können Ihr key pair mit dem **Publish to AWS** Wizard im AWS Toolkit for Visual Studio erstellen, wenn Sie Ihre Anwendung auf Elastic Beanstalk bereitstellen. Wenn Sie zusätzliche Schlüsselpaare mit dem Toolkit erstellen möchten, führen Sie die folgenden Schritte aus. Alternativ können Sie Ihre EC2 Amazon-Schlüsselpaare über die [AWS Management Console](https://console.aws.amazon.com/) einrichten. Anweisungen zum Erstellen eines key pair für Amazon finden Sie im [Amazon EC2 Elastic Compute Cloud Getting Started Guide](https://docs.aws.amazon.com/AWSEC2/latest/GettingStartedGuide/). 

 Im Textfeld **Bestehendes key pair** können Sie den Namen eines EC2 Amazon-Schlüsselpaars angeben, mit dem Sie sich sicher bei den EC2 Amazon-Instances anmelden können, auf denen Ihre Elastic Beanstalk Beanstalk-Anwendung ausgeführt wird. 

**Um den Namen eines EC2 Amazon-Schlüsselpaars anzugeben**

1. Erweitern Sie den ** EC2Amazon-Knoten** und doppelklicken Sie auf **Schlüsselpaare**.

1.  Klicken Sie auf **Create Key Pair (Schlüsselpaar erstellen)** und geben Sie den Namen des Schlüsselpaares ein. 

1.  Klicken Sie auf **OK**. 

Weitere Informationen zu EC2 Amazon-Schlüsselpaaren finden Sie [unter Using Amazon EC2 Credentials](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-credentials.html) im *Amazon Elastic Compute Cloud-Benutzerhandbuch*. Weitere Informationen zum Herstellen einer Verbindung zu EC2 Amazon-Instances finden Sie unter[Auflisten von Server-Instances/Verbinden mit Server-Instances](create_deploy_NET.ec2connect.md). 

## Überwachungsintervall
<a name="create_deploy_NET.managing.monitoring"></a>

 Standardmäßig sind nur grundlegende CloudWatch Amazon-Metriken aktiviert. Sie geben Daten in 5-Minuten-Intervallen zurück. Sie können detailliertere CloudWatch Ein-Minuten-Metriken aktivieren, indem Sie im Bereich **Server** auf der Registerkarte **Konfiguration** für Ihre Umgebung unter **1 Minute** für das **Überwachungsintervall** auswählen. AWS Toolkit for Eclipse

**Anmerkung**  
 CloudWatch Amazon-Servicegebühren können für Metriken im Abstand von einer Minute anfallen. Weitere Informationen erhalten Sie [ CloudWatchbei Amazon](https://aws.amazon.com/cloudwatch/).

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

 Sie können das Standard-AMI, das für Ihre EC2 Amazon-Instances verwendet wird, durch Ihr eigenes benutzerdefiniertes AMI überschreiben, indem Sie die **ID Ihres benutzerdefinierten AMI** in das Feld Benutzerdefinierte AMI-ID im Abschnitt **Server** der Registerkarte **Konfiguration** für Ihre Umgebung in der eingeben AWS Toolkit for Eclipse. 

**Wichtig**  
Die Verwendung eines eigenen AMI ist eine Aufgabe für Fortgeschrittene und sollte mit Bedacht ausgeführt werden. Wenn Sie ein benutzerdefiniertes AMI benötigen, empfehlen wir, das standardmäßige Elastic Beanstalk-AMI als Ausgangspunkt zu nehmen und es zu ändern. Um als fehlerfrei angesehen zu werden, geht Elastic Beanstalk davon aus, dass EC2 Amazon-Instances eine Reihe von Anforderungen erfüllen, einschließlich eines laufenden Host-Managers. Werden diese Anforderungen nicht erfüllt, funktioniert Ihre Umgebung möglichweise nicht ordnungsgemäß.

# Konfiguration von Elastic Load Balancing mit dem AWS Toolkit für Visual Studio
<a name="create_deploy_NET.managing.elb"></a>

Elastic Load Balancing ist ein Amazon-Webservice, der Ihnen hilft, die Verfügbarkeit und Skalierbarkeit Ihrer Anwendung zu verbessern. Dieser Service macht es Ihnen leicht, Anwendungslasten auf zwei oder mehr EC2 Amazon-Instances zu verteilen. Elastic Load Balancing ermöglicht die Verfügbarkeit durch Redundanz und unterstützt wachsenden Datenverkehr für Ihre Anwendung. 

 Mit Elastic Load Balancer können Sie den eingehenden Datenverkehr der Anwendung automatisch auf sämtliche Instances verteilen, die Sie ausführen. Mit dem Service ist es auch ganz einfach, neue Instances hinzuzufügen, wenn Sie die Kapazität Ihrer Anwendung erhöhen.

 Elastic Beanstalk stellt Elastic Load Balancing automatisch bereit, wenn Sie eine Anwendung bereitstellen. Sie können die EC2 Amazon-Instance-Konfiguration der Elastic Beanstalk Beanstalk-Umgebung mit der Registerkarte **Load Balancer** innerhalb Ihrer Anwendungsumgebung in AWS Toolkit for Visual Studio bearbeiten.

![\[Elastic Beanstalk Elastic Load Balancing-Konfigurationsfeld\]](http://docs.aws.amazon.com/de_de/elasticbeanstalk/latest/dg/images/aeb-vs-loadbalancer.png)


 In den folgenden Abschnitten werden die Elastic Load Balancing-Parameter beschrieben, die Sie für Ihre Anwendung konfigurieren können.

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

Der Load Balancer, der für die Bearbeitung von Anfragen für Ihre Elastic Beanstalk Beanstalk-Anwendung bereitgestellt wurde, sendet Anfragen an die EC2 Amazon-Instances, auf denen Ihre Anwendung ausgeführt wird. Der bereitgestellte Load Balancer kann Anfragen an HTTP- und HTTPS-Ports abhören und Anfragen an die EC2 Amazon-Instances in Ihrer AWS Elastic Beanstalk Anwendung weiterleiten. Standardmäßig verarbeitet der Load Balancer Anfragen auf dem HTTP-Port. Mindestens einer der Ports (HTTP oder HTTPS) muss aktiviert werden.

![\[Elastic Beanstalk Elastic Load Balancing-Konfiguration – Ports\]](http://docs.aws.amazon.com/de_de/elasticbeanstalk/latest/dg/images/aeb-vs-loadbalancer-ports.png)


**Wichtig**  
Stellen Sie sicher, dass der von Ihnen angegebene Port nicht gesperrt ist. Andernfalls können die Benutzer keine Verbindung zu Ihrer Elastic Beanstalk-Anwendung herstellen.

### Steuern des HTTP-Ports
<a name="create_deploy_NET.managing.elb.ports.http"></a>

Um den HTTP-Port auszuschalten, wählen Sie **OFF (AUS)** für **HTTP Listener Port** aus. Zum Aktivieren des HTTP-Ports wählen Sie einen HTTP-Port (z. B. **80**) aus der Liste aus.

**Anmerkung**  
Für den Zugriff auf Ihre Umgebung mit einem anderen als dem Standardport 80, z. B. Port 8080, fügen Sie dem vorhandenen Load Balancer einen Listener hinzu und konfigurieren Sie den neuen Listener für die Überwachung des entsprechenden Ports.  
Geben Sie beispielsweise [AWS CLI für Classic Load Balancer](https://docs.aws.amazon.com/cli/latest/reference/elb/create-load-balancer-listeners.html) den folgenden Befehl ein und *LOAD\$1BALANCER\$1NAME* ersetzen Sie ihn durch den Namen Ihres Load Balancers für Elastic Beanstalk.  

```
aws elb create-load-balancer-listeners --load-balancer-name LOAD_BALANCER_NAME --listeners "Protocol=HTTP, LoadBalancerPort=8080, InstanceProtocol=HTTP, InstancePort=80"
```
Geben Sie beispielsweise [AWS CLI für Application Load Balancers](https://docs.aws.amazon.com/cli/latest/reference/elbv2/create-listener.html) den folgenden Befehl ein und *LOAD\$1BALANCER\$1ARN* ersetzen Sie ihn durch den ARN Ihres Load Balancers für Elastic Beanstalk.  

```
aws elbv2 create-listener --load-balancer-arn LOAD_BALANCER_ARN --protocol HTTP --port 8080
```
Wenn Elastic Beanstalk Ihre Umgebung überwachen soll, entfernen Sie den Listener für Port 80 nicht.

### Steuern des HTTPS-Ports
<a name="create_deploy_NET.managing.elb.ports.https"></a>

Elastic Load Balancing unterstützt das HTTPS/TLS Protokoll, um die Verschlüsselung des Datenverkehrs für Client-Verbindungen zum Load Balancer zu ermöglichen. Verbindungen vom Load Balancer zu den EC2 Instances verwenden Klartextverschlüsselung. Standardmäßig ist der HTTPS-Port deaktiviert.

**So aktivieren Sie den HTTPS-Port**

1. Erstellen Sie ein neues Zertifikat mit AWS Certificate Manager (ACM) oder laden Sie ein Zertifikat und einen Schlüssel zu AWS Identity and Access Management (IAM) hoch. Weitere Informationen zum Anfordern eines ACM-Zertifikats finden Sie unter [Zertifikat anfordern](https://docs.aws.amazon.com/acm/latest/userguide/gs-acm-request.html) im *AWS Certificate Manager -Benutzerhandbuch*. Weitere Informationen zum Importieren von Zertifikaten von Drittanbietern in ACM finden Sie unter [Importieren von Zertifikaten](https://docs.aws.amazon.com/acm/latest/userguide/import-certificate.html) im *AWS Certificate Manager -Benutzerhandbuch*. Wenn ACM [in Ihrer Region nicht verfügbar](https://docs.aws.amazon.com/general/latest/gr/acm.html) ist, verwenden Sie AWS Identity and Access Management (IAM), um ein Zertifikat eines Drittanbieters hochzuladen. Die ACM- und IAM-Services speichern das Zertifikat und stellen einen Amazon-Ressourcennamen (ARN) für das SSL-Zertifikat bereit. Weitere Informationen zum Erstellen und Hochladen von Zertifikaten in IAM finden Sie unter [Arbeiten mit Serverzertifikaten](https://docs.aws.amazon.com/IAM/latest/UserGuide/ManagingServerCerts.html) im *IAM-Benutzerhandbuch*.

1. Geben Sie den HTTPS-Port an, indem Sie einen Port für **HTTPS Listener Port** auswählen.  
![\[Elastic Beanstalk Elastic Load Balancing-Konfiguration – SSL\]](http://docs.aws.amazon.com/de_de/elasticbeanstalk/latest/dg/images/aeb-vs-elb-ssl.png)

1. Geben Sie für **SSL Certificate ID (SSL-Zertifikat-ID)** den Amazon-Ressourcennamen (ARN) Ihres SSL-Zertifikats ein. Beispiel: **arn:aws:iam::123456789012:server-certificate/abc/certs/build** oder **arn:aws:acm:us-east-2:123456789012:certificate/12345678-12ab-34cd-56ef-12345678**. Verwenden Sie das SSL-Zertifikat, das Sie in Schritt 1 erstellt oder hochgeladen haben.

Um den HTTPS-Port auszuschalten, wählen Sie **OFF (AUS)** für **HTTPS Listener Port**.

## Zustandsprüfungen
<a name="create_deploy_NET.managing.elb.healthchecks"></a>

Die Definition der Zustandsprüfung enthält einen URL, die für den Instance-Zustand abgefragt wird. Standardmäßig nutzt Elastic Beanstalk TCP:80 für Nonlegacy-Container und HTTP:80 für Legacy-Container. Sie können die Standard-URL überschreiben, sodass sie mit einer vorhandenen Ressource der Anwendung übereinstimmt (z. B. `/myapp/default.aspx`). Dazu geben Sie diese im Feld **Application Health Check URL (Zustandsprüfungs-URL für die Anwendung)** ein. Wenn Sie die Standard-URL überschreiben, verwendet Elastic Beanstalk HTTP zum Abfragen der Ressource. Wenn Sie überprüfen möchten, ob Sie einen Legacy-Container verwenden, erhalten Sie Informationen unter [Warum sind einige Plattformversionen als Legacy gekennzeichnet?](using-features.migration.md#using-features.migration.why)

 Sie können die Einstellungen für die Integritätsprüfung im Bereich **EC2 Instance Health Check** im Bereich **Load Balancing** steuern.

![\[Elastic Beanstalk Elastic Load Balancing-Konfiguration – Zustandsprüfungen\]](http://docs.aws.amazon.com/de_de/elasticbeanstalk/latest/dg/images/aeb-vs-loadbalancer-healthcheck.png)


Die Definition der Zustandsprüfung enthält einen URL, die für den Instance-Zustand abgefragt wird. Überschreiben Sie die Standard-URL, sodass sie mit einer vorhandenen Ressource der Anwendung übereinstimmt (z. B. `/myapp/index.jsp`). Dazu geben Sie diese im Feld **Application Health Check URL (Zustandsprüfungs-URL für die Anwendung)** ein. 

In der folgenden Liste werden die Zustandsprüfungs-Parameter beschrieben, die Sie für Ihre Anwendung festlegen können. 
+ Geben Sie für **Health Check Interval (Sekunden)** die Anzahl der Sekunden ein, die Elastic Load Balancing zwischen den Zustandsprüfungen für die EC2 Amazon-Instances Ihrer Anwendung wartet.
+  Für **Health Check Timeout (seconds) (Zustandsprüfungs-Timeout (Sekunden))** geben Sie die Anzahl der Sekunden ein, die Elastic Load Balancing auf eine Antwort wartet, bevor die Instance als nicht reagierend eingestuft wird.
+ Für **Healthy Check Count Threshold (Schwellenwert Anzahl erfolgreicher Zustandsprüfungen)** und **Unhealthy Check Count Threshold (Schwellenwert Anzahl fehlgeschlagener Zustandsprüfungen)** geben Sie die Anzahl der aufeinanderfolgenden erfolgreichen oder nicht erfolgreichen URL-Proben ein, bevor Elastic Load Balancing den Status des Instance-Zustands ändert. Beispiel: Die Angabe von **5** für **Unhealthy Check Count Threshold (Schwellenwert Anzahl fehlgeschlagener Zustandsprüfungen)** bedeutet, dass die URL fünfmal hintereinander eine Fehlermeldung oder eine Zeitüberschreitung zurückgeben müssten, bevor Elastic Load Balancing die Zustandsprüfung als fehlgeschlagen einstufen würde.

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

Standardmäßig leitet ein Load Balancer jede Anforderung getrennt an die Server-Instance mit der kleinsten Last weiter. Im Vergleich dazu bindet eine Sticky Session eine Benutzersitzung an eine bestimmte Server-Instance, sodass alle vom Benutzer während der Sitzung gesendeten Anforderungen an die gleiche Server-Instance übermittelt werden. 

 Elastic Beanstalk nutzt von Load Balancer generierte HTTP-Cookies, wenn Sticky Sessions für eine Anwendung aktiviert sind. Der Load Balancer verwendet ein vom Load-Balancer generiertes spezielles Cookie, um die Anwendungs-Instance für jede Anforderung nachzuverfolgen. Wenn der Load Balancer eine Anforderung empfängt, prüft er zunächst, ob dieses Cookie in der Anforderung vorhanden ist. Wenn ja, wird die Anforderung an die im Cookie angegebene Anwendungs-Instance gesendet. Wenn kein Cookie vorhanden ist, wählt der Load Balancer eine Anwendungs-Instance basierend auf dem vorhandenen Load Balancing-Algorithmus aus. Ein Cookie wird in die Antwort eingefügt, um nachfolgende Anforderungen von demselben Benutzer an diese Anwendungs-Instance zu binden. Mit der Konfiguration der Richtlinie wird ein Cookie-Ablauf definiert, der die Dauer der Gültigkeit für jedes Cookie festlegt. 

Sie können über den Abschnitt **Sessions (Sitzungen)** auf der Registerkarte **Load Balancer** angeben, ob der Load Balancer für Ihre Anwendung "Sticky Sessions" erlaubt.

![\[Elastic Beanstalk Elastic Load Balancing-Konfiguration – Sitzungen\]](http://docs.aws.amazon.com/de_de/elasticbeanstalk/latest/dg/images/aeb-vs-loadbalancer-sessions.png)


 Weitere Informationen zu Elastic Load Balancing finden Sie im [Elastic Load Balancing-Entwicklerhandbuch](https://docs.aws.amazon.com/ElasticLoadBalancing/latest/DeveloperGuide/). 

# Konfiguration von Auto Scaling mit dem AWS Toolkit für Visual Studio
<a name="create_deploy_NET.managing.as"></a>

Amazon EC2 Auto Scaling ist ein Amazon-Webservice, der EC2 Amazon-Instances auf der Grundlage benutzerdefinierter Trigger automatisch startet oder beendet. Benutzer können *Auto Scaling-Gruppen* einrichten und diesen Gruppen *Auslöser* zuweisen, um Datenverarbeitungsressourcen automatisch basierend auf Metriken, wie Bandbreitennutzung oder CPU-Auslastung, zu skalieren. Amazon EC2 Auto Scaling arbeitet mit Amazon zusammen CloudWatch , um Metriken für die Server-Instances abzurufen, auf denen Ihre Anwendung ausgeführt wird.

Mit Amazon EC2 Auto Scaling können Sie eine Gruppe von EC2 Amazon-Instances nehmen und verschiedene Parameter festlegen, sodass die Anzahl dieser Gruppen automatisch erhöht oder verringert wird. Amazon EC2 Auto Scaling kann EC2 Amazon-Instances zu dieser Gruppe hinzufügen oder daraus entfernen, damit Sie problemlos mit Verkehrsänderungen in Ihrer Anwendung umgehen können. 

 Amazon EC2 Auto Scaling überwacht auch den Zustand jeder EC2 Amazon-Instance, die es startet. Wenn eine Instance unerwartet beendet wird, erkennt Amazon EC2 Auto Scaling die Kündigung und startet eine Ersatz-Instance. Mit dieser Funktion können Sie automatisch eine feste, gewünschte Anzahl von EC2 Amazon-Instances verwalten. 

Elastic Beanstalk stellt Amazon EC2 Auto Scaling für Ihre Anwendung bereit. Sie können die EC2 Amazon-Instance-Konfiguration der Elastic Beanstalk Beanstalk-Umgebung mit der Registerkarte **Auto Scaling** innerhalb Ihrer Anwendungsumgebung im AWS Toolkit for Visual Studio bearbeiten.

![\[Elastic Beanstalk Auto Scaling-Konfigurationsfeld\]](http://docs.aws.amazon.com/de_de/elasticbeanstalk/latest/dg/images/aeb-vs-autoscaling.png)


Im folgenden Abschnitt wird beschrieben, wie Sie Auto Scaling-Parameter für die Anwendung konfigurieren. 

## Starten der Konfiguration
<a name="create_deploy_NET.managing.as.launchconfig"></a>

Sie können die Startkonfiguration bearbeiten, um zu steuern, wie Ihre Elastic Beanstalk Beanstalk-Anwendung Amazon EC2 Auto Scaling Scaling-Ressourcen bereitstellt.

In den Feldern **Minimum Instance Count (Minimale Instance-Anzahl)** and **Maximum Instance Count (Maximale Instance-Anzahl)** geben Sie die minimale sowie die maximale Größe der Auto Scaling-Gruppe an, die von der Elastic Beanstalk-Anwendung genutzt wird.

![\[Elastic Beanstalk Auto Scaling-Startkonfiguration – Konfigurationsfenster\]](http://docs.aws.amazon.com/de_de/elasticbeanstalk/latest/dg/images/aeb-vs-autoscaling-launchconfig.png)


**Anmerkung**  
Um eine feste Anzahl von EC2 Amazon-Instances beizubehalten, setzen Sie **Minimum Instance Count** und **Maximum Instance Count** auf denselben Wert.

Im Feld **Availability Zones** können Sie die Anzahl der Availability Zones angeben, in denen sich Ihre EC2 Amazon-Instances befinden sollen. Es ist wichtig, diese Zahl festzulegen, wenn Sie fehlertolerante Anwendungen erstellen möchten. Falls eine Availability Zone ausfällt, werden die Instances in den anderen Availability Zones weiterhin ausgeführt. 

**Anmerkung**  
Derzeit ist es nicht möglich anzugeben, in welcher Availability Zone sich Ihre Instance befinden wird. 

## Auslöser
<a name="create_deploy_NET.managing.as.trigger"></a>

Ein *Trigger* ist ein Amazon EC2 Auto Scaling Scaling-Mechanismus, den Sie so einrichten, dass er dem System mitteilt, wann Sie die Anzahl der Instances erhöhen (nach oben *skalieren*) und wann Sie die Anzahl der Instances verringern (*skalieren*) möchten. Sie können Trigger so konfigurieren, dass sie bei jeder auf Amazon veröffentlichten Metrik *ausgelöst* werden CloudWatch, z. B. bei der CPU-Auslastung, und feststellen, ob die von Ihnen angegebenen Bedingungen erfüllt sind. Wird der obere oder untere Schwellenwert der Metrikbedingungen für einen bestimmten Zeitraum überschritten, startet der Auslöser den anhaltenden Prozess der *Skalierung*.

Mit dem AWS Toolkit for Visual Studio können Sie einen Skalierungs-Trigger für Ihre Elastic Beanstalk Beanstalk-Anwendung definieren.

![\[Elastic Beanstalk Auto Scaling-Auslöser\]](http://docs.aws.amazon.com/de_de/elasticbeanstalk/latest/dg/images/aeb-vs-autoscaling-triggers.png)


Amazon EC2 Auto Scaling-Trigger funktionieren, indem sie eine bestimmte CloudWatch Amazon-Metrik für eine Instance beobachten. Zu den Auslösern zählen CPU-Auslastung, Netzwerkdatenverkehr und Datenträgeraktivität. Mit der Einstellung **Trigger Measurement (Auslösermessung)** wählen Sie eine Metrik für den Auslöser aus.

In der folgenden Liste werden die Trigger-Parameter beschrieben, die Sie mit der AWS Management Console konfigurieren können.
+ Sie können angeben, welche Statistik der Auslöser verwenden soll. Sie können **Minimum**, **Maximum**, **Sum (Summe)** oder **Average (Durchschnitt)** für **Trigger Statistic (Auslöserstatistik)** auswählen.
+ Für **Unit of Measurement (Maßeinheit)** geben Sie die Maßeinheit für den Auslöser an.
+ Der Wert im Feld **Messzeitraum** gibt an, wie oft Amazon die Metriken für Ihren Trigger CloudWatch misst. Mit **Breach Duration (Verletzungsdauer)** wird der Zeitraum angegeben, für den der Grenzwert einer Metrik überschritten werden kann (wie unter **Upper Threshold (Oberer Schwellenwert)** und **Lower Threshold (Unterer Schwellenwert)** definiert), bevor der Auslöser ausgelöst wird.
+ Geben Sie für **Upper Breach Scale Increment** und **Lower Breach Scale Increment** an, wie viele EC2 Amazon-Instances hinzugefügt oder entfernt werden sollen, wenn eine Skalierungsaktivität ausgeführt wird. 

Weitere Informationen zu Amazon EC2 Auto Scaling finden Sie im Abschnitt *Amazon EC2 Auto Scaling* in der [Amazon Elastic Compute Cloud-Dokumentation](https://aws.amazon.com/documentation/ec2/).

# Konfiguration von Benachrichtigungen mit dem AWS Toolkit für Visual Studio
<a name="create_deploy_NET.container.sns"></a>

Elastic Beanstalk verwendet den Amazon Simple Notification Service (Amazon SNS) für Benachrichtigungen zu wichtigen Ereignissen in Ihrer Anwendung. Um Amazon SNS-Benachrichtigungen zu aktivieren, geben Sie einfach Ihre E-Mail-Adresse in das Feld **Email Address** ein. Um diese Benachrichtigungen zu deaktivieren, entfernen Sie Ihre E-Mail-Adresse aus dem Feld.

![\[Elastic Beanstalk-Benachrichtigungsfenster\]](http://docs.aws.amazon.com/de_de/elasticbeanstalk/latest/dg/images/aeb-vs-notifications.png)


# Konfiguration von.NET-Containern mit dem AWS Toolkit für Visual Studio
<a name="create_deploy_NET.container"></a>

 Im Bereich **Container/.NET-Optionen** können Sie das Verhalten Ihrer EC2 Amazon-Instances optimieren und die Amazon S3-Protokollrotation aktivieren oder deaktivieren. Sie können das AWS Toolkit for Visual Studio verwenden, um Ihre Containerinformationen zu konfigurieren.

**Anmerkung**  
Sie können Ihre Konfigurationseinstellungen ändern, ohne eine Ausfallzeit in Kauf nehmen zu müssen, indem Sie den CNAME für Ihre Umgebungen austauschen. Weitere Informationen finden Sie unter [Blau/Grün-Bereitstellungen mit Elastic Beanstalk](using-features.CNAMESwap.md).

Wenn Sie möchten, können Sie die Anzahl der Parameter erhöhen. Weitere Informationen über das Erhöhen der Parameteranzahl finden Sie unter [Optionseinstellungen](ebextensions-optionsettings.md).

**So greifen Sie auf den Container/.NET-Optionsbereich für Ihre Elastic Beanstalk-Anwendung zu**

1. Erweitern Sie in AWS Toolkit for Visual Studio den Elastic Beanstalk-Knoten und Ihren Anwendungsknoten. 

1. Klicken Sie im **AWS Explorer** doppelt auf Ihre Elastic-Beanstalk-Umgebung.

1. Klicken Sie unten im Bereich **Overview (Übersicht)** auf die Registerkarte **Configuration (Konfiguration)**.

1. Konfigurieren Sie im Bereich **Container** die Containeroptionen.   
![\[Elastic Beanstalk Container-Bereich\]](http://docs.aws.amazon.com/de_de/elasticbeanstalk/latest/dg/images/aeb-vs-container.png)

## .NET-Container-Optionen
<a name="create_deploy_NET.container.vs.options"></a>

Sie können die Version von .NET-Framework für Ihre Anwendung wählen. Wählen Sie entweder 2.0 oder 4.0 für **Target runtime (Ziellaufzeit)** aus. Wählen Sie **Enable 32-bit Applications (32-Bit-Anwendungen aktivieren)** aus, wenn Sie 32-Bit-Anwendungen aktivieren möchten.

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

Unter **Application Settings (Anwendungseinstellungen)** geben Sie Umgebungsvariablen an, die aus dem Anwendungscode ausgelesen werden. 

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


# Verwalten von Konten
<a name="create_deploy_NET.accounts"></a>

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

Wenn Sie verschiedene AWS Konten einrichten möchten, um verschiedene Aufgaben wie Testen, Staging und Produktion auszuführen, können Sie Konten mit dem AWS Toolkit for Visual Studio hinzufügen, bearbeiten und löschen.

**So verwalten Sie mehrere Konten**

1.  Klicken Sie in Visual Studio im Menü **Anzeigen** auf **AWS -Explorer**.

1.  Neben der Liste **Account (Konto)** klicken Sie auf die Schaltfläche **Add Account (Konto hinzufügen)**.   
![\[AWS Registerkarte „Explorer“\]](http://docs.aws.amazon.com/de_de/elasticbeanstalk/latest/dg/images/aeb-aws-explorer-tab.png)

    Das Dialogfeld **Add Account (Konto hinzufügen)** wird angezeigt.   
![\[Dialogfeld "Add Account (Konto hinzufügen)"\]](http://docs.aws.amazon.com/de_de/elasticbeanstalk/latest/dg/images/aeb-vs-add-account.png)

1. Geben Sie die erforderlichen Informationen ein. 

1.  Ihre Kontoinformationen werden nun auf der Registerkarte **AWS -Explorer** angezeigt. Wenn Sie eine Veröffentlichung in Elastic Beanstalk durchführen, können Sie auswählen, welches Konto Sie verwenden möchten. 

# Auflisten von Server-Instances/Verbinden mit Server-Instances
<a name="create_deploy_NET.ec2connect"></a>

Sie können eine Liste der EC2 Amazon-Instances, auf denen Ihre Elastic Beanstalk Beanstalk-Anwendungsumgebung ausgeführt wird, über das AWS Toolkit for Visual Studio oder über die AWS Management Console anzeigen. Die Verbindung zu diesen Instances können Sie mit Remote Desktop Connection herstellen. Informationen zum Auflisten und Herstellen einer Verbindung zu Ihren Server-Instances mithilfe der AWS Management Console finden Sie unter. [Auflisten von Server-Instances/Verbinden mit Server-Instances](using-features.ec2connect.md) Im folgenden Abschnitt erfahren Sie, wie Sie Ihre Serverinstanzen mithilfe des AWS Toolkit for Visual Studio anzeigen und eine Verbindung zu ihnen herstellen.

**So zeigen Sie EC2 Amazon-Instances für eine Umgebung an und stellen eine Verbindung zu ihnen her**

1.  Erweitern Sie in Visual Studio im **AWS Explorer** den ** EC2Amazon-Knoten** und doppelklicken Sie auf **Instances**. 

1.  Klicken Sie in der Spalte Instance mit der rechten Maustaste auf die EC2 Instance-ID für die **Amazon-Instance**, die im Load Balancer Ihrer Anwendung ausgeführt wird, und wählen Sie im Kontextmenü **Remote Desktop öffnen** aus.   
![\[Dialogfeld “Open Remote Desktop (Remotedesktop öffnen)“\]](http://docs.aws.amazon.com/de_de/elasticbeanstalk/latest/dg/images/aeb-vs-rdp-login.png)

1.  Wählen Sie ** EC2 Schlüsselpaar verwenden, um sich anzumelden,** und fügen Sie den Inhalt Ihrer privaten Schlüsseldatei, die Sie zur Bereitstellung Ihrer Anwendung verwendet haben, in das Feld **Privater** Schlüssel ein. Alternativ geben Sie Ihren Benutzernamen und Ihr Passwort in die Textfelder **User name (Benutzername)** und **Password (Passwort)** ein.
**Anmerkung**  
Wenn das Schlüsselpaar im Toolkit gespeichert ist, wird das Textfeld nicht angezeigt.

1. Klicken Sie auf **OK**.

# Überwachen des Anwendungsstatus
<a name="create_deploy_NET.healthstatus"></a>

Bei Ausführung einer Produktionswebsite ist es wichtig zu wissen, dass die Anwendung verfügbar ist und auf Anforderungen reagiert. Für die Überwachung der Reaktionsfähigkeit der Anwendung können Sie die Elastic Beanstalk-Funktionen nutzen, mit denen Sie Anwendungsstatistiken überwachen und Warnungen erstellen können, die bei einer Überschreitung der Schwellenwerte ausgelöst werden.

Weitere Informationen über die Integritätsüberwachung von Elastic Beanstalk finden Sie unter [Grundlegende Zustandsberichte](using-features.healthstatus.md).

Sie können auf Betriebsinformationen zu Ihrer Anwendung zugreifen, indem Sie entweder das AWS Toolkit for Visual Studio oder die AWS Management Console verwenden.

Das Toolkit zeigt den Zustand Ihrer Umgebung und den Anwendungsstatus im Feld **Status** an.

![\[Elastic Beanstalk-Zustand\]](http://docs.aws.amazon.com/de_de/elasticbeanstalk/latest/dg/images/aeb-vs-env-status.png)


**So überwachen Sie den Anwendungsstatus**

1. Erweitern Sie im AWS Toolkit for Visual Studio im **AWS Explorer** den Elastic Beanstalk-Knoten und dann Ihren Anwendungsknoten. 

1. Klicken Sie mit der rechten Maustaste auf Ihre Elastic Beanstalk-Umgebung und anschließend auf **View Status (Status anzeigen)**.

1. Klicken Sie auf der Registerkarte der Anwendungsumgebung auf **Monitoring (Überwachung)**.

   Der Bereich **Monitoring (Überwachung)** enthält eine Reihe von Diagrammen, die die Ressourcennutzung für Ihre bestimmte Anwendungsumgebung zeigen.  
![\[Elastic Beanstalk-Überwachungsbereich\]](http://docs.aws.amazon.com/de_de/elasticbeanstalk/latest/dg/images/aeb-vs-monitoring.png)
**Anmerkung**  
Standardmäßig ist der Zeitraum auf der letzten Stunde gesetzt. Ändern Sie diese Einstellung, indem Sie in der Liste **Time Range (Zeitraum)** auf einen anderen Zeitraum klicken.

Sie können das AWS Toolkit for Visual Studio oder die AWS Management Console verwenden, um Ereignisse im Zusammenhang mit Ihrer Anwendung anzuzeigen.

**So zeigen Sie Anwendungsereignisse an**

1. Erweitern Sie im AWS Toolkit for Visual Studio im **AWS Explorer** den Elastic Beanstalk-Knoten und Ihren Anwendungsknoten. 

1. Klicken Sie in **AWS -Explorer** mit der rechten Maustaste auf Ihre Elastic-Beanstalk-Umgebung und anschließend auf **Status anzeigen**. 

1. Klicken Sie in der Registerkarte der Anwendungsumgebung auf **Events (Ereignisse)**.  
![\[Elastic Beanstalk-Ereignisfenster\]](http://docs.aws.amazon.com/de_de/elasticbeanstalk/latest/dg/images/aeb-vs-events.png)

# Bereitstellung von Elastic Beanstalk Beanstalk-Anwendungen in.NET mithilfe von AWS Bereitstellungstools
<a name="deploy_NET_standalone_tool"></a>

AWS bietet zwei Befehlszeilentools für die Bereitstellung von.NET Core- und ASP.NET Core-Anwendungen auf Elastic Beanstalk:
+ **AWS .NET-Bereitstellungstool** — Ein modernes Befehlszeilentool, das die Bereitstellung von.NET-Anwendungen für AWS Dienste, einschließlich Elastic Beanstalk, vereinfacht. Dieses Tool bietet ein interaktives Erlebnis und kann automatisch den besten AWS Service für Ihre Anwendung ermitteln. Weitere Informationen finden Sie [AWS unter.NET-Bereitstellungstool](https://github.com/aws/aws-dotnet-deploy?tab=readme-ov-file#aws-net-deployment-tool).
+ **AWS Erweiterungen für.NET CLI** — Eine Reihe von.NET-CLI-Erweiterungen, die Befehle für die Bereitstellung von.NET Core-Anwendungen für Elastic Beanstalk und andere AWS Dienste bereitstellen. Diese Erweiterungen lassen sich in den standardmäßigen .NET-CLI-Workflow integrieren. Weitere Informationen finden Sie unter [AWS Erweiterungen für.NET CLI](https://github.com/aws/aws-extensions-for-dotnet-cli?tab=readme-ov-file#aws-elastic-beanstalk-amazonelasticbeanstalktools).

# Migrieren Ihrer lokalen .NET-Anwendung zu Elastic Beanstalk
<a name="dotnet-onpremmigration"></a>

AWS Elastic Beanstalk bietet über die Elastic Beanstalk Command Line Interface (EB CLI) einen optimierten Migrationspfad für Ihre Windows-Anwendungen, die auf Internet Information Services (IIS) ausgeführt werden. Der **eb migrate** Befehl erkennt automatisch Ihre IIS-Sites, -Anwendungen und virtuellen Verzeichnisse, behält ihre Konfigurationen bei und stellt sie in der Cloud bereit. AWS 

Diese integrierte Migrationsfunktion bietet einen einfacheren Ansatz, der die Komplexität und den Zeitaufwand reduziert, der normalerweise mit Cloud-Migrationen verbunden ist. Der Migrationsprozess trägt dazu bei, die Anwendungsfunktionalität und die Konfigurationsintegrität während der Umstellung auf aufrechtzuerhalten. AWS

Vollständige, detaillierte Anweisungen zur Migration Ihrer IIS-Anwendungen auf AWS Elastic Beanstalk finden Sie im [Migration von IIS-Anwendungen zu Elastic Beanstalk](dotnet-migrating-applications.md) Kapitel in diesem Handbuch.

# Empfehlungen für ausrangierte Windows Server-Komponenten auf Elastic Beanstalk
<a name="dotnet-deprecation-recommendations"></a>

Dieses Thema enthält Empfehlungen für den Fall, dass Ihre Anwendungen derzeit auf den veralteten Windows Server 2012 R2-Plattformzweigen ausgeführt werden. Es befasst sich auch mit der veralteten Unterstützung für die Protokollversionen TLS 1.0 und 1.1 auf unseren AWS Service-API-Endpunkten und den betroffenen Plattformzweigen.

## Plattformzweige von Windows Server 2012 R2 außer Betrieb genommen
<a name="dotnet-retired-branches"></a>

Elastic Beanstalk hat die Windows Server 2012 R2-Plattformzweige am [4. Dezember 2023](https://docs.aws.amazon.com/elasticbeanstalk/latest/relnotes/release-2023-12-04-windows-2012-retire.html) eingestellt und die mit diesen Plattformen AMIs verknüpften Zweige am 10. April 2024 privat gemacht. Diese Aktion verhindert das Starten von Instances in Ihren Windows Server 2012-Umgebungen, die das standardmäßige Beanstalk-AMI verwenden.

Wenn Sie Umgebungen haben, die auf ausgemusterten Windows-Plattformzweigen ausgeführt werden, empfehlen wir Ihnen, diese auf eine der folgenden Windows Server-Plattformen zu migrieren, die aktuell sind und vollständig unterstützt werden:
+ Windows Server 2022 mit IIS 10.0 Version 2.x
+ Windows Server 2019 mit IIS 10.0, Version 2.x

Vollständige Überlegungen zur Migration finden Sie unter [Migration von früheren Hauptversionen der Windows Server-Plattform](dotnet-v2migration.md#dotnet-v2migration.migration).

Weitere Informationen zu Plattform-Veraltung finden Sie unter [Support-Richtlinie für die Elastic Beanstalk-Plattform](platforms-support-policy.md).

**Anmerkung**  
Wenn Sie nicht auf diese vollständig unterstützten Plattformen migrieren können, empfehlen wir, ein mit Windows Server 2012 R2 oder Windows Server 2012 R2 Core AMIs erstelltes benutzerdefiniertes Image AMIs als Basisimage zu verwenden, sofern Sie dies noch nicht getan haben. Detaillierte Anweisungen finden Sie unter [Behalten des Zugriffs auf ein Amazon Machine Image (AMI) für eine außer Betrieb genommene Plattform](using-features.customenv-env-copy.md). Wenden Sie sich an das [AWS Support Center](https://console.aws.amazon.com/support/home#/), wenn Sie während der Durchführung eines dieser Migrationsschritte temporären Zugriff auf ein AMI benötigen.

## TLS 1.2 Kompatibilität
<a name="tls-1-2-enforcement."></a>

Am 31. Dezember 2023 wurde mit der vollständigen Durchsetzung von TLS 1.2 auf allen AWS API-Endpunkten AWS begonnen. Durch diese Aktion wurde die Möglichkeit, die TLS-Versionen 1.0 und 1.1 mit allen zu verwenden, aufgehoben. AWS APIs Diese Information wurde ursprünglich am [28. Juni 2022](https://aws.amazon.com/blogs/security/tls-1-2-required-for-aws-endpoints/) übermittelt. Um das Risiko einer Beeinträchtigung der Verfügbarkeit zu vermeiden, sollten Sie alle Umgebungen, in denen die hier genannten Plattformversionen ausgeführt werden, so bald wie möglich auf eine neuere Version aktualisieren, sofern Sie dies noch nicht getan haben.

**Mögliche Auswirkungen**  
Versionen der Elastic Beanstalk-Plattformen, auf denen TLS v1.1 oder früher ausgeführt wird, sind betroffen. Diese Änderung wirkt sich auf Umgebungsaktionen aus, die unter anderem Folgendes umfassen: Konfigurationsbereitstellungen, Anwendungsbereitstellungen, auto Skalierung, Start neuer Umgebungen, Protokollrotation, erweiterte Gesundheitsberichte und Veröffentlichung von Anwendungsprotokollen im Amazon S3 S3-Bucket, der Ihren Anwendungen zugeordnet ist.

**Betroffene Windows-Plattformversionen**  
Kunden mit Elastic-Beanstalk-Umgebungen auf der folgenden Plattformversion wird empfohlen, jede ihrer entsprechenden Umgebungen auf die Windows-Plattformversion 2.8.3 oder höher, veröffentlicht am [18. Februar 2022](https://docs.aws.amazon.com/elasticbeanstalk/latest/relnotes/release-2022-02-18-windows.html), zu aktualisieren.
+ Windows Server 2019 – Plattformversion 2.8.2 oder frühere Versionen

Kunden mit Elastic-Beanstalk-Umgebungen auf den folgenden Plattformversionen wird empfohlen, jede ihrer entsprechenden Umgebungen auf die Windows-Plattformversion 2.10.7 oder höher, veröffentlicht am [28. Dezember 2022](https://docs.aws.amazon.com/elasticbeanstalk/latest/relnotes/release-2022-12-28-windows.html), zu aktualisieren.
+ Windows Server 2016 – Plattformversion 2.10.6 oder frühere Versionen
+ Windows Server 2012 — alle Plattformversionen; diese Plattform wurde am [4. Dezember 2023](https://docs.aws.amazon.com/elasticbeanstalk/latest/relnotes/release-2023-12-04-windows-2012-retire.html) eingestellt 
+ Windows Server 2008 — alle Plattformversionen; diese Plattform wurde am [28. Oktober 2019](https://docs.aws.amazon.com/elasticbeanstalk/latest/relnotes/release-2019-10-28-windows.html) eingestellt 

Eine Liste der neuesten und unterstützten Versionen der Windows-Server-Plattform finden Sie unter [Unterstützte Plattformen](https://docs.aws.amazon.com/elasticbeanstalk/latest/platforms/platforms-supported.html#platforms-supported.net) im *AWS Elastic Beanstalk -Plattformen*-Leitfaden. 

Einzelheiten und bewährte Methoden zur Aktualisierung Ihrer Umgebung finden Sie unter[Aktualisieren der Plattformversion für die Elastic Beanstalk-Umgebung](using-features.platform.upgrade.md).