Das vor kurzem erschienene Spiel Starbound befindet sich zwar noch in Entwicklung aber trotzdem ist es bereits möglich, einen eigenen Multiplayer-Server aufzusetzen. Wir wollen dies anhand dieser kleinen Anleitung bei DigitalOcean praktisch umsetzen.

Droplet starten

Zu Beginn benötigen wir erstmal einen Server bzw. ein Droplet bei DigitalOcean . Für einen kleinen Server für eine überschaubare Anzahl von Spielern sollte ein 512 MB RAM Ubuntu 13.10 x64 Droplet ausreichen. Dieses Droplet starten wir über die Adminoberfläche von DigitalOcean .

Ein wenig Swap

Ist unser Droplet fertig gestartet besorgen wir uns die IP-Adresse aus der Admin-Oberfläche und loggen uns als Root-User ein.

ssh root@111.111.111.111

Anmerkung: Die 111.111.... bitte durch die korrekte IP-Adresse ersetzen

Um sicher zu gehen, dass unserem Droplet nicht der Ram-Speicher zu knapp wird fügen wir etwas Swap-Speicher hinzu. Dies erfolgt mit den folgenden Befehlen über die SSH-Konsole:

dd if=/dev/zero of=/swapfile bs=2048 count=512k
mkswap /swapfile
swapon /swapfile
echo 0 > /proc/sys/vm/swappiness
chown root:root /swapfile 
chmod 0600 /swapfile

Um sicher zu gehen, dass bei jedem Systemstart auch das Swap-File geladen wird öffnen wir mit Hilfe eines Editors das fstab-File und legen eine Zeile für das Swapfile an:

nano /etc/fstab

Am Ende der Datei fügen wir folgendes ein:

 /swapfile       none    swap    sw      0       0 

Damit ist unser Server nun mit etwas Swap-Speicher ausgestattet.

_Quelle: https://www.digitalocean.com/community/articles/how-to-add-swap-on-ubuntu-12-04_

Nutzer anlegen

Damit unser geplanter Server nicht mit Root-Rechten läuft brauchen wir noch einen User. Der Nutzername ist frei wählbar - als Beispiel verwende ich hier den Usernamen starbound.

adduser starbound

Das Kommando fragt uns nach ein paar Daten die wir so korrekt wie möglich ausfüllen und zum Abschluss bestätigen.

Pakete installieren

Damit der Steam-Client, welchen wir für den Download der Server-Software auf unserem System auch lauffähig ist, benötigen wir noch ein 32-Bit-Paket und für den späteren Gebrauch screen. Dieses wird mit Hilfe folgender Eingabe installiert:

apt-get install -y lib32gcc1 screen

Steam installieren

Mit dem letzten Schritt sind nun alle Vorarbeiten erledigt und wir können dazu übergehen uns den Steam-Client zu besorgen.

Damit wir gleich mit dem korrekten Nutzer unterwegs sind, loggen wir uns erneut über SSH am Server ein. Diesmal aber nicht als Root-User sondern mit dem vorher erstellten User.

ssh starbound@111.111.111.111

Anmerkung: Bitte auch hier wieder die korrekte IP-Adresse einsetzen und falls ein anderer Username als starbound angelegt wurde bitte auch diesen korrekt einsetzen.

Als Alternative zum erneuten Einloggen könnte man auch das Kommando

su - starbound

verwenden, aber um spätere Probleme zu vermeiden gehe ich hier auf Nummer sicher und logge mich erneut ein.

Sind wir wieder auf unserem Server eingeloggt, besorgen wir uns den Steam Client. Dies erledigen wir mit folgenden Kommandos:

wget http://media.steampowered.com/client/steamcmd_linux.tar.gz
tar xvfz steamcmd_linux.tar.gz
rm steamcmd_linux.tar.gz

Das letzte Kommando dient nur dazu um hinter uns aufzuräumen und muss nicht zwingend ausgeführt werden.

Einloggen bei Steam

Damit wir Zugriff auf unsere Spiele haben, ist es notwendig, uns mit dem Steam-Client einzuloggen. Wichtig: Unbedingt auf dem Client-Rechner den Steam-Client schließen, da es sonst zu Problemen kommen kann.

Mit folgendem Kommando starten wir den Steam-Client:

./steamcmd.sh

Jetzt sollte sich unsere Kommandozeile etwas verändert haben und uns mit dem Wort "Steam>" begrüßen. Nun ist es Zeit sich einzuloggen. Dies erfolgt per

login --steamuser--

_Anmerkung: --steamuser-- durch euren eigenen Steam-Benutzernamen ersetzen (ohne --).

Sogleich werden wir nach unserem Passwort gefragt, welches wir auch eingeben. Danach erfolgt noch eine Abfrage des Steam-Guard-Codes. Dieser Code wird euch an die bei Steam hinterlegte E-Mail-Adresse zugesandt.

Starbound installieren

Nun da wir bei Steam eingeloggt sind, können wir Starbound installiern. Dies erfolgt durch die Eingabe von

app_update 211820

Anmerkung: 211820 stellt die ID der Applikation innerhalb von Steam dar.

Nun erfolgt der Download von Starbound auf euren Server. Dies kann ein Weilchen dauern.

Ist der Download abgeschlossen beenden wir den Steam-Client mit Hilfe der Tastenkombination CTRL+C.

Starbound starten

Es ist endlich soweit - wir können unseren Starbound-Server in Betrieb nehmen. Dazu wechseln wir in das Verzeichnis der Linux-Binaries:

cd ~/Steam/SteamApps/common/Starbound/linux64/

Dort angekommen stellen wir sicher, dass unsere Server-Software auch ausführbar ist:

chmod +x starbound_server

Und starten anschließend den Server:

screen ./starbound_server

Weitere Infos

Die Config-Datei für Starbound kann mit folgendem Kommando geöffnet und editiert werden:

nano ~/Steam/SteamApps/common/Starbound/assets/default_configuration.config

Unterstützung

Sollte das Tutorial hilfreich gewesen sein und die Entscheidung für einen DigitalOcean-Account gefallen sein, dann wäre es toll wenn ihr dafür meine Links zu DigitalOcean verwendet.

Bildquelle: Starbound Webseite

Starten des Droplets

Für unseren OpenTTD-Server benötigen wir keinen sonderlich leistungsstarken Server. Ein 512MB-Ubuntu-13.10-Droplet reicht für den Anfang vollkommen aus. Dieses starten wir über das Backend von Digital-Ocean. Ist das Droplet erstmal gestartet, suchen wir uns die zugewiesene IP-Adresse raus und loggen uns mit

ssh root@111.111.111.111

ein. (111.111.111.111 bitte durch die korrekte IP des droplets ersetzen ;-D)

Droplet einrichten

Bevor wir mit der Einrichtung des OpenTTD-Servers beginnen können, müssen wir vorher ein paar Schritte durchführen.

Erstmal bringen wir die Software des Servers auf den neusten Stand. Dies erfolgt mit Hilfe von apt-get:

apt-get update
apt-get upgrade -y

Apt holt sich nun die neusten Versionen der installierten Software-Pakete und installiert diese für uns. Dank SSD und guter Verbindung bei DigitalOcean sollte dies innerhalb weniger Minuten erledigt sein.

Jetzt holen wir uns noch 2 Software-Pakete die wir später benötigen:

apt-get install unzip screen -y

Auch dies sollte nur eine Angelegenheit von Sekunden sein.

Damit unser OpenTTD-Server später nicht mit root-Rechten unterwegs ist, legen wir uns noch einen User an:

adduser openttd

Anmerkung: Der User muss nicht zwingend "openttd" heißen.

Installation des OpenTTD-Servers

Jetzt da unser Droplet fertig eingerichtet ist, besorgen wir uns die neuste Version von OpenTTD. Dies erfolgt über die Webseite von OpenTTD.

Mit Hilfe von wget übertragen wir das OpenTTD-Paket auf unser Droplet:

wget http://binaries.openttd.org/releases/1.3.3/openttd-1.3.3-linux-ubuntu-raring-amd64.deb

Wichtige Anmerkung: Unbedingt die Architektur eures Droplets beachten (32 oder 64bit)

Sobal das Paket auf unser Droplet geladen ist, installieren wir dies mit Hilfe von:

dpkg -i openttd-1.3.3-linux-ubuntu-raring-amd64.deb

Dies wird jedoch wegen fehlender Abhängigkeiten nicht funktionieren. Kein Problem - denn wir lösen dies umgehend mit Hilfe von:

apt-get -f install -y

Und schon ist OpenTTD installiert.

Einrichten des OpenTTD-Servers

Um mit der Einrichtung der Server-Software für OpenTTD fortzufahren, loggen wir uns aus (exit) und erneut mit unserem openttd-User ein:

ssh openttd@111.111.111.111

Anmerkung: Bitte hier den User ("openttd") abändern falls ein anderer Username verwendet wurde und auch wieder die korrekte IP verwenden ;-)

Nun starten wir unseren OpenTTD-Server indem wir

openttd -D

eingeben.

Aus irgendeinem unerfindlichen Grund meckert OpenTTD nun, dass kein Grafik-Paket installiert ist. Grafik-Paket .... auf einer Konsole für einen Server? O_O Nun gut, tun wir unserer kleinen "Transport-Diva" den gefallen und installieren wir das Grafik-Paket.

Grafik-Paket installieren

Als erstes besorgen wir uns über die Webseite die aktuelle Version des "OpenGFX" Grafik-Pakets. Die Webseite findet ihr hier.

Wieder mit der Hilfe von wget laden wir das Grafik-Paket auf unser Droplet:

wget http://bundles.openttdcoop.org/opengfx/releases/LATEST/opengfx-0.4.7.zip

Anmerkung: Es ist nicht zwingend notwendig dies mit wget zu erledigen, es ist auch möglich das Grafik-Paket mit Hilfe von SCP auf den Server zu kopieren. (Passende Software ist zB: Cyberduck für Mac oder WinSCP für Windows ).

Da wir ein ZIP-File bekommen müssen wir dies zuerst auspacken:

unzip opengfx-0.4.7.zip

Sobald es entzippt ist, kopieren wir die Dateien in den Arbeits-Ordner von OpenTTD:

mv ~/opengfx-0.4.7/* ~/.openttd/baseset/

Danach räumen wir noch mit

rm -rvf opengfx-0.4.7*

hinter uns auf.

OpenTTD-Server starten (jetzt aber wirklich)

Nun starten wir unsern Server erneut:

openttd -D

Nun sollte der Server starten und anhand der Voreinstellungen eine neue Karte generieren. Mit Hilfe des Spiel-Clients ist es nun möglich sich mit dem Server zu verbinden und mit Freunden und Verwandten OpenTTD zu genießen.

Eine Kleinigkeit gibt es aber noch. Falls wir unsere Konsole nun schließen ist der OpenTTD-Server auch weg. Um den OpenTTD-Server dauerhaft laufen zu lassen verwenden wir das Tool "screen". Uns so funktioniert es:

screen openttd -D

Und schon läuft unser Server. Mit CTRL + A + D können wir die Konsole nun verlassen.

Mit dem Kommando

screen -r

können wir uns wieder Zugriff auf die Admin-Konsole von OpenTTD verschaffen.

Weitere Einrichtung und Anpassungen

Um unseren Server anzupassen und zu gestalten bietet OpenTTD eine Vielfalt an Optionen innerhalb der Konfigurations-Datei. Diese ist im Heimat-Ordner unseres openttd-Users unter .openttd zu finden.

Alle möglichen Optionen und deren Bedeutung findet ihr in der OpenTTD-Wiki unter http://wiki.openttd.org/Openttd.cfg.

Unterstützung

Sollte das Tutorial hilfreich gewesen sein und die Entscheidung für einen DigitalOcean-Account gefallen sein dann wäre es toll wenn ihr dafür meine Links zu DigitalOcean verwendet.

Bildquelle: OpenTTD - eigener Screenshot

Diese kleine Anleitung beschreibt die Verwendung von Jekyll mit Hilfe von Git auf einem uberspace.de Account.

Ruby und Gems vorbereiten (uberspace)

Falls du auf deinem uberspace.de Account noch kein Ruby eingerichtet hast solltest du dies zuerst mal erledigen. Jekyll benötigt eine Ruby-Version von 1.9 oder höher.

Hier nun Schritt für Schritt die Anleitung wie dies erfolgt. (Für diese Schritte setze ich einen "jungfräulichen" uberspace-Account voraus)

[helga@helium ~]$ cat <<'__EOF__' >> ~/.bash_profile
export PATH=/package/host/localhost/ruby-2.0.0/bin:$PATH
export PATH=$HOME/.gem/ruby/2.0.0/bin:$PATH
__EOF__

[helga@helium ~]$ . ~/.bash_profile

Quelle

Damit ist auch schon Ruby auf eine für Jekyll passende Version gebracht. Nun müssen wir noch die Installation von eigenen einrichten. Dies erfolgt mit einer Zeile Shell-Befehl:

[helga@helium ~]$ echo "gem: --user-install --no-rdoc --no-ri" > ~/.gemrc

Quelle

Damit steht der Installation von Jekyll nichts mehr im Wege und wir erledigen dies mit

[helga@helium ~] gem install jekyll

Nach einer kurzen Wartezeit ist nun auch Jekyll für die spätere Verwendung installiert.

Jekyll auf dem lokalen System installieren

Hier wird es etwas schwierig für mich eine Anleitung anzubieten da es einfach zu viele unterschiedliche Systeme gibt auf denen Ruby und Jekyll laufen kann. Um dies trotzdem in einer vernünftigen Form anzubieten behelfe ich mich der alten Internet-Technik und zwar der Hyperlinks :-D

Hier nun ein paar Links zu entsprechenden Anleitungen:

Git auf dem lokalen System installieren

Falls dein lokales System noch über keine Git-Installation verfügt solltest du dies noch schnell nachholen. Wie auch bereits bei dem Punkt darüber behelfe ich hier mir mit einer Verlinkung :-)

Jekyll auf dem lokalen System vorbereiten

Ist nun Jekyll und Git auf dem eigenen System installiert können wir mit der Erstellung unseres ersten Jekyll-Blogs fortfahren. Hier die wichtigsten Basics um ein Jekyll-Blog am eigenen System zu erstellen:

Mit folgendem Shell-Befehl wechseln wir in das Verzeichnis in das unser neues Jekyll-Blog abgelegt werden soll:

[user@lokal ~] cd /dort/wo/das/blog/abgelegt/werden/soll

Jetzt erstellen wir ein Jekyll-Blog (für blogname setzt bitte den gewünschten Namen des Blogs ein):

[user@lokal ~] jekyll new blogname

Mit Hilfe von cd wechseln wir jetzt in den neu generierten Ordner (hier bitte den oben verwendeten Blognamen einsetzen.

[user@lokal ~] cd blogname

In diesem Ordner finden sich nun einige Dateien und Ordner die Jekyll für uns angelegt hat.

  • _config.yml
  • _layouts
  • _posts
  • css
  • index.html

Welche Aufgaben diese Dateien und Ordner haben entnimmst du bitte der Jekyll-Dokumentation.

Nun kommen wir zurück zu Git. Um unser Jekyll-Blog später mit Hilfe von Git versionieren und übertragen zu können verwandeln wir unseren Jekyll-Blog-Ordner in ein lokales Git-Repository und machen unseren ersten Commit.

[user@lokal ~] git init
[user@lokal ~] git add .
[user@lokal ~] git commit -m "erster Commit"

Falls du mit Git noch nicht ganz sattelfest bist schau bitte hier vorbei. Dort kannst du die Grundlagen von Git innerhalb weniger Minuten erlernen.

Mit den letzten 3 Kommandos ist die Arbeit auf unserem lokalen System nahezu erledigt. Jetzt müssen wir aber erstmal auf unserem uberspace-Account noch ein paar Dinge erledigen.

Git-Repository auf dem uberspace-Account vorbereiten

Für unser neues Jekyll-Blog brauchen wir jetzt auf dem uberspace-Account eine Gegenstelle sprich ein Git-Repository. Dazu wechseln wir mit Hilfe von

[helga@helium ~] cd ~

in unser Home-Verzeichnis und legen dort durch

[helga@helium ~] mkdir repos

ein neues Verzeichnis an in dem wir all unsere Git-Repositories aufgewahren. Jetzt brauchen wir noch ein Verzeichnis, dass gleichzeitig als Git-Repository dienen soll. Dies erledigen wir mit Hilfe folgender Shell-Befehle:

[helga@helium ~] mkdir blogname.git
[helga@helium ~] cd blogname.git
[helga@helium ~] git init --bare

Für den Begriff blogname bitte wieder den vorher verwendeten Namen einsetzen. Durch das gerade abgesetzte Kommando git init --bare haben wir ein den leeren Ordner in ein Git-Repository verwandelt und darin befindet sich nun ein Ordner mit dem Namen hooks. Diesen Ordner öffnen wir nun mit einem einfachen

[helga@helium ~] cd hooks

Im hooks-Ordner angelangt erstellen wir dort eine Datei mit dem Titel post-receive und editieren diese zugleich. Die erfolgt mit folgenden Shell-Befehlen:

[helga@helium ~] touch post-receive
[helga@helium ~] nano post-receive

Nun haben wir den Nano-Editor vor und und fügen dort folgende Zeilen per Copy/Pase ein:

#!/bin/bash -l
GIT_REPO=$HOME/repos/blogname.git
TMP_GIT_CLONE=$HOME/tmp/git/blogname
PUBLIC_WWW=/var/www/virtual/$USER/html

git clone $GIT_REPO $TMP_GIT_CLONE
jekyll build --source $TMP_GIT_CLONE --destination $PUBLIC_WWW
rm -Rf $TMP_GIT_CLONE
exit

Bitte ersetze wieder blogname mit deinem vorher verwendeten Begriff. Mit dem Tastenkürzel STRG + O und einem anschließenden beherzten Druck auf die Entertaste speichern wir unser neu erstelltest Script ab und laden wieder auf der Kommando-Zeile.

Jetzt müssen wir das neu erstellte Script nur mehr ausführbar machen, dies erledigen wir mit Hilfe von

chmod +x post-receive

Somit sind nun alle Schritte auf der Seite unseres uberspace.de Accounts erledigt und wir kehren wieder zurück zu unserem Arbeitsrechner.

uberspace-Account als Remote eintragen und pushen

Damit unsere Blog-Einträge und Änderungen auch auf dem Server landen müssen wir unsere frisch erstellte Git-Gegenstelle noch bei unserem lokalen Git-Repository als "Remote" hinterlegen.

Dazu wechseln wir in das Verzeichnis unseres zuvor lokal erstellten Jekyll-Blogs und geben dort folgendes in die Kommando-Zeile ein:

git remote add uberspace helga@helium.uberspace.de:repos/blogname.git

Bitte ersetze hier hela@helium.uberspace.de mit deinen korrekten uberspace.de Zugangsdaten und blogname wieder durch den zuvor verwendeten Begriff

Nun ist der Zeitpunkt gekommen und wir starten die Veröffentlichung unseres Jekyll-Blogs mit Hilfe von Git. Dies erfolgt mit dem Kommando

git push uberspace master

Mit Hilfe dieses Kommandos werden alle Änderungen am Jekyll-Blog zum uberspace-Account übertragen und dort durch das post-receive-Script verarbeitet. Ist diese Verarbeitung abgeschlossen sollte dein Jekyll-Blog online sein.

Fertig

Ich hoffe du hast alles verstanden und dein Jekyll-Blog ist nun online. Hast du noch Fragen dann poste Sie einfach als Kommentar und ich werde versuchen dir zu helfen.

Wenn du noch tiefer in die Thematik von Jekyll eintauchen möchtest hier ein paar interessante Links:

Bildquelle: Death to the Stock Photo

Relaunch

Kategorie: Allgemein Autor: Daniel bei G+

Endlich ist es soweit. Nach über einem Jahr mit keinen neuen Posts und keiner Weiterentwicklung hab ich mich dazu entschieden mein Blog wieder zu starten. Um die eigene Motivation zu stärken und alte Lasten aus den Anfängen meines Blogs abzuwerfen habe ich mich dazu entschieden komplett neu zu starten.

Alle alten Posts sind natürlich nicht verloren (ein paar gute sind ja doch dabei) sondern in ein statisches Archiv gewandert. Dieses Archiv ist unter http://old.wittistribune.com erreichbar.

Kein Wordpress, Ghost oder Ähnliches

Nun etwas zur Technik, ich habe mich bewusst gegen Wordpress, Ghost oder eine ähnliche Software entschieden und meine eigene kleine Blogsoftware gebastelt (Quellcode bei Github folgt sobald alle Features implementiert sind).

Warum kein Wordpress?

Beruflich habe ich bereits einige kleinere und größere Projekte umgesetzt und werde auch weitere Projekte damit umsetzen. Wordpress ist eine der beliebtesten und am weitesten entwickelte Blogging-Software auf dem Markt aber der Mensch brauch Abwechslung und auch ich brauche diese. Darum kein Wordpress bei meinem kleinen privaten Blog.

Weiters bin ich mit dem Plugin-System von Wordpress nicht ganz zufrieden. Aber das ist eine andere Geschichte.

Warum kein Ghost?

Dafür gibt es zwei Gründe:

  1. Ich kenne NodeJS aber mein Wissenstand darüber ist noch etwas zu gering um es produktiv einsetzen zu können. Ich kenne gerne die Software mit der ich arbeite und möchte zu 100% verstehen wie sie arbeitet. (vorausgesetzt der Quellcode ist verfügbar)

  2. Ich sehe nicht ein warum man keine Kickstarter-Aktion braucht um eine Blogging-Software zu entwickeln und schon gar nicht wenn man sich die ganzen Abhängigkeiten ansieht die bei der Installation von Ghost anfallen. Ich bin mit dieser Meinung nicht der einzige. Man muss sich nur mal Software wie Wardrobe ansehen. Dafür benötigte man auch kein Kickstarter. Persönlich würde ich interessieren ob ein einziger Entwickler der vorher erwähnten Abhängigkeiten eine Donation erhalten hat. Vermutlich nicht.

Warum was eigenes?

Ich entwickle sehr gerne Software und verbringe auch sehr gern sehr viel Zeit damit. Um meinen Horizont zu erweitern und meine Kenntnisse zu verbessern habe ich mich für diesen Weg entschieden.

Ausblick

Ich habe bereits einige Themen auf meiner Warteliste die ich noch in diesem Jahr behandeln möchte. Einige davon werden sich um meinen lieblingshoster uberspace.de in Verbindung mit Laravel 4 drehen. Weiters plane ich einige Resource-Posts für iOS und Laravel. Zu viel möchte ich aber noch nicht verraten.

Bildquelle: Death to the Stock Photo