Lokale Entwicklungsumgebung vorbereiten

Bevor Sie beginnen

Neben den in diesem Abschnitt dargestellten Aufgaben zum Einrichten einer lokalen Linux-Instanz für die Funktionsentwicklung müssen Sie folgende Aufgaben ausführen:

Um Funktionen lokal zu entwickeln, installieren Sie die Fn Project-Entwicklungsplattform von GitHub.
Stellen Sie sicher, dass Docker-Version 17.10.0 oder höher auf Ihrer lokalen Instanz installiert ist.

Weitere Informationen über die Installation oder das Upgrade von Docker auf Linux finden Sie im Oracle Container Runtime for Docker User's Guide.

Signaturschlüssel erstellen

Bevor Sie Oracle Functions verwenden, müssen Sie einen Oracle Cloud Infrastructure API-Signaturschlüssel einrichten.

Melden Sie sich als Funktionsentwickler bei Ihrer lokalen Maschinenentwicklungsumgebung an.
Generieren Sie einen privaten Schlüssel verschlüsselt mit einer Passphrase, die Sie angeben, indem Sie Folgendes eingeben:
```
$ openssl genrsa -out ~/.oci/<private-key-file-name>.pem -aes128 2048
```
wobei <private-key-file-name> ein Name Ihrer Wahl für die Private Key-Datei ist.
Geben Sie bei Aufforderung eine Passphrase ein, um die Private Key-Datei zu verschlüsseln. Notieren Sie sich unbedingt die Passphrase, die Sie eingeben, da Sie sie später benötigen.
Geben Sie die Passphrase erneut ein, um sie zu bestätigen.
Ändern Sie die Berechtigungen für die Datei, um sicherzustellen, dass nur Sie sie lesen können.
```
$ chmod go-rwx ~/.oci/<private-key-file-name>.pem
```
wobei <private-key-file-name> ein Name der Private Key-Datei ist.
Generieren Sie einen Public Key (verschlüsselt mit derselben Passphrase, die Sie beim Erstellen des Private Key angegeben haben, und an demselben Speicherort wie die Private Key File), indem Sie Folgendes eingeben:
```
$ openssl rsa -pubout -in ~/.oci/<private-key-file-name>.pem -out ~/.oci/<public-key-file-name>.pem
```
wobei <private-key-file-name> ein Name der Private Key-Datei ist und <public-key-file-name> ein Name Ihrer Wahl für die Public Key-Datei ist.
Geben Sie bei Aufforderung dieselbe Passphrase ein, die Sie zuvor eingegeben haben, um die Private Key-Datei zu verschlüsseln.
Kopieren Sie den Inhalt der soeben erstellten Public Key-Datei, indem Sie Folgendes eingeben:
```
$ cat ~/.oci/<public-key-file-name>.pem | pbcopy
```
wobei <public-key-file-name> ein Name Ihrer Wahl für die Public Key-Datei ist.
Melden Sie sich als Funktionsentwickler bei der Konsole an, öffnen Sie das Menü Benutzer in der oberen rechten Ecke, und wählen Sie Benutzereinstellungen.
Klicken Sie auf der Seite API-Schlüssel auf Öffentlichen Schlüssel hinzufügen. Fügen Sie den Wert des Public Keys in das Fenster ein, und klicken Sie auf Hinzufügen. Der Schlüssel wird hochgeladen und der Fingerabdruck wird angezeigt.

Befehlszeilenschnittstellenprofil (CLI) erstellen

Bevor Sie Oracle Functions verwenden, müssen Sie über eine Oracle Cloud Infrastructure CLI-Konfigurationsdatei verfügen, die das Zugangsdatenprofil des Benutzeraccounts enthält, mit dem Sie Funktionen erstellen und bereitstellen.

Die Oracle Cloud Infrastructure CLI-Konfigurationsdatei kann mehrere Profile enthalten. Wenn Sie bereits eine Konfigurationsdatei mit einem oder mehreren Profilen haben, müssen Sie der vorhandenen Datei ein neues Profil hinzufügen, damit der Benutzer, der Oracle Functions verwendet, Funktionen erstellt und bereitstellt

Melden Sie sich als Funktionsentwickler bei Ihrer lokalen Maschinenentwicklungsumgebung an.
Öffnen Sie die Datei ~/.oci/config in einem Texteditor. (Wenn das Verzeichnis und/oder die Datei noch nicht vorhanden sind, erstellen Sie sie).
Fügen Sie der Datei ~.oci/config ein neues Profil wie folgt hinzu:
```
[<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>
```
dabei gilt Folgendes:
- <profile-name> ist ein Name Ihrer Wahl für das Profil.
- <user-ocid> ist die OCID des Oracle Cloud Infrastructure-Benutzeraccount, mit dem Sie Funktionen erstellen und bereitstellen.
- <public-key-fingerprint> ist der Fingerprint des öffentlichen API-Schlüsselwerts, den Sie früher in der Konsole hochgeladen haben.
- <full-path-to-private-key-pem-file> ist der vollständige Pfad zur Private Key-Datei, die Sie zuvor erstellt haben.
- <tenancy-ocid> ist die OCID des Mandanten, in dem Sie Funktionen erstellen und bereitstellen.
- <region-identifier> ist die ID des Oracle Cloud Infrastructure-Bereichs, in dem Sie Funktionen erstellen und bereitstellen. Beispiel: us-phoenix-1.
- <passphrase> ist die Passphrase, die Sie beim Erstellen öffentlicher/privater Schlüssel angegeben haben.
Speichern und schließen Sie die Datei.

OCI-Curl-Skript kopieren und konfigurieren

Mit einem Skript können Sie eine Funktion aufrufen. Das Skript oci-curl erstellt eine signierte Anforderung basierend auf Zugangsdaten, die Sie im Text des Skripts angeben.

Um eine Funktion mit oci-curl aufzurufen, müssen Sie die Zugangsdaten eines Oracle Cloud Infrastructure-Benutzers angeben, dem Zugriff auf Ressourcen im selben Mandanten erteilt wurde und zu demselben Compartment wie die Funktion gehört.

Normalerweise möchten Sie eine Funktion als Funktionsentwickler aufrufen, der für Ihre Entwicklungsumgebung konfiguriert ist. Die nachstehenden Anweisungen gehen davon aus, dass dies der Fall ist.

Melden Sie sich bei Ihrer Entwicklungsumgebung an.
Erstellen Sie eine Kopie der Skriptdatei oci-curl in Ihrer Entwicklungsumgebung, und fügen Sie Ihre Zugangsdaten der Datei wie folgt hinzu:
1. Navigieren Sie in einem Browser zu https://docs.cloud.oracle.com/iaas/Content/Resources/Assets/signing_sample_bash.txt, um den oci-curl-Code als Rohtext anzuzeigen.
2. Wählen Sie den gesamten Text aus, und kopieren Sie ihn.
3. Öffnen Sie in einem Texteditor eine neue Datei an einem bequemen Ort.
  Beispiel: In einem Terminalfenster können Sie ein neues Unterverzeichnis in Ihrem Home-Verzeichnis erstellen und eine neue Datei in diesem Verzeichnis öffnen, indem Sie Folgendes eingeben:
```
$ cd ~

$ mkdir oci-curl

$ vim ~/oci-curl/oci-curl.sh
```
  Der Name und Speicherort der neuen Datei liegt bei Ihnen, die folgenden Anweisungen gehen jedoch von ~/oci-curl/oci-curl.sh aus.
4. Fügen Sie den Skriptcode oci-curl ein, den Sie zuvor in die neue Datei kopiert haben.
5. Speichern Sie die Datei, lassen Sie sie jedoch offen, damit Sie Ihre Zugangsdaten hinzufügen können.
Ersetzen Sie die Beispielzugangsdaten in der Datei oci-curl.sh durch die Beispielzugangsdaten des Benutzeraccounts, die Sie Funktionen aufrufen möchten:
```
local tenancyId="<tenancy_id>";
local authUserId="<user_id>";
local keyFingerprint="<public_fingerprint>";
local privateKeyPath="<private_key_path>";
```
Dabei gilt Folgendes:
- <tenancy_id> ist die OCID des Mandanten, in dem die Funktion bereitgestellt wurde.
- <user_id> ist die OCID des Benutzeraccounts, den Sie ausführen möchten. Der Benutzeraccount muss Zugriff auf Ressourcen im selben Mandanten haben und zu demselben Compartment gehören wie die Funktion.
- <public_fingerprint> ist der Fingerabdruck des Public Keys des Benutzers, der in Oracle Cloud Infrastructure hochgeladen wurde.
- <private_key_path> ist der vollständige Pfad zur Private Key-Datei, die mit dem Public Key gepaart ist, für den Sie den Fingerprint angegeben haben. Zum Beispiel:
```
local privateKeyPath="/Users/johndoe/.oci/john_api_key_private.pem";
```
Speichern und schließen Sie die Datei oci-curl.sh.

Fn-Projekt-Befehlszeilenschnittstelle (CLI) installieren

Bevor Sie Oracle Functions verwenden, muss die Befehlszeilenschnittstelle Fn Project (CLI) in Ihrer Entwicklungsumgebung installiert sein.

In dieser Prozedur wird die CLI mit curl auf einer Linux-Instanz installiert. Anweisungen für andere Betriebssysteme finden Sie in der Readme-Datei für das Fn-Projekt in GitHub.

Melden Sie sich als Funktionsentwickler bei Ihrer Entwicklungsumgebung an.
Verwenden Sie den folgenden Befehl, um das Installationsskript abzurufen und auszuführen:
```
$ curl -LSs https://raw.githubusercontent.com/fnproject/cli/master/install | sh
```
Geben Sie bei Aufforderung zur Eingabe eines Kennworts das Superuser-Kennwort ein.
Bestätigen Sie in einem Terminalfenster, dass die CLI installiert wurde, indem Sie Folgendes eingeben:
```
$ fn version
```
Wurde die CLI korrekt installiert, wird die Version angezeigt.

Fn-Befehlszeilenschnittstellenkontext erstellen

Wenn die Befehlszeilenschnittstelle Fn Project (CLI) anfänglich installiert ist, ist sie für die lokale Entwicklung konfiguriert. Um Fn Project CLI für die Anmeldung bei Ihrem Oracle Cloud Infrastructure Mandanten zu konfigurieren, müssen Sie einen neuen Kontext erstellen.

Der Kontext gibt Oracle Functions-Endpunkte, die OCID des Compartments an, zu dem bereitgestellte Funktionen gehören, und die Adresse der Docker-Registry, zu der und von der Bilder gepusht und gezogen werden sollen. Sie können mehrere Kontexte definieren, die jeweils in einer anderen Kontextdatei im. yaml-Format gespeichert sind.

Melden Sie sich als Funktionsentwickler bei Ihrer Entwicklungsumgebung an.
Erstellen Sie in einem Terminalfenster den neuen Fn Project CLI-Kontext für Oracle Cloud Infrastructure:
```
$ fn create context <my-context> --provider oracle
```
wobei <my-context> ein Name ist, den Sie wählen.
Geben Sie an, dass die Fn-Projekt-CLI den neuen Kontext verwenden soll:
```
$ fn use context <my-context>
```
wobei <my-context> der Kontextname ist, den Sie angegeben haben.
Geben Sie den Namen des Befehlszeilenschnittstellenprofils an, das verwendet werden soll:
```
$ fn update context oracle.profile <profile-name>
```
Geben Sie die Compartment-OCID an, in der die bereitgestellten Funktionen bereitgestellt werden:
```
$ fn update context oracle.compartment-id <compartment-ocid>
```
Geben Sie den Endpunkt an, der beim Aufruf der API verwendet werden soll:
```
$ fn update context api-url <api-endpoint>
```
Dabei ist <api-endpoint> einer der Endpunkte im Format:
```
https://functions.<region-identifier>.oci.oraclecloud.com
```
Dabei ist <region-identifier> die ID des Oracle Cloud Infrastructure-Bereichs, in dem Sie Funktionen erstellen und bereitstellen. Zum Beispiel:
```
us-phoenix-1
```
Konfigurieren Sie den neuen Kontext mit der Adresse der Docker-Registry, die Sie mit Oracle Functions verwenden möchten:
```
$ fn update context registry <region-key>.ocir.io/<tenancy-namespace>/<repo-name>
```
Dabei gilt Folgendes:
- <region-key> ist der Schlüssel der Oracle Cloud Infrastructure Registry-Region. Beispiel: phx für Phoenix.
  
  Oracle empfiehlt, dass sich die angegebene Docker-Registry in demselben Bereich wie das Subnetz befindet, in dem Sie Funktionen ausführen möchten.
- <tenancy-namespace> ist die automatisch generierte Oracle Cloud Infrastructure Object Storage-Namespace-Zeichenfolge des Mandanten, in dem Repositorys erstellt werden sollen (wie auf der Seite "Mandanteninformationen" gezeigt).
- <repo-name> ist ein Repository-Name, der vor dem Pen für die Namen der Funktionen steht, die Sie bereitstellen.
Zum Beispiel:
```
$ fn update context registry phx.ocir.io/ansh81vru1zp/my-repo
```

Authentifizierungstoken erstellen

Um Funktionen in Oracle Cloud Infrastructure bereitzustellen, müssen Sie ein Authentifizierungstoken erstellen, das bei der Anmeldung von Docker bei Oracle Cloud Infrastructure Registry als Kennwort verwendet werden soll.

Melden Sie sich bei der Oracle Cloud Infrastructure-Konsole an, klicken Sie auf das Symbol Benutzer, und wählen Sie Benutzereinstellungen.
Um ein neues Authentifizierungstoken zu erstellen, klicken Sie im Abschnitt Ressourcen auf Authentifizierungstoken, und klicken Sie dann auf Token generieren.
Geben Sie eine Beschreibung für das Authentifizierungstoken an, und klicken Sie auf Token generieren. Kopieren Sie das Token, wenn es angezeigt wird.
Klicken Sie auf den Link "Kopieren", und speichern Sie die Tokeninformationen an einem sicheren Speicherort, da Sie das Token beim Schließen des Dialogfeldes nicht erneut in der Konsole sehen können.
Klicken Sie auf Schließen.

Bei Oracle Cloud Infrastructure Registry anmelden

Bevor Sie Oracle Functions verwenden können, müssen Sie Docker bei der Docker-Registry anmelden, in der Sie Ihre Funktionen als Docker-Images speichern möchten. Dies ist die Docker-Registry, die Sie zuvor im Fn Project-Befehlszeilenschnittstellen-(CLI-)Kontext angegeben haben.

Bevor Sie sich bei der Registry anmelden können, müssen Sie Folgendes ausgeführt haben:

Docker in der Entwicklungsumgebung installiert und gestartet
Oracle Cloud Infrastructure-Kontext für die Fn-Befehlszeilenschnittstelle (CLI) erstellt
Oracle Cloud Infrastructure-Authentifizierungstoken für den Benutzer erstellt

Sie können Funktionen in öffentlichen und privaten Repositorys in Oracle Cloud Infrastructure Registry speichern, einer Oracle-verwalteten Registry, die auf Oracle Cloud Infrastructure basiert.

Um die folgenden Schritte auszuführen, müssen Sie den Mandantennamespace für Oracle Cloud Infrastructure Object Storage, den Benutzernamen und das Authentifizierungstoken des Benutzers angeben.

So melden Sie Docker bei Oracle Cloud Infrastructure Registry an:

Melden Sie sich als Funktionsentwickler bei Ihrer Entwicklungsumgebung an.
Melden Sie sich in einem Terminalfenster bei Oracle Cloud Infrastructure Registry an:
```
$ docker login <region-key>.ocir.io
```
Dabei ist <region-key> der Schlüssel für den Oracle Cloud Infrastructure Registry-Bereich, der im Fn Project CLI-Kontext angegeben wird. Beispiel: phx für Phoenix.
Geben Sie bei Aufforderung den Benutzernamen des Benutzers ein, der Funktionen erstellt und bereitstellt:
```
<tenancy-namespace>/<username>
```
Dabei gilt Folgendes:
- <tenancy-namespace> ist die automatisch generierte Oracle Cloud Infrastructure Object Storage-Namespace-Zeichenfolge des Mandanten, in dem Repositorys erstellt werden sollen (wie auf der Seite "Mandanteninformationen" gezeigt).
- <username> ist der Benutzer, der Funktionen erstellt und bereitstellt.
Wenn Ihr Mandant mit Oracle Identity Cloud Service föderiert ist, verwenden Sie das folgende Format:
```
<tenancy-namespace>/oracleidentitycloudservice/<username>
```
Geben Sie bei Aufforderung zur Eingabe eines Kennworts das Oracle Cloud Infrastructure-Authentifizierungstoken des Benutzers ein.