Was sind Container im Cloud Computing?

Seit der Einführung von Docker im Jahr 2013 erfreuen sich Container zunehmender Beliebtheit. Viele Unternehmen haben Container bereits in ihre Arbeitsabläufe integriert, weil sie damit ihre Software einfach bereitstellen, verteilen, verwalten und skalieren können.

In diesem Artikel erklären wir, was Container im Cloud Computing sind. Wir sprechen über die Vorteile der Verwendung von Containern, ihre Anwendungsfälle, vergleichen sie mit virtuellen Maschinen und werfen einen Blick auf Docker und Kubernetes. Zum Schluss zeigen wir Ihnen, wie Sie eine Webanwendung programmieren, andocken und in Back4app Containern bereitstellen können – und das völlig kostenlos!

Container-Definition

Ein Container ist ein eigenständiges ausführbares Paket, das alles enthält, was zur Ausführung einer Anwendung benötigt wird: Code, Laufzeit, Bibliotheken, Umgebungsvariablen und Konfigurationsdateien. Das Tolle an containerisierten Anwendungen ist, dass sie überall ausgeführt werden können, von Ihrer lokalen Entwicklungsumgebung bis hin zu öffentlichen Clouds und so weiter. Container sind klein, effizient und ermöglichen eine effektive Isolierung.

Vorteile der Verwendung von Containern

Die Verwendung von Containern hat mehrere Vorteile. Schauen wir uns einige davon an.

Wirkungsgrad

Container benötigen weniger Systemressourcen als herkömmliche Server oder VMs, da sie kein Betriebssystem-Image enthalten. Dadurch sind sie äußerst effizient, haben eine geringe Größe (in der Regel in MB gemessen) und ermöglichen die Ausführung einer großen Anzahl von Anwendungen auf einem Server.

Isolierung der Anwendung

Container isolieren die Anwendung und ihre Abhängigkeiten vom Hostsystem. Gleichzeitig sind sie in der Lage, den Betriebssystemkern und Systemressourcen wie CPU, Speicher, Storage und Netzwerk gemeinsam zu nutzen.

Tragbarkeit

Containerisierte Software kann auf praktisch jedem Rechner, auf dem die Container-Engine installiert ist, auf die gleiche Weise ausgeführt werden und sich gleich verhalten. Dies erleichtert die Bereitstellung und das Verschieben von Anwendungen zwischen verschiedenen Umgebungen und beseitigt das Problem “es funktioniert auf meinem Rechner”.

Trennung der Verantwortung

Container ermöglichen die Trennung der Verantwortlichkeiten, indem sie Aufgaben und Verantwortlichkeiten zwischen Entwicklern und IT-Betriebsteams aufteilen. Die Entwickler sind für die Erstellung und Pflege des Anwendungscodes und der Abhängigkeiten zuständig, während sich die IT-Betriebsteams auf die Bereitstellung und Verwaltung der Container und der zugrunde liegenden Infrastruktur konzentrieren.

Schnellere Anwendungsentwicklung

Die Containerisierung erleichtert die Entwicklung, Prüfung, Verwaltung und Verteilung von Software. Container können leicht in CI/CD-Systeme integriert werden, was den Prozess der Softwareentwicklung und -auslieferung erheblich beschleunigen kann.

Einfache Skalierung

Containerisierte Anwendungen in Kombination mit einer Orchestrierungsplattform wie Kubernetes lassen sich problemlos nach Bedarf skalieren. So kann Ihr Unternehmen hohe Arbeitslasten bewältigen und gleichzeitig die Kosten minimieren.

Container Anwendungsfälle

Die Containertechnologie bietet sowohl für Entwickler als auch für IT-Betriebsteams eine Vielzahl von Anwendungsmöglichkeiten.

Container-Native Entwicklung

Container-native Entwicklung ist ein Softwareentwicklungsansatz, der Container als primären Baustein nutzt. Bei der containernativen Entwicklung werden Anwendungen als Container verpackt und in einer containerisierten Umgebung ausgeführt. Dieser Entwicklungsansatz bietet Ihnen alle Vorteile, die Container zu bieten haben.

Kontinuierliche Integration und kontinuierliche Bereitstellung (CI/CD)

In einer CI/CD-Pipeline werden Container verwendet, um Anwendungen zu verpacken und automatisierte Tests auszuführen, die es ermöglichen, Anwendungen auf konsistente und wiederholbare Weise zu testen und bereitzustellen. Container können als Teil der CI/CD-Pipeline einfach erstellt, getestet und bereitgestellt werden, wodurch das Fehlerrisiko verringert und die Gesamteffizienz des Softwareentwicklungsprozesses verbessert wird.

Microservices

Mit Containern können Sie Anwendungen entwickeln, die einer Microservice-Architektur folgen. Mit Containern können Sie Ihre monolithische Anwendung einfach in eine Sammlung von lose gekoppelten, feinkörnigen Diensten aufteilen, die in verschiedenen Containern ausgeführt werden.

Entwicklungsumgebung

Mit Containern können Entwicklerteams ihre Entwicklungsumgebungen schnell einrichten. Sie bieten konsistente Entwicklungsumgebungen unabhängig von ihrem Host-Betriebssystem und den Host-Bibliotheken.

Batch-Prozesse

Batch-Prozesse können einfach in Container verpackt und in der Cloud bereitgestellt werden. Jede Aufgabe wird als eigenes Container-Image verpackt und als separate Container-Instanz ausgeführt. Dies ermöglicht eine effiziente Ressourcennutzung, da jede Aufgabe in ihrer eigenen Umgebung ausgeführt wird und andere Aufgaben nicht beeinträchtigt.

Container vs. Virtuelle Maschinen

Container und virtuelle Maschinen sind zwei unterschiedliche Ansätze zur Virtualisierung. Obwohl sie einige Ähnlichkeiten aufweisen, sind sie doch recht unterschiedlich.

Virtuelle Maschinen (VMs) sind eine Abstraktion der physischen Hardware. Sie ermöglichen es uns, einen Server in mehrere Server zu verwandeln. Jede der VMs hat ihr eigenes Betriebssystem und wird in der Regel von einem Hypervisor verwaltet. VMs eignen sich für die Ausführung mehrerer Anwendungen (auf demselben Server), monolithischer Anwendungen und Anwendungen, die ein hohes Maß an Isolierung und Sicherheit erfordern. Ihr Nachteil ist, dass sie in der Regel viel Speicherplatz benötigen und recht langsam hochfahren können.

Container hingegen sind auf der Ebene des Betriebssystems virtualisiert. Sie benötigen weniger Platz, da sie denselben Linux-Kernel nutzen, sind effizienter, booten schneller, sind hoch skalierbar und können mehr Anwendungen verarbeiten. Container werden von einer Container-Engine verwaltet. Ihre Hauptanwendungsfälle im Gegensatz zu VMs sind Microservices und Anwendungen, die portabel, leichtgewichtig und skalierbar sein müssen.

Es ist auch möglich, Container und VMs zu kombinieren, um die Vorteile von beiden zu nutzen.

Docker und Kubernetes

Zwei der beliebtesten Tools für die Arbeit mit Containern sind Docker und Kubernetes. Lassen Sie uns erklären, wie sie funktionieren und welche Unterschiede es gibt.

Docker ist ein Linux-basiertes Open-Source-Projekt, das zur Automatisierung der Bereitstellung und Verwaltung von Anwendungen in leichtgewichtigen Containern verwendet wird. Dadurch können containerisierte Anwendungen in verschiedenen Umgebungen effizient arbeiten. Heutzutage ist Docker fast überall zu finden, von Linux-Rechnern bis hin zu großen Cloud-Anbietern und so weiter.

Die beliebtesten Docker-Alternativen sind Podman, LXD und containerd.

Kubernetes (K8s) ist ein Open-Source-Container-Orchestrierungssystem zur Automatisierung der Bereitstellung, Skalierung und Verwaltung von containerisierten Anwendungen. Seit seiner Veröffentlichung im Jahr 2014 hat es sich zum De-facto-Standard für die Bereitstellung und den Betrieb von containerisierten Anwendungen in Cloud-Umgebungen entwickelt. Zu den Vorteilen von Kubernetes gehören Skalierbarkeit, hohe Verfügbarkeit, automatisierter Betrieb, Abstraktion der Infrastruktur und Zustandsüberwachung.

Andere Orchestrierungsplattformen sind: AWS ECS, Nomad und Red Hat OpenShift.

Was ist also der Unterschied zwischen Docker und Kubernetes? Nun, einfach ausgedrückt ermöglicht es Docker, Anwendungen in Containern zu verpacken und zu verteilen, während Kubernetes es mehreren Containern leicht macht, harmonisch miteinander zu arbeiten.

Entwickeln einer Anwendung mit Container-basierter Architektur

In diesem Abschnitt des Tutorials werden wir eine einfache REST-API erstellen, andocken und auf Back4app Containern bereitstellen.

Was ist Back4app Containers?

Back4app Containers ist eine kostenlose Open-Source-Plattform für die Bereitstellung und Skalierung von Anwendungen auf global verteilten Containern in einer Cloud-Infrastruktur.

So können Sie sich auf Ihre Software konzentrieren und sie schneller bereitstellen, ohne sich um DevOps kümmern zu müssen. Die Plattform ist eng mit GitHub integriert, verfügt über ein integriertes CI/CD-System und ermöglicht es Ihnen, Ihre App in wenigen Minuten zum Laufen zu bringen!

Warum Back4app-Container verwenden?

• Gut mit GitHub integrierbar
• Bereitstellungen ohne Ausfallzeiten
• Einfach zu benutzen & hat eine kostenlose Stufe
• Ausgezeichnete Kundenbetreuung

Projekt-Einführung

Wir werden eine einfache REST-API erstellen, die als Film-Watchlist dienen wird. Die Web-App wird grundlegende CRUD-Operationen wie das Hinzufügen eines Films, das Löschen eines Films und so weiter ermöglichen. Zur Erstellung der API werden wir das Flask-Framework verwenden. Zum Schluss werden wir das Projekt dockerisieren und demonstrieren, wie einfach es ist, es in Back4app Containern bereitzustellen.

Voraussetzungen

• Erfahrung mit dem Flask-Framework
• Grundlegendes Verständnis von Docker und Containern
• Fähigkeit zur Nutzung von Git und GitHub

Code App

Für die folgenden Schritte ist es erforderlich, dass Sie Python installiert haben. Wenn Sie Python noch nicht installiert haben, können Sie es herunterladen.

Projektinitialisierung

Erstellen Sie zunächst ein eigenes Verzeichnis für Ihre Anwendung und navigieren Sie dorthin:

$ mkdir flask-watchlist
$ cd flask-watchlist

Erstellen Sie dann eine neue virtuelle Umgebung und aktivieren Sie sie:

$ python3 -m venv venv && source venv/bin/activate

Da wir Flask als unser Framework verwenden werden, müssen wir es installieren:

$ (venv) pip install Flask==2.2.2

Erstellen Sie app.py mit folgendem Inhalt:

# app.py

from flask import Flask

app = Flask(__name__)
app.config['JSON_SORT_KEYS'] = False


@app.route('/')
def index_view():
    return {
        'detail': 'Hello world!'
    }

Dieser Code initialisiert Flask und erstellt einen einfachen Endpunkt, der eine Nachricht zurückgibt.

Starten Sie den Server mit:

$ flask run

Navigieren Sie zu http://localhost:5000/, und Sie sollten eine Meldung mit dem Wort "Hello world" sehen.

Datenbank

Für die Datenbank werden wir SQLite verwenden. SQLite ist ein eingebettetes, serverloses relationales Datenbankmanagementsystem. Um die Arbeit mit der Datenbank zu vereinfachen, werden wir Flask-SQLAlchemy installieren – eine Erweiterung für Flask, die Ihrer Anwendung Unterstützung für SQLAlchemy hinzufügt.

Installieren Sie ihn, indem Sie ihn ausführen:

$ (venv) pip install Flask-SQLAlchemy==3.0.3

Als Nächstes navigieren Sie zum Anfang der Datei app.py und ändern sie so, dass die Datenbank initialisiert wird:

# app.py

db = SQLAlchemy()
app = Flask(__name__)
app.config['JSON_SORT_KEYS'] = False
app.config['SECRET_KEY'] = '5b3cd5b80eb8b217c20fb37074ff4a33'
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
app.config["SQLALCHEMY_DATABASE_URI"] = "sqlite:///default.db"
db.init_app(app)

Vergessen Sie die Einfuhr nicht:

from flask_sqlalchemy import SQLAlchemy

Als Nächstes müssen wir unsere Datenbankmodelle definieren.

Da wir eine einfache Filmliste erstellen, benötigen wir nur ein Modell. Definieren Sie das Movie-Modell wie folgt:

# app.py

class Movie(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    title = db.Column(db.String(128), nullable=False)
    release_date = db.Column(db.Date(), nullable=False)

    is_watched = db.Column(db.Boolean, default=False)
    watched_at = db.Column(db.DateTime, default=None, nullable=True)

    def as_dict(self):
        return {c.name: getattr(self, c.name) for c in self.__table__.columns}

    def __repr__(self):
        return '<Movie %r>' % self.title

Um unsere Datenbank zu initialisieren und aufzufüllen, erstellen wir ein einfaches Python-Skript. Navigieren Sie zu Ihrem Projektstamm und erstellen Sie eine neue Datei namens init_db.py mit folgendem Inhalt:

# init_db.py

from datetime import date

from app import db, app
from app import Movie

with app.app_context():
    db.create_all()

    if Movie.query.count() == 0:
        movies = [
            Movie(title='Fight Club', release_date=date(1999, 9, 15)),
            Movie(title='The Matrix', release_date=date(1999, 3, 31)),
            Movie(title='Donnie Darko', release_date=date(2001, 1, 19)),
            Movie(title='Inception', release_date=date(2010, 7, 16)),
        ]

        for movie in movies:
            db.session.add(movie)

        db.session.commit()

Als Letztes müssen wir das Skript ausführen:

$ (venv) python init_db.py

Dadurch werden die Datenbank und die Datenbanktabellen erstellt und mit Daten gefüllt. Die Datenbankdatei wird im Instanzordner abgelegt.

API-Endpunkte

Unsere Webanwendung wird die folgenden Endpunkte haben:

1. / gibt grundlegende API-Informationen zurück
2. /api/ liefert die Liste der Filme
3. /api/create/ fügt der Beobachtungsliste einen neuen Film hinzu
4. /api/ / liefert Details zu einem bestimmten Film
5. /api/watch/ / markiert den Film als gesehen

Definieren Sie die Endpunkte am Ende von app.py:

# app.py

@app.route('/')
def index_view():
    return {
        'name': 'flask-watchlist',
        'description': 'a simple app for tracking the movies you want to watch',
        'version': 1.1,
    }


@app.route('/api/')
def list_view():
    json = [movie.as_dict() for movie in Movie.query.all()]
    return jsonify(json)


@app.route('/api/<int:movie_id>/', methods=['GET', 'DELETE'])
def detail_view(movie_id):
    movie = db.get_or_404(Movie, movie_id)

    if request.method == 'DELETE':
        db.session.delete(movie)
        db.session.commit()

        return {
            'detail': 'Movie has been successfully deleted.'
        }
    else:
        return movie.as_dict()


@app.route('/api/create/', methods=['POST'])
def create_view():
    title = request.form.get('title')
    release_date = request.form.get('release_date', type=float)

    if title is None or release_date is None:
        return {
            'detail': 'Please provide the title and release_date.'
        }, 400

    movie = Movie(title=title, release_date=datetime.fromtimestamp(release_date))
    db.session.add(movie)
    db.session.commit()

    return movie.as_dict()


@app.route('/api/watch/<int:movie_id>/')
def watch_view(movie_id):
    movie = db.get_or_404(Movie, movie_id)

    if movie.is_watched:
        return {
            'detail': 'Movie has already been watched.'
        }, 400

    movie.is_watched = True
    movie.watched_at = datetime.now()
    db.session.commit()

    return movie.as_dict()

Vergessen Sie nicht die Importe:

from datetime import datetime
from flask import request, jsonify

Großartig, unsere Anwendung ist nun mehr oder weniger vollständig. Starten Sie den Entwicklungsserver:

$ (venv) flask run

Testen Sie, ob Sie die Filmliste abrufen können:

$ (venv) curl http://localhost:5000/api/ | jq '.'

[
  {
    "id": 1,
    "title": "Fight Club",
    "release_date": "Wed, 15 Sep 1999 00:00:00 GMT",
    "is_watched": false,
    "watched_at": null
  },
  {
    "id": 2,
    "title": "The Matrix",
    "release_date": "Wed, 31 Mar 1999 00:00:00 GMT",
    "is_watched": false,
    "watched_at": null
  },
  ...
]

Gunicorn

Der Flask-Entwicklungsserver ist nicht für die Produktion geeignet, also tauschen wir ihn gegen Gunicorn aus. Gunicorn oder “Green Unicorn” ist ein produktionsreifer Python WSGI HTTP Server für Unix.

Installieren Sie es durch Ausführen:

$ (venv) pip install gunicorn==20.1.0

Nachdem das Paket installiert wurde, können Sie Ihren WSGI-Server wie folgt starten:

$ (venv) gunicorn -w 2 -b 0.0.0.0:5000 app:app

[INFO] Starting gunicorn 20.1.0
[INFO] Listening at: http://0.0.0.0:5000 (1)
[INFO] Using worker: sync
[INFO] Booting worker with pid: 7
[INFO] Booting worker with pid: 8

Beachten Sie, dass dieser Befehl nur auf UNIX-basierten Betriebssystemen funktioniert.

Dadurch werden zwei Gunicorn-Worker gestartet und Ihre App dem Internet zugänglich gemacht. Um auf die App zuzugreifen, öffnen Sie Ihren bevorzugten Webbrowser und navigieren Sie zu http://localhost:5000.

Anforderungen.txt

Das letzte, was wir vor dem Dockerisieren unserer Anwendung tun müssen, ist das Erstellen einer requirements.txt-Datei. Die Datei requirements.txt wird verwendet, um die Abhängigkeiten des Projekts anzugeben.

Der einfachste Weg, sie zu erzeugen, ist die Ausführung:

$ (venv) pip freeze > requirements.txt

Dockerize-App

Für die folgenden Schritte ist es erforderlich, dass Sie Docker installiert haben. Der einfachste Weg, Docker zu installieren, ist der Download von Docker Desktop.

Um zu überprüfen, ob Sie Docker installiert haben, führen Sie aus:

$ docker --version

Docker version 20.10.22, build 3a2c30b

Dockerdatei

Zur Dockerisierung unserer Anwendung verwenden wir ein Dockerfile. Ein Dockerfile ist eine einfache Textdatei, mit der wir das Basisimage, die Umgebung, Umgebungsvariablen, Befehle, Netzwerkeinstellungen, Volumes usw. definieren können.

Erstellen Sie ein Dockerfile in Ihrem Projektstamm mit folgendem Inhalt:

# syntax=docker/dockerfile:1.4
FROM --platform=$BUILDPLATFORM python:3.10-alpine

# set the working directory
WORKDIR /app

# set environmental variables
ENV PYTHONDONTWRITEBYTECODE 1
ENV PYTHONUNBUFFERED 1

# install the requirements
COPY requirements.txt /app
RUN --mount=type=cache,target=/root/.cache/pip \
    pip3 install -r requirements.txt

# copy the code to the container
COPY . .

# initialize the database (create DB, tables, populate)
RUN python init_db.py

# expose
EXPOSE 5000/tcp

# entrypoint command
CMD ["gunicorn", "-w", "2", "-b", "0.0.0.0:5000", "app:app"]

1. Wir haben python:3.10-alpine als Basisbild verwendet.
2. Das Setzen von PYTHONDONTWRITEBYTECODE auf 1 bewirkt, dass Python keine .pyc-Dateien mehr auf die Festplatte schreibt.
3. Das Setzen von PYTHONUNBUFFERED auf 1 stellt sicher, dass die Python-Ausgabeströme direkt an das Terminal gesendet werden.

Weitere Informationen zum Schreiben von Dockerdateien finden Sie in der Dockerfile-Referenz.

.dockerignore

Bevor Docker ein Image erstellt, sucht es nach einer .dockerignore-Datei. Mit einer .dockerignore-Datei können wir festlegen, welche Dateien nicht in das Abbild aufgenommen werden sollen. Dies kann die Größe des Images erheblich reduzieren. Sie funktioniert ähnlich wie eine .gitignore-Datei.

Erstellen Sie eine .dockerignore-Datei im Stammverzeichnis des Projekts mit folgendem Inhalt:

# .dockerignore

.git/
instance/
__pycache__/
.idea/

Fügen Sie alle zusätzlichen Verzeichnisse oder Dateien hinzu, die Sie ausschließen möchten.

Erstellen und Ausführen des Abbilds

Lassen Sie uns nun unser Docker-Image erstellen und markieren.

$ docker build -t flask-watchlist:1.0 .

[+] Building 11.1s (15/15) FINISHED
 => [internal] load build definition from Dockerfile                                                                                                                                                                                                                                                               0.0s 
 => => transferring dockerfile: 32B                                                                                                                                                                                                                                                                                0.0s 
 => [internal] load .dockerignore                                                                                                                                                                                                                                                                                  0.0s 
 => => transferring context: 34B                                                                                                                                                                                                                                                                                   0.0s 
 => resolve image config for docker.io/docker/dockerfile:1.4                                                                                                                                                                                                                                                       0.5s 
 => CACHED docker-image://docker.io/docker/dockerfile:1.4@sha256:9ba7531a0dbc                                                                                                                                                                                  0.0s 
 => [internal] load build definition from Dockerfile                                                                                                                                                                                                                                                               0.0s 
 => [internal] load .dockerignore                                                                                                                                                                                                                                                                                  0.0s 
 => [internal] load metadata for docker.io/library/python:3.10-alpine                                                                                                                                                                                                                                              0.5s 
 => [stage-0 1/6] FROM docker.io/library/python:3.10-alpine@sha256:da5ab5e911253dfb                                                                                                                                                                                0.0s 
 => [internal] load build context                                                                                                                                                                                                                                                                                  0.3s 
 => => transferring context: 182.45kB                                                                                                                                                                                                                                                                              0.2s 
 => CACHED [stage-0 2/6] WORKDIR /app                                                                                                                                                                                                                                                                              0.0s 
 => [stage-0 3/6] COPY requirements.txt /app                                                                                                                                                                                                                                                                       0.0s 
 => [stage-0 4/6] RUN --mount=type=cache,target=/root/.cache/pip     
                      pip3 install -r requirements.txt                                                                                                                                                                                                              7.2s 
 => [stage-0 5/6] COPY . .                                                                                                                                                                                                                                                                                         0.3s 
 => [stage-0 6/6] RUN python init_db.py                                                                                                                                                                                                                                                                            1.5s 
 => exporting to image                                                                                                                                                                                                                                                                                             0.3s 
 => => exporting layers                                                                                                                                                                                                                                                                                            0.3s 
 => => writing image sha256:2671ccb7546a0594807c721a0600a                                                                                                                                                                                                                       0.0s 
 => => naming to docker.io/library/flask-watchlist:1.0 

Wenn Sie die Bilder auflisten, sollten Sie unser neues Bild sehen:

$ docker images

REPOSITORY        TAG       IMAGE ID       CREATED       SIZE
flask-watchlist   1.0       7bce66230eb1   8 hours ago   110MB

Schließlich verwenden Sie das Image, um einen neuen Docker-Container zu starten:

$ docker run -it -p 5000:5000 flask-watchlist:1.0

[2023-02-02 20:08:57 +0000] [1] [INFO] Starting gunicorn 20.1.0
[2023-02-02 20:08:57 +0000] [1] [INFO] Listening at: http://0.0.0.0:5000 (1)
[2023-02-02 20:08:57 +0000] [1] [INFO] Using worker: sync
[2023-02-02 20:08:57 +0000] [7] [INFO] Booting worker with pid: 7
[2023-02-02 20:08:57 +0000] [8] [INFO] Booting worker with pid: 8

Sie können -d verwenden, um den Docker-Container im losgelösten Modus zu starten. Das bedeutet, dass der Container im Hintergrund Ihres Terminals läuft und keine Eingaben empfängt oder Ausgaben anzeigt.

Gut gemacht, Ihre Anwendung läuft jetzt in einem Container! Navigieren Sie zu http://localhost:5000 und Sie sollten die folgende Antwort erhalten:

{
    "name": "flask-watchlist",
    "description": "a simple app for tracking the movies you want to watch",
    "version": 1
}

GitHub

Um die App auf Back4app Containers bereitzustellen, müssen Sie Ihren Quellcode in ein GitHub-Repository hochladen. Legen Sie ein neues Repository auf GitHub an, fügen Sie die Remote hinzu, fügen Sie .gitignore hinzu und übertragen Sie Ihren Code. Sobald sich Ihr Code auf GitHub befindet, fahren Sie mit dem nächsten Schritt fort.

App auf Back4app Containern bereitstellen

Für die folgenden Schritte benötigen Sie ein Back4app-Konto. Wenn Sie bereits ein Konto haben, loggen Sie sich ein, ansonsten melden Sie sich für das kostenlose Konto an.

Um mit Back4app zu arbeiten, müssen wir zunächst eine App erstellen. Wenn Sie sich in Ihrem Dashboard anmelden, sehen Sie die Liste Ihrer Apps. Klicken Sie auf “Build a new app”, um eine neue App zu erstellen.

Wählen Sie dann “Container als Dienst”.

Wenn Sie es noch nicht getan haben, verbinden Sie Ihr GitHub mit Back4app und importieren Sie die Repositories, die Sie bereitstellen möchten. Sobald Ihr GitHub verbunden ist, werden Ihre Repositories in der Tabelle angezeigt.

Wählen Sie das Repository, das Sie bereitstellen möchten, indem Sie auf “Auswählen” klicken.

Als nächstes wird Back4app Sie bitten, die Umgebung zu konfigurieren. Wählen Sie einen Namen für die Anwendung, ich werde flask-watchlist wählen. Alles andere können Sie als Standard belassen.

Klicken Sie abschließend auf “App erstellen”, um die App automatisch zu erstellen und bereitzustellen.

Sie werden dann zu den Details Ihrer Anwendung weitergeleitet, wo Sie die Bereitstellungsprotokolle sehen können.

Warten Sie ein paar Minuten auf die Bereitstellung der App und voila! Ihre App ist nun live auf Back4app Containers. Um Ihre App in Aktion zu sehen, klicken Sie auf die grüne URL auf der linken Seite.

Schlussfolgerung

In diesem Artikel haben wir erklärt, was Container sind, welche Vorteile sie bieten und wie Sie Container in Ihren Arbeitsablauf integrieren können. Inzwischen sollten Sie in der Lage sein, Ihre eigene einfache REST-API zu erstellen, sie zu docken und in Back4app Containern bereitzustellen.

Holen Sie sich den endgültigen Quellcode aus dem GitHub-Repository.

Künftige Schritte

1. Sie sollten die Datenbank nicht in Ihrem Image speichern. Im Moment wird die Datenbank bei jedem Redeploy zurückgesetzt. Erwägen Sie den Wechsel zu einer verwalteten PostgreSQL- oder MySQL-Instanz.
2. Erfahren Sie mehr über mehrstufige Builds zur Optimierung Ihrer Dockerdateien.
3. Lesen Sie den Artikel Bereitstellung von Docker-Containern für eine Schritt-für-Schritt-Anleitung

FAQ