FDKs (Function Development Kits)

Saiba mais sobre os FDKs (Function Development Kits) usados pelo OCI Functions para suportar diferentes idiomas.

O OCI Functions usa Fn Project Function Development Kits (FDKs) para oferecer suporte a linguagens populares - Java, Node.js, Python, Go, Ruby e C#. Um FDK é um conjunto de bibliotecas auxiliares que lidam com internos do sistema (como protocolos, análise de entrada e saída e lógica para contêineres de funções). Cada idioma FDK consiste em três componentes:

Uma imagem base de tempo de compilação, contendo bibliotecas e ferramentas específicas do idioma para criar funções executáveis.
Uma imagem base de runtime, para fornecer um ambiente de runtime específico do idioma no qual executar funções executáveis.
Uma biblioteca FDK (no caso do Java, a biblioteca FDK é incluída nas imagens base de runtime e build-time).

Os FDKs são específicos para versões específicas de um determinado idioma. A Oracle publica regularmente novas imagens base de tempo de compilação e runtime do FDK para idiomas suportados (por exemplo, para emitir um patch ou para suportar uma versão recém-lançada do idioma). No caso do Java, uma atualização FDK sempre inclui todos os três componentes (as imagens base de tempo de execução e tempo de execução, bem como a biblioteca FDK). No caso de outros idiomas, uma atualização FDK pode incluir um ou mais dos componentes.

Ao criar uma função pela primeira vez usando o comando fn init da CLI do Fn Project, você especifica o idioma no qual o código-fonte da função é gravado usando a opção de comando --runtime. Além de especificar um idioma, você pode especificar opcionalmente uma versão do idioma. Se você não especificar a versão do idioma, a CLI do Fn Project pressupõe que você deseja usar a versão mais recente do FDK do idioma disponível. A CLI do Fn Project registra o valor da opção de comando --runtime como o valor do parâmetro runtime: no func.yaml da função. A CLI do Fn Project também adiciona valores para os parâmetros build_image: e run_image: no arquivo func.yaml de acordo com a opção de comando --runtime especificada, da seguinte forma:

Se você especificar simplesmente um idioma como o valor da opção de comando --runtime, a CLI do Fn Project adicionará as versões mais recentes das imagens base de runtime e de build do FDK desse idioma como valores para os parâmetros build_image: e run_image:. Por exemplo, se você informar fn init --runtime python helloworld-func e o Python 3.11 for a versão mais recente disponível, a CLI do Fn Project adicionará o seguinte:
```
runtime: python
build_image: fnproject/python:3.11-dev
run_image: fnproject/python:3.11
```
Se você especificar um idioma e uma versão como o valor da opção de comando --runtime, a CLI do Fn Project adicionará a versão correspondente das imagens base de runtime e de build do FDK do idioma como valores para os parâmetros build_image: e run_image:. Por exemplo, se você digitar fn init --runtime python3.9 helloworld-func, a CLI do Fn Project adicionará o seguinte:
```
runtime: python3.9
build_image: fnproject/python:3.9-dev
run_image: fnproject/python:3.9
```

Quando você cria uma função usando fn build ou fn deploy, a CLI do Fn Project cria uma imagem do Docker (e, no caso de fn deploy, envia a imagem para um registro do Docker). A imagem do Docker contém as dependências de runtime da função. Se a função for escrita em um idioma para o qual um FDK esteja disponível, a CLI do Fn Project:

Usa a imagem base de tempo de build especificada pelo parâmetro build_image: para criar uma versão executável da função e inclui a função executável na imagem do Docker.
Inclui a imagem base do runtime especificada pelo parâmetro run_image: na imagem do Docker, para fornecer o ambiente de runtime no qual executar a função executável.

A CLI do Fn Project usa versões armazenadas em cache das imagens base de tempo de compilação e runtime do FDK, se elas estiverem disponíveis. Se as versões armazenadas em cache das imagens base não estiverem disponíveis, a CLI do Fn Project extrairá as imagens base de tempo de compilação e runtime do idioma do FDK do Docker Hub.

Observe que, se uma nova versão de um idioma FDK for liberada, os valores dos parâmetros build_image: e run_image: no arquivo func.yaml de uma função existente não serão atualizados automaticamente. As versões iniciais das imagens base de runtime e de build-time do FDK do idioma que foram especificadas anteriormente como valores para os parâmetros build_image: e run_image: quando a função foi criada ainda são usadas para criar o executável da função e fornecer o ambiente de runtime. O uso dos valores iniciais dos parâmetros build_image: e run_image: ajuda a garantir que o código de função permaneça compatível com as imagens base de tempo de compilação e runtime do FDK do idioma.

Se você quiser recriar uma função existente com outra versão do idioma e incluir outro runtime na imagem do Docker da função, altere os valores dos parâmetros build_image: e run_image: no arquivo func.yaml da função para fazer referência a outra versão do FDK do idioma. Para consistência e evitar confusão, atualize o valor do parâmetro runtime: para corresponder à opção de comando --runtime da versão do idioma FDK. No caso de funções Java, você também precisa alterar a versão do FDK no arquivo pom.xml da função.

Exemplos

Os exemplos nesta seção pressupõem que você esteja usando o Fn Project CLI versão 0.6.7 (ou posterior) e que o Python 3.11 é a versão mais recente do Python suportada pelo Python FDK.

Exemplo 1: Criar uma nova função com Python 3.11

Se você quiser criar uma nova função com o Python 3.11, execute um dos seguintes comandos:

fn init --runtime python helloworld-func

fn init --runtime python3.11 helloworld-func

No caso de fn init --runtime python helloworld-func, a CLI do Fn Project registra o valor da opção de comando --runtime como o valor do parâmetro runtime: no func.yaml da função e adiciona os números de versão mais recentes das imagens base de runtime e de build do Python FDK como valores para os parâmetros build_image: e run_image::

runtime: python
build_image: fnproject/python:3.11-dev
run_image: fnproject/python:3.11

No caso de fn init --runtime python3.11 helloworld-func, a CLI do Fn Project registra o valor da opção de comando --runtime como o valor do parâmetro runtime: no func.yaml da função e adiciona as imagens base de runtime e de build do Python 3.11 FDK como valores para os parâmetros build_image: e run_image::

runtime: python3.11
build_image: fnproject/python:3.11-dev
run_image: fnproject/python:3.11

A partir de agora, quando você cria a função, a CLI do Fn Project continua a usar essas versões iniciais das imagens base de runtime e build-time para criar o executável da função e fornecer o ambiente de runtime.

Exemplo 2: Criar uma nova função com Python 3.9

Se você quiser criar uma nova função com o Python 3.9, execute o seguinte comando:

fn init --runtime python3.9 helloworld-func

A CLI do Fn Project registra o valor da opção de comando --runtime como o valor do parâmetro runtime: no func.yaml da função e adiciona a versão das imagens base de runtime e de build do Python FDK apropriadas para o Python 3.9 como valores para os parâmetros build_image: e run_image:, conforme mostrado:

runtime: python3.9
build_image: fnproject/python:3.9-dev
run_image: fnproject/python:3.9

A partir de agora, quando você cria a função, a CLI do Fn Project continua a usar essas versões iniciais do Python 3.9 das imagens base de build-time e runtime para criar o executável da função e fornecer o ambiente de runtime.

Exemplo 3: Recriar uma função existente com Python 3.8

Se você quiser reconstruir uma função existente que foi inicialmente criada com o Python 3.8 e quiser continuar a criá-la com o Python 3.8, execute o seguinte comando:

fn build helloworld-func

Os parâmetros build_image: e run_image: no arquivo func.yaml foram originalmente definidos para versões das imagens base de runtime e de build do Python FDK apropriadas para o Python 3.8. Quando você cria a função, a CLI do Fn Project continua a usar as mesmas imagens base de runtime e de build do Python 3.8 para criar o executável da função e fornecer o ambiente de runtime.

Exemplo 4: Recriar uma função Python 3.8 existente com Python 3.11

Se você quiser reconstruir uma função existente que foi inicialmente criada com o Python 3.8 e agora quiser criá-la com o Python 3.11:

Altere os valores dos parâmetros build_image: e run_image: no func.yaml da função para fazer referência à versão mais recente do FDK para Python 3.11 (consulte Como descobrir as versões mais recentes da imagem base de runtime e do tempo de compilação do FDK para uma versão de idioma suportada específica):
```
runtime: python3.8
build_image: fnproject/python:3.11-dev
run_image: fnproject/python:3.11
```
Para consistência e evitar confusão, atualize o valor do parâmetro runtime: para corresponder à opção de comando --runtime para Python 3.11.
```
runtime: python3.11
build_image: fnproject/python:3.11-dev
run_image: fnproject/python:3.11
```
Execute o seguinte comando:
```
fn build helloworld-func
```

A CLI do Fn Project usa as versões das imagens base de runtime e de build-time do FDK Python especificadas pelos parâmetros build_image: e run_image: no arquivo func.yaml para criar o executável da função e fornecer o ambiente de runtime. A partir de agora, quando você cria a função, a CLI do Fn Project usa essas versões das imagens base de tempo de compilação e runtime.

Comportamento em Versões Anteriores da CLI do Fn Project (antes da versão 0.6.7)

Usando versões da CLI do Fn Project anteriores à versão 0.6.7, toda vez que você criava ou reconstruía uma função escrita em uma linguagem suportada por um FDK (com exceção do Java, veja abaixo), a CLI do Fn Project usava versões em cache da linguagem de imagens base de tempo de compilação e runtime do FDK, se elas estivessem disponíveis. Se as versões armazenadas em cache das imagens base não estiverem disponíveis, a CLI do Fn Project extrairá as versões mais recentes das imagens base do Docker Hub. Como resultado, você não pode ter certeza de que o código da função era compatível com a imagem base do tempo de compilação do FDK do idioma usada para criar o executável da função ou com a imagem base do runtime usada para fornecer o ambiente de runtime.

Você pode continuar a criar funções existentes exatamente como antes, não especificando explicitamente a versão do idioma FDK ao criar uma função. A CLI do Fn Project continuará a usar versões armazenadas em cache das imagens base de runtime e de build do FDK (se disponíveis) ou extrairá as versões mais recentes das imagens base do Docker Hub (se as imagens armazenadas em cache não estiverem disponíveis).

A partir do Fn Project CLI versão 0.6.7:

Se você especificar explicitamente a versão do idioma FDK ao criar uma função, a CLI do Fn Project adicionará essa versão como o valor dos parâmetros build_image: e run_image: no arquivo func.yaml da função.
Se você criar ou implantar uma função e o arquivo func.yaml da função ainda não contiver parâmetros build_image: e run_image: porque ela foi criada com uma versão anterior da CLI do Fn Project, a CLI do Fn Project adicionará os parâmetros ao arquivo func.yaml. Os valores dos parâmetros build_image: e run_image: registram as versões das imagens base de runtime e de build do FDK que a CLI do Fn Project está usando no momento.

A menos que você especifique explicitamente uma versão diferente ao recriar a função posteriormente, a CLI do Fn Project continuará a usar a versão do FDK especificada pelos parâmetros build_image: e run_image:.

Observe que, no caso das funções Java, as versões anteriores da CLI do Fn Project adicionaram os parâmetros runtime:, build_image: e run_image: aos arquivos func.yaml, para ajudar a garantir que o código de função permanecesse compatível com as imagens base de runtime e de build do Java FDK.

Como descobrir as versões de idioma suportadas por FDKs

Para descobrir as versões de linguagens suportadas por FDKs (Java, Node.js, Python, Go, Ruby e C#):

Se ainda não tiver sido atualizado, faça upgrade da CLI do Fn Project para a versão mais recente. Consulte Upgrade da CLI do Fn Project.
Em uma janela de terminal, digite:
```
fn init --help | grep runtime
```
Por exemplo:
```
fn init --help | grep runtime

--runtime value Choose an existing runtime - dotnet, dotnet3.1, dotnet6.0, dotnet8.0, go, go1.18, go1.19, java, java11, java17, java8, kotlin, node, node14, node16, node18, python, python3.11, python3.8, python3.9, ruby, ruby2.7, ruby3.1
```
No exemplo acima, você pode ver que diferentes FDKs suportam:
- três versões de dotnet (para C#), Java, Python e Node.js
- duas versões de Go e Ruby
- Uma versão do Kotlin
Para obter mais detalhes sobre as versões suportadas, consulte Idiomas Suportados pelo OCI Functions.

Como descobrir a versão das imagens base de tempo de compilação e runtime do FDK usadas para uma função existente

Para descobrir a versão das imagens base de tempo de compilação e runtime do FDK que a CLI do Fn Project está usando no momento para criar o executável da função e fornecer o ambiente de runtime:

Se ainda não tiver sido atualizado, faça upgrade da CLI do Fn Project para a versão mais recente. Consulte Upgrade da CLI do Fn Project.
Em uma janela de terminal, altere para o diretório que contém o código da função.
Use os comandos fn build ou fn deploy para criar ou implantar a função.
Os parâmetros build_image: e run_image: serão adicionados ao arquivo func.yaml da função, se ainda não estiverem presentes. Os valores de parâmetro mostram a versão das imagens base de runtime e de build-time do FDK que a CLI do Fn Project está usando no momento para criar o executável da função e fornecer o ambiente de runtime.

Como descobrir as versões padrão de imagem base de tempo de compilação e runtime do FDK para um determinado idioma

Para descobrir as versões padrão da imagem base de tempo de compilação e runtime do FDK que a CLI do Fn Project está usando no momento para criar executáveis de função e fornecer o ambiente de runtime para funções gravadas em um determinado idioma:

Se ainda não tiver sido atualizado, faça upgrade da CLI do Fn Project para a versão mais recente. Consulte Upgrade da CLI do Fn Project.
Em uma janela de terminal, crie uma nova função helloworld informando:
```
fn init --runtime <language> hello-func
```
em que <language> é o idioma específico no qual você está interessado (um dos idiomas java, python, node, ruby, go, kotlin ou dotnet (para C#)).
Por exemplo:
```
fn init --runtime java hello-func
```
Altere para o diretório /hello-func criado para a nova função e abra o arquivo func.yaml em um editor de texto.
As versões padrão de imagem base de runtime e de build-time do FDK para o idioma especificado são mostradas como valores dos parâmetros build_image: e run_image:.

Como descobrir as versões mais recentes da imagem base de tempo de compilação e runtime do FDK para uma versão de idioma suportada específica

Para descobrir as versões mais recentes da imagem base de tempo de compilação e runtime do FDK que a CLI do Fn Project está usando no momento para criar executáveis e fornecer o ambiente de runtime para funções em uma versão específica de um determinado idioma.

Se ainda não tiver sido atualizado, faça upgrade da CLI do Fn Project para a versão mais recente. Consulte Upgrade da CLI do Fn Project.
Para ver as versões de idioma suportadas disponíveis, execute:
```
fn init --help | grep runtime
```
Por exemplo:
```
fn init --help | grep runtime

--runtime value Choose an existing runtime - dotnet, dotnet3.1, dotnet6.0, dotnet8.0, go, go1.18, go1.19, java, java11, java17, java8, kotlin, node, node14, node16, node18, python, python3.11, python3.8, python3.9, ruby, ruby2.7, ruby3.1
```
Observe os valores válidos da opção de comando --runtime para o idioma específico no qual você está interessado, que incluem o número de versões suportadas. Por exemplo:
- java17, java11, java8
- python3.11, python3.9, python3.8
- node18, node16, node14
- ruby2.7, ruby3.1
- go1.19, go1.18
- dotnet3.1, dotnet6.0, dotnet8.0 (para C#)
Em uma janela de terminal, crie uma nova função helloworld informando:
```
fn init --runtime <language-version> hello-func
```
em que <language-version> é o idioma e a versão em que você está interessado.
Por exemplo:
```
fn init --runtime java17 hello-func
```
Altere para o diretório /hello-func criado para a nova função e abra o arquivo func.yaml em um editor de texto.
As versões de imagem base de runtime e de build-time do FDK suportadas mais recentes para a versão do idioma especificada são mostradas como valores dos parâmetros build_image: e run_image:.

Como atualizar uma função existente para usar a versão mais recente da imagem base de tempo de compilação e runtime do FDK para um idioma suportado

Para fazer upgrade de uma função existente, de modo que a CLI do Fn Project use as versões mais recentes da imagem base de runtime e de build-time do FDK para um idioma suportado para criar o executável da função e fornecer o ambiente de runtime:

Se ainda não tiver sido atualizado, faça upgrade da CLI do Fn Project para a versão mais recente. Consulte Upgrade da CLI do Fn Project.
Em uma janela de terminal, altere para o diretório que contém o código da função e abra o arquivo func.yaml em um editor de texto.
Os parâmetros build_image: e run_image: mostram as versões de imagem base de runtime e de build-time do FDK que estão sendo usadas no momento pela CLI do Fn Project para criar o executável da função e fornecer o ambiente de runtime. Por exemplo:
```
build_image: fnproject/fn-java-fdk-build:jdk11-1.0.105
run_image: fnproject/fn-java-fdk:jre11-1.0.105
```
Se os parâmetros build_image: e run_image: não estiverem presentes no arquivo func.yaml, use os comandos fn build ou fn deploy para criar a função. Isso adicionará os parâmetros build_image: e run_image: ao arquivo func.yaml, definidos como a imagem de build do FDK e as versões de imagem de runtime que estão sendo usadas no momento pela CLI do Fn Project.
Descubra as versões de imagem base de tempo de compilação e runtime do FDK para a versão do idioma que você deseja que a CLI do Fn Project use (consulte Como descobrir as versões mais recentes da imagem base de tempo de compilação e runtime do FDK para uma versão de idioma suportada específica).
Abra o arquivo func.yaml em um editor de texto (se ele ainda não estiver aberto) e atualize-o da seguinte forma:
1. Altere os valores dos parâmetros build_image: e run_image: para as versões de imagem base de runtime e de build do FDK identificadas na etapa anterior.
  Por exemplo, você pode alterar:
```
build_image: fnproject/fn-java-fdk-build:jdk11-1.0.105
run_image: fnproject/fn-java-fdk:jre11-1.0.105
```
  para
```
build_image: fnproject/fn-java-fdk-build:jdk11-1.0.130
run_image: fnproject/fn-java-fdk:jre11-1.0.130
```
2. Para consistência e para evitar confusão, altere o valor do parâmetro runtime: para corresponder à opção de comando --runtime da versão do idioma. Por exemplo:
```
runtime: java11
```
Somente para funções Java, abra o arquivo pom.xml em um editor de texto e atualize o elemento <fdk.version> para corresponder à versão especificada em func.yaml.
Por exemplo, você pode alterar <fdk.version>1.0.105</fdk.version> para <fdk.version>1.0.130</fdk.version>.
Implante a função novamente e teste-a para confirmar se o código da função é compatível com as novas versões de imagem base de tempo de compilação e runtime do FDK que a CLI do Fn Project agora está usando para criar o executável da função e fornecer o ambiente de runtime.

Documentação do Oracle Cloud Infrastructure