\documentclass[10pt,a4paper]{article}

% Packages
\usepackage{fancyhdr}           % For header and footer
\usepackage{multicol}           % Allows multicols in tables
\usepackage{tabularx}           % Intelligent column widths
\usepackage{tabulary}           % Used in header and footer
\usepackage{hhline}             % Border under tables
\usepackage{graphicx}           % For images
\usepackage{xcolor}             % For hex colours
%\usepackage[utf8x]{inputenc}    % For unicode character support
\usepackage[T1]{fontenc}        % Without this we get weird character replacements
\usepackage{colortbl}           % For coloured tables
\usepackage{setspace}           % For line height
\usepackage{lastpage}           % Needed for total page number
\usepackage{seqsplit}           % Splits long words.
%\usepackage{opensans}          % Can't make this work so far. Shame. Would be lovely.
\usepackage[normalem]{ulem}     % For underlining links
% Most of the following are not required for the majority
% of cheat sheets but are needed for some symbol support.
\usepackage{amsmath}            % Symbols
\usepackage{MnSymbol}           % Symbols
\usepackage{wasysym}            % Symbols
%\usepackage[english,german,french,spanish,italian]{babel}              % Languages

% Document Info
\author{Huluvu424242 (FunThomas424242)}
\pdfinfo{
  /Title (docker.pdf)
  /Creator (Cheatography)
  /Author (Huluvu424242 (FunThomas424242))
  /Subject (Docker Cheat Sheet)
}

% Lengths and widths
\addtolength{\textwidth}{6cm}
\addtolength{\textheight}{-1cm}
\addtolength{\hoffset}{-3cm}
\addtolength{\voffset}{-2cm}
\setlength{\tabcolsep}{0.2cm} % Space between columns
\setlength{\headsep}{-12pt} % Reduce space between header and content
\setlength{\headheight}{85pt} % If less, LaTeX automatically increases it
\renewcommand{\footrulewidth}{0pt} % Remove footer line
\renewcommand{\headrulewidth}{0pt} % Remove header line
\renewcommand{\seqinsert}{\ifmmode\allowbreak\else\-\fi} % Hyphens in seqsplit
% This two commands together give roughly
% the right line height in the tables
\renewcommand{\arraystretch}{1.3}
\onehalfspacing

% Commands
\newcommand{\SetRowColor}[1]{\noalign{\gdef\RowColorName{#1}}\rowcolor{\RowColorName}} % Shortcut for row colour
\newcommand{\mymulticolumn}[3]{\multicolumn{#1}{>{\columncolor{\RowColorName}}#2}{#3}} % For coloured multi-cols
\newcolumntype{x}[1]{>{\raggedright}p{#1}} % New column types for ragged-right paragraph columns
\newcommand{\tn}{\tabularnewline} % Required as custom column type in use

% Font and Colours
\definecolor{HeadBackground}{HTML}{333333}
\definecolor{FootBackground}{HTML}{666666}
\definecolor{TextColor}{HTML}{333333}
\definecolor{DarkBackground}{HTML}{A3A3A3}
\definecolor{LightBackground}{HTML}{F3F3F3}
\renewcommand{\familydefault}{\sfdefault}
\color{TextColor}

% Header and Footer
\pagestyle{fancy}
\fancyhead{} % Set header to blank
\fancyfoot{} % Set footer to blank
\fancyhead[L]{
\noindent
\begin{multicols}{3}
\begin{tabulary}{5.8cm}{C}
    \SetRowColor{DarkBackground}
    \vspace{-7pt}
    {\parbox{\dimexpr\textwidth-2\fboxsep\relax}{\noindent
        \hspace*{-6pt}\includegraphics[width=5.8cm]{/web/www.cheatography.com/public/images/cheatography_logo.pdf}}
    }
\end{tabulary}
\columnbreak
\begin{tabulary}{11cm}{L}
    \vspace{-2pt}\large{\bf{\textcolor{DarkBackground}{\textrm{Docker Cheat Sheet}}}} \\
    \normalsize{by \textcolor{DarkBackground}{Huluvu424242 (FunThomas424242)} via \textcolor{DarkBackground}{\uline{cheatography.com/19991/cs/5094/}}}
\end{tabulary}
\end{multicols}}

\fancyfoot[L]{ \footnotesize
\noindent
\begin{multicols}{3}
\begin{tabulary}{5.8cm}{LL}
  \SetRowColor{FootBackground}
  \mymulticolumn{2}{p{5.377cm}}{\bf\textcolor{white}{Cheatographer}}  \\
  \vspace{-2pt}Huluvu424242 (FunThomas424242) \\
  \uline{cheatography.com/funthomas424242} \\
        \uline{\seqsplit{github}.com/Huluvu424242}
  \end{tabulary}
\vfill
\columnbreak
\begin{tabulary}{5.8cm}{L}
  \SetRowColor{FootBackground}
  \mymulticolumn{1}{p{5.377cm}}{\bf\textcolor{white}{Cheat Sheet}}  \\
   \vspace{-2pt}Published 5th September, 2015.\\
   Updated 11th July, 2019.\\
   Page {\thepage} of \pageref{LastPage}.
\end{tabulary}
\vfill
\columnbreak
\begin{tabulary}{5.8cm}{L}
  \SetRowColor{FootBackground}
  \mymulticolumn{1}{p{5.377cm}}{\bf\textcolor{white}{Sponsor}}  \\
  \SetRowColor{white}
  \vspace{-5pt}
  %\includegraphics[width=48px,height=48px]{dave.jpeg}
  Measure your website readability!\\
  www.readability-score.com
\end{tabulary}
\end{multicols}}




\begin{document}
\raggedright
\raggedcolumns

% Set font size to small. Switch to any value
% from this page to resize cheat sheet text:
% www.emerson.emory.edu/services/latex/latex_169.html
\footnotesize % Small font.

\begin{multicols*}{2}

\begin{tabularx}{8.4cm}{X}
\SetRowColor{DarkBackground}
\mymulticolumn{1}{x{8.4cm}}{\bf\textcolor{white}{Docker Umgebungen / Provider}}  \tn
\SetRowColor{white}
\mymulticolumn{1}{x{8.4cm}}{{\bf{Spieleumgebung von Docker zum Auspobieren der Images}}: \newline % Row Count 2 (+ 2)
(Registrierung notwendig) \newline % Row Count 3 (+ 1)
\seqsplit{https://labs.play-with-docker.com/} \newline % Row Count 4 (+ 1)
{\bf{Docker Server/Hosting Provider}}: \newline % Row Count 5 (+ 1)
* \seqsplit{https://www.digitalocean.com/pricing/} \newline % Row Count 6 (+ 1)
* \seqsplit{https://sloppy.io/de/pricing/} \newline % Row Count 7 (+ 1)
* \seqsplit{https://www.orchardup.com/pricing} \newline % Row Count 8 (+ 1)
* \seqsplit{https://aws.amazon.com/de/ecs/pricing/} \newline % Row Count 9 (+ 1)
* https://giantswarm.io \newline % Row Count 10 (+ 1)
* \seqsplit{https://cloud.google.com/pricing/list} \newline % Row Count 11 (+ 1)
* \seqsplit{https://jelastic.com/public-cloud-pricing/} \newline % Row Count 12 (+ 1)
* https://www.loodse.com/ \newline % Row Count 13 (+ 1)
* \seqsplit{https://upcube.io/\#intro}% Row Count 14 (+ 1)
} \tn 
\hhline{>{\arrayrulecolor{DarkBackground}}-}
\SetRowColor{LightBackground}
\mymulticolumn{1}{x{8.4cm}}{Quelle: \seqsplit{https://t3n.de/news/docker-hosting-613802/}}  \tn 
\hhline{>{\arrayrulecolor{DarkBackground}}-}
\end{tabularx}
\par\addvspace{1.3em}

\begin{tabularx}{8.4cm}{X}
\SetRowColor{DarkBackground}
\mymulticolumn{1}{x{8.4cm}}{\bf\textcolor{white}{Installation unter Ubuntu}}  \tn
\SetRowColor{LightBackground}
\mymulticolumn{1}{x{8.4cm}}{curl -sSL https://get.docker.com/ | sh \newline curl -sSL \seqsplit{https://get.docker.com/gpg} | sudo apt-key add - \newline sudo docker run hello-world \newline  \newline ; um nicht bei jedem Kommando sudo nutzen zu müssen  \newline sudo usermod -aG docker mylocaluserName \newline ; restart und dann l{\"a}ufts ohne sudo \newline  \newline ; Falls dieser Fehler erscheint \newline ;Cannot connect to the Docker daemon at \seqsplit{unix:///var/run/docker.sock.} Is the docker daemon running? \newline ; Dann muss in der Regel noch der Daemon gestartet werden \newline ; Tempor{\"a}r geht das so  \newline sudo dockerd\& \newline  \newline  \newline ; Bei diesem Fehler  \newline Error starting daemon: error initializing graphdriver: driver not supported \newline ; half bei mir die Docker Installation zu aktualisieren und \newline ; das Verzeichnis der aufs images zu l{\"o}schen: sudo rm -rf /var/lib/docker/aufs \newline ; (anschlie{\ss}end neustart)} \tn 
\hhline{>{\arrayrulecolor{DarkBackground}}-}
\SetRowColor{LightBackground}
\mymulticolumn{1}{x{8.4cm}}{Dein Kernel sollte mindestens 3.10 besser 3.13 oder h{\"o}her sein. Prüfe es mittels: {\emph{uname -r }} \newline Weitere Infos unter: \seqsplit{https://docs.docker.com/installation/ubuntulinux/}}  \tn 
\hhline{>{\arrayrulecolor{DarkBackground}}-}
\end{tabularx}
\par\addvspace{1.3em}

\begin{tabularx}{8.4cm}{x{1.6 cm} x{6.4 cm} }
\SetRowColor{DarkBackground}
\mymulticolumn{2}{x{8.4cm}}{\bf\textcolor{white}{Docker File - Syntax}}  \tn
% Row 0
\SetRowColor{LightBackground}
FROM & Base Image von dem abgeleitet wird \tn 
% Row Count 2 (+ 2)
% Row 1
\SetRowColor{white}
\seqsplit{MAINTAINER} & Produzent des Images \tn 
% Row Count 4 (+ 2)
% Row 2
\SetRowColor{LightBackground}
LABEL & Hinzufügen von Metainformationen \tn 
% Row Count 6 (+ 2)
% Row 3
\SetRowColor{white}
ARG & Definiert Build Parametervariablen deren Werte bereits ins Image geschrieben werden \tn 
% Row Count 9 (+ 3)
% Row 4
\SetRowColor{LightBackground}
ENV & Definiert Umgebungsvariablen welche beim Containerstart mit -e  überschrieben werden - im Image werden nur Platzhalter angelegt \tn 
% Row Count 13 (+ 4)
% Row 5
\SetRowColor{white}
ADD & Hinzufügen von Dateien zum Image aus dem Host \tn 
% Row Count 15 (+ 2)
% Row 6
\SetRowColor{LightBackground}
COPY & Kopiert Dateien vom Host in das Image \tn 
% Row Count 17 (+ 2)
% Row 7
\SetRowColor{white}
RUN & Kommando welches beim Build ausgeführt wird \tn 
% Row Count 19 (+ 2)
% Row 8
\SetRowColor{LightBackground}
EXPOSE & Freigabe und Mapping von Ports zur Aussenwelt (Host und andere Container) \tn 
% Row Count 22 (+ 3)
% Row 9
\SetRowColor{white}
VOLUME & Definiert Volumen welche mit der Aussenwelt verknüpft werden k{\"o}nnen (Mountpoint) \tn 
% Row Count 25 (+ 3)
% Row 10
\SetRowColor{LightBackground}
WORKDIR & Festlegen des Arbeitsverzeichnisses \tn 
% Row Count 27 (+ 2)
% Row 11
\SetRowColor{white}
USER & Accountwechsel beim Build des Images z.b. von root auf jenkins \tn 
% Row Count 29 (+ 2)
% Row 12
\SetRowColor{LightBackground}
\seqsplit{ENTRYPOINT} & Kommando welches beim Containerstart ausgeführt wird (erg{\"a}nzt den Entrypoint) \tn 
% Row Count 32 (+ 3)
\end{tabularx}
\par\addvspace{1.3em}

\vfill
\columnbreak
\begin{tabularx}{8.4cm}{x{1.6 cm} x{6.4 cm} }
\SetRowColor{DarkBackground}
\mymulticolumn{2}{x{8.4cm}}{\bf\textcolor{white}{Docker File - Syntax (cont)}}  \tn
% Row 13
\SetRowColor{LightBackground}
CMD & Kommando welches beim Containerstart ausgeführt wird (erg{\"a}nzt den Entrypoint z.B. um Parameter) \tn 
% Row Count 4 (+ 4)
\hhline{>{\arrayrulecolor{DarkBackground}}--}
\SetRowColor{LightBackground}
\mymulticolumn{2}{x{8.4cm}}{Die Kommandos im Dockerfile werden in der Regel ausgeführt w{\"a}hrend des Build Prozesses und auf den im Image liegenden Verzeichnissen und Dateien.  \newline  \newline Einzige Kommandos welche zur Laufzeit des Images also im Container ausgeführt werden sind: CMD und ENTRYPOINT \newline  \newline Details zu den Kommandos: \seqsplit{https://docs.docker.com/v17.09/engine/reference/builder/}}  \tn 
\hhline{>{\arrayrulecolor{DarkBackground}}--}
\end{tabularx}
\par\addvspace{1.3em}

\begin{tabularx}{8.4cm}{x{4 cm} x{4 cm} }
\SetRowColor{DarkBackground}
\mymulticolumn{2}{x{8.4cm}}{\bf\textcolor{white}{Command Line Befehle}}  \tn
% Row 0
\SetRowColor{LightBackground}
docker build -t user/pojectname:tag projectfolder & Docker Image bauen aus einem Projekt mit Dockerfile \tn 
% Row Count 3 (+ 3)
% Row 1
\SetRowColor{white}
docker pull user/project & L{\"a}dt ein Image von Docker Hub herunter. Image ID funktioniert über User/Projekt \tn 
% Row Count 8 (+ 5)
% Row 2
\SetRowColor{LightBackground}
docker images & Listet alle lokal verfügbaren images \tn 
% Row Count 10 (+ 2)
% Row 3
\SetRowColor{white}
docker image inspect \textless{}imageId\textgreater{} & Zeigt Detailinformationen zum Image an \tn 
% Row Count 12 (+ 2)
% Row 4
\SetRowColor{LightBackground}
docker rmi user/repo:tag & L{\"o}scht lokal das zugeordnete Image. \tn 
% Row Count 14 (+ 2)
% Row 5
\SetRowColor{white}
docker image rm \textless{}imageId\textgreater{} {[}-f{]} & L{\"o}scht ein Image aus der lokalen Registry. Mit -f auch wenn noch Abh{\"a}ngigkeiten zu laufenden Containern bestehen. \tn 
% Row Count 20 (+ 6)
% Row 6
\SetRowColor{LightBackground}
docker run & Startet einen Container. Z.B. {\emph{docker run -it ubuntu bash}} startet ein Ubuntu mit Shell \tn 
% Row Count 25 (+ 5)
% Row 7
\SetRowColor{white}
docker stop \textless{}containerId\textgreater{} & T{\"o}tet den MainThread im Container und beendet ihn dadurch. Die Daten aus dem editierbaren Layer bleiben erhalten. \tn 
% Row Count 31 (+ 6)
\end{tabularx}
\par\addvspace{1.3em}

\vfill
\columnbreak
\begin{tabularx}{8.4cm}{x{4 cm} x{4 cm} }
\SetRowColor{DarkBackground}
\mymulticolumn{2}{x{8.4cm}}{\bf\textcolor{white}{Command Line Befehle (cont)}}  \tn
% Row 8
\SetRowColor{LightBackground}
docker start \textless{}containerId\textgreater{} & Startet einen Container wieder an der Stelle an der er gestoppt wurde. \tn 
% Row Count 4 (+ 4)
% Row 9
\SetRowColor{white}
docker ps & Zeigt alle laufenden Container. Mit -a auch alle anderen. \tn 
% Row Count 7 (+ 3)
% Row 10
\SetRowColor{LightBackground}
docker rm \textless{}containerId|name:tag\textgreater{} & L{\"o}scht einen nicht laufenden Container \tn 
% Row Count 9 (+ 2)
% Row 11
\SetRowColor{white}
docker exec -it \textless{}containerId\textgreater{} bash & Startet eine zus{\"a}tzliche Bash auf dem laufenden Container mit ID \tn 
% Row Count 13 (+ 4)
% Row 12
\SetRowColor{LightBackground}
docker commit \textless{}containerId\textgreater{} \textless{}mein-neuer-image-name\textgreater{}:\textless{}tag-name\textgreater{} & Persistiert die Änderungen eines laufenden Containers als Image. z.B: docker commit c3f279d17e0a  \seqsplit{SvenDowideit/testimage:version3} \tn 
% Row Count 20 (+ 7)
% Row 13
\SetRowColor{white}
docker export \textless{}containerId\textgreater{} -o \textless{}filename\textgreater{}.tar & Container als Tar File exportieren \tn 
% Row Count 23 (+ 3)
% Row 14
\SetRowColor{LightBackground}
docker save -o mein-image-save.tar \textless{}mein-image-name\textgreater{} & Image als Tar zur Weitergabe exportieren \tn 
% Row Count 26 (+ 3)
% Row 15
\SetRowColor{white}
docker load -i mein-image-save.tar & Docker Image aus Tar lokal einlesen \tn 
% Row Count 28 (+ 2)
% Row 16
\SetRowColor{LightBackground}
docker tag \textless{}imageId\textgreater{} user/project:tag & Taggen eines lokalen Images \tn 
% Row Count 30 (+ 2)
\end{tabularx}
\par\addvspace{1.3em}

\vfill
\columnbreak
\begin{tabularx}{8.4cm}{x{4 cm} x{4 cm} }
\SetRowColor{DarkBackground}
\mymulticolumn{2}{x{8.4cm}}{\bf\textcolor{white}{Command Line Befehle (cont)}}  \tn
% Row 17
\SetRowColor{LightBackground}
docker login & Interaktive Eingabe der Login Daten für Docker Hub \tn 
% Row Count 3 (+ 3)
% Row 18
\SetRowColor{white}
docker push user/repo:tag & Upload eines Images zum Docker Hub Portal \tn 
% Row Count 6 (+ 3)
% Row 19
\SetRowColor{LightBackground}
docker system prune & R{\"a}um lokal mal richtig auf - obsolete Dinge fliegen weg \tn 
% Row Count 9 (+ 3)
\hhline{>{\arrayrulecolor{DarkBackground}}--}
\SetRowColor{LightBackground}
\mymulticolumn{2}{x{8.4cm}}{Bitte beachten Sie, dass vor dem Upload von Images auf Docker Hub eine Registrierung bei dieser Platform notwendig ist. \newline  \newline Weiterhin ist für einen authorisierten Zugriff vor einem Push ein Login mittels docker login auf der Kommandozeile durchzuführen.  \newline  \newline Best Praxis ist ein automatisch baubares Images auf Github als Projekt zu hosten und mit Docker Hub zu verbinden.}  \tn 
\hhline{>{\arrayrulecolor{DarkBackground}}--}
\end{tabularx}
\par\addvspace{1.3em}

\begin{tabularx}{8.4cm}{X}
\SetRowColor{DarkBackground}
\mymulticolumn{1}{x{8.4cm}}{\bf\textcolor{white}{Docker in Docker (nested docker)}}  \tn
\SetRowColor{white}
\mymulticolumn{1}{x{8.4cm}}{Du willst einen Docker Daemon  in einem Docker Container starten und wei{\ss}t nicht wie es geht? Dann kennst Du auch nicht die Probleme welche daraus resultieren. Zun{\"a}chst lies also diese beiden Artikel: \newline % Row Count 5 (+ 5)
* \seqsplit{https://itnext.io/docker-in-docker-521958d34efd} \newline % Row Count 6 (+ 1)
* \seqsplit{https://github.com/jpetazzo/dind} \newline % Row Count 7 (+ 1)
Jetzt wei{\ss}t Du was Du wirklich willst und entscheidest zwischen blauer oder roter Pille? \newline % Row Count 9 (+ 2)
A) Du willst eigentlich nur Container in einem Container starten z.B. um zu Testen oder zu bauen (Jenkins etc. ...) und diese dürfen durchaus im Hostsystem angelegt werden? Dann nimm ein von docker abgeleitetes image und mounte beim Start als Volume den docker Socket. Dein Docker Client im Container kann ab jetzt genau wie der Docker Client vom Host über den selben docker Deamon neue Container starten und Images pullen.  \newline % Row Count 18 (+ 9)
`docker run -ti -v \seqsplit{/var/run/docker.sock:/var/run/docker.sock} docker` \newline % Row Count 20 (+ 2)
B) Du willst wirklich einen echten verschachtelten Docker - also im Container einen eigenen Docker deamon. Dann starte ein vom docker:dind Image abgeleitetes Image mit Sonderprivilegien. Alles wird gut - aber wundere Dich nicht wo Dein Speicher bleibt. \newline % Row Count 26 (+ 6)
`docker run -{}-privileged -d docker:dind`% Row Count 27 (+ 1)
} \tn 
\hhline{>{\arrayrulecolor{DarkBackground}}-}
\end{tabularx}
\par\addvspace{1.3em}

\begin{tabularx}{8.4cm}{X}
\SetRowColor{DarkBackground}
\mymulticolumn{1}{x{8.4cm}}{\bf\textcolor{white}{Jenkins im Container}}  \tn
\SetRowColor{white}
\mymulticolumn{1}{x{8.4cm}}{`docker run -p 8080:8080 -p 50000:50000 -v \seqsplit{/var/run/docker.sock:/var/run/docker.sock} -v \seqsplit{/usr/bin/docker:/usr/bin/docker} -v \seqsplit{/var/lib/jenkins\_home:/var/jenkins\_home} -e \seqsplit{"DOCKER\_GID\_ON\_HOST=docker\_group\_id"} oose/dockerjenkins`% Row Count 5 (+ 5)
} \tn 
\hhline{>{\arrayrulecolor{DarkBackground}}-}
\SetRowColor{LightBackground}
\mymulticolumn{1}{x{8.4cm}}{Quellen: \newline {\emph{ \seqsplit{https://www.oose.de/blogpost/jenkins-in-docker-und-mit-docker-und-fuer-docker/} \newline }} \seqsplit{https://blogs.itemis.com/de/jenkins-mit-docker-virtualisieren-oder-doch-nicht}}  \tn 
\hhline{>{\arrayrulecolor{DarkBackground}}-}
\end{tabularx}
\par\addvspace{1.3em}

\begin{tabularx}{8.4cm}{X}
\SetRowColor{DarkBackground}
\mymulticolumn{1}{x{8.4cm}}{\bf\textcolor{white}{Troubleshooting}}  \tn
\SetRowColor{white}
\mymulticolumn{1}{x{8.4cm}}{\#  Kein Image im Manifest beim pull \newline % Row Count 1 (+ 1)
{\bf{Fehlerbild}} \newline % Row Count 2 (+ 1)
`\textgreater{} latest: Pulling from library/openjdk` \newline % Row Count 3 (+ 1)
`\textgreater{} no matching manifest for unknown in the manifest list entries` \newline % Row Count 5 (+ 2)
{\bf{Ursache}}  \newline % Row Count 6 (+ 1)
Das angeforderte Image unterstützt die vorliegende Architektur nicht \newline % Row Count 8 (+ 2)
{\bf{Analyse}} \newline % Row Count 9 (+ 1)
`\textgreater{} docker info  -f '\{\{.OSType\}\}/\{\{.Architecture\}\}'` \newline % Row Count 11 (+ 2)
{\bf{L{\"o}sung}} (Beispielsuche nach openjdk) \newline % Row Count 12 (+ 1)
`\textgreater{} mkdir \textasciitilde{}/docker-testconfig` \newline % Row Count 13 (+ 1)
`\textgreater{} touch \textasciitilde{}/docker-testconfig/config.json` \newline % Row Count 14 (+ 1)
\{ \newline % Row Count 15 (+ 1)
 "experimental": "enabled" \newline % Row Count 16 (+ 1)
\} \newline % Row Count 17 (+ 1)
`\textgreater{} docker -{}-config \textasciitilde{}/docker-testconfig manifest inspect -v library/openjdk:latest | jq .{[}{]}.Platform` \newline % Row Count 20 (+ 3)
{\bf{Quelle}} \newline % Row Count 21 (+ 1)
\seqsplit{https://success.docker.com/article/error-pulling-image-no-matching-manifest}% Row Count 23 (+ 2)
} \tn 
\hhline{>{\arrayrulecolor{DarkBackground}}-}
\end{tabularx}
\par\addvspace{1.3em}

\begin{tabularx}{8.4cm}{X}
\SetRowColor{DarkBackground}
\mymulticolumn{1}{x{8.4cm}}{\bf\textcolor{white}{Netzwerke bilden: user-defined bridge}}  \tn
\SetRowColor{white}
\mymulticolumn{1}{x{8.4cm}}{Im default Netzwerk (also ohne irgendwelche Anpassungen) finden sich die einzelnen Container (z.B. frontend und backend) einer App nicht. Hier konnte man früher mit dem jetzt nicht mehr unterstützten docker run Argument `-{}-link` eine Verbindung schaffen. Der Weg wird explizit als veraltet und nicht empfohlen beschrieben.  \newline % Row Count 7 (+ 7)
{\bf{Der neue Weg}} sind die Definition von "user-defined-brigde Netzwerken". Alle Container eines Netzwerkes k{\"o}nnen direkt untereinander kommunizieren (über den Containernamen welcher als Hostname im DNS fungiert). Hierbei wird von automatic service discovery gesprochen. Die Zuordnungen k{\"o}nnen on the fly erstellt und entfernt werden: \newline % Row Count 14 (+ 7)
`\# ein Netzwerk my-net erstellen` \newline % Row Count 15 (+ 1)
`docker network rm my-net` \newline % Row Count 16 (+ 1)
`\# den Container my-nginx dem Netzwerk my-net zuordnen' \newline % Row Count 18 (+ 2)
`docker network connect my-net my-nginx` \newline % Row Count 19 (+ 1)
`\# den Container my-nginx aus dem Netzwerk my-net entfernen` \newline % Row Count 21 (+ 2)
`docker network disconnect my-net my-nginx` \newline % Row Count 22 (+ 1)
Zus{\"a}tzlich lassen sich über publish Portmappings herstellen: \newline % Row Count 24 (+ 2)
`-{}-publish 8080:80` mappt Port 80 im Container auf 8080 im Host. \newline % Row Count 26 (+ 2)
Beispiele zum konkreten Aufbau von Netzwerken findet man hier: \newline % Row Count 28 (+ 2)
\seqsplit{https://docs.docker.com/network/network-tutorial-standalone/\#use-user-defined-bridge-networks} \newline % Row Count 30 (+ 2)
} \tn 
\end{tabularx}
\par\addvspace{1.3em}

\vfill
\columnbreak
\begin{tabularx}{8.4cm}{X}
\SetRowColor{DarkBackground}
\mymulticolumn{1}{x{8.4cm}}{\bf\textcolor{white}{Netzwerke bilden: user-defined bridge (cont)}}  \tn
\SetRowColor{white}
\mymulticolumn{1}{x{8.4cm}}{Netzwerke über verschiedene Docker Deamon's nennen sich Overlay Netze: \newline % Row Count 2 (+ 2)
\seqsplit{https://docs.docker.com/network/overlay/}% Row Count 3 (+ 1)
} \tn 
\hhline{>{\arrayrulecolor{DarkBackground}}-}
\SetRowColor{LightBackground}
\mymulticolumn{1}{x{8.4cm}}{Quelle: \seqsplit{https://docs.docker.com/network/bridge/\#\#differences-between-user-defined-bridges-and-the-default-bridge}}  \tn 
\hhline{>{\arrayrulecolor{DarkBackground}}-}
\end{tabularx}
\par\addvspace{1.3em}

\begin{tabularx}{8.4cm}{X}
\SetRowColor{DarkBackground}
\mymulticolumn{1}{x{8.4cm}}{\bf\textcolor{white}{Allgemeine Infos}}  \tn
\SetRowColor{white}
\mymulticolumn{1}{x{8.4cm}}{Docker ist ein System welches fertige Systeme ({\"a}hnlich einer virtuellen Machine) bereitstellen kann. Diese Systeme werden in Docker Images beschrieben (eine Art Template oder Klasse). Von diesen Images lassen sich dann beliebig viele Laufzeitinstanzen starten. Jede Laufzeitinstanz eines Images wird Container genannt (sozusagen die konkrete Auspr{\"a}gung einer Systemklasse).  \newline % Row Count 8 (+ 8)
In jedem Container soll es nur einen Hauptthread geben. Solange dieser ausgeführt wird, gilt der Container als gestartet. Ist der Hauptthread beendet so geht der Container in den Zustand gestoppt über.  \newline % Row Count 13 (+ 5)
Die Images sind in Layer unterteilt. Jeder Layer enth{\"a}lt die Deltas welche auf dem Filesystem stattfanden. Images selbst sind TAR Archive. Die Layer im Image sind nur lesbar und nicht beschreibbar. \newline % Row Count 17 (+ 4)
Beim Start eines Containers wird auch ein zus{\"a}tzlicher beschreibbarer Layer on top angelegt. In diesem k{\"o}nnen die Anwendungen Änderungen am Filesystem vornehmen. Nach dem Stop eines Containers bleibt dieser Layer in diesem konkreten Container erhalten. Der Zustand l{\"a}sst sich per docker commit persistieren.  \newline % Row Count 24 (+ 7)
Docker Images k{\"o}nnen automatisiert per Dockerfile über docker build erstellt werden. Um die Gr{\"o}{\ss}e der Images klein zu halten (sie explodiert extrem schnell), sollte von kleinen Root Images (alpine) abgeleitet und ein Multistage Build genutzt werden. \newline % Row Count 30 (+ 6)
} \tn 
\end{tabularx}
\par\addvspace{1.3em}

\vfill
\columnbreak
\begin{tabularx}{8.4cm}{X}
\SetRowColor{DarkBackground}
\mymulticolumn{1}{x{8.4cm}}{\bf\textcolor{white}{Allgemeine Infos (cont)}}  \tn
\SetRowColor{white}
\mymulticolumn{1}{x{8.4cm}}{Container mit Sicherheitsinformationen wie Passw{\"o}rtern oder gültig konfigurierten GIT Zug{\"a}ngen sollte man niemals auf den HUB schieben! \newline % Row Count 3 (+ 3)
Wird ein Container auf einem Remote Host gestartet (z.B. weil dort der Docker Daemon l{\"a}uft) so beziehen sich die Parameter wie Port- und Volumenmappings auf diesen Remotehost.  \newline % Row Count 7 (+ 4)
Beim Mappen von Volumen werden die Berechtigungen wie User-ID und Gruppen-ID aus dem Container zum Schreiben auf das gemountete Volumen benutzt. Wenn die ID 100 im Container dem Nutzer jenkins geh{\"o}rt und der Hauptthread unter Nutzer jenkins l{\"a}uft und dieser auf die gemounteten Volumen schreibt, dann wird auf dem Host mit der Nutzer ID 100 geschrieben auch wenn diese dann dem Nutzer Klaus oder root geh{\"o}rt. Zur Anwendung kommen natürlich dann die Berechtigungen im Hostsystem. Wenn Klaus also keine Rechte zum Schreiben besitzt wird der Jenkins Nutzer aus dem Container im Host nicht auf das Volumen schreiben k{\"o}nnen.  \newline % Row Count 20 (+ 13)
Letztlich muss auch noch beachtet werden, dass Docker Images Architektur spezifisch sind. Falls das vom Hub geladene Image nicht zur ausführenden Architektur passt kann man versuchen es selbst auf dieser Architektur zu bauen. Dazu ben{\"o}tigt man natürlich das Dockerfile aber das ist über den Hub und die Verlinkung zum Projekt meist zu bekommen.  \newline % Row Count 27 (+ 7)
Problematischer wird es wenn das im Dockerfile genutzte base Image nicht Architektur agnostisch ist. Die aktuellen offiziellen Base Images gro{\ss}er Tools versuchen zwar agnostisch bzgl. der Architektur zu sein aber das muss man evtl. prüfen und kann es nicht einfach als gegeben hinnehmen.  \newline % Row Count 33 (+ 6)
} \tn 
\end{tabularx}
\par\addvspace{1.3em}

\vfill
\columnbreak
\begin{tabularx}{8.4cm}{X}
\SetRowColor{DarkBackground}
\mymulticolumn{1}{x{8.4cm}}{\bf\textcolor{white}{Allgemeine Infos (cont)}}  \tn
\SetRowColor{white}
\mymulticolumn{1}{x{8.4cm}}{( \seqsplit{https://stackoverflow.com/questions/52767983/docker-error-standard-init-linux-go185-exec-user-process-caused-exec-format-e} )% Row Count 3 (+ 3)
} \tn 
\hhline{>{\arrayrulecolor{DarkBackground}}-}
\end{tabularx}
\par\addvspace{1.3em}

\begin{tabularx}{8.4cm}{X}
\SetRowColor{DarkBackground}
\mymulticolumn{1}{x{8.4cm}}{\bf\textcolor{white}{Remotezugriff auf die Docker Engine}}  \tn
\SetRowColor{white}
\mymulticolumn{1}{x{8.4cm}}{ACHTUNG - Remote Zugriff ist B{\"o}se - Clients spielen Root - ACHTUNG \newline % Row Count 2 (+ 2)
Der Docker Deamon l{\"a}uft normalerweise lokal und stellt den Socket \newline % Row Count 4 (+ 2)
\seqsplit{`unix:///var/run/docker.sock`} für Anfragen von docker cli bereit.  \newline % Row Count 6 (+ 2)
Das kann herausgefunden werden mittels: \newline % Row Count 7 (+ 1)
`sudo netstat -lnpx | grep docker.sock` \newline % Row Count 8 (+ 1)
Die Default Ports des Deamon sind 2375 (unverschlüsselt) und 2376 (verschlüsselt).  \newline % Row Count 10 (+ 2)
Der aktuelle Status des Deamon l{\"a}sst sich so ermitteln: \newline % Row Count 12 (+ 2)
`systemctl status docker.service` \newline % Row Count 13 (+ 1)
Der Zugriff auf einen Remote Docker Deamon kann per REST API oder über Docker CLI oder einem Drittanbieter Client vorgenommen werden. \newline % Row Count 16 (+ 3)
1) Zugriff über Docker-CLI in der Shell \newline % Row Count 17 (+ 1)
Hier muss die Umgebungsvariable DOCKER\_HOST auf den Docker socket des Remote Daemon gesetzt werden. Ab da sendet Docker CLI alle Befehle an den Remote Deamon. Beispiel: \newline % Row Count 21 (+ 4)
`export \seqsplit{DOCKER\_HOST=tcp://X.X.X.X:2376`} \newline % Row Count 22 (+ 1)
2) Zugriff über das REST API \newline % Row Count 23 (+ 1)
Dokumentation der Doker Engine REST API: \seqsplit{https://docs.docker.com/engine/api/version-history/} \newline % Row Count 25 (+ 2)
Ein Beispiel für das Absetzen von Kommandos per REST Client: \newline % Row Count 27 (+ 2)
GET \seqsplit{http://x.x.x.x:2376/containers/json} -\textgreater{} entspricht einem docker ps \newline % Row Count 29 (+ 2)
Auf dem Rechner des Docker Deamon muss der REST Zugriff freigeschalten werden.  \newline % Row Count 31 (+ 2)
} \tn 
\end{tabularx}
\par\addvspace{1.3em}

\vfill
\columnbreak
\begin{tabularx}{8.4cm}{X}
\SetRowColor{DarkBackground}
\mymulticolumn{1}{x{8.4cm}}{\bf\textcolor{white}{Remotezugriff auf die Docker Engine (cont)}}  \tn
\SetRowColor{white}
\mymulticolumn{1}{x{8.4cm}}{API aktivieren ( \seqsplit{https://success.docker.com/article/how-do-i-enable-the-remote-api-for-dockerd} ): \newline % Row Count 2 (+ 2)
`\# \seqsplit{/etc/systemd/system/docker}.service.d/override.conf anlegen mit inhalt` \newline % Row Count 4 (+ 2)
`{[}Service{]}` \newline % Row Count 5 (+ 1)
`ExecStart=` \newline % Row Count 6 (+ 1)
\seqsplit{`ExecStart=/usr/bin/dockerd} -H fd:// -H tcp://0.0.0.0:2376` \newline % Row Count 8 (+ 2)
`\$ sudo systemctl daemon-reload` \newline % Row Count 9 (+ 1)
`\$ sudo systemctl restart docker.service` \newline % Row Count 10 (+ 1)
\# Docker Deamon bei Systemstart automatisch starten lassen \newline % Row Count 12 (+ 2)
`\$ sudo systemctl enable docker`% Row Count 13 (+ 1)
} \tn 
\hhline{>{\arrayrulecolor{DarkBackground}}-}
\SetRowColor{LightBackground}
\mymulticolumn{1}{x{8.4cm}}{Chrome REST Erweiterung: http://bit.ly/2Q4hJ9h \newline Docker CLI für Windows: \seqsplit{https://download.docker.com/win/static/stable/x86\_64/} \newline Docker Deamon Doku: \seqsplit{https://docs.docker.com/v17.09/engine/reference/commandline/dockerd/\#examples}}  \tn 
\hhline{>{\arrayrulecolor{DarkBackground}}-}
\end{tabularx}
\par\addvspace{1.3em}

\begin{tabularx}{8.4cm}{x{3.28 cm} x{4.72 cm} }
\SetRowColor{DarkBackground}
\mymulticolumn{2}{x{8.4cm}}{\bf\textcolor{white}{docker run  Options}}  \tn
% Row 0
\SetRowColor{LightBackground}
-i & interacive Mode = -a STDIN \tn 
% Row Count 2 (+ 2)
% Row 1
\SetRowColor{white}
-{}-sig-proxy=true & Alle Signale werden an den Containerthread weitergeleitet (nur ohne -t m{\"o}glich) \tn 
% Row Count 6 (+ 4)
% Row 2
\SetRowColor{LightBackground}
-t & Stellt im Container eine Pseudo TTY bereit \tn 
% Row Count 8 (+ 2)
% Row 3
\SetRowColor{white}
-a stderr -a stdin -a stdout & -a verbindet stellt Streams des Hosts im Container zur Verfügung. Gülige Werte: STDIN, STDOUT, STDERR \tn 
% Row Count 13 (+ 5)
% Row 4
\SetRowColor{LightBackground}
-D & Schaltet den Debug Mode aktiv \tn 
% Row Count 15 (+ 2)
\hhline{>{\arrayrulecolor{DarkBackground}}--}
\SetRowColor{LightBackground}
\mymulticolumn{2}{x{8.4cm}}{Aufbau der Kommandozeile:  \newline docker run {[}OPTIONS{]} IMAGE{[}:TAG|@DIGEST{]} {[}COMMAND{]} {[}ARG...{]} \newline  \newline Details siehe hier: \seqsplit{https://docs.docker.com/v17.09/engine/reference/run/\#foreground}}  \tn 
\hhline{>{\arrayrulecolor{DarkBackground}}--}
\end{tabularx}
\par\addvspace{1.3em}

\begin{tabularx}{8.4cm}{X}
\SetRowColor{DarkBackground}
\mymulticolumn{1}{x{8.4cm}}{\bf\textcolor{white}{Multistage Builds (Kompaktiere das Image)}}  \tn
\SetRowColor{white}
\mymulticolumn{1}{x{8.4cm}}{Kleine und kompakte Images zu erzeugen war bislang schwierig - der alte Trick alles in eine Zeile zu pappen und mit \&\&  zu verknüpfen ist schwer wartbar und docker erkennt nicht immer wenn etwas neu gebaut werden muss. Dann gibt es hier und da auch schon mal veraltete images in denen die Änderung von eben gar nicht gegriffen hat.  \newline % Row Count 7 (+ 7)
Die L{\"o}sung: Multistage Builds durch mehrere FROM Anweisungen im Dockerfile. Der Trick dabei: {\bf{COPY -{}-from=0 }}kopiert nur die Deltas aus dem letzten Stage (Das 0. FROM).  \newline % Row Count 11 (+ 4)
Besser Du benennst die einzelnen Stages: \newline % Row Count 12 (+ 1)
`FROM golang:1.7.3 as builder` \newline % Row Count 13 (+ 1)
und nutzt die benannten Stages so: \newline % Row Count 14 (+ 1)
`COPY -{}-from=builder ...`% Row Count 15 (+ 1)
} \tn 
\hhline{>{\arrayrulecolor{DarkBackground}}-}
\SetRowColor{LightBackground}
\mymulticolumn{1}{x{8.4cm}}{Quelle: \seqsplit{https://docs.docker.com/v17.09/engine/userguide/eng-image/multistage-build/\#use-multi-stage-builds}}  \tn 
\hhline{>{\arrayrulecolor{DarkBackground}}-}
\end{tabularx}
\par\addvspace{1.3em}

\begin{tabularx}{8.4cm}{X}
\SetRowColor{DarkBackground}
\mymulticolumn{1}{x{8.4cm}}{\bf\textcolor{white}{Docker Image Analyse}}  \tn
\SetRowColor{white}
\mymulticolumn{1}{x{8.4cm}}{{\bf{Lokale Ablage der Images}} \newline % Row Count 1 (+ 1)
* \seqsplit{https://stackoverflow.com/questions/19234831/where-are-docker-images-stored-on-the-host-machine} \newline % Row Count 3 (+ 2)
{\bf{Image Formate}} \newline % Row Count 4 (+ 1)
* aufs \newline % Row Count 5 (+ 1)
* overlay2 \newline % Row Count 6 (+ 1)
* ... \newline % Row Count 7 (+ 1)
{\bf{Grobe Infos auslesen}} \newline % Row Count 8 (+ 1)
`\textgreater{}docker image inspect \textless{}imageId\textgreater{}` \newline % Row Count 9 (+ 1)
{\bf{Image Explorer Werkzeuge}} \newline % Row Count 10 (+ 1)
* \seqsplit{https://github.com/wagoodman/dive} \newline % Row Count 11 (+ 1)
{\bf{Image per Hand extrahieren}} \newline % Row Count 12 (+ 1)
`\textgreater{}docker save \textless{}imageId\textgreater{} -o \textless{}filename\textgreater{}.tar`% Row Count 13 (+ 1)
} \tn 
\hhline{>{\arrayrulecolor{DarkBackground}}-}
\end{tabularx}
\par\addvspace{1.3em}

\begin{tabularx}{8.4cm}{X}
\SetRowColor{DarkBackground}
\mymulticolumn{1}{x{8.4cm}}{\bf\textcolor{white}{Spezifische Eclipse Installation erstellen}}  \tn
\SetRowColor{LightBackground}
\mymulticolumn{1}{x{8.4cm}}{\textgreater{}sudo docker run -it -e DISPLAY -v \seqsplit{/tmp/.X11-unix:/tmp/.X11-unix} batmat/docker-eclipse \newline  \newline ; jetzt alle Plugins installieren und in einer anderen console folgendes eingeben \newline \textgreater{}docker ps \newline ; Hiermit l{\"a}sst sich die Container ID bestimmen und mit \newline \textgreater{}docker commit containerID  \seqsplit{username/imagename:version} \newline ; den Container als Image persistieren. \newline ; Das neue Image l{\"a}sst sich dann starten mit: \newline \textgreater{}sudo docker run -it -e DISPLAY -v \seqsplit{/tmp/.X11-unix:/tmp/.X11-unix} containerID:version} \tn 
\hhline{>{\arrayrulecolor{DarkBackground}}-}
\SetRowColor{LightBackground}
\mymulticolumn{1}{x{8.4cm}}{Der Hauptgrund für dieses Vorgehen ist ein bestehendes Linux System welches nicht ver{\"a}ndert werden soll. Dennoch m{\"o}chte man manchmal mit einer Eclipse-Luna neue DSLs entwickeln und mit einer Eclipse-Kepler neue RPC Anwendungen schreiben. Die ben{\"o}tigten Plugins und deren richtige Version k{\"o}nnen ein in die H{\"o}lle treiben. Daher ganz entspannt zukünftig nur den richtigen Docker Container starten. Klar vorher einmal bereitstellen :)}  \tn 
\hhline{>{\arrayrulecolor{DarkBackground}}-}
\end{tabularx}
\par\addvspace{1.3em}

\begin{tabularx}{8.4cm}{X}
\SetRowColor{DarkBackground}
\mymulticolumn{1}{x{8.4cm}}{\bf\textcolor{white}{Docker URL Aufbau}}  \tn
\SetRowColor{white}
\mymulticolumn{1}{x{8.4cm}}{Allgemeine Syntax für Docker URL: {[}registry-url{]}/{[}namespace{]}/{[}image{]} \newline % Row Count 2 (+ 2)
zum Beispiel: \seqsplit{docker.io/library/mysql:latest}% Row Count 3 (+ 1)
} \tn 
\hhline{>{\arrayrulecolor{DarkBackground}}-}
\end{tabularx}
\par\addvspace{1.3em}


% That's all folks
\end{multicols*}

\end{document}