Déploiement d'une application de front-end

1. Pour déployer une nouvelle application Code Engine, exécutez la commande suivante : fournissant un nom de service frontend et l'image de conteneur préconstruite en tant que paramètre à l'indicateur --image .

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

   Après avoir exécuté cette commande, vous devez voir une sortie avec une URL d'accès à votre application. Elle doit ressembler à ceci : https://frontend.305atabsd0w.us-south.codeengine.appdomain.cloud. Copiez ou notez l' URL la demande pour l'étape suivante. Avec ces deux données (nom de l'application et nom de l'image), Code Engine a déployé votre application et s'occupera de la complexité de sa configuration et de sa gestion pour vous.

   Le code source de l'application utilisée pour construire les images des conteneurs est disponible dans un repo GitHub pour votre référence. Si vous voulez générer les images de conteneur depuis le code source et les envoyer dans un registre de conteneur privé, suivez ces instructions.

2. Ouvrez l' URL l'application de l'étape précédente dans un navigateur pour obtenir un résultat similaire à celui-ci :

   

   Exécutez la commande ibmcloud code-engine application get -n frontend pour voir les détails de l'application. Vous devez voir des détails, tels que l'ID, les informations du projet, l'âge de l'application, l'URL d'accès à l'application, une URL de console pour accéder à la configuration de votre application, l'image, l'allocation de ressources et différentes révisions de votre application. Comme vous disposez d'une seule révision, vous devez voir que 100 % du trafic est dirigé vers cette révision. Vous pouvez également vérifier le nombre d'instances et leur statut.

3. Pour dépanner et vérifier les journaux de votre application, exécutez la commande suivante en remplaçant <INSTANCE_NAME> par le nom de l'une des instances de la commande ibmcloud code-engine application get -n frontend.

   Si vous ne voyez aucune instance en cours d'exécution, veillez à ouvrir à nouveau l' URL l'application à partir de l'étape 2.

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

   Si l'application est en cours d'exécution, la chaîne backend URL: undefined s'affiche et l'application est à l'écoute sur le port 8080. Plus loin dans ce tutoriel, vous allez connecter cette application de front-end à notre application de back-end.

Félicitations ! Vous venez de déployer une application Web dans Code Engine avec une seule commande et sans avoir à connaître les subtilités de Kubernetes, par exemple, les pods, les déploiements, les services et la ressource Ingress.

Mise à l'échelle de l'application

Lorsque vous avez créé l'application avec la commande application create, vous n'avez fait que transmettre une image à utiliser et un nom pour votre application. Bien qu'il s'agisse de la quantité minimale d'informations pour déployer une application, il existe un certain nombre d 'autres boutons sur lesquels vous avez le contrôle. Entre autres, vous pouvez définir le nombre de demandes pouvant être traitées simultanément par instance, la quantité d'UC et de mémoire pour l'instance de l'application, les variables d'environnement de l'application, le nombre maximal et minimal d'instances pouvant être utilisées pour cette application et le port utilisé par l'application pour écouter les demandes.

La plupart de ces valeurs ont une valeur par défaut définie si aucune option n'est fournie lors de la création de l'application. Comme nous n'avons pas fourni de valeur, Code Engine a déployé notre application avec une échelle maximale par défaut égale à 10, indiquant que l'échelle de notre application pourra comprendre jusqu'à 10 instances. L'échelle minimale par défaut est zéro, de sorte que lorsque notre application n'est plus utilisée, elle se remette à zéro.

1. Pour vérifier les capacités d'autoscaling de Code Engine, nous pouvons utiliser un générateur de charge pour effectuer des requêtes contre notre service. Le script shell suivant simule une charge de base de 3000 demandes.

   1. Ouvrez une fenêtre de terminal locale (shell).

   2. Créez une variable shell pour l' URL l'application frontale de l'étape précédente.

      export APPURL=<frontend-application-url>
      

   3. Exécutez le script suivant pour générer une charge. Vous pouvez le répéter pour créer plus de trafic.

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

2. Dans votre session Cloud Shell des sections précédentes, exécutez la commande ci-dessous pour voir le nombre d'instances (pod) incrémenté dans le cadre de la mise à l'échelle automatique.

   ibmcloud code-engine application get -n frontend
   

   Par défaut, le nombre maximal de demandes pouvant être traitées simultanément par instance est 10 ce qui entraîne la mise à l'échelle automatique. Cette valeur peut être modifiée en utilisant l'indicateur --concurrency or -cn avec la commande application update.

3. Si vous ne souhaitez pas autoriser la création de 10 instances, vous pouvez ajuster l'échelle maximale en indiquant un nombre moins élevé. Alors que votre application sans serveur peut évoluer facilement, vous pouvez dépendre d'un service en aval, tel qu'une base de données SQL pouvant traiter un nombre limité de connexions ou une API avec une autre limite. Essayons de limiter le nombre d'instances de cette application de front-end.

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

4. Lorsque la génération de chargement est arrêtée, patientez quelques minutes pour que les instances s'arrêtent et que leur nombre revienne finalement à zéro.

5. Dans votre fenêtre locale avec la commande de générateur de charge, exécutez à nouveau le script pour créer des demandes sur l'application. Dans la session Cloud Shell, exécutez la commande ibmcloud code-engine application get -n frontend pour voir le nombre d'instances passer à 5.

   Sortie attendue :

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

Déploiement d'une application de back-end et test de la connexion

1. Pour déployer une nouvelle application de back-end permettant de stocker vos fichiers texte dans IBM Cloud Object Storage, exécutez cette commande :

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

   Le drapeau --cluster-local indiquera à Code Engine de garder le point de terminaison de cette application privé, ce qui signifie qu'il ne sera disponible qu'à l'intérieur du projet. Il s'agit d'une pratique souvent utilisée à des fins de sécurité. Dans ce cas, il n'y a aucune raison d'exposer l'application de back-end avec un noeud final public, car elle ne sera pas accessible en dehors du cluster.

2. Copiez et enregistrez le point de terminaison interne URL ) de la sortie pour l'utiliser dans la commande suivante. Il devrait être similaire à ceci :

   BACKEND_PRIVATE_URL=http://backend.xxxxxx
   

   Vous pouvez exécuter la commande ibmcloud code-engine application get -n backend pour vérifier l'état et les détails de l'application backend qui comprend l'URL.

3. L'application de front-end utilise une variable d'environnement (BACKEND_URL) pour savoir où est hébergée l'application de back-end. Vous devez à présent mettre à jour l'application de front-end pour définir cette valeur de sorte à pointer vers le noeud final de l'application de back-end.

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

   L'indicateur --env peut apparaître autant de fois que vous le souhaitez si vous devez définir plus d'une variable d'environnement. Cette option pourrait également avoir été utilisée dans la commande ibmcloud code-engine application create pour l'application de front-end si vous en connaissiez la valeur à ce moment-là. Pour en savoir plus, consultez la rubrique Utilisation des variables d'environnement dans la documentation.

4. Forcez l'actualisation de l'URL de front-end sur le navigateur pour tester la connexion à l'application de back-end. Vous devez voir une page avec une option permettant de télécharger un fichier texte (.txt), ainsi qu'un message d'erreur de l'application de back-end car elle n'est pas encore connectée aux services IBM Cloud requis pour stocker et traiter les fichiers texte. Cliquer sur Upload text file doit également donner lieu à un message d'erreur similaire.

Mise à disposition des services Object Storage et Natural Language Understanding

1. Créez une instance de Object Storage

   1. Sélectionnez le plan Lite ou le plan Standard si vous disposez déjà d'une instance de service Object Storage dans votre compte.
   2. Définissez le nom de service sur your-initiales-code-engine-cos.
   3. Sélectionnez le groupe de ressources dans lequel vous avez créé le projet Code Engine.
   4. Cliquez sur Créer.
   5. Capturez le nom de service dans une variable shell:

      COS_INSTANCE_NAME=your-initials-code-engine-cos
      

2. Sous Créer un compartiment, cliquez sur Créer un compartiment, puis sous Créer un compartiment personnalisé, sélectionnez Créer.

   Lorsque vous créez des godets ou ajoutez des objets, veillez à ne pas utiliser d'informations personnelles identifiables (IPI). Remarque : les IPI sont des informations qui permettent d'identifier un utilisateur (personne physique) par son nom, sa localisation ou tout autre moyen.

   1. Entrez un nom de compartiment unique tel que <your-initials>-bucket-code-engine.
   2. Sélectionnez l'emplacement où vous avez créé le projet Code Engine
   3. Sélectionnez la classe de stockage Smart Tier.
   4. Cliquez sur Créer un compartiment.
   5. Capturez le nom du compartiment dans une variable shell:

      COS_BUCKETNAME=your-initials-bucket-code-engine
      

3. Sur la page du compartiment.

   1. Cliquez sur l'onglet Configuration
   2. Le noeud final Direct conserve les données dans IBM Cloud. Capturez le noeud final direct dans une variable shell. Dans la région de Dallas, au sud des États-Unis, c'est peut-être le cas :

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

4. Créez une instance de Natural Language Understanding

   1. Sélectionnez un lieu et choisissez le plan Lite.
   2. Définissez le Nom du service sur code-engine-nlu et sélectionnez le groupe de ressources dans lequel vous avez créé le projet Code Engine.
   3. Lisez le contrat de licence, puis cochez la case J'ai lu et j'accepte les contrats de licence suivants:.
   4. Cliquez sur Créer.
   5. Capturez le nom de service dans une variable shell:

      NLU_INSTANCE_NAME=YourServiceName
      

Liaison du service Object Storage à l'application de back-end

Vous devez désormais transmettre les données d'identification pour l'instance de service IBM Cloud Object Storage que vous venez de créer à votre application de back-end. Pour ce faire, vous liez le service Object Storage à votre application, ce qui ajoute automatiquement les informations d'identification d'un service aux variables d'environnement de votre application ou de votre travail.

1. Créez une liaison pour le service Object Storage avec le préfixe COS pour en faciliter l'utilisation dans votre application. La commande bind crée des données d'identification de service dans l'instance de service, à partir de laquelle elle initialise les variables d'environnement de l'application avec les données d'identification. Chaque liaison de service peut être configurée pour utiliser un préfixe de variable d'environnement personnalisé à l'aide de l'indicateur --prefix.

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

2. Il vous faudra également indiquer à l'application le nom de votre compartiment où stocker les fichiers texte ainsi que votre noeud final COS. Ces deux éléments ont été définis dans une étape antérieure. Le noeud final pour us-south pour Smart tier est s3.direct.us-south.cloud-object-storage.appdomain.cloud.

   Définissez une carte de configuration qui contiendra le nom du seau et le point d'accès, car ces informations ne sont pas sensibles. Les mappes de configuration sont des objets Kubernetes qui vous permettent de découpler les artefacts de configuration à partir de contenu d'image pour assurer la portabilité des applications conteneurisées. Vous pouvez créer un objet configmap à partir d'un fichier ou à partir d'une paire clé-valeur -- pour l'instant nous allons utiliser une paire clé-valeur avec l'indicateur --from-literal. Vérifiez que vous avez capturé ces éléments précédemment et créez la mappe de configuration:

   echo bucket $COS_BUCKETNAME endpoint $COS_ENDPOINT
   

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

3. Une fois l'objet configmap défini, vous pouvez mettre à jour l'application de back-end en demandant à Code Engine de définir des variables d'environnement dans l'environnement d'exécution de l'application en fonction des valeurs figurant dans l'objet configmap. Mettez à jour l'application de back-end avec la commande suivante :

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

   Pour créer un secret, vous devez utiliser l'indicateur --env-from-secret. Les secrets et les objets configmap constituent des "mappes" ; ainsi, les variables d'environnement définies auront un nom correspondant à la "clé" de chaque entrée dans ces mappes et les valeurs des variables d'environnement correspondront à la valeur de cette "clé".

4. Pour vérifier si l'application de back-end est mise à jour avec la liaison et l'objet configmap, vous pouvez exécuter la commande ci-dessous et rechercher les sections Service Bindings et Environment Variables dans la sortie

   ibmcloud code-engine application get --name backend
   

5. Accédez à l'interface utilisateur de l'application de front-end et à la section de téléchargement des fichiers texte pour l'analyse de texte. Vous devriez voir les fichiers téléchargés avec l'indicateur Not analyzed sur ces fichiers.

Créer un travail

Contrairement aux applications qui réagissent aux requêtes HTTP entrantes, les jobs sont destinés à l'exécution d'images de conteneurs contenant un exécutable conçu pour s'exécuter une fois et se terminer ensuite. Lorsque vous créez un travail (job), vous pouvez spécifier les informations de configuration de la charge de travail qui sont utilisées chaque fois que le travail est exécuté. Vous pouvez créer un travail à partir de la console ou avec l'interface de ligne de commande.

Ce travail va lire les fichiers texte depuis IBM Cloud Object Storage, puis les analyser à l'aide du service Natural Language Understanding. Il devra avoir accès aux données d'identification du service pour ces deux services.

1. Exécutez la commande suivante pour créer un travail,

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

   Vous pouvez définir la version du service Natural Language Understanding à l'aide de l'indicateur --env. Pour en savoir plus sur la gestion des versions, consultez ce lien

Liaison des services IBM Cloud au travail

1. Passons maintenant à la création d'une liaison pour le service Object Storage avec le préfixe COS_JOB à utiliser avec les travaux pour lire les fichiers téléchargés et pour stocker les résultats.

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

2. De même, effectuons la liaison du service Natural Language Understanding avec le préfixe NLU_JOB pour analyser les fichiers texte téléchargée :

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

3. Pour vérifier si le travail est mis à jour avec la liaison et l'objet configmap, vous pouvez exécuter la commande ci-dessous et rechercher les sections Service Bindings et Environment Variables dans la sortie

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

Exécution du travail

1. Pour exécuter un travail avec la configuration créée ci-dessus, utilisez la commande jobrun submit,

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

   Lorsque vous exécutez un travail, vous pouvez remplacer un grand nombre de variables que vous avez définies dans la configuration du travail. Pour vérifier les variables, exécutez la commande ibmcloud code-engine jobrun submit --help.

2. Pour vérifier le statut d'exécution du travail (jobrun), exécutez la commande suivante :

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

3. Les journaux peuvent être affichés:

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

4. Dans l'interface utilisateur de l'application de front-end, cliquez sur le bouton d'actualisation (en regard de Upload text file) pour voir les mots clés et le code JSON de chaque fichier texte téléchargé. L'indicateur pour chaque fichier doit maintenant passer à Analyzed.

5. Téléchargez de nouveaux fichiers ou supprimez un fichier individuel en cliquant sur l'icône supprimer, soumettez à nouveau l'exécution du travail (jobrun) avec la commande ci-dessous et cliquez sur le bouton d'actualisation pour voir les résultats.

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

Automatisation de l'exécution du travail

Au lieu d'exécuter le travail manuellement, vous pouvez automatiser l'exécution du travail en créant un abonnement IBM Cloud Object Storage qui est à l'écoute des modifications dans un compartiment Object Storage. Lorsque vous créez un abonnement à un bac, votre tâche reçoit un événement distinct pour chaque modification réussie de ce bac.

1. Pour pouvoir créer un abonnement Object Storage, vous devez affecter le rôle Notifications Manager à Code Engine. En tant que gestionnaire de notifications, Code Engine peut afficher, modifier et supprimer des notifications pour un compartiment Object Storage. Suivez ces instructions pour affecter le rôle Gestionnaire de notifications à votre projet Code Engine.
2. Exécutez la commande ci-dessous pour connecter votre travail de back-end (backend-job) au producteur d'événement IBM Cloud Object Storage. Vérifiez et mettez à jour le fichier bucket name avant d'exécuter la commande.

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

3. A présent, transférez simplement les nouveaux fichiers et cliquez sur le bouton d'actualisation pour afficher les résultats. A l'avenir, vous n'aurez pas besoin de soumettre à nouveau l'exécution de travail car l'abonnement s'en occupera.