Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.
# Créer une pile et exécuter une application
**Important**
Le AWS OpsWorks Stacks service a atteint sa fin de vie le 26 mai 2024 et a été désactivé tant pour les nouveaux clients que pour les clients existants. Nous recommandons vivement aux clients de migrer leurs charges de travail vers d'autres solutions dès que possible. Si vous avez des questions sur la migration, contactez l' AWS Support équipe sur [AWS Re:Post](https://repost.aws/) ou via le [AWS Support](https://aws.amazon.com/support) Premium.
Cette section montre comment utiliser le livre de recettes Tomcat pour mettre en place une configuration de pile élémentaire qui exécute une simple application de pages serveur Java (JSP), nommée SimpleJSP. La pile se compose d'une couche personnalisée basée sur Tomcat nommée TomCustom et d'une couche MySQL. SimpleJSP est déployé sur la base de données MySQL TomCustom et affiche certaines informations à partir de celle-ci. Si vous n'êtes pas déjà familiarisé avec les bases de l'utilisation de OpsWorks Stacks, vous devez d'abord lire[Mise en route des piles Linux Chef 11](gettingstarted.md).
## Application SimpleJSP
L'application SimpleJSP illustre les bases de la configuration d'une connexion de base de données et de l'extraction des données à partir de la base de données MySQL de la pile.
```
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 utilise un objet `DataSource` pour communiquer avec la base de données MySQL. Tomcat utilise les données du [fichier de configuration du contexte de l'application web](create-custom-configure.md#create-custom-configure-context) pour créer et initialiser un objet `DataSource` et le lier à un nom logique. Elle enregistre ensuite le nom logique avec un service d'attribution de noms JNDI (Java Naming et Directory Interface). Pour obtenir une instance de l'objet `DataSource` approprié, vous créez un objet `InitialContext` et passez le nom logique de la ressource à la méthode `lookup` de l'objet, qui récupère l'objet approprié. Le nom logique de l'exemple SimpleJSP, `java:comp/env/jdbc/mydb`, possède les éléments suivants :
+ L'espace de noms racine, `java`, qui est séparé du reste du nom par le signe deux points (:).
+ Les espaces de noms supplémentaires, séparés par des barres obliques (/).
Tomcat ajoute automatiquement les ressources à l'espace de noms `comp/env`.
+ Le nom de ressource, défini dans le fichier de configuration du contexte de l'application web et séparé des espaces de noms par une barre oblique.
Le nom de la ressource pour cet exemple est `jdbc/mydb`.
Pour établir une connexion à la base de données, SimpleJSP effectue les opérations suivantes :
1. Appelle la méthode `DataSource` de l'objet `getConnection`, qui retourne un objet `Connection`.
1. Appelle la méthode `Connection` de l'objet `createStatement` pour créer un objet `Statement`, qui vous permet de communiquer avec la base de données.
1. Communique avec la base de données en appelant la méthode `Statement` appropriée.
SimpleJSP appelle `executeQuery` pour exécuter une requête SHOW DATABASES, qui répertorie les bases de données du serveur.
La méthode `executeQuery` retourne un objet `ResultSet`, qui contient les résultats de la requête. SimpleJSP obtient les noms de base de données à partir de l'objet `ResultSet` retourné et les concatène pour créer une chaîne de sortie. Enfin, l'exemple ferme les objets `ResultSet`, `Statement` et `Connection`. Pour plus d'informations sur JSP et JDBC, consultez [JavaServer Pages Technology](http://docs.oracle.com/javaee/5/tutorial/doc/bnagx.html) et [JDBC](http://docs.oracle.com/javase/tutorial/jdbc/basics/) Basics, respectivement.
Pour utiliser SimpleJSP avec une pile, vous devez la placer dans un référentiel. Vous pouvez utiliser l'un des référentiels pris en charge, mais pour utiliser SimpleJSP avec l'exemple de pile présenté dans la section suivante, vous devez la placer dans une archive S3 publique. Pour plus d'informations sur l'utilisation des autres référentiels standard, consultez [Référentiels de livres de recettes](workingcookbook-installingcustom-repo.md).
**Pour placer SimpleJSP dans un référentiel d'archivage S3**
1. Copiez l'exemple de code dans un fichier nommé `simplejsp.jsp` et placez le fichier dans un répertoire nommé `simplejsp`.
1. Créez une archive `.zip` du répertoire `simplejsp`.
1. Créez un compartiment Amazon S3 public, `simplejsp.zip` chargez-le dans le compartiment et rendez le fichier public.
Pour obtenir une description de l'exécution de cette tâche, consultez [Mise en route avec Amazon Simple Storage Service](https://docs.aws.amazon.com/AmazonS3/latest/gsg/GetStartedWithS3.html).
## Créez une pile
Pour exécuter SimpleJSP, vous avez besoin d'une pile avec les couches suivantes.
+ Une couche MySQL, qui prend en charge le serveur principal MySQL.
+ Une couche personnalisée qui utilise le livre de recettes Tomcat pour prendre en charge les instances serveur Tomcat.
**Pour créer la pile**
1. Sur le tableau de bord OpsWorks Stacks, cliquez sur **Ajouter une pile** pour créer une nouvelle pile, puis sur **Avancé >>** pour afficher toutes les options. Configurez la pile comme suit.
+ **Nom** : nom de pile défini par l'utilisateur ; cet exemple utilise TomStack.
+ **Utiliser des livres de recettes Chef personnalisés** : réglez le bouton sur **Oui** pour afficher des options supplémentaires.
+ **Type de dépôt** —Git.
+ **URL du référentiel** —`git://github.com/amazonwebservices/opsworks-example-cookbooks.git`.
+ **Custom Chef JSON** —Ajoutez le JSON suivant :
```
{
"tomcat": {
"base_version": 7,
"java_opts": "-Djava.awt.headless=true -Xmx256m"
},
"datasources": {
"ROOT": "jdbc/mydb"
}
}
```
Pour le reste des options, vous pouvez accepter les valeurs par défaut.
Le JSON personnalisé exécute les tâches suivantes :
+ Remplace l'attribut `['base_version']` du livre de recettes Tomcat pour définir la version Tomcat sur 7 ; la valeur par défaut est 6.
+ Remplace l'attribut `['java_opts']` du livre de recettes Tomcat pour spécifier que l'instance est sans périphérique de contrôle et définir la taille maximale de segment de machine virtuelle Java sur 256 Mo ; la valeur par défaut ne définit aucune option pour les instances exécutant Amazon Linux.
+ Spécifie la valeur d'attribut `['datasources]`, qui attribue un nom de ressource JDBC (jdbc/mydb) au nom du contexte de l'application web (ROOT), comme indiqué dans [tomcat::context](create-custom-configure.md#create-custom-configure-context).
Ce dernier attribut n'a aucune valeur par défaut ; vous devez la définir avec le JSON personnalisé.
![\[Configuration Management interface showing Chef version options and custom JSON input field.\]](http://docs.aws.amazon.com/fr_fr/opsworks/latest/userguide/images/tom_add_stack.png)
1. Cliquez sur **Add a layer (Ajouter une couche)**. Pour **Layer type (Type de couche)**, sélectionnez **MySQL**. Puis, cliquez sur **Add Layer (Ajouter une couche)**.
1. Dans le panneau de navigation, cliquez sur **Instances**, puis cliquez sur **Add an instance (Ajouter une instance)**. Cliquez sur **Add Instance (Ajouter une instance)** pour accepter les valeurs par défaut. Sur la ligne de l'instance, cliquez sur **start (démarrer)**.
1. Revenez à la page **Layers (Couches)** et cliquez sur **\$1 Layer (\$1 Couche)** pour ajouter une couche. Pour **Layer type (Type de couche)**, cliquez sur **Custom (Personnalisé)**. L'exemple utilise **TomCustom** et **tomcustom** comme nom de couche et nom court, respectivement.
![\[Add Layer form with Custom layer type, Name, and Short name fields for creating a customized layer.\]](http://docs.aws.amazon.com/fr_fr/opsworks/latest/userguide/images/tom_add_custom_layer.png)
1. Sur la page **Layers (Couches)**, pour la couche personnalisée, cliquez sur **Recipes (Recettes)**, puis cliquez sur **Edit (Modifier)**. Sous **Custom Chef Recipes (Recettes Chef personnalisées)**, affectez les recettes du livre de recettes Tomcat aux événements de cycle de vie de la couche, comme suit :
+ Pour **Setup**, tapez **tomcat::setup** et cliquez sur **\$1**.
+ Pour **Configure**, tapez **tomcat::configure** et cliquez sur **\$1**.
+ Pour **Deploy**, tapez **tomcat::deploy** et cliquez sur **\$1**. Puis, cliquez sur **Save (Enregistrer)**.
.
![\[Custom Chef Recipes interface showing setup, configure, and deploy steps with options.\]](http://docs.aws.amazon.com/fr_fr/opsworks/latest/userguide/images/tom_events.png)
1. Dans le panneau de navigation, cliquez sur **Apps (Applications)**, puis cliquez sur **Add an app (Ajouter une application)**. Spécifiez les options suivantes, puis cliquez sur **Add App (Ajouter une application)** :
+ **Nom** : nom de l'application ; l'exemple utilise SimpleJSP et le nom abrégé généré par OpsWorks Stacks sera simplejsp.
+ **Type d'application** : définissez cette option sur **Autre**.
OpsWorks Stacks déploie automatiquement les types d'applications standard sur les instances de serveur associées. Si vous définissez **App type (Type d'application)** avec la valeur Other, OpsWorks Stacks exécute simplement les recettes Deploy et leur laisse gérer le déploiement.
+ **Racine du document** —Définissez cette option sur. **ROOT**
La valeur **Document root (Racine du document)** spécifie le nom du contexte.
+ **Type de référentiel** : définissez cette option sur **S3 Archive**.
+ **URL du référentiel** : définissez cette URL sur l'URL Amazon S3 de l'application que vous avez créée précédemment.
Utilisez les paramètres par défaut pour les autres options.
![\[Application settings form with fields for name, app type, document root, and source details.\]](http://docs.aws.amazon.com/fr_fr/opsworks/latest/userguide/images/tom_app.png)
1. Utilisez la page **Instances** pour ajouter une instance à la TomCustom couche et la démarrer. OpsWorks Stacks exécute automatiquement les recettes de déploiement sur une nouvelle instance une fois les recettes d'installation terminées. Le démarrage de l'instance déploie donc également SimpleJSP.
1. Lorsque l' TomCustom instance est en ligne, cliquez sur le nom de l'instance sur la page **Instances** pour voir ses détails. Copiez l'adresse IP publique. Créez ensuite une URL comme suit : http ://*publicIP**appname.jsp*/tc/. Pour l'exemple, cette URL doit se présenter ainsi : **http://50.218.191.172/tc/simplejsp.jsp**.
**Note**
L'URL Apache qui achemine les requêtes vers Tomcat est définie avec l'attribut `['tomcat']['apache_tomcat_bind_path']` par défaut, `/tc/`. La racine du document SimpleJSP est définie sur `ROOT`, une valeur spéciale qui se résout en `/`. Par conséquent, l'URL est « .../tc/simplejsp.jsp ».
1. Collez l'URL de l'étape précédente dans votre navigateur. Vous devez voir ce qui suit :
```
Databases found:
information_schema
simplejsp
test
```
**Note**
Si votre stack possède une instance MySQL, OpsWorks Stacks crée automatiquement une base de données pour chaque application, nommée avec le nom abrégé de l'application.