Préparer l'environnement de développement local

Avant de commencer

Outre les tâches présentées dans cette section pour la configuration d'une instance Linux locale pour le développement des fonctions, vous devez effectuer les tâches suivantes :

Pour développer des fonctions localement, installez la plate-forme de développement de projet Fn à partir de GitHub.
Assurez-vous que Docker version 17.10.0 ou ultérieure est installé sur votre instance locale.

Pour plus d'informations sur l'installation ou la mise à niveau de Docker sur Linux, reportez-vous au Oracle Container Runtime for Docker User' s Guide.

Créer une clé de signature

Avant d'utiliser Oracle Functions, vous devez configurer une clé de signature d'API Oracle Cloud Infrastructure.

Connectez-vous à votre environnement local de développement de machines en tant que développeur de fonctions.
Générez une clé privée cryptée avec une phrase de passe que vous fournissez en entrant :
```
$ openssl genrsa -out ~/.oci/<private-key-file-name>.pem -aes128 2048
```
où <private-key-file-name> est le nom de votre choix pour le fichier de clés privées.
Lorsque vous y êtes invité, entrez une phrase de passe pour crypter le fichier de clés privées. Assurez-vous de prendre note de la phrase de passe que vous entrez, car vous en aurez besoin ultérieurement.
Lorsque vous y êtes invité, saisissez de nouveau la phrase de passe pour la confirmer.
Modifiez les autorisations du fichier pour vous assurer que vous pouvez uniquement le lire.
```
$ chmod go-rwx ~/.oci/<private-key-file-name>.pem
```
où <private-key-file-name> est le nom du fichier de clés privées.
Générez une clé publique (cryptée avec la même phrase de passe que celle que vous avez fournie lors de la création de la clé privée et dans le même emplacement que le fichier de clés privées) en saisissant :
```
$ openssl rsa -pubout -in ~/.oci/<private-key-file-name>.pem -out ~/.oci/<public-key-file-name>.pem
```
où <private-key-file-name> est le nom du fichier de clés privées et <public-key-file-name> le nom de votre choix pour le fichier de clés publiques.
Lorsque vous y êtes invité, saisissez la même phrase de passe que celle que vous avez précédemment saisie pour crypter le fichier de clés privées.
Copiez le contenu du fichier de clés publiques que vous venez de créer en entrant :
```
$ cat ~/.oci/<public-key-file-name>.pem | pbcopy
```
où <public-key-file-name> est le nom de votre choix pour le fichier de clés publiques.
Connectez-vous à la console en tant que développeur de fonctions, ouvrez le menu Utilisateur dans l'angle supérieur droit et sélectionnez Paramètres utilisateur.
Sur la page Clés API, cliquez sur Ajouter une clé publique. Collez la valeur de la clé publique dans la fenêtre et cliquez sur Ajouter. La clé est téléchargée et son empreinte digitale s'affiche.

Créer un profil d'interface de ligne de commande (CLI)

Avant d'utiliser Oracle Functions, vous devez disposer d'un fichier de configuration de la CLI Oracle Cloud Infrastructure contenant le profil d'informations d'identification du compte utilisateur que vous allez utiliser pour créer et déployer des fonctions.

Le fichier de configuration de la CLI Oracle Cloud Infrastructure peut contenir plusieurs profils. Si vous avez déjà un fichier de configuration contenant un ou plusieurs profils, vous devez ajouter un nouveau profil au fichier existant pour l'utilisateur qui utilisera Oracle Functions pour créer et déployer des fonctions

Connectez-vous à votre environnement local de développement de machines en tant que développeur de fonctions.
Ouvrez le fichier ~/.oci/config dans un éditeur de texte. (Si le répertoire et/ou le fichier n'existent pas déjà, créez-les).
Ajoutez un profil au fichier ~.oci/config comme suit :
```
[<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>
```
où :
- <profile-name> est le nom de votre choix pour le profil.
- <user-ocid> est l'OCID du compte utilisateur Oracle Cloud Infrastructure que vous allez utiliser pour créer et déployer des fonctions.
- <public-key-fingerprint> est l'empreinte de la valeur de clé d'API publique que vous avez téléchargée dans la console précédente.
- <full-path-to-private-key-pem-file> est le chemin complet du fichier de clés privées créé précédemment.
- <tenancy-ocid> est l'OCID de la location dans laquelle vous allez créer et déployer des fonctions.
- <region-identifier> est l'identificateur de la région Oracle Cloud Infrastructure dans laquelle vous allez créer et déployer des fonctions. Par exemple, us-phoenix-1.
- <passphrase> est la phrase de passe que vous avez indiquée lors de la création de clés publiques/privées.
Enregistrez et fermez le fichier.

Copier et configurer le script oci-curl

Vous pouvez utiliser un script pour appeler une fonction. Le script oci-curl crée une demande signée en fonction des informations d'identification que vous fournissez dans le corps du script.

Pour utiliser oci-curl pour appeler une fonction, vous devez fournir les informations d'identification d'un utilisateur Oracle Cloud Infrastructure disposant d'un accès aux ressources dans la même location et appartenant au même compartiment que la fonction.

En général, vous voulez appeler une fonction en tant que développeur de fonctions configuré pour votre environnement de développement. Les instructions ci-dessous supposent que c'est le cas.

Connectez-vous à votre environnement de développement.
Créez une copie du fichier de script oci-curl dans votre environnement de développement et ajoutez les informations d'identification au fichier comme suit :
1. Dans un navigateur, accédez à https://docs.cloud.oracle.com/iaas/Content/Resources/Assets/signing_sample_bash.txt pour voir le code oci-curl comme texte brut.
2. Sélectionnez tout le texte et copiez-le.
3. Dans un éditeur de texte, ouvrez un nouveau fichier à un emplacement pratique.
  Par exemple, dans une fenêtre de terminal, vous pouvez créer un sous-répertoire dans votre répertoire d'origine et ouvrir un nouveau fichier dans ce répertoire en entrant :
```
$ cd ~

$ mkdir oci-curl

$ vim ~/oci-curl/oci-curl.sh
```
  Le nom et l'emplacement du nouveau fichier vous appartiennent, mais les instructions suivantes supposent ~/oci-curl/oci-curl.sh.
4. Collez le code script oci-curl que vous avez copié précédemment dans le nouveau fichier.
5. Sauvegardez le fichier mais laissez-le ouvert afin que vous puissiez ajouter vos informations d'identification et de connexion.
Remplacez les exemples d'informations d'identification du fichier oci-curl.sh par ceux du compte utilisateur que vous souhaitez appeler les fonctions :
```
local tenancyId="<tenancy_id>";
local authUserId="<user_id>";
local keyFingerprint="<public_fingerprint>";
local privateKeyPath="<private_key_path>";
```
Où :
- <tenancy_id> représente l'OCID de la location dans laquelle la fonction a été déployée.
- <user_id> est l'OCID du compte utilisateur à exécuter. Le compte utilisateur doit avoir accès aux ressources dans la même location et appartenir au même compartiment que la fonction.
- <public_fingerprint> est l'empreinte digitale de la clé publique de l'utilisateur téléchargée dans Oracle Cloud Infrastructure.
- <private_key_path> est le chemin complet du fichier de clés privées associé à la clé publique pour laquelle vous avez fourni l'empreinte digitale. Par exemple :
```
local privateKeyPath="/Users/johndoe/.oci/john_api_key_private.pem";
```
Enregistrez et fermez le fichier oci-curl.sh.

Installer l'interface de ligne de commande (CLI) du projet Fn

Avant d'utiliser Oracle Functions, l'interface de ligne de commande Fn Project (CLI) doit être installée dans votre environnement de développement.

Cette procédure utilise curl pour installer la CLI sur une instance Linux. Les instructions relatives à d'autres systèmes d'exploitation sont fournies dans le fichier readme du projet Fn sur GitHub.

Connectez-vous à votre environnement de développement en tant que développeur de fonctions.
Utilisez la commande suivante pour extraire et exécuter le script d'installation :
```
$ curl -LSs https://raw.githubusercontent.com/fnproject/cli/master/install | sh
```
Si vous y êtes invité, entrez le mot de passe du superutilisateur.
Dans une fenêtre de terminal, confirmez que la CLI a été installée en entrant :
```
$ fn version
```
Si la CLI a été correctement installée, la version s'affiche.

Créer un contexte d'interface de ligne de commande Fn

Lorsque l'interface de ligne de commande (CLI) Fn Project est initialement installée, elle est configurée pour le développement local. Pour configurer la CLI du projet Fn pour qu'elle se connecte à votre location Oracle Cloud Infrastructure, vous devez créer un contexte.

Le contexte spécifie les adresses Oracle Functions, l'OCID du compartiment auquel appartiendront les fonctions déployées et l'adresse du registre Docker vers et à partir duquel pousser et tirer des images. Vous pouvez définir plusieurs contextes, chacun stocké dans un fichier contextuel différent au format .yaml.

Connectez-vous à votre environnement de développement en tant que développeur de fonctions.
Dans une fenêtre de terminal, créez le contexte CLI du projet Fn pour Oracle Cloud Infrastructure :
```
$ fn create context <my-context> --provider oracle
```
où <my-context> est un nom que vous choisissez.
Indiquez que la CLI du projet Fn doit utiliser le nouveau contexte :
```
$ fn use context <my-context>
```
où <my-context> est le nom de contexte que vous avez indiqué.
Indiquez le nom du profil d'interface de ligne de commande à utiliser :
```
$ fn update context oracle.profile <profile-name>
```
Indiquez l'OCID de compartiment dans lequel les fonctions déployées seront déployées :
```
$ fn update context oracle.compartment-id <compartment-ocid>
```
Indiquez l'adresse à utiliser lors de l'appel de l'API :
```
$ fn update context api-url <api-endpoint>
```
Lorsque <api-endpoint> est l'une des adresses au format :
```
https://functions.<region-identifier>.oci.oraclecloud.com
```
Où <region-identifier> est l'identificateur de la région Oracle Cloud Infrastructure dans laquelle vous allez créer et déployer des fonctions. Par exemple :
```
us-phoenix-1
```
Configurez le nouveau contexte avec l'adresse du registre Docker à utiliser avec Oracle Functions :
```
$ fn update context registry <region-key>.ocir.io/<tenancy-namespace>/<repo-name>
```
Où :
- <region-key> est la clé de la région Oracle Cloud Infrastructure Registry. Par exemple, phx pour Phoenix.
  
  Oracle recommande que le registre Docker que vous indiquez se trouve dans la même région que le sous-réseau sur lequel vous comptez exécuter des fonctions.
- <tenancy-namespace> est la chaîne d'espace de noms Oracle Cloud Infrastructure Object Storage générée automatiquement de la location dans laquelle créer des référentiels (comme indiqué sur la page Informations sur la location).
- <repo-name> est un nom de référentiel à pré-pendre aux noms des fonctions que vous déployez.
Par exemple :
```
$ fn update context registry phx.ocir.io/ansh81vru1zp/my-repo
```

Créer un jeton d'authentification

Pour déployer des fonctions dans Oracle Cloud Infrastructure, vous devez créer un jeton d'authentification à utiliser comme mot de passe lors de la connexion de Docker à Oracle Cloud Infrastructure Registry.

Connectez-vous à la console Oracle Cloud Infrastructure, cliquez sur l'icône Utilisateur et sélectionnez Paramètres utilisateur.
Pour créer un jeton d'authentification, cliquez sur Jetons d'authentification dans la section Ressources, puis sur Générer un jeton.
Fournissez une description pour le jeton Auth et cliquez sur Générer un jeton. Copiez le jeton lorsqu'il est affiché.
Cliquez sur le lien Copier et stockez les informations de jeton dans un emplacement sécurisé car lorsque vous fermez la boîte de dialogue, vous ne pourrez plus voir le jeton dans la console.
Cliquez sur Fermer.

Connexion à Oracle Cloud Infrastructure Registry

Pour pouvoir utiliser Oracle Functions, vous devez vous connecter à Docker dans le registre Docker dans lequel vous allez stocker vos fonctions en tant qu'images Docker. Registre Docker indiqué précédemment dans le contexte de l'interface de ligne de commande (CLI) Fn Project.

Pour pouvoir vous connecter au registre, vous devez d'abord effectuer les opérations suivantes :

Installé et démarré Docker dans l'environnement de développement
Création d'un contexte Oracle Cloud Infrastructure pour l'interface de ligne de commande (CLI) Fn
Jeton d'authentification Oracle Cloud Infrastructure créé pour l'utilisateur

Vous pouvez stocker des fonctions dans des référentiels publics et privés dans Oracle Cloud Infrastructure Registry, un registre géré par Oracle construit sur Oracle Cloud Infrastructure.

Pour terminer les étapes ci-dessous, vous devez fournir l'espace de noms de location pour Oracle Cloud Infrastructure Object Storage, le nom utilisateur et le jeton d'authentification de l'utilisateur.

Pour connecter Docker à Oracle Cloud Infrastructure Registry, procédez comme suit :

Connectez-vous à votre environnement de développement en tant que développeur de fonctions.
Dans une fenêtre de terminal, connectez-vous à Oracle Cloud Infrastructure Registry :
```
$ docker login <region-key>.ocir.io
```
Où <region-key> est la clé de la région Oracle Cloud Infrastructure Registry indiquée dans le contexte de la CLI Projet Fn. Par exemple, phx pour Phoenix.
Lorsque vous y êtes invité, entrez le nom utilisateur de l'utilisateur qui va créer et déployer des fonctions :
```
<tenancy-namespace>/<username>
```
Où :
- <tenancy-namespace> est la chaîne d'espace de noms Oracle Cloud Infrastructure Object Storage générée automatiquement de la location dans laquelle créer des référentiels (comme indiqué sur la page Informations sur la location).
- <username> est l'utilisateur qui va créer et déployer des fonctions.
Si votre location est fédérée avec Oracle Identity Cloud Service, utilisez le format suivant :
```
<tenancy-namespace>/oracleidentitycloudservice/<username>
```
Lorsque vous y êtes invité, saisissez le jeton d'authentification Oracle Cloud Infrastructure de l'utilisateur.