Einleitung allgemein (Erklärungen zum ganzen M300-Projekt)
Aufgaben: https://github.com/mc-b/M300/tree/master/10-Toolumgebung
- Auf www.github.com ein Benutzerkonto erstellen (Angabe von Username, E-Mail und Passwort)
- E-Mail zur Verifizierung des Kontos bestätigen und anschliessend auf GitHub anmelden
Github account erstellt: https://github.com/AaronGen
Repository erstellen
- Anmelden unter www.github.com
- Innerhalb der Willkommens-Seite auf Start a project klicken
- Unter Repository name einen Name definieren (z.B. M300-Services)
- Optional: kurze Beschreibung eingeben
- Radio-Button bei Public belassen
- Haken bei Initialize this repository with a README setzen
- Auf Create repository klicken
Name: M300-Services
Description: Microservices / Containerumgebung
Status: Private
Repository Klonen
$ git clone <Repository>
Pullen
$ git pull
Status prüfen
$ git status
Status pushen
$ git add .
$ git commit -m "<nachricht>"
$ git push
Zuerst muss in der Konsole einen SSH Key erstellt werden
$ ssh-keygen -t rsa -b 4096
Generating public/private rsa key pair.
Enter a file in which to save the key (~/.ssh/id_rsa): ~/.ssh/M300_key
Enter passphrase (empty for no passphrase): [Passwort]
Enter same passphrase again: [Passwort wiederholen]
Nachdem der Key erstellt wurde, muss er im Terminal angezeigt werden, dies muss mit folgendem Befehl getan werden.
Wenn der Public key nun in der Konsole angezeigt wird, diesen Kopieren.
Den zuvor kopierten Public Key hier unter KEY Pasten.
Der Name kann frei gewählt werden.
Wenn der Key nun in Github eingetragen ist, muss er auf dem Lokalen PC noch mit dem Repository verbunden werden.
$ ssh git@github.com -T -i ~/.ssh/<dein KEY>
Hi User! Youve successfully authenticated, but GitHub does not provide shell access.
Connection to github.com closed.
$ cd /pfad/zu/repository
$ git init
$ git remote add origin https://github.com/<dein Username>/<dein GIT Repository>
$ git remote set-url git@github.com:<dein Username>/<dein GIT Repository>
$ git pull origin master
Installieren
Linux
apt install git
Windows
Wenn Git unter Windows Installiert werden soll "Would not recommend", hier downloaden
https://git-scm.com/downloads
Konfiguration
$ git config --global user.name "<username>"
$ git config --global user.email "<e-mail>"
Linux
$ apt install virtualbox
Windows
Folgendes File Installieren und dem Wizard folgen
https://download.virtualbox.org/virtualbox/6.1.22/VirtualBox-6.1.22-144080-Win.exe
Daten:
Name: M300_Ubuntu_20.04_Desktop
Typ: Linux x64
RAM: 2048 MB
Festplatte: 10 GB
Festplatten Typ: VMDK → dynamisch alloziert
Updaten und Upgraden
$ apt update
$ apt upgrade -y
Synaptic Installieren
$ apt install synaptic
Linux
$ apt install vagrant
Windows
Auf folgenden Link drücken, Downloaden und dem Wizard folgen:
https://www.vagrantup.com/downloads
Einfache VM Erstellen
- Verzeichniss erstellen
$ mkdir ~/vagrant/box1
- VM Initialisieren
**Wichtig, dieser befehl muss im eben erstellten Verzeichniss ausgeführt werden
$ vagrant init <user>/<box>
Beispiel für box:
vagrant init ubuntu/xenial64
- Vagrant VM starten
**Wichtig, dieser befehl muss im eben erstellten Verzeichniss ausgeführt werden
$ vagrant up
Vagrant Befehle und Konfiguraionen
Vagrant box herunterladen
$ vagrant box add <user>/<Box>
Die Boxen könenn hier gefunden werden: https://app.vagrantup.com/boxes/search
Box Initialisieren
$ vagrant init <user>/<box>
Box Starten
$ vagrant up
oder: vagrant up (<boxname>) (wenn mehrere boxen im Vagantfile vorhanden sind)
Box Stoppen
$ vagrant halt
oder: vagrant halt (<boxname>) (wenn mehrere boxen im Vagantfile vorhanden sind)
Box Anhalten
$ vagrant suspend
oder: vagrant suspend (<boxname>) (wenn mehrere boxen im Vagantfile vorhanden sind)
Box Löschen
$ vagrant destroy
Direkt ssh verbindung zu Box
$ vagrant ssh
oder: vagrant ssh (<boxname>) (wenn mehrere boxen im Vagantfile vorhanden sind)
mit "exit" kommt man wieder aus der SSH Session
Um den Status einer Box herauszufinden.
$ vagrant status
oder: vagrant status (<boxname>) (wenn mehrere boxen im Vagantfile vorhanden sind)
Dies gibt folgenden output
Current machine states:
default running (virtualbox)
oder
Current machine states:
default poweroff (virtualbox)
oder
Current machine states:
default saved (virtualbox)
Befehl | Beschreibung |
---|---|
vagrant init |
Initialisiert im aktuellen Verzeichnis eine Vagrant-Umgebung und erstellt, falls nicht vorhanden, ein Vagrantfile |
vagrant up |
Erzeugt und Konfiguriert eine neue Virtuelle Maschine, basierend auf dem Vagrantfile |
vagrant ssh |
Baut eine SSH-Verbindung zur gewünschten VM auf |
vagrant status |
Zeigt den aktuellen Status der VM an |
vagrant port |
Zeigt die Weitergeleiteten Ports der VM an |
vagrant halt |
Stoppt die laufende Virtuelle Maschine |
vagrant destroy |
Stoppt die Virtuelle Maschine und zerstört sie. |
Vagrantfile
Das Vagrantfile befindet sich in dem Ordner in dem man den Befehl vagrant init ausgeführt hat, es sieht ohne weitere Optionen folgendermassen aus.
Vagrant.configure("2") do |config|
config.vm.box = "user/box"
end
Die vagrant VMs werden standartmässig in Virtualbox laufen gelassen, solange man dies im Vagrantfile nicht ändert.
Nach dem Editieren des vagrantfiles, muss folgender befehl ausgeführt werden
$ vagrant reload
Um ein Hostname zu geben, muss man das Vagrantfile folgendermasen editieren unter config.vm.box = ""
config.vm.hostname = "dein Hostname"
Um eine IP Adresse zu setzen, muss man das Vagrantfile folgendermasen editieren
config.vm.network "private_network", ip: "10.9.8.7"
Mehrere Vms erstellen
Mit Vagrant ist es möglich mehrere Vms mit nur einem File zu erstellen, dies Zeige ich hier anhand eines Beispieles.
$ cd /path/to/vmstorage
$ mkdir multivm
$ cd multivm
$ vagrant init ubuntu/xenial64
$ nano Vagrantfile
FilePath: /path/to/vmstorage/multivm/Vagrantfile
-------------------------------------------------
Vagrant.configure("2") do |config|
config.vm.box = "ubuntu/xenial64" #Select box Image
# Define Box 1
config.vm.define "box1" do |box1|
box1.vm.hostname = "box1"
box1.vm.network "private_network", ip: "10.9.8.1"
end
# Define Box 2
config.vm.define "box2" do |box2|
box2.vm.hostname = "box2"
box2.vm.network "private_network", ip: "10.9.8.2"
end
end
Um die VMs zu starten
$ vagrant up
umd nur eine der beiden zu starten: vagrant up box1 oder box2
Nun laufen die beiden VMs und sie können auch miteinander kommunizieren.
Um eine der beiden VMs zu kontrollieren
$ vagrant ssh box1
oder
$ vagrant ssh box2
Automatisch bash befehle beim erstellen ausführen
Folgender Punkt muss auskommentiert weden, und die Befehle können dazwischen geschrieben werden, in desem Beispiel werde ich einen Apache Server installieren und das System updaten
config.vm.provision "shell", inline: <<-SHELL
apt-get update
apt-get install -y apache2
SHELL
Um mit Vagrant einen Webserver zu installieren, kann das Vagrantfile folgendermassen konfiguriert werden
Vagrant.configure(2) do |config|
config.vm.box = "ubuntu/xenial64" # Install Ubuntu (Xenial = 16.04)
config.vm.network "forwarded_port", guest:80, host:8080, auto_correct: true # Port 80 von VM zu port 8080 Host weiterleiten
config.vm.synced_folder ".", "/var/www/html" # den Pfad in dem das Vagrant file ist, zum webverzeichnis weiterleiten
config.vm.provider "virtualbox" do |vb|
vb.memory = "512" # Server mit einem Halben gb ram ausstatten
end
config.vm.provision "shell", inline: <<-SHELL
# Packages vom lokalen Server holen
# sudo sed -i -e"1i deb {{config.server}}/apt-mirror/mirror/archive.ubuntu.com/ubuntu xenial main restricted" /etc/apt/sources.list
sudo apt-get update # System Updaten
sudo apt-get -y install apache2 # apache2 Installieren
SHELL
end
Dieses vagrantfile ist bereits im Git Repo von MC-B vorhanden.
https://github.com/tbz-it/M300/tree/master/vagrant/web
cd ~/gitrep/M300/vagrant/web
vagrant up
Linux
snap install --classic code
Windows
Auf dem folgenden Linux drücken und dem Wizard folgen.
https://code.visualstudio.com/
Infrastruktur – Infrastructure as a Service (IaaS)
Die Infrastruktur (auch "Cloud Foundation") stellt die unterste Schicht im Cloud Computing dar. Der Benutzer greift hier auf bestehende Dienste innerhalb des Systems zu, verwaltet seine Recheninstanzen (virtuelle Maschinen) allerdings weitestgehend selbst.
Plattform – Platform as a Service (PaaS)
Der Entwickler erstellt die Anwendung und lädt diese in die Cloud. Diese kümmert sich dann selbst um die Aufteilung auf die eigentlichen Verarbeitungseinheiten. Im Unterschied zu IaaS hat der Benutzer hier keinen direkten Zugriff auf die Recheninstanzen. Er betreibt auch keine virtuellen Server.
Anwendung – Software as a Service (SaaS)
Die Anwendungssicht stellt die abstrakteste Sicht auf Cloud-Dienste dar. Hierbei bringt der Benutzer seine Applikation weder in die Cloud ein, noch muss er sich um Skalierbarkeit oder Datenhaltung kümmern. Er nutzt eine bestehende Applikation, die ihm die Cloud nach aussen hin anbietet.
Mit dem Advent von Docker (Containierisierung) hat sich zwischen IaaS und PaaS eine neue Ebene geschoben:
CaaS (Container as a Service)
Diese Ebene ist dafür zuständig, containerisierten Workload auf den Ressourcen auszuführen, die eine IaaS-Cloud zur Verfügung stellt. Die Technologien dieser Ebene wie Docker, Kubernetes oder Mesos sind allesamt quelloffen verfügbar. Somit kann man sich seine private Cloud ohne Gefahr eines Vendor Lock-ins aufbauen.
Beispiele:
Public Cloud
AWS, Azure, Digital Ocean, Google, exoscale
Private Cloud
CloudStack, OpenStack, VMware vCloud
Lokale Virtualisierung
Oracle VirtualBox, Hyper-V, VMware Player
Hyperkonvergente Systeme
Rechner die die oben beschriebenen Eigenschaften in einer Hardware vereinen
Beispiele:
Programmierbar
Ein Userinterface ist zwar angenehm und viele Cloud Anbieter haben ein solches, aber für IaC muss die Plattform via Programmierschnittstelle (API) ansprechbar sein.
On-demand
Ressourcen (Server, Speicher, Netzwerke) schnell erstellen und vernichtet.
Self-Service
Ressourcen anpassen und auf eigene Bedürfnisse zuschneiden.
Portabel
Anbieter von Ressourcen (z.B. AWS, Azure) müssen austauschbar sein.
Sicherheit, Zertifizierungen (z.B. ISO 27001), etc.
Ziele von Infrastructure as a Code (IaC) sind:
- IT-Infrastruktur wird unterstützt und ermöglicht Veränderung, anstatt Hindernis oder Einschränkung zu sein.
- Änderungen am System sind Routine, ohne Drama oder Stress für Benutzer oder IT-Personal.
- IT-Mitarbeiter verbringen ihre Zeit für wertvolle Dinge, die ihre Fähigkeiten fördern und nicht für sich wiederholende Aufgaben.
- Fachanwender erstellen und verwalten ihre IT-Ressourcen, die sie benötigen, ohne IT-Mitarbeiter
- Teams sind in der Lage, einfach und schnell, ein abgestürztes System wiederherzustellen.
- Verbesserungen sind kontinuierlich und keine teuren und riskanten "Big Bang" Projekte.
- Lösungen für Probleme sind durch Implementierung, Tests, und Messen institutionalisiert, statt diese in Sitzungen und Dokumente zu erörtern.
Definitionen
- Versionsverwaltung - Version Control Systems (VCS)
- Testgetriebene Entwicklung - Testdriven Development (TDD)
- Kontinuierliche Integration - Continuous Integration (CI)
- Kontinuierliche Verteilung - Continuous Delivery (CD)
Packer ist ein Tool zur Erstellung von Images bzw. Boxen für eine Vielzahl von Dynamic Infrastructure Platforms mittels einer Konfigurationsdatei.
Ausgabe von allen offenen ports
$ apt install net-tools
$ netstat -tulpn
apt install ufw
Bedienen
$ sudo ufw status
$ sudo ufw enable
$ sudo ufw disable
Regeln öffnen
# Port 80 (HTTP) öffnen für alle
$ ufw allow 80/tcp
# Port 22 (SSH) nur für den Host (wo die VM laufen) öffnen
$ ufw allow from [Meine-IP] to any port 22
# Port 3306 (MySQL) nur für den web Server öffnen
$ ufw allow from [IP der Web-VM] to any port 3306
Regeln schliessen
# Port 80 (HTTP) öffnen für schliessen
$ ufw deny 80/tcp
Testen
$ curl -f 192.168.55.101
$ curl -f 192.168.55.100:3306
Regeln Löschen
$ sudo ufw status numbered
$ sudo ufw delete 1
$ apt install apache2
$ apt install libapache2-mod-proxy-html
$ apt install libxml2-dev
$ a2enmod proxy
$ a2enmod proxy_html
$ a2enmod proxy_http
Die Datei /etc/apache2/apache2.conf wie folgt ergänzen:
ServerName localhost
Apache Server neustarten
$ sudo service apache2 restart
Um eine Weiterleitung zu kreiren, das File sites-enabled/001-reverseproxy.conf erstellen / bearbeiten
# Allgemeine Proxy Einstellungen
ProxyRequests Off
<Proxy *>
Order deny,allow
Allow from all
</Proxy>
# Weiterleitungen master
ProxyPass /master http://master
ProxyPassReverse /master http://master
Benutzername | Funktion |
---|---|
root |
Der Systemverwalter unter Linux |
nobody |
Wird von Prozessen als Benutzererkennung verwendet, wenn nur ein Minimum an Rechten vergeben werden soll |
cupsys |
Benutzer des Druckdienstes CUPS |
www-data |
Benutzer des Webservers Apache |
Die Benutzer stehen in der Datei /etc/passwd. Die Passwörter in der Datei /etc/shadow.
Die Gruppen stehen in der Datei /etc/group.
Das Homeverzeichnis setzt sich aus /home und dem jeweiligen Benutzernamen zusammen (z.B. /home/myaccount).
mit ls -al können alle Berechtigungen angezeigt werden, die user/gruppen auf Files haben.
HTTPS
# Default Konfiguration in /etc/apache2/sites-available freischalten (wird nach sites-enabled verlinkt)
sudo a2ensite default-ssl.conf
# SSL Modul in Apache2 aktivieren
sudo a2enmod ssl
# Optional HTTP deaktivieren
sudo a2dissite 000-default.conf
# Datei /etc/apache2/ports.conf editieren und <Listen 80> durch Voranstellen von # deaktivieren
sudo nano /etc/apache2/ports.conf
# Apache Server frisch starten
sudo service apache2 restart
Passwort
# .htpasswd Datei erzeugen (ab dem zweiten User ohne -c), Password wird verlangt
sudo htpasswd -c /etc/apache2/.htpasswd guest
# /etc/apache2/sites-enabled/default-ssl.conf Editieren und vor </VirtualHost> folgendes Einfügen
<Directory "/var/www/html">
AuthType Basic
AuthName "Restricted Content"
AuthUserFile /etc/apache2/.htpasswd
Require valid-user
</Directory>
Merkmale
Container teilen sich Ressourcen mit dem Host-Betriebssystem
Container können im Bruchteil einer Sekunde gestartet und gestoppt werden
Anwendungen, die in Containern laufen, verursachen wenig bis gar keinen Overhead
Container sind portierbar --> Fertig mit "Aber bei mir auf dem Rechner lief es doch!"
Container sind leichtgewichtig, d.h. es können dutzende parallel betrieben werden.
Container sind "Cloud-ready"!
Docker Deamon
- Erstellen, Ausführen und Überwachen der Container
- Bauen und Speichern von Images
Der Docker Daemon wird normalerweise durch das Host-Betriebssystem gestartet.
Docker Client
- Docker wird über die Kommandozeile (CLI) mittels des Docker Clients bedient
- Kommuniziert per HTTP REST mit dem Docker Daemon
Da die gesamte Kommunikation über HTTP abläuft, ist es einfach, sich mit entfernten Docker Daemons zu verbinden und Bindings an Programmiersprachen zu entwickeln.
Images
- Images sind gebuildete Umgebungen welche als Container gestartet werden können
- Images sind nicht veränderbar, sondern können nur neu gebuildet werden.
- Images bestehen aus Namen und Version (TAG), z.B. ubuntu:16.04.
- Wird keine Version angegeben wird automatisch :latest angefügt.
Container
- Container sind die ausgeführten Images
- Ein Image kann beliebig oft als Container ausgeführt werden
- Container bzw. deren Inhalte können verändert werden, dazu werden sogenannte Union File Systems verwendet, welche nur die Änderungen zum original Image speichern.
Docker Registry
- In Docker Registries werden Images abgelegt und verteilt
Die Standard-Registry ist der Docker Hub, auf dem tausende öffentlich verfügbarer Images zur Verfügung stehen, aber auch "offizielle" Images.
Viele Organisationen und Firmen nutzen eigene Registries, um kommerzielle oder "private" Images zu hosten, aber auch um den Overhead zu vermeiden, der mit dem Herunterladen von Images über das Internet einhergeht.
docker run
- Ist der Befehl zum Starten neuer Container.
- Der bei weitem komplexesten Befehl, er unterstützt eine lange Liste möglicher Argumente.
- Ermöglicht es dem Anwender, zu konfigurieren, wie das Image laufen soll, Dockerfile-Einstellungen zu überschreiben, Verbindungen zu konfigurieren und Berechtigungen und Ressourcen für den Container zu setzen.
Standard-Test:
$ docker run hello-world
Startet einen Container mit einer interaktiven Shell (interactive, tty):
$ docker run -it ubuntu /bin/bash
Startet einen Container, der im Hintergrund (detach) läuft:
$ docker run -d ubuntu sleep 20
Startet einen Container im Hintergrund und löscht (remove) diesen nach Beendigung des Jobs:
$ docker run -d --rm ubuntu sleep 20
Startet einen Container im Hintergrund und legt eine Datei an:
$ docker run -d ubuntu touch /tmp/lock
Startet einen Container im Hintergrund und gibt das ROOT-Verzeichnis (/) nach STDOUT aus:
$ docker run -d ubuntu ls -l
docker ps
- Gibt einen Überblick über die aktuellen Container, wie z.B. Namen, IDs und Status.
Aktive Container anzeigen:
$ docker ps
Aktive und beendete Container anzeigen (all):
$ docker ps -a
Nur IDs ausgeben (all, quit):
$ docker ps -a -q
docker images
- Gibt eine Liste lokaler Images aus, wobei Informationen zu Repository-Namen, Tag-Namen und Grösse enthalten sind.
Lokale Images ausgeben:
$ docker images
Alternativ auch mit ... image ls:
$ docker image ls
docker rm und docker rmi
- docker rm
- Entfernt einen oder mehrere Container. Gibt die Namen oder IDs erfolgreich gelöschter Container zurück.
- docker rmi
- Löscht das oder die angegebenen Images. Diese werden durch ihre ID oder Repository- und Tag-Namen spezifiziert.
Docker Container löschen:
$ docker rm [name]
Alle beendeten Container löschen:
$ docker rm `docker ps -a -q`
Alle Container, auch aktive, löschen:
$ docker rm -f `docker ps -a -q`
Docker Image löschen:
$ docker rmi ubuntu
Zwischenimages löschen (haben keinen Namen):
$ docker rmi `docker images -q -f dangling=true`
docker start
- Startet einen (oder mehrere) gestoppte Container.
- Kann genutzt werden, um einen Container neu zu starten, der beendet wurde, oder um einen Container zu starten, der mit docker create erzeugt, aber nie gestartet wurde.
Docker Container neu starten, die Daten bleiben erhalten:
$ docker start [id]
Container stoppen, killen
- docker stop
- Stoppt einen oder mehrere Container (ohne sie zu entfernen). Nach dem Aufruf von docker stop für einen Container wird er in den Status »exited« überführt.
- docker kill
- Schickt ein Signal an den Hauptprozess (PID 1) in einem Container. Standardmässig wird SIGKILL gesendet, womit der Container sofort stoppt.
Informationen zu Containern
- docker logs
- Gibt die "Logs" für einen Container aus. Dabei handelt es sich einfach um alles, was innerhalb des Containers nach STDERR oder STDOUT geschrieben wurde.
- docker inspect
- Gibt umfangreiche Informationen zu Containern oder Images aus. Dazu gehören die meisten Konfigurationsoptionen und Netzwerkeinstellungen sowie Volumes-Mappings.
- docker diff
- Gibt die Änderungen am Dateisystem des Containers verglichen mit dem Image aus, aus dem er gestartet wurde.
- docker top
- Gibt Informationen zu den laufenden Prozessen in einem angegebenen Container aus.
Ein Dockerfile ist eine Textdatei mit einer Reihe von Schritten, die genutzt werden können, um ein Docker-Image zu erzeugen.
Dazu wird zuerst ein Verzeichnis erstellt und darin eine Datei mit Namen "Dockerfile".
Anschliessend kann das Image wie folgt gebuildet werden:
$ docker build -t mysql .
Starten:
$ docker run --rm -d --name mysql mysql
Funktionsfähigkeit überprüfen:
$ docker exec -it mysql bash
Überprüfung im Container:
$ ps -ef
$ netstat -tulpen
Anweisungen im Dockerfile
FROM
Welches Base Image von hub.docker.com verwendet werden soll, z.B. ubuntu:16.04
ADD
Kopiert Dateien aus dem Build Context oder von URLs in das Image.
CMD
Führt die angegebene Anweisung aus, wenn der Container gestartet wurde. Ist auch ein ENTRYPOINT definiert, wird die Anweisung als Argument für ENTRYPOINT verwendet.
COPY
Wird verwendet, um Dateien aus dem Build Context in das Image zu kopieren. Es gibt die zwei Formen COPY src dest und COPY ["src", "dest"]. Das JSON-Array-Format ist notwendig, wenn die Pfade Leerzeichen enthalten.
ENTRYPOINT
Legt eine ausführbare Datei (und Standardargumente) fest, die beim Start des Containers laufen soll. Jegliche CMD-Anweisungen oder an docker run nach dem Imagenamen übergebenen Argumente werden als Parameter an das Executable durchgereicht. ENTRYPOINT-Anweisungen werden häufig genutzt, um "Start-Scripts" anzustossen, die Variablen und Services initialisieren, bevor andere übergebene Argumente ausgewertet werden.
ENV
Setzt Umgebungsvariablen im Image.
EXPOSE
Erklärt Docker, dass der Container einen Prozess enthält, der an dem oder den angegebenen Port(s) lauscht.
HEALTHCHECK
Die Docker Engine prüft regelmässig den Status der Anwendung im Container. HEALTHCHECK --interval=5m --timeout=3s \ CMD curl -f http://localhost/ || exit 1`
MAINTAINER
Setzt die "Autor-Metadaten" des Image auf den angegebenen Wert.
RUN
Führt die angegebene Anweisung im Container aus und bestätigt das Ergebnis.
SHELL
Die Anweisung SHELL erlaubt es seit Docker 1.12, die Shell für den folgenden RUN-Befehl zu setzten. So ist es möglich, dass nun auch direkt bash, zsh oder Powershell-Befehle in einem Dockerfile genutzt werden können.
USER
Setzt den Benutzer (über Name oder UID), der in folgenden RUN-, CMD- oder ENTRYPOINT-Anweisungen genutzt werden soll.
VOLUME
Deklariert die angegebene Datei oder das Verzeichnis als Volume. Besteht die Datei oder das Verzeichnis schon im Image, wird sie bzw. es in das Volume kopiert, wenn der Container gestartet wird.
WORKDIR
Setzt das Arbeitsverzeichnis für alle folgenden RUN-, CMD-, ENTRYPOINT-, ADD oder COPY-Anweisungen.
Portweiterleitung
$ docker run --rm -d -p <port>:<port> <image>
Netzwerk anzeigen lassen
$ docker network ls
der -v parameter addet ein Volume.
Datenverzeichnis /var/lib/mysql vom Container auf dem Host einhängen (mount):
$ docker run -d -p 3306:3306 -v ~/data/mysql:/var/lib/mysql --name mysql --rm mysql
# Datenverzeichnis
$ ls -l ~/data/mysql
Json logging
$ docker run --name logtest ubuntu bash -c 'echo "stdout"; echo "stderr" >>2'
Syslog
$ docker run -d --log-driver=syslog ubuntu bash -c 'i=0; while true; do i=$((i+1)); echo "docker $i"; sleep 1; done;'
$ tail -f /var/log/syslog
User Setzen
RUN groupadd -r user_grp && useradd -r -g user_grp user
USER user
Speicher begrenzen
RUN groupad
docker run -m 128m --memory-swap 128m amouat/stress stress --vm 1 --vm-bytes 127m -t 5s
Load Balancing
Mittels Lastverteilung (englisch Load Balancing) werden in der Informatik umfangreiche Berechnungen oder große Mengen von Anfragen auf mehrere parallel arbeitende Systeme verteilt.
Insbesondere bei Webservern ist eine Lastverteilung wichtig, da ein einzelner Host nur eine begrenzte Menge an HTTP-Anfragen auf einmal beantworten kann.
Für unsere Zwecke kann Lastverteilung als der Prozess des Verteilens von Anfragen auf verschiedene Container betrachtet werden.
Cluster
Immutable (Unveränderlich) statt Mutable.
Deklarative statt Imperative (Ausführen von Anweisungen) Konfiguration.
Selbstheilende Systeme - Neustart bei Absturz.
Entkoppelte APIs – LoadBalancer / Ingress (Reverse Proxy).
Skalieren der Services durch Änderung der Deklaration.
Anwendungsorientiertes statt Technik (z.B. Route 53 bis AWS) Denken.
Abstraktion der Infrastruktur statt in Rechnern Denken.
Pod - Ein Pod repräsentiert eine Gruppe von Anwendungs-Containern und Volumes, die in der gleichen Ausführungsumgebung (gleiche IP, Node) laufen.
ReplicaSet: ReplicaSets bestimmen wieviele Exemplare eines Pods laufen und stellen sicher, dass die angeforderte Menge auch verfügbar ist.
Deployment: Deployments erweitern ReplicaSets um deklarative Updates (z.B. von Version 1.0 auf 1.1) von Container Images.
Service: Ein Service steuert den Zugriff auf einen Pod (IP-Adresse, Port). Während Pods (bzw. Images) ersetzt werden können (z.B. durch Update auf neue Version) bleibt ein Service stabil.
Ingress: Ähnlich einem Reverse Proxy ermöglicht ein Ingress den Zugriff auf einen Service über einen URL.
Ein Rechnerverbund oder Computercluster, meist einfach Cluster genannt (vom Englischen für „Rechner-Schwarm“, „-Gruppe“ oder „-Haufen“), bezeichnet eine Anzahl von vernetzten Computern.
Der Begriff wird zusammenfassend für zwei unterschiedliche Aufgaben verwendet:
die Erhöhung der Rechenkapazität (HPC-Cluster)
die Erhöhung der Verfügbarkeit (HA-Cluster, engl. high available - hochverfügbar).
Die in einem Cluster befindlichen Computer (auch Knoten, vom englischen nodes oder Server) werden auch oft als Serverfarm bezeichnet.
Aufgaben und einige Texte: https://github.com/mc-b/M300/tree/master
Dieses Werk ist lizenziert unter einer Creative Commons Namensnennung - Nicht-kommerziell - Weitergabe unter gleichen Bedingungen 3.0 Schweiz Lizenz