Creare uno stack ed eseguire un'applicazione - AWS OpsWorks

Creare uno stack ed eseguire un'applicazione

Importante

Il AWS OpsWorks Stacks servizio ha raggiunto la fine del ciclo di vita il 26 maggio 2024 ed è stato disattivato sia per i clienti nuovi che per quelli esistenti. Consigliamo vivamente ai clienti di migrare i propri carichi di lavoro verso altre soluzioni il prima possibile. Se hai domande sulla migrazione, contatta il Supporto AWS Team su AWS re:post o tramite Premium AWS Support.

In questa sezione viene illustrato come utilizzare il libro di ricette Tomcat per implementare una configurazione di base dello stack che esegue una semplice applicazione Java Server Pages (JSP) denominata SimpleJSP. Lo stack è costituito da un livello personalizzato basato su Tomcat denominato e da TomCustom un livello MySQL. SimpleJSP viene distribuito TomCustom e visualizza alcune informazioni dal database MySQL. Se non hai già familiarità con le nozioni di base su come usare AWS OpsWorks Stacks, dovresti prima leggere. Nozioni di base sugli stack Linux Chef 11

Applicazione SimpleJSP

L'applicazione SimpleJSP illustra le basi della configurazione di una connessione di database e del recupero di dati dal database MySQL dello stack.



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

SimpleJSP utilizza un oggetto DataSource per comunicare con il database MySQL. Tomcat usa i dati nel file di configurazione del contesto dell'app Web per creare e inizializzare un oggetto DataSource e associarlo a un nome logico. Quindi, registra il nome logico con un servizio di denominazione JNDI (Java Naming and Directory Interface). Per ottenere un'istanza dell'oggetto DataSource appropriato, devi creare un oggetto InitialContext e passare il nome logico della risorsa al metodo lookup dell'oggetto, che recupera l'oggetto appropriato. Il nome logico dell'esempio SimpleJSP, java:comp/env/jdbc/mydb, ha i seguenti componenti:

Lo spazio dei nomi radice, java, che è separato dal resto del nome da due punti (:).
Eventuali spazi dei nomi aggiuntivi, separati da barre (/).

Tomcat aggiunge automaticamente le risorse allo spazio dei nomi comp/env.
Il nome della risorsa, definito nel file di configurazione del contesto dell'app Web e separato dagli spazi dei nomi per mezzo di una barra.

In questo esempio il nome della risorsa è jdbc/mydb.

Per stabilire una connessione al database, SimpleJSP esegue le seguenti operazioni:

Chiama il metodo DataSource dell'oggetto getConnection, che restituisce un oggetto Connection.
Chiama il metodo Connection dell'oggetto createStatement per creare un oggetto Statement, che puoi utilizzare per comunicare con il database.
Comunica con il database chiamando il metodo Statement appropriato.

SimpleJSP chiama executeQuery per eseguire una query SHOW DATABASES, che elenca i database del server.

Il metodo executeQuery restituisce un oggetto ResultSet, che contiene i risultati delle query. SimpleJSP ottiene i nomi dei database dall'oggetto ResultSet restituito e li concatena per creare una stringa di output. Infine, l'esempio chiude gli oggetti ResultSet, Statement e Connection. Per ulteriori informazioni su JSP e JDBC, vedere rispettivamente JavaServer Pages Technology e JDBC Basics.

Per usare SimpleJSP con uno stack, devi inserirlo in un repository. Puoi utilizzare uno qualsiasi dei repository supportati, ma per utilizzare SimpleJSP con lo stack di esempio illustrato nella sezione seguente, devi inserirlo in un archivio S3 pubblico. Per informazioni su come utilizzare gli altri repository standard, consulta Repository dei libri di ricette.

Per inserire SimpleJSP in un repository di archiviazione S3

Copiare il codice di esempio in un file denominato simplejsp.jsp e inserire il file in una directory denominata simplejsp.
Creare un archivio .zip della directory simplejsp.
Crea un bucket Amazon S3 pubblico, caricalo simplejsp.zip nel bucket e rendi pubblico il file.

Per sapere come eseguire questa attività, consulta Nozioni di base su Amazon Simple Storage Service.

Creare uno stack

Per eseguire SimpleJSP hai bisogno di uno stack con i seguenti livelli.

Un livello MySQL, che supporta il server MySQL di back-end.
Un livello personalizzato che utilizza il libro di ricette Tomcat per supportare istanze server Tomcat.

Per creare lo stack

Nella dashboard AWS OpsWorks Stacks, fai clic su Aggiungi stack per creare un nuovo stack e fai clic su Avanzato >> per visualizzare tutte le opzioni. Configurare lo stack come segue.
- Nome: un nome di stack definito dall'utente; in questo esempio viene utilizzato. TomStack
- Usa libri di cucina personalizzati per Chef: imposta l'interruttore su Sì, che mostra alcune opzioni aggiuntive.
- Tipo di repository —Git.
- URL del repository:. git://github.com/amazonwebservices/opsworks-example-cookbooks.git
- Custom Chef JSON: aggiungi il seguente JSON:
```
{
  "tomcat": {
    "base_version": 7,
    "java_opts": "-Djava.awt.headless=true -Xmx256m"
  },
  "datasources": {
    "ROOT": "jdbc/mydb"
  }
}
```
Per le opzioni rimanenti, puoi accettare le impostazioni predefinite.

Il JSON personalizzato esegue le operazioni seguenti:
- Ignora l'attributo ['base_version'] del libro di ricette Tomcat per impostare la versione di Tomcat su 7. Il valore predefinito è 6.
- Ignora l'attributo ['java_opts'] del libro di ricette Tomcat per specificare che l'istanza è headless e impostare la dimensione heap massima di JVM su 256 MB. Il valore predefinito non prevede l'impostazione di opzioni per le istanze che eseguono Amazon Linux.
- Specifica il valore dell'attributo ['datasources], che assegna un nome di risorsa JDBC (jdbc/mydb) al nome del contesto dell'app Web (ROOT), come descritto in tomcat::context.
  
  Quest'ultimo attributo non dispone di un valore predefinito, pertanto devi impostarlo con un JSON personalizzato.
Fare clic su Add a layer (Aggiungi un livello). Per Layer type (Tipo di livello), selezionare MySQL. Quindi, fare clic su Add Layer (Aggiungi livello).
Fare clic su Instances (Istanze) nel riquadro di navigazione, quindi fare clic su Add an instance (Aggiungi un'istanza). Fare clic su Add Instance (Aggiungi istanza) per accettare le impostazioni predefinite. Sulla riga dell'istanza, fare clic su start (avvia).
Tornare alla pagina Layers (Livelli) e fare clic su + Layer (+ Livello) per aggiungere un livello. Per Layer type (Tipo di livello), fare clic su Custom (Personalizzato). L'esempio utilizza TomCustom e tomcustom, rispettivamente, come nome e nome abbreviato del livello.
Nella pagina Layers (Livelli), per il livello personalizzato, fare clic su Recipes (Ricette), quindi fare clic su Edit (Modifica). In Custom Chef Recipes (Ricette Chef personalizzate), assegnare le ricette del libro di ricette Tomcat agli eventi del ciclo di vita del livello, nel modo seguente:
- Per Setup (Installazione), digitare tomcat::setup e fare clic su +.
- Per Configure (Configurazione), digitare tomcat::configure e fare clic su +.
- Per Deploy (Distribuzione), digitare tomcat::deploy e fare clic su +. Quindi, fare clic su Save (Salva).
  
  .
Fare clic su Apps (App) nel riquadro di navigazione, quindi fare clic su Add an app (Aggiungi un'app). Specificare le seguenti opzioni e fare clic su Add App (Aggiungi app):
- Nome: il nome dell'app; l'esempio utilizza SimpleJSP e il nome breve generato da Stacks sarà simplejsp. AWS OpsWorks
- Tipo di app: imposta questa opzione su Altro.
  
  AWS OpsWorks Stacks distribuisce automaticamente i tipi di app standard nelle istanze del server associate. Se si imposta App type (Tipo di app) su un'opzione diversa, AWS OpsWorks Stacks esegue semplicemente le ricette di distribuzione e consente loro di gestire la distribuzione.
- Document root: imposta questa opzione su. ROOT
  
  Il valore Document root (Radice documento) specifica il nome del contesto.
- Tipo di repository: imposta questa opzione su S3 Archive.
- URL del repository: imposta questo valore sull'URL Amazon S3 dell'app che hai creato in precedenza.
Utilizzare le impostazioni predefinite per le altre opzioni.
Utilizza la pagina Istanze per aggiungere un'istanza al TomCustom layer e avviarla. AWS OpsWorks Stacks esegue automaticamente le ricette Deploy su una nuova istanza al termine delle ricette di installazione, quindi l'avvio dell'istanza distribuisce anche SimpleJSP.
Quando l' TomCustom istanza è online, fai clic sul nome dell'istanza nella pagina Istanze per visualizzarne i dettagli. Copiare l'indirizzo IP pubblico. Quindi costruisci un URL come segue: http://publicIP/tc/. appname.jsp Ad esempio, l'URL sarà simile al seguente: http://50.218.191.172/tc/simplejsp.jsp.

Nota
L'URL Apache che inoltra le richieste a Tomcat è impostato sull'attributo ['tomcat']['apache_tomcat_bind_path'] predefinito, /tc/. La radice del documento SimpleJSP è impostata su ROOT, un valore speciale che si risolve su /. L'URL è quindi ".../tc/simplejsp.jsp".
Incollare nel browser l'URL copiato al passaggio precedente. Verrà visualizzato un codice analogo al seguente:
```
Databases found:
information_schema
simplejsp
test
```
Nota
Se il tuo stack ha un'istanza MySQL AWS OpsWorks , Stacks crea automaticamente un database per ogni app, denominato con il nome breve dell'app.