Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
# 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](https://repost.aws/) o tramite Premium [AWS Support](https://aws.amazon.com/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 OpsWorks Stacks, dovresti prima leggere. [Nozioni di base sugli stack Linux Chef 11](gettingstarted.md)
## 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.
```
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 utilizza un oggetto `DataSource` per comunicare con il database MySQL. Tomcat usa i dati nel [file di configurazione del contesto dell'app Web](create-custom-configure.md#create-custom-configure-context) 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:
1. Chiama il metodo `DataSource` dell'oggetto `getConnection`, che restituisce un oggetto `Connection`.
1. Chiama il metodo `Connection` dell'oggetto `createStatement` per creare un oggetto `Statement`, che puoi utilizzare per comunicare con il database.
1. 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](http://docs.oracle.com/javaee/5/tutorial/doc/bnagx.html) e JDBC Basics.](http://docs.oracle.com/javase/tutorial/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](workingcookbook-installingcustom-repo.md).
**Per inserire SimpleJSP in un repository di archiviazione S3**
1. Copiare il codice di esempio in un file denominato `simplejsp.jsp` e inserire il file in una directory denominata `simplejsp`.
1. Creare un archivio `.zip` della directory `simplejsp`.
1. 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](https://docs.aws.amazon.com/AmazonS3/latest/gsg/GetStartedWithS3.html).
## 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**
1. Nella dashboard 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](create-custom-configure.md#create-custom-configure-context).
Quest'ultimo attributo non dispone di un valore predefinito, pertanto devi impostarlo con un JSON personalizzato.
![\[Configuration Management interface showing Chef version options and custom JSON input field.\]](http://docs.aws.amazon.com/it_it/opsworks/latest/userguide/images/tom_add_stack.png)
1. 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)**.
1. 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)**.
1. Tornare alla pagina **Layers (Livelli)** e fare clic su **\$1 Layer (\$1 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.
![\[Add Layer form with Custom layer type, Name, and Short name fields for creating a customized layer.\]](http://docs.aws.amazon.com/it_it/opsworks/latest/userguide/images/tom_add_custom_layer.png)
1. 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 **\$1**.
+ Per **Configure (Configurazione)**, digitare **tomcat::configure** e fare clic su **\$1**.
+ Per **Deploy (Distribuzione)**, digitare **tomcat::deploy** e fare clic su **\$1**. Quindi, fare clic su **Save (Salva)**.
.
![\[Custom Chef Recipes interface showing setup, configure, and deploy steps with options.\]](http://docs.aws.amazon.com/it_it/opsworks/latest/userguide/images/tom_events.png)
1. 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. OpsWorks
+ **Tipo di app****: imposta questa opzione su Altro.**
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, 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.
![\[Application settings form with fields for name, app type, document root, and source details.\]](http://docs.aws.amazon.com/it_it/opsworks/latest/userguide/images/tom_app.png)
1. Utilizza la pagina **Istanze** per aggiungere un'istanza al TomCustom layer e avviarla. 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.
1. 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".
1. 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 OpsWorks , Stacks crea automaticamente un database per ogni app, denominato con il nome breve dell'app.