Documentation sur Oracle Cloud Infrastructure

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

Découvrez comment spécifier l'architecture de processeur sur laquelle exécuter une fonction avec le service des fonctions pour OCI.

Lors du déploiement d'une fonction dans le service des fonctions pour OCI, vous pouvez spécifier l'architecture de processeur des instances de calcul sur lesquelles vous voulez exécuter la fonction. Vous pouvez limiter l'exécution de la fonction sur une seule architecture (telle que Arm), ou vous pouvez activer l'exécution de la fonction sur plusieurs architectures (telles que Arm et x86).

Il existe trois étapes pour spécifier l'architecture du processeur sur laquelle exécuter une fonction :

Selon la façon dont vous choisissez de créer des fonctions à l'aide du service des fonctions pour OCI, vous pouvez effectuer et combiner ces étapes de plusieurs façons différentes. Par exemple :

  • Vous pouvez utiliser la console pour créer une application avec la forme appropriée en premier, puis utiliser la commande fn deploy de l'interface de ligne de commande Fn Project 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 une image contenant les dépendances nécessaires en premier, 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 architecture unique ou d'une forme d'application multiarchitecture sur laquelle exécuter une fonction

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

Lorsque vous définissez une application dans le service des fonctions pour OCI, 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 de la même architecture.

Pour spécifier l'architecture de l'instance de calcul sur laquelle vous souhaitez exécuter des fonctions dans une application, sélectionnez une forme pour celle-ci comme suit :

  • Si vous voulez que les fonctions de l'application s'exécutent toujours sur des instances de calcul dotées d'une architecture basée 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 (dans une seule image d'architecture ou une image multiarchitecture).
  • Si vous voulez que les fonctions de l'application s'exécutent toujours sur des instances de calcul dotées d'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 s'exécutent sur des instances de calcul ayant une capacité suffisante, sélectionnez la forme Generic_X86_ARM. Dans ce cas, le service des fonctions pour OCI 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 à la fois pour l'architecture ARM et pour 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 forme d'architecture unique pour l'application, l'image de la fonction doit contenir les dépendances nécessaires pour l'architecture correspondante (dans une seule image d'architecture ou une image multiarchitecture).
  • Si vous sélectionnez une forme à architecture multiple pour l'application, l'image de la fonction doit contenir les dépendances nécessaires pour les deux architectures (dans une image à architecture multiple).

Pour utiliser la même image pour déployer et exécuter une fonction sur plusieurs architectures différentes, vous utilisez une image multi-architecture (également appelée liste de manifestes, ou "image multi-arch". Vous créez des images à architecture multiple à partir d'un arbre 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 Fn Project 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 pour 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 comportant plusieurs architectures à l'aide de Docker Buildx et de Podman. Si vous utilisez un outil autre que l'interface de ligne de commande Fn Project pour créer une image multiarchitecture, il est de votre responsabilité de vérifier que l'image est compatible avec la forme de l'application.

Lorsque vous sélectionnez une forme à architecture multiple pour une application, le service des fonctions pour OCI é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 multiarchitecture. Il vous incombe de vérifier qu'une fonction basée sur une image multiarchitecture peut être appelée avec succès dans les architectures x86 et ARM. Pour ce faire, nous vous recommandons de créer une telle fonction dans une application avec une forme à architecture multiple et de créer des fonctions basées sur une image à architecture multiple 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.

Après avoir créé une application, notez que vous ne pouvez pas modifier la forme de l'application. Si vous souhaitez qu'une fonction particulière s'exécute sur une autre architecture, créez-la 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 forme d'architecture unique (Arm ou x86) pour une application, mais que vous voulez qu'une fonction particulière s'exécute sur une architecture différente, créez la fonction dans une application différente qui a la forme d'architecture appropriée.
  • Si vous sélectionnez une forme d'architecture multiple 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 application différente qui a la forme d'architecture unique appropriée.
  • Si vous sélectionnez une forme d'architecture unique (Arm ou x86) pour l'application, mais que vous voulez 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 application différente qui a une forme multiarchitecture.

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

Découvrez comment créer des images multi-architecture pour des fonctions dans des applications ayant des formes multi-architecture.

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

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

Note

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 à architecture multiple, ni d'applications avec des formes à architecture multiple. 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, voir Architecture Cloud Shell).

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

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

  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. Voir Création d'applications.
  3. Si vous n'avez pas déjà initialisé la fonction, suivez les instructions sous Utilisation des commandes de l'interface de ligne de commande Fn Project pour initialiser la fonction maintenant.
  4. Dans le répertoire de la fonction, entrez la commande Fn Project suivante pour créer la fonction et ses dépendances en tant qu'image multiarchitecture Docker, pousser l'image vers le registre Docker spécifié et la déployer vers le service des fonctions pour OCI :
    fn -v deploy --app <app-name>

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

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

Utiliser le plugiciel Docker buildx pour créer une image multiarchitecture

Préalable : Avant de pouvoir utiliser le plugiciel Docker buildx, vous devez télécharger et installer le plugiciel. Pour les instructions de téléchargement et d'installation, consultez la documentation relative à Docker buildx sur github.

Après avoir téléchargé et installé le plugin Docker buildx, vous pouvez utiliser le plugin pour construire une image multi-architecture sur laquelle baser une fonction à déployer dans une application avec une forme unique ou multi-architecture. Pour plus d'informations sur l'utilisation du plugiciel Docker buildx, consultez la documentation relative à Docker buildx 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. Remplacez le répertoire par le nouveau répertoire créé. Par exemple :
    cd helloworld-python-dir
  4. Créez une fonction Python helloworld en entrant :
    fn init --runtime python helloworld-func

    Un répertoire appelé helloworld-func est créé, contenant :

    • func.yaml : Fichier de définition de fonction contenant la quantité minimale d'informations requises pour créer et exécuter la fonction. Voir la documentation Fn Project 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.
  5. Créez un nouveau 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 maintenant 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.

    Par exemple, modifiez :

    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

    en :

    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 x86 et basées sur ARM et générer une image multiarchitecture à partir d'elles, en entrant :
    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. Poussez l'image d'architecture multiple dans Oracle Cloud Infrastructure Registry. Par exemple, en entrant :
    docker manifest push my-manifest-name:1.0.0-SNAPSHOT-X86-ARM

    Vous pouvez maintenant baser une fonction sur l'image multi-architecture.

  11. (Facultatif) Créez une nouvelle fonction et réglez la propriété Image de la fonction au nom de l'image à architecture multiple. Par exemple :
    • Lorsque vous utilisez la console, spécifiez my-manifest-name:1.0.0-SNAPSHOT-X86-ARM dans le champ Image.
    • Lorsque vous utilisez l'interface de ligne de commande Fn Project, spécifiez 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éation d'images d'architecture unique

Découvrez comment créer des images d'architecture unique pour des fonctions dans des applications dotées de 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 image d'architecture unique, vous devez créer la fonction dans une application qui a une forme d'architecture unique compatible.

Utilisation de l'interface de ligne de commande Fn Project pour créer une image d'architecture unique

Vous pouvez utiliser l'interface de ligne de commande Fn Project 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 forme d'architecture unique dans laquelle créer la fonction n'existe pas déjà, créez une telle application maintenant. Voir Création d'applications.
  3. Si vous n'avez pas déjà initialisé la fonction, suivez les instructions sous Utilisation des commandes de l'interface de ligne de commande Fn Project pour initialiser la fonction maintenant.
  4. Dans le répertoire de la fonction, entrez la commande Fn Project suivante pour créer la fonction et ses dépendances en tant qu'image d'architecture unique, pousser l'image vers le registre Docker spécifié et déployer la fonction dans le service des fonctions pour OCI :
    fn -v deploy --app <app-name>

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

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

Utilisation de la commande de création Docker pour créer une image d'architecture unique

Vous pouvez utiliser la commande de création Docker pour créer une image d'architecture unique sur laquelle baser une fonction que vous souhaitez déployer dans une application avec une forme d'architecture unique. Pour plus d'informations, voir la commande de création de docker dans la documentation sur Docker.

Notez que lorsque vous utilisez la commande de création Docker pour créer une image, celle-ci inclut les dépendances nécessaires pour l'architecture de la plate-forme courante sur laquelle vous exécutez la commande. Ainsi, si vous exécutez la commande de compilation 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 courante, utilisez le plugiciel Docker buildx et spécifiez l'architecture cible unique comme valeur de l'argument --platform. Voir Utilisation du plugiciel Docker buildx pour créer une image multiarchitecture.