02s-deploying.md.erb

---
title: Deployment
slug: deploying
date: 0002/01/02
number: 2.5
points: 1
sidebar: true
photoUrl: http://www.flickr.com/photos/monomaniacgarage/10703829133/
photoAuthor: Monomaniacgarage
contents: Lerne auf Meteor.com zu deployen.|Lerne auf Modulus zu deployen|Lerne auf deinen eigenen Server mit Meteor Up zu deployen.
paragraphs: 46
---

Manche Leute arbeiten gerne an einem Projekt, bis es perfekt ist. Andere wiederum können es kaum erwarten, das Projekt möglichst früh der Welt zu präsentieren.

Wenn du zum ersten Typ gehörst und lieber lokal arbeitest, kannst du dieses Kapitel auch überspringen. Du kannst dir aber auch die Zeit nehmen, um zu lernen, wie du mit deiner Meteor App online gehst.

Du wirst verschiedene Arten kennenlernen, um eine Meteor App zu deployen (veröffentlichen). Du kannst jede dieser Arten an jedem Punkt in deinem Entwicklungsprozess nutzen, egal ob du an Microscope oder einer anderen Meteor App arbeitest. Lass uns anfangen!


<% note do %>

### Erklärung zu Sidebars

Dies ist ein **Sidebar** Kapitel. Sidebars geben, unabhängig vom Rest des Buches, einen tieferen Einblick in allgemeine Meteor Themen.


Möchtest du lieber an Microscope weiterentwickeln, kannst du dieses Kapitel auch zunächst überspringen und es später lesen.

<% end %>

###Deployen auf Meteor

Auf eine Meteor Subdomain zu deployen (z.B. `http://myapp.meteor.com`) ist die einfachste und erste Möglichkeit, die wir versuchen werden. Dies kann nützlich sein, um die App in einem frühen Stadium anderen zu zeigen oder um schnell einen Staging Server einzurichten (ein Staging Server ist ein Server, auf dem eine Entwicklungsversion unter Live-Bedingungen getestet werden kann).

Auf Meteor zu deployen ist ziemlich einfach. Öffne dein Terminal, wechsle in dein Meteor App Verzeichnis und tippe:

~~~bash
$ meteor deploy myapp.meteor.com
~~~

Natürlich musst du "myapp" mit einem Namen deiner Wahl ersetzen, möglichst einem der noch nicht vergeben ist. 

Wenn du zum ersten mal eine App deployst, wirst du aufgefordert, einen Meteor Account zu erstellen. Wenn alles funktioniert, kannst du deine App nach einigen Sekunden unter `http://myapp.meteor.com` aufrufen.

In der [offiziellen Dokumentation](http://docs.meteor.com/#deploying) findest du weitere Informationen zu Themen wie direktem Zugriff zu der gehosteten Datenbankinstanz oder dem Konfigurieren einer eigenen Domain für deine App.

### Deployen auf Modulus

[Modulus](https://modulus.io/) ist eine grossartige Möglichkeit, um Node.js Apps zu deployen. Es ist eine der wenigen PaaS (platform-as-a-service) Anbieter, welche offiziell Meteor unterstützt und es gibt bereits einige Leute, die ihre Meteor App auf Modulus im Produktionsbetrieb bereitstellen.

<% note do %>

### Demeteorizer

Modulus bietet ein Open-Source Werkzeug namens [demeteorizer](https://github.com/onmodulus/demeteorizer) an, welches deine Meteor App in eine Standard Node.js App konvertiert.

<% end %>

Starte mit dem [Erstellen eines Accounts](https://modulus.io/register). Um die App auf Modulus zu deployen, musst du das Modulus Kommandozeilen-Tool installieren.


~~~bash
$ npm install -g modulus
~~~

Und dann authentifizieren mit:

~~~bash
$ modulus login
~~~

Wir erstellen nun ein Modulus Projekt (du kannst dies auch im Modulus Web Dashboard machen):

~~~bash
$ modulus project create
~~~

Der nächste Schritt ist das Erstellen einer MongoDB Datenbank für unsere App. Wir könnnen eine MongoDB Datenbank mit [Modulus selbst](https://modulus.io/codex/database/getting_started) erstellen, [MongoHQ](https://www.mongohq.com/) oder mit einem anderen Cloud MongoDB Anbieter.

Haben wir unsere MongDB Datenbank erstellt, können wir die `MONGO_URL` für unsere Datenbank vom Modulus Web UI abrufen (gehe zu Dashboard > Database > Select your database > Administration), nutze diese um deine App folgendermassen zu konfigurieren: 


~~~bash
$ modulus env set MONGO_URL "mongodb://<user>:<pass>@mongo.onmodulus.net:27017/<database_name>"
~~~

Es ist nun an der Zeit, unsere App zu deployen. Und so simpel ist es:

~~~bash
$ modulus deploy
~~~

Wir haben nun erfolgreich unsere App auf Modulus deployed. In der [Modulus Dokumentation](https://modulus.io/codex/projects) findest du weitere Informationen über den Zugriff auf Log-Dateien, dem Einrichten eigener Domains und SSL.

### Meteor Up

Obwohl täglich neue Cloud Lösungen auftauchen, haben alle ihre eigenen Probleme und Beschränkungen. Aktuell ist das Deployen auf den eigenen Server die beste Möglichkeit, um eine Meteor Applikation im Produktionsbetrieb einzusetzen. Nur ist dies nicht ganz so einfach, vor allem wenn du professionell deployen willst.

[Meteor Up](https://github.com/arunoda/meteor-up) (kurz `mup`) ist ein weiterer Versuch, dieses Problem zu beheben. Dies funktioniert mit einem Kommandozeilen-Tool, welches die Installation und das Deployment für dich übernimmt. Sehen wir uns an, wie Microscope mit Meteor Up deployet werden kann. 

Als Allererstes benötigen wir einen Server, auf welchen wir deployen können. Wir empfehlen entweder [Digital Ocean](http://digitalocean.com), auf denen man ab 5$ pro Monat deployen kann oder [Amazon Webservices (AWS)](http://aws.amazon.com/), die Micro Instanzen gratis anbieteen (damit wirst du schnell an Skalierungsprobleme stossen, aber um mit Meteor Up herumzuspielen sollte es genügen).

Unabhängig vom gewählten Service solltest du nun drei Sachen haben: eine Server IP-Adresse, ein Login (normalerweise `root` oder `ubuntu`) und ein Kennwort. Bewahre diese sicher auf, wir werden sie bald benötigen.


### Meteor Up initialisieren

Zum Starten müssen wir Meteor Up via `npm` folgendermassen installieren:

~~~bash
$ npm install -g mup
~~~

Nun erstellen wir ein spezielles, separated Verzeichnis, dass unsere Meteor Up Einstellungen für ein bestimmtes Deployment enthält. Aus zwei Gründen nutzen wir ein separates Verzeichnis: Erstens ist es normalerweise das beste, private Anmeldedaten nicht im Git Repository zu speichern, vor allem wenn dein Code öffentlich ist.

Zweitens sind wir mit mehreren separaten Verzeichnissen in der Lage, mehrere Meteor Up Kongurationen parallel zu verwalten. Dies ist nützlich um z.B. auf Produktions- und Staging Instanzen zu deployen.

Erstellen wir also das neue Verzeichnis und nutzen es um das neue Meteor Up Projekt zu initialisieren:

~~~bash
$ mkdir ~/microscope-deploy
$ cd ~/microscope-deploy
$ mup init
~~~

<% note do %>

### Austausch mit Dropbox

Ein guter Weg, um sicherzustellen, dass alle in deinem Team dieselben Deployment-Einstellungen verwenden, ist einfach ein Meteor Up Verzeichnis in deiner Dropbox (oder einem ähnlichen Service) zu erstellen.

<% end %>

### Meteor Up Konfiguration

Beim Initialisieren eines neuen Projekts erstellt Meteor Up zwei Dateien für dich: `mup.json` und `settings.json`. 

`mup.json` enthält alle deployment-spezifischen Einstellungen, während `settings.json` alle app-spezifischen Einstellungen enthält (OAuth Tokens, Analytics Tokens, etc.).

Der nächste Schritt ist deine `mup.json` Datei zu konfigurieren. Standardmässig wird die `mup.json` Datei mit `mup init` erstellt. Nun musst du nur noch die leeren Zeilen befüllen:


~~~js
{
  //server authentication info
  "servers": [{
    "host": "hostname",
    "username": "root",
    "password": "password"
    //or pem file (ssh based authentication)
    //"pem": "~/.ssh/id_rsa"
  }],

  //install MongoDB in the server
  "setupMongo": true,

  //location of app (local directory)
  "app": "/path/to/the/app",

  //configure environmental
  "env": {
    "ROOT_URL": "http://supersite.com"
  }
}
~~~
<%= caption "mup.json" %>

Gehen wir durch jede dieser Einstellungen.

**Server Authentifikation**

Du wirst sehen, dass Meteor Up kennwortbasierte und private-key (PEM) basierte Authentifizierung unterstützt. Somit kann es fast mit jedem Cloud Anbieter verwendet werden.

**Wichtige Notiz**: Nutzt du die kennwortbasierte Authentifizierung, musst du zuerst `sshpass` installieren ([siehe Anleitung](https://gist.github.com/arunoda/7790979)). 

**MongoDB Konfiguration**

Der nächste Schritt ist eine MongoDB Datenbank für die App zu konfigurieren. Wir empfehen [MongoHQ](https://www.mongohq.com/home) oder einen anderen Cloud MongoDB Anbieter zu nutzen, da diese professionellen Support und bessere Management Tools anbieten.

Entscheidest du dich für MongoDB, setze `setupMongo` zu `false` and füge die `MONGO_URL` bei den Umgebungsvariablen in `mup.json`'s `env` Block hinzu. Wenn du dich dafür entscheidest, MongoDB mit Meteor Up zu hosten, setze einfach `setupMongo` als `true` and Meteor Up wird sich um den Rest kümmern.

**Meteor App Pfad**

Da unsere Meteor Up Konfiguration in zwei unterschiedlichen Verzeichnissen existiert, müssen wir Meteor Up zu unserer App mit der `app` Einstellung verweisen. Gib deinen absoluten lokalen Pfad an, den du mit dem `pwd` Befehl im Termin herausfinden kannst, wenn du dich im App-Verzeichnis befindest.

**Umgebungsvariablen**

Hier kannst du alle Umgebungsvariablen für deine App (wie `ROOT_URL`, `MAIL_URL`, `MONGO_URL`, etc.) im `env` Block definieren.

### Setup und Deploying

Bevor wir deployen können müssen wir den Server aufsetzen, damit er bereit ist, um Meteor Apps zu hosten. Meteor Up vereinfacht diesen komplexen Prozess in einen einzigen Befehl!

~~~bash
$ mup setup
~~~

Dies dauert einige Minuten, abhängig von der Server Performance und der Netzwerkverbindung. Wurde das Setup erfolgreich durchgeführt, können wir unsere App mit folgenden Befehl deployen.

~~~bash
$ mup deploy
~~~

Dies bündelt die Meteor App und deployt sie zum eben eingerichteten Server.

### Anzeigen von Logs

Logs sind ziemlich wichtig und Meteor Up bietet einen einfach Weg an um diese abzurufen, in dem es den `tail -f` Befehl emuliert. Gib dazu folgendes ein:

~~~bash
$ mup logs -f
~~~

All dies kann Meteor Up für uns machen. Für mehr Informationen empfehlen wir [Meteor Up's GitHub Repository](https://github.com/arunoda/meteor-up).

Diese drei Möglichkeiten, eine Meteor App zu deployen, sollten für die meisten Anwendungsfälle reichen. Natürlich wissen wir, dass einige unter euch es bevorzugen, die komplette Kontrolle über ihr Meteor Server von Beginn an zu haben. Aber dies ist ein Thema für ein ander Mal... oder für ein anderes Buch!