Documentation Oracle Cloud Infrastructure

Spécification de l'architecture de calcul sur laquelle exécuter des fonctions

Découvrez comment spécifier l'architecture de processeur sur laquelle exécuter une fonction avec OCI Functions.

Lors du déploiement d'une fonction vers OCI Functions, vous pouvez indiquer l'architecture de processeur des instances de calcul sur lesquelles exécuter la fonction. Vous pouvez limiter l'exécution de la fonction à une seule architecture (par exemple, Arm) ou activer l'exécution de la fonction sur plusieurs architectures (par exemple, Arm et x86).

Pour spécifier l'architecture du processeur sur laquelle exécuter une fonction, procédez comme suit :

Selon la façon dont vous choisissez de créer des fonctions à l'aide d'OCI Functions, vous pouvez effectuer et combiner ces étapes de différentes manières. Par exemple :

  • Vous pouvez d'abord utiliser la console pour créer une application avec la forme appropriée, puis utiliser la commande fn deploy de l'interface de ligne de commande du projet Fn pour créer et déployer la fonction (qui crée automatiquement une image appropriée contenant les dépendances nécessaires).
  • Vous pouvez utiliser une commande Docker pour créer d'abord une image contenant les dépendances nécessaires, utiliser l'interface de ligne de commande OCI pour créer une application avec la forme appropriée, puis utiliser la console pour créer une fonction dans l'application en fonction de l'image.

Sélection d'une forme d'application à architecture unique ou à architecture multiple sur laquelle exécuter une fonction

Découvrez comment la sélection de la forme d'une application influence l'architecture de processeur des instances de calcul sur lesquelles les fonctions s'exécutent avec OCI Functions.

Lorsque vous définissez une application dans OCI Functions, vous sélectionnez l'architecture de processeur des instances de calcul sur lesquelles déployer et exécuter des fonctions dans l'application. Toutes les fonctions de l'application sont déployées et exécutées sur des instances de calcul avec la même architecture.

Pour indiquer l'architecture d'instance de calcul sur laquelle exécuter des fonctions dans une application, sélectionnez une forme pour l'application comme suit :

  • Si vous voulez toujours que les fonctions de l'application s'exécutent sur des instances de calcul avec une architecture reposant sur Arm, sélectionnez la forme Generic_ARM. Si vous sélectionnez cette forme d'architecture unique pour l'application, l'image de chaque fonction doit contenir les dépendances nécessaires pour l'architecture Arm (soit dans une image d'architecture unique, soit dans une image multiarchitecture).
  • Si vous voulez toujours que les fonctions de l'application soient exécutées sur des instances de calcul avec une architecture basée sur x86, sélectionnez la forme Generic_X86. Si vous sélectionnez cette forme d'architecture unique pour l'application, l'image de chaque fonction doit contenir les dépendances nécessaires pour l'architecture x86 (dans une seule image d'architecture ou une image multiarchitecture).
  • Si vous voulez que les fonctions soient exécutées sur des instances de calcul avec l'architecture ayant une capacité suffisante, sélectionnez la forme Generic_X86_ARM. Dans ce cas, OCI Functions sélectionne l'architecture sur laquelle exécuter les fonctions en fonction de la capacité disponible. Si vous sélectionnez cette forme à architecture multiple pour l'application, l'image de chaque fonction doit contenir les dépendances nécessaires pour l'architecture Arm et l'architecture x86 (dans une image à architecture multiple).

Lorsque vous créez une fonction dans une application, l'image sur laquelle la fonction est basée doit inclure les dépendances nécessaires pour la forme de l'application :

  • Si vous sélectionnez une seule forme d'architecture pour l'application, l'image de la fonction doit contenir les dépendances nécessaires pour l'architecture correspondante (soit dans une seule image d'architecture, soit dans une image multiarchitecture).
  • Si vous sélectionnez une forme multiarchitecture pour l'application, l'image de la fonction doit contenir les dépendances nécessaires pour les deux architectures (dans une image multiarchitecture).

Pour utiliser la même image pour déployer et exécuter une fonction sur plusieurs architectures différentes, vous utilisez une image multiarchitecture (également appelée liste de manifestes ou "image multi-arch"). Vous créez des images multi-architectures à partir d'une arborescence source unique, avec une balise d'image qui inclut des images pour les architectures x86 et Arm.

Si vous utilisez la commande d'interface de ligne de commande du projet Fn fn -v deploy --app <app-name> pour créer une fonction et ses dépendances en tant qu'image Docker, l'image est créée avec les dépendances nécessaires à la forme de l'application. Si l'application a une forme multi-architecture, l'image de la fonction est construite en tant qu'image multi-architecture. Vous pouvez également créer des images multi-architectures à l'aide de Docker Buildx et de Podman. Si vous utilisez un outil autre que l'interface de ligne de commande du projet Fn pour créer une image multi-architecture, il vous incombe de vérifier que l'image est compatible avec la forme de l'application.

Lorsque vous sélectionnez une forme à plusieurs architectures pour une application, OCI Functions évalue la capacité disponible et détermine l'architecture dans laquelle déployer et exécuter les fonctions en conséquence. Comme une fonction peut être déployée dans différentes architectures, elle doit être basée sur une image multi-architecture. Il est de votre responsabilité de vérifier qu'une fonction basée sur une image multi-architecture peut être appelée avec succès dans les architectures x86 et Arm. Pour ce faire, nous vous recommandons, en plus de créer une telle fonction dans une application avec une forme multi-architecture, de créer également des fonctions basées sur une image multi-architecture dans des applications avec des formes à architecture unique. Pour faciliter le débogage, Oracle recommande également que les journaux d'une fonction incluent des détails sur l'architecture de l'instance de calcul sur laquelle la fonction est exécutée.

Une fois l'application créée, vous ne pouvez plus la modifier. Si vous souhaitez qu'une fonction particulière s'exécute sur une autre architecture, créez la fonction dans une autre application (créez une nouvelle application si nécessaire) et fournissez l'architecture unique ou l'image multiarchitecture appropriée. Par exemple :

  • Si vous sélectionnez une seule forme d'architecture (Arm ou x86) pour une application mais que vous souhaitez qu'une fonction particulière s'exécute sur une autre architecture, créez la fonction dans une autre application possédant la forme d'architecture appropriée.
  • Si vous sélectionnez une forme multiarchitecture pour une application, mais que vous souhaitez qu'une fonction particulière s'exécute toujours sur une architecture spécifique, créez la fonction dans une autre application possédant la forme d'architecture unique appropriée.
  • Si vous sélectionnez une seule forme d'architecture (Arm ou x86) pour l'application mais que vous souhaitez qu'une fonction particulière s'exécute sur n'importe quelle instance de calcul, quelle que soit l'architecture, créez la fonction dans une autre application dotée d'une forme multiarchitecture.

Création d'images multi-architecture (multi-archives)

Découvrez comment créer des images multi-architectures pour les fonctions des applications aux formes multi-architectures.

Vous pouvez créer des images multiarchitecture de différentes manières, notamment :

Vous pouvez créer des fonctions basées sur une image multiarchitecture à la fois dans les applications qui ont une forme multiarchitecture et dans les applications qui ont une forme d'architecture unique, à condition que l'image multiarchitecture inclut les dépendances nécessaires (images enfant) pour la forme de l'application.

Remarque

Notez que dans l'environnement de développement Cloud Shell, OCI Functions ne prend pas en charge la création et le déploiement de fonctions basées sur des images multi-architectures, ni d'applications avec des formes multi-architectures. En outre, l'architecture de la session Cloud Shell doit être identique à celle de l'application (pour plus d'informations sur la sélection de l'architecture de la session Cloud Shell, reportez-vous à Architecture Cloud Shell).

Utiliser l'interface de ligne de commande du projet Fn pour créer une image multiarchitecture (recommandé)

Vous pouvez utiliser l'interface de ligne de commande du projet Fn pour créer une image multi-architecture lors du déploiement d'une fonction dans une application avec une forme multi-architecture :

  1. Connectez-vous à votre environnement de développement en tant que développeur de fonctions.
  2. Si une application appropriée avec une forme multi-architecture dans laquelle créer la fonction n'existe pas déjà, créez une telle application maintenant. Reportez-vous à Création d'applications.
  3. Si vous n'avez pas encore initialisé la fonction, suivez les instructions de la section Using Fn Project CLI Commands pour initialiser la fonction maintenant.
  4. Dans le répertoire de la fonction, entrez la commande de projet Fn suivante pour construire la fonction et ses dépendances en tant qu'image multi-architecture Docker, propager l'image vers le registre Docker indiqué et déployer la fonction vers OCI Functions :
    fn -v deploy --app <app-name>

    où <app-name> est le nom de l'application avec la forme multiarchitecture dans laquelle vous voulez créer la fonction.

    L'image multiarchitecture est créée et inclut les dépendances nécessaires pour les architectures spécifiées par la forme multiarchitecture de l'application.

Utiliser le module d'extension Docker buildx pour créer une image multiarchitecture

Prérequis : pour pouvoir utiliser le module d'extension buildx Docker, vous devez télécharger et installer le module d'extension. Pour obtenir des instructions de téléchargement et d'installation, reportez-vous à la documentation buildx de Docker sur github.

Après avoir téléchargé et installé le module d'extension buildx de Docker, vous pouvez l'utiliser pour créer une image multi-architecture sur laquelle baser une fonction à déployer vers une application avec une forme à architecture unique ou multiple. Pour plus d'informations sur l'utilisation du module d'extension buildx Docker, reportez-vous à la documentation buildx Docker sur github.

Par exemple, vous pouvez créer une image multiarchitecture pour une image hello-world Python comme suit :

  1. Connectez-vous à votre environnement de développement en tant que développeur de fonctions.
  2. Dans une fenêtre de terminal, créez un répertoire dans lequel stocker les fonctions. Par exemple :
    mkdir helloworld-python-dir
  3. Passez au répertoire que vous venez de créer. Par exemple :
    cd helloworld-python-dir
  4. Créez une fonction Python helloworld en saisissant ce qui suit :
    fn init --runtime python helloworld-func

    Un répertoire nommé helloworld-func est créé et contient les éléments suivants :

    • func.yaml : fichier de définition de fonction, contenant la quantité minimale d'informations requises pour créer et exécuter la fonction. Reportez-vous à la documentation du projet Fn pour en savoir plus sur les paramètres supplémentaires que vous pouvez inclure dans un fichier func.yaml.
    • requirements.txt : liste des bibliothèques Python requises.
    • func.py : fichier de la fonction réelle.
  5. Créez un fichier nommé Dockerfile dans le même répertoire.

    Notez que vous devez nommer le fichier Dockerfile.

  6. Ouvrez le fichier nommé Dockerfile dans l'éditeur de votre choix et ajoutez les lignes suivantes :
    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. Enregistrez le fichier nommé Dockerfile. Vous pouvez désormais utiliser le fichier Dockerfile en tant que fichier Dockerfile personnalisé.
  8. Dans le fichier func.yaml, remplacez la valeur du paramètre runtime: par runtime: docker.

    Modifiez par exemple :

    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

    vers :

    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. Utilisez la commande docker buildx pour créer des images basées sur x86 et Arm et générer une image multiarchitecture à partir de ces images, en saisissant ce qui suit :
    docker buildx build --push --platform <platform1,platform2,..> --tag <manifest_name> <dockerfile_path>

    Par exemple :

    docker buildx build --push --platform linux/arm64/v8,linux/amd64 --tag my-manifest-name:1.0.0-SNAPSHOT-X86-ARM .
  10. Envoi de l'image multi-architecture à Oracle Cloud Infrastructure Registry. Par exemple, entrez la commande suivante :
    docker manifest push my-manifest-name:1.0.0-SNAPSHOT-X86-ARM

    Vous pouvez désormais baser une fonction sur l'image multiarchitecture.

  11. (Facultatif) Créez une nouvelle fonction et définissez la propriété Image de la fonction sur le nom de l'image multiarchitecture. Par exemple :
    • Lorsque vous utilisez la console, indiquez my-manifest-name:1.0.0-SNAPSHOT-X86-ARM dans le champ Image.
    • Lorsque vous utilisez l'interface de ligne de commande du projet Fn, indiquez my-manifest-name:1.0.0-SNAPSHOT-X86-ARM comme valeur de l'argument d'image. Par exemple :
      fn create function acmeapp acme-func phx.ocir.io/ansh81vru1zp/acme-repo/my-manifest-name:1.0.0-SNAPSHOT-X86-ARM

Créer des images d'architecture unique

Découvrez comment créer des images d'architecture unique pour des fonctions dans des applications ayant des formes d'architecture uniques.

Vous pouvez créer des images d'architecture unique de différentes manières, notamment :

Lorsque vous créez une fonction basée sur une seule image d'architecture, vous devez la créer dans une application qui a une forme d'architecture unique compatible.

Utiliser l'interface de ligne de commande du projet Fn pour créer une image d'architecture unique

Vous pouvez utiliser l'interface de ligne de commande du projet Fn pour créer une image d'architecture unique lors du déploiement d'une fonction dans une application avec une forme d'architecture unique :

  1. Connectez-vous à votre environnement de développement en tant que développeur de fonctions.
  2. Si une application appropriée avec une seule forme d'architecture dans laquelle créer la fonction n'existe pas déjà, créez une telle application maintenant. Reportez-vous à Création d'applications.
  3. Si vous n'avez pas encore initialisé la fonction, suivez les instructions de la section Using Fn Project CLI Commands pour initialiser la fonction maintenant.
  4. Dans le répertoire de la fonction, entrez la commande de projet Fn suivante pour construire la fonction et ses dépendances en tant qu'image d'architecture unique, propager l'image vers le registre Docker indiqué et déployer la fonction vers OCI Functions :
    fn -v deploy --app <app-name>

    où <app-name> est le nom de l'application avec la forme d'architecture unique dans laquelle créer la fonction.

    L'image d'architecture unique est créée et inclut les dépendances nécessaires pour l'architecture spécifiée par la forme d'architecture unique de l'application.

Utiliser la commande de build Docker pour créer une image d'architecture unique

Vous pouvez utiliser la commande de build Docker pour créer une image d'architecture unique sur laquelle baser une fonction à déployer vers une application avec une forme d'architecture unique. Pour plus d'informations, reportez-vous à la commande de build docker dans la documentation Docker.

Lorsque vous utilisez la commande de build Docker pour créer une image, l'image inclut les dépendances nécessaires pour l'architecture de la plate-forme en cours sur laquelle vous exécutez la commande. Par conséquent, si vous exécutez la commande de build Docker sur une plate-forme AMD (architecture x86), l'image inclut les dépendances nécessaires pour l'architecture x86. Si vous voulez créer une image d'architecture unique pour une architecture différente de la plate-forme en cours, utilisez le module d'extension Docker buildx et indiquez l'architecture cible unique en tant que valeur de l'argument --platform. Reportez-vous à Utilisation du module d'extension Docker buildx pour créer une image multiarchitecture.