Documentazione di Oracle Cloud Infrastructure

Specifica dell'architettura di computazione su cui eseguire le funzioni

Scopri come specificare l'architettura del processore su cui eseguire una funzione con OCI Functions.

Quando si distribuisce una funzione in OCI Functions, è possibile specificare l'architettura del processore delle istanze di computazione su cui si desidera eseguire la funzione. È possibile limitare l'esecuzione della funzione su un'unica architettura (ad esempio Arm) oppure abilitare l'esecuzione della funzione su più architetture (ad esempio Arm e x86).

Per specificare l'architettura del processore su cui eseguire una funzione, effettuare le operazioni riportate di seguito.

A seconda di come scegli di creare funzioni utilizzando OCI Functions, puoi completare e combinare questi passaggi in diversi modi. Ad esempio:

  • È possibile utilizzare la console per creare prima un'applicazione con la forma appropriata, quindi utilizzare il comando CLI fn deploy di Fn Project per creare e distribuire la funzione (che crea automaticamente un'immagine appropriata contenente le dipendenze necessarie).
  • È possibile utilizzare un comando Docker per creare un'immagine contenente le dipendenze necessarie, utilizzare prima l'interfaccia CLI OCI per creare un'applicazione con la forma appropriata, quindi utilizzare la console per creare una funzione nell'applicazione basata sull'immagine.

Selezione di una singola architettura o di una forma applicazione multiarchitettura su cui eseguire una funzione

Scopri come la selezione della forma di un'applicazione influisce sull'architettura del processore delle istanze di computazione su cui vengono eseguite le funzioni con OCI Functions.

Quando definisci un'applicazione in OCI Functions, selezioni l'architettura del processore delle istanze di computazione su cui distribuire ed eseguire le funzioni nell'applicazione. Tutte le funzioni nell'applicazione vengono distribuite ed eseguite su istanze di computazione con la stessa architettura.

Per specificare l'architettura dell'istanza di computazione in cui si desidera eseguire le funzioni in un'applicazione, selezionare una forma per l'applicazione come indicato di seguito.

  • Se si desidera che le funzioni dell'applicazione vengano sempre eseguite su istanze di computazione con un'architettura basata su Arm, selezionare la forma Generic_ARM. Se si seleziona questa singola forma di architettura per l'applicazione, l'immagine di ogni funzione deve contenere le dipendenze necessarie per l'architettura Arm (in una singola immagine di architettura o in un'immagine multi-architettura).
  • Se si desidera che le funzioni dell'applicazione vengano sempre eseguite su istanze di computazione con un'architettura basata su x86, selezionare la forma Generic_X86. Se si seleziona questa singola forma di architettura per l'applicazione, l'immagine di ogni funzione deve contenere le dipendenze necessarie per l'architettura x86 (in una singola immagine di architettura o in un'immagine multi-architettura).
  • Se si desidera che le funzioni vengano eseguite sulle istanze di computazione con la capacità sufficiente di qualsiasi architettura, selezionare la forma Generic_X86_ARM. In questo caso, OCI Functions seleziona l'architettura su cui eseguire le funzioni in base alla capacità disponibile. Se si seleziona questa forma multi-architettura per l'applicazione, l'immagine di ogni funzione deve contenere le dipendenze necessarie sia per l'architettura Arm che per l'architettura x86 (in un'immagine multi-architettura).

Quando si crea una funzione in un'applicazione, l'immagine su cui si basa la funzione deve includere le dipendenze necessarie per la forma dell'applicazione:

  • Se si seleziona una singola forma di architettura per l'applicazione, l'immagine della funzione deve contenere le dipendenze necessarie per l'architettura corrispondente (in una singola immagine di architettura o in un'immagine multi-architettura).
  • Se si seleziona una forma a più architetture per l'applicazione, l'immagine della funzione deve contenere le dipendenze necessarie per entrambe le architetture (in un'immagine a più architetture).

Per utilizzare la stessa immagine per distribuire ed eseguire una funzione su più architetture diverse, è possibile utilizzare un'immagine multi-architettura (nota anche come elenco manifesto o come 'immagine multi-arco'). È possibile creare immagini multi-architettura da un unico albero di origine, con un tag immagine che include immagini per entrambe le architetture x86 e Arm.

Se si utilizza il comando CLI di Fn Project fn -v deploy --app <app-name> per creare una funzione e le relative dipendenze come immagine Docker, l'immagine viene creata con le dipendenze necessarie per la forma dell'applicazione. Se l'applicazione ha una forma multi-architettura, l'immagine della funzione viene creata come immagine multi-architettura. Puoi anche creare immagini multi-architettura utilizzando Docker Buildx e Podman. Se si utilizza uno strumento diverso dall'interfaccia CLI di Fn Project per creare un'immagine multi-architettura, è responsabilità dell'utente verificare che l'immagine sia compatibile con la forma dell'applicazione.

Quando selezioni una forma multi-architettura per un'applicazione, OCI Functions valuta la capacità disponibile e determina l'architettura in cui distribuire ed eseguire le funzioni di conseguenza. Poiché una funzione può essere distribuita in architetture diverse, la funzione deve essere basata su un'immagine a più architetture. È responsabilità dell'utente verificare che una funzione basata su un'immagine multiarchitettura possa essere richiamata con successo sia nelle architetture x86 che nelle architetture Arm. Per consentirti di farlo, ti consigliamo di creare una tale funzione in un'applicazione con una forma multi-architettura e di creare funzioni basate su un'immagine multi-architettura in applicazioni con forme a architettura singola. Per facilitare il debug, Oracle consiglia inoltre che i log di una funzione includano dettagli dell'architettura dell'istanza di computazione su cui è in esecuzione la funzione.

Dopo aver creato un'applicazione, tenere presente che in seguito non sarà possibile modificare la forma dell'applicazione. Se si desidera che una particolare funzione venga eseguita su un'architettura diversa, creare la funzione in un'altra applicazione (creare una nuova applicazione se necessario) e fornire l'architettura singola o l'immagine multi-architettura appropriata. Ad esempio:

  • Se si seleziona una singola forma di architettura (Arm o x86) per un'applicazione ma si desidera che una particolare funzione venga eseguita su un'architettura diversa, creare la funzione in un'applicazione diversa con la forma di architettura appropriata.
  • Se si seleziona una forma a più architetture per un'applicazione, ma si desidera che una particolare funzione venga sempre eseguita su un'architettura specifica, creare la funzione in un'applicazione diversa con la forma di architettura singola appropriata.
  • Se si seleziona una singola forma di architettura (Arm o x86) per l'applicazione ma si desidera che una determinata funzione venga eseguita su qualsiasi istanza di computazione, indipendentemente dall'architettura, creare la funzione in un'applicazione diversa con una forma multiarchitettura.

Costruire Multi-Architettura (Multi-Arch) Immagini

Scopri come creare immagini multi-architettura per funzioni in applicazioni con forme multi-architettura.

È possibile creare immagini multi-architettura in diversi modi, tra cui:

È possibile creare funzioni basate su un'immagine multi-architettura sia in applicazioni con una forma multi-architettura che in applicazioni con una singola forma di architettura, a condizione che l'immagine multi-architettura includa le dipendenze necessarie (immagini figlio) per la forma dell'applicazione.

Nota

Si noti che nell'ambiente di sviluppo Cloud Shell, OCI Functions non supporta la creazione e la distribuzione di funzioni basate su immagini multiarchitettura né di applicazioni con forme multi-architettura. Inoltre, l'architettura della sessione di Cloud Shell deve essere uguale all'architettura dell'applicazione (per ulteriori informazioni sulla selezione dell'architettura della sessione di Cloud Shell, vedere Architettura di Cloud Shell).

Utilizzo dell'interfaccia CLI di Fn Project per creare un'immagine multi-architettura (consigliato)

È possibile utilizzare l'interfaccia CLI di Fn Project per creare un'immagine multi-architettura durante la distribuzione di una funzione in un'applicazione con una forma multi-architettura:

  1. Accedere all'ambiente di sviluppo come sviluppatore di funzioni.
  2. Se un'applicazione adatta con una forma multi-architettura in cui creare la funzione non esiste già, creare un'applicazione di questo tipo ora. Vedere Creazione di applicazioni.
  3. Se la funzione non è già stata inizializzata, seguire le istruzioni in Uso dei comandi CLI di Fn Project per inizializzare la funzione ora.
  4. Nella directory della funzione, immettere il comando Fn Project seguente per creare la funzione e le relative dipendenze come immagine multi-architettura Docker, eseguire il PUSH dell'immagine nel registro Docker specificato e distribuire la funzione nelle funzioni OCI:
    fn -v deploy --app <app-name>

    dove <app-name> è il nome dell'applicazione con la forma multiarchitettura, in cui si desidera creare la funzione.

    L'immagine a più architetture viene creata e include le dipendenze necessarie per le architetture specificate dalla forma a più architetture dell'applicazione.

Utilizzo del plugin buildx Docker per creare un'immagine multi-architettura

Prerequisito: prima di poter utilizzare il plugin buildx Docker, è necessario scaricare e installare il plugin. Per istruzioni sul download e sull'installazione, consulta la documentazione buildx Docker su github.

Dopo aver scaricato e installato il plugin buildx Docker, è possibile utilizzare il plugin per creare un'immagine multi-architettura su cui basare una funzione da distribuire a un'applicazione con una forma singola o multi-architettura. Per ulteriori informazioni sull'uso del plugin buildx Docker, consulta la documentazione buildx Docker su github.

Ad esempio, è possibile creare un'immagine multi-architettura per un'immagine hello-world Python come indicato di seguito.

  1. Accedere all'ambiente di sviluppo come sviluppatore di funzioni.
  2. In una finestra di terminale, creare una directory in cui memorizzare le funzioni. Ad esempio:
    mkdir helloworld-python-dir
  3. Spostarsi nella directory appena creata. Ad esempio:
    cd helloworld-python-dir
  4. Creare una funzione Python helloworld immettendo:
    fn init --runtime python helloworld-func

    Viene creata una directory denominata helloworld-func contenente:

    • func.yaml: il file di definizione della funzione, contenente la quantità minima di informazioni necessarie per creare ed eseguire la funzione. Per ulteriori informazioni sui parametri aggiuntivi che è possibile includere in un file func.yaml, consultare la documentazione di Fn Project.
    • requirements.txt: lista delle librerie Python necessarie.
    • func.py: il file delle funzioni effettivo.
  5. Creare un nuovo file denominato Dockerfile nella stessa directory.

    Si noti che è necessario assegnare un nome al file Dockerfile .

  6. Aprire il file denominato Dockerfile in un editor a scelta e aggiungere le righe seguenti:
    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. Salvare il file denominato Dockerfile. Ora è possibile utilizzare il file Dockerfile come Dockerfile personalizzato.
  8. Nel file func.yaml, modificare il valore del parametro runtime: in runtime: docker.

    Ad esempio modificare:

    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. Utilizzare il comando docker buildx per creare immagini basate su x86 e Arm e generare un'immagine multiarchitettura da esse immettendo:
    docker buildx build --push --platform <platform1,platform2,..> --tag <manifest_name> <dockerfile_path>

    Ad esempio:

    docker buildx build --push --platform linux/arm64/v8,linux/amd64 --tag my-manifest-name:1.0.0-SNAPSHOT-X86-ARM .
  10. Esegui il push dell'immagine a più architetture in Oracle Cloud Infrastructure Registry. Ad esempio, immettendo:
    docker manifest push my-manifest-name:1.0.0-SNAPSHOT-X86-ARM

    Ora è possibile basare una funzione sull'immagine multi-architettura.

  11. (Facoltativo) Creare una nuova funzione e impostare la proprietà Image della funzione sul nome dell'immagine a più architetture. Ad esempio:
    • Quando si utilizza la console, specificare my-manifest-name:1.0.0-SNAPSHOT-X86-ARM nel campo Immagine.
    • Quando si utilizza l'interfaccia CLI di Fn Project, specificare my-manifest-name:1.0.0-SNAPSHOT-X86-ARM come valore dell'argomento immagine. Ad esempio:
      fn create function acmeapp acme-func phx.ocir.io/ansh81vru1zp/acme-repo/my-manifest-name:1.0.0-SNAPSHOT-X86-ARM

Creazione di immagini di architettura singola

Scopri come creare immagini a architettura singola per funzioni in applicazioni con forme a architettura singola.

È possibile creare singole immagini di architettura in diversi modi, tra cui:

Quando si crea una funzione basata su una singola immagine di architettura, è necessario creare la funzione in un'applicazione con una singola forma di architettura compatibile.

Utilizzo dell'interfaccia CLI di Fn Project per creare un'unica immagine di architettura

È possibile utilizzare l'interfaccia CLI di Fn Project per creare un'unica immagine di architettura durante la distribuzione di una funzione in un'applicazione con una singola forma di architettura:

  1. Accedere all'ambiente di sviluppo come sviluppatore di funzioni.
  2. Se un'applicazione adatta con una singola forma di architettura in cui creare la funzione non esiste già, creare un'applicazione di questo tipo ora. Vedere Creazione di applicazioni.
  3. Se la funzione non è già stata inizializzata, seguire le istruzioni in Uso dei comandi CLI di Fn Project per inizializzare la funzione ora.
  4. Nella directory della funzione, immettere il seguente comando Fn Project per creare la funzione e le relative dipendenze come singola immagine di architettura, eseguire il push dell'immagine nel registro Docker specificato e distribuire la funzione in OCI Functions:
    fn -v deploy --app <app-name>

    dove <app-name> è il nome dell'applicazione con la forma a architettura singola, in cui si desidera creare la funzione.

    Viene creata la singola immagine dell'architettura e sono incluse le dipendenze necessarie per l'architettura specificata dalla forma a architettura singola dell'applicazione.

Utilizzo del comando build Docker per creare un'unica immagine dell'architettura

È possibile utilizzare il comando build Docker per creare un'unica immagine di architettura su cui basare una funzione che si desidera distribuire in un'applicazione con una singola forma di architettura. Per ulteriori informazioni, consulta il comando di build del docker nella documentazione Docker.

Tenere presente che quando si utilizza il comando di creazione Docker per creare un'immagine, l'immagine include le dipendenze necessarie per l'architettura della piattaforma corrente su cui si esegue il comando. Pertanto, se si esegue il comando build Docker su una piattaforma AMD (un'architettura x86), l'immagine include le dipendenze necessarie per l'architettura x86. Se si desidera creare un'unica immagine di architettura per un'architettura diversa dalla piattaforma corrente, utilizzare il plugin buildx Docker e specificare l'architettura di destinazione singola come valore dell'argomento --platform. Vedere Utilizzo del plugin buildx Docker per creare un'immagine a più architetture.