Especificando a Arquitetura de Computação na Qual Executar Funções

Você pode usar a CLI do Fn Project para criar uma imagem de várias arquiteturas ao implantar uma função em um aplicativo com uma forma de várias arquiteturas:

1. Acesse o ambiente de desenvolvimento como desenvolvedor de funções.
2. Se um aplicativo adequado com uma forma de arquitetura múltipla na qual criar a função ainda não existir, crie esse aplicativo agora. Consulte Criando Aplicativos.
3. Se você ainda não tiver inicializado a função, siga as instruções em Usando Comandos da CLI do Fn Project para inicializar a função agora.
4. No diretório da função, informe o seguinte comando do Fn Project para construir a função e suas dependências como uma imagem de várias arquiteturas do Docker, submeter a imagem ao registro Docker especificado e implantar a função no OCI Functions:

   fn -v deploy --app <app-name>

   em que <app-name> é o nome do aplicativo com a forma de várias arquiteturas, na qual você deseja criar a função.

   A imagem de várias arquiteturas é criada e inclui as dependências necessárias para as arquiteturas especificadas pela forma de várias arquiteturas do aplicativo.

Pré-requisito: Para poder usar o plug-in buildx do Docker, faça download do plug-in e instale-o. Para obter instruções de download e instalação, consulte a documentação do Docker buildx no github.

Depois de fazer download e instalar o plug-in buildx do Docker, você pode usar o plug-in para criar uma imagem de várias arquiteturas na qual basear uma função a ser implantada em um aplicativo com uma forma única ou de várias arquiteturas. Para obter mais informações sobre o uso do plug-in buildx do Docker, consulte a documentação do buildx do Docker no github.

Por exemplo, você pode criar uma imagem de várias arquiteturas para uma imagem hello-world do Python da seguinte forma:

1. Acesse o ambiente de desenvolvimento como desenvolvedor de funções.
2. Em uma janela de terminal, crie um diretório no qual armazenar funções. Por exemplo:

   mkdir helloworld-python-dir

3. Altere o diretório para o diretório recém-criado. Por exemplo:

   cd helloworld-python-dir

4. Crie uma função helloworld Python digitando:

   fn init --runtime python helloworld-func

   Um diretório chamado helloworld-func é criado, contendo:

   • func.yaml: O arquivo de definição de função, contendo o volume mínimo de informações necessárias para construir e executar a função. Consulte a documentação do Fn Project para saber mais sobre os parâmetros adicionais que você pode incluir em um arquivo func.yaml.
   • requirements.txt: Uma lista de bibliotecas Python necessárias.
   • func.py: O arquivo de função real.
5. Crie um novo arquivo chamado Dockerfile no mesmo diretório.

   Observe que você deve nomear o arquivo como Dockerfile .

6. Abra o arquivo chamado Dockerfile em um editor de sua escolha e adicione as seguintes linhas:

   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. Salve o arquivo chamado Dockerfile. Agora você pode usar o arquivo Dockerfile como um Dockerfile personalizado.
8. No arquivo func.yaml, altere o valor do parâmetro runtime: para runtime: docker.

   Por exemplo, altere:

   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

   para:

   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. Use o comando docker buildx para criar x86 e imagens baseadas em Arm e gerar uma imagem de várias arquiteturas a partir delas, digitando:

   docker buildx build --push --platform <platform1,platform2,..> --tag <manifest_name> <dockerfile_path>

   Por exemplo:

   docker buildx build --push --platform linux/arm64/v8,linux/amd64 --tag my-manifest-name:1.0.0-SNAPSHOT-X86-ARM .

10. Envie a imagem de várias arquiteturas para o Oracle Cloud Infrastructure Registry. Por exemplo, informando:

    docker manifest push my-manifest-name:1.0.0-SNAPSHOT-X86-ARM

    Agora você pode basear uma função na imagem de várias arquiteturas.

11. (Opcional) Crie uma nova função e defina a propriedade Image da função como o nome da imagem de várias arquiteturas. Por exemplo:
    • Ao usar a Console, especifique my-manifest-name:1.0.0-SNAPSHOT-X86-ARM no campo Imagem.
    • Ao usar a CLI do Fn Project, especifique my-manifest-name:1.0.0-SNAPSHOT-X86-ARM como o valor do argumento de imagem. Por exemplo:

      fn create function acmeapp acme-func phx.ocir.io/ansh81vru1zp/acme-repo/my-manifest-name:1.0.0-SNAPSHOT-X86-ARM

Você pode usar a CLI do Fn Project para criar uma única imagem de arquitetura ao implantar uma função em um aplicativo com uma única forma de arquitetura:

1. Acesse o ambiente de desenvolvimento como desenvolvedor de funções.
2. Se um aplicativo adequado com uma única forma de arquitetura na qual criar a função ainda não existir, crie esse aplicativo agora. Consulte Criando Aplicativos.
3. Se você ainda não tiver inicializado a função, siga as instruções em Usando Comandos da CLI do Fn Project para inicializar a função agora.
4. No diretório da função, informe o seguinte comando do Fn Project para construir a função e suas dependências como uma única imagem de arquitetura, submeter a imagem ao registro Docker especificado e implantar a função no OCI Functions:

   fn -v deploy --app <app-name>

   em que <app-name> é o nome do aplicativo com a forma de arquitetura única, na qual você deseja criar a função.

   A imagem de arquitetura única é criada e inclui as dependências necessárias para a arquitetura especificada pela forma de arquitetura única do aplicativo.

Você pode usar o comando build do Docker para criar uma única imagem de arquitetura na qual basear uma função que deseja implantar em um aplicativo com uma única forma de arquitetura. Para obter mais informações, consulte o comando docker build na documentação do Docker.

Observe que quando você usa o comando de build do Docker para criar uma imagem, a imagem inclui as dependências necessárias para a arquitetura da plataforma atual na qual você executa o comando. Portanto, se você executar o comando de build do Docker em uma plataforma AMD (uma arquitetura x86), a imagem incluirá as dependências necessárias para a arquitetura x86. Se você quiser criar uma única imagem de arquitetura para uma arquitetura diferente da plataforma atual, use o plug-in buildx do Docker e especifique a arquitetura de destino único como o valor do argumento --platform. Consulte Usando o plug-in buildx do Docker para criar uma imagem com várias arquiteturas.