GraphQL Declarativo en una Puerta de Enlace Nativa en la Nube

Hola a todos. Así que sobre mí, soy un especialista en soporte técnico en solo, y me uní recientemente hace un mes aproximadamente. Tengo experiencia en DevOps y administración de Linux. Y sí, esto es esto. Esto es algo completamente nuevo para mí.

Kubernetes y todas estas cosas nativas de la nube, pero estoy aprendiendo a medida que avanzo. Entonces, cuando abras el enlace, se te mostrará este tipo de página y simplemente puedes hacer clic en esto. Una vez que hagas clic en la opción de iniciar el seguimiento, tomará alrededor de dos minutos para crear el entorno. Y mientras tanto, puedes ver el video que tiene una descripción general de GraphQL.

Entonces, ¿qué es exactamente GraphQL? Entonces GraphQL es como un lenguaje de consulta de esquema. Si has oído hablar de SQL, el famoso SQL database, MySQL, PostgreSQL. Es algo similar. Pero esta vez es para las API REST. Entonces tienes un montón de API REST. Sabes, la mayoría de las veces tienes que consultar una y luego obtienes mucha información de ella y tienes que filtrar la información de ella. Esto puede volverse un poco engorroso considerando que, por ejemplo, solo quieres el nombre de un usuario, pero debido a que REST es REST, obtienes un montón de detalles como sus números de teléfono y otros detalles como la dirección, etc. Y luego tienes que filtrarlo. Esto provoca llamadas innecesarias. Y si tienes, digamos, un carrito de compras o algo así o alguna consulta de compra, como sabes, hacer múltiples llamadas a la API REST solo para obtener un poco de data, entonces, ya sabes, en esos términos, REST se vuelve un poco engorroso. Y tienes que hacer múltiples llamadas solo para obtener información del backend. Mientras que en GraphQL, lo que sucede es que tienes un servidor en el backend. Y este servidor es como, una especie de Uber para tu, Uber chat podríamos decir, para tu aplicación. Y simplemente le dices al servidor en un lenguaje de definición de esquema, qué es exactamente lo que quieres y cómo lo quieres. Por ejemplo, si tienes una aplicación de tienda de mascotas y, ya sabes, tienes una mascota y tienes una tienda. Entonces, si quieres tener los nombres de las mascotas, todos los nombres de las mascotas en la tienda, simplemente puedes decirle a graphql, dame eso y graphql te dará solo eso. Obtienes lo que pides básicamente, y no todo el ruido que es innecesario y no necesario.

Bueno, un poco sobre Instruct. Esta es una masterclass autónoma. Todo lo que necesitas está dentro de esta masterclass, no tienes que cambiar a tu máquina local ni nada por el estilo, puedes ejecutar todo en este laboratorio dentro de este navegador web, tendrás estos botones de interfaz de usuario en los que puedes hacer clic a veces, en caso de que no se carguen o algo así, así como el botón de actualización aquí en el lado derecho, verás esta barra que se puede redimensionar en caso de que el texto sea demasiado pequeño. Así que puedes revisar los detalles que proporciona la masterclass que te dará una visión general básica de qué es GraphQL y cómo funciona y todo.

Es muy útil en términos de microservicios, donde tienes múltiples API REST. Tenemos un producto llamado BlueEdge, que es una especie de punto de entrada a tu aplicación. Es como una puerta de enlace de API, digamos, y todo pasa por ahí. Hemos integrado GraphQL dentro de este producto. Así que tiene su propio. No hay un servidor GraphQL separado que se esté ejecutando o algo así. Cuando normalmente implementas GraphQL, tienes que implementarlo con el servidor. Mayormente hay un GraphQL de Apollo y hay varios servidores disponibles que puedes implementar y usar. Pero lo hemos integrado dentro de nuestro producto. Además, esta es una característica empresarial. Por lo tanto, la versión de código abierto no tiene esto. En caso de que desees probarlo, siempre puedes contactarnos a nosotros o a mí y te ayudaremos con una licencia de prueba que puedes usar para probar esto y realizar tus pruebas en eso.

Entonces, sí, comencemos. Primero, comenzaremos por instalar BlueEdge. Puedes simplemente copiar los comandos a la derecha y presionar Shift e Insertar. Y se copiarán los comandos en la pantalla. No necesitas copiar y pegar usando el clic derecho. Puedes hacerlo directamente con el teclado.

Una característica que ofrecemos es la generación automática de esquemas. Para aquellos que saben, aquellos que no saben, o aquellos que saben, GraphQL es como un lenguaje de esquema, ¿verdad? Debes definir un esquema para tus APIs. Y le das ese esquema al servidor GraphQL, y le dices que así es como es mi esquema de GraphQL. Cuando los usuarios hacen consultas, hay un tipo especial de consulta en GraphQL que los usuarios pueden obtener, y hay mutaciones. Estos dos son tipos muy especiales en GraphQL. Por lo general, consultas el tipo de consulta mute. Y dentro de eso defines todas tus estructuras de datos y tus tipos, básicamente, y funciones. Un poco sobre las mutaciones, las mutaciones son algo así como, ya sabes, tu CRUD, donde puedes actualizar, eliminar y crear, ya sabes, consultas, pero usando GraphQL y el tipo de consulta es como un punto de entrada a tu servidor GraphQL, básicamente, o tu backend de GraphQL. El tipo de entrada es donde se define todo. Defines tus tipos, los datos a los que tu cliente puede acceder básicamente, y también puedes tener funciones como tal. También puedes tener varios tipos de entrada.

Ahora hemos instalado glue edge en el clúster. Y si ves, si ejecutas este comando, básicamente podrás ver todas las implementaciones que están ocurriendo. Glue edge se instala en un espacio de nombres llamado sistema de pegamento. Entonces, si ejecutas, kube cut obtendrá los pods en él, podrás ver todos los pods que están en este espacio de nombres y puedes ver que todos están en ejecución ahora. Ahora desplegaremos la aplicación de demostración. Todos los archivos requeridos para esta masterclass están dentro de este módulo de instrucciones en sí. Así que no necesitas copiar y pegar desde ningún otro lugar. En caso de que alguien tenga alguna consulta, siempre puedes publicarla en el chat. No estoy seguro si alguien está usando la sección de preguntas y respuestas. Pero estoy atento al chat, así que en caso de que surja alguna consulta, puedo responderla. Hemos desplegado la aplicación de demostración y podemos verificar si todos están siguiendo que ahora hemos desplegado la aplicación de demostración y simplemente probaremos la API REST. Estas son API REST básicamente, y simplemente crearemos una. Entonces, en Blue, para que cualquier cosa entre en el sistema, creamos algo conocido como un servicio virtual.

Si alguien ha implementado aplicaciones de Apache o ha oído hablar del host virtual, esto es algo similar. Así que crearemos este servicio virtual. También podemos ver su contenido. Puedes ver que hemos establecido un prefijo. Entonces, cada vez que las consultas lleguen con una URL que tenga el prefijo blocks. Las dirigiremos al servidor ascendente. En este caso, el servidor ascendente es un servidor backend o un servicio backend básicamente que está en el sistema blue. Podemos hacer clic en esto y verás que obtuvimos la dirección de la especificación JSON de este servicio. Y hemos realizado una solicitud de llamada a él. Puedes ver los datos que se muestran: ID, usuario, nombre de usuario, título, contenido. Puedes ver que hay muchas cosas escritas. Y en caso de que solo quisiera el ID, probablemente tendría que crear otra ruta que diga dame slash ID o dame slash usuario, algo así como obtener usuario, obtener ID. Y esto es como información adicional, veamos cómo GraphQL resuelve este problema.

Ahora expondremos una interfaz de Glue Edge, por lo que tenemos una interfaz que viene con Glue y también puedes ver todo en esta interfaz. Es como una interfaz de solo lectura. En caso de que muestre una página en blanco, simplemente actualiza y podrás ver esta interfaz. Entonces, si vas aquí, puedes ver que hay diferentes servicios virtuales. Por ejemplo, el que creamos ahora mismo, puedes ver los diferentes servidores ascendentes que tenemos. Hemos implementado estos servidores ascendentes. Glue crea automáticamente servidores ascendentes a partir de los servicios que implementas. No necesitas crear manualmente ningún servicio. Glue se encargará automáticamente de eso. También tenemos gluectl. Parece que no está instalado en este momento. Tenemos generación automática de esquemas para los servicios GRPC y REST. Todo lo que tienes que hacer es etiquetar el servicio y Glue lo recogerá automáticamente y generará el esquema a partir de él. Como puedes ver, no se han creado objetos CRD de la API GraphQL en este momento.

Lo que haremos ahora es etiquetar los bloques de servicio. Así que ahora hemos etiquetado un bloque de servicio. Y en unos segundos, veremos que esto ha sido generado. Así que también puedes verificar qué esquema se genera en caso de que esto no sea lo que deseas, siempre puedes editar el esquema.

Así que puedes ver que se han generado muchas cosas. Así que vamos paso a paso. Tenemos algo llamado un esquema ejecutable en GraphQL. Ahí es donde se genera tu esquema. Tenemos algo llamado funciones resolutoras.

En este caso, estamos utilizando un resolvedor REST. Así que esta es la API REST. Estamos utilizando el resolvedor REST. En caso de que sea un servicio gRPC, entonces tendrás un resolvedor gRPC. Así que le damos este nombre, como una lata, es como un alias básicamente, solo te dice qué tipo de API REST es esta, como una mutación. Si recuerdas, las mutaciones son básicamente CRUD. Puedes crear, leer, actualizar y eliminar con ellas.

Esto es para publicar bloques. Así que también puedes, ya sabes, formar el esquema generado. Observa que tenemos estos argumentos. Estos se envían a la API REST desde GraphQL. Así que no necesitamos pasarlos, porque se enviarán automáticamente, siempre que proporciones esta entrada. Esto es un tipo POST y también tenemos una consulta GET aquí, donde puedes obtener todos los bloques, básicamente. Y el servidor ascendente que está aquí es el backend. Así que este es un backend REST en la línea de base. Y si te fijas aquí, tenemos algo llamado una definición de esquema. Esta definición de esquema es la definición de esquema GraphQL. El enlace que compartí antes, este es el esquema que le das a GraphQL y te permitirá realizar consultas en él. Así que si te fijas aquí, hay una entrada. Esto es una entrada. Los usuarios pueden pasar estas entradas.

El contenido es un tipo de cadena. El ID es un tipo entero. Y el título es un tipo de cadena. Y si te fijas, el usuario es otra entrada. Entonces, si te fijas a continuación, se llama entrada de usuario y es un nombre de usuario. Así que este es un tipo personalizado, podrías decir. Tipo de datos personalizado, básicamente. Y también tenemos una mutación, donde puedes publicar registros utilizando esto como entrada de blog. Y si te fijas aquí, hay algo llamado nombre de resolución, y apunta a este alias. Y este alias se encuentra aquí. Así es como, en caso de que te preguntes cómo GraphQL sabe a qué API REST acceder. En caso de que requiera algún data, así es como lo hace.

Y esto también, estos son dos tipos especiales. Uno es mutación, el otro es consulta. La consulta es tu punto de entrada. Siempre que escribas una consulta, debes escribir esto y obtendrás los data. Y esto se resuelve a esta función get. Luego tenemos un bloque de tipo y un tipo de usuario que se ha definido dentro de él. Entonces, cuando consultas get blocks, esto es lo que puedes obtener de eso.

Y todo esto también, en caso de que lo que he explicado sea un poco confuso. Esto también se explica en el lado derecho dentro de este instructor. Y si vas a tu interfaz de Blue Edge, puedes jugar y ver... Hemos inspeccionado esta especificación de GraphQL para ti y puedes ver todas las entradas generadas y los resolutores aquí. También podemos ver la configuración en bruto. Y también puedes... También hay un campo de gráfico, como un explorador de GraphQL que ahora expondremos en los próximos pasos.

Así que creemos ahora un servicio virtual para, como, generaremos un servicio virtual con un punto final de GraphQL. Así puedes hacer consultas y obtener tus respuestas de él. Hemos creado un servicio virtual ahora. Con ok, get vs. Puedes ver que hemos creado este servicio virtual predeterminado. Para consultar el punto final de GraphQL, debes usar este comando aquí que te dará una URL. Así que debes copiar esta URL. Será única para cada persona. Así que copia esto y ve a, ve a este explorador de GraphQL. Así que si quieres ver dónde está, puedes ir a la interfaz principal, hacer clic en APIs. En la sección de GraphQL, deberías ver este blog predeterminado. Haz clic en Explorar. Haz clic en Mostrar barra de URL. Y simplemente reemplázalo con esto, la URL que obtuviste aquí cuando ejecutaste este comando echo. Y ahora, si ejecutas esto, no mostrará nada. Solo te dará un error.

Entonces actualmente nada. Así que intentemos una consulta de ejemplo. En el lado derecho, tendrás una consulta de GraphQL aquí. Pega esto, obtendrás esta consulta, myQuery. Y si la ejecutas, obtendrás las respuestas. Así que si te fijas, obtuvimos lo que pedimos. Por ejemplo, ejecutamos una función llamada get logs y queríamos el contenido, solo queríamos el ID y dentro del usuario, solo queríamos el nombre de usuario. Así que obtuvimos la misma respuesta que pedimos. Así que obtienes lo que solicitaste en GraphQL y cómo lo quieres es de la misma manera que lo pediste. Así que es una declaración muy implícita, no hay conjeturas sobre cómo vendrán tus datos. ¿Vendrá el usuario antes del ID o vendrá el ID en la parte superior? Sin embargo, pidas los datos, de esa manera es como GraphQL te los devuelve. Así que ya no más, si has usado Python, hay diccionarios que antes eran desordenados. Así que solía convertirse en un gran problema como este donde no tienes el orden del diccionario, pero ahora es mucho mejor, supongo, hay diccionarios ordenados en Python. Así que es algo similar a eso.

Uno de los desafíos más frecuentes en REST es la agregación de datos. Cuando tienes que obtener datos. Ok, como mencioné antes, hay un caso de uso muy particular para GraphQL cuando se trata de agregación. La agregación ocurre cuando tienes múltiples APIs REST, pero quieres que tu consulta sea devuelta en una sola respuesta básicamente. Por lo tanto, GraphQL es muy útil cuando tienes aplicaciones móviles o cualquier otra cosa similar, porque solo tendrás un punto final, como una sola consulta que debes realizar. Y sabes que el backend, que son tus servidores potentes que se ejecutan en centros de datos, se encargarán de hacer el trabajo pesado para resolver y obtener todos los datos. Por lo tanto, no tienes que depender de la red del usuario o de su teléfono móvil y qué tan moderno o antiguo es. Solo tienes que llamar a la API REST y obtener los datos.

Entonces, la agregación es esta cosa donde, por ejemplo, si tengo tres APIs REST y tengo que obtener data que está relacionada con las tres, pero no quiero hacer llamadas a las tres APIs REST. Ahí es donde puedo simplemente agregarlas en una sola consulta y puedo obtener la respuesta.

Así que comencemos con esta tercera sección. Como dije antes, tenemos generación automática de esquemas. Pero ya sabes, siempre hay casos especiales o momentos en los que quieres tener tu propio esquema, así que eso también es compatible. Si te fijas, hay una pestaña de configuración aquí. Si abres esta pestaña, puedes ir a este archivo llamado gql1-gql.yaml, y todo esto ya está creado aquí para ti.

Así que aquí tenemos dos resolutores. Ambos son resolutores REST. Uno obtendrá los bloques para ti, se obtendrán todos los bloques, y otro obtendrá los comentarios de estas publicaciones de bloques. Y te das cuenta de que hay un ID de bloque que se da aquí con parent.id. Así que si te fijas aquí, tenemos esta cosa llamada comentarios. Y ahora, como sabes, un bloque puede tener varios comentarios, ¿verdad? Así que aquí tenemos una relación de uno a muchos definida, y esta cosa alrededor de este comentario, se llama lista. Si te fijas en esta definición de esquema, hay un tipo de bloque, ¿de acuerdo? Y te darás cuenta de que los comentarios están en este formato de lista, ¿de acuerdo? Y al lado, lo hemos resuelto para obtener comentarios, que se define aquí arriba, ¿de acuerdo?

Así que si lo resaltas, verás que esto se resuelve desde esta API REST. Ahora, lo que tenemos aquí es una relación de uno a muchos, como un bloque puede tener muchos comentarios, ¿verdad? Así que si tuvieras una API REST, probablemente tendrías que consultar primero los bloques, ¿de acuerdo? Luego, dentro de eso, tendrías que obtener todos los IDs de allí, y luego tendrías que enviar eso a los comentarios para obtener todas las respuestas, ¿verdad? Entonces, en GraphQL, solo defines el esquema. Dices que quiero el ID, el usuario, el título del contenido y los comentarios. Y el comentario es un tipo de comentario. Así que dentro de los comentarios, tienes estos campos, es el ID, usuario, comentarios. Entonces puedes solicitarle a GraphQL, por ejemplo, si solo quieres el ID del comentario, o si solo quieres un usuario de comentario que haya comentado esto, quieres obtener el número de comentarios o algo así, ¿verdad? Y también tienes un tipo de usuario que tiene un nombre de usuario, ¿de acuerdo? Así que todo lo que estoy explicando también está en el lado derecho, en caso de que sea un poco difícil entender algo, siempre puedes consultar el lado derecho.

Así que una vez que hayamos pasado por esto, en caso de que algo sea confuso, siempre puedes publicarlo en el cuadro de comentarios. No estoy seguro de si todos están usando la sección de preguntas y respuestas. Muy bien, y esta es la consulta. Entonces este es el tipo de consulta, básicamente este es tu punto de entrada. Así que lo aplicaremos ahora. Deberías obtener esta cosa que dice API GraphQL creada. Ahora, si obtienes la API GraphQL, deberíamos ver un nuevo blogs-graphql-definido. Y si te fijas, esto es lo que hemos enviado básicamente a GraphQL. Hemos definido nuestra propia API GraphQL. Ahora que hemos definido nuestra API GraphQL, vamos a definir el servicio virtual para ella. Como mencioné, todo tu servicio virtual es como un punto de entrada, o si quieres pensarlo en términos de Apache, es como un host virtual donde le dices qué URL, qué prefijo, etc.

Y puedes dar un punto de entrada a tu upstream. Upstream en este sentido son tus servicios backend. Puedes ver que este servicio virtual ha sido configurado. Si quieres, también puedes verificar lo que hay en este servicio virtual. Puedes ver que hemos definido esta referencia de API GraphQL, que apunta a los blogs-graphql que definimos anteriormente. Así es como mapeamos la API GraphQL al servicio virtual.

Y te darás cuenta de que solo tenemos un punto final singular para GraphQL. Ahora que tenemos esto, podemos volver a la interfaz de usuario de BlueEdge. Ir a la sección de API, y en caso de que no tengas solo una URL, tienes este comando que se muestra justo debajo. Y puedes obtener esta URL nuevamente. Solo tienes que hacer clic en blog-graphql-graph. Y luego ir a la sección de exploración. Y si ejecutas esto, aún obtendrás los blogs, pero cambiemos la consulta.

No admitimos la generación automática de GraphQL a partir de Soap, pero puedes convertir tu Soap a REST y luego generar un esquema utilizando REST. Así que tenemos una forma de convertir Soap a REST API básicamente. Ahora tenemos una consulta mucho más grande. Así que antes de ejecutarla, vamos a revisarla y ver qué está sucediendo exactamente. Porque no debería ser así, ejecutas algo y solo ves la salida. Así que vamos a revisarla. Te darás cuenta de que este get blogs es lo que tenemos en nuestro tipo de consulta. Si subes aquí, te darás cuenta de que este get blogs es lo que tenemos en nuestra consulta, y es del tipo blog. Así que en el blog tenemos ID, tenemos usuario, tenemos contenido, tenemos título y tenemos comentarios, que es a su vez un tipo de comentario. Así que ves, está agregando diferentes API en este momento. Así que podemos solicitar lo que queramos. Si ejecuto esto, y aquí cada vez que damos algo, simplemente le decimos que quiero comentarios. Y en los comentarios solo quiero el ID básicamente. Hemos dado todos los comentarios. Todo en el comentario vendrá aquí, el ID y el usuario. Y en el contenido tenemos el ID, el usuario y el comentario. Así que ahora del usuario solo tenemos el nombre de usuario, ¿verdad? Intentemos hacer algo más.

Entonces, si eliminamos este ID, dentro de los comentarios hemos eliminado el ID de allí. Así que te das cuenta de que no tenemos el número de ID, ¿verdad? ¿Correcto? De manera similar, tienes una estructura anidada básicamente. Así que, como puedes ver, solo le hemos dicho a GraphQL que simplemente me dé estos datos y eso es todo lo que quiero.

Entonces, si elimino este bloque de comentarios, todo este bloque de comentarios, Por ejemplo, puedo eliminar el bloque de usuario. Lo ejecuto. No tendré un bloque de usuario dos veces. Así que ves que no tenemos los datos, pero tenemos los datos restantes que necesitamos, ¿verdad? Así que básicamente obtienes lo que pides. No obtienes ningún dato adicional. No obtienes menos datos. Obtienes la cantidad que se requiere y la cantidad que solicitaste básicamente.

Así que todos están conmigo en esto, ¿hay algo confuso o algo así? ¿Es emocionante? Algo que puedas decirme, quiero decir, incluso yo sé, como, no estás siguiendo, ¿verdad? Una vez. Dos veces. De acuerdo, así que sigamos adelante. Así que todos han visto que obtienen una respuesta JSON de esto. Ahora básicamente extraeremos múltiples esquemas de GraphQL. Los que tienes ahora mismo, múltiples fuentes REST, ahora combinaremos múltiples esquemas de GraphQL, se llama unión de esquemas. Así que uniremos múltiples esquemas de GraphQL en un solo esquema y llamaremos al esquema más pequeño sub-esquemas. Así que veremos eso en la próxima sección. Así que crearemos un supergráfico ahora, que será una combinación de múltiples gráficos. Veamos cómo se hace esto en la demostración.

Así que implementarás un servicio llamado usuarios y una API preexistente de GraphQL. Así que tenemos un Resolver llamado obtener-detalles-usuario, que integraremos con nuestros servicios de blog y comentarios. Si ves, tenemos esta API de GraphQL definida aquí. Tenemos un upstream remoto básicamente. Y hemos definido un esquema aquí. En esto, tenemos un tipo de usuario Y tenemos un tipo de consulta. Este es el punto de entrada. Tenemos obtener-detalles-usuario y toma un nombre de usuario, que está en formato de cadena. Así que te das cuenta de que ahora hemos dado un filtro clasificador.

Entonces, damos get-user-details un nombre de usuario, y nos dará los detalles de ese usuario. Qué tipo de detalles nos dará es este tipo de usuario. Así que si te fijas aquí arriba, este tipo está definido con ID, nombre de usuario, apellido y nombre. Y si te fijas aquí, hay un signo de exclamación después de esta cadena. Esto significa que es requerido. Así que tendrás que proporcionar este nombre de usuario como entrada a esta función básicamente. Sin eso, obtendrás un error. Así que apliquemos esto.

De acuerdo. Entonces te darás cuenta de que tenemos un, tenemos algo llamado un ejecutor remoto. Así que primero veamos qué es. De acuerdo. Oh. Aparte del espacio de nombres. Así que les daremos un espacio de nombres. Tenemos un nombre de servicio llamado usuarios. Básicamente, este es el servicio que es la API. Y si te fijas, no hemos dado ningún tipo de resolutor REST o algo como eso. Solo hemos referenciado este upstream que se menciona aquí. Así que puedes ver que esto es solo una sugerencia normal como una API normal y no hemos dado ningún URL o algo así. Es solo un servicio normal de Kubernetes. Así que ahora crearemos esto, creamos una API GraphQL para esto. Así que hemos creado una API GraphQL. Si haces clic aquí, verás la siguiente sección sobre el esquema. Esto es una consulta remota y esto es la unión de esquemas. Así que si vamos aquí, vemos las API y vemos los usuarios remotos de GraphQL, tenemos obtener detalles de usuario, así que aún no hemos creado un servicio virtual. Así que si te fijas aquí, tenemos, podemos ver todas estas definiciones que se crean en la API GraphQL. Así que sigamos adelante y ahora uniremos estos esquemas. Así que luego podremos obtener una salida unificada básicamente.

Veamos este esquema de API GraphQL que se llama un esquema de fusión. Ahora estamos uniendo esquemas, no estamos creando ninguna definición de esquema aquí. Estamos uniendo esquemas existentes en uno y lo que estamos haciendo aquí es decir una especie de forma de fusionar básicamente. Y se llama fusión de tipos en GraphQL. Y lo que podemos hacer es fusionarlo en el campo que se llama nombre de usuario y la consulta. Hemos dado el nombre de usuario como campo y hemos dado los argumentos, por lo que enviaremos el argumento de nombre de usuario y fusionará tanto este remoto como los blogs en un supergráfico básicamente. Así que tendrás solo un punto final de GraphQL, pero podrás realizar consultas a ambos utilizando el nombre de usuario.

Así que apliquemos también esta unión de esquemas. Hemos aplicado la unión de esquemas. Ahora actualizaremos el servicio virtual. Ahora hemos actualizado nuestro servicio virtual para exponer el punto final. Básicamente, notarás aquí que hemos dado una referencia de API de GraphQL al esquema unido que es una combinación de todos los esquemas generados y que hemos definido anteriormente.

Ahora volvamos al sistema Glue, básicamente a la interfaz de Glue Edge. Y vayamos a la API. Notarás que tenemos un GQL unido aquí. Y notarás que tenemos subgráficos. Estas son las API de GraphQL por sí mismas. Estas son ambas API de GraphQL. Y las hemos combinado en esta única API unida, API de GraphQL unida. Y también puedes ver todas estas, ya sabes, están fusionadas básicamente, y puedes ver cómo Entonces, Ruffles está preguntando, ¿este esquema puede compartir tipos comunes? ¿Estás diciendo que si hubiera dos tipos de blogs, como en ambos esquemas, están diciendo eso? Entonces, si ese es el caso, se fusionan. Es como una fusión... También se fusionan los tipos. Sí. Entonces, en este caso, ambos tipos se fusionarán y se fusionarán en un solo tipo con todos los campos. Entonces, debes especificar la configuración de fusión y mediante eso, generalmente se fusiona. Entonces, en caso de que tengas relaciones de clave externa, puedes especificar la configuración de fusión y luego se fusionará en consecuencia. Entonces, sí, sigamos adelante.

Ahora tenemos una consulta, y notarás que tenemos algo llamado obtener blogs. Y también tenemos otra función llamada obtener detalles de usuario. Pero solo tenemos obtener blogs aquí. Y verás cómo se combinan todos juntos. Así que ejecutemos nuestra consulta. Ejecutamos una consulta obtener blog, pedimos los comentarios. En el comentario, pedimos el comentario real, el id. Y también queríamos un usuario. Entonces, tenemos el usuario, nuevo nombre apellido. Ahora, si ves aquí, el blog tiene un tipo de usuario, ¿verdad? Y el usuario está definido aquí.

Entonces, te das cuenta de que ambos están fusionados, ¿verdad, basado en el usuario? Entonces, tenemos un supergrafo único en este caso. ¿Todos están conmigo hasta aquí? Que puedes ver tu. Devuelve los detalles del usuario. Devuelve un nombre de usuario.

Bien, entonces sigamos adelante, como cualquier otra API. También debes asegurar, tus APIs de GraphQL. Veamos cómo podemos hacerlo. Con Blue Edge tenemos algo conocido como autenticación externa o autenticación extendida donde puedes integrar OIDC, OPA, LDAP, autenticación básica y claves de API.

Bien, vamos a crear una clave de API. Y aseguraremos la API utilizando esta clave básicamente. Así que creemos una clave. Este es el valor real de la clave. Se almacena en base 64. Abres esto y verás esta clave que está ahí. Pero una vez que. Una vez que lo abras, no podrás acceder a él. Lo ves. Ya está codificado en base 64, así que ahora tenemos que crear algo llamado una configuración de autenticación. Este es el mecanismo que Glue utiliza para proteger entre el backend y tus aplicaciones. Así es como creas una configuración de autenticación. Vamos a usar API key alt en esto. Disculpa por eso. Puedes ver este comando aquí que dice kubectl apply authentication file. Y los secretos están mapeados con esta etiqueta llamada equipo infraestructura, ¿de acuerdo? Hemos creado la configuración de autenticación. Y ahora actualicemos nuestro servicio virtual para adjuntar esta configuración de autenticación. El servicio virtual lo adjuntará. Entonces, cuando llegue la solicitud, verificará eso y luego me dirá si la clave de API es válida o no. Y luego obtendremos la respuesta.

Vamos a la interfaz de Blueedge, una vez más. Haz clic en las APIs, ve a la API GQL unificada. Haz clic en explorar nuevamente. De acuerdo. Deberías ver esta URL. Si no está ahí, puedes ejecutar el comando que se muestra en el chat. Y simplemente ejecutaremos este comando. Y verás este error, que dice fin inesperado de data. Verificaremos una vez más si esta URL es correcta.

De acuerdo. Entonces agreguemos esto a las cabeceras de la solicitud. Si te fijas, hay una pequeña barra aquí abajo, que dice variables de consulta y cabecera de solicitud. Simplemente agreguemos esto y ejecutémoslo nuevamente. Y notarás que obtuvimos, obtuvimos la consulta que estábamos buscando desde aquí, todos los detalles que queríamos. Así es como puedes asegurar tu API con una clave de API. Puedes darle al usuario una clave de API básicamente, y podrán hacer consultas. También tienes cosas como límite de velocidad. Y tenemos muchas otras características, límite de velocidad, firewall de aplicaciones web, donde puedes aplicar todas estas características y asegurar tus data.

La siguiente característica que tenemos se llama prevención de pérdida de data. Entonces, cuando tienes data sensible y estás enviando el data sensible a los usuarios, entonces, ya sabes, en los registros de acceso, quieres ocultar estos valores sensibles, ¿verdad? Puedes usar la prevención de pérdida de data para ocultar, como el data. Entonces, si te fijas aquí, déjame hacer esto rápido. Hemos definido esto en nuestro servicio virtual, donde, ya sabes, básicamente ocurre el punto de entrada, hemos definido este bloque DLP. Y decimos que queremos ocultar un carácter que tiene el nombre de prueba. Y hemos dado una expresión regular. La expresión regular es el nombre de usuario. Entonces, en cualquier lugar donde haya un nombre de usuario, en cualquier lugar donde esta expresión regular coincida, se reemplazará con este carácter, el carácter Ashtec. Entonces, y solo ocultaremos el 60% de eso. Entonces, si tiene 10 caracteres, solo se ocultará el 60% de eso. El resto no se ocultará. Así que intentemos...

Hemos configurado el servicio virtual. Y ahora volvamos a ejecutar esta consulta. Y ahora notarás que en esta sección de nombre de usuario aquí, tenemos nombre de usuario y hemos ocultado el 60% de los data. Así es como puedes ocultar datos sensibles de la database en tus aplicaciones.

La siguiente característica que tenemos se llama... ¿Todos me siguen? ¿Todos han llegado hasta aquí? ¿Alguna pregunta, alguna consulta, algo así? Así que casi hemos llegado al final de la sesión. Así que si hay alguna consulta o algo así.

Si no hay consultas, podemos pasar a la última parte de la sección. La resiliencia es una característica muy importante. No quieres que tus servicios se caigan. No existe tal cosa como un tiempo de actividad siempre del 99.99. Hay fallas, siempre habrá algún problema. Es cómo te recuperas de eso básicamente. Entonces los servicios se caen, la red nunca es, cómo decirlo, la red nunca es confiable. Siempre verás que algún otro servicio se cae o alguna red se pierde o algo así.

Por eso, incluso en Kubernetes, ejecutas réplicas. Entonces, si una réplica se cae, tienes otras dos réplicas en ejecución. Veamos cómo lo hacemos aquí. Ya está creado para nosotros. Tenemos un servicio de respaldo de usuarios. Verificaremos si el despliegue está en ejecución. Y podemos ver que está en ejecución. Ahora lo modificaremos, este upstream, para crear, para simular una falla básicamente. Así que esto actualizará el valor predeterminado. Por lo tanto, hará que el despliegue del curso falle básicamente. Así que apliquemos esto. Si hemos creado un upstream que fallará. Puedes realizar esto una última vez y todo funciona como se esperaba. Ahora simularemos una falla. Escalaremos el despliegue a cero y verificaremos si los pods están en ejecución.

Veremos que está terminando aquí. Así que tomará algo de tiempo. Así que los pods están terminando básicamente y eso simulará una falla porque no hay nada en ejecución. Entonces no tenemos usuarios, no hay ningún pod de usuario en ejecución en este momento. Entonces no hay servicio de usuario y veamos qué sucede.

Así que te das cuenta de que no sucedió nada como si no hubiéramos fallado porque agregamos esta parte de conmutación por error aquí. Agregamos una sección de conmutación por error aquí que decía en caso de una conmutación por error, cambias el backend a usuarios-backup. Entonces, en caso de que la verificación de estado falle y no haya ningún pod en ejecución, cambiará automáticamente al servicio de respaldo predeterminado que tenemos en el espacio de nombres predeterminado. Entonces esto es básicamente una URL de servicio. Así es como tenemos una especie de resiliencia incorporada donde simplemente especificas el respaldo y puedes seguir adelante.

Esto es todo. Esto es el final. Gracias por quedarte. Que tengas un buen día. Adiós.