Eigenen Docker Container erstellen

Eigenen Docker Container erstellen – Was brauchen wir?

Natürlich muss auf deinem Server oder Raspberry Pi der Docker Dienst installiert sein und auch Portainer ist sehr hilfreich – allerdings optional.
Solltest du bisher noch kein Docker nutzen, empfehle ich dir erst einmal folgenden Artikel von mir durchzugehen:

Eigene Entwicklungsumgebung in einem Docker Container

Bevor wir starten und einen eigenen Container (Image) erstellen, mit dem wir dann weiter experimentieren und ihn anpassen können, hier ein kleiner Hinweis zur Begrifflichkeit:

Wenn ich im Folgenden von “dev-env” spreche, meine ich damit “development environment” – also eine Entwicklungsumgebung.

Wozu du letztendlich deinen eigenen Docker Container erstellen willst, bzw. danach nutzen möchtest, ist grundsätzlich nicht wichtig. Ich möchte dir lediglich aufzeigen, wie du einen solchen Container generell erstellen kannst.
Sobald du die Schritte dahinter – die wirklich nicht sehr kompliziert sind – verstanden hast, wirst du auch in der Lage dazu sein, deinen eigenen Docker Container nach deinen Bedürfnissen anzupassen!

Starten wir mit der folgende Ausgangslage:
Wir erstellen einen Docker-Container zum Entwickeln weiterer Python-Applikationen, die später in einem eigenen Docker-Image eingebunden werden.
Dies dient als Grundlage, um direkt in einem Docker Container entwickeln zu können.

Das Ganze läuft bei mir auf folgenden Komponenten:

Werbung

Vorschau	Produkt	Preis
	Raspberry Pi 4 Modell B; 4 GB, ARM-Cortex-A72 4 x, 1,50…	69,99 EUR	Bei Amazon kaufen
	Raspberry 4596 Pi – offizielles Netzteil für Raspberry…	10,42 EUR	Bei Amazon kaufen
	Miuzei Gehäuse für Raspberry Pi 4 mit Lüfter, 5.1V…	23,00 EUR 15,99 EUR	Bei Amazon kaufen
	SD kartenleser 5 in 1 USB 3.0, Aluminiumlegierung mit…		Bei Amazon kaufen
	Samsung MZ-76E1T0B/EU 860 EVO 1 TB SATA 2,5″ Interne…	164,90 EUR 157,40 EUR	Bei Amazon kaufen
	UGREEN Festplattengehäuse 2,5 Zoll USB C 3.2 Gen 2 auf…	19,99 EUR 15,68 EUR	Bei Amazon kaufen
	JSAUX USB 3.0 auf SATA Adapter, USB 3.0 zu 2,5 Zoll…	11,99 EUR 10,19 EUR	Bei Amazon kaufen

Letzte Aktualisierung am 28.04.2024 (Preise können abweichen) / Infos zu Affiliate Links / Bilder von der Amazon Product Advertising API

Affiliate – Links

DarkWolfCave.de ist Teilnehmer des Amazon-Partnerprogramm, das zur Bereitstellung eines Mediums für Webseiten konzipiert wurde, mittels dessen durch die Platzierung von Partner-Links zu Amazon.de Entgelte verdient werden können.

Weitere Infos zu Affiliate-Links

Wir nutzen wie immer einen Raspberry Pi (ich mag ihn einfach…) und erstellen uns erst einmal eine Ordnerstruktur – in meinem Fall speichere ich alles unter dem angemeldeten User/tutorials/eigene_docker_container/dev-env.
Wenn du diesem Beispiel folgen möchtest, musst du dich lediglich auf deinen Raspberry mit einem Terminal und deinem User verbinden.

Mit mkdir ~/tutorials/eigene_docker_container/dev-env erstellst du dann im Home-Verzeichnis die entsprechenden Ordner.

Wechsel jetzt mit cd ~/tutorials/eigene_docker_container/dev-env in das neu angelegte Verzeichnis.

Hier erstellen wir direkt zwei leere Dateien. Beachte dabei unbedingt, dass die Datei “Dockerfile” genauso – also großes D – genannt wird:

touch Dockerfile
touch requirements.txt

Ich werde dieses Image später dazu nutzen, ein paar Applikationen unter Python zu entwickeln. Daher füge ich erst einmal ein paar grundlegende Anforderungen hinzu. Sollte ich im Laufe des Entwickelns feststellen, dass ich noch andere Python Bibliotheken benötige, wird dies direkt dokumentiert und später genauso in ein finales Image eingebunden.
Also bearbeiten wir die requirements.txt, fügen folgendes hinzu und speichern die Änderungen:

Flask==2.0.1
requests==2.26.0
tabulate

Als nächstes bearbeiten wir das, aktuell noch leere, Dockerfile und tragen ein paar Dinge dort ein. Es handelt sich um diverse Build-Befehle. Für mehr Informationen schaue bitte in die offizielle Dokumentation.

# Verwenden eines offiziellen Basisimage für Python 3.11
FROM python:3.11

# hier legen wir das Arbeitsverzeichnis innerhalb des Containers fest
WORKDIR /app

# Kopieren der requirements.txt in den Container
COPY requirements.txt requirements.txt

# Jetzt installieren wir alles aus der requirements.txt
RUN pip install -r requirements.txt

# Bibliotheken updaten und ein paar Entwicklertools hinzufügen (hier git und build-essential was ein Metapaket ist, das grundlegende Entwicklertools wie Compiler und Bibliotheken enthält)
RUN apt-get update && apt-get install -y \
    build-essential \
    git \
    && rm -rf /var/lib/apt/lists/*

Jetzt erstellen wir ein Image mit:

docker build -t dev-env-container:v1 .

Du kannst grundsätzlich direkt über das Terminal den Container starten oder den Weg über Portainer nutzen.

Terminal-Variante:

docker run --name dev-env-container -it dev-env-container:v1 bash

Der Befehl startet und verbindet dich direkt mit dem Container.
Du solltest dann im Prompt /app# sehen (dein festgelegtes Arbeitsverzeichnis).
Mit exit verlässt und beendest du den Container wieder.

Container über Portainer bereitstellen

Einfach den Namen des Images bei “Create Container” unter “Image” eintragen.
Und nicht durch das docker.io irritieren lassen. Da Portainer ja lokal auf unsere Images zugreift, findet er unser neu Erstelltes auch entsprechend und sucht nicht bei docker.io.
Hast du das Image nicht auf dem System erstellt, wo auch Portainer läuft, müsstest du noch entsprechend eine neue Registry erstellen. Dies wäre aber ein eigenes Thema und wird heute hier nicht behandelt.

Wir geben noch den Port an, da ich auch eine WebGui bereitstellen möchte und diese über den entsprechenden Port erreicht werden soll. Beispielhaft nehmen wir zum Testen den Port 5666.
Weiterhin auf jeden Fall unter dem Punkt “Advanced container settings” und “Console” die Auswahl “Interactive & TTY” auswählen

Mit Container verbinden

Diesen können wir über Portainer oder unser LinuxTerminal erreichen.

Für das Terminal:

docker exec -it dev-env-container /bin/bash

#mit exit kannst du den Container wieder verlassen

Für Portainer:

In der Portainer GUI auf “Container Übersicht“, und dann den kleinen Button klicken. Ein weiterer Klick auf Connect und du befindest dich in einem Terminal wieder.
Damit dies funktioniert musst du aber bei dem Deployment zuvor die Option “Interactive & TTY” unter dem Punkt “Advanced container settings” und “Console” ausgewählt haben.

Wenn du meiner Anleitung gefolgt bist, solltest du dich jetzt innerhalb deines Containers im Pfad /app befinden. Dieser ist natürlich noch komplett leer.

Allerdings haben wir ja python installiert. Dies startest du mit python und befindest dich in der entsprechenden Prompt-Umgebung. Mit exit() kannst du es verlassen.

In deinem eigenen Docker Container kannst du jetzt herumexperimentieren, Scripts entwickeln usw.

Bedenke aber: mit der normalen Installation sind alle Container Inhalte flüchtig, und entsprechend wieder weg, sobald du deinen Container neu aufsetzen würdest. Bei einem einfachen Stopp und Neustart bleiben deine nachträglich hinzugefügten Daten in der Regel (gibt Ausnahmen) erhalten.

Du kannst allerdings persistente Volumes außerhalb des Containers erstellen und mit dem ‘Inneren’ verbinden. Diese Thematik wurde bereits in meinen Artikeln zu Docker- und Portainer-Installationen behandelt.

Wie geht es jetzt weiter?

In diesem Artikel ging es in erster Linie darum, dir zu zeigen wie du einen eigenen Container aus Images erstellen, an deine Bedürfnisse anpassen, und als eigenes Image einbinden kannst.

Was du jetzt benötigst musst du selbst wissen. Beispielsweise als Basis ein Ubuntu-Image und dann erweitern mit Mysql-Server, Apache usw.
Du kannst alles wie oben beschrieben über das Dockerfile entsprechend einbinden.

Ich hoffe ich konnte dir ein wenig helfen und bin auch für weitere Fragen gerne für dich da. Schreibe in den Kommentaren oder schaue bei Discord vorbei.

Kurze Zusammenfassung

• auf deinem Raspberry eine Ordnerstruktur erstellen wo du alles für deinen eigenen Docker Container speichern kannst
• dort zwei Dateien erstellen:
  touch Dockerfile
  touch requirements.txt
• in requirements.txt kommen alle Python-Abhängigkeiten hinein
• in Dockerfile alle Build-Befehle
• Build erstellen mit: docker build -t dev-env-container:v1 .
• Container über Terminal bereitstellen: docker exec -it dev-env-container /bin/bash
• Im Container weiteres zum testen nachinstallieren. Alles was benötigt wird am besten direkt in das Dockerfile eintragen (oder requirements.txt falls es sich um Python Abhängigkeiten handelt)
• Final mit allem zufrieden und hoffentlich dokumentiert?
  Dann wieder ein neues Build erstellen (v1.1 oder so)
  usw.

FAQ´s

Was ist Docker?

Docker ist eine Container-Plattform, die es ermöglicht, Anwendungen und deren Abhängigkeiten in isolierten Umgebungen, sogenannten Containern, zu verpacken und auszuführen. Diese Container sind leichtgewichtige, tragbare und konsistente Einheiten, die eine reibungslose Bereitstellung von Anwendungen über verschiedene Umgebungen hinweg ermöglichen.

Was ist das Ziel dieses Artikels?

Dieser Artikel zeigt, wie du deinen eigenen Docker Container erstellen kannst. Ob du ein erfahrener Tech-Enthusiast mit einer eigenen Entwicklungsumgebung bist oder gerade erst in die Welt der Containerisierung einsteigst, hier findest du eine detaillierte Anleitung, um deine eigene Entwicklungs-Containerumgebung einzurichten.

Welche Voraussetzungen sind notwendig?

Auf deinem Server oder Raspberry Pi muss der Docker-Dienst installiert sein. Portainer ist hilfreich, aber optional. Falls du bisher noch kein Docker nutzt, wird ein empfohlener Artikel bereitgestellt, den du vorab durchgehen kannst.

Was bedeutet “dev-env” in diesem Kontext

Wenn im Folgenden von “dev-env” die Rede ist, bezieht sich dies auf “development environment” – also eine Entwicklungsumgebung.

Meine Frage steht hier nicht!

Du hast weitere Fragen oder benötigst Hilfe? Gerne versuche ich im Rahmen meiner Möglichkeiten dich zu unterstützen. Dafür kannst du hier die Kommentar-Sektion (nicht vergessen Antworten zu abonnieren) nutzen oder du schaust auf meinem Discord-Kanal vorbei.