Erstellen von Funktions-Workloads mit Repository-Quellcode

Sie können Ihre Funktion direkt aus dem Quellcode, der sich in einem Git Repository befindet, über die IBM Cloud® Code Engine Konsole oder mit der CLI erstellen.

Ein Code-Bundle ist eine Sammlung von Dateien, die Ihren Funktionscode darstellen. Dieses Code-Bündel wird in den Laufzeit-Container injiziert. Ihr Code-Bundle wird von Code Engine erstellt und in der Container-Registrierung oder inline mit der Funktion gespeichert. Ein Code-Bundle ist kein Standard-Container-Image der Open Container Initiative (OCI).

In diesem Szenario erstellt Code Engine ein Code-Bündel aus der Quelle Ihres Git Repositorys, lädt das Code-Bündel automatisch in Ihre Container-Registry hoch und erstellt dann Ihre Funktion, um auf dieses erstellte Code-Bündel zu verweisen. Sie müssen nur einen Namen für die Funktion, die URL zum Git Repository und die Laufzeit für die Funktion angeben. In diesem Fall verwaltet Code Engine den Namensbereich für Sie. Wenn Sie jedoch eine andere Container-Registrierung verwenden möchten, müssen Sie das Code-Bündel und ein Registrierungsgeheimnis für diese Container-Registrierung angeben.

Informationen zu den erforderlichen Zugriffsberechtigungen bezüglich Image-Registrys finden Sie unter Berechtigungen für Image-Registrys einrichten.

Erstellen von Funktions-Workloads mit Repository-Quellcode über die Konsole

Erstellen Sie eine Funktion mit Quellcode in der Konsole.

Öffnen Sie die Code Engine konsole.
Wählen Sie Los geht's.
Funktion auswählen.
Geben Sie einen Namen für die Funktion ein, z. B. myfunction. Verwenden Sie einen Namen für Ihre Funktion, der innerhalb des Projekts eindeutig ist.
Wählen Sie ein Projekt aus der Liste der verfügbaren Projekte aus. Sie können auch ein neues erstellen. Sie müssen ein Projekt auswählen, um eine Funktion zu erstellen.
Wählen Sie ein Laufzeitbild für Ihren Funktionscode. Weitere Informationen finden Sie unter Laufzeiten.
Wählen Sie die Option Codebündel aus Quellcode erstellen. Wenn Sie diese Option wählen, wird Ihre Funktion aus dem Quellcode erstellt und in der Containerregistrierung gespeichert.
Wählen Sie ein Quell-Repository, zum Beispiel https://github.com/IBM/CodeEngine. Wenn Sie sich für die Verwendung des Beispiels entscheiden, benötigen Sie keine Anmeldedaten, so dass Sie None für den Zugriff auf das Code Repo wählen können. Sie können optional einen Verzweigungsnamen angeben. Wenn Sie keinen Verzweigungsnamen angeben und das Feld leer lassen, verwendet Code Engine automatisch die Standardverzweigung des angegebenen Repositorys. Klicken Sie Weiter.
Wählen Sie eine Strategie für Ihren Build sowie Ressourcen für Ihren Build aus. Weitere Informationen zu Buildoptionen finden Sie im Abschnitt Build planen. Klicken Sie auf Weiter.
Wählen Sie eine Position für die Container-Registry aus, z. B. IBM Registry Dallas, um anzugeben, wo das Image Ihrer Buildausgabe gespeichert werden soll. Wenn Ihre Registry privat ist, müssen Sie den Zugriff auf diese Registry einrichten.
Geben Sie Registryinformationen dazu an, wo das Image Ihrer Buildausgabe gespeichert werden soll. Wählen Sie ein bestehendes Registrierungsgeheimnis oder erstellen Sie ein neues. Wenn Sie Ihr Image in einer Container Registry-Instanz erstellen, die sich in Ihrem Konto befindet, können Sie Code Engine managed secret auswählen und Code Engine den geheimen Schlüssel für Sie erstellen und verwalten lassen.
Wählen Sie einen Namensbereich, einen Namen und einen Tag für Ihr Image aus. Wenn Sie Ihr Image in einer IBM Cloud Container Registry-Instanz erstellen, die sich in Ihrem Konto befindet, können Sie einen vorhandenen Namensbereich auswählen oder Code Engine den Namensbereich für Sie erstellen und verwalten lassen. Wenn Sie zusätzliche Hilfe benötigen, klicken Sie auf Hilfe bei der Angabe des Codepakets. Weitere Informationen finden Sie unter Auf Container-Registrys zugreifen.
Geben Sie Ihre Ressourceninformationen an, einschließlich der CPU- und Speicherkombinationen und der Verkleinerungsverzögerung.
Optional können Sie eine benutzerdefinierte Domäne oder Umgebungsvariablen angeben. Sie können diese Optionen später hinzufügen.
Klicken Sie auf Erstellen.
Wenn der Funktionsstatus auf Bereit wechselt, können Sie die Funktion testen. Klicken Sie auf Testfunktion und dann auf Anfrage senden. Um die Funktion in einer Webseite zu öffnen, klicken Sie auf Funktion URL.
Sie können Ihren Funktionscode auch im Editor-Fenster ändern. Wenn Sie Ihre Funktion erneut bereitstellen, wird der Code inline gespeichert.

Sie können Ihre Funktion aufrufen, indem Sie auf Funktion testen und dann auf Anfrage senden klicken.

Erstellen von Funktions-Workloads mit Repository-Quellcode mit der CLI

Verwenden Sie den function create um ein Code-Bündel aus den Quellen Ihres Git Repositorys zu erstellen und Ihre Funktion zu erstellen, die auf dieses erstellte Code-Bündel verweist. Eine vollständige Liste der Optionen finden Sie unter dem ibmcloud ce function create befehl.

Vorbereitende Schritte

Konfigurieren Sie die Umgebung der Code Engine-Befehlszeilenschnittstelle.
Erstellen Sie ein Projekt und arbeiten Sie damit.

Das folgende Beispiel function create befehl erstellt die Funktion myfun, die auf Code verweist, der sich in https://github.com/IBM/CodeEngine befindet. Mit diesem Befehl wird das Code-Bündel automatisch erstellt und in einen IBM Cloud® Container Registry-Namespace in Ihrem Konto hochgeladen. Die Funktion verweist auf dieses gebaute Codebündel. Wenn Sie die Option --build-context-dir angeben, verwendet der Build die Quelle im Verzeichnis helloworld-samples/function-codebundle-nodejs.

ibmcloud ce function create --name myfun --runtime nodejs --build-source https://github.com/IBM/CodeEngine --build-context-dir /helloworld-samples/function-codebundle-nodejs

Beispielausgabe

Preparing function 'myfun' for build push...
Creating function 'myfun'...
Submitting build run 'myfun-run-230111-111212718'...
Creating image 'icr.io/ce--abcde-glxo4kabcde/function-myfun:230111-1532-vwo4o'...
Waiting for build run to complete...
Build run status: 'Running'
Build run completed successfully.
Run 'ibmcloud ce buildrun get -n myfun-run-230111-111212718' to check the build run status.
Waiting for function 'myfun' to become ready...
Function 'myfun' is ready.
OK                                                
Run 'ibmcloud ce function get -n myfun' to see more details.

https://myfun.11a66hbi3rhz.us-south.codeengine.appdomain.cloud

Beachten Sie, dass die Ausgabe des function create befehls gibt Auskunft über den Verlauf des Build-Laufs, bevor die Funktion erstellt wird.

In diesem Beispiel wird das erstellte Code-Bündel in den Namespace ce--abcde-4svg40kna19 in Container Registry hochgeladen.

Die folgende Tabelle fasst die Optionen zusammen, die mit dem function create befehl in diesem Beispiel verwendet werden. Weitere Informationen über den Befehl und seine Optionen finden Sie unter dem ibmcloud ce function create befehl.

Befehlsbeschreibung
Option	Beschreibung
`--name`	Der Name der Funktion. Verwenden Sie einen Namen, der innerhalb des Projekts eindeutig ist. Dieser Wert ist erforderlich. Der Name muss mit einem Kleinbuchstaben beginnen. Der Name muss mit einem alphanumerischen Zeichen enden. Der Name darf maximal 63 Zeichen lang sein und muss Buchstaben, Ziffern und Bindestriche (-) enthalten.
`--build-source`	Die URL des Git-Repositorys, in dem der Quellcode enthalten ist; Beispiel: `https://github.com/IBM/CodeEngine`.
`--build-context-dir`	Das Verzeichnis im Repository, das den Code enthält. Dieser Wert ist optional.
`--runtime`	Die Laufzeit für die Funktion.

Die folgende Ausgabe zeigt das Ergebnis des Befehls function get für dieses Beispiel, einschließlich Informationen zum Build.

Beispielausgabe

Getting function 'myfun'
'...
OK

Name:          myfun  
Project Name:  sample  
Project ID:    abcdefgh-abcd-abcd-abcd-1a2b3c4d5e6f
Age:           27m  
Created:       2023-06-27T21:07:26Z  
Visibility:    public  
URL:           https://myfun.13c66hbi3rhz.us-south.codeengine.appdomain.cloud  
Internal URL:  http://myfun.13c66hbi3rhz.function.cluster.local  

Resources:    
  CPU:               0.25  
  Memory:            500M  
  Timeout:           60 seconds  
  Scale Down Delay:  1 seconds  
  Trusted profiles:  disabled  

Environment Variables:    
  Type     Name             Value  
  Literal  CE_API_BASE_URL  https://api.us-south.codeengine.cloud.ibm.com  
  Literal  CE_DOMAIN        us-south.codeengine.appdomain.cloud  
  Literal  CE_FUNCTION      myfun  
  Literal  CE_REGION        us-south  
  Literal  CE_SUBDOMAIN     13c66hbi3rhz  
  Literal  CE_PROJECT_ID    abcdefgh-abcd-abcd-abcd-1a2b3c4d5e6f

Build Information:    
  Build Run Name:     myfun-run-230111-111212718  
  Build Type:         git  
  Build Strategy:     codebundle-nodejs-22
  Timeout:            600  
  Source:             https://github.com/IBM/CodeEngine  
  Context Directory:  /helloworld-samples/function-codebundle-nodejs    

  Build Run Status:   Succeeded  
  Build Run Reason:   All Steps have completed executing  
  Run 'ibmcloud ce buildrun get -n myfun-run-230111-111212718' for details.  

Function Code:    
  Runtime:        nodejs-22
  Bundle Secret:  ce-auto-icr-us-south  
  Code Bundle:    cr://icr.io/ce--abcde-glxo4kabcde/function-myfun:230111-1532-vwo4o
  Main:           main

Status:  Ready  
URL:     https://myfun.13c66hbi3rhz.us-south.codeengine.appdomain.cloud

Da Ihre Funktion nun aus dem Quellcode des Repositorys erstellt wurde, können Sie die Funktion mit dem Befehl ibmcloud ce function update befehl. Wenn Sie Ihren Quelltext aktualisieren wollen, um ihn mit Ihrer Funktion zu verwenden, müssen Sie die Option --build-source für den function update befehl angeben.

Wenn Ihre Funktion aus Repository-Quellcode oder aus lokalem Quellcode mit der CLI erstellt wird, basiert der resultierende Build-Lauf nicht auf einer Build-Konfiguration. Abgeschlossene Build-Läufe werden schließlich automatisch gelöscht. Build-Läufe, die nicht auf einer Build-Konfiguration beruhen, werden nach 1 Stunde gelöscht, wenn der Build-Lauf erfolgreich war. Wenn der Build-Lauf nicht erfolgreich ist, wird dieser Build-Lauf nach 24 Stunden gelöscht. Sie können Informationen zu diesem Build-Lauf nur über die CLI anzeigen. Sie können diesen Build-Lauf nicht in der Konsole anzeigen.

Einbindung von Abhängigkeiten für Ihre Funktion

Sie können Funktionen in vielen verschiedenen Programmiersprachen erstellen. Wenn Ihr Funktionscode komplexer wird, können Sie Codebausteine als Abhängigkeiten für Ihre Funktion hinzufügen. Jede Sprache hat ihre eigenen Module, die Sie mit Ihrem Funktionscode verwenden können. Zum Beispiel sind die Abhängigkeiten von Node.js in der Regel bestehende npm Module, während Python Python Pakete verwendet. Diese Abhängigkeiten müssen deklariert und in einer Datei mit Ihrem Quellcode erstellt werden

Einbindung von Modulen für eine Node.js Funktion

Erstellen Sie eine Funktion, die eine Abhängigkeit für ein bestimmtes Node.js Modul enthält, indem Sie eine package.json Datei erstellen. In diesem Fall befinden sich sowohl der Quellcode als auch die Paketdatei in demselben Ordner.

Erstellen Sie Ihren Quellcode, indem Sie Ihren Code in eine main.js Datei schreiben. Kopieren Sie zum Beispiel das folgende Codebeispiel in eine Datei mit dem Namen main.js.

/**
* The `main` function is the entry-point into the function.
* It has one optional argument, which carries all the
* parameters the function was invoked with.
*/
function main(params /* optional */) {
  // use third-party 'lorem-ipsum' package to generate random words
  const LoremIpsum = require("lorem-ipsum").LoremIpsum;
  const lorem = new LoremIpsum();

  // Since functions are invoked through http(s), we return an HTTP response.
  return {
    headers: { "Content-Type": "text/plain;charset=utf-8" },
    body: lorem.generateWords(10),
  };
}

// This step is necessary, if you gave your main function a different name.
// We include it here for documentation purposes only.
module.exports.main = main;

Erstellen Sie eine Datei package.json, die die erforderlichen Abhängigkeiten für Ihre Funktion enthält. Verwenden Sie für das vorherige Code-Beispiel den folgenden Inhalt für Ihre package.json-Datei.
```
{
  "name": "function",
  "version": "1.0.0",
  "main": "main.js",
  "dependencies" : {
		    "lorem-ipsum" : "2.0.8"
 	}
}
```
Erstellen Sie Ihre Dateien als Funktion in Code Engine. Die beiden vorherigen Dateien müssen im Repository zugänglich sein. Wenn sie sich in einem privaten Repository befinden, erstellen Sie den Zugriff auf das private Code-Repository und geben Sie diesen Wert dann mit der Option --build-git-repo-secret an. Wenn sich Ihre Dateien in einem anderen Verzeichnis als main befinden, geben Sie den Pfad zu diesem Verzeichnis mit der Option --build-context-dir an. Im folgenden Beispiel werden die Dateien aus dem öffentlichen Repository https://github.com/IBM/CodeEngine abgerufen.
```
ibmcloud ce fn create -n nodelorem -runtime nodejs --build-source https://github.com/IBM/CodeEngine --build-context-dir /helloworld-samples/function-codebundle-nodejs/
```
Führen Sie den mitgelieferten Befehl fn get aus, um Einzelheiten über Ihre Funktion zu erfahren.
Rufen Sie Ihre Funktion auf, indem Sie die Adresse URL in einen Webbrowser einfügen. Ihr Browser zeigt eine Passage von lorem ipsum an.

Weitere Informationen über den Befehl fn create und seine Optionen finden Sie unter Erstellen einer Funktion.

Einbindung von Modulen für eine Python Funktion

Erstellen Sie eine Funktion, die eine Abhängigkeit für ein bestimmtes Python Modul enthält, indem Sie eine requirements.txt Datei erstellen. In diesem Fall befinden sich sowohl der Quellcode als auch die Anforderungsdatei im selben Ordner.

Erstellen Sie Ihre Funktion, indem Sie Ihren Code in einer __main__.py Datei speichern

# use third-party 'lorem-ipsum' package to generate random words
from lorem_text import lorem

# The `main` function is the entry-point into the function.
# It has one optional argument, which carries all the
# parameters the function was invoked with.
def main(params):
    words = 10

    # since functions are invoked through http(s), we return an HTTP response
    return {
      "headers": {
        "Content-Type": "text/plain;charset=utf-8",
    },
    "body": lorem.words(words),
}
def main(params):
     words = 10

     return {
          "headers": {
              "Content-Type": "text/plain;charset=utf-8",
          },
          "body": lorem.words(words),
      }

Erstellen Sie eine requirements.txt mit den erforderlichen Abhängigkeiten für Ihre Funktion
```
lorem-text
```
Erstellen Sie Ihre Dateien als Funktion in Code Engine. Die beiden vorherigen Dateien müssen im Repository zugänglich sein. Wenn sie sich in einem privaten Repository befinden, erstellen Sie den Zugriff auf das private Code-Repository und geben Sie diesen Wert dann mit der Option --build-git-repo-secret an. Wenn sich Ihre Dateien in einem anderen Verzeichnis als main befinden, geben Sie den Pfad zu diesem Verzeichnis mit der Option --build-context-dir an. Im folgenden Beispiel werden die Dateien aus dem öffentlichen Repository https://github.com/IBM/CodeEngine abgerufen.
```
ibmcloud ce fn create -n pylorem -runtime python --build-source https://github.com/IBM/CodeEngine --build-context-dir /helloworld-samples/function-codebundle-python/
```
Führen Sie den mitgelieferten Befehl fn get aus, um Einzelheiten über Ihre Funktion zu erfahren.
Rufen Sie Ihre Funktion auf, indem Sie die Adresse URL in einen Webbrowser einfügen. Ihr Browser zeigt eine Passage von lorem ipsum an.

Weitere Informationen über den Befehl fn create und seine Optionen finden Sie unter Erstellen einer Funktion.

Nächste Schritte

Nachdem Ihre Funktion erstellt wurde, können Sie auf Ihre Funktion zugreifen, indem Sie in der Konsole auf Funktion testen klicken oder die URL für Ihre Funktion mit dem function get befehl.
Sie können eine benutzerdefinierte Domänenzuordnung erstellen und sie Ihrer Funktion zuweisen.
Nachdem Ihre Funktion erstellt und bereitgestellt wurde, können Sie die Funktion über die Konsole oder mit dem Befehl ibmcloud ce function update befehl. Wenn Sie Ihren Quelltext aktualisieren wollen, um ihn mit Ihrer Funktion zu verwenden, müssen Sie die Option --build-source für den function update befehl angeben.

Nachdem Ihre Funktion erstellt wurde, können Sie Ihre Funktion und den referenzierten Code auf eine der folgenden Arten aktualisieren, unabhängig davon, wie Sie Ihre Funktion erstellt oder zuvor aktualisiert haben:

Wenn Sie über ein vorhandenes Code-Bundle verfügen, müssen Sie nur einen Verweis auf das Image angeben, der auf den Speicherort Ihrer Container-Registrierung verweist, wenn Sie Ihre Anwendung bereitstellen. Weitere Informationen finden Sie unter Erstellen von Funktions-Workloads aus vorhandenen Codebündeln.

Wenn Sie Ihre Funktion mit dem Befehl function create erstellt haben und die Option --build-source angegeben haben, um das Code-Bundle aus einer lokalen oder einer Repository-Quelle zu erstellen, und Sie Ihre Funktion so ändern möchten, dass sie auf ein anderes Code-Bundle verweist, müssen Sie zunächst die Zuordnung des Builds zu Ihrer Funktion aufheben. Führen Sie zum Beispiel ibmcloud ce function update -n FUN_NAME --build-clear aus. Nachdem Sie die Assoziation des Builds aus Ihrer Funktion entfernt haben, können Sie die Funktion aktualisieren, um auf ein anderes Bild zu verweisen.
Wenn Sie mit Quellcode beginnen, der sich in einem Git Repository befindet, können Sie Code Engine beauftragen, das Code-Bündel aus Ihren Quellen zu erstellen und Ihre Funktion mit einem einzigen Vorgang zu erzeugen. In diesem Szenario lädt Code Engine Ihr Code-Bündel auf IBM Cloud® Container Registry hoch. Weitere Informationen finden Sie unter Erstellen Ihrer Funktion aus dem Repository-Quellcode.
Wenn Sie mit Quellcode beginnen, der sich auf einer lokalen Workstation befindet, können Sie Code Engine wählen, um das Code-Bündel aus Ihren Quellen zu erstellen und Ihre Funktion mit einem einzigen CLI-Befehl zu erstellen. In diesem Szenario lädt Code Engine Ihren Quellcode und Ihr Codebündel auf IBM Cloud® Container Registry hoch.

Sie könnten sich beispielsweise dafür entscheiden, dass Code Engine Ihren lokalen Quellcode erstellt, während Sie die Entwicklung Ihres Quellcodes für die Funktion vorantreiben. Wenn das Code-Bündel dann ausgereift ist, können Sie Ihre Funktion aktualisieren, um auf das gewünschte Code-Bündel zu verweisen. Sie können diesen Prozess nach Bedarf wiederholen.

Benötigen Sie weitere Codebeispiele? Sehen Sie sich das Samples for IBM Cloud Code Engine GitHub repo an.