Utilizzo di un esempio per creare una funzione con l'editor di codice

Scopri come utilizzare l'Editor di codice per creare una nuova funzione in OCI Functions in base a una funzione di esempio.

È possibile utilizzare l'Editor di codice per creare una nuova funzione in OCI Functions in base a una funzione di esempio. Oracle fornisce una serie di utili funzioni di esempio scritte in diverse lingue. Dopo aver creato una funzione di esempio func.yaml e file di codice sorgente in una directory senza controllo della versione, è possibile utilizzare l'Editor di codice per convertire la directory in un repository Git locale che è possibile eseguire il push in un repository Git remoto. Con i file nel repository Git remoto, è quindi possibile utilizzare l'Editor di codice per distribuire la funzione in OCI Functions e quindi per richiamare la funzione.

Quando si utilizza l'Editor di codice per creare e aggiornare le funzioni, tenere presente quanto riportato di seguito.

Il repository Git remoto deve contenere un file func.yaml valido al livello superiore.
Il nome di una funzione creata mediante l'Editor di codice deve corrispondere al nome della funzione specificato nel file func.yaml nel repository di codici remoti. Se i nomi sono diversi, non sarà possibile richiamare la funzione.
Quando si distribuisce una funzione in OCI Functions, si sta recuperando il commit più recente dal repository Git remoto. Le modifiche di cui non è stato eseguito il commit e i commit nel repository locale vengono ignorati. Pertanto, prima di poter distribuire una funzione nuova o aggiornata in OCI Functions, è necessario eseguire sempre il commit di file nuovi e modificati nel repository Git locale, quindi eseguire il push delle modifiche nel repository Git remoto.

In questo argomento viene spiegato come utilizzare l'editor di codice per:

crea una nuova funzione da una funzione di esempio
convertire la directory senza controllo della versione contenente i file di codice sorgente e func.yaml della funzione in un repository Git locale che è possibile inviare a un repository Git remoto
distribuire la funzione in OCI Functions
richiamare la funzione
facoltativamente, aggiornare la funzione, ridistribuirla e richiamarla di nuovo

Prima di iniziare:

È necessario aver completato i passi in Funzioni QuickStart su Cloud Shell.
Per seguire la procedura descritta in questo argomento, è necessario disporre dell'accesso a un repository Git remoto vuoto (ad esempio, in GitHub) o essere in grado di creare un repository di questo tipo.
Per comodità e semplicità, gli esempi in questo argomento presuppongono di creare una funzione dalla funzione di esempio oci-list-compartments-python. Se si crea una funzione da un'altra funzione di esempio, alcune istruzioni non vengono applicate.

Per ulteriori informazioni sulle caratteristiche e le funzionalità dell'editor di codice, vedere Editor di codice.

Creazione di una funzione da un esempio mediante l'editor di codice

Per utilizzare l'editor di codice per creare una nuova funzione in OCI Functions in base a una funzione di esempio:

Confermare di aver completato i passi delle funzioni QuickStart in Cloud Shell per effettuare le operazioni riportate di seguito.
- Impostare la tenancy con gruppi e utenti, creare un compartimento in cui creare risorse di OCI Functions, creare una VCN e una subnet e creare un criterio IAM.
- Impostare l'ambiente di sviluppo Cloud Shell con il contesto CLI di Fn Project, ottenere un token di autenticazione ed eseguire il login al registro Docker specificato per il contesto CLI di Fn Project.
Accedere alla console come sviluppatore di funzioni.
Utilizzare la console per creare una nuova applicazione in OCI Functions:
1. Aprire il menu di navigazione e selezionare Developer Services. In Funzioni, selezionare Applicazioni.
2. Selezionare l'area che si desidera utilizzare per OCI Functions.
  Si consiglia di utilizzare la stessa area del registro Docker specificato nel contesto CLI di Fn Project (vedere Creazione di un contesto CLI di Fn Project per connettersi a Oracle Cloud Infrastructure).
3. Selezionare il compartimento specificato nel contesto CLI di Fn Project (vedere Creazione di un contesto CLI di Fn Project per connettersi a Oracle Cloud Infrastructure).
  
  La pagina Applicazioni mostra le applicazioni già definite nel compartimento.
4. Selezionare Crea applicazione e specificare:
  - Nome della nuova applicazione. Ad esempio, samples-app
  - La VCN e la subnet (o subnet, fino a un massimo di tre) in cui eseguire la funzione. Si consiglia di posizionare le subnet nella stessa area del registro Docker specificato nel contesto CLI di Fn Project (vedere Creazione di un contesto CLI di Fn Project per connettersi a Oracle Cloud Infrastructure).
  Per ulteriori informazioni sulle altre opzioni di creazione dell'applicazione, vedere Creazione di un'applicazione.
5. Selezionare Crea per creare l'applicazione.
Avviare l'editor di codice in uno dei seguenti modi:
- Nella pagina dell'elenco Applicazioni selezionare l'applicazione in cui si desidera creare la funzione. Nella pagina dei dettagli dell'applicazione selezionare Funzioni. Nella scheda Funzioni selezionare Crea nell'editor di codice. Questo metodo apre l'editor di codice nell'applicazione appena creata.
- Selezionare l'opzione Editor di codice dal pulsante Strumenti di sviluppo nella barra degli strumenti della console.
Crea una nuova funzione da una funzione di esempio:
1. Nel pannello Editor di codice di Oracle Cloud Infrastructure, passare all'applicazione appena creata nel compartimento specificato nel contesto CLI di Fn Project. Ad esempio, samples-app.
2. Con il nome dell'applicazione evidenziato, selezionare Crea funzione... dal menu con il pulsante destro del mouse.
3. Selezionare il metodo di creazione Crea da un esempio nel campo di immissione nella barra dei menu dell'editor di codice.
4. Selezionare una funzione dall'elenco di funzioni campione e premere Invio. Ad esempio, selezionare oci-list-compartments-python.
5. Immettere un nome per la nuova funzione nel campo di immissione nella barra dei menu dell'editor di codice e premere Invio. Il nome immesso deve essere uguale al nome nel file func.yaml della funzione di esempio. Nella maggior parte dei casi, questo è il nome nell'elenco delle funzioni di esempio del passo precedente. Ad esempio, oci-list-compartments-python.
  Immettere un nome per la nuova funzione nel campo di immissione nella barra dei menu dell'editor di codice e premere Invio. Il nome immesso deve essere uguale al nome della funzione di esempio selezionata nell'elenco. Ad esempio, oci-list-compartments-python.
6. Selezionare OK per confermare la finestra di dialogo che informa che è necessario eseguire il commit e il push delle modifiche in una diramazione remota prima di poter distribuire la funzione.
  Una directory che prende il nome dalla funzione viene creata nella directory /home/<username>/oci-ide-plugins/faas-artifacts/<app-ocid>/. Ad esempio, in /home/jdoe/oci-ide-plugins/faas-artifacts/ocid1.fnapp.oc1.iad.aaaaaa______76nf/oci-list-compartments-python,
  Se la nuova funzione è stata basata sulla funzione di esempio oci-list-compartments-python, la directory contiene:
  - func.yaml
  - func.py
  - README.md
  - requirments.txt
  - una directory /images
Salvare la funzione in un repository Git locale:
1. Per aprire una finestra del terminale dell'editor di codice, selezionare Nuovo terminale nella finestra Terminale nella barra dei menu dell'editor di codice.
2. Nella finestra del terminale dell'Editor di codice, passare alla directory appena creata che contiene il file func.yaml e i file di origine della funzione immettendo:
```
cd /home/<oci-username>/oci-ide-plugins/faas-artifacts/<application-OCID>/<function-name>
```
  Ad esempio:
```
cd /home/jdoe/oci-ide-plugins/faas-artifacts/ocid1.fnapp.oc1.iad.aaaaaaaa______76nf/oci-list-compartments-python
```
3. Convertire la directory senza controllo delle versioni (ad esempio, denominata oci-list-compartments-python) in un repository Git locale immettendo:
```
git init
```
4. Aggiungere i file nella directory all'area intermedia immettendo:
```
git add .
```
5. Memorizzare il contenuto dell'area intermedia nel repository Git locale immettendo:
```
git commit
```
6. Quando richiesto, immettere un messaggio di commit:
  1. Premere il tasto i sulla tastiera per inserire testo.
  2. Immettere un messaggio di commit. Ad esempio, immettendo:
```
Adds sample files.
```
  3. Premere il tasto Esc, quindi digitare : w q e premere Invio.
Creare un nuovo repository Git remoto. Ad esempio, in GitHub come https://github.com/jdoe/list-compartments-sample-repo.
Eseguire il push della funzione nel repository Git remoto:
1. Nella finestra del terminale dell'Editor di codice, nella directory contenente il file func.yaml e i file di origine della funzione, collegare il repository Git locale al repository Git remoto appena creato immettendo:
```
git remote add origin <remote-repository-url>
```
  Ad esempio:
```
git remote add origin https://github.com/jdoe/list-compartments-sample-repo.git
```
2. Creare una nuova diramazione denominata principale nel repository Git locale immettendo:
```
git branch -M main
```
3. Eseguire il push dei file nella diramazione main nel repository Git remoto immettendo:
```
git push -u origin main
```
4. Se richiesto, immettere il nome utente e la password Git per il repository Git remoto.
  Nel caso di GitHub, la password è il token di accesso personale GitHub.
Distribuire la funzione in OCI Functions:
1. Nella finestra del terminale Editor di codice, nella directory contenente il file func.yaml e i file di origine della funzione, eseguire il login al registro Docker specificato nel contesto CLI di Fn Project. Supponendo che il registro Docker sia Oracle Cloud Infrastructure Registry, utilizzare il seguente comando:
```
docker login -u '<tenancy-namespace>/<user-name>' <region-key>.ocir.io
```
  Ad esempio:
```
docker login -u 'ansh81vru1zp/jdoe@acme.com' phx.ocir.io
```
2. Quando viene richiesta una password, immettere il token di autenticazione OCI.
3. Nella finestra del terminale dell'editor di codice, distribuire la funzione in OCI Functions eseguendo:
```
fn -v deploy --app <application-name>
```
  Ad esempio:
```
fn -v deploy --app samples-app
```
Alcune funzioni di esempio dispongono di prerequisiti specifici, ad esempio criteri IAM specifici. Questi prerequisiti sono descritti nel file README.md della funzione di esempio. Ad esempio, per una funzione basata sulla funzione di esempio oci-list-compartments-python, il file README.md indica che l'unico prerequisito è che la funzione sia membro di un gruppo dinamico.

Se la nuova funzione è stata basata sulla funzione di esempio oci-list-compartments-python, seguire le istruzioni riportate di seguito per aggiungere la funzione a un gruppo dinamico.
1. Aprire il menu di navigazione e selezionare Identità e sicurezza. In Identità, selezionare Domini. In Dominio di Identity, selezionare Gruppi dinamici.
2. Seguire le istruzioni in Per creare un gruppo dinamico e assegnare al gruppo dinamico un nome (ad esempio, sample-func-dyn-grp).
3. Quando si specifica una regola per il gruppo dinamico, immettere una regola simile alla seguente per aggiungere tutte le funzioni del compartimento in cui è stata creata la nuova funzione al gruppo dinamico:
```
ALL {resource.type = 'fnfunc', resource.compartment.id = '<compartment-ocid>'}
```
  dove <compartment-ocid> è l'OCID del compartimento in cui è stata creata l'applicazione.
  
  Ad esempio:
```
ALL {resource.type = 'fnfunc', resource.compartment.id = 'ocid1.compartment.oc1..aaaaaaaa23______smwa'}
```
4. Selezionare Crea gruppo dinamico.
Richiamare la funzione appena distribuita:
1. Nella finestra del terminale dell'Editor di codice, nella directory che contiene il file func.yaml e i file di origine della funzione, richiamare la funzione eseguendo:
```
fn invoke <application-name> <function-name>
```
  Ad esempio:
```
fn invoke samples-app oci-list-compartments-python
```
  Se viene restituito un messaggio che indica che la funzione non è stata trovata, è probabile che una causa sia una mancata corrispondenza tra il nome della funzione creata nell'Editor di codice e il nome della funzione specificata in func.yaml. Ripetere i passi precedenti per creare una funzione nell'Editor di codice con lo stesso nome specificato nel file func.yaml nel repository Git remoto.
  Se si soddisfano i prerequisiti identificati nel file README.md della funzione, la funzione restituisce una risposta.
  Ad esempio, se la nuova funzione è stata basata sulla funzione di esempio oci-list-compartments-python e la si è aggiunta a un gruppo dinamico (come descritto in precedenza), la funzione restituisce una lista di tutti i compartimenti all'interno della tenancy come indicato di seguito.
```
{"compartments": [["<compartment-ocid>", "<compartment-name>"], ["<compartment-ocid>", "<compartment-name>"]… }
```
(Facoltativo) Se la nuova funzione è stata basata sulla funzione di esempio oci-list-compartments-python nei passi precedenti, questo passo facoltativo descrive come personalizzare la funzione di esempio modificando parte del testo del messaggio visualizzato quando viene richiamata la funzione. È possibile aggiornare il testo del messaggio nel repository Git locale, eseguire il push dell'aggiornamento nel repository Git remoto, quindi distribuire e richiamare la funzione.
1. Nel pannello Editor di codice di Oracle Cloud Infrastructure, sotto la funzione oci-list-compartments-python appena creata, selezionare il file func.py e modificare la riga:
```
resp = {"compartments": compartments}
```
  da leggere:
```
resp = {"compartments in tenancy": compartments}
```
2. Nel Navigator dell'Editor di codice, selezionare il pannello Controllo origine, il pulsante Altre azioni e selezionare Esegui commit dal menu Esegui commit.
3. Quando viene richiesto di modificare l'area intermedia, selezionare Sì.
4. Immettere un messaggio di commit (ad esempio, Adds-in-tenancy) e premere Invio.
5. Selezionare il pulsante Altre azioni e selezionare Push dal menu Pull, Push.
6. Se richiesto, immettere il nome utente e la password Git per il repository Git remoto.
  Nel caso di GitHub, la password è il token di accesso personale GitHub.
7. Se viene visualizzata una finestra di dialogo con il messaggio "Si desidera che l'editor di codice esegua periodicamente 'git fetch'?", selezionare Chiedi più tardi.
8. Nella finestra del terminale dell'editor di codice, nella directory contenente il file func.yaml e i file di origine della funzione, distribuire la funzione in OCI Functions immettendo:
```
fn -v deploy --app <application-name>
```
  Ad esempio:
```
fn -v deploy --app samples-app
```
9. Nella finestra del terminale dell'editor di codice, richiamare la funzione immettendo:
```
fn invoke <application-name> <function-name>
```
  Ad esempio:
```
fn invoke samples-app oci-list-compartments-python
```
  Verrà visualizzato il seguente messaggio.
```
{"compartments in tenancy": [["<compartment-ocid>", "<compartment-name>"], ["<compartment-ocid>", "<compartment-name>"]… }
```
Il messaggio aggiornato conferma che il codice di origine della funzione è stato modificato correttamente nel repository Git locale, ha eseguito il PUSH dell'aggiornamento nel repository Git remoto, quindi ha distribuito e richiamato la funzione.

Documentazione di Oracle Cloud Infrastructure

Utilizzo di un esempio per creare una funzione con l'editor di codice

Creazione di una funzione da un esempio mediante l'editor di codice