Oracle Cloud Infrastructure - Dokumentation

Compute-Architektur für die Ausführung von Funktionen angeben

Erfahren Sie, wie Sie die Prozessorarchitektur angeben, auf der eine Funktion mit OCI Functions ausgeführt werden soll.

Wenn Sie eine Funktion in OCI Functions bereitstellen, können Sie die Prozessorarchitektur der Compute-Instanzen angeben, auf denen Sie die Funktion ausführen möchten. Sie können die Ausführung der Funktion auf eine einzelne Architektur (z.B. Arm) beschränken oder die Ausführung der Funktion auf mehreren Architekturen (z.B. Arm und x86) aktivieren.

Es gibt drei Schritte, um die Prozessorarchitektur anzugeben, auf der eine Funktion ausgeführt werden soll:

Je nachdem, wie Sie Funktionen mit OCI Functions erstellen, können Sie diese Schritte auf verschiedene Arten ausführen und kombinieren. Beispiel:

  • Sie können mit der Konsole zuerst eine Anwendung mit der entsprechenden Ausprägung erstellen und dann mit dem Fn-Projekt-CLI-Befehl fn deploy die Funktion erstellen und bereitstellen (die automatisch ein geeignetes Image mit den erforderlichen Abhängigkeiten erstellt).
  • Mit einem Docker-Befehl können Sie zuerst ein Image mit den erforderlichen Abhängigkeiten erstellen. Mit der OCI-CLI können Sie eine Anwendung mit der entsprechenden Ausprägung erstellen. Anschließend können Sie mit der Konsole eine Funktion in der Anwendung basierend auf dem Image erstellen.

Ausprägung einer einzelnen Architektur oder einer Anwendung mit mehreren Architekturen auswählen, auf der eine Funktion ausgeführt werden soll

Erfahren Sie, wie die Auswahl der Ausprägung einer Anwendung die Prozessorarchitektur der Compute-Instanzen beeinflusst, auf denen Funktionen mit OCI Functions ausgeführt werden.

Wenn Sie eine Anwendung in OCI Functions definieren, wählen Sie die Prozessorarchitektur der Compute-Instanzen aus, auf denen Funktionen in der Anwendung bereitgestellt und ausgeführt werden sollen. Alle Funktionen in der Anwendung werden bereitgestellt und auf Compute-Instanzen mit derselben Architektur ausgeführt.

Sie geben die Compute-Instanzarchitektur an, auf der Sie Funktionen in einer Anwendung ausführen möchten, indem Sie eine Ausprägung für die Anwendung wie folgt auswählen:

  • Wenn Funktionen in der Anwendung immer auf Compute-Instanzen mit einer Arm-basierten Architektur ausgeführt werden sollen, wählen Sie die Ausprägung Generic_ARM aus. Wenn Sie diese einzelne Architekturform für die Anwendung auswählen, muss das Image jeder Funktion die erforderlichen Abhängigkeiten für die Arm-Architektur enthalten (entweder in einem einzelnen Architekturimage oder einem Image mit mehreren Architekturen).
  • Wenn Funktionen in der Anwendung immer auf Compute-Instanzen mit einer x86-basierten Architektur ausgeführt werden sollen, wählen Sie die Ausprägung Generic_X86 aus. Wenn Sie diese einzelne Architekturausprägung für die Anwendung auswählen, muss das Image jeder Funktion die erforderlichen Abhängigkeiten für die x86-Architektur enthalten (entweder in einem einzelnen Architekturimage oder einem Image mit mehreren Architekturen).
  • Wenn Funktionen auf Compute-Instanzen mit einer Architektur mit ausreichender Kapazität ausgeführt werden sollen, wählen Sie die Ausprägung Generic_X86_ARM aus. In diesem Fall wählt OCI Functions die Architektur aus, auf der Funktionen basierend auf der verfügbaren Kapazität ausgeführt werden sollen. Wenn Sie diese Form mit mehreren Architekturen für die Anwendung auswählen, muss das Image jeder Funktion die erforderlichen Abhängigkeiten sowohl für die Arm-Architektur als auch für die x86-Architektur (in einem Image mit mehreren Architekturen) enthalten.

Wenn Sie eine Funktion in einer Anwendung erstellen, muss das Image, auf dem die Funktion basiert, die erforderlichen Abhängigkeiten für die Ausprägung der Anwendung enthalten:

  • Wenn Sie eine einzelne Architekturform für die Anwendung auswählen, muss das Image der Funktion die erforderlichen Abhängigkeiten für die entsprechende Architektur enthalten (entweder in einem einzelnen Architekturimage oder einem Image mit mehreren Architekturen).
  • Wenn Sie eine Ausprägung mit mehreren Architekturen für die Anwendung auswählen, muss das Image der Funktion die erforderlichen Abhängigkeiten für beide Architekturen (in einem Image mit mehreren Architekturen) enthalten.

Um dasselbe Image zum Bereitstellen und Ausführen einer Funktion auf mehreren verschiedenen Architekturen zu verwenden, verwenden Sie ein Image mit mehreren Architekturen (auch als Manifestliste oder als "Multi-Arch Image" bezeichnet). Sie erstellen Images mit mehreren Architekturen aus einem einzelnen Quellbaum mit einem Imagetag, das Images für x86- und Arm-Architekturen enthält.

Wenn Sie mit dem Fn-Projekt-CLI-Befehl fn -v deploy --app <app-name> eine Funktion und ihre Abhängigkeiten als Docker-Image erstellen, wird das Image mit den erforderlichen Abhängigkeiten für die Ausprägung der Anwendung erstellt. Wenn die Anwendung eine Form mit mehreren Architekturen aufweist, wird das Bild der Funktion als Bild mit mehreren Architekturen erstellt. Sie können auch Images mit mehreren Architekturen mit Docker Buildx und Podman erstellen. Wenn Sie ein anderes Tool als die Fn-Projekt-CLI verwenden, um ein Image mit mehreren Architekturen zu erstellen, müssen Sie prüfen, ob das Image mit der Ausprägung der Anwendung kompatibel ist.

Wenn Sie eine Ausprägung mit mehreren Architekturen für eine Anwendung auswählen, bewertet OCI Functions die verfügbare Kapazität und bestimmt die Architektur, in der Funktionen entsprechend bereitgestellt und ausgeführt werden. Da eine Funktion in verschiedenen Architekturen bereitgestellt werden kann, muss die Funktion auf einem Image mit mehreren Architekturen basieren. Es liegt in Ihrer Verantwortung zu prüfen, ob eine Funktion, die auf einem Image mit mehreren Architekturen basiert, sowohl in x86- als auch in Arm-Architekturen erfolgreich aufgerufen werden kann. Um dies zu ermöglichen, wird empfohlen, dass Sie nicht nur eine solche Funktion in einer Anwendung mit einer Form mit mehreren Architekturen erstellen, sondern auch Funktionen erstellen, die auf einem Bild mit mehreren Architekturen in Anwendungen mit einzelnen Architekturformen basieren. Um das Debugging zu unterstützen, empfiehlt Oracle außerdem, dass die Logs einer Funktion Details zur Architektur der Compute-Instanz enthalten, auf der die Funktion ausgeführt wird.

Nachdem Sie eine Anwendung erstellt haben, können Sie die Ausprägung der Anwendung anschließend nicht mehr ändern. Wenn eine bestimmte Funktion auf einer anderen Architektur ausgeführt werden soll, erstellen Sie die Funktion in einer anderen Anwendung (erstellen Sie gegebenenfalls eine neue Anwendung) und stellen Sie die entsprechende einzelne Architektur oder das Image mit mehreren Architekturen bereit. Beispiel:

  • Wenn Sie eine einzelne Architekturausprägung (Arm oder x86) für eine Anwendung auswählen, aber eine bestimmte Funktion auf einer anderen Architektur ausführen möchten, erstellen Sie die Funktion in einer anderen Anwendung mit der entsprechenden Architekturausprägung.
  • Wenn Sie eine Ausprägung mit mehreren Architekturen für eine Anwendung auswählen, eine bestimmte Funktion jedoch immer auf einer bestimmten Architektur ausgeführt werden soll, erstellen Sie die Funktion in einer anderen Anwendung mit der entsprechenden Ausprägung mit einer einzelnen Architektur.
  • Wenn Sie eine einzelne Architekturausprägung (Arm oder x86) für die Anwendung auswählen, aber eine bestimmte Funktion unabhängig von der Architektur auf jeder Compute-Instanz ausgeführt werden soll, erstellen Sie die Funktion in einer anderen Anwendung mit einer Ausprägung mit mehreren Architekturen.

Multi-Architektur (Multi-Arch) Bilder erstellen

Erfahren Sie, wie Sie Images mit mehreren Architekturen für Funktionen in Anwendungen erstellen, die Ausprägungen mit mehreren Architekturen aufweisen.

Sie können Images mit mehreren Architekturen auf verschiedene Arten erstellen, darunter:

Sie können Funktionen basierend auf einem Image mit mehreren Architekturen sowohl in Anwendungen mit einer Ausprägung mit mehreren Architekturen als auch in Anwendungen mit einer einzigen Architekturausprägung erstellen, vorausgesetzt, das Image mit mehreren Architekturen enthält die erforderlichen Abhängigkeiten (untergeordnete Images) für die Ausprägung der Anwendung.

Hinweis

Beachten Sie, dass OCI Functions in der Cloud Shell-Entwicklungsumgebung weder das Erstellen und Deployment von Funktionen unterstützt, die auf Images mit mehreren Architekturen basieren, noch Anwendungen mit Ausprägungen mit mehreren Architekturen. Darüber hinaus muss die Architektur der Cloud Shell-Session mit der Architektur der Anwendung identisch sein (weitere Informationen zum Auswählen der Architektur der Cloud Shell-Session finden Sie unter Cloud Shell-Architektur).

Verwenden der Fn-Projekt-CLI zum Erstellen eines Images mit mehreren Architekturen (empfohlen)

Mit der Fn-Projekt-CLI können Sie ein Image mit mehreren Architekturen erstellen, wenn Sie eine Funktion in einer Anwendung mit einer Ausprägung mit mehreren Architekturen bereitstellen:

  1. Melden Sie sich als Funktionsentwickler bei Ihrer Entwicklungsumgebung an.
  2. Wenn eine geeignete Anwendung mit einer Multi-Architektur-Form, in der die Funktion erstellt werden soll, noch nicht vorhanden ist, erstellen Sie eine solche Anwendung jetzt. Siehe Anwendungen erstellen.
  3. Wenn Sie die Funktion noch nicht initialisiert haben, befolgen Sie die Anweisungen unter Fn-Projekt-CLI-Befehle verwenden, um die Funktion jetzt zu initialisieren.
  4. Geben Sie im Verzeichnis der Funktion den folgenden Fn-Projektbefehl ein, um die Funktion und ihre Abhängigkeiten als Docker-Mehrarchitekturimage zu erstellen, das Image in die angegebene Docker-Registry zu übertragen und die Funktion in OCI Functions bereitzustellen:
    fn -v deploy --app <app-name>

    Dabei ist <app-name> der Name der Anwendung mit der Ausprägung mit mehreren Architekturen, in der Sie die Funktion erstellen möchten.

    Das Multi-Architektur-Image wird erstellt und enthält die erforderlichen Abhängigkeiten für die Architekturen, die durch die Multi-Architektur-Form der Anwendung angegeben werden.

Mit dem Docker-Buildx-Plug-in ein Image mit mehreren Architekturen erstellen

Voraussetzung: Bevor Sie das Docker-Buildx-Plug-in verwenden können, müssen Sie das Plug-in herunterladen und installieren. Anweisungen zum Herunterladen und Installieren finden Sie in der Docker-Buildx-Dokumentation auf github.

Nachdem Sie das Docker-Buildx-Plug-in heruntergeladen und installiert haben, können Sie mit dem Plug-in ein Image mit mehreren Architekturen erstellen, auf dem eine Funktion für das Deployment in einer Anwendung mit einer einzelnen oder einer Ausprägung mit mehreren Architekturen basieren soll. Weitere Informationen zur Verwendung des Docker-Buildx-Plug-ins finden Sie in der Docker-Buildx-Dokumentation auf github.

Beispiel: Sie können ein Image mit mehreren Architekturen für ein Python-Hello-World-Image wie folgt erstellen:

  1. Melden Sie sich als Funktionsentwickler bei Ihrer Entwicklungsumgebung an.
  2. Erstellen Sie in einem Terminalfenster ein Verzeichnis, in dem Funktionen gespeichert werden sollen. Beispiel:
    mkdir helloworld-python-dir
  3. Wechseln Sie in das neu erstellte Verzeichnis. Beispiel:
    cd helloworld-python-dir
  4. Erstellen Sie eine Python-Helloworld-Funktion, indem Sie Folgendes eingeben:
    fn init --runtime python helloworld-func

    Ein Verzeichnis mit dem Namen helloworld-func wird erstellt. Es enthält:

    • func.yaml: Die Funktionsdefinitionsdatei mit der Mindestmenge an Informationen, die zum Erstellen und Ausführen der Funktion erforderlich sind. Weitere Informationen zu zusätzlichen Parametern, die Sie in eine func.yaml-Datei aufnehmen können, finden Sie in der Fn-Projekt-Dokumentation.
    • requirements.txt: Eine Liste der erforderlichen Python-Librarys.
    • func.py: eigentliche Funktionsdatei.
  5. Erstellen Sie im selben Verzeichnis eine neue Datei mit dem Namen Dockerfile.

    Beachten Sie, dass Sie der Datei den Namen Dockerfile geben müssen.

  6. Öffnen Sie die Datei mit dem Namen Dockerfile in einem Editor Ihrer Wahl, und fügen Sie die folgenden Zeilen hinzu:
    FROM fnproject/python:3.6-dev as build-stage
WORKDIR /function
ADD requirements.txt /function/
 
RUN pip3 install --target /python/  --no-cache --no-cache-dir -r requirements.txt &&\
  rm -fr ~/.cache/pip /tmp* requirements.txt func.yaml Dockerfile .venv &&\
  chmod -R o+r /python
ADD . /function/
RUN rm -fr /function/.pip_cache
 
FROM fnproject/python:3.6
WORKDIR /function
COPY --from=build-stage /python /python
COPY --from=build-stage /function /function
RUN chmod -R o+r /function
ENV PYTHONPATH=/function:/python
ENTRYPOINT ["/python/bin/fdk", "/function/func.py", "handler"]
  7. Speichern Sie die Datei mit dem Namen Dockerfile. Sie können die Datei Dockerfile jetzt als benutzerdefinierte Dockerfile verwenden.
  8. Ändern Sie in der Datei func.yaml den Wert des Parameters runtime: in runtime: docker.

    Ändern Sie zum Beispiel:

    schema_version: 20180708
name: helloworld-func
version: 0.0.1
runtime: python
build_image: fnproject/python:3.9-dev
run_image: fnproject/python:3.9
entrypoint: /python/bin/fdk /function/func.py handler
memory: 256

    in:

    schema_version: 20180708
name: helloworld-func
version: 0.0.1
runtime: docker
build_image: fnproject/python:3.9-dev
run_image: fnproject/python:3.9
entrypoint: /python/bin/fdk /function/func.py handler
memory: 256
  9. Verwenden Sie den Befehl docker buildx, um x86- und Arm-basierte Images zu erstellen und daraus ein Image mit mehreren Architekturen zu generieren, indem Sie Folgendes eingeben:
    docker buildx build --push --platform <platform1,platform2,..> --tag <manifest_name> <dockerfile_path>

    Beispiel:

    docker buildx build --push --platform linux/arm64/v8,linux/amd64 --tag my-manifest-name:1.0.0-SNAPSHOT-X86-ARM .
  10. Übertragen Sie das Image mit mehreren Architekturen an die Oracle Cloud Infrastructure Registry. Beispiel: Geben Sie Folgendes ein:
    docker manifest push my-manifest-name:1.0.0-SNAPSHOT-X86-ARM

    Sie können nun eine Funktion auf dem Multi-Architektur-Bild basieren.

  11. (Optional) Erstellen Sie eine neue Funktion, und legen Sie die Bildeigenschaft der Funktion auf den Namen des Images mit mehreren Architekturen fest. Beispiel:
    • Wenn Sie die Konsole verwenden, geben Sie my-manifest-name:1.0.0-SNAPSHOT-X86-ARM im Feld Image an.
    • Wenn Sie die Fn-Projekt-CLI verwenden, geben Sie my-manifest-name:1.0.0-SNAPSHOT-X86-ARM als Wert des Bildarguments an. Beispiel:
      fn create function acmeapp acme-func phx.ocir.io/ansh81vru1zp/acme-repo/my-manifest-name:1.0.0-SNAPSHOT-X86-ARM

Einzelne Architekturbilder erstellen

Erfahren Sie, wie Sie einzelne Architekturimages für Funktionen in Anwendungen mit einzelnen Architekturausprägungen erstellen.

Sie können einzelne Architekturimages auf unterschiedliche Weise erstellen, einschließlich:

Wenn Sie eine Funktion basierend auf einem einzelnen Architekturimage erstellen, müssen Sie die Funktion in einer Anwendung mit einer kompatiblen einzelnen Architekturausprägung erstellen.

Mit der Fn-Projekt-CLI ein einzelnes Architekturimage erstellen

Mit der Fn-Projekt-CLI können Sie ein einzelnes Architekturimage erstellen, wenn Sie eine Funktion in einer Anwendung mit einer einzelnen Architekturausprägung bereitstellen:

  1. Melden Sie sich als Funktionsentwickler bei Ihrer Entwicklungsumgebung an.
  2. Wenn eine geeignete Anwendung mit einer einzelnen Architekturform, in der die Funktion erstellt werden soll, noch nicht vorhanden ist, erstellen Sie eine solche Anwendung jetzt. Siehe Anwendungen erstellen.
  3. Wenn Sie die Funktion noch nicht initialisiert haben, befolgen Sie die Anweisungen unter Fn-Projekt-CLI-Befehle verwenden, um die Funktion jetzt zu initialisieren.
  4. Geben Sie im Funktionsverzeichnis den folgenden Fn-Projektbefehl ein, um die Funktion und ihre Abhängigkeiten als einzelnes Architekturimage zu erstellen, das Image in die angegebene Docker-Registry zu übertragen und die Funktion in OCI Functions bereitzustellen:
    fn -v deploy --app <app-name>

    Dabei ist <app-name> der Name der Anwendung mit der einzelnen Architekturausprägung, in der Sie die Funktion erstellen möchten.

    Das einzelne Architekturimage wird erstellt und enthält die erforderlichen Abhängigkeiten für die Architektur, die von der einzelnen Architekturform der Anwendung angegeben wird.

Mit dem Docker-Build-Befehl ein einzelnes Architekturimage erstellen

Mit dem Docker-Build-Befehl können Sie ein einzelnes Architekturimage erstellen, auf dem eine Funktion basiert, die Sie in einer Anwendung mit einer einzelnen Architekturausprägung bereitstellen möchten. Weitere Informationen finden Sie unter docker build-Befehl in der Docker-Dokumentation.

Wenn Sie mit dem Docker-Build-Befehl ein Image erstellen, enthält das Image die erforderlichen Abhängigkeiten für die Architektur der aktuellen Plattform, auf der Sie den Befehl ausführen. Wenn Sie also den Docker-Build-Befehl auf einer AMD-Plattform (eine x86-Architektur) ausführen, enthält das Image die erforderlichen Abhängigkeiten für die x86-Architektur. Wenn Sie ein einzelnes Architekturimage für eine Architektur erstellen möchten, die sich von der aktuellen Plattform unterscheidet, verwenden Sie das Docker Buildx-Plug-in, und geben Sie die einzelne Zielarchitektur als Wert des Arguments --platform an. Siehe Docker Buildx-Plug-in zum Erstellen eines Images mit mehreren Architekturen verwenden.