Cloud-Shell initialisieren

Die Red Hat OpenShift Container Platform CLI bietet Befehle für die Verwaltung Ihrer Anwendungen sowie Tools auf niedrigerer Ebene für die Interaktion mit den einzelnen Komponenten Ihres Systems. Die Befehlszeilenschnittstelle bzw. CLI kann über den Befehl oc aufgerufen werden.

Um die Installation von Befehlszeilentools zu vermeiden, empfiehlt es sich, IBM Cloud Shell zu verwenden.

IBM Cloud Shell ist ein cloudbasierter Shell-Arbeitsbereich, den Sie in Ihrem Browser aufrufen können. Es ist mit der vollständigen IBM Cloud-CLI sowie vielen Plug-ins und Tools vorkonfiguriert, die Sie zum Verwalten von Apps, Ressourcen und Infrastruktur verwenden können.

In diesem Schritt verwenden Sie die IBM Cloud-Shell und konfigurieren oc so, dass es auf den Ihnen zugewiesenen Cluster verweist.

1. Wenn der Cluster bereit ist, klicken Sie (neben Ihrem Konto) auf die Schaltfläche in der rechten oberen Ecke, um Cloud Shell zu starten. Lassen Sie das aktuelle Fenster bzw. die aktuelle Registerkarte geöffnet.

2. Überprüfen Sie die Version der OpenShift-Befehlszeilenschnittstelle:

   oc version
   

   Die Version muss mindestens 4.12.x sein, andernfalls installieren Sie die neueste Version, indem Sie diese Anweisungen befolgen.

3. Prüfen Sie, ob Ihr Cluster in der Liste aller Cluster aufgeführt ist:

   ibmcloud oc clusters
   

4. Initialisieren Sie die Befehlsumgebung oc, indem Sie den Platzhalter ersetzen:

   ibmcloud oc cluster config -c <your-cluster-name> --admin
   

5. Überprüfen Sie, ob der Befehl oc funktioniert:

   oc get projects
   

Projekt erstellen

Ein Projekt ist eine Sammlung von Ressourcen, die von einem DevOps-Team verwaltet werden. Ein Administrator erstellt das Projekt und die Entwickler können Anwendungen erstellen, die erstellt und bereitgestellt werden können.

1. Navigieren Sie zur Webkonsole Red Hat OpenShift, indem Sie im ausgewählten Cluster auf die Schaltfläche OpenShift web console klicken.
2. Wählen Sie im linken Navigationsbereich in der Perspektive Administrator die Ansicht Startseite > Projekte aus, um alle Projekte anzuzeigen.
3. Erstellen Sie ein neues Projekt, indem Sie auf Projekt erstellen klicken. Geben Sie im Popup-Fenster als Name des Projekts example-health an, lassen Sie Anzeigename und Beschreibung leer und klicken Sie auf Erstellen.
4. Die Seite Projektdetails des neuen Projekts wird angezeigt. Beachten Sie, dass Ihr Kontext folgender sein sollte: Administrator > Startseite > Projekte auf der linken Seite und Projekte > Projektdetails > example-health ganz oben.

Anwendung erstellen und bereitstellen

1. Wechseln Sie von der Ansicht Administrator in die Perspektive Entwickler. Ihr Kontext sollte Folgender sein: Entwickler > +Hinzufügen auf der linken Seite und Projekt: example-health ganz oben.

   

2. Erstellen und implementieren Sie die Anwendung, indem Sie importieren aus Git auswählen.
3. Geben Sie das Repository https://github.com/IBM-Cloud/patient-health-frontend.git im Feld "Git-Repo-URL" ein.
   • Beachten Sie die grüne Markierung Builder image detected und die Node.js 16 (UBI 8).
   • Beachten Sie, dass das Builder-Image die Sprache Node.js automatisch erkannt hat. Falls nicht erkannt, wählen Sie Node.js aus der bereitgestellten Liste aus.
   • Belassen Sie Version des Builder-Image bei dem Standardwert.
   • Löschen Sie in Anwendungsname alle Zeichen und lassen Sie das Feld leer (damit wird standardmäßig der Name übernommen)
   • Name : patient-health-frontend.
   • Klicken Sie auf den Link Ressourcentyp und wählen Sie DeploymentConfig aus.
   • Für die anderen Auswahlen belassen Sie die Standardeinstellungen.
4. Klicken Sie unten im Fenster auf Erstellen, um die Anwendung zu erstellen und bereitzustellen.

Anwendung anzeigen

1. Es sollte die soeben bereitgestellte App angezeigt werden. Beachten Sie, dass Sie sich in der Ansicht Topologie des Projekts 'example-health' in der Perspektive Entwickler befinden. Alle Anwendungen im Projekt werden angezeigt.

2. Wählen Sie node patient-health-frontend aus, um die Detailansicht der DeploymentConfig aufzurufen. Beachten Sie die Angabe DC neben patient-health-frontend. Die Pods, Builds, Services und Routen sind sichtbar.

   

   • Pods: Ihre Node.js-Anwendungscontainer.
   • Builds: Der automatisch generierte Build, der ein Docker-Image aus Ihrem Node.js-Quellcode erstellt, ihn in der Red Hat OpenShift-Container-Registry bereitstellt und Ihre Bereitstellungskonfiguration eingeleitet hat.
   • Services: Informiert Red Hat OpenShift darüber, wie es auf Ihre Pods zugreifen kann, indem es sie als einen Service gruppiert und den Port für die Empfangsbereitschaft definiert.
   • Routen: Machen Ihre Services für die Außenwelt verfügbar, indem sie die Lastausgleichsfunktion verwenden, die vom IBM Cloud-Netz bereitgestellt wird.

3. Klicken Sie neben Ihrem abgeschlossenen Build auf Protokolle anzeigen. Dies zeigt den Prozess an, den Red Hat OpenShift verwendet hat, um die Abhängigkeiten für Ihre Node.js-Anwendung zu installieren und ein Docker-Image mit Push-/Pull-Operation zu übertragen. Der letzte Eintrag sollte wie folgt aussehen:

   Successfully pushed image-registry.openshift-image-registry.svc:5000/example-health/patient-health-frontend@sha256:f9385e010144f36353a74d16b6af10a028c12d005ab4fc0b1437137f6bd9e20a
   Push successful
   

4. Klicken Sie erneut auf Topologie und wählen Sie Ihre App erneut aus.

5. Klicken Sie auf die URL unter Routen, um Ihre Anwendung aufzurufen. Geben Sie eine beliebige Zeichenfolge als Benutzernamen und Kennwort ein, z. B. test:test, da die App im Demonstrationsmodus ausgeführt wird.

Die Node.js-App wurde in Red Hat OpenShift Container Platform bereitgestellt. Zusammenfassung:

• Die Node.js-Anwendung "Example Health" wurde direkt von GitHub in Ihrem Cluster bereitgestellt.
• Die Anwendung wurde in der Red Hat OpenShift on IBM Cloud-Konsole untersucht.
• Eine Buildkonfiguration wurde erstellt - eine neue Festschreibung kann sowohl erstellt als auch bereitgestellt werden, indem Sie im Abschnitt 'Builds' der Anwendungsdetails auf Build starten klicken.

Auslastung der Anwendung simulieren

Erstellen Sie ein Script, um die Auslastung zu simulieren.

1. Stellen Sie sicher, dass Sie mit dem Projekt verbunden sind, in dem Sie Ihre App bereitgestellt haben.

   oc project example-health
   

2. Rufen Sie die öffentliche Route für den Zugriff auf Ihre Anwendung ab:

   oc get routes
   

   Die Ausgabe ähnelt der folgenden. Notieren Sie den Wert für 'Host':

   NAME         HOST/PORT                                                                                                 PATH      SERVICES     PORT       TERMINATION   WILDCARD
   patient-health-frontend   patient-health-frontend-example-health.roks07-872b77d77f69503584da5a379a38af9c-0000.eu-de.containers.appdomain.cloud             patient-health-frontend   8080-tcp                 None
   

3. Definieren Sie eine Variable mit dem Host:

   HOST=$(oc get routes -o json | jq -r '.items[0].spec.host')
   

4. Überprüfen Sie den Zugriff auf die Anwendung. Die Patienteninformationen werden ausgegeben:

   curl -s -L http://$HOST/info
   

   Die Ausgabe sollte wie folgt aussehen:

   $ curl -s -L http://$HOST/info
   {"personal":{"name":"Ralph DAlmeida","age":38,"gender":"male","street":"34 Main Street","city":"Toronto","zipcode":"M5H 1T1"},"medications":["Metoprolol","ACE inhibitors","Vitamin D"],"appointments":["2018-01-15 1:00 - Dentist","2018-02-14 4:00 - Internal Medicine","2018-09-30 8:00 - Pediatry"]}
   

5. Führen Sie das folgende Script aus, das Anforderungen endlos an die Anwendung sendet und Datenverkehr generiert:

   while sleep 0.2; do curl --max-time 2 -s -L http://$HOST/info >/dev/null; echo -n "."
   done
   

   Zum Stoppen des Scripts drücken Sie die Tastenkombination CTRL + c.

Red Hat OpenShift on IBM Cloud-Protokollierung

Da es nur einen einzigen Pod gibt, ist das Anzeigen der Anwendungsprotokolle sehr einfach.

1. Stellen Sie sicher, dass Sie sich in der Ansicht Topologie der Perspektive Entwickler befinden.

2. Navigieren Sie zu Ihrem Pod, indem Sie Ihre App auswählen.

3. Klicken Sie auf Protokolle anzeigen neben dem Namen des Pod unter Pods, um das Streaming-Protokoll Ihrer aktiven Anwendung anzuzeigen. Wenn immer noch Datenverkehr generiert wird, sollten Protokollnachrichten für jede Anforderung angezeigt werden.

   

Red Hat OpenShift on IBM Cloud-Terminal

Einer der großen Vorteile von Kubernetes ist seine Fähigkeit, Anwendungspods mit SSH-Terminals schnell zu debuggen. Dies eignet sich hervorragend für die Entwicklung, ist aber in der Regel in Produktionsumgebungen nicht zu empfehlen. Red Hat OpenShift macht es noch einfacher, indem es Ihnen ermöglicht, ein Terminal direkt im Dashboard zu starten.

1. Wechseln Sie von der Registerkarte Protokolle zur Registerkarte Terminal.
2. Führen Sie die folgenden Shell-Befehle aus:

Red Hat OpenShift on IBM Cloud-Monitoring

Beim Bereitstellen neuer Apps, Vornehmen von Konfigurationsänderungen oder einfachen Überprüfen des Clusterstatus gibt das Projektdashboard dem Entwickler klare Einblicke.

1. Greifen Sie in der Entwicklerperspektive auf das Dashboard zu, indem Sie im Menü auf der linken Seite auf Beobachten klicken.
2. Sie können auch tiefer eintauchen, indem Sie auf die Registerkarte Ereignisse klicken. Ereignisse sind nützlich, um die Zeitleiste von Ereignissen zu ermitteln und potenzielle Fehlernachrichten zu finden. Beim Verfolgen des Status eines neuen Rollouts, bei der Verwaltung vorhandener Assets oder auch bei einfacheren Aufgaben wie dem Zugänglichmachen einer Route, ist die Ereignisansicht sehr wichtig bei der Ermittlung der Zeitleiste von Aktivitäten. Noch nützlicher ist dies, wenn man bedenkt, dass mehrere Operatoren möglicherweise für einen einzelnen Cluster arbeiten.

Fast alle Aktionen in Red Hat OpenShift führen dazu, dass ein Ereignis in dieser Ansicht ausgelöst wird. Da sie in Echtzeit aktualisiert wird, bietet sie eine sehr gute Möglichkeit, um Änderungen am Status zu verfolgen.

Dashboards

Red Hat OpenShift enthält vordefinierte Dashboards zur Überwachung Ihrer Projekte.

1. Beginnen Sie, indem Sie von der Perspektive Entwickler in die Perspektive Administrator wechseln:
2. Navigieren Sie in der linken Leiste zu Beobachten > Dashboards.
3. Wählen Sie Kubernetes/Ressourcen berechnen/Namensbereich (Pods) aus der Dropdown-Liste aus und wählen Sie den Namensbereich example-health.
4. Beachten Sie die CPU- und Speicherbelegung für Ihre Anwendung. In Produktionsumgebungen ist dies hilfreich zur Ermittlung der durchschnittlichen Menge an CPU oder Speicher, die Ihre Anwendung verwendet, insbesondere, da sie im Tagesverlauf schwanken kann. Die automatische Skalierung ist eine Möglichkeit, Schwankungen zu bewältigen. Sie wird wenig später demonstriert.

Metriken

Red Hat OpenShift bietet eine Webschnittstelle zum Ausführen von Abfragen und zum Untersuchen der in einem Diagramm visualisierten Metriken. Diese Funktionalität bietet eine umfassende Übersicht über den Clusterstatus und ermöglicht Ihnen die Behebung von Problemen.

1. Navigieren Sie zu Beobachten > Metriken.

2. Geben Sie den folgenden Ausdruck ein und klicken Sie auf Abfragen ausführen. Sie sollten den Wert und das Diagramm sehen, die der Abfrage zugeordnet sind.

   sum(container_cpu_usage_seconds_total{container="patient-health-frontend"})
   

   

Ressourcenbegrenzungen aktivieren

Vor der automatischen Skalierung müssen die CPU- und Speicherressourcenbegrenzungen festgelegt werden.

Die Dashboards haben Ihnen zuvor gezeigt, dass die Last zwischen ".002" und ".02" Kerne verbraucht. Dies lässt sich in 2 - 20 "Millicores" umsetzen. Um sicherzugehen, setzen Sie den oberen Grenzwert auf bis zu 30 Millicores. Außerdem haben die Daten gezeigt, dass die App ungefähr 25-65 MB RAM verbraucht. In den folgenden Schritten werden die Ressourcenbegrenzungen in der Bereitstellungskonfiguration festgelegt.

1. Stellen Sie sicher, dass das Script zum Generieren von Datenverkehr ausgeführt wird.

2. Wechseln Sie in die Perspektive Administrator.

3. Navigieren Sie zu Workloads > DeploymentConfigs.

4. Wählen Sie das Projekt example-health aus.

5. Wählen Sie im Menü Aktionen (drei vertikale Punkte) von patient-health-frontend die Option Implementierungskonfiguration bearbeiten aus.

   

6. Suchen Sie in der YAML-Ansicht den Abschnitt Spezifikation > Vorlage > Spezifikation > Container und fügen Sie die folgenden Ressourcengrenzwerte in die leeren Ressourcen ein. Ersetzen Sie resources {} und achten Sie auf korrekte Einrückungen, da diese in YAML streng beachtet werden müssen.

             resources:
               limits:
                 cpu: 30m
                 memory: 100Mi
               requests:
                 cpu: 3m
                 memory: 40Mi
   

   Es folgt ein Snippet nach dem Vornehmen der Änderungen:

          ports:
            - containerPort: 8080
              protocol: TCP
          resources:
            limits:
              cpu: 30m
              memory: 100Mi
            requests:
              cpu: 3m
              memory: 40Mi
          terminationMessagePath: /dev/termination-log
   

7. Speichern, um die Änderungen anzuwenden.

8. Überprüfen Sie, ob der Replikationscontroller geändert wurde, indem Sie zur Registerkarte Ereignisse navigieren:

   

Autoscaler aktivieren

Die Ressourcengrenzwerte sind nun konfiguiert und der Autoscaler für den Pod kann aktiviert werden.

Standardmäßig können Sie mit dem Autoscaler basierend auf CPU- oder Speicherverbrauch skalieren. Die Pods werden zwischen der angegebenen Mindest- und Höchstanzahl von Pods ausgeglichen. Mit dem Autoscaler werden Pods automatisch erstellt oder gelöscht, um sicherzustellen, dass die durchschnittliche CPU-Belastung der Pods unterhalb des definierten CPU-Anforderungsziels liegt. Grundsätzlich ist es wohl sinnvoll, mit der Skalierung zu beginnen, wenn die Werte in die Nähe von 50 - 90% der CPU-Auslastung eines Pods rücken. In diesem Fall kann mit der angegebenen Last 1% verwendet werden.

1. Navigieren Sie zur Perspektive Administrator Workloads > HorizontalPodAutoscalers und klicken Sie dann auf HorizontalPodAutoscaler erstellen.

   

   Ersetzen Sie den Inhalt des Editors durch diesen YAML-Inhalt:

   apiVersion: autoscaling/v2
   kind: HorizontalPodAutoscaler
   metadata:
     name: patient-hpa
     namespace: example-health
   spec:
     scaleTargetRef:
       apiVersion: apps.openshift.io/v1
       kind: DeploymentConfig
       name: patient-health-frontend
     minReplicas: 1
     maxReplicas: 10
     metrics:
       - type: Resource
         resource:
           name: cpu
           target:
             averageUtilization: 1
             type: Utilization
   

2. Klicken Sie auf Erstellen.

Autoscaler testen

Wenn Sie nicht das Script zur Simulation der Arbeitslast ausführen, sollte die Anzahl der Pods bei 1 bleiben.

1. Überprüfen Sie dies, indem Sie die Seite Übersicht der Bereitstellungskonfiguration öffnen. Klicken Sie auf Workloads > Implementierungskonfig und dann auf Patient-Health-Frontend. Stellen Sie sicher, dass die Anzeige Details ausgewählt ist.

2. Beginnen Sie mit der Simulation der Arbeitslast (siehe vorherigen Abschnitt zur Simulation der Arbeitslast der Anwendung).

   

   Es kann einige Minuten dauern, bis der Autoscaler Anpassungen vornimmt.

Das ist alles! Sie verfügen nun über eine hochverfügbare und automatisch skalierte Front-End-Anwendung Node.js. Red Hat OpenShift skaliert Ihre Anwendungs-Pods automatisch, da die CPU-Auslastung der Pods 1% des Ressourcenlimits 30 Millicores weit überschritten hat.

Automatische Skalierung über die Befehlszeile

Sie können Ressourcen wie Autoscaler auch über die Befehlszeile löschen und erstellen.

1. Beginnen Sie, indem Sie überprüfen, ob der Kontext Ihr Projekt ist:

   oc project example-health
   

2. Rufen Sie den Autoscaler ab, der zuvor erstellt wurde:

   oc get hpa
   

3. Löschen Sie den Autoscaler, der zuvor erstellt wurde:

   oc delete hpa/patient-hpa
   

4. Erstellen Sie einen neuen Autoscaler mit maximal 9 Pods:

   oc autoscale deploymentconfig/patient-health-frontend --name patient-hpa --min 1 --max 9 --cpu-percent=1
   

5. Rufen Sie erneut die Detailseite Workloads > Bereitstellungskonfigurationen (DeploymentConfigs) für die Implementierung von patient-health-frontend auf und sehen Sie, wie es funktioniert.

IBM Cloud Operator aktivieren

Im Folgenden wird die genaue Funktionsweise von Operatoren erklärt. In der ersten Übung haben Sie einen Builder verwendet, um eine einfache Anwendung mit DeploymentConfig einem Standardressourcentyp zu implementieren, der mit Red Hat OpenShiftgeliefert wird. Eine benutzerdefinierte Ressourcendefinition ermöglicht es Ihnen, Ressourcentypen zu erstellen, die nicht mit Red Hat OpenShift on IBM Cloud vorinstalliert sind, wie z. B. einen IBM Cloud-Dienst. Operatoren verwalten den Lebenszyklus von Ressourcen und erstellen angepasste Ressourcendeskriptoren, CRDs, mit denen Sie angepasste Ressourcen auf dem nativen "Kubernetes"-Weg verwalten können.

1. Klicken Sie in der Perspektive Administrator auf Operatoren > OperatorHub.
2. Suchen Sie den IBM Cloud Operator und klicken Sie auf Installieren.
3. Behalten Sie die Standardoptionen bei und klicken Sie auf Installieren.
4. Nach einigen Sekunden sollte installed operator - ready for use angezeigt werden.

Cloudant-Service erstellen und mithilfe der CRDs binden

Klicken Sie hier, um sie zu öffnen. Blättern Sie abwärts zum Abschnitt mit den Voraussetzungen.

In diesem Abschnitt ist ein API-Schlüssel mit den entsprechenden Berechtigungen zum Erstellen einer IBM Cloudant-Datenbank erforderlich. Der API-Schlüssel wird in einer Ressource in Form eines geheimen Kubernetes-Schlüssels gespeichert. Diese muss mithilfe der Shell erstellt werden. Im Abschnitt Voraussetzungen des installierten Operators finden Sie entsprechende Anweisungen. Schritte:

1. Verwenden Sie dieselbe Ressourcengruppe und dieselbe Region, die auch Ihrem Cluster zugeordnet sind.

   ibmcloud target -g <resource_group> -r <region>
   

   Um die Ressourcengruppen in Ihrem Konto anzuzeigen, führen Sie den Befehl ibmcloud resource groups aus.

2. Überprüfen Sie, ob die Ressourcengruppe und die Region Ihrem Cluster entsprechen. Der folgende Befehl sollte Ihren Cluster zurückgeben.

   ibmcloud oc cluster ls
   

Die Ausgabe sieht ungefähr wie folgt aus:

$ ibmcloud oc cluster ls
OK
Name      ID                     State    Created        Workers   Location   Version                  Resource Group Name   Provider
osmicro   ck68svdd0vvcfs6ad9ag   normal   18 hours ago   2         Dallas     4.12.26_1562_openshift   default               vpc-gen2

3. Verwenden Sie das von IBM bereitgestellte Helper-Script, um die folgenden Ressourcen zu erstellen:

   • Ein IBM Cloud-API-Schlüssel, der Sie und Ihre Berechtigungen für die Verwendung von IBM Cloud darstellt.
   • Ein geheimer Kubernetes-Schlüssel mit dem Namen secret-ibm-cloud-operator im Namensbereich default. Dieser geheime Schlüssel verfügt über die Schlüssel api-key und region. Der Operator verwendet diese Daten, um die Cloudant-Serviceinstanz zu erstellen.
   • Eine Kubernetes-ConfigMap-Ressource mit dem Namen config-ibm-cloud-operator im Namensbereich default, die die Region und die Ressourcengruppe enthält.

   Verwenden Sie den bereitgestellten curl-Befehl:

   curl -sL https://raw.githubusercontent.com/IBM/cloud-operators/master/hack/configure-operator.sh | bash
   

4. Klicken Sie, zurück in der Red Hat OpenShift-Webkonsole, auf Service erstellen auf der Registerkarte Service für Installierte Operatoren der Seite IBM Cloud Operator und wählen Sie YAML-Ansicht aus, um den yaml-Editor zu öffnen.

5. Nehmen Sie die vorgeschlagenen Ersetzungen vor, wobei die Serviceklasse cloudantnosqldb ist und der Plan entweder Lite oder Standard sein kann (pro Konto ist nur ein Lite-Plan zulässig). Ersetzen Sie <your-initials>:

   apiVersion: ibmcloud.ibm.com/v1
   kind: Service
   metadata:
     annotations:
      ibmcloud.ibm.com/self-healing: enabled
     name: <your-initials>-cloudant-service
     namespace: example-health
   spec:
     serviceClass: cloudantnosqldb
     plan: standard
   

6. Klicken Sie auf Erstellen, um eine IBM Cloudant-Datenbankinstanz zu erstellen. Ihr Kontext sollte folgender sein: Operatoren > Installierte Operatoren > IBM Cloud Operator in der Perspektive Administrator mit dem Projekt 'example-health' in der Anzeige Service.

7. Klicken Sie auf den soeben erstellten Dienst <Ihre-Anfänge>-Cloudant-Service. Im Laufe der Zeit ändert sich der Status von " Provisioning" zu "Online", was bedeutet, dass der Dienst einsatzbereit ist.

8. Erstellen Sie eine Bindungsressource und eine Ressource in Form eines geheimen Schlüssels für die soeben erstellte Cloudant-Service-Ressource. Navigieren Sie zurück zur Registerkarte Operatoren > Installierte Operatoren > IBM Cloud Operator > Bindung. Öffnen Sie die Registerkarte Bindung, klicken Sie auf Bindung erstellen und wählen Sie YAML-Ansicht aus. Erstellen Sie eine Cloudant-Bindung, die dem Servicenamen <your-initials>-cloudant-service zugeordnet ist (dies ist der für den zuvor erstellten Service angegebene Name).

   apiVersion: ibmcloud.ibm.com/v1
   kind: Binding
   metadata:
     name: cloudant-binding
     namespace: example-health
   spec:
     serviceName: <your-initials>-cloudant-service
   

9. Optional können Sie die Beziehung zwischen Red Hat OpenShift-Ressourcen weiter erkunden: Service, Bindung des Service, geheimer Schlüssel der Bindung sowie die IBM Cloud-Ressourcen: Service, Instanz des Service und Serviceberechtigungsnachweise der Instanz. Bei Verwendung der Cloud-Shell:

   ibmcloud resource service-instances --service-name cloudantnosqldb
   

   YOURINITIALS=<your-initials>
   

   ibmcloud resource service-instance $YOURINITIALS-cloudant-service
   

   ibmcloud resource service-keys --instance-name $YOURINITIALS-cloudant-service --output json
   

   Die Ausgabe sieht ungefähr wie folgt aus:

   youyou@cloudshell:~$ ibmcloud resource service-instances --service-name cloudantnosqldb
   Retrieving instances with type service_instance in all resource groups in all locations under ..
   OK
   Name                           Location   State    Type
   <your-initials>-cloudant-service               us-south   active   service_instance
   youyou@cloudshell:~$ ibmcloud resource service-instance <your-initials>-cloudant-service
   Retrieving service instance <your-initials>-cloudant-service in all resource groups under ...
   OK
   
   Name:                  <your-initials>-cloudant-service
   ID:                    crn:v1:bluemix:public:cloudantnosqldb:us-south:a/0123456789507a53135fe6793c37cc74:SECRET
   GUID:                  SECRET
   Location:              us-south
   Service Name:          cloudantnosqldb
   Service Plan Name:     standard
   Resource Group Name:   Default
   State:                 active
   Type:                  service_instance
   Sub Type:
   Created at:            2020-05-06T22:39:25Z
   Created by:            youyou@us.ibm.com
   Updated at:            2020-05-06T22:40:03Z
   Last Operation:
                       Status       create succeeded
                       Message      Provisioning is complete
                       Updated At   2020-05-06 22:40:03.04469305 +0000 UTC
   
   youyou@cloudshell:~$ ibmcloud resource service-keys --instance-name $YOURINITIALS-cloudant-service --output json
   [
       {
           "guid": "01234560-902d-4078-9a7f-20446a639aeb",
           "id": "crn:v1:bluemix:public:cloudantnosqldb:us-south:a/0123456789507a53135fe6793c37cc74:SECRET",
           "url": "/v2/resource_keys/01234560-902d-4078-9a7f-20446a639aeb",
           "created_at": "2020-05-06T23:03:43.484872077Z",
           "updated_at": "2020-05-06T23:03:43.484872077Z",
           "deleted_at": null,
           "name": "cloudant-binding",
           "account_id": "0123456789507a53135fe6793c37cc74",
           "resource_group_id": "01234567836d49029966ab5be7fe50b5",
           "source_crn": "crn:v1:bluemix:public:cloudantnosqldb:us-south:a/0123456789507a53135fe6793c37cc74:SECRET",
           "state": "active",
           "credentials": {
               "apikey": "SECRET",
               "host": "SECRET",
               "iam_apikey_description": "Auto-generated for key SECRET",
               "iam_apikey_name": "cloudant-binding",
               "iam_role_crn": "SECRET",
               "iam_serviceid_crn": "SECRET",
               "password": "SECRET",
               "port": 443,
               "url": "https://01234SECRET",
               "username": "01234567-SECRET"
           },
           "iam_compatible": true,
           "resource_instance_url": "/v2/resource_instances/SECRET",
           "crn": "crn:v1:bluemix:public:cloudantnosqldb:us-south:a/0123456789507a53135fe6793c37cc74:SECRET"
       }
   ]
   

Node.js-App für Back-End-Datenbank bereitstellen

Nun erstellen Sie die Node.js-App, die Ihre Cloudant-Datenbank mit Patientendaten füllen wird. Zudem befüllt sie auch die zuvor bereitgestellte Front-End-Anwendung mit Daten.

1. Stellen Sie sicher, dass Ihr Kontext das Projekt example-health ist:

   oc project example-health
   

2. Der folgende Befehl 'new-app' erstellt eine Buildkonfiguration und eine Bereitstellungskonfiguration. Im Folgenden wird der CLI-Aufruf von 'add application' veranschaulicht (denken Sie daran, die GUI-Konsole für das Front-End zu verwenden):

   oc new-app --name=patient-health-backend --as-deployment-config registry.access.redhat.com/ubi9/nodejs-20-minimal:latest~https://github.com/IBM-Cloud/patient-health-backend
   

3. Kehren Sie in die Konsole zur Ansicht Topologie der Perspektive Entwickler zurück, öffnen Sie die App patient-health-backend und warten Sie, bis die Erstellung beendet ist. Beachten Sie, dass der Pod nicht gestartet werden kann. Klicken Sie auf die Pod-Protokolle, um Folgendes zu sehen:

   > node app.js
   
   /opt/app-root/src/app.js:23
            throw("Cannot find Cloudant credentials, set CLOUDANT_URL.")
            ^
   Cannot find Cloudant credentials, set CLOUDANT_URL.
   

4. Dies wird behoben, indem Sie die Umgebungsvariable der Bereitstellungskonfiguration (DeploymentConfig) auf den geheimen Schlüssel cloudant-binding festlegen, den Sie zuvor im Abschnitt der Operator-Bindung erstellt haben. Navigieren Sie zu der Bereitstellungskonfiguration für die Anwendung patient-health-backend, indem Sie auf die App klicken und dann den Namen neben DC auswählen:

   

5. Wechseln Sie zur Registerkarte Umgebung, klicken Sie auf Aus Konfigurationszuordnung oder geheimem Schlüssel hinzufügen und erstellen Sie eine neue Umgebungsvariable mit dem Namen CLOUDANT_URL. Wählen Sie den geheimen Schlüssel cloudant-binding und dann die URL für den Schlüssel aus. Klicken Sie auf Speichern.

   

6. Wechseln Sie zurück zur Registerkarte Topologie und klicken Sie auf patient-health-backend. Prüfen Sie den Abschnitt Pods, der nach kurzer Zeit den Status Aktiv anzeigen sollte. Klicken Sie auf Protokolle anzeigen neben dem aktiven Pod und beachten Sie die erstellten Datenbanken.

Front-End-App für Patientengesundheit für die Verwendung der Back-End-App für Patientengesundheit konfigurieren

Die Anwendung patient-health-frontend verfügt über eine Umgebungsvariable für die Back-End-Mikroservice-URL.

1. Setzen Sie die Umgebungsvariable API_URL in der Bereitstellungskonfiguration für das Front-End auf den Wert default. Navigieren Sie zur Bereitstellungskonfiguration für die App patient-health-frontend, indem Sie in der Ansicht Topologie auf die Front-End-App klicken und den Namen neben DC auswählen:

2. Rufen Sie die Registerkarte Umgebung auf und fügen Sie im Abschnitt Einzelwerte (Umgebung) den Namen API_URL und den Wert default hinzu. Klicken Sie auf Speichern und anschließend auf Erneut laden. Damit wird eine Verbindung zu http://patient-health-backend:8080/ hergestellt, die Sie anhand der Pod-Protokolle überprüfen können. Sie können überprüfen, dass dies der richtige Port ist, indem Sie nach der Ausgabe Pod Template / Containers / Port dieses Befehls suchen:

   oc describe dc/patient-health-backend
   

Ihre Anwendung wird jetzt durch die simulierten Patientendaten in der Cloudant-Datenbank unterstützt. Sie können sich nun mithilfe einer beliebigen Benutzer-ID/eines beliebigen Kennworts in der Cloudant-DB anmelden, indem Sie opall:opall verwenden.

1. In einem realen Anwendungsfall sollten diese Kennwörter nicht als Klartext gespeichert werden. Um die Patienten (und alternativen Anmeldedaten) in der Cloudant-Datenbank zu überprüfen, navigieren Sie zu Ihren services in der IBM Cloud-Ressourcenliste. Klicken Sie auf < your-initials> -cloudant-service.
2. Starten Sie das Cloudant-Dashboard, indem Sie auf die Schaltfläche Dashboard starten klicken. Anschließend klicken Sie auf die patients-Datenbank.
3. Klicken Sie sich durch die verschiedenen Patienten, als die Sie sich anmelden können.

Vordefinierte Überwachungsansichten und -dashboards anzeigen

Verwenden Sie Ansichten und Dashboards, um Ihre Infrastruktur, Anwendungen und Services zu überwachen. Sie können vordefinierte Dashboards verwenden. Sie können auch angepasste Dashboards über die Webbenutzerschnittstelle oder programmgesteuert erstellen. Sie können Dashboards mithilfe von Python-Scripts sichern und wiederherstellen.

In der folgenden Tabelle sind die verschiedenen Typen vordefinierter Dashboards aufgeführt:

Monitoring-Dashboard anzeigen

1. Navigieren Sie zu Red Hat OpenShift on IBM Cloud-Cluster und beachten Sie die Red Hat OpenShift-Cluster.
2. Klicken Sie auf Ihren Cluster und überprüfen Sie, dass die Registerkarte Übersicht auf der linken Seite ausgewählt ist.
3. Klicken Sie im Abschnitt Integrationen neben Überwachung auf die Schaltfläche Starten.

Die Anfangsdaten sind für neu erstellte Instanzen der Überwachung möglicherweise NICHT verfügbar.

• Nach einigen Minuten werden Rohdaten angezeigt.
• Nach etwa einer Stunde der Indexierung werden die erforderliche Detailinformationen für das Fortfahren mit diesem Lernprogramm bereitgestellt.

1. Wählen Sie im Abschnitt " Dashboards" die Option Kubernetes > Pod-Status und -Leistung, um Rohdaten für alle auf dem Cluster ausgeführten Workloads anzuzeigen.
2. Setzen Sie den Filter namespace auf example-health, um sich auf die Pods Ihrer Anwendung zu konzentrieren.
3. Erweitern Sie unter Dashboards im linken Teilfenster den Eintrag Anwendungen in Dashboard-Vorlagen. Anschließend wählen Sie HTTP, um eine globale Ansicht der HTTP-Last für den Cluster zu erhalten.

Cluster- und Knotenkapazität erkunden

1. Wählen Sie Dashboards aus, und überprüfen Sie die beiden Dashboard-Vorlagen:

   • Container > Containerressourcennutzung
   • Hostinfrastruktur > Hostressourcennutzung

2. Wählen Sie die Vorlage Kubernetes > Pod Rightsizing & Workload Capacity Optimization aus. Mit diesem Dashboard können Sie Ihre Infrastruktur optimieren und die Clusterausgaben besser steuern, indem Sie sicherstellen, dass die Größe der Pods korrekt ist. Machen Sie sich damit vertraut, ob Sie Ressourcen freigeben können, indem Sie Speicher-und/oder CPU-Anforderungen reduzieren.

Anwendung kennenlernen

1. Wählen Sie Dashboards und die Vorlage Kubernetes > Workload Status & Performance aus.

   Ein detailliertes Dashboard mit allen Pods im Cluster.

2. Erstellen Sie ein angepasstes Dashboard und ordnen Sie es einem bestimmten Namensbereich zu.

   • Klicken Sie oben rechts auf In meine Dashboards kopieren und nennen Sie es Workload Status & Performanceapp example-health.
   • Klicken Sie auf Erstellen und öffnen, um ein eigenes Dashboard zu erstellen.
   • Bearbeiten Sie den Dashboardbereich.
   • Legen Sie den Filter für kube_namespace_name, is, example-health fest.
   • Klicken Sie auf Speichern.

   Im Dashboard werden nun Informationen angezeigt, die sich auf den Namensbereich 'example-health' konzentrieren.

   Scrollen Sie nach unten zu TimeCharts für HTTP, Latenz, Fehler usw., um die Leistung der Anwendung zu verstehen.

   

Weitere Informationen zu IBM Cloud Monitoring finden Sie in der IBM Cloud-Dokumentation.