Docker auf anderen Pfad einstellen

Dienstag, Januar 10, 2017 by crypti

Da speziell ein Yocto-Build sehr viel Speicherplatz benötigt und mein System nicht allzuviel Platz besitzt (nach 2-3 Builds war die Festplatte voll) habe ich mir eine extra Festplatte für Docker in meinen PC eingebaut.

Diese Festplatte habe ich im ersten Schritt in die fstab eingetragen:

/dev/sdb2  /docker ext4 defaults,noatime,discard,rw,exec 0 1

Wichtig hierbei ist (bei der aktuelle Manjaro-Version 4.4.39-Kernel) die exec-Option, da ansonsten möglicherweise beim Start des docker-Images die Fehlermeldung:

standard_init_linux.go:175: exec user process caused “permission denied”

erscheint.
Anschließend wird der docker-Ordner gemounted:

sudo mount /docker

Nun erzeugt man ein Verzeichnis docker.service.d in /etc/systemd/system:

sudo mkdir /etc/systemd/system/docker.service.d

und anschließend eine Datei imagelocation.conf

sudo vi /etc/systemd/system/docker.service.d/imagelocation.conf

Hier trägt man dann folgende Zeilen ein:

[Service]
ExecStart=
ExecStart=/usr/bin/dockerd -g /docker -H fd://

Nun kann man alle Dateien von /var/lib/docker in das neue Docker-Verzeichnis kopieren:

sudo cp -r /var/lib/docker/ /docker

Nach Abschluss des Kopierens wird der docker-Dienst neu gestartet:

sudo systemctl restart docker

Mit dem Befehl:

docker info

kann überprüft werden, ob das Umstellen funktioniert hat. Hier sollte “Docker Root Dir” auf /docker stehen.

Tablespaces in Oracle anlegen

Freitag, Oktober 28, 2016 by crypti

Obwohl das zum “Standard-Reportoire” eines Datenbank-Admins gehört, vergesse ich laufend die Standard-Optionen beim Anlegen von Tablespaces. Weil ich das doch mal ab und zu brauche, hier ein paar kurze Befehlszeilen zum Anlegen von Tablespaces.

Normalen Tablespace anlegen

create tablespace <tablespace_name> 
   datafile '<location>' 
   size <ts_size> 
   autoextend on 
   next <increaseSize>
   maxsize unlimited
   extent management local

Temporären Tablespace anlegen

create temporary tablespace <tablespace_name>
  tempfile '<location>'
  size <ts_size>
  autoextend on
  next <increaseSize>
  maxsize unlimited
  extent management local

Yocto im Docker-Image auf Manjaro

Donnerstag, August 4, 2016 by crypti

Wie bereits im vorigen Thread (Makulu Linux Tutorial) angekündigt, werde ich heute ein kleines Tutorial schreiben, wie man Yocto in einem Docker-Image unter Manjaro Linux zum laufen bekommt.

Grundsystem aktualisieren und Docker installieren

Als Basis nehme ich ein Manjaro Linux, das ich erst einmal mit:

sudo pacman -Sy

und

sudo pacman -Su

auf aktuellen Stand bringe.

Anschließend installiere ich docker mit:

sudo pacman -S docker

Dabei wird der eigentliche docker installiert d.h. client und server.

Update 04.09.2016

Da ich auf meinem neuen Notebook kein Manjaro zum laufen bekomme, hier noch kurz eine Anleitung,
wie man docker in Ubuntu 16.04 LTS installiert:

Erst einmal wird das Ubuntu aktualisiert:

sudo apt-get update
sudo apt-get upgrade
sudo apt-get dist-upgrade

sollte dabei ein neuer Kernel installiert werden, macht am besten ein Reboot des Systems um den neuen Kernel zu aktivieren.

Anschließend können wir docker mit:

sudo apt-get install docker.io

installieren. Hier auf docker.io achten, da es auch das Paket docker gibt.

Weiter gehts, egal, ob Manjaro oder Ubuntu

Nach der Installation wird erst einmal der docker-Dämon aktiviert und gestartet:

sudo systemctl enable docker

und

sudo systemctl start docker

Damit docker unter Eurem Nutzer läuft, müsst ihr mit:

usermod -a -G docker <nutzername>

euch der Gruppe docker zuordnen. Solltet ihr das nicht machen, bekommt ihr bei Start von Docker immer folgende Meldung:

Cannot connect to the Docker daemon. Is the docker daemon running on this host?

Nach Zuordnung der Gruppe loggt ihr Euch entweder aus und neu ein, macht ein reboot oder könnt viel einfacher noch Euch die Gruppe quasi neu zuordnen:

newgrp docker

Docker ausprobieren

Nun könnt ihr den ersten docker-Befehl ausprobieren:

docker run hello-world

und wenn alles gut gelaufen ist, meldet sich Docker mit einer Willkommens-Nachricht.

Soviel erst mal zur grundsätzlichen Einrichtung. Nun geht es ans eingemachte - der Installation einer virtuellen Ubuntu-Umgebung unter Docker.

Grundsystem im Docker aufsetzen

Als basis für den Build nehme ich ubuntu 14.04. Im Github kann man sehen, dass ein “normales” Ubuntu-Image unter : ubuntu:14.04 abrufbar ist. Das wird dann gleich gepullt.

docker pull ubuntu:14.04

Nun kann mit:

docker run -it ubuntu:14.04 /bin/bash

eine bash im ubuntu-System geöffnet werden. In der Bash des Docker-Containers wird erst mal eine Aktualisierung von apt vorgenommen und die für den Build notwendigen Komponenten installiert:

 apt-get update
 apt-get upgrade
 apt-get install wget unzip make 
  g++ python git diffstat 
  texinfo gawk chrpath libsdl1.2-dev

Jetzt legen wir einen Nutzer an:

useradd -m -s /bin/bash -U smx6Dev -p test

und die verschiedenen Verzeichnisse für den Nutzer:

 mkdir /home/smx6Dev/Downloads
 mkdir /home/smx6Dev/build

Nach Anlegen der Verzeichnisse wird das Yocto-Image vom Kugelmann-Server geholt:

wget -O /home/smx6Dev/Downloads/Yocto_Linux_BSP_SMARC-sAMX6i_R02.10.zip http://public.kugelmann.com/yocto/Yocto_Linux_BSP_SMARC-sAMX6i_R02.10.zip

und entpackt:

unzip /home/smx6Dev/Downloads/Yocto_Linux_BSP_SMARC-sAMX6i_R02.10.zip -d /home/smx6Dev/Downloads

mit den beiden Befehlen:

tar -C /home/smx6Dev/build -xzf /home/smx6Dev/Downloads/sources-base.tar.gz 
 tar -C /home/smx6Dev/build -xzf /home/smx6Dev/Downloads/sources-meta-smx6.tar.gz

werden die Yocto-Sourcen entpackt. Bevor wir uns anmelden und die eigentlichen Yocto-Sachen machen, wird noch der owner umgestellt:

chown smx6Dev:smx6Dev -R /home/smx6Dev/build
 chown smx6Dev:smx6Dev /home/smx6Dev/Downloads

Wenn das getan ist, kann man sich als smx6Dev einloggen:

su - smx6Dev

Nun wechselt man ins build-Verzeichnis und ruft das setup-environment auf:

cd build
 source ./sources/meta-smx6/setup-environment ./build

auf. Last but not least kann dann mit:

bitbake smx6-image

das Bauen des Images angestoßen werden.

Um das ganze noch zu vereinfachen, habe ich ein Image gebaut. Die Einzelnen Schritte sind in dem folgenden Docker-File beschrieben. Falls ihr das benutzen wollt, benennt bitte die Datei in Dockerfile um (ohne txt!).

Wenn man den Docker-Container verlässt, kann man mit:

docker build -t yocto-build .

ausgeführt im Verzeichnis, wo das Dockerfile liegt, ein eigenes Image bauen. Das habe ich jedoch bereits gemacht und es in mein Dockhub-Repository hochgeladen.

Um es abzurufen, muss man sich erst einloggen (als crypti76):

docker login --username=crypti76

und kann dann mit:

docker run -it crypti76/smx6image:latest /bin/bash

das fertig vorbereitete image starten und die letzten Schritte (ab anmelden als smx6Dev) durchführen.