Migrer une application basée sur Backbone.js, Node.js et MongoDB depuis Amazon Web Services

Section précédente : Provisionnez les ressources cloud lors de la migration depuis Amazon Web Services

Ce scénario vous montre comment migrer une application Backbone.js, Node.js et MongoDB® d'Amazon Web Services (AWS) vers le Rackspace Cloud. Cela prend environ 30 minutes.

Le schéma suivant montre la topologie de l'application :

Prérequis

Ce scénario a les prérequis suivants :

Une pile d'applications sur AWS avec un accès root ou des privilèges appropriés pour les instances et les services individuels.
Un compte valide et activé sur Rackspace Cloud.

Préparation

Effectuez les étapes suivantes avant de commencer le scénario :

Identifiez les ressources que vous souhaitez migrer, y compris les ressources d'application et de base de données.
Créez une liste de tous les packages logiciels nécessaires installés sur vos instances Amazon Elastic Compute Cloud (EC2) autres que Backbone.js, Node.js et MongoDB.
Créez une liste de tous les services Amazon supplémentaires utilisés par votre application, tels que Simple Email Service (SES) pour les e-mails ou Relational DatabaseService (RDS) pour les bases de données.
Si vous ne l'avez pas déjà fait, créez une instance de serveur cloud et tous les services Rackspace Cloud compatibles.

Installer des packages logiciels

Cette section fournit des instructions pour installer les packages logiciels requis et facultatifs.

Installer Git et cURL

Vous devez utiliser Git et cURL pour obtenir des composants dépendants tels que Node.js.

Exécutez la commande suivante pour installer git et cURL :

sudo apt-get -y install git curl

Installer Python (facultatif)

Le support à long terme (LTS) d'Ubuntu® version 12.0.4 inclut Python® version 2.7.2. Si vous avez besoin d'une version différente, vous pouvez l'installer à partir de la page de téléchargement de Python.

Installer OpenJDK

Utilisez les étapes suivantes pour installer OpenJDK™ :

À l'aide de Secure Shell (SSH), connectez-vous à l'instance Cloud Servers en utilisant l'URL PublicNet et le mot de passe root.
Installez OpenJDK 7 en saisissant la commande suivante :
```
 sudo apt-get -y install openjdk-7-jre
```
Déterminer l'emplacement de JAVA_HOME en saisissant la commande suivante :
```
 ll /etc/alternatives/java
```
Dans l'exemple de sortie suivant, JAVA_HOME est situé à /usr/lib/jvm/jre-1.7.0-openjdk-amd64 :
```
 /etc/alternatives/java -> /usr/lib/jvm/java-7-openjdk-amd64/jre/bin/java*
```

Installer Tomcat 7 sur le serveur cloud

Utilisez les étapes suivantes pour installer Apache® Tomcat® :

Saisissez la commande suivante pour installer Tomcat 7 :
```
 sudo apt-get -y install tomcat7
```
Si vous souhaitez installer une version différente de Tomcat ou installer Tomcat manuellement, sélectionnez la version sur la page de téléchargement de logiciels Tomcat 7.
Copiez l'URL du tar.gz fichier (par exemple,https://www.us.apache.org/dist/tomcat/tomcat-7/v7.0.39/bin/apache-tomcat-7.0.39.tar.gz ).
Changez de répertoire en /usr/share (ou le répertoire que vous souhaitez utiliser) et téléchargez le fichier binaire en saisissant les commandes suivantes :
```
 cd /usr/share
 sudo wget https://www.us.apache.org/dist/tomcat/tomcat-7/v7.0.39/bin/apache-tomcat-7.0.39.tar.gz
```
Modifiez les autorisations en saisissant la commande suivante :
```
 sudo chmod 775 apache-tomcat-7.0.39.tar.gz
```
Extrayez le contenu du fichier en saisissant la commande suivante :
```
 sudo tar zxvf apache-tomcat-7.0.39.tar.gz
```
Une fois Tomcat extrait, supprimez le tar.gz fichiers pour économiser de l'espace en saisissant la commande suivante :
```
 sudo rm apache-tomcat-7.0.39.tar.gz
```
Définissez les variables d'environnement dans le catalina.sh fichier en saisissant les commandes suivantes :
```
 cd /usr/share/apache-tomcat-7.0.39/bin
 sudo vi catalina.sh
```
Ajoutez la ligne suivante immédiatement après \#!/bin/sh :
```
 JAVA_HOME=/usr/lib/jvm/jre-1.7.0-openjdk.x86_64
```
Enregistrez vos modifications et quittez le fichier.
Automatisez le démarrage de Tomcat à l'aide des commandes suivantes :
```
cd /etc/init.d
sudo vi tomcat
```

Ajoutez les informations suivantes au fichier. Assurez-vous que JAVA_HOME ,TOMCAT_HOME , START_TOMCAT , et STOP_TOMCAT reportez-vous aux bons répertoires.

#!/bin/bash
# chkconfig: 234 20 80
# description: Tomcat Server basic start/shutdown script
# processname: tomcat
JAVA_HOME=/usr/lib/jvm/jre-1.7.0-openjdk.x86_64
export JAVA_HOME
TOMCAT_HOME=/usr/share/apache-tomcat-7.0.39/bin
START_TOMCAT=/usr/share/apache-tomcat-7.0.39/bin/startup.sh
STOP_TOMCAT=/usr/share/apache-tomcat-7.0.39/bin/shutdown.sh
start() {
echo -n "Starting tomcat: "
cd $TOMCAT_HOME
${START_TOMCAT}
echo "done."
}
stop() {
echo -n "Shutting down tomcat: "

cd $TOMCAT_HOME
${STOP_TOMCAT}
echo "done."
}
case "$1" in
start)
start
;;
stop)
stop
;;
restart)
stop
sleep 10
start
;;
*)
echo "Usage: $0 {start|stop|restart}"
esac
exit 0

Enregistrez vos modifications et quittez le fichier.
Définissez les autorisations de fichiers, configurez Tomcat en tant que service système et testez la configuration en saisissant les commandes suivantes :
```
sudo chmod 755 tomcat
sudo /sbin/chkconfig --add tomcat
sudo /sbin/chkconfig --level 234 tomcat on
sudo /sbin/chkconfig --list tomcat
```
Le résultat doit ressembler à l'exemple suivant :
```
tomcat 0:off 1:off 2:on 3:on 4:on 5:off 6:off
```
Étant donné que Tomcat s'exécute sur le port 8080, assurez-vous qu'iptables n'interfère pas avec la connectivité.

Pour en savoir plus sur iptables, consultez Introduction à iptables.
Testez Tomcat en recherchant l'adresse IP (Internet Protocol) du serveur cloud à partir du panneau de configuration Rackspace Cloud et en ouvrant l'URL dans un navigateur (par exemple, https://:8080/ ).

La page d'accueil d'Apache Tomcat s'affiche.

Remarque :Vous pouvez démarrer et arrêter Tomcat à l'aide des commandes suivantes :
```
sudo /sbin/service tomcat stop
sudo /sbin/service tomcat start
```

Installer MongoDB sur votre serveur cloud

Vous pouvez trouver des instructions pour installer MongoDB sur le Rackspace Cloud sur le site Web de documentation de MongoDB.

Pour un déploiement en production, vous devez utiliser un jeu de répliques avec au moins trois nœuds.

Pour une installation à nœud unique, procédez comme suit :

Ajoutez la clé GNU Privacy Guard (GPG) à apt-get pour créer un fiable source en saisissant la commande suivante :
```
 sudo apt-key adv --keyserver keyserver.ubuntu.com --recv 7F0CEB10
```
Utilisez les commandes suivantes pour créer un 10gen personnalisé fichier de référentiel contenant l'emplacement des fichiers binaires MongoDB :
```
 sudo sh -c 'echo "deb https://downloads-distro.mongodb.org/repo/ubuntu-upstart dist 10gen" | tee -a /etc/apt/sources.list.d/10gen.list'
```
Mettre à jour apt-get pour récupérer de nouveaux colis en saisissant la commande suivante :
```
 sudo apt-get -y update
```
Installez MongoDB en saisissant la commande suivante :
```
 sudo apt-get -y install mongodb-10gen
```
Vérifiez que MongoDB est en cours d'exécution en saisissant la commande suivante :
```
 ps aux | grep mongo
```

Remarque :MongoDB utilise /var/lib/mongodb comme chemin de données par défaut. Si vous souhaitez modifier ce chemin, vous pouvez arrêter l'instance MongoDB et mettre à jour le fichier de configuration dans /etc/mongodb.conf .

Configurer un serveur Node.js

Si vos services sont soutenus par Node.js au lieu de Python, utilisez les étapes suivantes pour configurer un serveur Node.js sur votre instance cloud :

Installez Node.js en saisissant la commande suivante :
```
 sudo apt-get -y install nodejs npm
```
Testez l'installation en utilisant la commande suivante pour obtenir la version de Node.js que vous exécutez :
```
 node --version
```

Installer OpenStack Swift (facultatif)

Si vous prévoyez d'utiliser Cloud Files pour transférer vos données, procédez comme suit pour installer le client OpenStack® Swift afin d'activer l'accès depuis votre serveur :

Installez le client Swift en saisissant la commande suivante :
```
 sudo apt-get install python-novaclient glance-client swift
```
Définissez les variables d'environnement nécessaires en exécutant les commandes suivantes, en remplaçant votre nom d'utilisateur et votre clé d'interface de programmation d'application (API) :
```
 export ST_USER=<yourLoginUsername>
 export ST_KEY=<yourApiKey>
 export ST_AUTH=https://identity.api.rackspacecloud.com/v1.0/
```
Vous voudrez peut-être définir ces variables dans le .bashrc ou.bash\_profile fichier, puis rechargez le fichier avec le source suivant commande, en remplaçant .bash\_profile si nécessaire :
```
 source .bashrc
```
Tapez swift list et assurez-vous que vous pouvez voir le conteneur que vous avez créé pour contenir vos données.

Sauvegarder les données d'AWS vers Rackspace Cloud Files

Cette section vous montre comment sauvegarder des données d'AWS vers Rackspace Cloud Files. L'exemple utilise un conteneur existant nommé AppData.

Tout d'abord, récupérez vos données depuis EC2. Vous pouvez transférer les données directement de l'une des manières suivantes :

Utilisez le protocole de transfert de fichiers SSH rsyncor (SFTP).
Utilisez le client OpenStack Swift pour transférer vos données vers Cloud Files, puis transférez-les de Cloud Files vers le serveur Cloud.

Pour utiliser Cloud Files, suivez ces étapes préparatoires :

À l'aide de SSH, connectez-vous à votre instance EC2 en saisissant la commande suivante :
```
ssh -i your_private_key.pem [email protected]
```

Effectuez un vidage de MongoDB. Utilisez le -host et -port options si MongoDB s'exécute sur une instance différente, comme illustré dans l'exemple suivant :

mongodump --host mongodb1.yourdomain.com --port 3017 --username $USERNAME --password $PASSWORD --out ~/backup/mongodump-2013-05-03
tar czvf backbonedb-2013-05-03.tar.gz ~/backup/db/mongodump-2013-05-03/*

Utilisez les commandes suivantes pour sauvegarder votre application et toutes les ressources dont l'application a besoin, y compris les journaux et autres répertoires :

# Backup backbone resources
sudo tar cvzf ~/backup/app/backhone.tar.gz /usr/share/tomcat/webapps/YOURAPP/*
# Backup node.js resources
sudo tar cvzf ~/backup/app/nodejs.tar.gz /usr/local/nodejs/YOURAPP/*

Si vous utilisez Cloud Files pour transférer vos fichiers, utilisez l'une des méthodes suivantes pour effectuer le transfert. Si vous utilisez rsync ou SFTP, terminez le transfert et passez à la dernière section de cet article.
- Importez vos archives dans le conteneur Cloud Files à l'aide du client Swift et des commandes suivantes :
```
swift upload AppData backbonedb-2013-05-03.tar.gz
swift upload AppData backhone.tar.gz
swift upload AppData nodejs.tar.gz
```
- Procédez comme suit pour importer vos données dans Cloud Files à l'aide du panneau de configuration Cloud :
  1. Connectez-vous au panneau de configuration du cloud.
  2. Dans la barre de navigation supérieure, cliquez sur Sélectionner un produit> RackspaceCloud .
  3. Sélectionnez Stockage> Fichiers> containerName pour ouvrir votre conteneur.
  4. Cliquez sur Télécharger des fichiers .
  5. Cliquez sur Parcourir et sélectionnez les fichiers que vous souhaitez télécharger. Cliquez ensuite sur Ouvrir ou Sélectionner (selon votre navigateur et votre système).
  6. Cliquez sur Télécharger le fichier .

Restaurer les données des fichiers cloud vers les serveurs cloud

Si vous avez importé vos données dans Cloud Files, transférez-les vers CloudServers en procédant comme suit :

À l'aide de SSH, connectez-vous à l'instance Cloud Servers en utilisant l'URL PublicNet et le mot de passe root.
Installez et configurez l'interface de ligne de commande (CLI) Swift comme décrit dans la section "Installer les packages logiciels".
Exécuter la swift list commande et assurez-vous que vous voyez le nouveau conteneur que vous avez créé dans les résultats.
Téléchargez le vidage de la base de données à partir de la sauvegarde que vous avez effectuée dans la section « Sauvegarder les données d'AWS vers Rackspace Cloud Files » et restaurez-le localement à l'aide des commandes suivantes :
```
swift download AppData backbonedb-2013-05-03.tar.gz
gunzip < backbonedb-2013-05-03.tar.gz | mongorestore --host mongodb1.yourdomain.com --port 3017 --username user --password pass
```

Téléchargez les données (Backbone.js et Node.js) et restaurez-les en utilisant les commandes suivantes :

sudo service tomcat7 stop #stop tomcat server
swift download AppData backbone.tar.gz
# restore / deflate backbone
cd /usr/share/tomcat/webapps
sudo tar xvf backbone.tar.gz
# restore node.js
swift download AppData nodejs.tar.gz
sudo mkdir -p /usr/local/nodejs/YOURAPP
cd /usr/local/nodejs
sudo tar xvf nodejs.tar.gz

Démarrez les services de l'application à l'aide des commandes suivantes :

sudo service tomcat7 start
cd /usr/local/nodejs/YOURAPP/
sudo node server.js

Testez votre application

Accédez à https:/// dans une fenêtre de navigateur pour accéder et tester votre application.

Étape suivante

Considérations post-migration lors de la migration depuis Amazon Web Services

Pour d'autres scénarios de migration, consultez les articles suivants :

Migrer une application .NET depuis Amazon Web Services
Migrer une application Web Java depuis Amazon Web Services