cassandra.adoc.po

# SOME DESCRIPTIVE TITLE
# Copyright (C) YEAR Free Software Foundation, Inc.
# This file is distributed under the same license as the PACKAGE package.
# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.
#
#, fuzzy
msgid ""
msgstr ""
"Project-Id-Version: PACKAGE VERSION\n"
"POT-Creation-Date: 2023-11-12 08:20+0000\n"
"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
"Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
"Language-Team: LANGUAGE <LL@li.org>\n"
"Language: es_ES\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"

#. This guide is maintained in the main Quarkus repository
#. and pull requests should be submitted there:
#. https://github.com/quarkusio/quarkus/tree/main/docs/src/main/asciidoc
#. type: Title =
#: _guides/cassandra.adoc
#, fuzzy, no-wrap
msgid "Using the Cassandra Client"
msgstr "Uso del cliente Cassandra"

#: _guides/cassandra.adoc
#, fuzzy
msgid ""
"Apache Cassandra® is a free and open-source, distributed, wide column store, NoSQL database\n"
"management system designed to handle large amounts of data across many commodity servers, providing\n"
"high availability with no single point of failure."
msgstr "Apache Cassandra® es un sistema de gestión de bases de datos NoSQL de código abierto y gratuito, distribuido, con un amplio almacén de columnas y diseñado para manejar grandes cantidades de datos a través de muchos servidores básicos, proporcionando una alta disponibilidad sin un único punto de fallo."

#. type: Plain text
#: _guides/cassandra.adoc
#, fuzzy
msgid "In this guide, we will see how you can get your REST services to use a Cassandra database."
msgstr "En esta guía, veremos cómo puedes hacer que tus servicios REST utilicen una base de datos Cassandra."

#. type: Title ==
#: _guides/cassandra.adoc
#, no-wrap
msgid "Prerequisites"
msgstr "Requisitos previos"

#: _guides/cassandra.adoc
#, fuzzy
msgid ""
"A running link:https://cassandra.apache.org[Apache Cassandra],\n"
"link:https://www.datastax.fr/products/datastax-enterprise[DataStax Enterprise] (DSE) or\n"
"link:https://astra.datastax.com[DataStax Astra] database; or alternatively, a fresh Docker\n"
"installation."
msgstr "Una base de datos link:https://cassandra.apache.org[Apache Cassandra] , link:https://www.datastax.fr/products/datastax-enterprise[DataStax Enterprise] (DSE) o link:https://astra.datastax.com[DataStax Astra] en funcionamiento; o alternativamente, una instalación Docker fresca."

#. type: Title ==
#: _guides/cassandra.adoc
#, no-wrap
msgid "Architecture"
msgstr "Arquitectura"

#: _guides/cassandra.adoc
#, fuzzy
msgid ""
"This quickstart guide shows how to build a REST application using the\n"
"link:https://github.com/datastax/cassandra-quarkus[Cassandra Quarkus extension], which allows you to\n"
"connect to an Apache Cassandra, DataStax Enterprise (DSE) or DataStax Astra database, using the\n"
"link:https://docs.datastax.com/en/developer/java-driver/latest[DataStax Java driver]."
msgstr "Esta guía de inicio rápido muestra cómo construir una aplicación REST utilizando la link:https://github.com/datastax/cassandra-quarkus[extensión Cassandra Quarkus] , que le permite conectarse a una base de datos Apache Cassandra, DataStax Enterprise (DSE) o DataStax Astra, utilizando el link:https://docs.datastax.com/en/developer/java-driver/latest[controlador Java de DataStax] ."

#: _guides/cassandra.adoc
#, fuzzy
msgid ""
"This guide will also use the\n"
"link:https://docs.datastax.com/en/developer/java-driver/latest/manual/mapper[DataStax Object Mapper]\n"
"– a powerful Java-to-CQL mapping framework that greatly simplifies your application's data access\n"
"layer code by sparing you the hassle of writing your CQL queries by hand."
msgstr "Esta guía también utilizará el link:https://docs.datastax.com/en/developer/java-driver/latest/manual/mapper[mapeador de objetos de DataStax] , un potente marco de mapeo de Java a CQL que simplifica enormemente el código de la capa de acceso a datos de su aplicación al evitarle la molestia de escribir sus consultas CQL a mano."

#: _guides/cassandra.adoc
#, fuzzy
msgid ""
"The application built in this quickstart guide is quite simple: the user can add elements in a list\n"
"using a form, and the items list is updated. All the information between the browser and the server\n"
"is formatted as JSON, and the elements are stored in the Cassandra database."
msgstr "La aplicación construida en esta guía de inicio rápido es bastante sencilla: el usuario puede añadir elementos en una lista mediante un formulario, y la lista de elementos se actualiza. Toda la información entre el navegador y el servidor se formatea como JSON, y los elementos se almacenan en la base de datos Cassandra."

#. type: Title ==
#: _guides/cassandra.adoc
#, no-wrap
msgid "Solution"
msgstr "Solución"

#: _guides/cassandra.adoc
#, fuzzy
msgid ""
"We recommend that you follow the instructions in the next sections and create the application step\n"
"by step. However, you can go right to the completed example."
msgstr "Le recomendamos que siga las instrucciones de las siguientes secciones y cree la aplicación paso a paso. Sin embargo, puede ir directamente al ejemplo completado."

#: _guides/cassandra.adoc
#, fuzzy
msgid ""
"The solution is located in the\n"
"link:https://github.com/datastax/cassandra-quarkus/tree/main/quickstart[quickstart directory] of\n"
"the Cassandra Quarkus extension GitHub repository."
msgstr "La solución se encuentra en el link:https://github.com/datastax/cassandra-quarkus/tree/main/quickstart[directorio quickstart] del repositorio GitHub de la extensión Cassandra Quarkus."

#. type: Title ==
#: _guides/cassandra.adoc
#, fuzzy, no-wrap
msgid "Creating a Blank Maven Project"
msgstr "Creación de un proyecto Maven en blanco"

#: _guides/cassandra.adoc
#, fuzzy
msgid ""
"First, create a new Maven project and copy the `pom.xml` file that is present in the `quickstart`\n"
"directory."
msgstr "En primer lugar, cree un nuevo proyecto Maven y copie el archivo `pom.xml` que se encuentra en el directorio `quickstart` ."

#. type: Plain text
#: _guides/cassandra.adoc
#, fuzzy
msgid "The `pom.xml` is importing all the Quarkus extensions and dependencies you need."
msgstr "El `pom.xml` está importando todas las extensiones y dependencias de Quarkus que necesita."

#. type: Title ==
#: _guides/cassandra.adoc
#, fuzzy, no-wrap
msgid "Creating the Data Model and Data Access Objects"
msgstr "Creación del modelo de datos y de los objetos de acceso a los datos"

#. type: Plain text
#: _guides/cassandra.adoc
#, fuzzy
msgid "In this example, we will create an application to manage a list of fruits."
msgstr "En este ejemplo, crearemos una aplicación para gestionar una lista de frutas."

#. type: Plain text
#: _guides/cassandra.adoc
#, fuzzy
msgid "First, let's create our data model – represented by the `Fruit` class – as follows:"
msgstr "En primer lugar, vamos a crear nuestro modelo de datos - representado por la clase `Fruit` - de la siguiente manera:"

#: _guides/cassandra.adoc
#, fuzzy
msgid ""
"As stated above, we are using the DataStax Object Mapper. In other words, we are not going to write\n"
"our CQL queries manually; instead, we will annotate our data model with a few annotations, and the\n"
"mapper will generate proper CQL queries underneath."
msgstr "Como ya hemos dicho, vamos a utilizar el mapeador de objetos de DataStax. En otras palabras, no vamos a escribir nuestras consultas CQL manualmente; en su lugar, anotaremos nuestro modelo de datos con unas cuantas anotaciones, y el mapeador generará las consultas CQL adecuadas por debajo."

#: _guides/cassandra.adoc
#, fuzzy
msgid ""
"This is why the `Fruit` class is annotated with `@Entity`: this annotation marks it as an _entity\n"
"class_ that is mapped to a Cassandra table. Its instances are meant to be automatically persisted\n"
"into, and retrieved from, the Cassandra database. Here, the table name will be inferred from the\n"
"class name: `fruit`."
msgstr "Esta es la razón por la que la clase `Fruit` está anotada con `@Entity` : esta anotación la marca como una _clase de entidad_ que está mapeada a una tabla Cassandra. Sus instancias están destinadas a ser automáticamente persistidas en, y recuperadas de, la base de datos Cassandra. En este caso, el nombre de la tabla se deducirá del nombre de la clase: `fruit` ."

#: _guides/cassandra.adoc
#, fuzzy
msgid ""
"Also, the `name` field represents a Cassandra partition key, and so we are annotating it with\n"
"`@PartitionKey` – another annotation from the Object Mapper library."
msgstr "Además, el campo `name` representa una clave de partición Cassandra, por lo que lo estamos anotando con `@PartitionKey` - otra anotación de la biblioteca Object Mapper."

#: _guides/cassandra.adoc
#, fuzzy
msgid ""
"Entity classes are normally required to have a default no-arg constructor, unless they\n"
"are annotated with `@PropertyStrategy(mutable = false)`, which is the case here."
msgstr "Normalmente, las clases de entidad deben tener un constructor sin carga por defecto, a menos que estén anotadas con `@PropertyStrategy(mutable = false)` , que es el caso que nos ocupa."

#: _guides/cassandra.adoc
#, fuzzy
msgid ""
"The next step is to create a DAO (Data Access Object) interface that will manage instances of\n"
"`Fruit` entities:"
msgstr "El siguiente paso es crear una interfaz DAO (Data Access Object) que gestionará las instancias de las entidades `Fruit` :"

#: _guides/cassandra.adoc
#, fuzzy
msgid ""
"This interface exposes operations that will be used in our REST service. Again, the annotation\n"
"`@Dao` comes from the DataStax Object Mapper, which will also automatically generate an\n"
"implementation of this interface for you."
msgstr "Esta interfaz expone operaciones que se utilizarán en nuestro servicio REST. De nuevo, la anotación `@Dao` proviene del mapeador de objetos de DataStax, que también generará automáticamente una implementación de esta interfaz para usted."

#: _guides/cassandra.adoc
#, fuzzy
msgid ""
"Note also the special return type of the `findAll` method,\n"
"link:https://docs.datastax.com/en/drivers/java/latest/com/datastax/oss/driver/api/core/PagingIterable.html[`PagingIterable`]:\n"
"it's the base type of result sets returned by the driver."
msgstr "Observe también el tipo de retorno especial del método `findAll` , link:https://docs.datastax.com/en/drivers/java/latest/com/datastax/oss/driver/api/core/PagingIterable.html[PagingIterable] ya que es el tipo base de los conjuntos de resultados devueltos por el controlador."

#. type: Plain text
#: _guides/cassandra.adoc
#, fuzzy
msgid "Finally, let's create a Mapper interface:"
msgstr "Por último, vamos a crear la interfaz de un mapeador:"

#: _guides/cassandra.adoc
#, fuzzy
msgid ""
"The `@Mapper` annotation is yet another annotation recognized by the DataStax Object Mapper. A\n"
"mapper is responsible for constructing DAO instances – in this case, out mapper is constructing\n"
"an instance of our only DAO, `FruitDao`."
msgstr "La anotación `@Mapper` es otra anotación reconocida por el mapeador de objetos DataStax. Un mapeador es responsable de construir instancias DAO - en este caso, nuestro mapeador está construyendo una instancia de nuestro único DAO, `FruitDao` ."

#: _guides/cassandra.adoc
#, fuzzy
msgid ""
"Think of the mapper interface as a factory for DAO beans. If you intend to construct and inject a\n"
"specific DAO bean in your own code, then you first must add a `@DaoFactory` method for it in a\n"
"`@Mapper` interface."
msgstr "Piense en la interfaz del mapeador como una fábrica de beans DAO. Si pretende construir e inyectar un frijol DAO específico en su propio código, entonces primero debe añadir un método `@DaoFactory` para él en una interfaz `@Mapper` ."

#. type: Plain text
#: _guides/cassandra.adoc
#, fuzzy
msgid "`@DaoFactory` method names are irrelevant."
msgstr "`@DaoFactory` los nombres de los métodos son irrelevantes."

#. type: Plain text
#: _guides/cassandra.adoc
#, fuzzy
msgid "`@DaoFactory` methods should return beans of the following types:"
msgstr "`@DaoFactory` deben devolver beans de los siguientes tipos:"

#. type: Plain text
#: _guides/cassandra.adoc
#, fuzzy
msgid "Any `@Dao`-annotated interface, e.g. `FruitDao`;"
msgstr "Todas las interfaces anotadas en `@Mapper` en su proyecto."

#. type: Plain text
#: _guides/cassandra.adoc
#, fuzzy
msgid "A `CompletionStage` of any `@Dao`-annotated interface, e.g. `CompletionStage<FruitDao>`."
msgstr "Un `CompletationStage` de cualquier interfaz anotada en `@Dao`, por ejemplo `CompletionStage&amp;lt;FruitDao&amp;gt;`."

#. type: Plain text
#: _guides/cassandra.adoc
#, fuzzy
msgid "A `Uni` of any `@Dao`-annotated interface, e.g. `Uni<FruitDao>`."
msgstr "Un `Uni` de cualquier interfaz anotada en `@Dao`, por ejemplo `Uni&amp;lt;FruitDao&amp;gt;`."

#: _guides/cassandra.adoc
#, fuzzy
msgid ""
"`Uni` is a type from the Mutiny library, which is the reactive programming library used by\n"
"Quarkus. This will be explained in more detail in the \"Reactive Programming\" section below."
msgstr "`Uni` es un tipo de la biblioteca Mutiny, que es la biblioteca de programación reactiva utilizada por Quarkus. Esto se explicará con más detalle en la sección \"Programación reactiva\" más adelante."

#. type: Title ==
#: _guides/cassandra.adoc
#, fuzzy, no-wrap
msgid "Generating the DAO and mapper implementations"
msgstr "Generación de las implementaciones DAO y mapper"

#: _guides/cassandra.adoc
#, fuzzy
msgid ""
"As you probably guessed already, we are not going to implement the interfaces above. Instead, the\n"
"Object Mapper will generate such implementations for us."
msgstr "Como probablemente ya habrá adivinado, no vamos a implementar las interfaces anteriores. En su lugar, el mapeador de objetos generará dichas implementaciones por nosotros."

#. type: Plain text
#: _guides/cassandra.adoc
#, fuzzy
msgid "The Object Mapper is composed of 2 pieces:"
msgstr "El mapeador de objetos se compone de 2 piezas:"

#: _guides/cassandra.adoc
#, fuzzy
msgid ""
"A (compile-time) annotation processor that scans the classpath for classes annotated with\n"
"`@Mapper`, `@Dao` or `@Entity`, and generates code and CQL queries for them; and"
msgstr "Un procesador de anotaciones (en tiempo de compilación) que explora el classpath en busca de clases anotadas con `@Mapper` , `@Dao` o `@Entity` , y genera código y consultas CQL para ellas; y"

#. type: Plain text
#: _guides/cassandra.adoc
#, fuzzy
msgid "A runtime module that contains the logic to execute the generated queries."
msgstr "Un módulo de ejecución que contiene la lógica para ejecutar las consultas generadas."

#. type: Plain text
#: _guides/cassandra.adoc
#, fuzzy
msgid "Therefore, enabling the Object Mapper requires two steps:"
msgstr "Por lo tanto, habilitar el mapeador de objetos requiere dos pasos:"

#: _guides/cassandra.adoc
#, fuzzy
msgid ""
"Declare the `cassandra-quarkus-mapper-processor` annotation processor. With Maven, this is done\n"
"by modifying the compiler plugin configuration in the project's `pom.xml` file as follows:"
msgstr "Declare el procesador de anotaciones `cassandra-quarkus-mapper-processor` . Con Maven, esto se hace modificando la configuración del plugin del compilador en el archivo `pom.xml` del proyecto de la siguiente manera:"

#. type: Plain text
#: _guides/cassandra.adoc
#, fuzzy
msgid "With Gradle, this is done by adding the following line to the `build.gradle` file:"
msgstr "Con Gradle, esto se hace añadiendo la siguiente línea al archivo `build.gradle`:"

#: _guides/cassandra.adoc
#, fuzzy
msgid ""
"Verify that you are enabling the right annotation processor! The Cassandra driver ships\n"
"with its Object Mapper annotation processor, called `java-driver-mapper-processor`. But the\n"
"Cassandra Quarkus extension also ships with its own annotation processor:\n"
"`cassandra-quarkus-mapper-processor`, which has more capabilities than the driver's. This annotation\n"
"processor is the only one suitable for use in a Quarkus application, so check that this is the one\n"
"in use. Also, never use both annotation processors together."
msgstr "Compruebe que está habilitando el procesador de anotaciones correcto. El controlador Cassandra se entrega con su procesador de anotaciones Object Mapper, llamado `java-driver-mapper-processor` . Pero la extensión Quarkus de Cassandra también se envía con su propio procesador de anotaciones: `cassandra-quarkus-mapper-processor` , que tiene más capacidades que el del controlador. Este procesador de anotaciones es el único adecuado para su uso en una aplicación Quarkus, así que compruebe que es el que está en uso. Además, nunca utilice ambos procesadores de anotación juntos."

#: _guides/cassandra.adoc
#, fuzzy
msgid ""
"Declare the `java-driver-mapper-runtime` dependency in compile scope in the project's `pom.xml`\n"
"file as follows:"
msgstr "Declare la dependencia `java-driver-mapper-runtime` en el ámbito de compilación en el archivo `pom.xml` del proyecto como sigue:"

#. type: Plain text
#: _guides/cassandra.adoc
#, fuzzy
msgid "Although this module is called \"runtime\", it must be declared in compile scope."
msgstr "Aunque este módulo se llama \"runtime\", debe declararse en el ámbito de compilación."

#: _guides/cassandra.adoc
#, fuzzy
msgid ""
"If your project is correctly set up, you should now be able to compile it without errors, and you\n"
"should see the generated code in the `target/generated-sources/annotations` directory (if you are\n"
"using Maven). It's not required to get familiar with the generated code though, as it is mostly\n"
"internal machinery to interact with the database."
msgstr "Si su proyecto está correctamente configurado, ahora debería poder compilarlo sin errores, y debería ver el código generado en el directorio `target/generated-sources/annotations` (si está utilizando Maven). Sin embargo, no es necesario que se familiarice con el código generado, ya que en su mayor parte se trata de maquinaria interna para interactuar con la base de datos."

#. type: Title ==
#: _guides/cassandra.adoc
#, fuzzy, no-wrap
msgid "Creating a service & JSON REST endpoint"
msgstr "Creación de un servicio y un punto final JSON REST"

#: _guides/cassandra.adoc
#, fuzzy
msgid ""
"Now let's create a `FruitService` that will be the business layer of our application and store/load\n"
"the fruits from the Cassandra database."
msgstr "Ahora vamos a crear un `FruitService` que será la capa de negocio de nuestra aplicación y almacenará/cargará los frutos de la base de datos Cassandra."

#: _guides/cassandra.adoc
#, fuzzy
msgid ""
"Note how the service is being injected a `FruitDao` instance. This DAO instance is injected\n"
"automatically, thanks to the generated implementations."
msgstr "Observe cómo se inyecta al servicio una instancia de `FruitDao` . Esta instancia DAO se inyecta automáticamente, gracias a las implementaciones generadas."

#: _guides/cassandra.adoc
#, fuzzy
msgid ""
"The Cassandra Quarkus extension allows you to inject any of the following beans in your own\n"
"components:"
msgstr "La extensión Cassandra Quarkus le permite inyectar cualquiera de los siguientes beans en sus propios componentes:"

#. type: Plain text
#: _guides/cassandra.adoc
#, fuzzy
msgid "All `@Mapper`-annotated interfaces in your project."
msgstr "Todas las interfaces anotadas en `@Mapper` en su proyecto."

#. type: Plain text
#: _guides/cassandra.adoc
#, fuzzy
msgid "You can also inject a `CompletionStage` or `Uni` of any `@Mapper`-annotated interface."
msgstr "También puede inyectar un `CompletionStage` o `Uni` de cualquier interfaz anotada en `@Mapper`."

#. type: Plain text
#: _guides/cassandra.adoc
#, fuzzy
msgid "Any bean returned by a `@DaoFactory` method (see above for possible bean types)."
msgstr "Cualquier bean devuelto por un método `@DaoFactory` (ver más arriba los posibles tipos de bean)."

#: _guides/cassandra.adoc
#, fuzzy
msgid ""
"The\n"
"link:https://javadoc.io/doc/com.datastax.oss.quarkus/cassandra-quarkus-client/latest/com/datastax/oss/quarkus/runtime/api/session/QuarkusCqlSession.html[`QuarkusCqlSession`]\n"
"bean: this application-scoped, singleton bean is your main entry point to the Cassandra client; it\n"
"is a specialized Cassandra driver session instance with a few methods tailored especially for\n"
"Quarkus. Read its javadocs carefully!"
msgstr "El bean link:https://javadoc.io/doc/com.datastax.oss.quarkus/cassandra-quarkus-client/latest/com/datastax/oss/quarkus/runtime/api/session/QuarkusCqlSession.html[QuarkusCqlSession] bean: este bean singleton de ámbito de aplicación es su principal punto de entrada al cliente Cassandra; es una instancia de sesión especializada del controlador Cassandra con unos pocos métodos adaptados especialmente para Quarkus. ¡Lea atentamente sus javadocs!"

#. type: Plain text
#: _guides/cassandra.adoc
#, fuzzy
msgid "You can also inject `CompletionStage<QuarkusCqlSession>` or `Uni<QuarkusCqlSession>`."
msgstr "También puede inyectar `CompletationStage&amp;lt;QuarkusCqlSession&amp;gt;` o `Uni&amp;lt;QuarkusCqlSession&amp;gt;`."

#: _guides/cassandra.adoc
#, fuzzy
msgid ""
"In our example, both `FruitMapper` and `FruitDao` could be injected anywhere. We chose to inject\n"
"`FruitDao` in `FruitService`."
msgstr "En nuestro ejemplo, tanto `FruitMapper` como `FruitDao` podrían inyectarse en cualquier lugar. Elegimos inyectar `FruitDao` en `FruitService` ."

#. type: Plain text
#: _guides/cassandra.adoc
#, fuzzy
msgid "The last missing piece is the REST API that will expose GET and POST methods:"
msgstr "La última pieza que falta es la API REST que expondrá los métodos GET y POST:"

#. type: Plain text
#: _guides/cassandra.adoc
#, fuzzy
msgid "Notice how `FruitResource` is being injected a `FruitService` instance automatically."
msgstr "Observe que a `FruitResource` se le inyecta una instancia de `FruitService` automáticamente."

#: _guides/cassandra.adoc
#, fuzzy
msgid ""
"It is generally not recommended using the same entity object between the REST API and the data\n"
"access layer. These layers should indeed be decoupled and use distinct APIs in order to allow each\n"
"API to evolve independently of the other. This is the reason why our REST API is using a different\n"
"object: the `FruitDto` class – the word DTO stands for \"Data Transfer Object\". This DTO object will\n"
"be automatically converted to and from JSON in HTTP messages:"
msgstr "En general, no se recomienda utilizar el mismo objeto entidad entre la API REST y la capa de acceso a los datos. De hecho, estas capas deberían estar desacopladas y utilizar API distintas para permitir que cada API evolucione independientemente de la otra. Esta es la razón por la que nuestra API REST utiliza un objeto diferente: la clase `FruitDto` - la palabra DTO significa \"Data Transfer Object\" (objeto de transferencia de datos). Este objeto DTO se convertirá automáticamente a y desde JSON en los mensajes HTTP:"

#: _guides/cassandra.adoc
#, fuzzy
msgid ""
"The translation to and from JSON is done automatically by the Quarkus REST (formerly RESTEasy Reactive) extension, which is\n"
"included in this guide's pom.xml file. If you want to add it manually to your application, add the\n"
"below snippet to your application's pom.xml file:"
msgstr "La traducción a y desde JSON la realiza automáticamente la extensión REST de Quarkus (antes RESTEasy Reactive), que se incluye en el archivo pom.xml de esta guía. Si desea añadirlo manualmente a su aplicación, añada el siguiente fragmento al archivo pom.xml de su aplicación:"

#: _guides/cassandra.adoc
#, fuzzy
msgid ""
"DTO classes used by the JSON serialization layer are required to have a default no-arg\n"
"constructor."
msgstr "Se requiere que las clases DTO utilizadas por la capa de serialización JSON tengan un constructor sin carga por defecto."

#: _guides/cassandra.adoc
#, fuzzy
msgid ""
"The conversion from DTO to JSON is handled automatically for us, but we still must convert from\n"
"`Fruit` to `FruitDto` and vice versa. This must be done manually, which is why we have two\n"
"conversion methods declared in `FruitResource`: `convertToDto` and `convertFromDto`."
msgstr "La conversión de DTO a JSON se maneja automáticamente por nosotros, pero aún debemos convertir de `Fruit` a `FruitDto` y viceversa. Esto debe hacerse manualmente, por lo que tenemos dos métodos de conversión declarados en `FruitResource` : `convertToDto` y `convertFromDto` ."

#: _guides/cassandra.adoc
#, fuzzy
msgid ""
"In our example, `Fruit` and `FruitDto` are very similar, so you might wonder why not use\n"
"`Fruit` everywhere. In real life cases though, it's not uncommon to see DTOs and entities having\n"
"very different structures."
msgstr "En nuestro ejemplo, `Fruit` y `FruitDto` son muy similares, por lo que podría preguntarse por qué no utilizar `Fruit` en todas partes. Sin embargo, en casos de la vida real, no es raro ver DTO y entidades con estructuras muy diferentes."

#. type: Title ==
#: _guides/cassandra.adoc
#, fuzzy, no-wrap
msgid "Connecting to the Cassandra Database"
msgstr "Conexión a la base de datos Cassandra"

#. type: Title ===
#: _guides/cassandra.adoc
#, fuzzy, no-wrap
msgid "Connecting to Apache Cassandra or DataStax Enterprise (DSE)"
msgstr "Conexión a Apache Cassandra o DataStax Enterprise (DSE)"

#: _guides/cassandra.adoc
#, fuzzy
msgid ""
"The main properties to configure are: `contact-points`, to access the Cassandra database;\n"
"`local-datacenter`, which is required by the driver; and – optionally – the keyspace to bind to."
msgstr "Las principales propiedades a configurar son: `contact-points` `local-datacenter` , para acceder a la base de datos Cassandra; , que requiere el controlador; y - opcionalmente - el espacio de claves al que vincularse."

#. type: Plain text
#: _guides/cassandra.adoc
#, fuzzy
msgid "A sample configuration should look like this:"
msgstr "Un ejemplo de configuración debería ser el siguiente:"

#: _guides/cassandra.adoc
#, fuzzy
msgid ""
"In this example, we are using a single instance running on localhost, and the keyspace containing\n"
"our data is `k1`:"
msgstr "En este ejemplo, estamos utilizando una única instancia que se ejecuta en localhost, y el espacio de claves que contiene nuestros datos es `k1` :"

#: _guides/cassandra.adoc
#, fuzzy
msgid ""
"If your cluster requires plain text authentication, you must also provide two more settings:\n"
"`username` and `password`."
msgstr "Si su cluster requiere autenticación en texto plano, deberá proporcionar además dos configuraciones más: `username` y `password` ."

#. type: Title ===
#: _guides/cassandra.adoc
#, fuzzy, no-wrap
msgid "Connecting to a DataStax Astra Cloud Database"
msgstr "Conexión a una base de datos de DataStax Astra Cloud"

#: _guides/cassandra.adoc
#, fuzzy
msgid ""
"When connecting to link:https://astra.datastax.com[DataStax Astra], instead of providing a contact\n"
"point and a datacenter, you should provide a so-called _secure connect bundle_, which should point\n"
"to a valid path to an Astra secure connect bundle file. You can download your secure connect bundle\n"
"from the Astra web console."
msgstr "Cuando se conecte a link:https://astra.datastax.com[DataStax Astra] , en lugar de proporcionar un punto de contacto y un centro de datos, deberá proporcionar el denominado _secure connect b_ undle, que debe apuntar a una ruta válida a un archivo secure connect bundle de Astra. Puede descargar su secure connect bundle desde la consola web de Astra."

#: _guides/cassandra.adoc
#, fuzzy
msgid ""
"You will also need to provide a username and password, since authentication is always required on\n"
"Astra clusters."
msgstr "También tendrá que proporcionar un nombre de usuario y una contraseña, ya que la autenticación siempre es necesaria en los clusters Astra."

#. type: Plain text
#: _guides/cassandra.adoc
#, fuzzy
msgid "A sample configuration for DataStax Astra should look like this:"
msgstr "Un ejemplo de configuración para DataStax Astra debería tener este aspecto:"

#. type: Title ===
#: _guides/cassandra.adoc
#, fuzzy, no-wrap
msgid "Advanced Driver Configuration"
msgstr "Configuración avanzada de controladores"

#: _guides/cassandra.adoc
#, fuzzy
msgid ""
"You can configure other Java driver settings using `application.conf` or `application.json` files.\n"
"They need to be located in the classpath of your application. All settings will be passed\n"
"automatically to the underlying driver configuration mechanism. Settings defined in\n"
"`application.properties` with the `quarkus.cassandra` prefix will have priority over settings\n"
"defined in `application.conf` or `application.json`."
msgstr "Puede configurar otros ajustes del controlador Java utilizando los archivos `application.conf` o `application.json` . Deben estar ubicados en el classpath de su aplicación. Todos los ajustes se pasarán automáticamente al mecanismo de configuración del controlador subyacente. Los ajustes definidos en `application.properties` con el prefijo `quarkus.cassandra` tendrán prioridad sobre los definidos en `application.conf` o `application.json` ."

#: _guides/cassandra.adoc
#, fuzzy
msgid ""
"To see the full list of settings, please refer to the\n"
"link:https://docs.datastax.com/en/developer/java-driver/latest/manual/core/configuration/reference/[driver\n"
"settings reference]."
msgstr "Para ver la lista completa de ajustes, consulte la link:https://docs.datastax.com/en/developer/java-driver/latest/manual/core/configuration/reference/[referencia de ajustes del controlador] ."

#. type: Title ==
#: _guides/cassandra.adoc
#, fuzzy, no-wrap
msgid "Running a Local Cassandra Database"
msgstr "Ejecución de una base de datos Cassandra local"

#: _guides/cassandra.adoc
#, fuzzy
msgid ""
"By default, the Cassandra client is configured to access a local Cassandra database on port 9042\n"
"(the default Cassandra port)."
msgstr "Por defecto, el cliente Cassandra está configurado para acceder a una base de datos Cassandra local en el puerto 9042 (el puerto Cassandra por defecto)."

#: _guides/cassandra.adoc
#, fuzzy
msgid ""
"Make sure that the setting `quarkus.cassandra.local-datacenter` matches the datacenter of\n"
"your Cassandra cluster."
msgstr "Asegúrese de que la configuración `quarkus.cassandra.local-datacenter` coincide con el centro de datos de su cluster Cassandra."

#: _guides/cassandra.adoc
#, fuzzy
msgid ""
"If you don't know the name of your local datacenter, this value can be found by running the\n"
"following CQL query: `SELECT data_center FROM system.local`."
msgstr "Si no conoce el nombre de su centro de datos local, puede encontrar este valor ejecutando la siguiente consulta CQL: `SELECT data_center FROM system.local` ."

#: _guides/cassandra.adoc
#, fuzzy
msgid ""
"If you want to use Docker to run a Cassandra database, you can use the following command to launch\n"
"one in the background:"
msgstr "Si desea utilizar Docker para ejecutar una base de datos Cassandra, puede utilizar el siguiente comando para lanzar una en segundo plano:"

#: _guides/cassandra.adoc
#, fuzzy
msgid ""
"Next you need to create the keyspace and table that will be used by your application. If you are\n"
"using Docker, run the following commands:"
msgstr "A continuación deberá crear el espacio de claves y la tabla que utilizará su aplicación. Si utiliza Docker, ejecute los siguientes comandos:"

#. type: Plain text
#: _guides/cassandra.adoc
#, fuzzy
msgid "You can also use the CQLSH utility to interactively interrogate your database:"
msgstr "También puede utilizar la utilidad CQLSH para interrogar de forma interactiva a su base de datos:"

#. type: Title ==
#: _guides/cassandra.adoc
#, fuzzy, no-wrap
msgid "Testing the REST API"
msgstr "Prueba de la API REST"

#. type: Plain text
#: _guides/cassandra.adoc
#, fuzzy
msgid "In the project root directory:"
msgstr "En el directorio raíz del proyecto:"

#. type: Plain text
#: _guides/cassandra.adoc
#, fuzzy
msgid "Run `mvn clean package` and then `java -jar ./target/cassandra-quarkus-quickstart-*-runner.jar` to start the application;"
msgstr "Ejecute `mvn clean package` y luego `java -jar ./target/cassandra-quarkus-quickstart-*-runner.jar` para iniciar la aplicación;"

#. type: Plain text
#: _guides/cassandra.adoc
#, fuzzy
msgid "Or better yet, run the application in dev mode: `mvn clean quarkus:dev`."
msgstr "O mejor aún, ejecute la aplicación en modo dev: `mvn clean quarkus:dev`."

#. type: Plain text
#: _guides/cassandra.adoc
#, fuzzy
msgid "Now you can use curl commands to interact with the underlying REST API."
msgstr "Ahora puedes usar comandos curl para interactuar con la API REST subyacente."

#. type: Plain text
#: _guides/cassandra.adoc
#, fuzzy
msgid "To create a fruit:"
msgstr "Para crear una fruta:"

#. type: Plain text
#: _guides/cassandra.adoc
#, fuzzy
msgid "To retrieve fruits:"
msgstr "Para recuperar las frutas:"

#. type: Title ==
#: _guides/cassandra.adoc
#, fuzzy, no-wrap
msgid "Creating a Frontend"
msgstr "Creación de un frontend"

#. type: Plain text
#: _guides/cassandra.adoc
#, fuzzy
msgid "Now let's add a simple web page to interact with our `FruitResource`."
msgstr "Ahora vamos a añadir una página web sencilla para interactuar con nuestro `FruitResource`."

#: _guides/cassandra.adoc
#, fuzzy
msgid ""
"Quarkus automatically serves static resources located under the `META-INF/resources` directory. In\n"
"the `src/main/resources/META-INF/resources` directory, add a `fruits.html` file with the contents\n"
"from link:src/main/resources/META-INF/resources/fruits.html[this file] in it."
msgstr "Quarkus sirve automáticamente los recursos estáticos ubicados en el directorio `META-INF/resources` . En el directorio `src/main/resources/META-INF/resources` , añada un archivo `fruits.html` con el contenido de link:src/main/resources/META-INF/resources/fruits.html[este archivo] ."

#. type: Plain text
#: _guides/cassandra.adoc
#, fuzzy
msgid "You can now interact with your REST service:"
msgstr "Ahora puede interactuar con su servicio REST:"

#. type: Plain text
#: _guides/cassandra.adoc
#, fuzzy
msgid "If you haven't done yet, start your application with `mvn clean quarkus:dev`;"
msgstr "Si aún no lo ha hecho, inicie su aplicación con `mvn clean quarkus:dev`;"

#. type: Plain text
#: _guides/cassandra.adoc
#, fuzzy
msgid "Point your browser to `http://localhost:8080/fruits.html`;"
msgstr "Dirija su navegador a `&lt;a href=\"http://localhost:8080/fruits.html\" class=\"bare\"&gt;http://localhost:8080/fruits.html&lt;/a&gt;`;"

#. type: Plain text
#: _guides/cassandra.adoc
#, fuzzy
msgid "Add new fruits to the list via the form."
msgstr "Añadir nuevas frutas a la lista a través del formulario."

#. type: Title ==
#: _guides/cassandra.adoc
#, fuzzy, no-wrap
msgid "Reactive Programming with the Cassandra Client"
msgstr "Programación reactiva con el cliente Cassandra"

#: _guides/cassandra.adoc
#, fuzzy
msgid ""
"The\n"
"link:https://javadoc.io/doc/com.datastax.oss.quarkus/cassandra-quarkus-client/latest/com/datastax/oss/quarkus/runtime/api/session/QuarkusCqlSession.html[`QuarkusCqlSession`\n"
"interface] gives you access to a series of reactive methods that integrate seamlessly with Quarkus\n"
"and its reactive framework, Mutiny."
msgstr "La link:https://javadoc.io/doc/com.datastax.oss.quarkus/cassandra-quarkus-client/latest/com/datastax/oss/quarkus/runtime/api/session/QuarkusCqlSession.html[interfazQuarkusCqlSession] le da acceso a una serie de métodos reactivos que se integran perfectamente con Quarkus y su marco reactivo, Mutiny."

#. type: Plain text
#: _guides/cassandra.adoc
#, fuzzy
msgid "If you are not familiar with Mutiny, please check xref:mutiny-primer.adoc[Mutiny - an intuitive reactive programming library]."
msgstr "Si no está familiarizado con Mutiny, consulte  link:mutiny-primer.html[Mutiny - una biblioteca de programación reactiva intuitiva]."

#. type: Plain text
#: _guides/cassandra.adoc
#, fuzzy
msgid "Let's rewrite our application using reactive programming with Mutiny."
msgstr "Vamos a reescribir nuestra aplicación utilizando la programación reactiva con Mutiny."

#. type: Plain text
#: _guides/cassandra.adoc
#, fuzzy
msgid "First, let's declare another DAO interface that works in a reactive way:"
msgstr "En primer lugar, vamos a declarar otra interfaz DAO que funciona de forma reactiva:"

#: _guides/cassandra.adoc
#, fuzzy
msgid ""
"Note the usage of `MutinyMappedReactiveResultSet` - it is a specialized `Mutiny` type converted from\n"
"the original `Publisher` returned by the driver, which also exposes a few extra methods, e.g. to\n"
"obtain the query execution info. If you don't need anything in that interface, you can also simply\n"
"declare your method to return `Multi`: `Multi<Fruit> findAll()`,"
msgstr "Observe el uso de `MutinyMappedReactiveResultSet` - es un tipo especializado `Mutiny` convertido a partir del original `Publisher` devuelto por el controlador, que también expone algunos métodos extra, por ejemplo para obtener la información de ejecución de la consulta. Si no necesita nada de esa interfaz, también puede simplemente declarar su método para que devuelva `Multi` : `Multi<Fruit> findAll()` ,"

#: _guides/cassandra.adoc
#, fuzzy
msgid ""
"Similarly, the method `updateAsync` returns a `Uni` - it is automatically converted from the\n"
"original result set returned by the driver."
msgstr "Del mismo modo, el método `updateAsync` devuelve un `Uni` - se convierte automáticamente a partir del conjunto de resultados original devuelto por el controlador."

#: _guides/cassandra.adoc
#, fuzzy
msgid ""
"The Cassandra driver uses the Reactive Streams `Publisher` API for reactive calls. The Quarkus\n"
"framework however uses Mutiny. Because of that, the `CqlQuarkusSession` interface transparently\n"
"converts the `Publisher` instances returned by the driver into the reactive type `Multi`.\n"
"`CqlQuarkusSession` is also capable of converting a `Publisher` into a `Uni` – in this case, the\n"
"publisher is expected to emit at most one row, then complete. This is suitable for write queries\n"
"(they return no rows), or for read queries guaranteed to return one row at most (count queries, for\n"
"example)."
msgstr "El controlador Cassandra utiliza la API Reactive Streams `Publisher` para las llamadas reactivas. Sin embargo, el marco Quarkus utiliza Mutiny. Por ello, la interfaz `CqlQuarkusSession` convierte de forma transparente las instancias `Publisher` devueltas por el controlador en el tipo reactivo `Multi` . `CqlQuarkusSession` también es capaz de convertir un `Publisher` en un `Uni` - en este caso, se espera que el publicador emita como máximo una fila y luego se complete. Esto es adecuado para consultas de escritura (no devuelven ninguna fila), o para consultas de lectura en las que se garantiza que devolverán como máximo una fila (consultas de recuento, por ejemplo)."

#. type: Plain text
#: _guides/cassandra.adoc
#, fuzzy
msgid "Next, we need to adapt the `FruitMapper` to construct a `ReactiveFruitDao` instance:"
msgstr "A continuación, tenemos que adaptar el `FruitMapper` para construir una instancia de `ReactiveFruitDao`:"

#. type: Plain text
#: _guides/cassandra.adoc
#, fuzzy
msgid "Now, we can create a `ReactiveFruitService` that leverages our reactive DAO:"
msgstr "Ahora, podemos crear un `ReactiveFruitService` que aproveche nuestro DAO reactivo:"

#. type: Plain text
#: _guides/cassandra.adoc
#, fuzzy
msgid "Finally, we can create a `ReactiveFruitResource`:"
msgstr "Por último, podemos crear un `ReactiveFruitResource`:"

#: _guides/cassandra.adoc
#, fuzzy
msgid ""
"The above resource is exposing a new endpoint, `reactive-fruits`. Its capabilities are identical to\n"
"the ones that we created before with `FruitResource`, but everything is handled in a reactive\n"
"fashion, without any blocking operation."
msgstr "El recurso anterior está exponiendo un nuevo punto final, `reactive-fruits` . Sus capacidades son idénticas a las que creamos anteriormente con `FruitResource` , pero todo se gestiona de forma reactiva, sin ninguna operación de bloqueo."

#: _guides/cassandra.adoc
#, fuzzy
msgid ""
"The `getAll()` method above returns `Multi`, and the `add()` method returns `Uni`. These types\n"
"are the same Mutiny types that we met before; they are automatically recognized by the Quarkus\n"
"reactive REST API, so we don't need to convert them into JSON ourselves."
msgstr "El método `getAll()` anterior devuelve `Multi` , y el método `add()` devuelve `Uni` . Estos tipos son los mismos tipos Mutiny que conocimos antes; son reconocidos automáticamente por la API REST reactiva de Quarkus, por lo que no necesitamos convertirlos en JSON nosotros mismos."

#: _guides/cassandra.adoc
#, fuzzy
msgid "Quarkus REST natively supports the Mutiny reactive types e.g. `Uni` and `Multi`."
msgstr "Quarkus REST soporta de forma nativa los tipos reactivos de Mutiny, por ejemplo `Uni` y `Multi` ."

#: _guides/cassandra.adoc
#, fuzzy
msgid ""
"This dependency is already included in this guide's pom.xml, but if you are starting a new project\n"
"from scratch, make sure to include it."
msgstr "Esta dependencia ya está incluida en el pom.xml de esta guía, pero si está comenzando un nuevo proyecto desde cero, asegúrese de incluirla."

#. type: Title ==
#: _guides/cassandra.adoc
#, fuzzy, no-wrap
msgid "Testing the Reactive REST API"
msgstr "Prueba de la API REST reactiva"

#: _guides/cassandra.adoc
#, fuzzy
msgid ""
"Run the application in dev mode as explained above, then you can use curl commands to interact with\n"
"the underlying REST API."
msgstr "Ejecute la aplicación en modo dev como se ha explicado anteriormente, entonces podrá utilizar comandos curl para interactuar con la API REST subyacente."

#. type: Plain text
#: _guides/cassandra.adoc
#, fuzzy
msgid "To create a fruit using the reactive REST endpoint:"
msgstr "Para crear una fruta utilizando el punto final REST reactivo:"

#. type: Plain text
#: _guides/cassandra.adoc
#, fuzzy
msgid "To retrieve fruits with the reactive REST endpoint:"
msgstr "Para recuperar frutos con el punto final REST reactivo:"

#. type: Title ==
#: _guides/cassandra.adoc
#, fuzzy, no-wrap
msgid "Creating a Reactive Frontend"
msgstr "Creación de un Frontend Reactivo"

#: _guides/cassandra.adoc
#, fuzzy
msgid ""
"Now let's add a simple web page to interact with our `ReactiveFruitResource`. In the\n"
"`src/main/resources/META-INF/resources` directory, add a `reactive-fruits.html` file with the\n"
"contents from link:src/main/resources/META-INF/resources/reactive-fruits.html[this file] in it."
msgstr "Ahora vamos a añadir una página web sencilla para interactuar con nuestro `ReactiveFruitResource` . En el directorio `src/main/resources/META-INF/resources` , añada un archivo `reactive-fruits.html` con el contenido de link:src/main/resources/META-INF/resources/reactive-fruits.html[este archivo] en él."

#. type: Plain text
#: _guides/cassandra.adoc
#, fuzzy
msgid "You can now interact with your reactive REST service:"
msgstr "Ahora puede interactuar con su servicio REST reactivo:"

#. type: Plain text
#: _guides/cassandra.adoc
#, fuzzy
msgid "Point your browser to `http://localhost:8080/reactive-fruits.html`;"
msgstr "Dirija su navegador a `&lt;a href=\"http://localhost:8080/reactive-fruits.html\" class=\"bare\"&gt;http://localhost:8080/reactive-fruits.html&lt;/a&gt;`;"

#. type: Title ==
#: _guides/cassandra.adoc
#, fuzzy, no-wrap
msgid "Health Checks"
msgstr "Controles de salud"

#: _guides/cassandra.adoc
#, fuzzy
msgid ""
"If you are using the Quarkus SmallRye Health extension, then the Cassandra client will automatically\n"
"add a readiness health check to validate the connection to the Cassandra cluster. This extension is\n"
"already included in this guide's pom.xml, but if you need to include it manually in your\n"
"application, add the following:"
msgstr "Si está utilizando la extensión Quarkus SmallRye Health, el cliente Cassandra añadirá automáticamente una comprobación de estado de preparación para validar la conexión con el clúster Cassandra. Esta extensión ya está incluida en el pom.xml de esta guía, pero si necesita incluirla manualmente en su aplicación, añada lo siguiente:"

#: _guides/cassandra.adoc
#, fuzzy
msgid ""
"When health checks are available, you can access the `/health/ready` endpoint of your application\n"
"and have information about the connection validation status."
msgstr "Cuando las comprobaciones de salud están disponibles, puede acceder al punto final `/health/ready` de su aplicación y disponer de información sobre el estado de validación de la conexión."

#: _guides/cassandra.adoc
#, fuzzy
msgid ""
"Running in dev mode with `mvn clean quarkus:dev`, if you point your browser to\n"
"http://localhost:8080/health/ready you should see an output similar to the following one:"
msgstr "Ejecutando en modo dev con `mvn clean quarkus:dev` , si apunta su navegador a http://localhost:8080/health/ready debería ver una salida similar a la siguiente:"

#: _guides/cassandra.adoc
#, fuzzy
msgid ""
"If you need health checks globally enabled in your application, but don't want to activate\n"
"Cassandra health checks, you can disable Cassandra health checks by setting the\n"
"`quarkus.cassandra.health.enabled` property to `false` in your `application.properties`."
msgstr "Si necesita que las comprobaciones de salud se activen globalmente en su aplicación, pero no desea activar las comprobaciones de salud de Cassandra, puede desactivarlas estableciendo la propiedad `quarkus.cassandra.health.enabled` en `false` en su `application.properties` ."

#. type: Title ==
#: _guides/cassandra.adoc
#, fuzzy, no-wrap
msgid "Metrics"
msgstr "Métrica"

#: _guides/cassandra.adoc
#, fuzzy
msgid ""
"The Cassandra Quarkus client can provide metrics about the Cassandra session and about individual\n"
"Cassandra nodes. It supports both Micrometer and MicroProfile."
msgstr "El cliente Cassandra Quarkus puede proporcionar métricas sobre la sesión Cassandra y sobre nodos Cassandra individuales. Es compatible tanto con Micrometer como con MicroProfile."

#: _guides/cassandra.adoc
#, fuzzy
msgid ""
"The first step to enable metrics is to add a few additional dependencies depending on the metrics\n"
"framework you plan to use."
msgstr "El primer paso para habilitar las métricas es añadir algunas dependencias adicionales en función del marco de métricas que piense utilizar."

#. type: Title ===
#: _guides/cassandra.adoc
#, fuzzy, no-wrap
msgid "Enabling Metrics with Micrometer"
msgstr "Habilitación de métricas con Micrometer"

#. type: Plain text
#: _guides/cassandra.adoc
#, fuzzy
msgid "Micrometer is the recommended metrics framework in Quarkus applications."
msgstr "Micrometer es el marco métrico recomendado en las aplicaciones de Quarkus."

#. type: Plain text
#: _guides/cassandra.adoc
#, fuzzy
msgid "To enable Micrometer metrics in your application, you need to add the following to your pom.xml."
msgstr "Para habilitar las métricas de Micrometer en su aplicación, debe añadir lo siguiente a su pom.xml."

#. type: Plain text
#: _guides/cassandra.adoc
#, fuzzy
msgid "This guide uses Micrometer, so the above dependencies are already included in this guide's pom.xml."
msgstr "Esta guía utiliza Micrometer, por lo que las dependencias anteriores ya están incluidas en el pom.xml de esta guía."

#. type: Title ===
#: _guides/cassandra.adoc
#, fuzzy, no-wrap
msgid "Enabling Metrics with MicroProfile Metrics"
msgstr "Habilitación de métricas con MicroProfile Metrics"

#. type: Plain text
#: _guides/cassandra.adoc
#, fuzzy
msgid "Remove any dependency to Micrometer from your pom.xml, then add the following ones instead:"
msgstr "Elimine cualquier dependencia de Micrometer de su pom.xml, y añada las siguientes en su lugar:"

#. type: Title ===
#: _guides/cassandra.adoc
#, fuzzy, no-wrap
msgid "Enabling Cassandra Metrics"
msgstr "Habilitación de las métricas de Cassandra"

#: _guides/cassandra.adoc
#, fuzzy
msgid ""
"Even when metrics are enabled in your application, the Cassandra client will not report any metrics,\n"
"unless you opt in for this feature. So your next step is to enable Cassandra metrics in your\n"
"`application.properties` file."
msgstr "Incluso cuando las métricas están habilitadas en su aplicación, el cliente Cassandra no informará de ninguna métrica, a menos que usted opte por esta característica. Así que su siguiente paso es habilitar las métricas de Cassandra en su archivo `application.properties` ."

#. type: Plain text
#: _guides/cassandra.adoc
#, fuzzy
msgid "That's it!"
msgstr "¡Eso es!"

#: _guides/cassandra.adoc
#, fuzzy
msgid ""
"The final (and optional) step is to customize which specific Cassandra metrics you would like the\n"
"Cassandra client to track. Several metrics can be tracked; if you skip this step, a default set of\n"
"useful metrics will be automatically tracked."
msgstr "El paso final (y opcional) es personalizar qué métricas específicas de Cassandra desea que rastree el cliente Cassandra. Se pueden rastrear varias métricas; si omite este paso, se rastreará automáticamente un conjunto predeterminado de métricas útiles."

#: _guides/cassandra.adoc
#, fuzzy
msgid ""
"For the full list of available metric names, please refer to the\n"
"link:https://docs.datastax.com/en/developer/java-driver/latest/manual/core/configuration/reference/[driver\n"
"settings reference] page; search for the `advanced.metrics` section.\n"
"Also, Cassandra driver metrics are covered in detail in the\n"
"https://docs.datastax.com/en/developer/java-driver/latest/manual/core/metrics/[driver manual]."
msgstr "Para obtener la lista completa de nombres de métricas disponibles, consulte la página de link:https://docs.datastax.com/en/developer/java-driver/latest/manual/core/configuration/reference/[referencia de configuración] del controlador; busque la sección `advanced.metrics` . Además, las métricas del controlador Cassandra se tratan en detalle en el link:https://docs.datastax.com/en/developer/java-driver/latest/manual/core/metrics/[manual del controlador] ."

#. type: Plain text
#: _guides/cassandra.adoc
#, fuzzy
msgid "If you do wish to customize which metrics to track, you should use the following properties:"
msgstr "Si desea personalizar las métricas a seguir, debe utilizar las siguientes propiedades:"

#: _guides/cassandra.adoc
#, fuzzy
msgid ""
"`quarkus.cassandra.metrics.session.enabled` should contain the session-level metrics to enable\n"
"(metrics that are global to the session)."
msgstr "`quarkus.cassandra.metrics.session.enabled` debe contener las métricas a nivel de sesión a habilitar (métricas que son globales a la sesión)."

#: _guides/cassandra.adoc
#, fuzzy
msgid ""
"`quarkus.cassandra.metrics.node.enabled` should contain the node-level metrics to enable (metrics\n"
"for which each node contacted by the Cassandra client gets its own metric value)."
msgstr "`quarkus.cassandra.metrics.node.enabled` debe contener las métricas a nivel de nodo a habilitar (métricas para las que cada nodo contactado por el cliente Cassandra obtiene su propio valor métrico)."

#. type: Plain text
#: _guides/cassandra.adoc
#, fuzzy
msgid "Both properties accept a comma-separated list of valid metric names."
msgstr "Ambas propiedades aceptan una lista separada por comas de nombres de métricas válidos."

#. type: Plain text
#: _guides/cassandra.adoc
#, fuzzy
msgid "For example, let's assume that you wish to enable the following three Cassandra metrics:"
msgstr "Por ejemplo, supongamos que desea activar las siguientes tres métricas de Cassandra:"

#. type: Plain text
#: _guides/cassandra.adoc
#, fuzzy
msgid "Session-level: `session.connected-nodes` and `session.bytes-sent`;"
msgstr "A nivel de sesión: `session.connected-nodes` y `session.bytes-sent`;"

#. type: Plain text
#: _guides/cassandra.adoc
#, fuzzy
msgid "Node-level: `node.pool.open-connections`."
msgstr "Nivel de nodo: `node.pool.open-connections`."

#. type: Plain text
#: _guides/cassandra.adoc
#, fuzzy
msgid "Then you should add the following settings to your `application.properties`:"
msgstr "A continuación, deberá añadir la siguiente configuración a su `application.properties`:"

#: _guides/cassandra.adoc
#, fuzzy
msgid ""
"This guide's `application.properties` file has already many metrics enabled; you can use its metrics\n"
"list as a good starting point for exposing useful Cassandra metrics in your application."
msgstr "El archivo `application.properties` de esta guía ya tiene muchas métricas habilitadas; puede utilizar su lista de métricas como un buen punto de partida para exponer métricas útiles de Cassandra en su aplicación."

#: _guides/cassandra.adoc
#, fuzzy
msgid ""
"When metrics are properly enabled, metric reports for all enabled metrics are available at the\n"
"`/metrics` REST endpoint of your application."
msgstr "Cuando las métricas están correctamente habilitadas, los informes de métricas para todas las métricas habilitadas están disponibles en el punto final REST `/metrics` de su aplicación."

#: _guides/cassandra.adoc
#, fuzzy
msgid ""
"Running in dev mode with `mvn clean quarkus:dev`, if you point your browser to\n"
"`http://localhost:8080/metrics` you should see a list of metrics; search for metrics whose names\n"
"contain `cassandra`."
msgstr "Ejecutando en modo dev con `mvn clean quarkus:dev` , si apunta su navegador a `http://localhost:8080/metrics` debería ver una lista de métricas; busque las métricas cuyos nombres contengan `cassandra` ."

#: _guides/cassandra.adoc
#, fuzzy
msgid ""
"For Cassandra metrics to show up, the Cassandra client needs to be initialized and\n"
"connected; if you are using lazy initialization (see below), you won't see any Cassandra metrics\n"
"until your application actually connects and hits the database for the first time."
msgstr "Para que aparezcan las métricas de Cassandra, el cliente Cassandra debe estar inicializado y conectado; si está utilizando la inicialización perezosa (ver más abajo), no verá ninguna métrica de Cassandra hasta que su aplicación se conecte realmente y acceda a la base de datos por primera vez."

#. type: Title ==
#: _guides/cassandra.adoc
#, fuzzy, no-wrap
msgid "Running in native mode"
msgstr "Funcionamiento en modo nativo"

#. type: Plain text
#: _guides/cassandra.adoc
#, fuzzy
msgid "If you installed GraalVM, you can xref:building-native-image.adoc[build a native image] using:"
msgstr "Si has instalado GraalVM, puedes  link:https://quarkus.io/guides/building-native-image[construir una imagen nativa] usando:"

#: _guides/cassandra.adoc
#, fuzzy
msgid ""
"Beware that native compilation can take a significant amount of time! Once the compilation is done,\n"
"you can run the native executable as follows:"
msgstr "Tenga en cuenta que la compilación nativa puede llevar un tiempo considerable. Una vez realizada la compilación, puede ejecutar el ejecutable nativo de la siguiente manera:"

#. type: Plain text
#: _guides/cassandra.adoc
#, fuzzy
msgid "You can then point your browser to `http://localhost:8080/fruits.html` and use your application."
msgstr "A continuación, puede dirigir su navegador a `&lt;a href=\"http://localhost:8080/fruits.html\" class=\"bare\"&gt;http://localhost:8080/fruits.html&lt;/a&gt;` y utilizar su aplicación."

#. type: Title ==
#: _guides/cassandra.adoc
#, fuzzy, no-wrap
msgid "Choosing between eager and lazy initialization"
msgstr "Inicialización ansiosa o perezosa"

#. type: Plain text
#: _guides/cassandra.adoc
#, fuzzy
msgid "As explained above, this extension allows you to inject many types of beans:"
msgstr "Esta extensión le permite inyectar"

#. type: Plain text
#: _guides/cassandra.adoc
#, fuzzy
msgid "A simple bean like `QuarkusCqlSession` or `FruitDao`;"
msgstr "un `QuarkusCqlSession` bean;"

#: _guides/cassandra.adoc
#, fuzzy
msgid ""
"The asynchronous version of that bean, for example `CompletionStage<QuarkusCqlSession>` or\n"
"`CompletionStage<FruitDao>;"
msgstr "La versión asíncrona de ese bean, por ejemplo `CompletionStage<QuarkusCqlSession>` o `CompletionStage<FruitDao>;"

#. type: Plain text
#: _guides/cassandra.adoc
#, fuzzy
msgid "The reactive version of that bean, for example `Uni<QuarkusCqlSession>` or `Uni<FruitDao>`."
msgstr "o la versión reactiva de este frijol, es decir, `Uni&amp;lt;QuarkusCqlSession&amp;gt;`."

#: _guides/cassandra.adoc
#, fuzzy
msgid ""
"The most straightforward approach is obviously to inject the bean directly. This should work just\n"
"fine for most applications. However, the `QuarkusCqlSession` bean, and all DAO beans that depend on\n"
"it, might take some time to initialize before they can be used for the first time, and this process\n"
"is blocking."
msgstr "El enfoque más sencillo es, obviamente, inyectar el bean directamente. Esto debería funcionar bien para la mayoría de las aplicaciones. Sin embargo, el frijol `QuarkusCqlSession` , y todos los frijoles DAO que dependen de él, pueden tardar algún tiempo en inicializarse antes de poder ser utilizados por primera vez, y este proceso es bloqueante."

#: _guides/cassandra.adoc
#, fuzzy
msgid ""
"Fortunately, it is possible to control when the initialization should happen: the\n"
"`quarkus.cassandra.init.eager-init` parameter determines if the `QuarkusCqlSession` bean should be\n"
"initialized on its first access (lazy) or when the application is starting (eager). The default\n"
"value of this parameter is `false`, meaning the init process is lazy: the `QuarkusCqlSession` bean\n"
"will be initialized lazily on its first access – for example, when there is a first REST request\n"
"that needs to interact with the Cassandra database."
msgstr "Afortunadamente, es posible controlar cuándo debe producirse la inicialización: el parámetro `quarkus.cassandra.init.eager-init` determina si el frijol `QuarkusCqlSession` debe inicializarse en su primer acceso (lazy) o cuando la aplicación se está iniciando (eager). El valor por defecto de este parámetro es `false` , lo que significa que el proceso de init es lazy: el bean `QuarkusCqlSession` se inicializará lazy en su primer acceso - por ejemplo, cuando haya una primera petición REST que necesite interactuar con la base de datos Cassandra."

#: _guides/cassandra.adoc
#, fuzzy
msgid ""
"Using lazy initialization speeds up your application startup time, and avoids startup failures if\n"
"the Cassandra database is not available. However, it could also prove dangerous if your code is\n"
"fully non-blocking, for example if it uses xref:reactive-routes.adoc[reactive routes].\n"
"Indeed, the lazy initialization could accidentally happen on a thread that is not allowed\n"
"to block, such as a Vert.x event loop thread. Therefore, setting `quarkus.cassandra.init.eager-init`\n"
"to `false` and injecting `QuarkusCqlSession` should be avoided in these contexts."
msgstr "Utilizar la inicialización perezosa acelera el tiempo de arranque de su aplicación y evita fallos de arranque si la base de datos Cassandra no está disponible. Sin embargo, también podría resultar peligroso si su código es totalmente no bloqueante, por ejemplo si utiliza xref:reactive-routes.adoc[rutas reactivas] . En efecto, la inicialización perezosa podría producirse accidentalmente en un hilo al que no se le permite bloquear, como un hilo de bucle de eventos Vert.x. Por lo tanto, fijar `quarkus.cassandra.init.eager-init` en `false` e inyectar `QuarkusCqlSession` debería evitarse en estos contextos."

#: _guides/cassandra.adoc
#, fuzzy
msgid ""
"If you want to use Vert.x (or any other non-blocking framework) and keep the lazy initialization\n"
"behavior, you should instead inject only a `CompletionStage` or a `Uni` of the desired bean. When\n"
"injecting these beans, the initialization process will be triggered lazily, but it will happen in\n"
"the background, in a non-blocking way, leveraging the Vert.x event loop. This way you don't risk\n"
"blocking the Vert.x thread."
msgstr "Si desea utilizar Vert.x (o cualquier otro framework no bloqueante) y mantener el comportamiento de inicialización perezosa, deberá inyectar en su lugar sólo un `CompletionStage` o un `Uni` del bean deseado. Al inyectar estos beans, el proceso de inicialización se desencadenará perezosamente, pero ocurrirá en segundo plano, de forma no bloqueante, aprovechando el bucle de eventos de Vert.x. De esta forma no se arriesga a bloquear el hilo de Vert.x."

#: _guides/cassandra.adoc
#, fuzzy
msgid ""
"Alternatively, you can set `quarkus.cassandra.init.eager-init` to true: in this case the session\n"
"bean and all DAO beans will be initialized eagerly during application startup, on the Quarkus main\n"
"thread. This would eliminate any risk of blocking a Vert.x thread, at the cost of making your\n"
"startup time (much) longer."
msgstr "Alternativamente, puede establecer `quarkus.cassandra.init.eager-init` a true: en este caso el bean de sesión y todos los beans DAO se inicializarán eagerly durante el arranque de la aplicación, en el hilo principal de Quarkus. Esto eliminaría cualquier riesgo de bloquear un hilo Vert.x, a costa de hacer que su tiempo de arranque sea (mucho) más largo."

#. type: Title ==
#: _guides/cassandra.adoc
#, fuzzy, no-wrap
msgid "Conclusion"
msgstr "Conclusión"

#: _guides/cassandra.adoc
#, fuzzy
msgid ""
"Accessing a Cassandra database from a client application is easy with Quarkus and the Cassandra\n"
"extension, which provides configuration and native support for the DataStax Java driver for Apache\n"
"Cassandra."
msgstr "Acceder a una base de datos Cassandra desde una aplicación cliente es fácil con Quarkus y la extensión Cassandra, que proporciona configuración y soporte nativo para el controlador Java de DataStax para Apache Cassandra."