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.
# Erstellen eines Stacks und Ausführen einer Anwendung
**Wichtig**
Der AWS OpsWorks Stacks Dienst hat am 26. Mai 2024 das Ende seiner Lebensdauer erreicht und wurde sowohl für neue als auch für bestehende Kunden deaktiviert. Wir empfehlen Kunden dringend, ihre Workloads so bald wie möglich auf andere Lösungen zu migrieren. Wenn Sie Fragen zur Migration haben, wenden Sie sich an das AWS Support Team auf [AWS re:POST](https://repost.aws/) oder über den [AWS Premium-Support](https://aws.amazon.com/support).
In diesem Abschnitt wird erläutert, wie Sie das Tomcat-Rezeptbuch zum Implementieren einer grundlegenden Stack-Einrichtung verwenden, die eine einfache JSP-Anwendung (Java Server Pages-Anwendung) mit dem Namen "SimpleJSP" ausführt. Der Stack besteht aus einer Tomcat-basierten benutzerdefinierten Ebene mit dem Namen TomCustom und einer MySQL-Schicht. SimpleJSP wird in der MySQL-Datenbank bereitgestellt TomCustom und zeigt einige Informationen aus der MySQL-Datenbank an. Wenn Sie noch nicht mit den Grundlagen der Verwendung von OpsWorks Stacks vertraut sind, sollten Sie zuerst lesen. [Erste Schritte mit Chef 11 Linux-Stacks](gettingstarted.md)
## Die Anwendung SimpleJSP
Die SimpleJSP-Anwendung zeigt die Grundlagen der Einrichtung einer Datenbankverbindung und des Abrufens von Daten aus der MySQL-Datenbank des Stacks.
```
DB Access
<%@ page language="java" import="java.sql.*,javax.naming.*,javax.sql.*" %>
<%
StringBuffer output = new StringBuffer();
DataSource ds = null;
Connection con = null;
Statement stmt = null;
ResultSet rs = null;
try {
Context initCtx = new InitialContext();
ds = (DataSource) initCtx.lookup("java:comp/env/jdbc/mydb");
con = ds.getConnection();
output.append("Databases found:
");
stmt = con.createStatement();
rs = stmt.executeQuery("show databases");
while (rs.next()) {
output.append(rs.getString(1));
output.append("
");
}
}
catch (Exception e) {
output.append("Exception: ");
output.append(e.getMessage());
output.append("
");
}
finally {
try {
if (rs != null) {
rs.close();
}
if (stmt != null) {
stmt.close();
}
if (con != null) {
con.close();
}
}
catch (Exception e) {
output.append("Exception (during close of connection): ");
output.append(e.getMessage());
output.append("
");
}
}
%>
<%= output.toString() %>
```
SimpleJSP verwendet ein `DataSource`-Objekt für die Kommunikation mit der MySQL-Datenbank. Tomcat verwendet die Daten in der [Webanwendungs-Kontextkonfigurationsdatei](create-custom-configure.md#create-custom-configure-context), um ein `DataSource`-Objekt zu erstellen und zu initialisieren und mit einem logischen Namen zu verknüpfen. Es registriert dann den logischen Namen mit einer Java Naming and Directory Interface (JNDI). Um eine Instance des entsprechenden `DataSource`-Objekts zu erhalten, erstellen Sie ein `InitialContext`-Objekt und geben Sie den logischen Namen der Ressource an die `lookup`-Methode des Objekts weiter, die das entsprechende Objekt abruft. Der logische Namen des SimpleJSP-Beispiels, `java:comp/env/jdbc/mydb`, weist folgende Bestandteile auf:
+ Den Stamm-Namespace, `java`, der vom restlichen Namen durch einen Doppelpunkt (:) getrennt ist
+ Alle zusätzlichen Namespaces, getrennt durch Schrägstriche (/)
Tomcat fügt dem `comp/env`-Namespace automatisch Ressourcen hinzu.
+ Den Ressourcennamen, der in der Webanwendungs-Kontextkonfigurationsdatei definiert ist und mit einem Schrägstrich (/) vom Namespace getrennt ist
Der Ressourcenname für dieses Beispiel lautet `jdbc/mydb`.
Zum Herstellen einer Verbindung mit der Datenbank führt SimpleJSP Folgendes aus:
1. Ruft die `DataSource`-Methode des `getConnection`-Objekts auf, die ein `Connection`-Objekt zurückgibt.
1. Ruft die `Connection`-Methode des `createStatement`-Objekts auf, um ein `Statement`-Objekt zu erstellen, das Sie zur Kommunikation mit der Datenbank verwenden.
1. Kommuniziert mit der Datenbank, indem die entsprechende `Statement`-Methode aufgerufen wird.
SimpleJSP ruft `executeQuery` auf, um eine SHOW DATABASES-Abfrage auszuführen, die die Datenbanken des Servers auflistet.
Die `executeQuery`-Methode gibt ein `ResultSet`-Objekt zurück, das die Abfrageergebnisse enthält. SimpleJSP ruft den Datenbanknamen aus dem zurückgegebenen `ResultSet`-Objekts ab und verkettet sie, um eine Ausgabezeichenfolge zu erstellen. Zuletzt schließt das Beispiel die Objekte `ResultSet`, `Statement` und `Connection`. Weitere Informationen zu JSP und JDBC finden Sie unter [JavaServer Pages Technology](http://docs.oracle.com/javaee/5/tutorial/doc/bnagx.html) bzw. [JDBC](http://docs.oracle.com/javase/tutorial/jdbc/basics/) Basics.
Um SimpleJSP mit einem Stack zu verwenden, müssen Sie es in einem Repository ablegen. Sie können jedes der unterstützten Repositorys verwenden, aber um SimpleJSP mit dem Beispiel-Stack zu verwenden, der im folgenden Abschnitt besprochen wird, müssen Sie SimpleJSP in einem öffentlichen S3-Archiv speichern. Weitere Informationen zur Verwendung der anderen Standard-Repositorys finden Sie unter [Rezeptbuch-Repositorys](workingcookbook-installingcustom-repo.md).
**Speichern von SimpleJSP in einem S3-Archiv-Repository**
1. Kopieren Sie den Beispielcode in eine Datei mit dem Namen `simplejsp.jsp` und speichern Sie die Datei in einem Verzeichnis mit dem Namen `simplejsp`.
1. Erstellen Sie ein `.zip`-Archiv des Verzeichnisses `simplejsp`.
1. Erstellen Sie einen öffentlichen Amazon S3 S3-Bucket, laden `simplejsp.zip` Sie ihn in den Bucket hoch und machen Sie die Datei öffentlich.
Eine Beschreibung der Durchführung dieser Aufgabe finden Sie unter [Erste Schritte mit Amazon Simple Storage Service](https://docs.aws.amazon.com/AmazonS3/latest/gsg/GetStartedWithS3.html).
## Erstellen eines Stacks
Zum Ausführen von SimpleJSP benötigen Sie einen Stack mit den folgenden Layern.
+ Einen MySQL-Layer, der den Backend-MySQL-Server unterstützt
+ Einen benutzerdefinierten Layer, der das Tomcat-Rezeptbuch verwendet, um Tomcat-Server-Instances zu unterstützen
**So erstellen Sie den Stack**
1. Klicken Sie im OpsWorks Stacks-Dashboard auf **Stack hinzufügen, um einen neuen Stack** zu erstellen, und klicken Sie auf **Erweitert >>**, um alle Optionen anzuzeigen. Konfigurieren Sie den Stack wie folgt.
+ **Name** — Ein benutzerdefinierter Stackname; in diesem Beispiel wird. TomStack
+ **Benutzerdefinierte Chef-Kochbücher verwenden** — Stellen Sie den Schalter auf **Ja**, wodurch einige zusätzliche Optionen angezeigt werden.
+ **Repository-Typ** —Git.
+ **Repository-URL** —`git://github.com/amazonwebservices/opsworks-example-cookbooks.git`.
+ **Custom Chef JSON** — Fügen Sie den folgenden JSON hinzu:
```
{
"tomcat": {
"base_version": 7,
"java_opts": "-Djava.awt.headless=true -Xmx256m"
},
"datasources": {
"ROOT": "jdbc/mydb"
}
}
```
Für die restlichen Optionen können Sie die Standardwerte übernehmen.
Das benutzerdefinierte JSON-Objekt führt Folgendes durch:
+ Überschreibt das `['base_version']`-Attribut des Tomcat-Rezeptbuchs, um die Tomcat-Version auf 7 festzulegen. Der Standardwert ist 6.
+ Überschreibt das `['java_opts']`-Attribut des Tomcat-Rezeptbuchs, um festzulegen, dass die Instance keinen Monitor hat, und legt die maximale JVM-Heap-Größe auf 256 MB fest. Der Standardwert legt keine Optionen für Instances fest, die Amazon Linux ausführen.
+ Gibt den `['datasources]`-Attributwert an, der dem Webanwendungs-Kontextnamen ("ROOT") einen JDBC-Ressourcennamen ("jdbc/mydb") zuweist, wie unter [tomcat::context](create-custom-configure.md#create-custom-configure-context) erläutert.
Dieses letzte Attribut hat keinen Standardwert. Sie müssen es mit benutzerdefinierter JSON festlegen.
![\[Configuration Management interface showing Chef version options and custom JSON input field.\]](http://docs.aws.amazon.com/de_de/opsworks/latest/userguide/images/tom_add_stack.png)
1. Klicken Sie auf **Add a layer (Einen Layer hinzufügen)**. Wählen Sie für **Layer type (Ebenentyp)** die Option **MySQL** aus. Klicken Sie dann auf **Add Layer (Ebene hinzufügen)**.
1. Klicken Sie im Navigationsbereich auf **Instances** und dann auf **Add an instance (Eine Instance hinzufügen)**. Klicken Sie auf **Add Instance (Instance hinzufügen)**, um die Standardeinstellungen zu übernehmen. Klicken Sie in der Zeile für die Instance auf **start (starten)**.
1. Kehren Sie zur Seite **Layers (Ebenen)** zurück und klicken Sie auf **\$1 Layer (\$1Ebene)**, um einen Layer hinzuzufügen. Klicken Sie für **Layer type (Ebenentyp)** auf **Custom (Benutzerdefiniert)**. Das Beispiel verwendet **TomCustom** bzw. **tomcustom** als Namen bzw. Kurznamen des Layers.
![\[Add Layer form with Custom layer type, Name, and Short name fields for creating a customized layer.\]](http://docs.aws.amazon.com/de_de/opsworks/latest/userguide/images/tom_add_custom_layer.png)
1. Klicken Sie auf der Seite **Layers (Ebenen)** für den entsprechenden benutzerdefinierten Layer auf **Recipes (Rezepte)** und dann auf **Edit (Bearbeiten)**. Weisen Sie unter **Custom Chef Recipes (Benutzerdefinierte Chef-Rezepte)** den Lebenszyklusereignissen des Layers Tomcat-Rezeptbuchrezepte wie folgt zu:
+ Für **Setup (Einrichtung)** geben Sie tomcat::setup**tomcat::setup** ein und klicken Sie auf **\$1**.
+ Für **Configure (Konfigurieren)** geben Sie **tomcat::configure** ein und klicken Sie auf **\$1**.
+ Für **Deploy (Bereitstellen)** geben Sie **tomcat::deploy** ein und klicken Sie auf **\$1**. Klicken Sie dann auf **Save (Speichern)**.
.
![\[Custom Chef Recipes interface showing setup, configure, and deploy steps with options.\]](http://docs.aws.amazon.com/de_de/opsworks/latest/userguide/images/tom_events.png)
1. Klicken Sie im Navigationsbereich auf **Apps** und dann auf **Add an app (Eine App hinzufügen)**. Geben Sie die folgenden Optionen an und klicken Sie dann auf **Add App (App hinzufügen)**:
+ **Name** — Der Name der App; im Beispiel wird SimpleJSP verwendet und der von OpsWorks Stacks generierte Kurzname lautet simplejsp.
+ **App-Typ** **— Stellen Sie diese Option auf Andere ein.**
OpsWorks Stacks stellt automatisch Standard-App-Typen auf den zugehörigen Serverinstanzen bereit. Wenn Sie **App type (Typ hinzufügen)** auf "Other (Andere)" festlegen, führt OpsWorks Stacks einfach die Bereitstellungsrezepte aus und lässt diese die Bereitstellung verarbeiten.
+ **Dokumentenstamm** — Stellen Sie diese Option auf ein. **ROOT**
Der Wert **Document root (Dokumentenstamm)** gibt den Kontextnamen an.
+ **Repository-Typ** — Stellen Sie diese Option auf **S3** Archive ein.
+ **Repository-URL** — Stellen Sie hier die Amazon S3 S3-URL der App ein, die Sie zuvor erstellt haben.
Verwenden Sie für die anderen Optionen die Standardeinstellungen.
![\[Application settings form with fields for name, app type, document root, and source details.\]](http://docs.aws.amazon.com/de_de/opsworks/latest/userguide/images/tom_app.png)
1. Verwenden Sie die Seite „**Instances**“, um dem TomCustom Layer eine Instance hinzuzufügen und sie zu starten. OpsWorks Stacks führt die Deploy-Rezepte automatisch auf einer neuen Instance aus, nachdem die Setup-Rezepte abgeschlossen sind, sodass beim Starten der Instance auch SimpleJSP bereitgestellt wird.
1. Wenn die TomCustom Instanz online ist, klicken Sie auf der Instanzenseite auf den Instanznamen, um die zugehörigen Details zu **sehen**. Kopieren Sie die öffentliche IP-Adresse. Erstellen Sie dann eine URL wie folgt: http://*publicIP**appname.jsp*/tc/. Für das Beispiel sieht diese URL etwa folgendermaßen aus: **http://50.218.191.172/tc/simplejsp.jsp**.
**Anmerkung**
Die Apache-URL, die Anfragen an Tomcat weiterleitet, ist auf das `['tomcat']['apache_tomcat_bind_path']`-Standardattribut, `/tc/`, festgelegt. Das SimpleJSP-Dokumenten-Stammverzeichnis ist auf `ROOT` festgelegt, einen speziellen Wert, der aufgelöst wird in `/`. Die URL lautet daher "... /tc/simplejsp.jsp".
1. Fügen Sie die URL aus dem vorherigen Schritt in Ihren Browser ein. Sie sollten Folgendes sehen:
```
Databases found:
information_schema
simplejsp
test
```
**Anmerkung**
Wenn Ihr Stack über eine MySQL-Instanz verfügt, erstellt OpsWorks Stacks automatisch eine Datenbank für jede App, die mit dem Kurznamen der App benannt ist.