Front-End-Anwendung bereitstellen

1. Führen Sie den folgenden Befehl aus, um eine neue Code Engine-Anwendung bereitzustellen: Geben Sie einen Servicenamen frontend und das vordefinierte Container-Image als Parameter für das Flag --image an.

   ibmcloud code-engine application create --name frontend --image icr.io/solution-tutorials/tutorial-text-analysis-code-engine-frontend
   

   Nach der Ausführung dieses Befehls sollte eine Ausgabe mit einer URL zu Ihrer Anwendung angezeigt werden. Sie sollte ähnlich wie das folgende Beispiel aussehen: https://frontend.305atabsd0w.us-south.codeengine.appdomain.cloud. Kopieren oder notieren Sie sich diese URL für den nächsten Schritt. Mit nur diesen beiden Daten (Name der Anwendung und Name des Bildes) hat Code Engine Ihre Anwendung bereitgestellt und übernimmt die komplexe Konfiguration und Verwaltung für Sie.

   Der Quellcode der Anwendung, der zur Erstellung der Container-Images verwendet wurde, ist in GitHub zu Ihrer Information verfügbar. Falls Sie die Container-Images aus Quellcode erstellen und mit einer Push-Operation in eine private Container-Registry übertragen wollen, befolgen Sie die Anweisungen in diesem Abschnitt.

2. Öffnen Sie URL aus dem vorherigen Schritt in einem Browser, um eine Ausgabe ähnlich der folgenden zu sehen:

   

   Führen Sie den Befehl ibmcloud code-engine application get -n frontend aus, um die Details der Anwendung anzuzeigen. Es müssten Details wie die ID, Projektinformationen, das Alter der Anwendung, die Zugriffs-URL für die Anwendung, eine Konsolen-URL für den Zugriff auf Ihre Anwendungskonfiguration, das Image, die Ressourcenzuordnung sowie verschiedene Revisionen, Bedingungen und die Laufzeit für Ihre Anwendung angezeigt werden. Da Sie nur eine Revision haben, müsste angezeigt werden, dass 100 % des Datenverkehrs durch die neueste Revision fließen. Sie können außerdem die Anzahl der Instanzen und ihren Status prüfen.

3. Führen Sie zur Fehlerbehebung und zur Überprüfung der Protokolle Ihrer Anwendung den folgenden Befehl aus, indem Sie <INSTANCE_NAME> durch den Namen einer der Instanzen aus dem Befehl ibmcloud code-engine application get -n frontend ersetzen.

   Wenn Sie keine laufenden Instanzen sehen, öffnen Sie URL aus Schritt 2 erneut.

   ibmcloud code-engine application logs --instance <INSTANCE_NAME>
   

   Falls die Anwendung ausgeführt wird, sollte angezeigt werden, dass die Back-End-URL nicht definiert ist (backend URL: undefined) und dass die App an Port 8080 empfangsbereit ist. Später im Lernprogramm verbinden Sie diese Front-End-Anwendung mit unserer Back-End-Anwendung.

Herzlichen Glückwunsch! Sie haben soeben eine Webanwendung in Code Engine mit einem einfachen Befehl bereitgestellt, ohne dabei auf Wissen über komplexe Aspekte von Kubernetes wie Pods, Bereitstellungen (Deployments), Services und Ingress zurückgreifen zu müssen.

Anwendung skalieren

Als Sie die Anwendung mit dem Befehl application create erstellten, haben Sie nur ein zu verwendendes Image und einen Namen für Ihre Anwendung übergeben. Dies ist zwar die Mindestmenge an Informationen, die für die Bereitstellung einer Anwendung erforderlich ist, aber es gibt noch eine Reihe anderer Einstellungen, die Sie steuern können. So können Sie u. a. die Anzahl der Anforderungen, die gleichzeitig pro Instanz verarbeitet werden können, die CPU-Kapazität für die Instanz der Anwendung, die Größe des festgelegten Hauptspeichers für die Instanz der Anwendung, die Umgebungsvariablen für die Anwendung, die maximale und minimale Anzahl von Instanzen, die für diese Anwendung verwendet werden können, sowie den Port, über den die Anwendung für Anforderungen empfangsbereit ist, festlegen.

Für die meisten dieser Werte ist ein Standardwert für den Fall festgelegt, dass bei der Erstellung der Anwendung kein entsprechender Wert als Option angegeben wird. Da Sie hier keinen Wert angegeben haben, hat Code Engine Ihre Anwendung mit der maximalen Standardskalierung von 10 bereitgestellt. Dies bedeutet, dass Ihre Anwendung maximal auf 10 Instanzen skaliert wird. Die minimale Standardskalierung ist null, sodass Ihre Anwendung sich selbst auf null herunterskaliert (Scale-down), wenn sie nicht mehr verwendet wird.

1. Um die Autoscaling-Fähigkeiten von Code Engine zu überprüfen, können wir einen Lastgenerator verwenden, um Anfragen an unseren Dienst zu senden. Das folgende Shell-Script simuliert eine Basislast von 3000 Anforderungen.

   1. Öffnen Sie ein lokales Terminalfenster (Shell).

   2. Erstellen Sie eine Shell-Variable für URL aus dem obigen Schritt.

      export APPURL=<frontend-application-url>
      

   3. Führen Sie das folgende Script aus, um Ladevorgänge zu generieren. Sie können es wiederholen, um mehr Datenverkehr zu erstellen.

      seq 1 3000 | xargs -n1 -P300  curl -s  $APPURL -o /dev/null
      

2. Führen Sie in Ihrer Cloud Shell-Sitzung aus den vorherigen Abschnitten den folgenden Befehl aus, um anzuzeigen, wie die Anzahl der Instanzen (Pods) im Rahmen der automatischen Skalierung erhöht wird.

   ibmcloud code-engine application get -n frontend
   

   Die maximale Anzahl von Anforderungen, die gleichzeitig pro Instanz verarbeitet werden können, beträgt standardmäßig 10, die eine automatische Skalierung zur Folge hat. Dieser Wert kann mit dem Flag --concurrency or -cn im Befehl application update geändert werden.

3. Wenn Sie die Erstellung von weniger als 10 Instanzen wünschen, können Sie für die Anzahl für die maximale Skalierung (--max-scale) einen niedrigeren Wert festlegen. Während Ihre serverunabhängige Anwendung sich problemlos nach oben skalieren lässt (Scale-up), sind Sie möglicherweise von einem nachgeordneten Service wie SQL DB, der nur eine begrenzte Anzahl von Verbindungen verarbeiten kann, oder von einer anderen API mit begrenzter Rate abhängig. Versuchen Sie also jetzt einmal, die Anzahl der Instanzen für diese Front-End-Anwendung zu begrenzen.

   ibmcloud code-engine application update --name frontend --max-scale 5
   

4. Warten Sie nach dem Stoppen der Lastgenerierung einige Minuten ab, um zu verfolgen, wie die Instanzen beendet werden und die Skalierung schließlich auf null Instanzen zurückgeht.

5. Führen Sie in Ihrem lokalen Fenster mit dem Ladegeneratorbefehl das Script erneut aus, um Anforderungen für die App zu erstellen. Führen Sie in Cloud Shell den Befehl ibmcloud code-engine application get -n frontend aus, um zu sehen, wie die Anzahl der Instanzen auf 5 steigt.

   Erwartete Ausgabe:

   Name                                        Revision        Running  Status   Restarts  Age
   frontend-00002-deployment-77d5fbfb5d-7zpfl  frontend-00002  3/3      Running  0         70s
   frontend-00002-deployment-77d5fbfb5d-kv6rn  frontend-00002  3/3      Running  0         69s
   frontend-00002-deployment-77d5fbfb5d-mhlwn  frontend-00002  3/3      Running  0         68s
   frontend-00002-deployment-77d5fbfb5d-qkjmd  frontend-00002  3/3      Running  0         67s
   frontend-00002-deployment-77d5fbfb5d-zpr9n  frontend-00002  3/3      Running  0         85s
   

Back-End-Anwendung bereitstellen und Verbindung testen

1. Führen Sie den folgenden Befehl aus, um eine neue Back-End-Anwendung zum Speichern Ihrer Textdateien in IBM Cloud Object Storage bereitzustellen

   ibmcloud code-engine application create --name backend --image icr.io/solution-tutorials/tutorial-text-analysis-code-engine-backend --cluster-local
   

   Die Flagge --cluster-local weist Code Engine an, den Endpunkt für diese Anwendung privat zu halten, was bedeutet, dass er nur innerhalb des Projekts verfügbar ist. Diese Vorgehensweise wird häufig zu Sicherheitszwecken genutzt. In diesem Fall gibt es keinen Grund, die Back-End-Anwendung über einen öffentlichen Endpunkt zugänglich zu machen, da auf ihn nicht von außerhalb des Clusters zugegriffen werden soll.

2. Kopieren und speichern Sie den internen Endpunkt URL aus der Ausgabe, um ihn im nächsten Befehl zu verwenden. Dies sieht ungefähr wie folgt aus:

   BACKEND_PRIVATE_URL=http://backend.xxxxxx
   

   Sie können den Befehl ibmcloud code-engine application get -n backend ausführen, um den Status und die Details der Backend-Anwendung zu überprüfen, die URL enthält.

3. Die Front-End-Anwendung verwendet eine Umgebungsvariable (BACKEND_URL), um auf die Hostposition der Back-End-Anwendung zuzugreifen. Sie müssen die Front-End-Anwendung aktualisieren, um diesen Wert so festzulegen, dass er auf den Endpunkt der Back-End-Anwendung verweist.

   ibmcloud code-engine application update --name frontend --env BACKEND_URL=$BACKEND_PRIVATE_URL
   

   Das Flag --env kann beliebig oft angegeben werden, wenn mehr als eine Umgebungsvariable festgelegt werden muss. Diese Option hätten Sie im Befehl ibmcloud code-engine application create für die Front-End-Anwendung verwenden können, wenn Sie zu diesem Zeitpunkt den Wert bereits gewusst hätten. Weitere Informationen finden Sie im Dokumentationsthema Mit Umgebungsvariablen arbeiten.

4. Führen Sie eine harte Aktualisierung für die Front-End-URL im Browser durch, um die Verbindung zur Back-End-Anwendung zu testen. Sie sollten eine Seite mit einer Option zum Hochladen einer Textdatei (.txt) sowie eine Fehlernachricht aus der Back-End-Anwendung sehen, da das Back-End noch nicht mit den erforderlichen IBM Cloud-Services zum Speichern und Verarbeiten der Textdateien verbunden ist. Auch nach Klicken auf Textdatei hochladen sollte eine ähnliche Fehlernachricht angezeigt werden.

Object Storage-Service und Natural Language Understanding-Service bereitstellen

1. Instanz von Object Storageerstellen

   1. Wählen Sie den Lite-Plan oder den Standard-Plan aus, wenn Sie bereits über eine Object Storage-Serviceinstanz in Ihrem Konto verfügen.
   2. Setzen Sie Servicename auf your-initials-code-engine-cos.
   3. Wählen Sie die Ressourcengruppe aus, in der Sie das Projekt Code Engine erstellt haben.
   4. Klicken Sie auf Erstellen.
   5. Erfassen Sie den Servicenamen in einer Shellvariablen:

      COS_INSTANCE_NAME=your-initials-code-engine-cos
      

2. Klicken Sie unter Bucket erstellen auf Bucket erstellen und wählen Sie dann unter Angepasstes Bucket erstellen Erstellen aus.

   Wenn Sie Eimer erstellen oder Objekte hinzufügen, achten Sie darauf, keine personenbezogenen Daten (PII) zu verwenden. Hinweis: PII sind Informationen, die jeden Benutzer (natürliche Person) anhand seines Namens, seines Standorts oder auf andere Weise identifizieren können.

   1. Geben Sie Eindeutiger Bucketname ein, z. B. <your-initials>-bucket-code-engine.
   2. Wählen Sie einen Ort aus, an dem Sie Code Engine erstellt haben.
   3. Wählen Sie die Speicherklasse Smart Tier aus.
   4. Klicken Sie auf Bucket erstellen.
   5. Erfassen Sie den Bucketnamen in einer Shellvariablen:

      COS_BUCKETNAME=your-initials-bucket-code-engine
      

3. Auf der Bucketseite.

   1. Klicken Sie auf die Registerkarte "Konfiguration "
   2. Der Endpunkt Direct behält Daten in IBM Cloudbei. Erfassen Sie den direkten Endpunkt in einer Shellvariablen. In der Region Dallas, us-amerikanischer Süden, könnte das der Fall sein:

      COS_ENDPOINT=s3.direct.us-south.cloud-object-storage.appdomain.cloud
      

4. Instanz von Natural Language Understandingerstellen

   1. Wählen Sie einen Standort und wählen Sie den Lite-Plan.
   2. Geben Sie für Servicename den Wert code-engine-nlu an und wählen Sie die Ressourcengruppe aus, in der Sie das Code Engine-Projekt erstellt haben.
   3. Lesen Sie die Lizenzvereinbarung und überprüfen Sie anschließend Ich habe die folgenden Lizenzvereinbarungen gelesen und stimme ihnen zu.
   4. Klicken Sie auf Erstellen.
   5. Erfassen Sie den Servicenamen in einer Shellvariablen:

      NLU_INSTANCE_NAME=YourServiceName
      

Object Storage-Service an die Back-End-Anwendung binden

Jetzt müssen Sie die Berechtigungsnachweise für die IBM Cloud Object Storage-Instanz, die Sie gerade erstellt haben, an Ihre Back-End-Anwendung übergeben. Dazu verknüpfen Sie Object Storage mit Ihrer Anwendung, wodurch automatisch Anmeldeinformationen für einen Dienst zu den Umgebungsvariablen für Ihre Anwendung oder Ihren Job hinzugefügt werden.

1. Erstellen Sie eine Bindung für den Object Storage-Service aus praktischen Gründen mit dem Präfix COS zur Verwendung in Ihrer Anwendung. Der Befehl bind erstellt einen Serviceberechtigungsnachweis in der Serviceinstanz und initialisiert daraus die Umgebungsvariablen der Anwendung mit den Berechtigungsnachweisen. Jede Dienstbindung kann mithilfe des Flags --prefix so konfiguriert werden, dass ein benutzerdefiniertes Umgebungsvariablenpräfix verwendet wird.

   ibmcloud code-engine application bind --name backend --service-instance $COS_INSTANCE_NAME --role Writer --prefix COS
   

2. Sie müssen für die Anwendung auch den Namen Ihres Buckets, in dem Sie die Textdateien speichern wollen, und Ihren COS-Endpunkt angeben. Beide wurden in einem früheren Schritt definiert. Der Endpunkt für 'us-south' für Smart Tier ist s3.direct.us-south.cloud-object-storage.appdomain.cloud.

   Definieren Sie eine Configmap, um den Bucket-Namen und den Endpunkt zu speichern, da die Informationen nicht vertraulich sind. Konfigurationszuordnungen sind Kubernetes-Objekte, mit denen Sie Konfigurationsartefakte vom Imageinhalt entkoppeln können, um containerisierte Anwendungen portierbar zu halten. Sie können diese Konfigurationszuordnung durch eine Datei oder durch ein Schlüssel/Wert-Paar erstellen -- für den jetzigen Zweck verwenden Sie ein Schlüssel/Wert-Paar mit dem Flag --from-literal. Überprüfen Sie, ob Sie diese zuvor erfasst haben und erstellen Sie die ConfigMap:

   echo bucket $COS_BUCKETNAME endpoint $COS_ENDPOINT
   

   ibmcloud code-engine configmap create --name backend-configuration --from-literal=COS_BUCKETNAME=$COS_BUCKETNAME --from-literal=COS_ENDPOINT=$COS_ENDPOINT
   

3. Wenn die Konfigurationszuordnung definiert ist, können Sie die Back-End-Anwendung jetzt aktualisieren, indem Sie Code Engine auffordern, Umgebungsvariablen in der Laufzeit der Anwendung nach Maßgabe der Werte in der Konfigurationszuordnung festzulegen. Aktualisieren Sie die Back-End-Anwendung mit dem folgenden Befehl:

   ibmcloud code-engine application update --name backend --env-from-configmap backend-configuration
   

   Zum Erstellen eines geheimen Schlüssels müssten Sie das Flag --env-from-secret verwenden. Sowohl geheime Schlüssel als auch Konfigurationszuordnungen sind "Zuordnungen" (Maps); das heißt, in den festgelegten Umgebungsvariablen sind die Namen, die den Schlüsseln ("key") der Einträge in diesen Zuordnungen entsprechen, enthalten und die Werte der Umgebungsvariablen sind die Werte für die einzelnen Schlüssel.

4. Prüfen Sie, ob die Back-End-Anwendung mit der Bindung und der Konfigurationszuordnung aktualisiert wurde. Sie können den folgenden Befehl ausführen und nach den Abschnitten Service Bindings (Servicebindungen) und Environment Variables (Umgebungsvariablen) in der Ausgabe suchen:

   ibmcloud code-engine application get --name backend
   

5. Wechseln Sie zur Front-End-Benutzerschnittstelle und laden Sie Textdateien für die Textanalyse hoch. Die hochgeladenen Dateien sollten mit dem Tag Not analyzed gekennzeichnet sein.

Job erstellen

Im Gegensatz zu Anwendungen, die auf eingehende HTTP reagieren, sind Jobs für die Ausführung von Container-Images gedacht, die eine ausführbare Datei enthalten, die nur einmal ausgeführt und dann beendet wird. Wenn Sie einen job erstellen, können Sie Informationen zur Workloadonfiguration angeben, die bei jeder Ausführung des Jobs verwendet werden. Sie können den Job in der Konsole oder in der Befehlszeilenschnittstelle erstellen.

Dieser Job liest Textdateien aus IBM Cloud Object Storage und analysiert diese dann mithilfe des Natural Language Understanding-Service. Er muss Zugriff auf die Serviceberechtigungsnachweise für beide Services haben.

1. Führen Sie den folgenden Befehl aus, um einen Job zu erstellen

   ibmcloud code-engine job create --name backend-job --image icr.io/solution-tutorials/tutorial-text-analysis-code-engine-backend-job --env-from-configmap backend-configuration
   

   Sie können die Version des Natural Language Understanding-Service mit dem Flag --env festlegen. Informationen zur Versionierung finden Sie über diesen Link.

IBM Cloud-Services an den Job binden

1. Erstellen Sie nun eine Bindung für den Object Storage-Service mit dem Präfix COS_JOB, die mit den Jobs zum Lesen der hochgeladenen Dateien und zum Speichern der Ergebnisse verwendet werden soll.

   ibmcloud code-engine job bind --name backend-job --service-instance $COS_INSTANCE_NAME --role Writer --prefix COS_JOB
   

2. Ganz ähnlich binden Sie den Natural Language Understanding-Service mit dem Präfix NLU_JOB, um die hochgeladenen Textdateien zu analysieren.

   ibmcloud code-engine job bind --name backend-job --service-instance $NLU_INSTANCE_NAME --role Writer --prefix NLU_JOB
   

3. Prüfen Sie, ob der Job mit der Bindung und der Konfigurationszuordnung aktualisiert wurde. Sie können den folgenden Befehl ausführen und nach den Abschnitten Service Bindings (Servicebindungen) und Environment Variables (Umgebungsvariablen) in der Ausgabe suchen:

   ibmcloud code-engine job get --name backend-job
   

Job ausführen

1. Senden Sie die oben erstellte Konfiguration an einen Job erledigen. Verwenden Sie dazu den Befehl jobrun submit

   ibmcloud code-engine jobrun submit --name backend-jobrun --job backend-job
   

   Wenn Sie einen Job ausführen, können Sie viele der Variablen überschreiben, die Sie in der Jobkonfiguration festgelegt haben. Zum Prüfen der Variablen führen Sie den folgenden Befehl ibmcloud code-engine jobrun submit --help aus.

2. Führen Sie den folgenden Befehl aus, um den Status der Jobausführung (jobrun) zu prüfen:

   ibmcloud code-engine jobrun get --name backend-jobrun
   

3. Die Protokolle können angezeigt werden:

   ibmcloud code-engine jobrun logs --follow --name backend
   

4. Klicken Sie in der Front-End-Benutzerschnittstelle auf die Schaltfläche für Aktualisierung (neben 'Textdatei hochladen'), um die Schlüsselwörter und das JSON für jede der hochgeladenen Textdateien anzuzeigen. Der Tag für jede Datei sollte sich jetzt in Analyzed ändern.

5. Laden Sie neue Dateien hoch oder löschen Sie einzelne Dateien durch Klicken auf das Symbol zum Löschen, übergeben Sie die Jobausführung (jobrun) mit dem folgenden Befehl erneut und klicken Sie auf die Schaltfläche für Aktualisierung, um die Ergebnisse anzuzeigen.

   ibmcloud code-engine jobrun resubmit --jobrun backend-jobrun
   

Jobausführung automatisieren

Statt den Job manuell auszuführen, können Sie durch die Erstellung eines IBM Cloud Object Storage-Abonnements, das Änderungen an einem Object Storage-Bucket überwacht, den Job automatisieren. Wenn Sie ein Abonnement für einen Bucket erstellen, erhält Ihr Job für jede erfolgreiche Änderung an diesem Bucket ein separates Ereignis.

1. Bevor Sie ein Object Storage-Abonnement erstellen können, müssen Sie die Rolle Notifications Manager für Code Engine zuordnen. Als Benachrichtigungsmanager kann Code Engine Benachrichtigungen für ein Object Storage-Bucket anzeigen, ändern und löschen. Befolgen Sie die Anweisungen in diesem Abschnitt, um die Rolle 'Benachrichtigungsservice' für Ihr Code Engine-Projekt zuzuordnen.
2. Stellen Sie mit dem folgenden Befehl eine Verbindung zwischen Ihrem backend-job und dem IBM Cloud Object Storage-Ereignisproduzenten her. Überprüfen und aktualisieren Sie bucket name, bevor Sie den Befehl ausführen.

   ibmcloud code-engine subscription cos create --name backend-job-cos-event --destination-type job --destination backend-job --bucket $COS_BUCKETNAME --prefix files --event-type write
   

3. Laden Sie jetzt einfach neue Dateien hoch und klicken Sie auf die Schaltfläche für Aktualisierung, um die Ergebnisse anzuzeigen. Im weiteren Verlauf müssen Sie die Jobausführung nicht erneut übergeben, da sich darum das Abonnement kümmert.