Installation Docker

Nach vielen Versuchen mit unterschiedlichen Konfigurationen, habe mich vor 3 Jahren dazu entschieden mein SmartHome in Docker Containern zu betreiben.

Der Vorteil ist hier auf jeden Fall die Trennung der Konfiguration von der Applikation.

Das macht die Updates einfacher und die einzelnen Module lassen sich gut strukturieren. In der Zeit vor Docker hatte ich immer wieder mit Fehl Konfiguration des Linux Rechners zu tun, was dann eine Neuinstallation zur Folge hatte.

Installationsschritte

  • Update des Betriebssystem
  • Download des Installationsskriptes und Installation
  • Erlaubnis für Non Root User, Docker Kommandos auszuführen
  • Überprüfen der Docker Installation
  • Installation „Portainer“ zur Administration

Für das Tutorial nutze ich den Rechner „raspy3“ und den Benutzer „pi“

Update und Upgrade

Login auf den Rechner - ssh pi@raspy3
pi@raspy3:~ $ sudo apt-get update && sudo apt-get upgrade

Das kann ein wenig dauern. Die Abfragen für den positiven Fortgang beantworten.

Installation Docker

Zuerst das Docker Installations script laden

curl -fsSL https://get.docker.com -o get-docker.s

Das heruntergeladene Script wird dann ausgeführt

sudo sh get-docker.sh

Im Normalfall hat nur der ROOT User die Berechtigung die Container zu verwalten. Solltest Du nicht als ROOT eingeloggt sein, erhälst Du die Rechte mit dem „sudo“ Befehl.

Um das zu vereinfachen wird der gewünschte Benutzer der Gruppe docker zugefügt.

sudo usermod -aG docker <username>

Überprüfen der Docker Version

docker version

Installation Portainer

Hilfe für Portainer

Ich bin ein Freund graphischer Interfaces. So auch hier in docker.

Als Adminstrations Werkzeug ist Portainer sicher die gängigste Applikation.

Ich verwende zur Ablage der Konfigurationsdaten immer das lokale Dateisystem und keine Docker Volumes. Vielleicht ist das manchmal etwas aufwendiger, aber für mich einfacher zu administrieren.

Alle meine Docker Konfigurationen werden unter „/usr/share“ abgelegt.

sudo mkdir /usr/share/portainer

Bash Funktion

Für die Installation / Update des Portainers habe ich mir in „~/.bash_aliases“ eine Funktion geschrieben

function update_portainer {
local fileshare="/usr/share/portainer"
local container="Portainer"
local image="portainer/portainer-ce"

docker pull $image
docker container stop $container
docker rm $container

docker run -d -p 8000:8000 -p 9000:9000 --name="$container" -v /var/run/docker.sock:/var/run/docker.sock -v $fileshare:/data $image
}

Installationskommando

update_portainer

oder

docker run -d -p 8000:8000 -p 9000:9000 --name="Portainer" -v /var/run/docker.sock:/var/run/docker.sock -v Uusr/share/portainer:/data portainer/portainer-ce

Portainer aufrufen

https://<hostname>:9000

Weiterführend

Gute Tipps zum Thema Docker habe ich hier gefunden

https://phoenixnap.com/kb/docker-run-command-with-examples

Linux Basis Konfiguration

Mit der Installation des Images entsteht ein funktionaler Rechner. Was ihm jetzt noch fehlt ist das gewisse Etwas. Das was das leben mit Linux einfacher macht.

Das ist in meinen Augen eine brauchbare Konfiguration der Aliase und des VI. JA, ich bin einer derjenigen, die auf Linux mit dem VI arbeiten.

VIMRC

Hier die Auszüge meiner „~/.vimrc“ Datei.

set nocompatible
filetype indent plugin on
syntax on
colo desert
set hidden
set wildmenu
set showcmd
set hlsearch
set ignorecase
set smartcase
set backspace=indent,eol,start
set autoindent
set nostartofline
set ruler
set laststatus=2
set confirm
set visualbell
set t_vb=
set cmdheight=2
set number
set notimeout ttimeout ttimeoutlen=200
set pastetoggle=<F11>
set shiftwidth=2
set softtabstop=2
set expandtab
map Y y$
nnoremap <C-L> :nohl<CR><C-L>

Aliase

Ich bin nicht der größte Fan von „cd…“ Aliasen, aber so ein paar dann doch schon.

~/.bash_aliases

alias ag='alias | grep -i $1'
alias hg='history | grep -i $1'
alias va='vi ~/.bash_aliases && . ~/.bashrc'
alias ..='cd ..'
alias ...='cd ../..'

alias l='ls -ltra'
alias ll='ls -l'
alias la='ls -la'
alias ltra='ls -ltra'
alias lr='ls -lr'

alias cdplugins='cd /usr/lib/check_mk_agent/plugins'
alias cdconf='cd /etc/check_mk'
alias cdha='cd /usr/share/homeassistant'
alias tf='tail -f $1'
alias thl='tail -f /usr/share/homeassistant/home-assistant.log'
  • „ag“ – „alias | grep $1“ :: findet den Alais zu einem Suchbegriff
  • „hg“ – findet den Suchbegriff in der history
  • „va“ – öffnet die „~/.bash_aliases“ Datei im VI und lädt diese nach Beenden erneut. Damit stehen neue Aliase gleich zur Verfügung
  • „..“ – ein Verzeichnis zurück
  • „…“ – 2 Verzeichnisse zurück

Funktionen

Um einfach Ordner und Filerechte zu ändern, habe ich eine Funktion in eingebaut. Sicher wäre das auch als Shellscript im Suchpfad gegangen, aber es war eine Übung.

function chgdirgrants {
  local dir="$1"
  local usr="$2"
  local grp="$3"
  local dir_grants=$4
  local file_grants=$5

  if [ -z "$dir" ] ; then dir="." ; fi
  if [ -z "$usr" ] ; then usr="pi" ; fi
  if [ -z "$grp" ] ; then grp="docker" ; fi
  if [ -z "$dir_grants" ] ; then dir_grants=775 ; fi
  if [ -z "$file_grants" ] ; then file_grants=664 ; fi

  if [ -z $1 ] ; then
    echo "chdirgrants is a function to change grants on a subtree"
    echo ""
    echo "chdirgrants DIRECTORY USER GROUP DIR_GRANTS FILE_GRANTS"
    echo ""
    echo "All parameters will set to default values if they are missing! keep aware of that!"
    echo ""
    echo "Default values are:"
    echo ""
    echo "DIRECTORY: \"$dir\""
    echo "USER: \"$usr\""
    echo "GROUP: \"$grp\""
    echo "DIR_GRANTS: \"$dir_grants\""
    echo "FILE_GRANTS: \"$file_grants\""
    echo ""
    return 1
  fi

  echo "Directory to edit: \"${dir}\""
  echo "User \"$usr\" get Owner"
  echo "Group \"$grp\" get Group"
  echo "Directory  Grants: \"$dir_grants\""
  echo "File Grants: \"$file_grants\""
  echo ""
  local STEP_CHOWN="sudo chown -R $usr $dir"
  local STEP_CHGRP="sudo chgrp -R $grp $dir"
  local STEP_CHMOD="sudo chmod $dir_grants $dir"
  local STEP_SUBDIRS="sudo find $dir -type d -exec sudo chmod $dir_grants {} \;"
  local STEP_SUBFILES="sudo find $dir -type f -exec sudo chmod $file_grants {} \;"

  echo "$STEP_CHOWN"
  echo "$STEP_CHGRP"
  echo "$STEP_CHMOD"
  echo "$STEP_SUBDIRS"
  echo "$STEP_SUBFILES"
  echo ""
  echo "Press 1 to go on or  Return break"

  read choice

  case $choice in
    1)
      echo go on
      ;;
    *)
      echo "Will cancel :-("
      return 1
      ;;
  esac

  eval $STEP_CHOWN
  eval $STEP_CHGRP
  eval $STEP_CHMOD
  eval $STEP_SUBDIRS
  eval $STEP_SUBFILES
}

Die 3 PIs

Ich habe meine Anwendungen auf 3 Raspberrys verteilt. Die Aufteilung geschah nach unterschiedlichen Gesichtspunkten:

  • verfügbare Hardware
  • sinnvolle Gruppierung
  • Sicherheit
  • Performance

Verfügbar hatte ich 2x RP3 B+ und einen RP4. Für einen 3er eines USB-SATA Adapter und einen für den 4er. Dazu 2 MSATA Karten.

Sinnvolle Gruppierung:

  • Infrastruktur
  • Administration
  • Smarthome

Sicherheit:

Da ich eine Certificate Authority erstellen wollte, sollte diese unbedingt auf einen eigenen Rechner. 

Infrastruktur:

Für den Zugriff von Aussen habe ich ein VPN Gateway installiert. Dass dieses weder auf dem SmartHome Rechner noch auf dem mit der CA laufen soll geben Sicherheitsaspekte vor.

Also ergab sich folgende Aufteilung:

  • raspy3 – Raspberry 3 mit SD
    • Wireguard VPN Gateway
    • SAMBA Server
  • raspy4 – Raspberry 3 mit SSD
    • Administrations Desktop 
    • Certificate Authority
  • raspy5 – Raspberry PI4 mit SSD
    • Docker
    • Homeassistant
    • deConz
    • OZW Gateway
    • Mosquitto MQTT Server

Ich installiere meine PIs immer mit dem Standard Raspberry PI OS. Download hier.