Preparare l'ambiente di sviluppo locale

Prima di iniziare

Oltre ai task presentati in questa sezione per l'impostazione di un'istanza Linux locale per lo sviluppo delle funzioni, è necessario eseguire le operazioni riportate di seguito.

Per sviluppare le funzioni localmente, installare la piattaforma di sviluppo Fn Project da GitHub.
Assicurarsi di disporre di Docker versione 17.10.0 o successiva installato sull'istanza locale.

Per informazioni sull'installazione o l'aggiornamento di Docker su Linux, vedere Oracle Container Runtime for Docker User's Guide.

Crea una chiave di firma

Prima di utilizzare Oracle Functions, è necessario impostare una chiave di firma API Oracle Cloud Infrastructure.

Eseguire il login all'ambiente di sviluppo del computer locale come sviluppatore delle funzioni.
Generare una chiave privata cifrata con una passphrase fornita immettendo:
```
$ openssl genrsa -out ~/.oci/<private-key-file-name>.pem -aes128 2048
```
dove <private-key-file-name> è un nome a scelta per il file di chiave privata.
Quando richiesto, immettere una passphrase per cifrare il file della chiave privata. Assicurarsi di prendere nota della passphrase immessa, come sarà necessario in seguito.
Quando richiesto, immettere di nuovo la passphrase per confermarla.
Modificare le autorizzazioni sul file per assicurarsi di poterlo leggere solo.
```
$ chmod go-rwx ~/.oci/<private-key-file-name>.pem
```
dove <private-key-file-name> è un nome del file chiave privata.
Generare una chiave pubblica (cifrata con la stessa passphrase fornita durante la creazione della chiave privata e nella stessa posizione del file della chiave privata) immettendo:
```
$ openssl rsa -pubout -in ~/.oci/<private-key-file-name>.pem -out ~/.oci/<public-key-file-name>.pem
```
dove <private-key-file-name> è un nome del file di chiavi private e <public-key-file-name> è un nome a scelta per il file di chiavi pubbliche.
Quando richiesto, immettere la stessa passphrase immessa in precedenza per cifrare il file della chiave privata.
Copiare il contenuto del file della chiave pubblica appena creato immettendo:
```
$ cat ~/.oci/<public-key-file-name>.pem | pbcopy
```
dove <public-key-file-name> è un nome a scelta per il file di chiave pubblica.
Eseguire il login alla console come sviluppatore di funzioni, aprire il menu Utente nell'angolo superiore destro e selezionare Impostazioni utente.
Nella pagina Chiavi API fare clic su Aggiungi chiave pubblica. Incolla il valore della chiave pubblica nella finestra e fai clic su Aggiungi. La chiave viene caricata e viene visualizzata la relativa impronta digitale.

Crea profilo CLI (Command Line Interface)

Prima di utilizzare Oracle Functions, è necessario disporre di un file di configurazione CLI Oracle Cloud Infrastructure che contenga il profilo delle credenziali dell'account utente che verrà utilizzato per creare e distribuire le funzioni.

Il file di configurazione CLI di Oracle Cloud Infrastructure può contenere diversi profili. Se si dispone già di un file di configurazione contenente uno o più profili, è necessario aggiungere un nuovo profilo al file esistente per l'utente che utilizzerà Oracle Functions per creare e distribuire le funzioni.

Eseguire il login all'ambiente di sviluppo del computer locale come sviluppatore delle funzioni.
Aprire il file ~/.oci/config in un editor di testo. (Se la directory e/o il file non esistono, crearli).
Aggiungere un nuovo profilo al file ~.oci/config come riportato di seguito.
```
[<profile-name>]
user=<user-ocid>
fingerprint=<public-key-fingerprint>
key_file=<full-path-to-private-key-pem-file>
tenancy=<tenancy-ocid>
region=<region-name>
pass_phrase=<passphrase>
```
dove:
- <profile-name> è un nome scelto per il profilo.
- <user-ocid> è l'OCID dell'account utente Oracle Cloud Infrastructure che verrà utilizzato per creare e distribuire le funzioni.
- <public-key-fingerprint> è l'impronta digitale del valore della chiave API pubblica caricato in precedenza nella console.
- <full-path-to-private-key-pem-file> è il percorso completo del file della chiave privata creato in precedenza.
- <tenancy-ocid> è l'OCID della tenancy in cui verranno create e distribuite le funzioni.
- <region-identifier> è l'identificativo dell'area Oracle Cloud Infrastructure in cui verranno create e distribuite le funzioni. Ad esempio us-phoenix-1.
- <passphrase> è la passphrase specificata durante la creazione delle chiavi pubbliche/private.
Salvare e chiudere il file.

Copia e configura lo script oci-curl

È possibile utilizzare uno script per richiamare una funzione. Lo script oci-curl crea una richiesta firmata in base alle credenziali fornite nel corpo dello script.

Per utilizzare oci-curl per richiamare una funzione, è necessario fornire le credenziali di un utente Oracle Cloud Infrastructure a cui è stato concesso l'accesso alle risorse nella stessa tenancy e appartenente allo stesso compartimento della funzione.

In genere si desidera richiamare una funzione come sviluppatore delle funzioni configurato per l'ambiente di sviluppo. Le istruzioni riportate di seguito presuppongono che questo sia il caso.

Collegarsi all'ambiente di sviluppo.
Creare una copia del file di script oci-curl nell'ambiente di sviluppo e aggiungere le credenziali al file come riportato di seguito.
1. In un browser, andare a https://docs.cloud.oracle.com/iaas/Content/Resources/Assets/signing_sample_bash.txt per visualizzare il codice oci-curl come testo raw.
2. Selezionare tutto il testo e copiarlo.
3. In un editor di testo, aprire un nuovo file in una posizione conveniente.
  Ad esempio, in una finestra terminale, è possibile creare una nuova sottodirectory nella directory home e aprire un nuovo file in tale directory immettendo:
```
$ cd ~

$ mkdir oci-curl

$ vim ~/oci-curl/oci-curl.sh
```
  Il nome e la posizione del nuovo file spettano all'utente, ma le istruzioni riportate di seguito assumono ~/oci-curl/oci-curl.sh.
4. Incollare il codice script oci-curl copiato in precedenza nel nuovo file.
5. Salvare il file ma lasciarlo aperto in modo da poter aggiungere le credenziali.
Sostituire le credenziali di esempio nel file oci-curl.sh con quelle dell'account utente che si desidera richiamare le funzioni:
```
local tenancyId="<tenancy_id>";
local authUserId="<user_id>";
local keyFingerprint="<public_fingerprint>";
local privateKeyPath="<private_key_path>";
```
Posizione:
- <tenancy_id> è l'OCID della tenancy in cui la funzione è stata distribuita.
- <user_id> è l'OCID dell'account utente che si desidera eseguire la funzione. L'account utente deve disporre dell'accesso alle risorse nella stessa tenancy e appartenere allo stesso compartimento della funzione.
- <public_fingerprint> è l'impronta digitale della chiave pubblica dell'utente caricata in Oracle Cloud Infrastructure.
- <private_key_path> è il percorso completo del file di chiave privata associato alla chiave pubblica per la quale è stata fornita l'impronta digitale. Ad esempio:
```
local privateKeyPath="/Users/johndoe/.oci/john_api_key_private.pem";
```
Salvare il file oci-curl.sh e chiuderlo.

Installare l'interfaccia della riga di comando del progetto Fn (CLI)

Prima di utilizzare Oracle Functions, è necessario installare l'interfaccia CLI (Fn Project CommandLine Interface) nell'ambiente di sviluppo.

Questa procedura utilizza curl per installare la CLI su un'istanza di Linux. Le istruzioni per gli altri sistemi operativi sono fornite nel file readme per il progetto Fn in GitHub.

Eseguire il login all'ambiente di sviluppo come sviluppatore di funzioni.
Per recuperare ed eseguire lo script di installazione, utilizzare il comando seguente:
```
$ curl -LSs https://raw.githubusercontent.com/fnproject/cli/master/install | sh
```
Se richiesto per una password, immettere la password dell'utente privilegiato.
In una finestra del terminale confermare che il CLI è stato installato immettendo:
```
$ fn version
```
Se l'interfaccia CLI è stata installata correttamente, viene visualizzata la versione.

Crea contesto interfaccia riga di comando Fn

Quando l'interfaccia della riga di comando Fn Project (CLI) viene inizialmente installata, viene configurata per lo sviluppo locale. Per configurare Fn Project CLI per connettersi alla tenancy di Oracle Cloud Infrastructure, è necessario creare un nuovo contesto.

Il contesto specifica gli endpoint di Oracle Functions, l'OCID del compartimento a cui appartengono le funzioni distribuite e l'indirizzo del registro di Docker a e da cui eseguire il push e il pull delle immagini. È possibile definire più contesti, ognuno memorizzato in un altro file di contesto in formato .yaml.

Eseguire il login all'ambiente di sviluppo come sviluppatore di funzioni.
In una finestra terminale, creare il nuovo contesto CLI Fn Project per Oracle Cloud Infrastructure:
```
$ fn create context <my-context> --provider oracle
```
dove <my-context> è un nome scelto.
Specificare che la CLI progetto Fn deve utilizzare il nuovo contesto:
```
$ fn use context <my-context>
```
dove <my-context> è il nome di contesto specificato.
Specificare il nome del profilo di interfaccia della riga di comando da utilizzare:
```
$ fn update context oracle.profile <profile-name>
```
Specificare l'OCID compartimento in cui verranno distribuite le funzioni distribuite:
```
$ fn update context oracle.compartment-id <compartment-ocid>
```
Specificare l'endpoint da utilizzare durante il richiamo dell'API:
```
$ fn update context api-url <api-endpoint>
```
Dove <api-endpoint> è uno degli endpoint nel formato:
```
https://functions.<region-identifier>.oci.oraclecloud.com
```
Dove <region-identifier> è l'identificativo dell'area Oracle Cloud Infrastructure in cui verranno create e distribuite le funzioni. Ad esempio:
```
us-phoenix-1
```
Configurare il nuovo contesto con l'indirizzo del registro Docker che si desidera utilizzare con Oracle Functions:
```
$ fn update context registry <region-key>.ocir.io/<tenancy-namespace>/<repo-name>
```
Posizione:
- <region-key> è la chiave dell'area Oracle Cloud Infrastructure Registry. Ad esempio, phx per Phoenix.
  
  Oracle consiglia che il registro Docker specificato si trovi nella stessa area della sottorete in cui si intende eseguire le funzioni.
- <tenancy-namespace> è la stringa dello spazio di nomi Oracle Cloud Infrastructure Object Storage generata automaticamente della tenancy in cui creare repository (come illustrato nella pagina Informazioni tenancy).
- <repo-name> è un nome repository da anteporre ai nomi delle funzioni distribuite.
Ad esempio:
```
$ fn update context registry phx.ocir.io/ansh81vru1zp/my-repo
```

Crea un token di autenticazione

Per distribuire le funzioni in Oracle Cloud Infrastructure, è necessario creare un token di autenticazione da utilizzare come password durante la connessione di Docker a Oracle Cloud Infrastructure Registry.

Collegarsi alla console di Oracle Cloud Infrastructure, fare clic sull'icona Utente e selezionare Impostazioni utente.
Per creare un nuovo token di autenticazione, fare clic su Token di autenticazione nella sezione Risorse e quindi fare clic su Genera token.
Fornire una descrizione per il token di autenticazione e fare clic su Genera token. Copiare il token quando viene visualizzato.
Fare clic sul collegamento Copia e memorizzare le informazioni sul token in una posizione sicura perché alla chiusura della finestra di dialogo non sarà più possibile visualizzare il token nella console.
Fare clic su Chiudi.

Collega a Oracle Cloud Infrastructure Registry

Prima di poter utilizzare Oracle Functions, è necessario eseguire l'accesso a Docker nel registro Docker in cui verranno memorizzate le funzioni come immagini Docker. Registro Docker specificato in precedenza nel contesto CLI (interfaccia della riga di comando Progetto Fn).

Prima di eseguire l'accesso al registro, è necessario aver effettuato le operazioni riportate di seguito.

Installato e avviato Docker nell'ambiente di sviluppo
Creazione di un contesto Oracle Cloud Infrastructure per l'interfaccia della riga di comando Fn (CLI)
Creazione di un token di autenticazione Oracle Cloud Infrastructure per l'utente

È possibile memorizzare le funzioni nei repository pubblici e privati in Oracle Cloud Infrastructure Registry, un registro gestito da Oracle creato su Oracle Cloud Infrastructure.

Per completare i passi riportati di seguito, è necessario fornire lo spazio di nomi tenancy per Oracle Cloud Infrastructure Object Storage, il nome utente e il token di autenticazione dell'utente.

Per firmare Docker in Oracle Cloud Infrastructure Registry, effettuare le operazioni riportate di seguito.

Accedere all'ambiente di sviluppo come sviluppatore di funzioni.
In una finestra del terminale eseguire il login a Oracle Cloud Infrastructure Registry:
```
$ docker login <region-key>.ocir.io
```
Dove <region-key> è la chiave per l'area Oracle Cloud Infrastructure Registry specificata nel contesto CLI progetto Fn. Ad esempio phx per Phoenix.
Quando richiesto, immettere il nome utente dell'utente che creerà e distribuirà le funzioni:
```
<tenancy-namespace>/<username>
```
Posizione:
- <tenancy-namespace> è la stringa dello spazio di nomi Oracle Cloud Infrastructure Object Storage generata automaticamente della tenancy in cui creare repository (come illustrato nella pagina Informazioni tenancy).
- <username> è l'utente che creerà e distribuirà le funzioni.
Se la tenancy è federata con Oracle Identity Cloud Service, utilizzare il formato:
```
<tenancy-namespace>/oracleidentitycloudservice/<username>
```
Quando viene richiesto di immettere una password, immettere il token di autenticazione Oracle Cloud Infrastructure dell'utente.