» Linux - Marios Blog

Docker Image aus dem Reository laden

docker pull debian

1	docker pull debian

Docker Image starten

// -d läuft im Hintergrund
docker run -d dockerImageName

//durch "-i" (interactive) und "-t" (tty) können wir die Console des Docker Images steuern
docker run -i -t dockerImageName /bin/bash

1

2

3

4

5

// -d läuft im Hintergrund

docker run -d dockerImageName

//durch "-i" (interactive) und "-t" (tty) können wir die Console des Docker Images steuern

docker run -i -t dockerImageName /bin/bash

Ports mittels docker run

-p 8000:8888         Port LocalSystem:DockerContainer
-p port weiterleiten
-P alle ports für zb Kommunikation zw Containern

1

2

3

-p 8000:8888 Port LocalSystem:DockerContainer

-p port weiterleiten

-P alle ports für zb Kommunikation zw Containern

Daten des Hostsystems einbinden

-v /mein/ordner/im/host:/ordner/im/docker

1	-v /mein/ordner/im/host:/ordner/im/docker

Arbeiten mit Containern

Mit jeden docker run wird aus einem Image ein Container erstellt. Sollte dieser an der Konsole nachbearbeitet worden sein und ich beende diesen, kann ich den ihm mittels docker run nicht wieder starten, denn dann erstellt docker wieder einen neuen Container aus dessen Image.
Den veränderten Container kann ich mittels

docker container restart ContainerID

1	docker container restart ContainerID

starten. Eine Auflistung aller Container erhalte ich mittels

docker ps -a

1	docker ps -a

Wenn ich an die Console meines laufenden Containers möchte, kann ich diese über

docker exec -it ContainerID /bin/bash

1	docker exec -it ContainerID /bin/bash

erreichen.

Natürlich kann ich aus meinen modifizierten Container auch ein neues Image generieren. Dazu muss ich einfach meine Änderungen am Container in ein Image committen

docker commit -m "mein Kommentar" containerID neuerDockerImageName

1	docker commit -m "mein Kommentar" containerID neuerDockerImageName

Laufende Docker Instanzen anzeigen

docker ps

1

docker ps

Verfügbare Docker Images anzeigen

docker images

1	docker images

Laufende Docker Instanz beenden

docker stop ContainerID

1	docker stop ContainerID

Alle Docker Instanzen beenden

docker stop $(docker ps -a -q)

1	docker stop $(docker ps -a -q)

Alle Container löschen

docker rm $(docker ps -a -q)

1	docker rm $(docker ps -a -q)

Alle Images löschen

docker rmi $(docker images -q)

1	docker rmi $(docker images -q)

Unbenutzte Docker Daten löschen

docker system prune

1	docker system prune

Apache Weiterleitung auf Docker Container

Im Beispiel läuft über meine-domain.de/d-nginx ein Nginx Server

-- module aktivieren
a2enmod proxy
a2enmod proxy_http

<VirtualHost *:80>
...
<Location />
    Order allow,deny
    Allow from all
    Require all granted
  </Location>

 ProxyPass /d-nginx http://localhost:81/
 ProxyPassReverse /d-nginx http://localhost:81/
...
</VirtualHost>

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

-- module aktivieren

a2enmod proxy

a2enmod proxy_http

...

Order allow,deny

Allow from all

Require all granted

</Location>

ProxyPass /d-nginx http://localhost:81/

ProxyPassReverse /d-nginx http://localhost:81/

...

</VirtualHost>

Mittels sysv-rc können die Dienste in den entsprechenden Runlevels konfiguriert und eingesehen werden.

apt-get install sysv-rc-conf
<pre>

Manuell an der Console kann man zB. Mysql wie folgt automatisch starten
<pre>
sudo update-rc.d mysql defaults

1

2

3

4

5

6

apt-get install sysv-rc-conf

<pre>

Manuell an der Console kann man zB. Mysql wie folgt automatisch starten

<pre>

sudo update-rc.d mysql defaults

Einen Ordner per ssh mounten

// Verzeichnis anlegen in das ich meinen Ordner mounten möchte
mkdir /home/user/localMountFolder
sshfs <Username>@<Adresse des entfernten Servers>:/entferntes/Verzeichnis localMountFolder

// aushängen
fusermount -u /home/user/localMountFolder

1

2

3

4

5

6

// Verzeichnis anlegen in das ich meinen Ordner mounten möchte

mkdir /home/user/localMountFolder

sshfs <Username>@<Adresse des entfernten Servers>:/entferntes/Verzeichnis localMountFolder

// aushängen

fusermount -u /home/user/localMountFolder

Wenn das Passwort vergessen wurde, kann man sich mittels Live CD einen Zugang verschaffen.
Nachdem das System gebootet wurde sind folgende Schritte in der Shell notwendig:

# wir machen uns ersteinmal zum root user
sudo -i

# nun mounten wir das entsprechende Laufwerk
mount /dev/sda1 /mnt/

# jetzt ändern wir das root des Systems
chroot /mnt/ /bin/bash

# jetzt bekommt unser Benutzer ein neues Passwort
passwd MeinBenutzername

1

2

3

4

5

6

7

8

9

10

11

# wir machen uns ersteinmal zum root user

sudo -i

# nun mounten wir das entsprechende Laufwerk

mount /dev/sda1 /mnt/

# jetzt ändern wir das root des Systems

chroot /mnt/ /bin/bash

# jetzt bekommt unser Benutzer ein neues Passwort

passwd MeinBenutzername

Hier entsteht eine kleine Ansammlung an Befehlen.

Installierte Linux Distribution ermitteln:

uname -a
lsb_release -a 
cat /etc/issue

1

2

3

uname -a

lsb_release -a

cat /etc/issue

Spracheinstellungen jetzt setzten

export LC_ALL=en_US.utf8

1	export LC_ALL=en_US.utf8

Consolenhistory

history
history -c // History löschen
history -d NNN  // einen Historyeintrag löschen
 befehl  // Vorangestelltes Leerzeichen -> erscheint nicht in History

1

2

3

4

history

history -c // History löschen

history -d NNN // einen Historyeintrag löschen

befehl // Vorangestelltes Leerzeichen -> erscheint nicht in History

Speicherauslastung
Ordnergrößen

du -h --max-depth=1

1	du -h --max-depth=1

Festplattenbelegung

df -h

1

df -h

Zertifikat einer url prüfen:

curl --insecure -v https://www.meineDomain.de 2>&1 | awk '/^\* SSL/ { ssl=1 } /^\*/ { if (ssl) print }'

1	curl --insecure -v https://www.meineDomain.de 2>&1 \| awk '/^\* SSL/ { ssl=1 } /^\*/ { if (ssl) print }'

oder

openssl s_client -showcerts -connect www.meineDomain.de:443

1	openssl s_client -showcerts -connect www.meineDomain.de:443

Um die Debug-Ausgabe eines Bash-Scriptes zu aktivieren, reicht es direkt in den Script

set -x

1

set -x

einzufügen. Ab diesen Moment wird die Debug-Ausgabe aktiviert.

Deaktivieren kann man diese Ausgabe genauso einfach

set +x

1

set +x

Sollte es Zeichensatzprobleme bei SSH Verbindungen geben, so ĺiegt dies an unterschiedlich gesetzten Zeichensätzen.
Das Problem kann behoben werden, wenn der auf dem Zielsystem gesetzte Zeichensatz auch auf dem Lokalen System gesetzt wird.

So ermittelt man den gesetzten Zeichensatz:

locale

1

locale

Und so kann ich den Zeichensatz setzen:

export LANG=de_DE.UTF-8

1	export LANG=de_DE.UTF-8

Oft ist es hilfreich ein Swapfile zu nutzen.
Man kann dies relativ einfach anlegen.

Als erstes erstellen wir eine Datei mit einer festen Größe für das Swapfile

bs = steht für Blocksize
count = Anzahl der Blöcke
Größe der Datei = bs*count

dd if=/dev/zero of=/pfad/zum/swapfile bs=1M count=1024

1	dd if=/dev/zero of=/pfad/zum/swapfile bs=1M count=1024

Wir bereiten die Datei für den Einsatz als Swap vor. – Das gilt auch für Swap Partitionen

mkswap /pfad/zum/swapfile

1	mkswap /pfad/zum/swapfile

Nun aktivieren wir den neuen Swap-Speicher

swapon /pfad/zum/swapfile

1	swapon /pfad/zum/swapfile

Damit das Swapfile automatisch beim reboot geladen wird, konfigurieren wir noch die /etc/fstab

/pfad/zum/swapfile swap swap defaults 0 0

1	/pfad/zum/swapfile swap swap defaults 0 0

Sollte ein altes Swapfile, was nun nicht mehr benötigt wird, vorhanden sein, dann kann man dieses deaktivieren und abschließend löschen.
Der alte Eintrag in der fstab muss natürlich auch entfernt werden.

swapoff /pfad/zum/alten/swapfile

1	swapoff /pfad/zum/alten/swapfile

Jedes Zertifikat besteht aus einem privaten und einen öffentlichen Key.
Die Dateinamen sollten so gewählt werden, das diese nachher durch diesen zugeordnet werden können.

Wir erstellen den privaten Key

openssl genrsa -out /pad/cert.key 1024

1	openssl genrsa -out /pad/cert.key 1024

Anschließend erstellen wir aus dem privaten Key eine Zertifizierungsanforderungsdatei (csr)

openssl req -new -key /pad/cert.key -out /pad/cert.csr

1	openssl req -new -key /pad/cert.key -out /pad/cert.csr

Für die Erstellung der csr-Datei wird man nun gebeten einige Informationen auszufüllen.
Besonders wichtig ist die Angabe von:

Common Name (e.g. server FQDN or YOUR name) []:

1	Common Name (e.g. server FQDN or YOUR name) []:

Hier muss der komplette Domainname eingegeben werden, für den das Zertifikat gültig ist. Wenn die Domain mit www erreichbar ist, dann muss hier auch www im Domainnamen aufgeführt sein!
Für Testserver reicht hier auch ein localhost.

Nun erstellen wir das Zertifikat, die Gültigkeitsdauer gibt die Angabe in Tagen an.

openssl x509 -req -days 3650 -in /pad/cert.csr -signkey /pad/cert.key -out /pad/cert.crt

1	openssl x509 -req -days 3650 -in /pad/cert.csr -signkey /pad/cert.key -out /pad/cert.crt

Wer Composer auf seinem Server nutzen möchte, kann ihn wie folgt einrichten:

curl -sS https://getcomposer.org/installer | php
mv composer.phar /usr/local/bin/composer

1 2	curl -sS https://getcomposer.org/installer \| php mv composer.phar /usr/local/bin/composer

Nun sollte Composer auf dem Server verfügbar sein.

Als nächstes richten wir uns ein Projektordner ein, in diesen erstellen wir die Datei composer.json mit folgenden Beispielinhalt:

{
  "name": "Name meiner Anwendung",
  "description": "Beschreibung",
  "bin-dir": "bin",
  "license": "MIT",
  "require": {
    "monolog/monolog": "1.*",
    "symfony/yaml": "3.0.*@dev",
    "smarty/smarty": "~3.1"
  },
  "autoload": {
    "psr-4": {
      "Name\\Namespace\\": "src/folder"
    }
  },
  "require-dev": {
    "phpdocumentor/phpdocumentor": "dev-master",
    "phpunit/phpunit": "^4.6"
  }
}

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

{

"name": "Name meiner Anwendung",

"description": "Beschreibung",

"bin-dir": "bin",

"license": "MIT",

"require": {

"monolog/monolog": "1.*",

"symfony/yaml": "3.0.*@dev",

"smarty/smarty": "~3.1"

},

"autoload": {

"psr-4": {

"Name\\Namespace\\": "src/folder"

}

},

"require-dev": {

"phpdocumentor/phpdocumentor": "dev-master",

"phpunit/phpunit": "^4.6"

}

Mit einen einfachen

Composer install

1	Composer install

installieren wir nun unserer konfigurierten Pakete.

Unter Umständen können wir nicht alles aus den Repositories von GitHub laden. Dazu benötigen wir einen API Token.
Erzeugen können wir diesen, indem wir uns einen GitHub Account einrichten. Nun können wir dort unter „Settings->Personal access tokens->Generate new Token“ einen neuen Token erstellen.
Diesen Token geben wir bei Aufforderung durch den Composer an der Shell einfach ein, oder wir Konfigurieren Composer so, das dieser den Token schon kennt.

composer config github-oauth.github.com GITHUB-TOKEN

1	composer config github-oauth.github.com GITHUB-TOKEN

Hin und wieder möchte man ein Verzeichnis Online verfügbar machen, welches nicht für jedermann gedacht ist.
Da man dazu nun nicht unbedingt eine Authentifizierungs-Logik schreiben möchte kann man dies auch per .htacces Datei erledigen.

In der Regel kann dies jedes Webhosting-Paket, meist kann man dies dann irgendwo im Kundenbereich konfigurieren.

Hat man einen eigenen Server zu Verfügung, so kann man einfach eine Passwortdatei und eine .htaccess Datei im entsprechenden Verzeichnis anlegen.

Die Passwortdatei erstellen wir wie folgt

htpasswd -c %Datei% %User%

1	htpasswd -c %Datei% %User%

Im folgenden Dialog kann das Passwort eingegeben werden.

AuthType Basic
AuthName "Geschützter Bereich"
AuthUserFile %PasswortDatei%
require user %User%

1

2

3

4

AuthType Basic

AuthName "Geschützter Bereich"

AuthUserFile %PasswortDatei%

require user %User%

Sollten die verwendeten SSL Zertifikat des Apache eine Passphrase haben, so kommt es zu ungewollten Fehlern beim Neustart des Servers. Da sie Passphrase beim starten nicht eingegeben werden kann.

Am besten legen wir uns erst einmal eine Sicherungskopie des Zertifikates an:

cp %mein.key% %mein.key.bkp%

1	cp %mein.key% %mein.key.bkp%

Nun können wir die Passphrase entfernen, dazu müssen wir diese kennen, da sie im Prozess abgefragt wird.

openssl rsa -in %mein.key% -out %mein.key%

1	openssl rsa -in %mein.key% -out %mein.key%

Anschließend starten wir den Apache neu und können unsere SSL Verbindung testen.

apache2ct

1

apache2ct

Unter Umständen ist es nötig, einen Rsync-Aufruf mit einer Portangabe zu initiieren.

rsync -av -e 'ssh -p 1025' /pfad %User%@%Server%:/pfad/

1	rsync -av -e 'ssh -p 1025' /pfad %User%@%Server%:/pfad/

Wer eine Webseite betreibt, die er mittels get-text multilingual aufbaut, der muss auch seine Linux Systemsprachen anpassen.

Zum einen benötigen wir für die Übersetzungen gettext, dies kann man per apt-get installieren.

apt-get install gettext

1	apt-get install gettext

Sprachen die man zur Verfügung stellen möchte, benötigt man dann auch als Systemsprache, diese kann man jederzeit nachkonfigurieren.

dpkg-reconfigure locales

1	dpkg-reconfigure locales

Hier gibt es eine kleine Ansammlung an nützlichen aufrufen rund um die Paketverwaltung.

Auflistung aller installierten Pakete:

dpkg -l

1

dpkg -l

Wenn man eine Funktion nicht zur Verfügung hat kann man sein Glück so versuchen:

apt-cache search %Funktion%

1	apt-cache search %Funktion%

Für die Kommunikation zweier Linux Server, z.B. ein Datenbackup mittels rsync, muss man sich zwangsläufig per SSH anmelden.

Hierfür empfiehlt es sich, einen Zugang per Zertifikat zu wählen. Zum einen ist es sehr komfortabel, zum anderen ist es auch viel sicherer. Zumindest wenn man in einen weiteren Schritt den Zugang per Passwort unterbindet bzw. ein sehr sicheres Passwort wählt.

Damit wir uns auf dem entfernten Server einloggen können, benötigen wir dort einen Benutzer der sich per SSH Anmelden darf. Dazu empfehle ich den Server wie folgt zu konfigurieren: Linux SSH Root Zugang verbieten.

Wenn diese Voraussetzung erfüllt sind, kann ich mich wie folgt verbinden.

ssh %EntfernterBenutzer%@%EntfernterServer%

1	ssh %EntfernterBenutzer%@%EntfernterServer%

Allerdings wird jetzt noch eine Passwort abgefragt.

Damit wir zukünftig kein Passwort mehr angeben müssen, erstellen wir ein Schlüsselpaar.

ssh-keygen

1	ssh-keygen

Nun müssen wir den Public Key auf den entfernten Server übertragen.

ssh-copy-id -i ~/.ssh/id_rsa.pub %EntfernterBenutzer%@%EntfernterServer%

# Sollte SSH nicht auf dem Standardport laufen, kann man die diesen wie folgt mit angeben
ssh-copy-id -i ~/.ssh/id_rsa.pub '-p %SSHPort% %EntfernterBenutzer%@%EntfernterServer%'

# Wenn ssh-copy-id nicht zur Verfügung steht, kann der Schlüssel auch per cat übertragen werden
cat ~/.ssh/*.pub | ssh %EntfernterBenutzer%@%EntfernterServer% 'cat>>.ssh/authorized_keys'

1

2

3

4

5

6

7

ssh-copy-id -i ~/.ssh/id_rsa.pub %EntfernterBenutzer%@%EntfernterServer%

# Sollte SSH nicht auf dem Standardport laufen, kann man die diesen wie folgt mit angeben

ssh-copy-id -i ~/.ssh/id_rsa.pub '-p %SSHPort% %EntfernterBenutzer%@%EntfernterServer%'

# Wenn ssh-copy-id nicht zur Verfügung steht, kann der Schlüssel auch per cat übertragen werden

cat ~/.ssh/*.pub | ssh %EntfernterBenutzer%@%EntfernterServer% 'cat>>.ssh/authorized_keys'

Nun können wir den passwortlosen Zugriff testen

ssh %EntfernterBenutzer%@%EntfernterServer%

1	ssh %EntfernterBenutzer%@%EntfernterServer%

Sollte es Probleme geben, können wir uns wie folgt Details zum Verbindungsaufbau anzeigen lassen.

ssh -v %EntfernterBenutzer%@%EntfernterServer%

1	ssh -v %EntfernterBenutzer%@%EntfernterServer%

Das alte Passwort kann man auf dem Zielserver wie folgt deaktivieren

passwd %EntfernterBenutzer% -d

1	passwd %EntfernterBenutzer% -d

In aller Regel erhaltet ihr von eurem Hoster ein vorgefertigtes Image. In meinen Fall ist es ein Debian 7.

Damit nicht jeder Zugang zu eurem Server erlangt, solltet ihr euch ausschließlich mit einem eigenen Benutzer per ssh anmelden. Eine Anmeldung mit dem Root-Benutzer solltet ihr verbieten. Die Root-Rechte erlangen wir in Zukunft erst nach einem Ummelden des Benutzers.

Als erstes installieren wir Sudo.

apt-get install sudo

1	apt-get install sudo

Nun legen wir eine Gruppe an, in der alle Benutzer Mitglied werden, welche sich am Server anmelden können.

addgroup ssh-users

1	addgroup ssh-users

Anschließend erstellen wir unseren Benutzer.

adduser %USERNAME%

1	adduser %USERNAME%

Damit sich dieser per ssh anmelden kann, müssen wir den neuen Benutzer der Gruppe ssh-users hinzufügen.

adduser %USERNAME% ssh-users

1	adduser %USERNAME% ssh-users

Um später Root-Rechte zu erlangen benötigt dieser auch eine Mitglidschaft in der Gruppe sudo.

adduser %USERNAME% sudo

1	adduser %USERNAME% sudo

Jetzt konfigurieren wir ssh noch so, dass die Mitglieder der Gruppe ssh-users sich per ssh anmelden können.

vi /etc/ssh/sshd_config
# Zeile hinzufügen:
AllowGroups ssh-users

1

2

3

vi /etc/ssh/sshd_config

# Zeile hinzufügen:

AllowGroups ssh-users

Nun starten wir den ssh-Dienst neu

/etc/init.d/ssh restart

1	/etc/init.d/ssh restart

Nun können wir mit einer weiteren putty-Session schon einmal den Loginvorgang des neues Users prüfen.
Nach dem erfolgreichen Login melden wir uns wie folgt zum root-Benutzer um:

sudo -i

1

sudo -i

Wenn das alles funktioniert hat, dann verbieten wir den direkten ssh-Zugang des Root Benutzers.
Dazu öffnen wir wieder die ssh-config und passen folgende Zeile an

vi /etc/ssh/sshd_config
# Root Login verbieten
PermitRootLogin yes

1

2

3

vi /etc/ssh/sshd_config

# Root Login verbieten

PermitRootLogin yes

Auch nach dieser Änderung starten wir den ssh Dienst neu.

/etc/init.d/ssh restart

1	/etc/init.d/ssh restart

Nun ist es nicht mehr möglich sich als Root-Benutzer per ssh an der Konsole anzumelden.

Suche

Docker Shortcuts

Arbeiten mit Containern

Apache Weiterleitung auf Docker Container

Dienste, Autostart und Runlevels

Ordner per ssh mounten

Linux Passwort vergessen

Linux Befehle

Bash – Debuggen

Schriftsatzeinstellungen – ssh und mc

Swap File anlegen

Erstellen einen Server Zertifikates

Composer Quick Guide

Einfacher Passwortschutz per .htaccess Datei

So entfernt man die Passphrase eines Zertifikates

rsync mit Portangabe nutzen

Linux Spracheinstellungen

Linux Pakete

Linux passwortloser SSH Login per Zertifikat

Linux SSH Root Zugang verbieten