Libro de cocina Quarkus

Capítulo 1. Visión general de Quarkus

Este trabajo se ha traducido utilizando IA. Agradecemos tus opiniones y comentarios: [e-mail]

Kubernetes se está convirtiendo en la plataforma de facto para desplegar nuestras aplicaciones empresariales hoy en día. El movimiento hacia los contenedores y Kubernetes ha provocado cambios en la forma en que codificamos, desplegamos y mantenemos nuestras aplicaciones basadas en Java. Puedes meterte fácilmente en problemas si contenedorizas y ejecutas una aplicación Java sin tomar las medidas adecuadas. Los contenedores en Pods (un término de Kubernetes) son las unidades básicas en Kubernetes, por lo que es muy importante comprender bien cómo contenerizar correctamente una aplicación basada en Java para evitar trampas, trabajo perdido y horas extra de frustración.

Quarkus es un marco nativo en la nube con integración incorporada de Kubernetes. Es una pila de código abierto, publicada bajo la Licencia Apache 2.0, que te ayuda a crear aplicaciones nativas de Kubernetes adaptadas a GraalVM y OpenJDK HotSpot. Está construido sobre bibliotecas y tecnologías populares como Hibernate, Eclipse MicroProfile, Kubernetes, Apache Camel y Eclipse Vert.x.

Entre las ventajas de Quarkus se incluyen su fácil integración con Docker y Kubernetes, su rápido tiempo de arranque, su baja memoria de conjunto residente (RSS) y el aumento de la productividad de los desarrolladores. En este capítulo introductorio, echaremos un vistazo rápido a Quarkus: qué es, los problemas que resuelve, cómo se integra con Kubernetes, por qué los desarrolladores disfrutan trabajando con él y algunas de sus características más destacables.

Para desarrolladores

Quarkus te permite a ti, desarrollador Java, ser más productivo, y te ayuda a seguir siendo relevante en el vertiginoso ámbito de los microservicios y las aplicaciones basadas en la nube.

Quarkus permitirá a tus aplicaciones escalar mejor, llenar más estrechamente un clúster Kubernetes utilizando menos recursos en general, y hacer uso de décadas de trabajo de la comunidad en Java de código abierto.

Para empezar a desarrollar con Quarkus, no necesitarás aprender una nueva tecnología. Si ya estás familiarizado con los conceptos de inyección de dependencias, JAX-RS, Hibernate y Eclipse MicroProfile, no hay nada nuevo aquí. Todos los conocimientos que hayas acumulado a lo largo de tu carrera se trasladarán directamente a Quarkus. Mientras que aprender otros marcos de trabajo puede llevarte semanas, puedes empezar con Quarkus y ser productivo en cuestión de días o incluso horas.

Quarkus está diseñado para ser una opción optimizada para la próxima generación de desarrollo e implementación de aplicaciones. Te ayuda a lo largo de todo el ciclo de vida de la aplicación, desde el andamiaje de la aplicación y la recarga en vivo en modo dev (un flujo de trabajo de guardar y actualizar), hasta la implementación en un clúster Kubernetes basado en la nube. Como desarrollador, Quarkus te mantendrá productivo y resolviendo problemas, en lugar deafeitando yaks.

Integración con Kubernetes

Hemos dicho que Quarkus está pensado para ejecutarse en Kubernetes. Eso suena muy bien, pero sabemos que muchas cosas pueden ejecutarse en Kubernetes. Pon tu aplicación en un contenedor Docker y se ejecutará en Kubernetes. Aunque esto es cierto, hay una serie de cosas que tradicionalmente hay que hacer para ajustar, dimensionar y configurar adecuadamente tu aplicación para que se ejecute eficientemente en Kubernetes. También tienes que sacar tu editor de texto preferido y elaborar varios archivos YAML, y seamos sinceros, a nadie le gusta hacer todo eso.

Quarkus elimina ese trabajo al disponer de una serie de mejoras para la implementación y el uso de Kubernetes con tu aplicación. Cuando arrancas una aplicación de Quarkus, ésta viene con unos archivos Dockerfile que se utilizan para generar los contenedores Docker para tu aplicación, lo cual es un gran primer paso. Estos archivos están optimizados para ejecutarse con la JVM OpenJDK o como ejecutables nativos con GraalVM. Contienen lo necesario para ejecutar la aplicación, eliminando así tanta duplicación e hinchazón innecesaria de la imagen del contenedor como sea posible.

A continuación, cuando utilizas las extensiones de Kubernetes, Quarkus puede generar los recursos (archivos YAML) para una implementación en Kubernetes u OpenShift. Se acabó tener que vadear archivos YAML y asegurarte de que tienes la indentación correcta. Después de todo, preferirías estar escribiendo código que buscando esa única línea de YAML que no está formateada correctamente. Quarkus también puede enviar tu imagen a un registro antes de desplegarla en el clúster de Kubernetes. Todas estas imágenes de aplicaciones pueden mejorarse y personalizarse aún más mediante la configuración de aplicaciones de Quarkus, de la que aprenderás en el Capítulo 4. Por ejemplo, en Quarkus 1.4 y posteriores, ConfigMap y Secrets pueden leerse desde el servidor API: ¡no necesitas montar ninguno de los archivos en el Pod!

Memoria y Tiempo de Primera Respuesta

Quarkus es conocido como el framework Java "supersónico y subatómico". Eso puede hacer saltar las alarmas de marketing entre los desarrolladores, pero cuando lo desgloses y entiendas lo que hace Quarkus, verás que realmente estás consiguiendo una ejecución muy pequeña, rápida y productiva. Con Quarkus, puedes desplegar una aplicación nativa optimizada para ejecutarse en Kubernetes. Por ejemplo, supongamos que quieres desplegar una aplicación nativa, optimizada para ejecutarse en Kubernetes, en la que la imagen del contenedor ocupe unos 200 MB o menos. En Quarkus, esta aplicación se iniciará y estará lista para aceptar peticiones en una fracción de segundo, y utilizará menos de 50 MB de memoria.

Cuando se despliega en un clúster de Kubernetes, quieres empaquetar tantas instancias de tu aplicación como sea posible, de modo que puedas escalar para hacer frente a una carga inesperada y seguir utilizando tantos recursos como sea posible. Al escalar, quieres que las nuevas instancias de tu aplicación se pongan en marcha rápidamente: aquí es donde brilla un ejecutable nativo. Quarkus hace todo el prearranque posible de tu aplicación y de los frameworks que utiliza durante el proceso de construcción del ejecutable nativo, lo que ayuda a que tu aplicación se inicie rápidamente y esté lista para atender peticiones sin tener que hacer cargas adicionales de clases, análisis en tiempo de ejecución u otros calentamientos que suele hacer la JVM.

Naturalmente, la memoria disponible es un recurso finito. Entender exactamente cuánta memoria está utilizando tu aplicación, y no matar de hambre a la JVM mientras intentas mantener esa cifra baja, es clave para la densidad de implementación. Quarkus consigue ayudarte a conseguirlo con el ejecutable nativo, que es pequeño y eficiente en el uso de la memoria.

Un flujo de trabajo básico de Quarkus

Mientras lees este libro y sigues las recetas, te introducirás en el ecosistema de Quarkus. Aprenderás sobre extensiones, integraciones y decisiones de diseño. También verás el flujo de trabajo básico que se utiliza en todo el libro para ayudarte a ser productivo. En pocas palabras, este flujo de trabajo es el siguiente:

1. Andamio

2. Iniciar el modo de desarrollo

3. Código

4. Prueba

5. Paquete

6. Implementación

Andamiar tu aplicación, o añadir una extensión a un inicio existente, te proporciona una base sólida sobre la que construir. Te familiarizarás con esto en el Capítulo 2. Tras el andamiaje, se te pedirá que ejecutes tu aplicación en modo dev, que también se introduce en el Capítulo 2. A continuación, aprenderás las tareas típicas de una aplicación: crear servicios RESTful, completar el modelo básico de programación y realizar la configuración de la aplicación. El modo Dev te proporcionará información casi instantánea sin el molesto baile de compilar, empaquetar e implementar con el que ya te has familiarizado. En el Capítulo 5 verás cómo probar una aplicación Quarkus que se dirige tanto a la JVM como al ejecutable nativo, lo que te dará la seguridad de que tu aplicación se ejecuta correctamente y cumple tus normas. La creación del entregable final se trata en el Capítulo 6, al igual que el aprendizaje de cómo empaquetar tu aplicación para tu estrategia de implementación particular. La última pieza de ese flujo de trabajo, la implementación, se trata en el Capítulo 10. Explorando más a fondo, aprenderás cómo hacer que tu aplicación sea más resistente a fallos, cómo interactuar con varios motores de persistencia y cómo comunicarte con servicios externos. También explicaremos integraciones adicionales para ayudarte a aprovechar los conocimientos existentes de otras bibliotecas y paradigmas de programación. Te guiaremos a través de laconfiguración de las optimizaciones de Kubernetes necesarias para tu aplicación, la creación de recursosde Kubernetes y la puesta en marcha de todo.