Docker erklärt: Wie man Python-Webanwendungen containerisiert

Einführung

Die Gefahr, dass eine Webanwendung entführt und zur Übernahme des gesamten Hosts verwendet wird, ist groß und beängstigend. Es war schon lange eine Herausforderung, die Dinge zur Verbesserung der Sicherheit voneinander isoliert zu halten, insbesondere wenn die Anwendungen verschiedenen Kunden gehören. Es können viele Maßnahmen ergriffen werden, um dieses unglückliche Szenario zu verhindern; sie sind jedoch meist entweder zu kostspielig (sowohl in Bezug auf Zeit als auch auf Ressourcen) oder zu kompliziert für die meisten Anwendungsfälle von Entwicklern oder Administratoren.

In diesem DigitalOcean-Artikel werden wir über das "Containerisieren" von Python-Webanwendungen sprechen, um sie in sehr sicheren Sandkästen zu haben, die absolut in ihren eigenen Umgebungen gehalten werden (es sei denn, Sie verlinken sie ausdrücklich mit einer anderen). Um dies zu erreichen, werden wir Schritt für Schritt einen Docker-Container erstellen, um eine Python-Webanwendung zu hosten, und schließlich unsere Build-Prozesse mit einer Dockerfile automatisieren.

Glossar

1. Docker in Kürze

2. Docker auf Ubuntu installieren

3. Grundlegende Docker-Befehle

1. Den Docker-Daemon ausführen und die CLI-Nutzung
2. Docker-Befehle

4. Erstellen eines Docker-Containers zum Sandboxing von Python WSGI-Apps

1. Erstellen eines Basis-Docker-Containers aus Ubuntu
2. Den Basiscontainer für die Installation vorbereiten
3. Installation gängiger Python-Tools für die Bereitstellung
4. Die Installation der Webanwendung und ihrer Abhängigkeiten
5. Konfigurieren Ihrer Python WSGI-Anwendung

5. Erstellen der Dockerfile zum automatischen Erstellen des Images

1. Dockerfile Grundlagen
2. Übersicht der Dockerfile-Befehle
3. Erstellen der Dockerdatei
4. Die Grundlagen definieren
5. Aktualisierung des Standardanwendungsrepositories für Installationen
6. Die grundlegenden Werkzeuge installieren
7. Basisinstallationsanweisungen für Python und grundlegende Python-Tools
8. Anwendungsbereitstellung
9. Bootstrapping alles
10. Endgültige Dockerfile
11. Verwendung des Dockerfile zum automatischen Erstellen von Containern

Docker in Kürze

Das Docker-Projekt bietet höherstufige Werkzeuge, die zusammenarbeiten und auf einigen Funktionen des Linux-Kernels basieren. Das Ziel ist es, Entwicklern und Systemadministratoren zu helfen, Anwendungen - mitsamt all ihren Abhängigkeiten - zu portieren und sie ohne Kopfschmerzen über Systeme und Maschinen zum Laufen zu bringen.

Docker erreicht dies, indem es sichere, auf LXC (d.h. Linux-Containern) basierende Umgebungen für Anwendungen erstellt, die als Docker-Container bezeichnet werden. Diese Container werden unter Verwendung von Docker-Images erstellt, die entweder durch manuelles Ausführen von Befehlen oder automatisch über Dockerfiles erstellt werden können.

Hinweis: Um mehr über Docker und dessen Teile (z.B. Docker-Daemon, CLI, Images usw.) zu erfahren, lesen Sie unseren einführenden Artikel zum Projekt: Docker erklärt: Erste Schritte.

Docker auf Ubuntu (Aktuell) installieren

Mit seiner neuesten Version (0.7.1., datiert 5. Dezember) kann Docker auf verschiedenen Linux-Betriebssystemen, einschließlich Ubuntu/Debian und CentOS/RHEL, eingesetzt werden.

Denken Sie daran, dass Sie schnell loslegen können, indem Sie das einsatzbereite Docker-Image von DigitalOcean verwenden, das auf Ubuntu 13.04 basiert.

Wir werden schnell den Installationsprozess für Ubuntu (aktuell) durchgehen.

Installationsanweisungen für Ubuntu

Aktualisieren Sie Ihre Droplet:

sudo aptitude    update
sudo aptitude -y upgrade

Stellen Sie sicher, dass der Support verfügbar ist:

sudo aptitude install linux-image-extra-`uname -r`

Fügen Sie den Docker-Repository-Schlüssel zu apt-key für die Paketverifizierung hinzu:

sudo sh -c "wget -qO- https://get.docker.io/gpg | apt-key add -"

Fügen Sie das Docker-Repository zu den Aptitude-Quellen hinzu:

sudo sh -c "echo deb http://get.docker.io/ubuntu docker main\
> /etc/apt/sources.list.d/docker.list"

Aktualisiere das Repository mit der neuen Ergänzung:

sudo aptitude    update

Endlich, lade docker herunter und installiere es:

sudo aptitude install lxc-docker

Die Standardfirewall von Ubuntu (UFW: Uncomplicated Firewall) blockiert standardmäßig allen weitergeleiteten Verkehr, der von Docker benötigt wird.

Aktivieren Sie das Weiterleiten mit UFW:

Bearbeiten Sie die UFW-Konfiguration mit dem Nano-Texteditor.

sudo nano /etc/default/ufw

Scrollen Sie nach unten und finden Sie die Zeile, die mit DEFAULT_FORWARD_POLICY beginnt.

Ersetzen:

DEFAULT_FORWARD_POLICY="DROP"

Mit:

DEFAULT_FORWARD_POLICY="ACCEPT"

Drücken Sie CTRL+X und bestätigen Sie mit Y, um zu speichern und zu schließen.

Laden Sie schließlich die UFW neu:

sudo ufw reload

Grundlegende Docker-Befehle

Bevor wir mit Docker arbeiten, lassen Sie uns schnell die verfügbaren Befehle durchgehen, um unser Gedächtnis aus unserem ersten Erste Schritte Artikel aufzufrischen.

Den Docker-Daemon ausführen und die CLI-Nutzung

Bei der Installation sollte der Docker-Daemon im Hintergrund laufen und bereit sein, Befehle vom Docker-CLI entgegenzunehmen. In bestimmten Situationen, in denen es notwendig sein könnte, Docker manuell auszuführen, verwenden Sie Folgendes.

Den Docker-Daemon ausführen:

sudo docker -d &

Verwendung der Docker-CLI:

sudo docker [option] [command] [arguments]

Hinweis: Docker benötigt Sudo-Rechte, um zu funktionieren.

Docker-Befehle

Hier ist eine Zusammenfassung der derzeit verfügbaren (Version 0.7.1) Docker-Befehle:

befestigen

An einen laufenden Container anhängen

bauen

Erstelle einen Container aus einem Dockerfile

verpflichten

Erstellen Sie ein neues Image aus den Änderungen eines Containers.

cp

Kopiere Dateien/Ordner vom Dateisystem der Container in den Host-Pfad.

Differenz

Änderungen im Dateisystem eines Containers überprüfen

Ereignisse

Echtzeitereignisse vom Server abrufen

Export

Streamen Sie den Inhalt eines Containers als tar-Archiv

Geschichte

Zeige die Geschichte eines Bildes

Bilder

Bilder auflisten

Import

Erstellen Sie ein neues Dateisystem-Image aus dem Inhalt eines Tarballs.

Info

Systemweite Informationen anzeigen

einfügen

Fügen Sie eine Datei in ein Bild ein

inspektieren

Geben Sie niedrige Informationen zu einem Container zurück

töten

Einen laufenden Container stoppen

laden

Laden Sie ein Bild aus einem Tar-Archiv hoch

Anmelden

Registrieren oder anmelden bei dem Docker-Registry-Server

Protokolle

Holen Sie die Protokolle eines Containers ab

Hafen

Suchen Sie den öffentlich zugänglichen Port, der auf den PRIVATE_PORT umgeleitet ist.

ps

Listenbehälter

ziehen

Ziehen Sie ein Bild oder ein Repository vom Docker-Registry-Server.

drücken

Schiebe ein Bild oder ein Repository zum Docker-Registry-Server

neu starten

Einen laufenden Container neu starten

rm

Entfernen Sie einen oder mehrere Behälter

RMI

Entfernen Sie ein oder mehrere Bilder

laufen

Führen Sie einen Befehl in einem neuen Container aus

speichern

Speichern Sie ein Bild in einem Tar-Archiv

Suche

Suche nach einem Bild im Docker-Index

beginnen

Starte einen gestoppten Container

Stop

Stoppen Sie einen laufenden Container

Tag

Ein Bild in ein Repository taggen

oben

Überprüfen Sie die laufenden Prozesse eines Containers

Version

Zeige die Docker-Version Informationen an

Einen Docker-Container zum Sandboxen von Python WSGI-Anwendungen bauen

Nachdem wir Docker auf unserem VPS installiert und seine Befehle kurz durchgegangen sind, sind wir bereit, mit der eigentlichen Arbeit zu beginnen, um unseren Docker-Container zu erstellen, der eine Python WSGI-Anwendung ausführt.

Hinweis: Der folgende Abschnitt ermöglicht es Ihnen, eine dockerisierte (containerisierte) Python WSGI-Webanwendung zu haben. Es ist jedoch definitiv nicht die empfohlene Methode aufgrund ihrer Komplexität und Unpraktikabilität. Er dient dazu, Ihnen die Möglichkeit zu geben, zu lernen, wie man mit einem Live-Container arbeitet, und sich mit den Befehlen vertraut zu machen, die wir später im nächsten Abschnitt zur Automatisierung des Prozesses benötigen werden.

Lass uns anfangen!

Erstellen eines Basis-Docker-Containers aus Ubuntu

Wir beginnen mit der Erstellung eines neuen Containers basierend auf dem Ubuntu-Image, indem wir den RUN-Befehl von Docker verwenden. Wir werden ein Terminal daran anhängen, indem wir das -t-Flag verwenden, und bash wird als laufender Prozess fungieren.

Wir werden Port 80 freigeben, damit unsere Anwendung von außen zugänglich ist. In Zukunft möchten Sie möglicherweise mehrere Instanzen ausbalancieren und Container miteinander „verknüpfen“, um sie beispielsweise über einen Reverse-Proxy im laufenden Container zuzugreifen.

sudo docker run -i -t -p 80:80 ubuntu /bin/bash

Hinweis: Nach der Ausführung dieses Befehls muss docker möglicherweise das Ubuntu-Image herunterladen, bevor es einen neuen Container für Sie erstellt.

Denken Sie daran: Sie werden an den von Ihnen erstellten Container angehängt. Um sich zu lösen und zu Ihrem Hauptterminalzugangspunkt zurückzukehren, führen Sie die Escape-Sequenz aus: CTRL+P gefolgt von CTRL+Q. An einem Docker-Container angehängt zu sein, ist wie mit einem neuen Droplet von innerhalb eines anderen verbunden zu sein.

Um sich wieder an diesen Behälter anzuschließen:

1. Liste alle laufenden Container mit "sudo docker ps" auf

2. Finde seine ID

3. Verwenden Sie „sudo docker attach [id]“, um wieder an sein Terminal anzuschließen.

Wichtig: Bitte vergessen Sie nicht, dass alle folgenden Befehle, da wir in einem Container sind, dort ausgeführt werden, ohne den Host, auf dem er sich befindet, zu beeinflussen.

Den Basiscontainer für die Installation vorbereiten

Um Python WSGI-Webanwendungen in einem Container bereitzustellen – und die Werkzeuge, die wir für den Prozess benötigen – müssen die entsprechenden Anwendungsrepositories für die Downloads verfügbar sein. Leider (und absichtlich, um die Dinge einfach zu halten) ist dies nicht der Fall mit dem standardmäßigen Ubuntu-Image, das mit Docker geliefert wird.

Lassen Sie uns Ubuntus Universum-Repository zur Standardliste der Anwendungsquellen des Basisimages hinzufügen.

echo "deb http://archive.ubuntu.com/ubuntu/ $(lsb_release -sc) main universe" >> /etc/apt/sources.list

Aktualisieren Sie die Liste mit der neu hinzugefügten Quelle.

apt-get update

Bevor wir mit der Einrichtung von Python WSGI-Anwendungen fortfahren, sollten wir einige Werkzeuge wie nano, tar, curl usw. haben - nur für den Fall.

Lass uns einige nützliche Werkzeuge in unserem Container herunterladen.

apt-get install -y tar \
                   git \
                   curl \
                   nano \
                   wget \
                   dialog \
                   net-tools
                   build-essential

Installation gängiger Python-Tools für die Bereitstellung

Für unser Tutorial (als Beispiel) werden wir eine sehr grundlegende Flask-Anwendung erstellen. Nach dem Lesen dieses Artikels können Sie stattdessen Ihr bevorzugtes Framework verwenden und bereitstellen, genauso wie Sie es auf einem virtuellen Server bereitstellen würden.

Denken Sie daran: Alle untenstehenden Befehle und Anweisungen finden weiterhin innerhalb eines Containers statt, der fast so funktioniert, als ob es sich um einen brandneuen Droplet handelt.

Lass uns unseren Bereitstellungsprozess mit der Installation von Python und pip, dem Python-Paketmanager, beginnen:

Install pip's dependency: setuptools:
apt-get install -y python python-dev python-distribute python-pip

Die Installation der Webanwendung und ihrer Abhängigkeiten

Bevor wir mit der Erstellung einer Beispielanwendung beginnen, sollten wir sicherstellen, dass alles - d.h. alle Abhängigkeiten - vorhanden sind. Zuerst und vor allem haben Sie wahrscheinlich Ihr Web Application Framework (WAF) als Abhängigkeit Ihrer Anwendung (d.h. Flask).

Da wir pip installiert und bereit zur Arbeit haben, können wir es nutzen, um alle Abhängigkeiten herunterzuladen und sie in unserem Container einzurichten:

Download and install Flask framework:
pip install flask

Nachdem wir pip installiert haben, erstellen wir eine grundlegende, Beispiel-Flask-Anwendung in einem Ordner "my_application", der alles enthalten soll.

Make a my_application folder
mkdir my_application

Enter the folder
cd my_application 

Hinweis: Wenn Sie daran interessiert sind, Ihre Anwendung anstelle dieses einfachen Musters bereitzustellen, sehen Sie sich den “Schnell-Tipp” im unteren Abschnitt an.

Lass uns eine einfache, einseitige Flask “Hello World!” Anwendung mit Nano erstellen.

Create a sample (app.py) with nano:
nano app.py

Und kopieren Sie den Inhalt unten für diese kleine Anwendung, die wir gerade erwähnt haben:

from flask import Flask
app = Flask(__name__)

@app.route("/")
def hello():
    return "Hello World!"

if __name__ == "__main__":
    app.run()

Drücke CTRL+X und bestätige mit Y, um zu speichern und zu schließen.

Alternativ können Sie eine "requirements.txt" verwenden, um die Abhängigkeiten Ihrer Anwendung wie Flask zu enthalten.

Um eine requirements.txt mit dem Nano-Texteditor zu erstellen:

nano requirements.txt

Und fügen Sie das Folgende ein, zusammen mit all Ihren Abhängigkeiten:

flask
cherrypy

Drücke CTRL+X und bestätige mit Y, um zu speichern und zu schließen.

Hinweis: Sie können eine Liste der Abhängigkeiten Ihrer tatsächlichen Anwendung mit pip erstellen. Um zu sehen, wie es geht, schauen Sie sich unser Tutorial "Häufige Python-Tools: Verwendung von virtualenv, Installation mit Pip und Verwaltung von Paketen" an.

Unsere endgültige Anwendungsordnerstruktur:

/my_application
    |
    |- requirements.txt  # File containing list of dependencies
    |- /app              # Application module (which should have your app)
    |- app.py            # WSGI file containing the "app" callable
    |- server.py         # Optional: To run the app servers (CherryPy)

Hinweis: Bitte beachten Sie den folgenden Abschnitt zur “server.py” - Konfiguration Ihrer Python WSGI-Anwendung.

Denken Sie daran: Dieser Anwendungsordner wird innerhalb des Containers erstellt. Wenn Sie Images automatisch erstellen (siehe den folgenden Abschnitt über Dockerfiles), müssen Sie sicherstellen, dass diese Struktur auf dem Host vorhanden ist, neben dem Dockerfile.

__ * Schneller Tipp für tatsächliche Bereitstellungen * __

Wie man das Anwendungs-Repository und seine Anforderungen in einen Container bekommt

Im obigen Beispiel haben wir das Anwendungsverzeichnis innerhalb des Containers erstellt. Allerdings werden Sie das nicht tun, um Ihre Anwendung bereitzustellen. Wahrscheinlicher ist es, dass Sie den Quellcode aus einem Repository ziehen.

Es gibt mehrere Möglichkeiten, Ihr Repository in einen Container zu kopieren.

Unten sind zwei von ihnen erklärt:

Example [1]
Download the application using git:
Usage: git clone [application repository URL]
Example:
git clone https://github.com/mitsuhiko/flask/tree/master/examples/flaskr

Example [2]
Download the application tarball:
Usage: wget [application repository tarball URL]
Example: (make sure to use an actual, working URL)
wget http://www.github.com/example_usr/application/tarball/v.v.x

Expand the tarball and extract its contents:
Usage: tar vxzf [tarball filename .tar (.gz)]
Example: (make sure to use an actual, working URL)
tar vxzf application.tar.gz

Download and install your application dependencies with pip.
Download the requirements.txt (pip freeze output) and use pip to install them all:
Usage: curl [URL for requirements.txt] | pip install -r -
Example: (make sure to use an actual, working URL)
curl http://www.github.com/example_usr/application/requirements.txt | pip install -r -

Konfigurieren Ihrer Python WSGI-Anwendung

Um diese Anwendung bereitzustellen, benötigen Sie einen Webserver. Der Webserver, der die WSGI-App betreibt, muss im selben Container wie die anderen Ressourcen der Anwendung installiert werden. Tatsächlich wird er der Prozess sein, den Docker ausführt.

Hinweis: In diesem Beispiel werden wir den integrierten produktionsbereiten HTTP-Webserver von CherryPy aufgrund seiner Einfachheit verwenden. Sie können Gunicorn, CherryPy oder sogar uWSGI verwenden (und sie hinter Nginx einrichten), indem Sie unseren Tutorials zu diesem Thema folgen.

Laden Sie CherryPy mit pip herunter und installieren Sie es:

pip install cherrypy

Erstellen Sie eine "server.py", um die Webanwendung aus "app.py" bereitzustellen:

nano server.py

Kopieren Sie den Inhalt von unten und fügen Sie ihn ein, damit der Server Ihre Anwendung importieren und bereitstellen kann:

Import your application as:
from app import application
Example:

from app import app

Import CherryPy
import cherrypy

if __name__ == '__main__':

    # Mount the application
    cherrypy.tree.graft(app, "/")
        
    # Unsubscribe the default server
    cherrypy.server.unsubscribe()

    # Instantiate a new server object
    server = cherrypy._cpserver.Server()
    
    # Configure the server object
    server.socket_host = "0.0.0.0"
    server.socket_port = 80
    server.thread_pool = 30
    
    # For SSL Support
    # server.ssl_module            = 'pyopenssl'
    # server.ssl_certificate       = 'ssl/certificate.crt'
    # server.ssl_private_key       = 'ssl/private.key'
    # server.ssl_certificate_chain = 'ssl/bundle.crt'
    
    # Subscribe this server
    server.subscribe()
    
    # Start the server engine (Option 1 *and* 2)
    
    cherrypy.engine.start()
    cherrypy.engine.block()

Und das ist es! Jetzt können Sie eine „dockerisierte“ Python-Webanwendung sicher in ihrem Sandbox-Bereich betreiben, bereit, tausende und abertausende von Client-Anfragen zu bedienen, indem Sie einfach Folgendes ausführen:

python server.py

Dies wird den Server im Vordergrund ausführen. Wenn Sie ihn stoppen möchten, drücken Sie CTRL+C.

Um den Server im Hintergrund auszuführen, führen Sie Folgendes aus:

python server.py &

Wenn Sie eine Anwendung im Hintergrund ausführen, müssen Sie einen Prozessmanager (z. B. htop) verwenden, um sie zu beenden (oder anzuhalten).

Hinweis: Um mehr über die Konfiguration von Python WSGI-Anwendungen für den Einsatz mit CherryPy zu erfahren, sehen Sie sich unser Tutorial an: So setzen Sie Python WSGI-Apps mit dem CherryPy-Webserver ein.

Um zu testen, dass alles reibungslos funktioniert, was es tun sollte, da alle Portzuweisungen bereits erledigt sind, können Sie http://[die IP Ihres Droplets] mit Ihrem Browser besuchen, um die “Hallo Welt! ” Nachricht zu sehen.

Erstellen der Dockerfile zum automatischen Erstellen des Images

Wie bereits im vorherigen Schritt erwähnt, ist es sicherlich nicht der empfohlene Weg, Container auf diese Weise für ein skalierbares Produktionsdeployment zu erstellen. Der richtige Weg besteht darin, Dockerfiles zu verwenden, um den Build-Prozess auf strukturierte Weise zu automatisieren.

Nachdem wir die notwendigen Befehle zum Herunterladen und Installieren innerhalb eines Containers durchgegangen sind, können wir dasselbe Wissen nutzen, um ein Dockerfile zu erstellen, das Docker verwenden kann, um ein Image zu erstellen, das dann verwendet werden kann, um einen Python WSGI-Anwendungs-Container einfach auszuführen.

Bevor wir mit der Arbeit am Dockerfile beginnen, lassen Sie uns schnell die Grundlagen durchgehen.

Dockerfile Grundlagen

Dockerfiles sind Skripte, die nacheinander deklarierte Befehle enthalten, die von Docker in dieser Reihenfolge ausgeführt werden sollen, um automatisch ein neues Docker-Image zu erstellen. Sie helfen enorm bei Bereitstellungen.

Diese Dateien beginnen immer mit der Definition eines Basisbildes mit dem FROM-Befehl. Von dort aus beginnt der Bauprozess und jede folgende durchgeführte Aktion bildet das endgültige Bild, das auf dem Host erstellt wird.

Verwendung :

Build an image using the Dockerfile at current location
Tag the final image with [name] (e.g. *nginx*)
Example: sudo docker build -t [name] .
sudo docker build -t nginx_img . 

Hinweis: Um mehr über Dockerfiles zu erfahren, lesen Sie unseren Artikel: Docker erklärt: Dockerfiles verwenden, um den Aufbau von Images zu automatisieren.

Übersicht der Dockerfile-Befehle

Hinzufügen

Kopiere eine Datei vom Host in den Container

Befehlszeile

Setzen Sie die Standardbefehle, die ausgeführt oder an den ENTRYPOINT weitergegeben werden sollen.

EINGANGSPUNKT

Legen Sie die standardmäßige Einstiegspunkt-Anwendung innerhalb des Containers fest.

Umwelt

Umgebungsvariable setzen (z.B. „key=value“)

Expose

Einen Port nach außen freigeben

VON

Setze das Basisbild, das verwendet werden soll

WARTUNGSPERSON

Setzen Sie die Autor-/Besitzerdaten der Dockerfile

LAUFEN

Führen Sie einen Befehl aus und speichern Sie das Endergebnis (Container-)Bild.

BENUTZER

Setzen Sie den Benutzer, um die Container aus dem Bild auszuführen.

VOLUMEN

Ein Verzeichnis vom Host in den Container einbinden

ARBEITSVERZEICHNIS

Legen Sie das Verzeichnis für die auszuführenden CMD-Direktiven fest

Erstellen der Dockerdatei

Um eine Dockerfile am aktuellen Ort mit dem Nano-Texteditor zu erstellen, führen Sie den folgenden Befehl aus:

sudo nano Dockerfile

Hinweis: Fügen Sie alle folgenden Zeilen nacheinander hinzu, um die Dockerfile zu erstellen.

Die Grundlagen definieren

Lass uns unser Dockerfile beginnen, indem wir die Grundlagen definieren, wie das FROM-Image (z. B. Ubuntu) und den MAINTAINER.

Fügen Sie Folgendes hinzu:

############################################################
Dockerfile to build Python WSGI Application Containers
Based on Ubuntu
############################################################

Set the base image to Ubuntu
FROM ubuntu

File Author / Maintainer
MAINTAINER Maintaner Name

Aktualisierung des Standardanwendungsrepositories für Installationen

Führen Sie Folgendes aus, um das apt-get-Repository mit zusätzlichen Anwendungen zu aktualisieren, wie wir es im vorherigen Abschnitt gemacht haben.

Fügen Sie Folgendes hinzu:

Add the application resources URL
RUN echo "deb http://archive.ubuntu.com/ubuntu/ $(lsb_release -sc) main universe" >> /etc/apt/sources.list

Update the sources list
RUN apt-get update

Die grundlegenden Werkzeuge installieren

Nachdem wir die Standardanwendung Repository-Quellenliste aktualisiert haben, können wir mit unserem Bereitstellungsprozess beginnen, indem wir die grundlegenden Anwendungen erhalten, die wir benötigen.

Fügen Sie Folgendes hinzu:

Install basic applications
RUN apt-get install -y tar git curl nano wget dialog net-tools build-essential

Hinweis: Obwohl Sie wahrscheinlich niemals einige der oben genannten Werkzeuge benötigen werden, beschaffen wir sie dennoch - für den Fall der Fälle.

Basisinstallationsanweisungen für Python und grundlegende Python-Tools

Für die Bereitstellung von Python WSGI-Anwendungen werden Sie mit hoher Wahrscheinlichkeit einige der Werkzeuge benötigen, mit denen wir zuvor gearbeitet haben (z. B. pip). Lassen Sie uns diese jetzt installieren, bevor wir mit der Einrichtung des Frameworks (d. h. Ihres WAF) und Ihres bevorzugten Webanwendungsservers (WAS) fortfahren.

Fügen Sie Folgendes hinzu:

Install Python and Basic Python Tools
RUN apt-get install -y python python-dev python-distribute python-pip

Anwendungsbereitstellung

Da wir Docker-Images erstellen, um Python-Webanwendungen bereitzustellen, können wir alle den ADD-Befehl von Docker nutzen, um das Anwendungsrepository zu kopieren, vorzugsweise mit einer REQUIREMENTS-Datei, um schnell in einem einzigen Schritt einsatzbereit zu sein.

Hinweis: Um alles in einer einzigen Datei zusammenzufassen und Wiederholungen zu vermeiden, könnte ein Anwendungsordner, der ähnlich wie der untenstehende strukturiert ist, ein guter Weg sein.

Beispielanwendungsordnerstruktur:

/my_application
    |
    |- requirements.txt  # File containing list of dependencies
    |- /app              # Application module
    |- app.py            # WSGI file containing the "app" callable
    |- server.py         # Optional: To run the app servers (CherryPy)

Hinweis: Um zu erfahren, wie Sie diese Struktur erstellen können, scrollen Sie bitte nach oben und beziehen Sie sich auf den Abschnitt Installation der Webanwendung und ihrer Abhängigkeiten.

Fügen Sie Folgendes hinzu:

Copy the application folder inside the container
ADD /my_application /my_application

Hinweis: Wenn Sie von einem Online-Host-Git-Repository deployen möchten, können Sie den folgenden Befehl verwenden, um zu klonen:

RUN git clone [application repository URL]

Bitte vergessen Sie nicht, den URL-Platzhalter durch Ihre tatsächliche zu ersetzen.

Bootstrapping alles

Nachdem wir die Anweisungen zum Kopieren der Anwendung hinzugefügt haben, lassen Sie uns mit den finalen Konfigurationen fortfahren, wie dem Abrufen der Abhängigkeiten aus der requirements.txt.

Get pip to download and install requirements:
RUN pip install -r /my_application/requirements.txt

Expose ports
EXPOSE 80

Set the default directory where CMD will execute
WORKDIR /my_application

Set the default command to execute
when creating a new container
i.e. using CherryPy to serve the application
CMD python server.py

Endgültige Dockerfile

Am Ende sollte das Dockerfile wie folgt aussehen:

############################################################
Dockerfile to build Python WSGI Application Containers
Based on Ubuntu
############################################################

Set the base image to Ubuntu
FROM ubuntu

File Author / Maintainer
MAINTAINER Maintaner Name

Add the application resources URL
RUN echo "deb http://archive.ubuntu.com/ubuntu/ $(lsb_release -sc) main universe" >> /etc/apt/sources.list

Update the sources list
RUN apt-get update

Install basic applications
RUN apt-get install -y tar git curl nano wget dialog net-tools build-essential

Install Python and Basic Python Tools
RUN apt-get install -y python python-dev python-distribute python-pip

Copy the application folder inside the container
ADD /my_application /my_application

Get pip to download and install requirements:
RUN pip install -r /my_application/requirements.txt

Expose ports
EXPOSE 80

Set the default directory where CMD will execute
WORKDIR /my_application

Set the default command to execute    
when creating a new container
i.e. using CherryPy to serve the application
CMD python server.py

Speichern Sie die Datei erneut und verlassen Sie sie, indem Sie CTRL+X drücken und mit Y bestätigen.

Verwendung des Dockerfile zum automatischen Erstellen von Containern

Wie wir zuerst im Abschnitt "Grundlagen" besprochen haben, besteht die Verwendung von Dockerfiles darin, sie mit dem Befehl docker build aufzurufen.

Da wir Docker anweisen, einen Anwendungsordner (d.h. /my_application) aus dem aktuellen Verzeichnis zu kopieren, müssen wir sicherstellen, dass sich dieser Ordner neben dieser Dockerfile befindet, bevor wir den Build-Prozess starten.

Dieses Docker-Image ermöglicht es uns, mit einem einzigen Befehl schnell Container für Python WSGI-Anwendungen zu erstellen.

Um es zu verwenden, erstellen Sie ein neues Container-Image mit folgendem:

sudo docker build -t my_application_img . 

Und mit diesem Image - das wir my_application_img getaggt haben - können wir einen neuen Container starten, der die Anwendung mit folgendem Befehl ausführt:

sudo docker run -name my_application_instance -p 80:80 -i -t my_application_img

Jetzt können Sie die IP-Adresse Ihres Droplets besuchen, und Ihre Anwendung wird über einen Docker-Container ausgeführt.

Beispiel :

Usage: Visit http://[my droplet's ip]
http://95.85.10.236/

Beispielantwort:

Hello World!

Für das vollständige Set an Anweisungen zur Installation von Docker (einschließlich anderer Betriebssysteme) besuchen Sie die Docker-Installationsdokumentation unter docker.io.