Despliegue de una aplicación frontal

1. Para desplegar una nueva aplicación Code Engine, ejecute el mandato siguiente; proporcionando un nombre de servicio frontend y la imagen de contenedor preconstruida como parámetro para el distintivo --image.

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

   Después de ejecutar este mandato, debería ver alguna salida con un URL para la aplicación. Se debería parecer a: https://frontend.305atabsd0w.us-south.codeengine.appdomain.cloud. Copie o anote la URL esta aplicación para el siguiente paso. Con sólo estos dos datos (nombre de la aplicación y nombre de la imagen), Code Engine ha desplegado tu aplicación y se encargará de las complejidades de configurarla y gestionarla por ti.

   El código fuente de la aplicación utilizado para crear las imágenes de contenedor está disponible en un repositorio de GitHub para su consulta. Si desea crear las imágenes de contenedor desde el código fuente y enviar las imágenes a un registro de contenedor privado, siga estas instrucciones.

2. Abra la URL la aplicación del paso anterior en un navegador para ver una salida similar a esta:

   

   Ejecute el mandato ibmcloud code-engine application get -n frontend para ver los detalles de la aplicación. Debería ver detalles como ID, información sobre el proyecto, antigüedad de la aplicación, URL para acceder a la aplicación, URL de consola para acceder a la configuración de la aplicación, imagen, asignación de recursos y diversas revisiones, condiciones y tiempo de ejecución correspondientes a la aplicación. Puesto que solo tiene una revisión, debería ver que el 100 % del tráfico va a la última revisión. También puede comprobar la cantidad de instancias y sus estados.

3. Para solucionar problemas y comprobar los registros de su aplicación, ejecute el siguiente comando sustituyendo <INSTANCE_NAME> por el nombre de una de las instancias del comando ibmcloud code-engine application get -n frontend.

   Si no ve ninguna instancia en ejecución, asegúrese de abrir de nuevo la URL la aplicación desde el paso 2.

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

   Si la aplicación se está ejecutando, debería ver backend URL: undefined y que la app está a la escucha en el puerto 8080. Más adelante, en la guía de aprendizaje, conectará esta aplicación frontal a nuestra aplicación de fondo

¡Enhorabuena! Acaba de desplegar una aplicación web en Code Engine con un sencillo mandato y sin necesidad de conocer los entresijos de Kubernetes, como pods, despliegues, servicios y entrada.

Escalado de la aplicación

Cuando ha creado la aplicación con el mandato application create, solo ha pasado la imagen que desea utilizar y un nombre para la aplicación. Si bien esta es la cantidad mínima de información para desplegar una aplicación, hay una serie de otros mandos sobre los que tienes control. Entre otros, puede definir el número de solicitudes que se pueden procesar simultáneamente por instancia, la cantidad de CPU para la instancia de la aplicación, la cantidad de memoria establecida para la instancia de la aplicación, las variables de entorno para la aplicación, el número máximo y mínimo de instancias que se pueden utilizar para esta aplicación y el puerto donde la aplicación escucha las solicitudes.

La mayoría de estos valores tienen un valor predeterminado si no se especifica nada como opción al crear la aplicación. Como no hemos especificado un valor, Code Engine ha desplegado nuestra aplicación con una escala máxima predeterminada de 10, lo que significa que solo escalará nuestra aplicación hasta 10 instancias. La escala mínima predeterminada es cero, de modo que, cuando nuestra aplicación ya no se utilice, se escalará de nuevo a cero.

1. Para comprobar las capacidades de autoescalado de Code Engine, podemos utilizar un generador de carga para realizar peticiones contra nuestro servicio. El siguiente script de shell simula una carga básica de 3000 solicitudes.

   1. Abra una ventana de terminal local (shell).

   2. Cree una variable shell para la URL la aplicación frontend del paso anterior.

      export APPURL=<frontend-application-url>
      

   3. Ejecute el script siguiente para generar alguna carga. Puede repetirlo para crear más tráfico.

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

2. En la sesión de Cloud Shell de las secciones anteriores, ejecute el mandato siguiente para ver el recuento de instancias (pod) que se incrementa como parte del escalado automático.

   ibmcloud code-engine application get -n frontend
   

   De forma predeterminada, el número máximo de solicitudes que se pueden procesar simultáneamente por instancia es 10, y este valor se puede modificar con el distintivo --concurrency or -cn con el mandato application update.

3. Si no desea permitir que se creen más de 10 instancias, puede ajustar la escala máxima para que sea un número inferior. Aunque su aplicación sin servidor se puede escalar fácilmente, es posible que dependa de un servicio en sentido descendente, como por ejemplo una base de datos SQL que solo pueda gestionar un número limitado de conexiones o una API con velocidad limitada. Intentaremos limitar el número de instancias para esta aplicación frontal.

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

4. Una vez que se ha detenido la generación de carga, espere unos minutos para ver que las instancias terminan y finalmente se reducen a cero.

5. En la ventana local con el mandato de generador de carga, vuelva a ejecutar el script para crear solicitudes en la app. En la sesión Cloud Shell, ejecuta el comando ibmcloud code-engine application get -n frontend para ver que el recuento de instancias aumenta a 5.

   Resultado esperado:

   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
   

Despliegue de una aplicación de fondo y prueba de la conexión

1. Para desplegar una nueva aplicación de fondo para almacenar los archivos de texto en IBM Cloud Object Storage, ejecute este mandato

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

   La bandera --cluster-local indicará a Code Engine que mantenga privado el endpoint de esta aplicación, lo que significa que sólo estará disponible desde dentro del proyecto. Esto se suele utilizar por motivos de seguridad. En este caso, no hay motivo para exponer la aplicación de fondo con un punto final público, ya que no se accederá a la misma desde fuera del clúster.

2. Copie y guarde el endpoint interno URL ) de la salida para utilizarlo en el siguiente comando. Será algo similar a lo siguiente:

   BACKEND_PRIVATE_URL=http://backend.xxxxxx
   

   Puede ejecutar el comando ibmcloud code-engine application get -n backend para comprobar el estado y los detalles de la aplicación backend que incluye la URL.

3. La aplicación frontal utiliza una variable de entorno (BACKEND_URL) para saber dónde está alojada la aplicación de fondo. Ahora debe actualizar la aplicación frontal para establecer este valor de modo que apunte al punto final de la aplicación de fondo.

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

   El distintivo --env puede aparecer tantas veces como desee si necesita establecer más de una variable de entorno. Esta opción también se podría haber utilizado en el mandato ibmcloud code-engine application create para la aplicación frontal si conocía su valor en ese momento. Para obtener más información, consulte el tema de la documentación Trabajar con variables de entorno.

4. Renueve el URL frontal en el navegador para probar la conexión con la aplicación de fondo. Debería ver una página con una opción para cargar un archivo de texto (.txt) y también un mensaje de error de la aplicación de fondo, ya que el programa de fondo todavía no está conectado a los servicios de IBM Cloud necesarios para almacenar y procesar los archivos de texto. Si pulsa Cargar archivo de texto, se debería mostrar un mensaje de error parecido.

Suministro de servicios de Object Storage y Natural Language Understanding

1. Cree una instancia de Object Storage

   1. Seleccione el plan Lite o el plan Estándar si ya tiene una instancia del servicio Object Storage en su cuenta.
   2. Establezca Nombre de servicio en your-initials-code-engine-cos.
   3. Seleccione el grupo de recursos donde ha creado el proyecto Code Engine.
   4. Pulse Crear.
   5. Capture el nombre de servicio en una variable de shell:

      COS_INSTANCE_NAME=your-initials-code-engine-cos
      

2. En Crear grupo, pulse Crear grupo y, a continuación, en Crear un grupo personalizado seleccione Crear.

   Cuando cree cubos o añada objetos, asegúrese de evitar el uso de Información de Identificación Personal (IIP).Nota: La IIP es información que puede identificar a cualquier usuario (persona física) por su nombre, ubicación o cualquier otro medio.

   1. Especifique Nombre de grupo exclusivo como, por ejemplo, <your-initials>-bucket-code-engine.
   2. Seleccione una Ubicación, donde creó el proyecto Code Engine.
   3. Seleccione la clase de almacenamiento Smart Tier.
   4. Pulse Crear grupo.
   5. Capture el nombre de grupo en una variable de shell:

      COS_BUCKETNAME=your-initials-bucket-code-engine
      

3. En la página de grupo.

   1. Haga clic en la pestaña Configuración
   2. El punto final Directo mantendrá los datos en IBM Cloud. Capturar el punto final directo en una variable de shell. En la región de Dallas, EE.UU.-Sur, podría ser:

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

4. Cree una instancia de Natural Language Understanding

   1. Seleccione una ubicación y seleccione el plan Lite.
   2. Establezca el Nombre de servicio en code-engine-nlu y seleccione el grupo de recursos en el que ha creado el proyecto Code Engine.
   3. Lea el acuerdo de licencia y, a continuación, seleccione He leído y acepto los siguientes acuerdos de licencia:.
   4. Pulse Crear.
   5. Capture el nombre de servicio en una variable de shell:

      NLU_INSTANCE_NAME=YourServiceName
      

Enlace del servicio Object Storage con la aplicación de fondo

Ahora, tendrá que pasar las credenciales para la instancia de IBM Cloud Object Storage que acaba de crear a la aplicación de fondo. Para ello, vincule el servicio Object Storage a su aplicación, que añade automáticamente las credenciales de un servicio a las variables de entorno de su aplicación o trabajo.

1. Cree un enlace para el servicio Object Storage con el prefijo COS para facilitar su uso en la aplicación. El mandato bind crea una credencial de servicio en la instancia de servicio y a partir de ella inicializa las variables de entorno de la aplicación con las credenciales. Cada enlace de servicio puede configurarse para utilizar un prefijo de variable de entorno personalizado utilizando la bandera --prefix.

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

2. También deberá proporcionar a la aplicación el nombre del grupo en el que desea almacenar los archivos de texto, así como el punto final de COS. Ambos se definieron en un paso anterior. El punto final para us-south para Smart tier es s3.direct.us-south.cloud-object-storage.appdomain.cloud.

   Define un configmap para contener el nombre del cubo y el endpoint ya que la información no es sensible. Los mapas de configuración (ConfigMaps) son objetos de Kubernetes que le permiten desacoplar artefactos de configuración del contenido de la imagen para mantener la portabilidad de las aplicaciones en contenedores. Puede crear este mapa de configuración a partir de un archivo o de un par de clave y valor; por ahora utilizaremos un par de clave y valor con el distintivo --from-literal. Verifique que los ha capturado anteriormente y cree el mapa de configuración:

   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. Con el mapa de configuración definido, ahora puede actualizar la aplicación de fondo solicitando a Code Engine que establezca variables de entorno en el tiempo de ejecución de la aplicación en función de los valores del mapa de configuración. Actualice la aplicación de fondo con el mandato siguiente

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

   Para crear un secreto, deberá utilizar el distintivo --env-from-secret. Tanto los secretos como los mapas de configuración son "mapas", por lo que el conjunto de variables de entorno tendrá un nombre correspondiente a la "clave" de cada entrada de estos mapas y los valores de las variables de entorno serán el valor de esa "clave".

4. Para verificar si la aplicación de fondo se actualiza con el enlace y el mapa de configuración, puede ejecutar el mandato siguiente y buscar las secciones Service Bindings y Environment Variables en la salida

   ibmcloud code-engine application get --name backend
   

5. Vaya a la interfaz de usuario frontal y cargue archivos de texto para realizar un análisis de texto. Debería ver los archivos cargados con la etiqueta Not analyzed.

Crear un trabajo

Los trabajos, a diferencia de las aplicaciones que reaccionan a las peticiones HTTP entrantes, están pensados para ser utilizados para ejecutar imágenes de contenedores que contienen un ejecutable diseñado para ejecutarse una vez y luego salir. Cuando crea un job, puede especificar la información de configuración de carga de trabajo que se utiliza cada vez que se ejecuta el trabajo. Puede crear un trabajo desde la consola o con la CLI.

Este trabajo leerá los archivos de texto de IBM Cloud Object Storage y luego los analizará mediante el servicio Natural Language Understanding. Tendrá que tener acceso a las credenciales de servicio para ambos servicios.

1. Ejecute el siguiente comando para crear un trabajo,

   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
   

   Puede establecer la versión del servicio Natural Language Understanding con el distintivo --env. Para seleccionar la versión, consulte este enlace

Enlace del servicio IBM Cloud con el trabajo

1. Vamos a crear un enlace para el servicio Object Storage con un prefijo COS_JOB que se utilizará con los trabajos para leer los archivos cargados y almacenar los resultados.

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

2. De forma similar, vamos a enlazar el servicio Natural Language Understanding a un prefijo NLU_JOB para analizar los archivos de texto cargados.

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

3. Para verificar si el trabajo se actualiza con el enlace y el mapa de configuración, puede ejecutar el mandato siguiente y buscar las secciones Service Bindings y Environment Variables en la salida

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

Ejecutar el trabajo

1. Para ejecutar un trabajo con la configuración creada anteriormente, utilice el comando jobrun submit,

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

   Cuando ejecute un trabajo, puede modificar muchas de las variables que ha establecido en la configuración del trabajo. Para comprobar las variables, ejecute ibmcloud code-engine jobrun submit --help.

2. Para comprobar el estado de jobrun, ejecute el mandato siguiente

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

3. Los registros se pueden visualizar:

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

4. En la interfaz de usuario frontal, pulse el botón Renovar (junto Cargar archivo de texto) para ver las Palabras clave y JSON de cada archivo de texto cargado. La etiqueta de cada archivo debería cambiar a Analyzed.

5. Cargue archivos nuevos o suprima un archivo individual pulsando el icono Suprimir; vuelva a enviar jobrun con el mandato siguiente y pulse el botón Renovar para ver los resultados.

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

Automatización de la ejecución del trabajo

En lugar de ejecutar el trabajo manualmente, puede automatizar la ejecución del trabajo creando una suscripción de IBM Cloud Object Storage que escucha los cambios en un grupo de Object Storage. Cuando se crea una suscripción a un bucket, el trabajo recibe un evento independiente por cada cambio realizado con éxito en ese bucket.

1. Para poder crear una suscripción de Object Storage suscripción, debe asignar el rol de Notifications Manager a Code Engine. Como Gestor de notificaciones, Code Engine puede ver, modificar y suprimir notificaciones para un grupo de Object Storage. Siga estas instrucciones para asignar el rol de gestor de notificaciones al proyecto Code Engine.
2. Ejecute el mandato siguiente para conectar el backend-job al generador de sucesos de IBM Cloud Object Storage. Compruebe y actualice el bucket name antes de ejecutar el mandato

   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. Ahora, simplemente cargue archivos nuevos y pulse el botón renovar para ver los resultados. A partir de ahora, no tiene que volver a enviar jobrun porque la suscripción se hace cargo.