Docker/Image/best-practice/Dockerfile

Aus Foxwiki
Wechseln zu:Navigation, Suche

Docker/Image/best-practice/Dockerfile - Empfehlungen zur Verwendung von Dockerfile-Anweisungen


Beschreibung

Effiziente und wartungsfreundliche Dockerfiles erstellen

Empfehlungen zur korrekten Verwendung der Dockerfile-Anweisungen

FROM

Verwenden Sie nach Möglichkeit aktuelle offizielle Images als Grundlage für Ihre Images

  • Docker empfiehlt das Alpine-Image, da es streng kontrolliert wird und eine geringe Größe aufweist (unter 6 MB), dabei aber dennoch eine vollständige Linux-Distribution darstellt
Links
  1. https://docs.docker.com/reference/dockerfile/#from Dockerfile-Referenz zur FROM-Anweisung
  2. https://docs.docker.com/build/building/best-practices/#from

LABEL

Sie können Ihrem Bild Beschriftungen hinzufügen, um Bilder nach Projekten zu ordnen, Lizenzinformationen zu erfassen, die Automatisierung zu unterstützen oder aus anderen Gründen

  • Fügen Sie für jede Beschriftung eine Zeile ein, die mit LABEL beginnt und ein oder mehrere Schlüssel-Wert-Paare enthält
  • Die folgenden Beispiele zeigen die verschiedenen zulässigen Formate
  • Erläuternde Kommentare sind direkt im Text enthalten

Zeichenketten mit Leerzeichen müssen in Anführungszeichen gesetzt oder die Leerzeichen müssen mit Escape-Zeichen versehen werden

  • Innere Anführungszeichen (") müssen ebenfalls mit Escape-Zeichen versehen werden
Beispiel
# Set one or more individual labels
LABEL com.example.version="0.0.1-beta"
LABEL vendor1="ACME Incorporated"
LABEL vendor2=ZENITH\ Incorporated
LABEL com.example.release-date="2015-02-12"
LABEL com.example.version.is-production=""

Ein Image kann mehr als ein Label haben

  • Vor Docker 1.10 wurde empfohlen, alle Labels in einer einzigen LABEL-Anweisung zusammenzufassen, um zu verhindern, dass zusätzliche Layer erstellt werden
  • Dies ist nun nicht mehr erforderlich, die Zusammenfassung von Labels wird jedoch weiterhin unterstützt
Beispiel
# Set multiple labels on one line
LABEL com.example.version="0.0.1-beta" com.example.release-date="2015-02-12"

Das obige Beispiel lässt sich auch wie folgt schreiben:

# Set multiple labels at once, using line-continuation characters to break long lines
LABEL vendor=ACME\ Incorporated \
     com.example.is-beta= \
     com.example.is-production="" \
     com.example.version="0.0.1-beta" \
     com.example.release-date="2015-02-12"

Siehe Objekt-Labels verstehen für Richtlinien zu zulässigen Label-Schlüsseln und -Werten

Links

RUN

Teilen Sie lange oder komplexe RUN-Anweisungen auf mehrere Zeilen auf, getrennt durch Backslashes, um Ihr Dockerfile lesbarer, verständlicher und wartbarer zu machen

Beispielsweise können Sie Befehle mit dem Operator && verketten und Escape-Zeichen verwenden, um lange Befehle in mehrere Zeilen aufzuteilen

RUN apt-get update && apt-get install -y --no-install-recommends \

   package-bar \
   package-baz \
   package-foo

Standardmäßig dient der Backslash als Escape-Zeichen für ein Zeilenumbruchzeichen, aber du kannst dies mit der escape-Direktive ändern

Sie können auch Here-Dokumente verwenden, um mehrere Befehle auszuführen, ohne sie mit einem Pipeline-Operator zu verketten:

<<EOF
apt-get update
apt-get install -y --no-install-recommends \
    package-bar \
    package-baz \
    package-foo
EOF

Weitere Informationen

zu RUN finden Sie in der Dockerfile-Referenz zur RUN-Anweisung
Links

apt-get

Ein häufiger Anwendungsfall für RUN-Anweisungen in Debian-basierten Images ist die Installation von Software mithilfe von apt-get

  • Da apt-get Pakete installiert, weist der Befehl RUN apt-get einige nicht intuitiv erscheinende Verhaltensweisen auf, auf die man achten sollte

Kombinieren Sie RUN apt-get update immer mit apt-get install in derselben RUN-Anweisung

Beispiel
apt-get update && apt-get install -y --no-install-recommends \
    package-bar \
    package-baz \
    package-foo

Die alleinige Verwendung von apt-get update in einer RUN-Anweisung führt zu Problemen mit dem Cache und dazu, dass nachfolgende apt-get install-Anweisungen fehlschlagen

  • Dieses Problem tritt beispielsweise im folgenden Dockerfile auf:
# syntax=docker/dockerfile:1
FROM ubuntu:22.04
RUN apt-get update
RUN apt-get install -y --no-install-recommends curl

Nach dem Erstellen des Images befinden sich alle Layer im Docker-Cache

  • Angenommen, Sie ändern später apt-get install, indem Sie ein zusätzliches Paket hinzufügen, wie im folgenden Dockerfile gezeigt:
# syntax=docker/dockerfile:1
FROM ubuntu:22.04
RUN apt-get update
RUN apt-get install -y --no-install-recommends curl nginx

Docker betrachtet die ursprünglichen und die geänderten Anweisungen als identisch und verwendet den Cache aus den vorherigen Schritten erneut

  • Infolgedessen wird der Befehl apt-get update nicht ausgeführt, da der Build die zwischengespeicherte Version verwendet
  • Da der Befehl apt-get update nicht ausgeführt wird, kann es vorkommen, dass Ihr Build eine veraltete Version der Pakete curl und nginx erhält

Mit RUN apt-get update && apt-get install -y --no-install-recommends stellen Sie sicher, dass Ihr Dockerfile die neuesten Paketversionen installiert, ohne dass weitere Programmierarbeiten oder manuelle Eingriffe erforderlich sind

  • Diese Technik wird als „Cache Busting“ bezeichnet
  • Sie können Cache Busting auch erreichen, indem Sie eine bestimmte Paketversion angeben
  • Dies wird als „Version Pinning“ bezeichnet
Beispiel
RUN apt-get update && apt-get install -y --no-install-recommends \
   package-bar \
   package-baz \
   package-foo=1.3.*

Durch die Versionsfestlegung wird der Build dazu gezwungen, eine bestimmte Version abzurufen, unabhängig davon, was sich im Cache befindet

  • Diese Technik kann zudem Fehler reduzieren, die durch unerwartete Änderungen an erforderlichen Paketen verursacht werden

Im Folgenden finden Sie einen korrekt formatierten RUN-Befehl, der alle apt-get- Empfehlungen veranschaulicht

apt-get update && apt-get install -y --no-install-recommends \
   aufs-tools \
   automake \
   build-essential \
   curl \
   dpkg-sig \
   libcap-dev \
   libsqlite3-dev \
   mercurial \
   reprepro \
   ruby1.9.1 \
   ruby1.9.1-dev \
   s3cmd=1.1.* \
   && rm -rf /var/lib/apt/lists/*

Das s3cmd-Argument gibt eine Version 1.1.* an

  • Wenn für das Image zuvor eine ältere Version verwendet wurde, führt die Angabe der neuen Version zu einem Cache-Bust von apt-get update und stellt sicher, dass die neue Version installiert wird
  • Die Auflistung der Pakete in jeder Zeile kann zudem Fehler durch doppelte Paketinstallationen verhindern

Wenn Sie zudem den apt-Cache durch Löschen von /var/lib/apt/lists bereinigen, verringert sich die Image-Größe, da der apt-Cache nicht in einer Layer gespeichert wird

  • Da die RUN-Anweisung mit apt-get update beginnt, wird der Paket-Cache immer vor apt-get install aktualisiert

Offizielle Debian- und Ubuntu-Images führen automatisch apt-get clean aus, sodass ein expliziter Aufruf nicht erforderlich ist

Links

Pipes

Verwendung von Pipes

Einige RUN-Befehle setzen voraus, dass die Ausgabe eines Befehls mithilfe des Pipe-Zeichens (|) an einen anderen Befehl weitergeleitet werden kann, wie im folgenden Beispiel gezeigt:

wget -O - https://some.site | wc -l > /number

Docker führt diese Befehle mit dem Interpreter /bin/sh -c aus, der zur Feststellung des Erfolgs lediglich den Exit-Code der letzten Operation in der Pipe auswertet

  • Im obigen Beispiel ist dieser Build-Schritt erfolgreich und erzeugt ein neues Image, solange der Befehl wc -l erfolgreich ist, selbst wenn der Befehl wget fehlschlägt

Wenn Sie möchten, dass der Befehl aufgrund eines Fehlers in einer beliebigen Phase der Pipe fehlschlägt, fügen Sie set -o pipefail && am Anfang ein, um sicherzustellen, dass ein unerwarteter Fehler verhindert, dass der Build versehentlich erfolgreich abgeschlossen wird

Beispiel
set -o pipefail && wget -O - https://some.site | wc -l > /number
Beispiel
["/bin/bash", "-c", "set -o pipefail && wget -O - https://some.site | wc -l > /number"]
Links

CMD

Der Befehl CMD sollte verwendet werden, um die in Ihrem Image enthaltene Software zusammen mit etwaigen Argumenten auszuführen

  • CMD sollte fast immer in der Form CMD ["ausführbare Datei", "Parameter1", "Parameter2"] verwendet werden
  • Wenn das Image also für einen Dienst wie Apache und Rails bestimmt ist, würden Sie beispielsweise CMD ["apache2","-DFOREGROUND"] ausführen
  • Tatsächlich wird diese Form des Befehls für jedes dienstbasierte Image empfohlen

In den meisten anderen Fällen sollte CMD eine interaktive Shell erhalten, wie bash, Python oder Perl

  • Zum Beispiel CMD ["perl", "-de0"], CMD ["python"] oder CMD ["php", "-a"]
  • Wenn Sie diese Form verwenden, bedeutet das, dass Sie bei der Ausführung von beispielsweise docker run -it python direkt in eine einsatzbereite Shell gelangen. CMD sollte nur selten in der Form CMD ["param", "param"] in Verbindung mit ENTRYPOINT verwendet werden, es sei denn, Sie und Ihre erwarteten Benutzer sind bereits gut mit der Funktionsweise von ENTRYPOINT vertraut
Links
  1. Dockerfile-Referenz zur CMD-Anweisung
  2. https://docs.docker.com/build/building/best-practices/#cmd

EXPOSE

Die Anweisung EXPOSE gibt die Ports an, auf denen ein Container auf Verbindungen wartet

  • Daher sollten Sie den gängigen, herkömmlichen Port für Ihre Anwendung verwenden
  • Beispielsweise würde ein Image, das den Apache-Webserver enthält, EXPOSE 80 verwenden, während ein Image, das MongoDB enthält, EXPOSE 27017 verwenden würde und so weiter

Für den externen Zugriff können Ihre Benutzer den Befehl docker run mit einem Flag ausführen, das angibt, wie der angegebene Port auf einen Port ihrer Wahl abgebildet werden soll

  • Für die Verknüpfung von Containern stellt Docker Umgebungsvariablen für den Pfad vom Zielcontainer zurück zum Quellcontainer bereit (zum Beispiel MYSQL_PORT_3306_TCP)
Links
  1. https://docs.docker.com/build/building/best-practices/#expose
  2. Dockerfile-Referenz zur EXPOSE-Anweisung

ENV

Um die Ausführung neuer Software zu vereinfachen, können Sie mit ENV die Umgebungsvariable PATH für die Software aktualisieren, die Ihr Container installiert

  • So stellt beispielsweise ENV PATH=/usr/local/nginx/bin:$PATH sicher, dass CMD ["nginx"] einfach funktioniert

Die Anweisung ENV ist ebenfalls nützlich, um die erforderlichen Umgebungsvariablen für die Dienste bereitzustellen, die Sie in Container verlagern möchten, wie beispielsweise die PGDATA von Postgres

Schließlich kann ENV auch dazu verwendet werden, häufig verwendete Versionsnummern festzulegen, damit Versionserhöhungen einfacher zu verwalten sind, wie im folgenden Beispiel zu sehen ist:

ENV PG_MAJOR=9.3 ENV PG_VERSION=9.3.4 RUN curl -SL https://example.com/postgres-$PG_VERSION.tar.xz | tar -xJC /usr/src/postgres && … ENV PATH=/usr/local/postgres-$PG_MAJOR/bin:$PATH

Ähnlich wie bei der Verwendung von Konstanten in einem Programm – im Gegensatz zur festen Programmierung von Werten – können Sie mit diesem Ansatz durch Ändern einer einzigen ENV-Anweisung die Version der Software in Ihrem Container automatisch erhöhen

Jede ENV-Zeile erstellt eine neue Zwischenebene, genau wie RUN-Befehle

  • Das bedeutet, dass selbst wenn Sie die Umgebungsvariable in einer späteren Ebene zurücksetzen, sie in dieser Ebene weiterhin bestehen bleibt und ihr Wert ausgegeben werden kann
  • Sie können dies testen, indem Sie eine Dockerfile wie die folgende erstellen und diese anschließend kompilieren
  1. syntax=docker/dockerfile:1

FROM alpine ENV ADMIN_USER="mark" RUN echo $ADMIN_USER > ./mark RUN unset ADMIN_USER

docker run --rm test sh -c 'echo $ADMIN_USER'

mark

Um dies zu verhindern und die Umgebungsvariable zurückzusetzen, verwenden Sie einen RUN-Befehl mit Shell-Befehlen, um die Variable in einer einzigen Ebene zu setzen, zu verwenden und zurückzusetzen

  • Sie können Ihre Befehle mit ; oder && trennen
  • Wenn Sie die zweite Methode verwenden und einer der Befehle fehlschlägt, schlägt auch der Befehl docker build fehl
  • Dies ist in der Regel eine gute Idee
  • Die Verwendung von \ als Zeichen für Zeilenfortsetzung in Linux-Dockerfiles verbessert die Lesbarkeit
  • Sie könnten auch alle Befehle in ein Shell-Skript einfügen und den RUN-Befehl so gestalten, dass er lediglich dieses Shell-Skript ausführt
  1. syntax=docker/dockerfile:1

FROM alpine RUN export ADMIN_USER="mark" \

   && echo $ADMIN_USER > ./mark \
   && unset ADMIN_USER

CMD sh

docker run --rm test sh -c 'echo $ADMIN_USER'
Links
  1. https://docs.docker.com/build/building/best-practices/#env
  2. Dockerfile-Referenz zur ENV-Anweisung

KOPIEREN

ADD und COPY sind funktional ähnlich.

COPY unterstützt das einfache Kopieren von Dateien in den Container, entweder aus dem Build-Kontext oder aus einer Stufe eines mehrstufigen Builds.

ADD bietet Funktionen zum Abrufen von Dateien von entfernten HTTPS- und Git-URLs sowie zum automatischen Entpacken von tar-Dateien beim Hinzufügen von Dateien aus dem Build-Kontext

Meistens werden Sie COPY verwenden wollen, um Dateien in einem mehrstufigen Build von einer Stufe in eine andere zu kopieren

  • Wenn Sie Dateien aus dem Build-Kontext vorübergehend in den Container einbinden müssen, um eine RUN-Anweisung auszuführen, können Sie die COPY-Anweisung oft stattdessen durch eine Bind-Mount-Verbindung ersetzen
Beispiel

Vorübergehend eine requirements.txt-Datei für eine RUN pip install-Anweisung hinzufügen

RUN --mount=type=bind,source=requirements.txt,target=/tmp/requirements.txt \
   pip install --requirement /tmp/requirements.txt

Bind-Mounts sind effizienter als COPY, wenn es darum geht, Dateien aus dem Build- Kontext in den Container einzubinden

  • Beachten Sie, dass per Bind-Mount eingebundene Dateien nur vorübergehend für eine einzelne RUN-Anweisung hinzugefügt werden und im endgültigen Image nicht erhalten bleiben
  • Wenn Sie Dateien aus dem Build-Kontext in das endgültige Image einbinden möchten, verwenden Sie COPY

Der Befehl ADD eignet sich am besten, wenn Sie im Rahmen Ihres Builds ein Remote-Artefakt herunterladen müssen.

  • ADD ist besser als das manuelle Hinzufügen von Dateien mit Programmen wie wget und tar, da es einen präziseren Build-Cache gewährleistet.
  • ADD bietet außerdem integrierte Unterstützung für die Prüfsummenüberprüfung der Remote- Ressourcen sowie ein Protokoll zum Parsen von Branches, Tags und Unterverzeichnissen aus Git-URLs

Im folgenden Beispiel wird ADD verwendet, um ein .NET-Installationsprogramm herunterzuladen

  • In Kombination mit mehrstufigen Builds verbleibt in der letzten Stufe nur die .NET-Laufzeitumgebung, keine Zwischen-Dateien
# syntax=docker/dockerfile:1
FROM scratch AS src
ARG DOTNET_VERSION=8.0.0-preview.6.23329.7
ADD --checksum=sha256:270d731bd08040c6a3228115de1f74b91cf441c584139ff8f8f6503447cebdbb \
   https://dotnetcli.azureedge.net/dotnet/Runtime/$DOTNET_VERSION/dotnet-runtime-$DOTNET_VERSION-linux-arm64.tar.gz /dotnet.tar.gz

FROM mcr.microsoft.com/dotnet/runtime-deps:8.0.0-preview.6-bookworm-slim-arm64v8 AS installer
# Retrieve .NET Runtime
RUN --mount=from=src,target=/src <<EOF
mkdir -p /dotnet
tar -oxzf /src/dotnet.tar.gz -C /dotnet
EOF

FROM mcr.microsoft.com/dotnet/runtime-deps:8.0.0-preview.6-bookworm-slim-arm64v8

COPY --from=installer /dotnet /usr/share/dotnet
RUN ln -s /usr/share/dotnet/dotnet /usr/bin/dotnet
Links
  1. https://docs.docker.com/build/building/best-practices/#add-or-copy HINZUFÜGEN oder
  2. Dockerfile-Referenz für die Anweisung „ADD“
  3. Dockerfile-Referenz zur COPY-Anweisung

ENTRYPOINT

Die beste Verwendung für ENTRYPOINT besteht darin, den Hauptbefehl des Images festzulegen, sodass das Image so ausgeführt wird, als wäre es dieser Befehl, und anschließend CMD als Standardoptionen zu verwenden

Im Folgenden finden Sie ein Beispiel für ein Bild für das Befehlszeilentool s3cmd:

ENTRYPOINT ["s3cmd"] CMD ["--help"]

Mit dem folgenden Befehl können Sie das Image ausführen und die Hilfe zum Befehl anzeigen:

docker run s3cmd

Alternativ können Sie die richtigen Parameter verwenden, um einen Befehl auszuführen, wie im folgenden Beispiel gezeigt:

docker run s3cmd ls s3://mybucket

Das ist nützlich, da der Bildname gleichzeitig als Verweis auf die Binärdatei dienen kann, wie im obigen Befehl gezeigt

Die Anweisung ENTRYPOINT kann auch in Kombination mit einem Hilfsskript verwendet werden, wodurch sie ähnlich wie der obige Befehl funktioniert, selbst wenn der Start des Tools möglicherweise mehr als einen Schritt erfordert

Beispielsweise verwendet das offizielle Postgres-Image das folgende Skript als ENTRYPOINT:

#!/bin/sh
set -e

if [ "$1" = 'postgres' ]; then
    chown -R postgres "$PGDATA"

    if [ -z "$(ls -A "$PGDATA")" ]; then
        gosu postgres initdb
    fi

    exec gosu postgres "$@"
fi

exec "$@"

Dieses Skript verwendet die eingebaute Funktion exec, sodass die letztendlich ausgeführte Anwendung die PID 1 des Containers erhält

  • Dadurch kann die Anwendung alle an den Container gesendeten Unix-Signale empfangen
  • Weitere Informationen finden Sie in der ENTRYPOINT-Referenz

Im folgenden Beispiel wird ein Hilfsskript in den Container kopiert und beim Start des Containers über ENTRYPOINT ausgeführt:

COPY ./docker-entrypoint.sh /
ENTRYPOINT ["/docker-entrypoint.sh"]
CMD ["postgres"]

Mit diesem Skript können Sie auf verschiedene Arten mit Postgres interagieren

Es kann Postgres starten:

docker run postgres

Oder Sie können damit Postgres ausführen und Parameter an den Server übergeben

docker run postgres postgres --help

Zu guter Letzt kannst du damit auch ein ganz anderes Tool starten, zum Beispiel Bash:

docker run --rm -it postgres bash
Links
  1. https://docs.docker.com/build/building/best-practices/#entrypoint
  2. Dockerfile-Referenz zur ENTRYPOINT-Anweisung

Volume

Sie sollten die Anweisung VOLUME verwenden, um Datenbank-Speicherbereiche, Konfigurationsspeicher oder von Ihrem Docker-Container erstellte Dateien und Ordner freizugeben

  • Es wird dringend empfohlen, VOLUME für jede Kombination aus veränderbaren oder vom Benutzer zu wartenden Teilen Ihres Images zu verwenden
Links
  1. https://docs.docker.com/build/building/best-practices/#volume
  2. Dockerfile-Referenz zur VOLUME-Anweisung

BENUTZER

Wenn ein Dienst ohne Sonderrechte ausgeführt werden kann, verwenden Sie USER, um zu einem Nicht-Root-Benutzer zu wechseln

  • Erstellen Sie zunächst den Benutzer und die Gruppe im Dockerfile, etwa wie im folgenden Beispiel:

RUN

groupadd -r postgres && useradd --no-log-init -r -g postgres postgres
Anmerkung
  • Betrachten wir eine explizite UID/GID
  • Benutzern und Gruppen in einem Image wird eine nicht-deterministische UID/GID zugewiesen, da die „nächste“ UID/GID unabhängig von Image-Neuerstellungen vergeben wird
  • Wenn dies also kritisch ist, sollten Sie eine explizite UID/GID zuweisen
Anmerkung
  • unterstützt dieses Flag nicht

Vermeiden Sie die Installation oder Verwendung von sudo, da es ein unvorhersehbares Verhalten hinsichtlich TTY und Signalweiterleitung aufweist, das zu Problemen führen kann

  • Wenn Sie unbedingt eine ähnliche Funktionalität wie bei sudo benötigen, beispielsweise um den Daemon als root zu initialisieren, ihn aber als Nicht-root auszuführen, sollten Sie die Verwendung von „gosu“ in Betracht ziehen

Um die Anzahl der Ebenen und die Komplexität zu reduzieren, sollten Sie es schließlich vermeiden, USER häufig hin und her zu wechseln

Weitere Informationen zu USER finden Sie in der Dockerfile-Referenz zur USER-Anweisung

WORKDIR

Aus Gründen der Übersichtlichkeit und Zuverlässigkeit sollten Sie für Ihr WORKDIR stets absolute Pfade verwenden

  • Außerdem sollten Sie WORKDIR anstelle von sich häufenden Anweisungen wie RUN cd … && do-something verwenden, da diese schwer lesbar sind und die Fehlerbehebung sowie die Wartung erschweren

Weitere Informationen zu WORKDIR finden Sie in der Dockerfile-Referenz zur Anweisung WORKDIR

ONBUILD

Ein ONBUILD-Befehl wird ausgeführt, nachdem der aktuelle Dockerfile-Build abgeschlossen ist. ONBUILD wird in jedem untergeordneten Image ausgeführt, das FROM das aktuelle Image abgeleitet ist

  • Stellen Sie sich den ONBUILD-Befehl als eine Anweisung vor, die das übergeordnete Dockerfile an das untergeordnete Dockerfile gibt

Bei einem Docker-Build werden ONBUILD-Befehle vor allen Befehlen in einer untergeordneten Dockerfile-Datei ausgeführt

ONBUILD ist nützlich für Images, die FROM ein bestimmtes Image erstellt werden sollen

  • Beispielsweise würden Sie ONBUILD für ein Sprach-Stack-Image verwenden, das beliebige, in dieser Sprache geschriebene Anwendersoftware innerhalb des Dockerfile erstellt, wie Sie in den Ruby-Varianten von ONBUILD sehen können

Mit ONBUILD erstellte Images sollten ein eigenes Tag erhalten

  • Zum Beispiel ruby:1.9-onbuild oder ruby:2.0-onbuild

Seien Sie vorsichtig, wenn Sie ADD oder COPY in ONBUILD einfügen

  • Das Image stürzt katastrophal ab, wenn im Kontext des neuen Builds die hinzugefügte Ressource fehlt
  • Das Hinzufügen eines separaten Tags, wie oben empfohlen, hilft, dieses Problem zu mildern, indem es dem Verfasser des Dockerfiles die Wahl lässt

Weitere Informationen


Anhang

Siehe auch



Dokumentation

Projekt

  1. https://docs.docker.com/reference/dockerfile/
  2. https://docs.docker.com/build/building/best-practices/#dockerfile-instructions