Migrace aplikace založené na Backbone.js, Node.js a MongoDB z Amazon Web Services

Předchozí sekce: Poskytování cloudových zdrojů při migraci z webových služeb Amazon

Tento scénář ukazuje, jak migrovat aplikaci Backbone.js, Node.js a MongoDB® ze služeb Amazon Web Services (AWS) do cloudu Rackspace. Dokončení trvá asi 30 minut.

Následující diagram ukazuje topologii aplikace:

Předpoklady

Tento scénář má následující předpoklady:

Zásobník aplikací na AWS s přístupem root nebo příslušnými oprávněními pro jednotlivé instance a služby.
Platný a povolený účet v cloudu Rackspace.

Příprava

Před spuštěním scénáře proveďte následující kroky:

Identifikujte prostředky, které chcete migrovat, včetně prostředků aplikací a databáze.
Vytvořte seznam všech nezbytných softwarových balíčků, které jsou nainstalovány ve vašich instancích Amazon Elastic Compute Cloud (EC2) jiných než Backbone.js, Node.js a MongoDB.
Vytvořte seznam všech dalších služeb Amazonu, které vaše aplikace používá, jako je Simple Email Service (SES) pro e-mail nebo Relational DatabaseService (RDS) pro databáze.
Pokud jste to ještě neudělali, vytvořte instanci cloudového serveru a všechny podpůrné cloudové služby Rackspace.

Instalovat softwarové balíčky

Tato část obsahuje pokyny pro instalaci požadovaných a volitelných softwarových balíčků.

Nainstalujte Git a cURL

Chcete-li získat závislé komponenty, jako je Node.js.

, musíte použít Git a cURL

Spusťte následující příkaz k instalaci git a cURL:

sudo apt-get -y install git curl

Instalovat Python (volitelné)

Ubuntu® verze 12.0.4 Long Term Support (LTS) zahrnuje Python® verze 2.7.2. Pokud potřebujete jinou verzi, můžete si ji nainstalovat ze stránky pro stahování Pythonu.

Instalovat OpenJDK

K instalaci OpenJDK™ použijte následující kroky:

Pomocí Secure Shell (SSH) se připojte k instanci Cloud Servers pomocí adresy URL PublicNet a hesla uživatele root.
Nainstalujte OpenJDK 7 zadáním následujícího příkazu:
```
 sudo apt-get -y install openjdk-7-jre
```
Určete umístění JAVA_HOME zadáním následujícího příkazu:
```
 ll /etc/alternatives/java
```
V následujícím příkladu výstupu JAVA_HOME se nachází na adrese/usr/lib/jvm/jre-1.7.0-openjdk-amd64 :
```
 /etc/alternatives/java -> /usr/lib/jvm/java-7-openjdk-amd64/jre/bin/java*
```

Instalovat Tomcat 7 na cloudový server

K instalaci Apache® Tomcat® použijte následující kroky:

Chcete-li nainstalovat Tomcat 7, zadejte následující příkaz:
```
 sudo apt-get -y install tomcat7
```
Pokud chcete nainstalovat jinou verzi Tomcatu nebo nainstalovat Tomcat ručně, vyberte verzi na stránce Tomcat 7 Software Downloads.
Zkopírujte adresu URL souboru tar.gz soubor (napříkladhttps://www.us.apache.org/dist/tomcat/tomcat-7/v7.0.39/bin/apache-tomcat-7.0.39.tar.gz ).
Změňte adresář na /usr/share (nebo adresář, který chcete použít) a stáhněte si binární soubor zadáním následujících příkazů:
```
 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
```
Změňte oprávnění zadáním následujícího příkazu:
```
 sudo chmod 775 apache-tomcat-7.0.39.tar.gz
```
Extrahujte obsah souboru zadáním následujícího příkazu:
```
 sudo tar zxvf apache-tomcat-7.0.39.tar.gz
```
Po extrahování Tomcatu odstraňte tar.gz soubory, abyste ušetřili místo zadáním následujícího příkazu:
```
 sudo rm apache-tomcat-7.0.39.tar.gz
```
Nastavte proměnné prostředí v catalina.sh soubor zadáním následujících příkazů:
```
 cd /usr/share/apache-tomcat-7.0.39/bin
 sudo vi catalina.sh
```
Přidejte následující řádek bezprostředně za \#!/bin/sh :
```
 JAVA_HOME=/usr/lib/jvm/jre-1.7.0-openjdk.x86_64
```
Uložte změny a ukončete soubor.
Automatizujte spouštění Tomcat pomocí následujících příkazů:
```
cd /etc/init.d
sudo vi tomcat
```

Přidejte do souboru následující informace. Ujistěte se, že JAVA_HOME ,TOMCAT_HOME , START_TOMCAT a STOP_TOMCAT podívejte se do správných adresářů.

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

Uložte změny a ukončete soubor.
Nastavte oprávnění k souborům, nastavte Tomcat jako systémovou službu a otestujte nastavení zadáním následujících příkazů:
```
sudo chmod 755 tomcat
sudo /sbin/chkconfig --add tomcat
sudo /sbin/chkconfig --level 234 tomcat on
sudo /sbin/chkconfig --list tomcat
```
Výstup by měl být podobný následujícímu příkladu:
```
tomcat 0:off 1:off 2:on 3:on 4:on 5:off 6:off
```
Protože Tomcat běží na portu 8080, zajistěte, aby iptables nerušilo připojení.

Chcete-li se dozvědět o iptables, viz Úvod do iptables.
Otestujte Tomcat vyhledáním adresy internetového protokolu (IP) cloudserveru z ovládacího panelu cloudu Rackspace a otevřením adresy URL v prohlížeči (například https://:8080/ ).

Zobrazí se vstupní stránka Apache Tomcat.

Poznámka :Tomcat můžete spustit a zastavit pomocí následujících příkazů:
```
sudo /sbin/service tomcat stop
sudo /sbin/service tomcat start
```

Nainstalujte MongoDB na svůj cloudový server

Pokyny k instalaci MongoDB na Rackspace Cloud naleznete na webu MongoDB Documentation.

Pro produkční nasazení byste měli použít sadu replik s alespoň třemi uzly.

V případě instalace s jedním uzlem proveďte následující kroky:

Přidejte klíč GNU Privacy Guard (GPG) do apt-get vytvořit důvěryhodný source zadáním následujícího příkazu:
```
 sudo apt-key adv --keyserver keyserver.ubuntu.com --recv 7F0CEB10
```

Pomocí následujících příkazů vytvořte vlastní 10gen soubor úložiště obsahující umístění binárních souborů 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'

Aktualizujte apt-get pro vyzvednutí nových balíků zadáním následujícího příkazu:
```
 sudo apt-get -y update
```
Nainstalujte MongoDB zadáním následujícího příkazu:
```
 sudo apt-get -y install mongodb-10gen
```
Ověřte, že MongoDB běží zadáním následujícího příkazu:
```
 ps aux | grep mongo
```

Poznámka :MongoDB používá /var/lib/mongodb jako výchozí datovou cestu. Pokud chcete změnit tuto cestu, můžete vypnout instanci MongoDB a aktualizovat konfigurační soubor na /etc/mongodb.conf .

Nastavení serveru Node.js

Pokud jsou vaše služby podporovány Node.js namísto Pythonu, použijte následující kroky k nastavení serveru Node.js ve vaší cloudové instanci:

Nainstalujte Node.js zadáním následujícího příkazu:
```
 sudo apt-get -y install nodejs npm
```
Otestujte instalaci pomocí následujícího příkazu k získání verze Node.js, kterou používáte:
```
 node --version
```

Instalovat OpenStack Swift (volitelné)

Pokud plánujete k přenosu dat použít Cloud Files, pomocí následujících kroků nainstalujte klienta OpenStack® Swift, abyste umožnili přístup ze svého serveru:

Nainstalujte klienta Swift zadáním následujícího příkazu:
```
 sudo apt-get install python-novaclient glance-client swift
```
Nastavte potřebné proměnné prostředí spuštěním následujících příkazů, které nahradí vaše uživatelské jméno a klíč aplikačního programovacího rozhraní (API):
```
 export ST_USER=<yourLoginUsername>
 export ST_KEY=<yourApiKey>
 export ST_AUTH=https://identity.api.rackspacecloud.com/v1.0/
```
Možná budete chtít definovat tyto proměnné v .bashrc nebo .bash\_profile soubor a poté soubor znovu načtěte s následujícím source příkaz nahrazující .bash\_profile v případě potřeby:
```
 source .bashrc
```
Zadejte swift list a ujistěte se, že vidíte kontejner, který jste vytvořili pro uložení vašich dat.

Zálohování dat z AWS do Rackspace Cloud Files

Tato část ukazuje, jak zálohovat data z AWS do Rackspace Cloud Files. Příklad používá existující kontejner s názvem AppData.

Nejprve načtěte svá data z EC2. Data můžete přenést přímo jedním z následujících způsobů:

Použijte rsyncor SSH File Transfer Protocol (SFTP).
Pomocí klienta OpenStack Swift přeneste svá data do Cloud Files a poté je přeneste z Cloud Files na Cloud Server.

Chcete-li používat Cloud Files, postupujte podle těchto přípravných kroků:

Pomocí SSH se připojte k instanci EC2 zadáním následujícího příkazu:
```
ssh -i your_private_key.pem [email protected]
```

Proveďte výpis MongoDB. Použijte -host a -port možnosti, pokud MongoDB běží na jiné instanci, jak ukazuje následující příklad:

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

K zálohování aplikace a všech prostředků, které aplikace potřebuje, včetně protokolů a dalších adresářů, použijte následující příkazy:

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

Pokud k přenosu souborů používáte Cloud Files, proveďte přenos jedním z následujících způsobů. Pokud používáte rsync nebo SFTP, dokončete přenos a přejděte na poslední část tohoto článku.
- Nahrajte své archivy do kontejneru Cloud Files pomocí klienta Swift a následujících příkazů:
```
swift upload AppData backbonedb-2013-05-03.tar.gz
swift upload AppData backhone.tar.gz
swift upload AppData nodejs.tar.gz
```
- Pomocí následujících kroků nahrajte svá data do Cloud Files pomocí Cloud Control Panel:
  1. Přihlaste se do Cloud Control Panel.
  2. V horním navigačním panelu klikněte na Vybrat produkt> RackspaceCloud .
  3. Vyberte Úložiště> Soubory> název_kontejneru otevřete kontejner.
  4. Klikněte na Nahrát soubory .
  5. Klikněte na Procházet a vyberte soubory, které chcete nahrát. Poté klikněte na Otevřít nebo Vybrat (v závislosti na vašem prohlížeči a systému).
  6. Klikněte na Nahrát soubor .

Obnovení dat z cloudových souborů na cloudové servery

Pokud jste svá data nahráli do Cloud Files, přeneste je na CloudServers pomocí následujících kroků:

Pomocí SSH se připojte k instanci Cloud Servers pomocí adresy URL PublicNet a hesla uživatele root.
Nainstalujte a nakonfigurujte rozhraní příkazového řádku (CLI) Swift, jak je popsáno v části „Instalace softwarových balíčků“.
Spusťte swift list a ujistěte se, že ve výsledcích vidíte nový kontejner, který jste vytvořili.
Stáhněte výpis databáze ze zálohy, kterou jste pořídili v části „Zálohovat data z AWS do Rackspace Cloud Files“ a obnovte jej lokálně pomocí následujících příkazů:
```
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
```

Stáhněte si data (Backbone.js a Node.js) a obnovte je pomocí následujících příkazů:

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

Spusťte aplikační služby pomocí následujících příkazů:

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

Otestujte svou aplikaci

Přejděte na https:/// v okně prohlížeče pro přístup k aplikaci a její testování.

Další krok

Aspekty po migraci při migraci z webových služeb Amazon

Další scénáře migrace naleznete v následujících článcích:

Migrujte aplikaci .NET z webových služeb Amazon
Migrujte webovou aplikaci Java z webových služeb Amazon

Migrujte webovou aplikaci Java z webových služeb Amazon Migrujte mezi variantami serveru

Linux