Die einfache Anwendung JSP Erstellen eines Stacks

Erstellen eines Stacks und Ausführen einer Anwendung

Wichtig

Das Tool AWS OpsWorks Stacks Der 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 AWS Support Team ein AWS Re:post oder durch AWS Premium-Support.

In diesem Abschnitt wird gezeigt, wie Sie mit dem Tomcat-Kochbuch ein grundlegendes Stack-Setup implementieren, das eine einfache Java-Server-Pages (JSP) -Anwendung namens Simple ausführt. JSP Der Stack besteht aus einer Tomcat-basierten benutzerdefinierten Ebene mit dem Namen TomCustom und einer Ebene „Meine“. SQL Simple JSP wird in der Datenbank Meine SQL Datenbank bereitgestellt TomCustom und zeigt einige Informationen aus dieser Datenbank an. Wenn Sie noch nicht mit den Grundlagen der Verwendung vertraut sind AWS OpsWorks Stacks solltest du zuerst lesenErste Schritte mit Chef 11 Linux-Stacks.

Die einfache Anwendung JSP

Die JSP Anwendung Simple demonstriert die Grundlagen, wie man eine Datenbankverbindung einrichtet und Daten aus der Datenbank Meine SQL Datenbank des Stacks abruft.



<html>
  <head>
    <title>DB Access</title>
  </head>
  <body>
    <%@ 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:<br>");
        stmt = con.createStatement();
        rs = stmt.executeQuery("show databases");
        while (rs.next()) {
          output.append(rs.getString(1));
          output.append("<br>");
        }
      }
      catch (Exception e) {
        output.append("Exception: ");
        output.append(e.getMessage());
        output.append("<br>");
      }
      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("<br>");
        }
      }
    %>
    <%= output.toString() %>
  </body>
</html>

Simple JSP verwendet ein DataSource Objekt, um mit der SQL My-Datenbank zu kommunizieren. Tomcat verwendet die Daten in der Webanwendungs-Kontextkonfigurationsdatei, um ein DataSource-Objekt zu erstellen und zu initialisieren und mit einem logischen Namen zu verknüpfen. Anschließend registriert es den logischen Namen bei einem Benennungsdienst für 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 Name des JSP Beispiels Simple,java:comp/env/jdbc/mydb, besteht aus den folgenden Komponenten:

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.

Um eine Verbindung zur Datenbank herzustellen, JSP geht Simple wie folgt vor:

Ruft die DataSource-Methode des getConnection-Objekts auf, die ein Connection-Objekt zurückgibt.
Ruft die Connection-Methode des createStatement-Objekts auf, um ein Statement-Objekt zu erstellen, das Sie zur Kommunikation mit der Datenbank verwenden.
Kommuniziert mit der Datenbank, indem die entsprechende Statement-Methode aufgerufen wird.

Einfache JSP Aufrufe executeQuery zur Ausführung einer SHOW DATABASES Abfrage, die die Datenbanken des Servers auflistet.

Die executeQuery-Methode gibt ein ResultSet-Objekt zurück, das die Abfrageergebnisse enthält. Simple JSP ruft die Datenbanknamen aus dem zurückgegebenen ResultSet Objekt 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 bzw. JDBC Basics.

Um Simple JSP mit einem Stack zu verwenden, müssen Sie ihn in einem Repository ablegen. Sie können jedes der unterstützten Repositorys verwenden, aber um Simple JSP mit dem im folgenden Abschnitt beschriebenen Beispielstapel zu verwenden, müssen Sie ihn in einem öffentlichen S3-Archiv ablegen. Weitere Informationen zur Verwendung der anderen Standard-Repositorys finden Sie unter Rezeptbuch-Repositorys.

Um Simple JSP in ein S3-Archiv-Repository zu legen

Kopieren Sie den Beispielcode in eine Datei mit dem Namen simplejsp.jsp und speichern Sie die Datei in einem Verzeichnis mit dem Namen simplejsp.
Erstellen Sie ein .zip-Archiv des Verzeichnisses simplejsp.
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.

Erstellen eines Stacks

Um Simple auszuführenJSP, benötigen Sie einen Stack mit den folgenden Ebenen.

Ein My SQL Layer, der das Backend My SQL Server unterstützt.
Einen benutzerdefinierten Layer, der das Tomcat-Rezeptbuch verwendet, um Tomcat-Server-Instances zu unterstützen

So erstellen Sie den Stack

Auf dem AWS OpsWorks Klicken Sie im Stacks-Dashboard auf Stapel 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.
- Repositorium URL —git://github.com/amazonwebservices/opsworks-example-cookbooks.git.
- Custom Chef JSON — Fügen Sie Folgendes 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.

Der Custom JSON macht Folgendes:
- Überschreibt das ['base_version']-Attribut des Tomcat-Rezeptbuchs, um die Tomcat-Version auf 7 festzulegen. Der Standardwert ist 6.
- Überschreibt das ['java_opts'] Tomcat-Cookbook-Attribut, um anzugeben, dass die Instance kopflos ist, und legt die JVM maximale Heap-Größe auf 256 MB fest. Der Standardwert legt keine Optionen für Instances fest, auf denen Amazon Linux ausgeführt wird.
- Gibt den ['datasources] Attributwert an, der dem Kontextnamen der Web-App () einen JDBC Ressourcennamen (jdbc/mydb) zuweist, wie unter beschrieben. ROOT tomcat::context
  
  Dieses letzte Attribut hat keinen Standardwert. Sie müssen es mit Benutzerdefiniert festlegen. JSON
Klicken Sie auf Add a layer (Einen Layer hinzufügen). Wählen Sie für Layer-Typ die Option My ausSQL. Klicken Sie dann auf Add Layer (Ebene hinzufügen).
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).
Kehren Sie zur Seite Layers (Ebenen) zurück und klicken Sie auf + Layer (+Ebene), 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.
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::setuptomcat::setup ein und klicken Sie auf +.
- Für Configure (Konfigurieren) geben Sie tomcat::configure ein und klicken Sie auf +.
- Für Deploy (Bereitstellen) geben Sie tomcat::deploy ein und klicken Sie auf +. Klicken Sie dann auf Save (Speichern).
  
  .
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. Das Beispiel verwendet Simple JSP und den Kurznamen, generiert von AWS OpsWorks Stacks werden simplejsp sein.
- App-Typ — Stellen Sie diese Option auf Andere ein.
  
  AWS OpsWorks Stacks stellt automatisch Standard-App-Typen auf den zugehörigen Serverinstanzen bereit. Wenn Sie den App-Typ auf „Andere“ setzen, AWS OpsWorks Stacks führt einfach die Deploy-Rezepte aus und überlässt ihnen die Bereitstellung.
- 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 das Amazon S3 der App einURL, das Sie zuvor erstellt haben.
Verwenden Sie für die anderen Optionen die Standardeinstellungen.
Verwenden Sie die Seite Instances, um dem TomCustom Layer eine Instance hinzuzufügen und sie zu starten. AWS OpsWorks Stacks führt die Deploy-Rezepte nach Abschluss der Setup-Rezepte automatisch auf einer neuen Instance aus, sodass beim Starten der Instance auch Simple bereitgestellt wird. JSP
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. Konstruieren Sie dann eine URL wie folgt: http://publicIP/tc/appname.jsp. Für das Beispiel URL wird das ungefähr so aussehenhttp://50.218.191.172/tc/simplejsp.jsp.

Anmerkung
Der ApacheURL, der Anfragen an Tomcat weiterleitet, ist auf das ['tomcat']['apache_tomcat_bind_path'] Standardattribut gesetzt. /tc/ Der einfache JSP Dokumentenstamm ist auf einen speziellen Wert gesetztROOT, der in aufgelöst wird. / Das URL ist also „... /tc/simplejsp.jsp“.
Fügen Sie das URL aus dem vorherigen Schritt in Ihren Browser ein. Sie sollten Folgendes sehen:
```
Databases found:
information_schema
simplejsp
test
```
Anmerkung
Wenn Ihr Stack eine Meine SQL Instanz hat, AWS OpsWorks Stacks erstellt automatisch eine Datenbank für jede App, die mit dem Kurznamen der App benannt ist.