Zum Hauptinhalt springen

Dockerfile Build

Mit Dockerfile-Builds kann Deploio jede App erstellen, die mit einem Dockerfile gebaut werden kann. Dies ist besonders nützlich, wenn deine Anwendung eine Programmiersprache oder Runtime verwendet, die Deploio noch nicht nativ unterstützt.

Erste Schritte​

Das Erstellen einer Dockerfile-Applikation funktioniert wie bei jeder anderen Applikation in Deploio. Die einzigen Voraussetzungen sind, dass dein Repository ein Dockerfile enthält und dass du bei der Erstellung das Argument --dockerfile angeben (oder den Schalter Dockerfile Build im Cockpit aktivieren).

In unserem Beispiele-Repository haben wir eine einfache Dockerfile-App.

  1. Öffne die Applikation erstellen-Seite.
  2. Gib deine Repository-Details an. 3. Aktiviere den Schalter Dockerfile Build.

Konfiguration​

Deploio erlaubt es dir, verschiedene Aspekte deiner Dockerfile-basierten Applikation anzupassen:

Dockerfile-Pfad​

Standardmässig verwendet Deploio das Dockerfile im Stammverzeichnis deines Repositorys.

Nachdem du Dockerfile Build aktiviert hast, kannst du den Pfad im Feld Dockerfile Path angeben.

Build-Context​

Standardmässig setzt Deploio den Build-Context auf das Stammverzeichnis deines Repositorys.

Nachdem du Dockerfile Build aktiviert hast, kannst du das Verzeichnis im Feld Build Context angeben.

Build-Argumente​

Du kannst Dockerfile Build-Argumente für deinen Build übergeben.

Füge deine Argumente im Bereich Build Environment Variables hinzu.

Deploio stellt ausserdem bestimmte Variablen automatisch als Build-Argumente bereit, wie zum Beispiel DEPLOIO_GIT_REVISION. Um diese während des Builds zu verwenden, deklariere sie als ARG in deinem Dockerfile:

ARG DEPLOIO_GIT_REVISION
RUN echo "Building revision $DEPLOIO_GIT_REVISION"

Folgende Variablen werden automatisch bereitgestellt:

VariableBeschreibungBuild-ZeitLaufzeit
PORTDer Port, auf dem deine App erreichbar ist.—✓
DEPLOIO_APP_NAMEDer Name deiner Anwendung.—✓
DEPLOIO_PROJECT_NAMEDer Name des Projekts, zu dem deine App gehört.—✓
DEPLOIO_RELEASE_NAMEDer Name des aktuell aktiven Releases.—✓
DEPLOIO_GIT_REVISIONDie Git-Revision (Commit-SHA) des deployten Quellcodes.✓✓

Runtime und Health-Checks​

Die Deploio-Runtime verwendet den im Dockerfile angegebenen ENTRYPOINT und CMD, um deine Anwendung zu starten.

Um deiner App Traffic zu liefern, erwartet die Runtime, dass sie auf einem TCP-Socket auf 0.0.0.0:$PORT lauscht. Der Port ist standardmässig 8080, kann aber in der App-Definition auf eine beliebige gültige Portnummer konfiguriert werden. Die Runtime überprüft die App-Health durch eine TCP-Probe zum konfigurierten Port und Traffic fliesst erst zur App, wenn die Probe erfolgreich ist. Schlägt die TCP-Probe zu irgendeinem Zeitpunkt des Lebenszyklus fehl, startet die Runtime die App neu. Auch wenn die App aus irgendeinem Grund beendet wird, startet sie die Runtime automatisch neu.

Image-Grösse optimieren​

Mit Dockerfile-Build erstellte Images sollten unkomprimiert nicht grösser als 2 GiB sein. Es gibt ein festes Limit von 10 GiB für die gesamte Build-Umgebung, aber über 2 GiB kann das System nicht mehr alle Layers zwischenspeichern und du wirst eine Verschlechterung der Build-Leistung feststellen.

Best Practices​

Alle Best Practices, die für Dockerfiles im Allgemeinen gelten, gelten auch für Dockerfile-Builds auf Deploio. Eine umfassende Anleitung findest du in den offiziellen Docker Best Practices.

  • Versuche die Grösse deines Images zu minimieren, um schnellere Builds, schnellere Releases und eine verringerte Angriffsfläche zu erreichen.
  • Verwende Multi-Stage-Builds für kompilierte Sprachen, wann immer dies möglich ist.

Einschränkungen​

Bitte beachte die folgenden Einschränkungen:

  • Es ist derzeit nicht möglich, eine bestehende Applikation, welche Buildpacks verwendet, direkt in eine Dockerfile-basierte Applikation umzuwandeln. Du musst die Applikation löschen und neu erstellen, um Dockerfile-Builds zu nutzen.

    Das folgende Skript automatisiert diesen Vorgang mit nctl und jq (beide erforderlich). Es löscht die bestehende Applikation und erstellt sie mit aktivierten Dockerfile-Builds neu. Übergib enable, um auf Dockerfile-Builds umzustellen, oder disable, um zu Buildpacks zurückzukehren.

    warnung

    Dieses Skript löscht und erstellt deine Applikation neu, was zu vorübergehenden Ausfallzeiten führt.

    #!/usr/bin/env bash
    set -euo pipefail

    if [[ $# -ne 3 ]] || [[ "$3" != "enable" && "$3" != "disable" ]]; then
      echo "Usage: $0 <project> <app-name> <enable|disable>" >&2
      echo "  enable  = Dockerfile build, disable = buildpacks" >&2
      exit 1
    fi

    PROJECT=$1
    APP=$2
    [[ "$3" == "enable" ]] && DOCKER_BUILD_ENABLED=true || DOCKER_BUILD_ENABLED=false
    TMP=$(mktemp "${TMPDIR:-/tmp}/${APP}.XXXXXX")
    RAW=$(mktemp "${TMPDIR:-/tmp}/${APP}.XXXXXX")
    trap 'rm -f "$TMP" "$RAW"' EXIT
    set +e
    nctl get applications "$APP" --project="$PROJECT" -o json > "$RAW" 2>&1
    RC=$?
    set -e

    if [[ $RC -ne 0 ]]; then
      echo "nctl exited with status $RC. Output was:" >&2
      cat "$RAW" >&2
      exit 1
    fi

    if ! jq empty "$RAW" 2>/dev/null; then
      echo "nctl did not return valid JSON. Output was:" >&2
      cat "$RAW" >&2
      exit 1
    fi

    jq --argjson enabled "$DOCKER_BUILD_ENABLED" '
      del(.metadata.creationTimestamp, .metadata.resourceVersion, .metadata.uid, .status) |
      .spec.forProvider.dockerfileBuild.enabled = $enabled |
      if $enabled then del(.spec.forProvider.language) else . end
    ' "$RAW" > "$TMP"

    [[ -s "$TMP" ]] || { echo "Empty config extracted, aborting." >&2; exit 1; }

    echo "Wrote config to: $TMP" >&2
    cat "$TMP"

    echo "" >&2
    echo "WARNING: Application '$APP' in project '$PROJECT' will be DELETED and recreated." >&2
    echo "There will be TEMPORARY DOWNTIME until the new application is running." >&2
    echo "" >&2
    read -r -p "Press ENTER to continue or Ctrl+C to abort: "

    nctl delete application "$APP" --project="$PROJECT" --wait
    nctl create -f "$TMP"