Inizializza una shell cloud

La CLI della piattaforma container Red Hat OpenShift espone comandi per la gestione delle applicazioni, nonché strumenti di livello inferiore per interagire con ciascun componente del sistema. La CLI è disponibile utilizzando il comando oc.

Per evitare di installare gli strumenti della riga di comando, l'approccio consigliato è quello di utilizzare il sito IBM Cloud Shell.

La shell IBM Cloud è uno spazio di lavoro shell basato sul cloud a cui puoi accedere tramite il tuo browser. È preconfigurato con la CLI completa di IBM Cloud e con molti plug-in e strumenti che si possono usare per gestire applicazioni, risorse e infrastrutture.

In questo passo, utilizzerai la shell IBM Cloud e configurerai oc per puntare al cluster a te assegnato.

1. Quando il cluster è pronto, fai clic sul pulsante (accanto al tuo account) nell'angolo in alto a destra per avviare una shell cloud. Assicurarsi di non chiudere questa finestra/tab.

2. Controlla la versione della CLI OpenShift:

   oc version
   

   La versione deve essere almeno 4.12.x, altrimenti installare la versione più recente seguendo queste istruzioni.

3. Convalida che il cluster venga mostrato quando vengono elencati tutti i cluster:

   ibmcloud oc clusters
   

4. Inizializzare l'ambiente di comando oc sostituendo il segnaposto < nome - cluster - utente>:

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

5. Verifica che il comando oc funzioni:

   oc get projects
   

Crea progetto

Un progetto è una raccolta di risorse gestite da un team di operazioni di sviluppo. Un amministratore creerà il progetto e gli sviluppatori possono creare le applicazioni che possono essere sviluppate e distribuite.

1. Vai alla console web Red Hat OpenShift facendo clic sul pulsante OpenShift web console nel Cluster selezionato.
2. Nel pannello di navigazione sinistro, nella prospettiva Amministratore, selezionare la vista Home > Progetti per visualizzare tutti i progetti.
3. Crea un nuovo progetto facendo clic su Create Project. Nella finestra a comparsa assegnare un nome al progetto example-health, lasciare vuoto Nome visualizzato e Descrizione, quindi fare clic su Crea.
4. Viene visualizzata la pagina Project Details del nuovo progetto. Osserva che il tuo contesto è Administrator > Home > Projects sulla sinistra e Projects > Project Details > example-health nella parte superiore

Sviluppa e distribuisci l'applicazione

1. Passa dalla vista Administrator alla prospettiva Developer. Il contesto dovrebbe essere Sviluppatore > +Aggiungi a sinistra e Progetto: esempio-salute in alto.

   

2. Costruiamo e distribuiamo l'applicazione selezionando Importazione da Git.
3. Inserire il repository https://github.com/IBM-Cloud/patient-health-frontend.git nel campo Git Repo URL.
   • Nota il controllo verde Builder image detected e il Node.js 16 (UBI 8).
   • Nota che l'immagine del builder ha rilevato automaticamente il linguaggio Node.js. Se non viene rilevato, selezionare Node.js dall'elenco fornito.
   • Versione immagine costruttore lasciare l'impostazione predefinita.
   • Nome dell'applicazione eliminare tutti i caratteri e lasciare vuoto (questo sarà il nome predefinito)
   • Nome: patient-health-frontend.
   • Fare clic su Tipo di risorsa e scegliere DeploymentConfig.
   • Lasciare le impostazioni predefinite per le altre selezioni.
4. Fai clic su Create nella parte inferiore della finestra per sviluppare e distribuire l'applicazione.

Visualizza l'applicazione

1. Dovresti vedere l'applicazione che hai appena distribuito. Nota che sei nella vista Topology del progetto example-health nella prospettiva Developer. Vengono visualizzate tutte le applicazioni nel progetto.

2. Selezionare il nodo patient-health-frontend per visualizzare i dettagli di DeploymentConfig. Si noti il DC accanto a patient-health-frontend. I Pod, gli edifici, i servizi e le rotte sono visibili.

   

   • Pods: i tuoi contenitori dell'applicazione Node.js
   • Builds: la build generata automaticamente che ha creato un'immagine Docker dal tuo codice sorgente Node.js, l'ha distribuita al registro del contenitore Red Hat OpenShift e ha avviato la tua configurazione della distribuzione
   • Services: indica a Red Hat OpenShift come accedere ai tuoi Pod raggruppandoli insieme come un servizio e definendo la porta di ascolto
   • Routes: espone i tuoi servizi al mondo esterno utilizzando il LoadBalancer fornito dalla rete IBM Cloud

3. Fai clic su View Logs accanto alla tua Build completata. Ciò ti mostra il processo eseguito da Red Hat OpenShift per installare le dipendenze per la tua applicazione Node.js e per sviluppare/eseguire il push di un'immagine Docker. L'ultima voce dovrebbe essere simile alla seguente:

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

4. Fai clic fino a tornare a Topology e seleziona nuovamente la tua applicazione.

5. Cliccate sull' URL sotto Percorsi per visitare la vostra applicazione. Inserire una stringa qualsiasi per nome utente e password, ad esempio test:test perché l'applicazione è in modalità dimostrativa.

L'applicazione Node.js è stata distribuita a Red Hat OpenShift Container Platform. Ricapitolando:

• L'applicazione "Esempio di salute" Node.js è stata distribuita direttamente da GitHub nel cluster.
• L'applicazione è stata esaminata nella console Red Hat OpenShift on IBM Cloud.
• È stata creata una Build Configuration; un nuovo commit può essere sia sviluppato che distribuito facendo clic su Start Build nella sezione Builds dei dettagli dell'applicazione.

Simula il carico sull'applicazione

Crea uno script per simulare il carico.

1. Assicurati di essere connesso al progetto in cui hai distribuito la tua applicazione.

   oc project example-health
   

2. Richiama l'instradamento pubblico per accedere alla tua applicazione:

   oc get routes
   

   L'output è simile al seguente; nota il tuo valore per 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. Definisci una variabile con l'host:

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

4. Verifica l'accesso all'applicazione. Genera in output le informazioni sul paziente:

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

   L'output dovrebbe essere simile a:

   $ 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. Esegui il seguente script che invierà continuamente richieste all'applicazione e genera il traffico:

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

   Per arrestare lo script, premere CTRL + c sulla tastiera

Registrazione Red Hat OpenShift on IBM Cloud

Poiché esiste un solo pod, la visualizzazione dei registri delle applicazioni sarà semplice.

1. Assicurati che sei nella vista Topology della prospettiva Developer.

2. Passa al tuo pod selezionando la tua app.

3. Fai clic su Visualizza log accanto al nome del pod in Pods per visualizzare i log di streaming dalla tua applicazione in esecuzione. Se stai ancora generando del traffico, dovresti vedere i messaggi di log per ogni richiesta effettuata.

   

Terminale Red Hat OpenShift on IBM Cloud

Una delle migliori caratteristiche di Kubernetes è la capacità di eseguire rapidamente il debug dei tuoi pod dell'applicazione con i terminali SSH. Ciò è ottimo per lo sviluppo, ma generalmente non è consigliato negli ambienti di produzione. Red Hat OpenShift rende ancora più semplice consentendoti di avviare un terminale direttamente nel pannello di controllo.

1. Passa dalla scheda Logs alla scheda Terminal .
2. Esegui i seguenti comandi Shell:

Monitoraggio di Red Hat OpenShift on IBM Cloud

Quando si distribuiscono nuove applicazioni, si apportano modifiche alla configurazione o semplicemente si ispeziona lo stato del tuo cluster, il dashboard dell'ambito del progetto offre a uno sviluppatore delle chiare analisi approfondite.

1. Accedere al dashboard nella prospettiva Sviluppatore facendo clic su Observe sul menu a sinistra.
2. È anche possibile immergersi un po' più in profondità facendo clic sulla scheda Eventi. Gli eventi sono utili per identificare la sequenza temporale degli eventi e trovare potenziali messaggi di errore. Quando si traccia lo stato di una nuova distribuzione, si gestiscono asset esistenti o anche quando si esegue qualcosa di semplice come l'esposizione di un instradamento, la vista Events è di importanza critica nell'identificazione della linea temporale dell'attività. Ciò diventa anche più utile quando si considera che più operatori potrebbero essere impegnati a lavorare su un singolo cluster.

Quasi tutte le azioni in Red Hat OpenShift determinano l'attivazione di un evento in questa vista. Poiché ne viene eseguito l'aggiornamento in tempo reale, è un ottimo modo per tenere traccia delle variazioni dello stato.

Dashboard

Red Hat OpenShift viene fornito con dashboard predefiniti per monitorare i tuoi progetti.

1. Inizia passando dalla prospettiva Developer alla prospettiva Administrator:
2. Spostarsi su Osserva > Cruscotti nella barra di sinistra.
3. Seleziona Kubernetes / Compute Resources / Namespace (Pods) dal menu a discesa e Namespace a example - health.
4. Nota l'utilizzo di CPU e memoria per la tua applicazione. Negli ambienti di produzione, è utile per identificare la quantità media di CPU o memoria utilizzata dalla tua applicazione, soprattutto perché può fluttuare nel corso della giornata. Il ridimensionamento automatico è un modo per gestire le fluttuazioni e verrà illustrato un po' più avanti.

Metriche

Red Hat OpenShift fornisce un'interfaccia web per eseguire query ed esaminare le metriche visualizzate su un grafico. Questa funzionalità fornisce una vasta panoramica dello stato del cluster e ti consente di risolvere i problemi.

1. Passare a Osservare> Metriche.

2. Immettere la seguente espressione e fare clic su Esegui query. È necessario visualizzare il valore e il grafico associati alla query.

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

   

Abilita i limiti di risorse

Prima del ridimensionamento automatico, è necessario stabilire dei limiti di risorse massimi di CPU e memoria.

I dashboard precedenti mostravano che il carico consumava da ".002" a ".02" core. Ciò equivale a 2-20 "millicore". Per sicurezza, portiamo il valore massimo a 30 millicore. Inoltre, i dati hanno mostrato che l'applicazione utilizza circa 25-65 MB di RAM. I passi seguenti impostano i limiti delle risorse nel file deploymentConfig

1. Assicurarsi che lo script per generare il traffico sia in esecuzione.

2. Passare alla prospettiva Amministratore.

3. Passare a Workload> DeploymentConfigs.

4. Selezionare il progetto esempio-salute.

5. Dal menu Azioni (i tre punti verticali) di patient-health-frontend, scegliere Modifica DeploymentConfig.

   

6. Nella vista YAML, trova la sezione spec> template> spec> containers, aggiungi i seguenti limiti per le risorse nelle risorse vuote. Sostituisci resources {} e assicurati che la spaziatura sia corretta -- YAML utilizza un'indentazione stretta.

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

   Questo è un frammento di codice dopo che hai apportato le modifiche:

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

7. Salvare per applicare le modifiche.

8. Verificare che il controller di replica sia stato modificato navigando nella scheda Eventi:

   

Abilita l'autoscaler

Ora che i limiti per le risorse sono configurati, è possibile abilitare il pod autoscaler.

Per impostazione predefinita, l'autoscaler ti consente di eseguire il ridimensionamento in base a CPU o memoria. I pod sono bilanciati tra il numero minimo e quello massimo di pod che specifichi. Con l'autoscaler, i pod vengono creati o eliminati automaticamente per garantire che l'utilizzo medio della CPU dei pod sia sotto l'obiettivo di richiesta di CPU come definito. In generale, probabilmente vuoi iniziare ad eseguire un ridimensionamento incrementale quando ti avvicini al 50-90% dell'utilizzo della CPU di un pod. Nel nostro caso, 1% può essere utilizzato con il carico che si sta fornendo.

1. Navigare verso Amministratore prospettiva Carichi di lavoro > OrizzontalePodAutoscaler, quindi fare clic su Creare HorizontalPodAutoscaler.

   

   Sostituire il contenuto dell'editor con questo yaml:

   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. Fai clic su Crea.

Verifica autoscaler

Se non stai eseguendo lo script per simulare il carico, il numero di pod deve restare a 1.

1. Verificate aprendo la pagina Panoramica della configurazione dell'installazione client. Fare clic su Carichi di lavoro > DeploymentConfigs e fare clic su patient-health-frontend e assicurarsi che il pannello Dettagli sia selezionato.

2. Inizia a simulare il carico (vedi la sezione precedente per simulare il carico sull'applicazione).

   

   Potrebbe volerci qualche minuto perché l'autoscaler apporti le rettifiche.

Questo è tutto! Hai ora un'applicazione Node.js di frontend altamente disponibile e ridimensionata automaticamente. Red Hat OpenShift sta ridimensionando automaticamente i tuoi pod dell'applicazione poiché l'utilizzo della CPU dei pod ha notevolmente superato il 1% del limite di risorse, 30 millicore.

Ridimensionamento automatico dalla riga di comando

Puoi anche eliminare e creare risorse come gli autoscaler con la riga di comando.

1. Inizia verificando che il contesto sia il tuo progetto.

   oc project example-health
   

2. Ottieni l'autoscaler che è stato creato in precedenza:

   oc get hpa
   

3. Elimina l'autoscaler creato precedentemente.

   oc delete hpa/patient-hpa
   

4. Crea un nuovo autoscaler con un massimo di 9 pod:

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

5. Rivisitare la pagina Workloads > DeploymentConfigs Details per l'implementazione di patient-health-frontend e osservarne il funzionamento.

Abilita l'operatore IBM Cloud

Capiamo esattamente come funzionano gli operatori. Nel primo esercizio, hai utilizzato un builder per distribuire un'applicazione semplice utilizzando un DeploymentConfig un tipo di risorsa predefinito che viene con Red Hat OpenShift. Una definizione di risorsa personalizzata consente di creare tipi di risorse che non sono preinstallate in Red Hat OpenShift on IBM Cloud, come ad esempio il servizio IBM Cloud. Gli operatori gestiscono il ciclo di vita delle risorse e creano i CRD (Custom Resource Descriptor), che ti consentono di gestire le risorse personalizzate nel modo "Kubernetes" nativo.

1. Nella prospettiva Administrator, fai clic su Operators > OperatorHub.
2. Individuare l'operatore IBM Cloud e fare clic su Installa.
3. Mantenete le opzioni predefinite e fate clic su Installa.
4. Dopo alcuni secondi dovrebbe essere visualizzato installed operator - ready for use.

Crea servizio e bind Cloudant utilizzando i CRD

Fare clic per aprirlo. Scorrete fino alla sezione Prerequisiti.

In questa sezione è richiesta una chiave API con le autorizzazioni appropriate per creare un database IBM Cloudant. La chiave API verrà archiviata in una risorsa di segreto Kubernetes. Occorrerà eseguirne la creazione utilizzando la shell. Le istruzioni sono riportate nella sezione Prerequisiti dell'operatore installato. Passi:

1. Utilizzare lo stesso gruppo di risorse e la stessa regione associati al cluster.

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

   Per visualizzare i gruppi di risorse nel tuo account, immetti il comando ibmcloud resource groups

2. Verifica che il gruppo di risorse e la regione corrispondano al tuo cluster. Il seguente comando dovrebbe restituire il cluster.

   ibmcloud oc cluster ls
   

L'output è qualcosa di simile al seguente:

$ 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. Utilizza lo script helper fornito da IBM per creare le seguenti risorse:

   • La chiave API IBM Cloud che rappresenta te e le tue autorizzazioni a utilizzare IBM Cloud
   • Il segreto Kubernetes denominato secret-ibm-cloud-operator nello spazio dei nomi default. Questo segreto ha le chiavi api-key e region. L'operatore utilizzerà questi dati per creare l'istanza del servizio cloudant.
   • La risorsa ConfigMap Kubernetes con il nome config-ibm-cloud-operator nello spazio dei nomi default che conterrà la regione e il gruppo di risorse

   Utilizza il comando curl fornito:

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

4. Torna alla console web Red Hat OpenShift, fai clic su Crea servizio nella scheda Servizio sul Operatori installati della pagina Operatore IBM Cloud e seleziona Vista YAML per visualizzare l'editor yaml.

5. Esegui le sostituzioni consigliate dove serviceClass è cloudantnosqldb e il piano può essere lite o standard (è consentito un solo piano lite per ogni account). Sostituire <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. Fai clic su Create per creare un'istanza del database IBM Cloudant. Il tuo contesto dovrebbe essere Operators > Installed Operators > IBM Cloud Operator nella prospettiva Administrator con Project: example-health nel pannello Service.

7. Fate clic sul servizio appena creato, -cloudant-service e nel corso del tempo il campo dello stato cambierà da provisioning a Online, il che significa che è pronto a partire.

8. Crea una risorsa di bind (Binding) e una risorsa di segreto (Secret) per la risorsa di servizio (Service) di Cloudant appena creata. Torna alla scheda Operatori > Operatori installati > IBM Cloud > Binding. Aprire la scheda Bind, fare clic su Crea bind e selezionare Vista YAML. Creare un cloudant-binding associato a serviceName <your-initials>-cloudant-service, (questo è il nome fornito per il servizio creato in precedenza).

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

9. Facoltativamente, vai più a fondo per comprendere la relazione tra le risorse Red Hat OpenShift: servizio (Service), bind (Binding) del servizio, segreto (Secret) del bind e le risorse IBM Cloud: servizio (Service), istanza (Instance) del servizio e credenziali del servizio (Service credentials) dell'istanza. Utilizzando la shell cloud:

   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
   

   L'output è qualcosa di simile al seguente:

   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"
       }
   ]
   

Distribuisci l'applicazione di database Patient Backend Node.js

Ora creerai l'applicazione Node.js che popolerà il tuo DB Cloudant con i dati del paziente. Servirà inoltre i dati all'applicazione di frontend distribuita in precedenza.

1. Assicurati che il tuo contesto sia il progetto example-health:

   oc project example-health
   

2. Il seguente comando new-app eseguirà una configurazione di build e una configurazione di distribuzione. Quanto segue illustra il richiamo della CLI dell'aggiunta dell'applicazione (ricordati di utilizzare la console GUI per il frontend):

   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. Nella console e nella vista Topologia della prospettiva Sviluppatore, aprire l'applicazione patient-health-backend e attendere il completamento della compilazione. Nota che il Pod non può avviarsi. Fai clic sui log Pod per vedere:

   > 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. Correggiamo questa situazione impostando la variabile di ambiente della DeploymentConfig sul segreto cloudant-binding creato in precedenza nella sezione di bind dell'operatore (Operator Binding). Passare alla configurazione di distribuzione dell'applicazione patient-health-backend facendo clic sull'applicazione e selezionando il nome accanto a DC:

   

5. Accedere alla scheda Ambiente, fare clic su Aggiungi da ConfigMap o su Segreto e creare una nuova variabile d'ambiente denominata CLOUDANT_URL. Scegli il segreto cloudant-binding e scegli quindi url per la chiave. Fai clic su Save.

   

6. Torna alla scheda Topology e fai clic su patient-health-backend. Consultate la sezione Pods, che dovrebbe indicare l'esecuzione a breve. Fai clic su Visualizza log accanto al pod in esecuzione e nota i database creati.

Configura l'applicazione di frontend Patient Health per utilizzare l'applicazione di backend Patient Health

L'applicazione patient-health-frontend ha una variabile di ambiente per l'url del microservizio di backend

1. Impostare la variabile d'ambiente API_URL come predefinita nel frontend DeploymentConfig. Passare alla configurazione di distribuzione dell'applicazione patient-health-frontend facendo clic sull'applicazione frontend nella vista Topologia e selezionando il nome accanto a DC:

2. Passare alla scheda Ambiente e nella sezione Valori singoli (env) aggiungere il nome API_URL e il valore default. Fai clic su Save e quindi su Reload. Ciò produrrà una connessione a http://patient-health-backend:8080/ che puoi verificare consultando i log del pod. È possibile verificare che si tratti della porta corretta analizzando l'output Pod Template / Containers / Port di questo comando:

   oc describe dc/patient-health-backend
   

La tua applicazione è ora supportata dai dati del paziente fittizi nel DB Cloudant. È ora possibile accedere utilizzando qualsiasi user-id/password nel DB Cloudant, utilizzando "opall:opall ".

1. In un'applicazione nel mondo reale, queste password non devono essere memorizzate come testo normale. Per rivedere i pazienti (e i login alternativi) nel DB Cloudant, navigare nel proprio services in IBM Cloud Resource List. Fare clic su -cloudant-service.
2. Avviare il dashboard Cloudant facendo clic sul pulsante Launch Dashboard e poi sul db patients.
3. Fare clic sui diversi pazienti come cui è possibile accedere.

Visualizza dashboard e viste di monitoraggio predefinite

Utilizza le viste e i dashboard per monitorare le tue infrastrutture, le tue applicazioni e i tuoi servizi. Puoi utilizzare i dashboard predefiniti. Puoi anche creare dei dashboard personalizzati tramite l'IU web oppure programmaticamente. Puoi eseguire il backup e il ripristino dei dashboard utilizzando gli script Python.

La seguente tabella elenca i diversi tipi di dashboard predefiniti:

Visualizza il dashboard Monitoring

1. Vai a Red Hat OpenShift on IBM Cloud clusters e nota i cluster Red Hat OpenShift
2. Fai clic sul tuo cluster e verifica che la scheda Overview sulla sinistra sia selezionata
3. Nella sezione Integrations accanto a Monitoring, fai clic sul pulsante Launch.

I dati iniziali potrebbero NON essere disponibili sulle istanze di Monitoring appena create.

• Dopo pochi minuti, verranno visualizzati i dati non elaborati.
• Dopo circa un'ora, l'indicizzazione fornirà i dettagli necessari per procedere con questa esercitazione

1. Nella sezione Dashboard, seleziona Kubernetes > Pod Status & Performance per visualizzare le metriche non elaborate per tutti i carichi di lavoro in esecuzione sul cluster.
2. Imposta il filtro namespace su example - health per concentrarti sui pod della tua applicazione.
3. In Dashboard sul pannello di sinistra, espandere Applications in Dashboard Templates. Seleziona quindi HTTP per ottenere una vista globale del carico HTTP del cluster.

Esplora il cluster e la capacità del nodo

1. Selezionare Dashboard, eseguire il checkout dei due modelli di dashboard:

   • Contenitori> Utilizzo risorsa contenitore
   • Infrastruttura host> Utilizzo risorse host

2. Seleziona il template Kubernetes > Pod Rightsizing & Workload Capacity Optimization. Questo dashboard ti aiuta a ottimizzare la tua infrastruttura e a controllare meglio la spesa del cluster assicurarti che i pod siano ridimensionati correttamente. Comprendere se è possibile liberare risorse riducendo le richieste di memoria e / o CPU.

Esplora l'applicazione

1. Selezionare Dashboard e il template Kubernetes > Workload Status & Performance.

   Un dashboard dettagliato che mostra tutti i pod nel cluster.

2. Creare un dashboard personalizzato e quindi applicarlo a uno spazio dei nomi specifico.

   • In alto a destra, fare clic su Copia nei miei dashboard e denominarlo Workload Status & Performanceapp example-health
   • Fare clic su Crea e apri per creare il proprio dashboard.
   • Modificare l'ambito del dashboard.
   • Impostare il filtro per kube_namespace_name, is, example-health.
   • Fare clic su Salva.

   Il dashboard ora mostra le informazioni focalizzate sullo spazio dei nomi di stato di esempio.

   Scorrere i TimeCharts per le richieste HTTP, la latenza, l'errore, ... per capire le prestazioni dell'applicazione.

   

Trova ulteriori informazioni su IBM Cloud Monitoring nella documentazione di IBM Cloud.