GNU/Linux >> LINUX-Kenntnisse > >> Linux

Migrieren Sie eine Anwendung basierend auf Backbone.js, Node.js und MongoDB von Amazon Web Services

Vorheriger Abschnitt: Bereitstellen von Cloud-Ressourcen bei der Migration von Amazon Web Services

Dieses Szenario zeigt Ihnen, wie Sie eine Backbone.js-, Node.js- und MongoDB®-Anwendung von Amazon Web Services (AWS) in die Rackspace Cloud migrieren. Es dauert etwa 30 Minuten, bis er abgeschlossen ist.

Das folgende Diagramm zeigt die Topologie der Anwendung:

Voraussetzungen

Dieses Szenario hat die folgenden Voraussetzungen:

Ein Anwendungs-Stack auf AWS mit Root-Zugriff oder entsprechenden Berechtigungen für einzelne Instanzen und Dienste.
Ein gültiges und aktiviertes Konto auf Rackspace Cloud.

Vorbereitung

Führen Sie die folgenden Schritte aus, bevor Sie das Szenario starten:

Identifizieren Sie die Ressourcen, die Sie migrieren möchten, einschließlich Anwendungs- und Datenbankressourcen.
Erstellen Sie eine Liste aller erforderlichen Softwarepakete, die auf Ihren Amazon Elastic Compute Cloud (EC2)-Instanzen außer Backbone.js, Node.js und MongoDB installiert sind.
Erstellen Sie eine Liste aller zusätzlichen Amazon-Dienste, die Ihre Anwendung verwendet, wie z. B. Simple Email Service (SES) für E-Mail oder Relational DatabaseService (RDS) für Datenbanken.
Falls noch nicht geschehen, erstellen Sie eine Cloud Server-Instanz und alle unterstützenden Rackspace Cloud-Dienste.

Softwarepakete installieren

Dieser Abschnitt enthält Anweisungen zum Installieren der erforderlichen und optionalen Softwarepakete.

Git und cURL installieren

Sie müssen Git und cURL verwenden, um abhängige Komponenten wie Node.js zu erhalten.

Führen Sie den folgenden Befehl aus, um git und cURL zu installieren:

sudo apt-get -y install git curl

Python installieren (optional)

Ubuntu® Version 12.0.4 Long Term Support (LTS) enthält Python® Version 2.7.2. Wenn Sie eine andere Version benötigen, können Sie sie von der Python-Downloadseite installieren.

Installieren Sie OpenJDK

Verwenden Sie die folgenden Schritte, um OpenJDK™ zu installieren:

Stellen Sie mit Secure Shell (SSH) eine Verbindung zur Cloud Servers-Instanz her, indem Sie die PublicNet-URL und das Root-Passwort verwenden.
Installieren Sie OpenJDK 7, indem Sie den folgenden Befehl eingeben:
```
 sudo apt-get -y install openjdk-7-jre
```
Bestimmen Sie den Speicherort von JAVA_HOME durch Eingabe des folgenden Befehls:
```
 ll /etc/alternatives/java
```
In der folgenden Beispielausgabe JAVA_HOME befindet sich unter /usr/lib/jvm/jre-1.7.0-openjdk-amd64 :
```
 /etc/alternatives/java -> /usr/lib/jvm/java-7-openjdk-amd64/jre/bin/java*
```

Installieren Sie Tomcat 7 auf dem Cloud-Server

Verwenden Sie die folgenden Schritte, um Apache® Tomcat® zu installieren:

Geben Sie den folgenden Befehl ein, um Tomcat 7 zu installieren:
```
 sudo apt-get -y install tomcat7
```
Wenn Sie eine andere Version von Tomcat installieren oder Tomcat manuell installieren möchten, wählen Sie die Version auf der Tomcat 7-Software-Downloadseite aus.
Kopieren Sie die URL der tar.gz Datei (zum Beispiel https://www.us.apache.org/dist/tomcat/tomcat-7/v7.0.39/bin/apache-tomcat-7.0.39.tar.gz ).
Wechseln Sie in das Verzeichnis /usr/share (oder das Verzeichnis, das Sie verwenden möchten) und laden Sie die Binärdatei herunter, indem Sie die folgenden Befehle eingeben:
```
 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
```
Ändern Sie die Berechtigungen, indem Sie den folgenden Befehl eingeben:
```
 sudo chmod 775 apache-tomcat-7.0.39.tar.gz
```
Extrahieren Sie den Dateiinhalt, indem Sie den folgenden Befehl eingeben:
```
 sudo tar zxvf apache-tomcat-7.0.39.tar.gz
```
Nachdem Tomcat extrahiert wurde, entfernen Sie tar.gz Dateien, um Speicherplatz zu sparen, indem Sie den folgenden Befehl eingeben:
```
 sudo rm apache-tomcat-7.0.39.tar.gz
```
Setzen Sie die Umgebungsvariablen in catalina.sh Datei, indem Sie die folgenden Befehle eingeben:
```
 cd /usr/share/apache-tomcat-7.0.39/bin
 sudo vi catalina.sh
```
Fügen Sie die folgende Zeile unmittelbar nach \#!/bin/sh hinzu :
```
 JAVA_HOME=/usr/lib/jvm/jre-1.7.0-openjdk.x86_64
```
Speichern Sie Ihre Änderungen und beenden Sie die Datei.
Automatisieren Sie den Start von Tomcat mit den folgenden Befehlen:
```
cd /etc/init.d
sudo vi tomcat
```

Fügen Sie der Datei die folgenden Informationen hinzu. Stellen Sie sicher, dass JAVA_HOME ,TOMCAT_HOME , START_TOMCAT und STOP_TOMCAT auf die richtigen Verzeichnisse verweisen.

#!/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

Speichern Sie Ihre Änderungen und beenden Sie die Datei.
Legen Sie Dateiberechtigungen fest, richten Sie Tomcat als Systemdienst ein und testen Sie die Einrichtung, indem Sie die folgenden Befehle eingeben:
```
sudo chmod 755 tomcat
sudo /sbin/chkconfig --add tomcat
sudo /sbin/chkconfig --level 234 tomcat on
sudo /sbin/chkconfig --list tomcat
```
Die Ausgabe sollte dem folgenden Beispiel ähneln:
```
tomcat 0:off 1:off 2:on 3:on 4:on 5:off 6:off
```
Da Tomcat auf Port 8080 ausgeführt wird, stellen Sie sicher, dass iptables die Konnektivität nicht stört.

Um mehr über iptables zu erfahren, siehe Einführung in iptables.
Testen Sie Tomcat, indem Sie die Internet Protocol (IP)-Adresse für den Cloudserver im Rackspace Cloud Control Panel nachschlagen und die URL in einem Browser öffnen (z. B. https://:8080/). ).

Die Startseite von Apache Tomcat wird angezeigt.

Hinweis :Sie können Tomcat mit den folgenden Befehlen starten und stoppen:
```
sudo /sbin/service tomcat stop
sudo /sbin/service tomcat start
```

Installieren Sie MongoDB auf Ihrem Cloud-Server

Anweisungen zum Installieren von MongoDB in der Rackspace Cloud finden Sie auf der MongoDB-Dokumentationswebsite.

Für eine Produktionsbereitstellung sollten Sie einen Replikatsatz mit mindestens drei Knoten verwenden.

Führen Sie für eine Einzelknoteninstallation die folgenden Schritte aus:

Fügen Sie den GNU Privacy Guard (GPG)-Schlüssel zu apt-get hinzu um eine vertrauenswürdige zu erstellen Quelle durch Eingabe des folgenden Befehls:
```
 sudo apt-key adv --keyserver keyserver.ubuntu.com --recv 7F0CEB10
```
Verwenden Sie die folgenden Befehle, um einen benutzerdefinierten 10gen zu erstellen Repository-Datei, die den Speicherort der MongoDB-Binärdateien enthält:
```
 sudo sh -c 'echo "deb https://downloads-distro.mongodb.org/repo/ubuntu-upstart dist 10gen" | tee -a /etc/apt/sources.list.d/10gen.list'
```
Aktualisieren Sie apt-get um neue Pakete abzuholen, indem Sie den folgenden Befehl eingeben:
```
 sudo apt-get -y update
```
Installieren Sie MongoDB, indem Sie den folgenden Befehl eingeben:
```
 sudo apt-get -y install mongodb-10gen
```
Stellen Sie sicher, dass MongoDB ausgeführt wird, indem Sie den folgenden Befehl eingeben:
```
 ps aux | grep mongo
```

Hinweis :MongoDB verwendet /var/lib/mongodb als Standarddatenpfad. Wenn Sie diesen Pfad ändern möchten, können Sie die MongoDB-Instanz herunterfahren und die Konfigurationsdatei unter /etc/mongodb.conf aktualisieren .

Richten Sie einen Node.js-Server ein

Wenn Ihre Dienste von Node.js anstelle von Python unterstützt werden, führen Sie die folgenden Schritte aus, um einen Node.js-Server auf Ihrer Cloud-Instanz einzurichten:

Installieren Sie Node.js, indem Sie den folgenden Befehl eingeben:
```
 sudo apt-get -y install nodejs npm
```
Testen Sie die Installation mit dem folgenden Befehl, um die Version von Node.js abzurufen, die Sie ausführen:
```
 node --version
```

Installieren Sie OpenStack Swift (optional)

Wenn Sie Cloud Files zum Übertragen Ihrer Daten verwenden möchten, verwenden Sie die folgenden Schritte, um den OpenStack® Swift-Client zu installieren, um den Zugriff von Ihrem Server zu ermöglichen:

Installieren Sie den Swift-Client, indem Sie den folgenden Befehl eingeben:
```
 sudo apt-get install python-novaclient glance-client swift
```
Legen Sie die erforderlichen Umgebungsvariablen fest, indem Sie die folgenden Befehle ausführen und dabei Ihren Benutzernamen und den API-Schlüssel (Application Programming Interface) ersetzen:
```
 export ST_USER=<yourLoginUsername>
 export ST_KEY=<yourApiKey>
 export ST_AUTH=https://identity.api.rackspacecloud.com/v1.0/
```
Möglicherweise möchten Sie diese Variablen in .bashrc definieren oder.bash\_profile Datei, dann laden Sie die Datei mit dem folgenden source neu Befehl, ersetzen Sie .bash\_profile ggf.:
```
 source .bashrc
```
Geben Sie swift list ein und stellen Sie sicher, dass Sie den Container sehen können, den Sie für Ihre Daten erstellt haben.

Sichern Sie Daten von AWS in Rackspace Cloud Files

Dieser Abschnitt zeigt Ihnen, wie Sie Daten von AWS in Rackspace Cloud Files sichern. Das Beispiel verwendet einen vorhandenen Container namens AppData.

Rufen Sie zunächst Ihre Daten von EC2 ab. Sie können die Daten direkt auf eine der folgenden Arten übertragen:

Verwenden Sie rsyncor SSH File Transfer Protocol (SFTP).
Verwenden Sie den OpenStack Swift-Client, um Ihre Daten in Cloud Files zu übertragen, und übertragen Sie sie dann von Cloud Files auf den Cloud Server.

Um Cloud-Dateien zu verwenden, befolgen Sie diese vorbereitenden Schritte:

Stellen Sie mit SSH eine Verbindung zu Ihrer EC2-Instance her, indem Sie den folgenden Befehl eingeben:
```
ssh -i your_private_key.pem [email protected]
```

Führen Sie einen Dump von MongoDB durch. Verwenden Sie den -host und -port Optionen, wenn MongoDB auf einer anderen Instanz ausgeführt wird, wie im folgenden Beispiel gezeigt:

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

Verwenden Sie die folgenden Befehle, um Ihre Anwendung und alle Ressourcen zu sichern, die die Anwendung benötigt, einschließlich Protokolle und andere Verzeichnisse:

# 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/*

Wenn Sie Cloud Files verwenden, um Ihre Dateien zu übertragen, verwenden Sie eine der folgenden Methoden, um die Übertragung durchzuführen. Wenn Sie rsync oder SFTP verwenden, schließen Sie die Übertragung ab und fahren Sie mit dem letzten Abschnitt dieses Artikels fort.
- Laden Sie Ihre Archive mit dem Swift-Client und den folgenden Befehlen in den Cloud Files-Container hoch:
```
swift upload AppData backbonedb-2013-05-03.tar.gz
swift upload AppData backhone.tar.gz
swift upload AppData nodejs.tar.gz
```
- Verwenden Sie die folgenden Schritte, um Ihre Daten mithilfe des Cloud Control Panels in Cloud Files hochzuladen:
  1. Melden Sie sich beim Cloud Control Panel an.
  2. Klicken Sie in der oberen Navigationsleiste auf Produkt auswählen> RackspaceCloud .
  3. Wählen Sie Speicher> Dateien> Containername aus um Ihren Container zu öffnen.
  4. Klicken Sie auf Dateien hochladen .
  5. Klicken Sie auf Durchsuchen und wählen Sie die Dateien aus, die Sie hochladen möchten. Klicken Sie dann auf Öffnen oder Auswählen (je nach Browser und System).
  6. Klicken Sie auf Datei hochladen .

Stellen Sie Daten aus Cloud-Dateien auf Cloud-Servern wieder her

Wenn Sie Ihre Daten in Cloud Files hochgeladen haben, übertragen Sie sie mithilfe der folgenden Schritte auf CloudServers:

Stellen Sie mit SSH eine Verbindung zur Cloud Servers-Instanz her, indem Sie die PublicNet-URL und das Root-Passwort verwenden.
Installieren und konfigurieren Sie die Swift-Befehlszeilenschnittstelle (CLI) wie im Abschnitt „Softwarepakete installieren“ beschrieben.
Führen Sie die swift list aus Befehl und vergewissern Sie sich, dass Sie den von Ihnen erstellten neuen Container in den Ergebnissen sehen.
Laden Sie den Datenbank-Dump aus der Sicherung herunter, die Sie im Abschnitt „Daten von AWS in Rackspace Cloud-Dateien sichern“ erstellt haben, und stellen Sie ihn lokal wieder her, indem Sie die folgenden Befehle verwenden:
```
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
```

Laden Sie die Daten (Backbone.js und Node.js) herunter und stellen Sie sie mit den folgenden Befehlen wieder her:

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

Starten Sie die Anwendungsdienste mit den folgenden Befehlen:

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

Testen Sie Ihre Anwendung

Navigieren Sie zu https:/// in einem Browserfenster, um auf Ihre Anwendung zuzugreifen und sie zu testen.

Nächster Schritt

Überlegungen nach der Migration bei der Migration von Amazon Web Services

Weitere Migrationsszenarien finden Sie in den folgenden Artikeln:

Migrieren Sie eine .NET-Anwendung von Amazon Web Services
Migrieren Sie eine Java-Webanwendung von Amazon Web Services

Migrieren Sie eine Java-Webanwendung von Amazon Web Services

Migrieren Sie zwischen Server-Varianten

Linux

So installieren Sie TermPair, um Terminals in Echtzeit über den Webbrowser freizugeben und zu steuern

So installieren Sie den Hiawatha-Webserver auf CentOS 7

Installieren und konfigurieren Sie phpMyAdmin

Migrieren Sie eine .NET-Anwendung von Amazon Web Services

Migrieren Sie eine Java-Webanwendung von Amazon Web Services

Stellen Sie Cloud-Ressourcen bereit, wenn Sie von Amazon Web Services migrieren