Déploiement de microservices avec Red Hat OpenShift on IBM Cloud

Initialisation d'un interpréteur de commandes cloud

Le CLI de Red Hat OpenShift Container Platform expose des commandes pour gérer vos applications, ainsi que des outils de niveau inférieur pour interagir avec chaque composant de votre système. L'interface de ligne de commande est disponible en utilisant la commande oc.

Pour éviter d'installer les outils de ligne de commande, il est recommandé d'utiliser IBM Cloud Shell.

L'interpréteur de commandes IBM Cloud est un espace de travail d'interpréteur de commandes cloud accessible par l'intermédiaire de votre navigateur. Il est préconfiguré avec l'interface de ligne de commande complète d'IBM Cloud et de nombreux plug-in et outils permettant de gérer les applications, les ressources et l'infrastructure.

Au cours de cette étape, vous utiliserez l'interpréteur de commandes IBM Cloud et configurerez oc pour pointer vers le cluster qui vous a été affecté.

1. Lorsque le cluster est prêt, cliquez sur le bouton (en regard de votre compte) dans l'angle supérieur droit pour lancer un interpréteur de commandes cloud. Assurez-vous de ne pas fermer cette fenêtre..

2. Vérifiez la version de l'interface de ligne de commande OpenShift :

   oc version
   

   La version doit être au minimum 4.12.x, sinon installez la dernière version en suivant ces instructions.

3. Vérifiez que votre cluster s'affiche lorsque vous répertoriez l'ensemble de vos clusters :

   ibmcloud oc clusters
   

4. Initialiser l'environnement de commande oc en remplaçant l'espace réservé :

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

5. Vérifiez que la commande oc fonctionne :

   oc get projects
   

Créer un projet

Un projet est une collection de ressources gérées par une équipe DevOps. Un administrateur crée le projet et les développeurs peuvent créer des applications pouvant être générées et déployées.

1. Naviguez vers la console web Red Hat OpenShift en cliquant sur le bouton de la console web OpenShift dans le cluster sélectionné.
2. Dans le panneau de navigation de gauche, sous la perspective Administrateur, sélectionnez Accueil > Projets pour afficher tous les projets.
3. Créez un projet en cliquant sur Créer un projet. Dans la boîte de dialogue contextuelle nommez le projet example-health, laissez les zones Nom d'affichage et Description vides, puis cliquez sur Créer.
4. La nouvelle page des détails du projet s'affiche. Le contexte qui s'affiche est Administrateur > Accueil > Projets sur la gauche et Projets > Détails du projet > example-health en haut de l'écran.

Génération et déploiement d'une application

1. Passez de la perspective Administrateur à la perspective Développeur. Votre contexte doit être Développeur > + Ajouter à gauche et Projet: exemple-santé en haut.

   

2. Reconstruisons et déployons l'application en sélectionnant Importer à partir de Git.
3. Indiquez le référentiel https://github.com/IBM-Cloud/patient-health-frontend.git dans la zone d'URL du référentiel Git.
   • Notez la vérification verte Builder image detected et la Node.js 16 (UBI 8).
   • Notez que l'image du générateur a détecté automatiquement la langue Node.js. S'il n'est pas détecté, sélectionnez Node.js dans la liste fournie.
   • Zone Builder Image Version : conservez les valeurs par défaut.
   • Zone Application Name : supprimez tous les caractères et laissez-la vide (elle prend par défaut la valeur de la zone Name).
   • Zone Name : patient-health-frontend.
   • Cliquez sur le lien Type de ressource et choisissez DeploymentConfig.
   • Laissez les valeurs par défaut pour les autres sélections.
4. Cliquez sur Create au bas de la fenêtre pour générer et déployer l'application.

Affichage de l'application

1. Vous devriez voir l'application que vous venez de déployer. Notez que vous êtes dans la vue Topologie du projet example-health dans la perspective Développeur. Toutes les applications du projet sont affichées.

2. Sélectionnez le noeud patient-health-frontend pour afficher la vue des détails de DeploymentConfig. Notez la mention DC en regard de patient-health-frontend. Les Pods, Builds, Services et Routes sont visibles.

   

   • Pods : conteneurs de votre application Node.js
   • Générations : générations automatiques qui ont créé une image Docker à partir de votre code source Node.js, l'ont déployée sur le registre de conteneur Red Hat OpenShift et ont lancé votre configuration de déploiement.
   • Services : indique à Red Hat OpenShift comment accéder à vos pods en les regroupant en service et en définissant le port d'écoute.
   • Routes : expose vos services au monde extérieur en utilisant l'équilibreur de charge fourni par le réseau IBM Cloud.

3. Cliquez sur Afficher les journaux en regard de votre génération terminée. Cela vous permet de visualiser le processus qu'Red Hat OpenShift a mis en oeuvre pour installer les dépendances pour votre application Node.js et générer/envoyer une image Docker. La dernière entrée doit se présenter comme suit :

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

4. Revenez sur la Topologie et sélectionnez de nouveau votre application.

5. Cliquez sur l'URL sous Routes pour accéder à votre application. Entrez une chaîne quelconque pour le nom d'utilisateur et le mot de passe, par exemple test:test puisque l'application s'exécute en mode démonstration.

L'application Node.js a été déployée sur Red Hat OpenShift Container Platform. Récapitulons :

• L'application Node.js "Example Health" a été déployée directement de GitHub dans votre cluster.
• L'application a été examinée dans la console Red Hat OpenShift on IBM Cloud.
• Une Configuration de génération a été créée - une nouvelle validation peut être à la fois générée et déployée en cliquant sur Commencer la génération dans la section Générations des détails de l'application.

Simulation de charge sur l'application

Créez un script pour simuler une charge.

1. Vérifiez que vous êtes connecté au projet où vous avez déployé votre application.

   oc project example-health
   

2. Extrayez la route publique d'accès à votre application :

   oc get routes
   

   La sortie se présente comme suit ; notez la valeur de 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. Définissez une variable avec l'hôte :

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

4. Vérifiez l'accès à l'application. Elle génère des informations sur le patient :

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

   La sortie se présente comme suit :

   $ 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. Exécutez le script suivant qui enverra en continu des demandes à l'application et générera du trafic :

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

   Pour arrêter le script, tapez CTRL + c au clavier.

Consignation Red Hat OpenShift on IBM Cloud

Comme il n'y a qu'un seul pod, visualiser les journaux d'application sera simple.

1. Vérifiez que vous êtes dans la vue Topologie de la perspective Développeur.

2. Accédez à votre pod en sélectionnant votre application.

3. Cliquez sur Afficher les journaux en regard du nom du pod dans la section Pods pour voir les journaux de diffusion en continu de votre application en cours d'exécution. Si vous générez encore du trafic, vous devez voir des messages de journal pour chaque demande effectuée.

   

Terminal Red Hat OpenShift on IBM Cloud

Le grand avantage de Kubernetes tient à la possibilité de déboguer rapidement vos pods d'application avec des terminaux SSH. C'est parfait pour le développement, mais ce n'est généralement pas recommandé dans les environnements de production. Red Hat OpenShift rend les choses encore plus faciles en vous permettant de lancer un terminal directement dans le tableau de bord.

1. Passez de l'onglet Journaux à l'onglet Terminal.
2. Exécutez les commandes shell suivantes :

Red Hat OpenShift on IBM Cloud Surveillance

Lorsque vous déployez de nouvelles applications, apportez des modifications à la configuration ou inspectez simplement l'état de votre cluster, le tableau de bord de portée du projet fournit à un développeur des informations d'analyse très claires.

1. Accédez au tableau de bord dans la perspective du développeur en cliquant sur Observer dans le menu de gauche.
2. Vous pouvez également explorer un peu plus en profondeur en cliquant sur l'onglet Evénements. Les événements sont utiles pour identifier la chronologie des événements et rechercher des messages d'erreur potentiels. Lors du suivi de l'état d'un nouveau déploiement, de la gestion des actifs existants, voire d'une opération très simple telle qu'exposer une route, la vue Evénements est importante pour l'identification de la chronologie d'une activité. Elle se révèle encore plus utile en tenant compte du fait que plusieurs opérateurs peuvent travailler sur un même cluster.

Presque toutes les actions dans Red Hat OpenShift génèrent le déclenchement d'un événement dans cette vue. Etant donné qu'elle est mise à jour en temps réel, c'est l'outil idéal de suivi des modifications d'état.

Tableaux de bord

Red Hat OpenShift est fourni avec des tableaux de bord prédéfinis pour surveiller vos projets.

1. Commencez par passer de la perspective Développeur à la perspective Administrateur :
2. Accédez à Observe > Tableaux de bord dans la barre de gauche.
3. Sélectionnez Kubernetes / Compute Resources / Namespace (Pods) dans la liste déroulante et l'espace de nom vers Exemple-santé.
4. Notez l'utilisation de l'UC et de la mémoire de votre application. Dans les environnements de production, cette information est utile pour identifier la quantité moyenne d'UC ou de mémoire utilisée par votre application, sachant qu'elle peut fluctuer au cours de la journée. La mise à l'échelle automatique est un moyen de gérer les fluctuations comme nous le verrons un peu plus tard.

Mesures

Red Hat OpenShift fournit une interface Web permettant d'exécuter des requêtes et d'examiner les métriques visualisées sur un tracé. Cette fonctionnalité offre une vue d'ensemble exhaustive de l'état du cluster et vous permet d'identifier et de résoudre des problèmes.

1. Accédez à Observe > Metrics.

2. Entrez l'expression suivante et cliquez sur Exécuter les requêtes. Vous devriez voir la valeur et le graphique associés à la requête.

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

   

Activation des limites de ressources

Avant la mise à l'échelle automatique, des limites de ressources de mémoire et d'UC maximales doivent être établies.

Les tableaux de bord précédents vous ont montré que la charge consommait entre 0,002 et 0,02 cœurs. Soit 2 à 20 "millicores". Par sécurité, allons jusqu'à 30 millicores. En outre, les données ont montré que l'application consomme environ 25-65 Mo de mémoire RAM. Les étapes suivantes vous permettent de définir les limites de ressources dans la section deploymentConfig

1. Assurez-vous que le script permettant de générer du trafic est en cours d'exécution.

2. Passez à la perspective Administrateur .

3. Accédez à Charges de travail > DeploymentConfigs.

4. Sélectionnez le projet exemple-santé .

5. Dans le menu Actions (les trois points verticaux) de patient-health-frontend, choisissez Éditer la configuration de déploiement.

   

6. Sous la vue YAML, recherchez la section spec > template > spec > containers, puis ajoutez les limites de ressources suivantes dans les ressources vides. Remplacez resources {} et vérifiez que l'espacement est correct -- YAML utilise l'indentation stricte.

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

   Voici un fragment après entrée des modifications :

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

7. Sauvegarder pour appliquer les modifications.

8. Vérifiez que le contrôleur de réplication a été modifié en accédant à l'onglet Événements :

   

Activation du programme de mise à l'échelle automatique (autoscaler)

A présent que les limites de ressource sont configurées, le programme de mise à l'échelle automatique de pod peut être activé.

Par défaut, le programme de mise à l'échelle automatique vous permet d'effectuer une mise à l'échelle en fonction de l'unité centrale ou de la mémoire. Les pods sont équilibrés entre le nombre minimum et maximum de pods que vous spécifiez. Avec la mise à l'échelle automatique, des pods sont automatiquement créés ou supprimés afin de garantir que l'utilisation moyenne d'UC des pods est inférieure à la cible de demande d'UC telle que définie. En général, vous souhaitez probablement effectuer une mise à l'échelle par augmentation lorsque vous atteignez 50 à 90% de l'utilisation d'UC d'un pod. Dans notre cas, 1% peut être utilisé avec la charge fournie.

1. Accédez à la perspective Administrateur, puis à Workloads > HorizontalPodAutoscalers, puis cliquez sur Create HorizontalPodAutoscaler.

   

   Remplacez le contenu de l'éditeur par le code yaml suivant :

   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. Cliquez sur Créer.

Test du programme de mise à l'échelle automatique

Si vous n'exécutez pas le script de simulation de charge, le nombre de pods doit rester à 1.

1. Vérifiez en ouvrant la page Présentation de la configuration de déploiement. Cliquez sur Charges de travail > DeploymentConfigs et cliquez sur patient-health-frontend en vous assurant que le panneau Détails est sélectionné.

2. Commencez à simuler la charge (voir la section précédente pour simuler la charge sur l'application).

   

   Quelques minutes peuvent être nécessaires au programme de mise à l'échelle automatique pour effectuer les ajustements.

Voilà ! Vous avez maintenant une application front-end Node.js hautement disponible et automatiquement mise à l'échelle. Red Hat OpenShift met automatiquement à l'échelle les pods de votre application car l'utilisation du CPU des pods a largement dépassé 1% de la limite de ressources, 30 millicores.

Mise à l'échelle automatique à partir de la ligne de commande

Vous pouvez également supprimer et créer des ressources telles que des programmes de mise à l'échelle automatique avec la ligne de commande.

1. Commencez par vérifier le contexte est votre projet :

   oc project example-health
   

2. Obtenez le programme de mise à l'échelle automatique créé précédemment :

   oc get hpa
   

3. Supprimez le programme de mise à l'échelle automatique précédemment créé :

   oc delete hpa/patient-hpa
   

4. Créez un nouveau programme de mise à l'échelle automatique avec un maximum de 9 pods :

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

5. Revisitez la page des détails de Workloads > DeploymentConfigs correspondant au déploiement de patient-health-frontend et observez son fonctionnement.

Activation de l'opérateur IBM Cloud Operator

Voyons comment fonctionnent exactement les opérateurs. Dans le premier exercice, vous avez utilisé un générateur pour déployer une application simple à l'aide d'un DeploymentConfig type de ressource par défaut qui est disponible avec Red Hat OpenShift. Une définition de ressource personnalisée vous permet de créer des types de ressources qui ne sont pas préinstallés sur Red Hat OpenShift on IBM Cloud, tels que le service IBM Cloud. Les opérateurs gèrent le cycle de vie des ressources et créent des descripteurs de ressource personnalisée, ce qui vous permet de gérer des ressources personnalisées en mode "Kubernetes" natif.

1. Dans la perspective Administrateur, cliquez sur Opérateurs > OperatorHub.
2. Recherchez l'opérateur IBM Cloud Operator, puis cliquez sur Installer.
3. Conservez les options par défaut et cliquez sur Installer.
4. Au bout de quelques secondes, installed operator - ready for use doit s'afficher.

Création d'une liaison et d'un service Cloudant à l'aide des descripteurs de ressource personnalisée

Cliquez pour l'ouvrir. Faites défiler l'écran vers le bas jusqu'à la section Prérequis.

Une clé d'API disposant des droits appropriés pour créer une base de données IBM Cloudant est requise dans cette section. La clé d'API va être stockée dans une ressource de secret Kubernetes. Elle doit être créée à l'aide de l'interpréteur de commandes. La section Prérequis de l'opérateur installé contient des instructions. Etapes :

1. Utilisez le groupe de ressources et la région associés à votre cluster.

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

   Pour voir les groupes de ressources de votre compte, exécutez la commande ibmcloud resource groups

2. Vérifiez que le groupe de ressources et la région correspondent à votre cluster. La commande suivante doit renvoyer votre cluster.

   ibmcloud oc cluster ls
   

La sortie ressemble à ceci :

$ 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. Utilisez le script auxiliaire fourni par IBM pour créer les ressources suivantes :

   • Clé d'API IBM Cloud qui vous représente ainsi que vos droits à utiliser IBM Cloud
   • Secret Kubernetes nommé secret-ibm-cloud-operator dans l'espace de nom default. Ce secret possède les clés api-key et region. L'opérateur utilisera ces données pour créer l'instance de service Cloudant.
   • Ressource Kubernetes ConfigMap nommée config-ibm-cloud-operator dans l'espace de nom default pour stocker la région et le groupe de ressources

   Utilisez la commande curl fournie :

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

4. De retour dans la console Web Red Hat OpenShift, cliquez sur Créer un service sous l'onglet Service des Opérateurs installés de la page IBM Cloud Operator et sélectionnez la vue YAML pour afficher l'éditeur yaml.

5. Effectuez les substitutions suggérées où la classe de service (serviceClass) est cloudantnosqldb et le plan peut être lite ou standard (un seul plan lite est autorisé par compte). Remplacez <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. Cliquez sur Créer pour créer une instance de base de données IBM Cloudant. Votre contexte doit être Opérateurs > Opérateurs installés > IBM Cloud Operator dans la perspective Administrateur avec projet example-health dans le panneau Service.

7. Cliquez sur le service que vous venez de créer, -cloudant-service, et au fil du temps, le champ d' état passera de provisioning à Online, ce qui signifie qu'il est prêt à fonctionner.

8. Créez une ressource de liaison et une ressource de secret pour la ressource de service Cloudant que vous venez de créer. Revenez dans Opérateurs > Opérateurs installés > IBM Cloud Operator > onglet Liaison. Ouvrez l'onglet Liaison, cliquez sur Créer une liaison et sélectionnez Vue YAML. Créez une liaison de type cloudant associée au serviceName <your-initials>-cloudant-service, (il s'agit du nom fourni pour le service créé précédemment).

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

9. Vous pouvez éventuellement creuser un peu plus pour comprendre la relation entre les ressources Red Hat OpenShift : service, liaison de service, secret de liaison et les ressources IBM Cloud : service, instance de service et données d'identification du service de l'instance. En utilisant l'interpréteur de commandes 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
   

   La sortie ressemble à ceci :

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

Déploiement de l'application de base de données de back-end de patients Node.js

Vous allez maintenant créer l'application Node.js qui va alimenter votre base de données Cloudant avec des données de patients. Elle fournira également des données à l'application de front-end précédemment déployée.

1. Vérifiez que votre contexte est le projet example-health :

   oc project example-health
   

2. La commande new-app suivante va créer une configuration de génération et une configuration de déploiement. L'exemple suivant illustre l'appel de l'interface de ligne de commande de l'application d'ajout (n'oubliez pas d'utiliser la console de l'interface graphique pour l'application de front-end) :

   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. De retour dans la console, dans la vue Topologie de la perspective Développeur, ouvrez l'application patient-health-backen et attendez la fin de la génération. Notez que le pod ne démarre pas. Cliquez sur les journaux du pod pour voir :

   > 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. Rectifions cette erreur en définissant la variable d'environnement de DeploymentConfig sur le secret cloudant-binding créé précédemment dans la section de liaison de l'opérateur. Accédez à la configuration de déploiement de l'application patient-health-backend en cliquant sur l'application, puis en sélectionnant le nom en regard de DC:

   

5. Accédez à l'onglet Environment, cliquez sur Add from ConfigMap or Secret puis créez une variable d'environnement nommée CLOUDANT_URL. Sélectionnez le secret cloudant-binding, puis url pour la clé (Key). Cliquez sur Sauvegarder.

   

6. Revenez sur l'onglet Topologie, puis cliquez sur patient-health-backend. Vérifiez que la section Pods indique maintenant En cours d'exécution. Cliquez sur Afficher les journaux en regard du pod en cours d'exécution et notez les bases de données créées.

Configuration de l'application de front-end de santé des patients afin d'utiliser l'application de back-end de santé des patients

L'application patient-health-frontend a une variable d'environnement pour l'URL du microservice de back-end.

1. Définissez la variable d'environnement API_URL sur default dans la section DeploymentConfig de l'application de front-end. Accédez à la configuration de déploiement correspondant à l'application patient-health-frontend en cliquant sur l'application de front-end dans la vue Topologie, puis en sélectionnant le nom en regard de DC :

2. Accédez à l'onglet Environnement et, dans la section Single values (env), ajoutez un nom API_URL et une valeur default. Cliquez sur Sauvegarder, puis sur Recharger. Cette opération établit une connexion à http://patient-health-backend:8080/, comme le confirment les journaux du pod. Vous pouvez vérifier qu'il s'agit du port approprié en examinant la sortie Pod Template / Containers / Port de la commande suivante :

   oc describe dc/patient-health-backend
   

Votre application s'appuie désormais sur les données de patient fictif dans la base de données Cloudant. Vous pouvez à présent vous connecter avec n'importe quel ID utilisateur/mot de passe à la base de données Cloudant, en utilisant par exemple "opall:opall".

1. Dans une application réelle, ces mots de passe ne doivent pas être stockés en texte en clair. Pour passer en revue les patients (et les autres connexions) dans la base de données Cloudant, accédez à vos services dans la liste des ressources IBM Cloud. Cliquez sur < votre_initials> -cloudant-service.
2. Ouvrez le tableau de bord Cloudant en cliquant sur le bouton de lancement du tableau de bord, puis cliquez sur la base de données patients.
3. Cliquez sur les différents patients pour lesquels vous pouvez vous connecter.

Affichage des tableaux de bord et des vues de surveillance prédéfinis

Utilisez des vues et des tableaux de bord pour surveiller votre infrastructure, vos applications et vos services. Vous pouvez utiliser des tableaux de bord prédéfinis. Vous pouvez également créer des tableaux de bord personnalisés via l'interface utilisateur Web ou à l'aide d'un programme. Vous pouvez sauvegarder et restaurer des tableaux de bord à l'aide de scripts Python.

Le tableau suivant répertorie les différents types de tableaux de bord prédéfinis :

Affichage du tableau de bord Monitoring

1. Accédez à Clusters Red Hat OpenShift on IBM Cloud et notez les clusters Red Hat OpenShift
2. Cliquez sur votre cluster et vérifiez que l'onglet Vue d'ensemble à gauche est sélectionné
3. Dans la section Intégrations en regard de Monitoring, cliquez sur le bouton Lancer.

Les données initiales NE SONT PAS forcément disponibles sur les instances Monitoring existantes.

• Au bout de quelques minutes, les données brutes s'affichent
• Au bout d'environ une heure, l'indexation fournit les détails requis pour poursuivre ce tutoriel

1. Dans la section Tableaux de bord, sélectionnez Kubernetes > Pod Status & Performance pour afficher les mesures brutes de toutes les charges de travail exécutées sur le cluster.
2. Définissez le filtre namespace sur example-health pour vous concentrer sur les pods de votre application.
3. Sous Dashboards dans la sous-fenêtre de gauche, développez Applications dans la section Dashboard Templates. Puis sélectionnez HTTP pour obtenir une vue globale de la charge HTTP du cluster.

Exploration du cluster et de la capacité du noeud

1. Sélectionnez Dashboards, vérifiez les deux modèles de tableau de bord :

   • Containers > Container Resource Usage
   • Host Infrastructure > Host Resource Usage

2. Sélectionnez le modèle Kubernetes > Pod Rightizing & Workload Capacity Optimization. Ce tableau de bord vous aide à optimiser votre infrastructure et à mieux contrôler les dépenses de cluster en vous assurant que les pods sont dimensionnés correctement. Comprenez si vous pouvez libérer des ressources en réduisant les demandes de mémoire et / ou d'UC.

Explorer l'application

1. Sélectionnez Tableaux de bord et le modèle Kubernetes > Statut et performances de la charge de travail.

   Tableau de bord détaillé présentant tous les pods du cluster.

2. Créez un tableau de bord personnalisé, puis étendez-le à un espace de nom spécifique.

   • Dans l'angle supérieur droit, cliquez sur Copier dans mes tableaux de bord et nommez-le Workload Status & Performanceapp example-health
   • Cliquez sur Créer et ouvrir pour créer votre propre tableau de bord.
   • Editez la portée du tableau de bord.
   • Définissez le filtre pour kube_namespace_name, is, example-health.
   • Cliquez sur Sauvegarder.

   Le tableau de bord affiche désormais des informations sur l'espace de nom example-health.

   Faites défiler vers le bas jusqu'aux TimeCharts pour les requêtes HTTP, la latence, les erreurs, ... pour comprendre la performance de l'application.

   

Pour plus d'informations sur IBM Cloud Monitoring voir la documentation IBM Cloud.