Löschen

docker-compose rm

Auflisten

docker-compose ps

Starten

docker-compose up

Starten als Dienst und neu bauen

docker-compose up -d --build

Beenden

docker-compose down

In Container springen; der Servicename ist der Name der Containerdefinition im docker-compose.yaml File

docker-compose exec Servicename bash 

.env
Variablen können in ein .env File parallel zur docker-compose.yml angelegt werden
Der Inhalt muss wie folgt aufgebaut werden

VAR_NAME=value
VAR_NAME_2=value2

Innerhalb der docker-compose.yml kann wie untenstehend darauf zugegriffen werden.

version: '3'
services:
  webtools:
    user: ${VAR_NAME}

Um innerhalb des Dockerfiles auf die Variable zuzugreifen, muss diese in den Args Block der Docker-compose.yml

version: '3'
services:
  webtools:
    environment:
      user: ${VAR_NAME}

Dann kann die Variable im Dockerfile verwendet werden

ARG VAR_NAME
RUN echo $VAR_NAME

Letzencrypt Zertifikat erstellen

automatisch per cron

./letsencrypt-auto certonly --renew-by-default --standalone --rsa-key-size 4096 -d domain.de -d www.domain.de

manuell, auf einen anderen System

./letsencrypt-auto certonly -a manual --rsa-key-size 4096 -d domain.de -d www.domain.de

Nun dem Dialog folgen. Es muss noch eine html Datei auf dem Webserver erstellt werden.
Abschließend kann man die Zertifikate per scp übertragen

scp /mein/Pfad/zum/Cert/* user@server:

Mobile Geräte arbeiten mit unterschiedlichen Bilschirmauflösungen, damit aber Anwendungen und auch Webseiten auf allen Geräten unabhängig davon dargestellt werden, arbeitet zB der Browser nicht direkt mit diesen Auflösungen.

Als Beispiel zur Verdeutlichung nutzen ich ein
Samsung Galaxy S6 5,1 Zoll mit einer Auflösung von 1440px * 2560px, und ein
Samsung Galaxy Note 4 5,7 Zoll mit einer Auflösung von 1440px * 2560px, und einen
FullHD Monitor 21 Zoll mit einer Auflösung von 1980px * 1080px.

In unserer Webanwendung nutzen wir folgendes css mit zwei MediaQueries.

body {
            width: 100%;
            height: 100%;
            background-color: gray;
        }

        @media screen and (max-width: 1200px) {
            body {
                background-color: red;
            }
        }

        @media screen and (max-width: 450px) {
            body {
                background-color: yellow;
            }
        }

        @media screen and (max-width: 350px) {
            body {
                background-color: green;
            }
        }

Der Hintergrund wird auf grau gesetzt, wenn der Bildschirm kleiner wird, wird der Hintergrund bei <= 1200px rot und bei <= 450px gelb und bei <= 350px grün eingefärbt. Wie sieht nun die Darstellung auf den verschiedenen Geräten aus?
Die Smartphones halten wir dabei im Querformat.

Das Verhalten des Monitors:
Bei der Darstellung dieses Codes im Browser wird das Browserfenster in meinen Monitor grau sein, verkleinere ich es wird es erst einmal rot und bei weiterer Verkleinerung grün.

Das Verhalten der Smartphones, Querformat:
Obwohl wir bei den Smartphones die selbe Displayauflösung haben, erhalten diese sich dennoch anders:
Galaxy S6 – der Browser zeigt ein grünes Bild
Galaxy Note 4 – der Browser zeigt ein gelbes Bild

Warum ist das so?
Hier kommt die Pixeldichte ins Spiel

ldpi (120dpi) = Faktor 0.75
mdpi (160dpi) = Faktor 1.0
HDpi (240dpi) = Faktor 1.5
xhdpi (320dpi) = Faktor 2.0
xxhdpi (480dpi) = Faktor 3.0
xxxhdpi (640dpi) = Faktor 4.0

Das Galaxy S6 hat eine Pixeldichte vom Faktor 4.0 das ergibt einen Bildschirmbreite im Querformat mit der der Browser arbeitet von 640dp = 2560px/4.
Beim Galaxy Note 4 ist die Pixeldichte etwas kleiner, nämlich 3.0, das ergibt dann
480dp = 2560px/4.
Der Browser interpretiert ein dp als ein px.

dp ist eine abstrakte Einheit, sie varieiert nach der Pixeldichte.
Eine Linie mit einer Höhe von einen Pixel, wird auf einen Display mit 160dpi tatsächlich 1 Pixel hoch sein, auf einen Display mit 320dpi wird diese tatsächlich 2 Pixel hoch sein.
Der Browser jedoch hat nur die Anweisung eine Linie von 1 Pixel zu zeichen.

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

apt-get install sysv-rc-conf

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

                

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

svn switch des Repositories

svn switch Pfad/neuer/Branch
svn switch --relocate pfad/from/repository path/to/repository

svn gelöschte Dateien als gelöscht markieren

svn status | grep '^!' | awk '{print $2}' | xargs svn delete

svn kopieren – zB neuer Branch oder Tag

svn copy file:///pfad/zum/svn-projekt/branches/1.0 file:///pfad/zum/svn-projekt/branches/2.0 -m "mein Kommentar"

Eine gelöschte Datei aus dem Repository wiederherstellen

svn copy protokoll://repository/pfad/zur/datei@1097 dateiname

Branch von Revision erzeugen

svn copy -rREVNUMBER protokoll://repository/pfad/From protokoll://repository/pfad/To

Es gibt verschiedene Möglichkeiten einen Wert aus einem Select in eine Variable zu speichern.
Dennoch gibt es unterschiedliche Ergebnisse.

SELECT INTO

SELECT ID INTO @MeineID FROM Table WHERE Short = "MeinName";

Ein großer Nachteil von SELECT INTO ist, die Variable wird nur gesetzt, wenn das SELECT einen return Wert hat.
Wurde die Variable bereits vorab gesetzt und in meiner SELECT INTO Query es gab keinen Return Wert, dann bleibt die Variable auf dem alten Wert. Das kann schwerwiegende Folgen für weitere Operationen haben.

Deshalb empfinde ich es besser SET zu verwenden.

SET @MeineID = (SELECT ID FROM Table WHERE Name = "MeinName");

Hier wird die Variable immer gesetzt, ist meine Query erfolglos, ist der Wert null. Egal welchen Wert sie vorher hatte.

Hier entsteht eine kleine Ansammlung an Befehlen.

Installierte Linux Distribution ermitteln:

uname -a
lsb_release -a 
cat /etc/issue 

Spracheinstellungen jetzt setzten

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

Speicherauslastung
Ordnergrößen

du -h --max-depth=1

Festplattenbelegung

df -h

Zertifikat einer url prüfen:

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

Welche Anwendung läuft auf Port xyz

netstat -tanp | grep [Portnummer]

                

Mit dem Mail Kommando kann man eine Mail vom Terminal aus zu senden

mail mein@empfaenger.de

Danach den Betreff eingeben, dies mit Enter bestätigen.
Nun kann noch der Text eingegeben werden.
Den Dialog beendet man abschließend mit

. Enter

Exportieren
Einzelne MySQL Datenbank exportieren

mysqldump -u username -p database_name > dump.sql

Die Struktur einer MySQL Datenbank exportieren

mysqldump -u username -p --no-data database_name > dump.sql

Die Daten aus einer MySQL Datenbank exportieren

mysqldump -u username -p --no-create-info database_name > dump.sql

Mehrere MySQL Datenbanken exportieren

mysqldump -u username -p --databases db_name1 [db_name2 ...] > dump.sql

Alle Mysql Datenbanken in eine Datei exportieren

mysqldump -u username -p --all-databases --skip-lock-tables > alldatabases.sql

Importieren

MySQL Datenbank importieren

mysql -u username -p -D MeineDB < database.sql

Eine Datenbank aus der Datei "alldatabases.sql" importieren

mysql -u username -p --one-database destdbname < alldatabases.sql

Sonstiges
Fehler übergehen -f force

mysql -f ...

Einen Teil eines Strings suchen und ersetzen:

UPDATE MeineTabelle SET MeinFeld = REPLACE(MeinFeld, 'suchstring', 'replacestring')

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

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

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) []: 

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

Um unseren Server mit https auszustatten benötigen wir ein Zertifikat, dieses bekommen wir zB. unserem Hoster oder einem Anbieter wie zB. StartSSL.

Wenn es sich um einen Testserver handelt, kann man sich auch selbst ein Zertifikat erstellen, allerdings wird dieses von den Internetbrowsern dann bemängelt.

Nun richten wir dieses Zertifikat in unserem Apache ein.

Als erstes stellen wir sicher das das SSL Modul aktiviert ist.

Anschließend prüfen wir, ob der Webserver auch auf dem Port 443 arbeitet, dazu muss folgender Eintrag in der ports.conf aktiviert sein.

vi /etc/apache2/ports.conf

    Listen 443

Nun bearbeiten wir noch unsere Konfiguration der Domain, die mit SSL arbeiten soll.

Alle aktivierten Konfigurationen findet man im Verzeichnis sites-enabled. Wir editieren hier die entsprechende, in unserem Fall die 000-default

vi /etc/apache2/sites-enabled/000-default

    DocumentRoot /Pfad/htdocs
    
        Options Indexes FollowSymLinks MultiViews
        AllowOverride All
        Order allow,deny
        allow from all
    
 
    SSLEngine on
    SSLCertificateKeyFile /Pfad/Zum/Zertifikat.key
    SSLCertificateFile /Pfad/Zum/Zertifikat.crt

Abschließend starten wir den Apache mit folgendem Befehl neu:

apache2ctl restart

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

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"
  }
}

Mit einen einfachen

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

Ihr habt einen WordPress Blog. Damit man individuelle Anpassungen wie Themes oder eigene Erweiterungen komfortabel einarbeiten kann, sollte man sich die WordPress Installation lokal verfügbar machen.

Dazu kopieren wir uns erst einmal die Datenbank und alle Daten des WordPress vom Server auf dem lokalen PC, idealerweise richtet man sich hier auch ein Versionssystem wie Git oder SVN ein.

Als erstes müssen wir die Verbindung zu Datenbank anpassen, diese steht in der wp-config.php.
Hier passen wir folgende Zeilen an:

define('DB_NAME', '%%%Name_der_Datenbank%%%');
define('DB_USER', '%%%Datenbankbenutzer%%%');
define('DB_PASSWORD', '%%%Passwort%%%');

Diese Datei dürfen wir nun natürlich nicht mehr auf dem Webserver kopieren, sonst ist dieser nicht mehr lauffähig.

Damit unser lokales WordPress nicht ständig auf die Online URLs verlinkt müssen wir eine kleine Anpassung durchführen.
Dazu gehen wir in der Datenbank in die Tabelle wp_options dort passen wir die Einträge siteurl und home auf unsere lokale Pfadangabe an.

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%

Im folgenden Dialog kann das Passwort eingegeben werden.

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%

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%

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

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/

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

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

dpkg-reconfigure locales 

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

Auflistung aller installierten Pakete:

dpkg -l

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

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%

Allerdings wird jetzt noch eine Passwort abgefragt.

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

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'

Nun können wir den passwortlosen Zugriff testen

ssh %EntfernterBenutzer%@%EntfernterServer%

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

ssh -v %EntfernterBenutzer%@%EntfernterServer%

Das alte Passwort kann man auf dem Zielserver wie folgt deaktivieren

passwd %EntfernterBenutzer% -d