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.

Daten backupen

    JSON.stringify(localStorage)

Daten wiederherstellen

    Object.keys(objectdata).forEach(function(key) { 
        localStorage.setItem(key, objectdata[key]);
    }

Wir haben ein Element mit einen Außenabstand. Nun möchte ich ein Element in diesen Element (zB Headergrafik) aber relativ auf die komplette Bildschirmbreite setzen.
Das ganze geht ganz einfach, man muss nur die Einheit „vw“ statt „%“ verwenden.

vw: view width
vh: view height

.fullSize {
    position: relative;
    width: 100vw;
    // Korrektur des linken randes
    left: -15px;
}

Einrichtung

Für die Entwicklung von Angular benötigen wir node.js und npm.
Wenn dies in den entsprechenden Versionen vorhanden ist installieren wir uns angular.

npm install -g @angular/cli 

Das erste Projekt

Nun starten wir unser Projekt, auch dies geht einfach über die Konsole.

-- projekt anlegen
ng new my-test 
-- projekt starten
cd my-test/ 
ng serve --open 

Anlegen von Komonenten

Einzelne Komponenten können auch über die Konsole erstellt werden, das ist auch sehr sinnvoll, da wir uns so die händischen „includes“ sparen.

-- neue componente anlegen 
-- ng generate component name 
ng g c login

Routing

Wahrscheinlich benötigt die Anwendung auch ein Routing, hiefür bietet sich des RouterModule an.
Auch das ist schnell erledigt.

In der app.module einen Array mit Routen definieren, die Componenten müssen natürlich vorher definiert werden.

var routes = [
    {
        path: "",
        component: HomeComponent,
    },
    {
        path: "login",
        component: LoginComponent,
    },
    {
        path: "home",
        component: HomeComponent
    },
    {
        path: "admin",
        component: AdminComponent
    },
    {
        path: '**',
        component: PageNotFoundComponent
    },
]

Im Bereich Imports müssen diese nun gesetzt werden

@NgModule ...
    imports: [
        ...
        RouterModule.forRoot(routes)
    ];

In der html Datei der App Componente muss nun noch die Ausgabe des Routings erfolgen.
Dafür genügt es an der Stelle wo der Content ausgegeben werden soll, die Directive router-outlet einzubinden.

geladen werden.

2 Wege Data Binding in Forms

Um das 2-Wege-Data-Binding in Formularen zu nutzen benötigen wir noch das FormsModule.
Auch dies setzen wir in der app.module.

@NgModule ...
    imports: [
        ...
        FormsModule
    ];

Die Verwendung im input tag des Forms sieht dann wie folgt aus:

Angular ohne NodeJS auf dem Produktivsystem einsetzen

Während sich für die Entwicklung der Angular App der Einsatz von

ng serve --open

durchaus lohnt, kann man die Anwendung für das Produktivsystem gebaut werden.

ng build

Rest mittels HttpClient

Es ist relativ einfach in einer Componente einen Rest Call abzusetzen.

  constructor(protected http: HttpClient) {
  }

  ngOnInit() {
      this.http.get('meineUrl').subscribe(data => {
          console.log(data);
      });
  }

Voraussetzung das dies funktioniert ist der Import des Modules „HttpClientModule“.
Dazu einfach in der app.module folgende Einträge setzen:

import {HttpClientModule} from '@angular/common/http';
....
@NgModule({
  declarations: [
    ...
  ],
  imports: [
    ....
    HttpClientModule,
    ....
  ],
})

Docker Image aus dem Reository laden

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

Ports mittels docker run

-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

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

starten. Eine Auflistung aller Container erhalte ich mittels

docker ps -a

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

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

Laufende Docker Instanzen anzeigen

docker ps

Verfügbare Docker Images anzeigen

docker images

Laufende Docker Instanz beenden

docker stop ContainerID

Alle Docker Instanzen beenden

docker stop $(docker ps -a -q)

Alle Container löschen

docker rm $(docker ps -a -q)

Alle Images löschen

docker rmi $(docker images -q)

Unbenutzte Docker Daten löschen

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


...

    Order allow,deny
    Allow from all
    Require all granted
  

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

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

                

Einen Ordner per ssh mounten

// Verzeichnis anlegen in das ich meinen Ordner mounten möchte
mkdir /home/user/localMountFolder
sshfs @:/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

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.

Wie kann ich eine Procedure debuggen?

Ich persönlich nutze dazu gern eine eigene Procedure die eine Tabelle beschreibt.

DELIMITER $$

DROP PROCEDURE IF EXISTS DEBUG_PROCEDURE;
CREATE PROCEDURE DEBUG_PROCEDURE (Identifier VARCHAR(255), Name VARCHAR(255), Value VARCHAR(255))
BEGIN

CREATE TABLE IF NOT EXISTS `TMP_DEBUG` (
	`id` INT(11) NOT NULL AUTO_INCREMENT,
	`identifier` VARCHAR(50) NULL DEFAULT NULL,
	`name` VARCHAR(50) NULL DEFAULT NULL,
	`value` VARCHAR(50) NULL DEFAULT NULL,
	`time` DATETIME NULL DEFAULT CURRENT_TIMESTAMP,
	PRIMARY KEY (`id`)
)
COLLATE='utf8_general_ci'
ENGINE=InnoDB
AUTO_INCREMENT=1;

INSERT INTO TMP_DEBUG (`identifier`, `name`, `value`) VALUES
(Identifier,  Name, Value);

END$$
DELIMITER ;

Nun kann ich in jeder Procedure mit CALL einen Debug Eintrag erzeugen.

CALL DEBUG_PROCEDURE("ProcedureName", "Name der Var", "Value");

Wie kann ich eine Prozedur in MySQL anlegen?

Eine Procedure kann dazu verwendet werden mehrere SQL Befehle anzustoßen.

Um eine Procedure anzulegen, kann ich diverse SQL Tools nutzen, oder sebst ein SQL zum Erstellen anlegen.
Wenn ich mich für das eigene sql entscheide muss ich für das CREATE Kommando einen eigenen Delimiter verwenden.
Warum? Der Delimiter dient dazu das Ende des Befehles für den SQL Server zu markieren. Da eine Procedure mehrere Kommandos enthält, welche mit dem Semikolon abgeschlossen werden, würde der Server es nach dem ersten Semikolon einen SQL Befehl erkennen und ausführen. Das wiederum würde einen Fehler erzeugen.
Um dies zu umgehen setze ich vor der Erstellung der Procedure meinen Delimiter auf zB $$ und am Ende wieder auf ;.

-- ich setze meinen Delimiter auf $$
DELIMITER $$

-- eventuell gibt es eine alte Version meiner Prozedure, daher lösche ich diese
DROP PROCEDURE IF EXISTS MY_FIRST_PROCEDURE;
-- nun erzeuge ich meine Procedure
CREATE PROCEDURE MY_FIRST_PROCEDURE (VariableA VARCHAR(255), VariableB VARCHAR(255))
BEGIN
    -- hier kann nun ganz normaler sql ausgeführt werden
    -- SELECT, UPDATE, DELETE, Aufruf von Funtionen und Prozeduren
    
    -- innerhalb er Prozedure verwende ich den Standard Delimiter
    SELECT CONCAT('Hallo ', VariableA, ' ', VariableB);

-- am Ende den gesetzten Delimiter
END$$

-- nun setze ich den Delimiter auf Standard zurück
DELIMITER ;

Ausführen kann ich diese Prozedure wie folgt:

CALL MY_FIRST_PROCEDURE("Vorname", "Nachname");

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]

                

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

set -x

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

Deaktivieren kann man diese Ausgabe genauso einfach

set +x

Um die lokale Entwicklungsumgebung zu modifizieren, kann man einfach eine php Datei preloaden.

Dies kann man einfach mit php Mitteln tun:

if(file_exists("prepend.php")) {
    include_once("prepend.php");
}

Oder per .htaccess:

php_value auto_prepend_file "/mein/Pfad/prepend.php"

Ein Vorteil für die .htaccess-Variante sehe ich darin, das man sich das online unnütze file_exists spart.
Weiterhin hat man auch den Vorteil, das man die Einstellungen projektübergreifend setzen kann, da die .htaccess die gesetzten Werte ja vererbt.

Genauso gibt es auch die Möglichkeit des ladens einer Datei am Ende:

php_value auto_append_file "/mein/Pfad/append.php"

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

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

Und so kann ich den Zeichensatz setzen:

export LANG=de_DE.UTF-8

Oftmals hat man das Problem, das nach dem entwickeln doch noch Debug Ausgaben in der Javascript Console erscheinen.
Gerade bei komplexeren Javascript Bibliotheken möchte man eventuell auch die Konsolenausgaben nicht alle löschen um beim späteren weiterentwickeln nicht alle logzeilen neu zu erfinden oder diese ständig ein- und auskommentieren.

Dazu schaffe ich mir gern eine eigene Logfunktionalität.
Hierfür benötige ich zwei Variablen.
useLog diese kann true oder false sein und gibt an ob ich das Logging aktiviere oder deaktivere
customConsole ist mein LogObjekt
Wenn die Variable useLog auf true gesetzt ist, wird einfach meine Variable customConsole auf die window.console gesetzt.
Ist useLog auf false gesetzt wird das komplette Logging deaktiviert.

var useLog = false;
var useLog = false;

if(useLog === true) {
    var customConsole = window.console;
} else {
    var customConsole = {
        group   : function () {},
        log     : function () {},
        groupEnd: function () {}
    };
}

customConsole.log("Meine Logausgabe")