{"id":17010,"date":"2025-04-07T10:48:50","date_gmt":"2025-04-07T17:48:50","guid":{"rendered":"https:\/\/www.couchbase.com\/blog\/?p=17010"},"modified":"2025-07-08T09:15:31","modified_gmt":"2025-07-08T16:15:31","slug":"pyspark-ga-couchbase-spark-connector","status":"publish","type":"post","link":"https:\/\/www.couchbase.com\/blog\/es\/pyspark-ga-couchbase-spark-connector\/","title":{"rendered":"Cree aplicaciones AI\/ML altamente escalables con Couchbase y PySpark"},"content":{"rendered":"

Nos complace anunciar la disponibilidad general (GA) de la compatibilidad de Python con Conector Spark de Couchbase<\/a>que aporta una integraci\u00f3n de primera clase entre Couchbase Server y Apache Spark<\/a> a los ingenieros de datos de Python. Esta versi\u00f3n GA significa que el conector est\u00e1 listo para producci\u00f3n y totalmente soportado, permitiendo a las aplicaciones PySpark leer y escribir sin problemas en Couchbase. Con la base de datos NoSQL de alto rendimiento de Couchbase (con lenguaje de consulta SQL++\/SQL++) y el motor de procesamiento distribuido de Spark, los ingenieros de datos pueden ahora combinar f\u00e1cilmente estas tecnolog\u00edas para construir pipelines de datos y flujos de trabajo anal\u00edticos r\u00e1pidos y escalables. En resumen, el conector Spark de Couchbase para PySpark desbloquea la integraci\u00f3n de datos eficiente y paralela, lo que le permite aprovechar Spark para ETL\/ELT, an\u00e1lisis en tiempo real, aprendizaje autom\u00e1tico y mucho m\u00e1s en los datos almacenados en Couchbase.<\/p>\n

En este post, cubriremos c\u00f3mo empezar con el conector PySpark, demostraremos operaciones b\u00e1sicas de lectura\/escritura (tanto clave-valor como basadas en consultas) para bases de datos operacionales Couchbase y bases de datos Columnar Capella; y compartiremos consejos de ajuste de rendimiento para obtener el mejor rendimiento. Tanto si has estado utilizando el conector Spark de Couchbase en Scala, como si eres nuevo en la integraci\u00f3n Couchbase-Spark, esta gu\u00eda te ayudar\u00e1 a utilizar r\u00e1pidamente PySpark para tus necesidades de ingenier\u00eda de datos.<\/p>\n

\u00bfPor qu\u00e9 PySpark?<\/h2>\n

La incorporaci\u00f3n de PySpark al conector Spark de Couchbase se debe a la creciente demanda de ingenieros de datos y desarrolladores que prefieren Python por su sencillez y el ecosistema masivo de Python ML para Spark en los flujos de trabajo de ingenier\u00eda y ciencia de datos. Este soporte garantiza que los equipos que ya utilizan Python puedan ahora integrar Couchbase (tanto si utiliza Couchbase Capella (DBaaS)<\/a>, base de datos operativa autogestionada<\/a> o Capella Columnar<\/a> ) en flujos de trabajo Spark basados en Python, lo que permite una adopci\u00f3n m\u00e1s amplia y procesos de datos racionalizados.<\/p>\n

El dominio de Python en los casos de uso de IA\/ML, respaldado por marcos como SparkML, PyTorch, TensorFlow, H2O, DataRobot, scikit-learn y SageMaker, as\u00ed como herramientas populares de an\u00e1lisis exploratorio de datos como Matplotlib y Plotly, subraya a\u00fan m\u00e1s la necesidad de integraci\u00f3n de PySpark. Adem\u00e1s, la compatibilidad con PySpark permite acelerar los procesos ETL y ML aprovechando la aceleraci\u00f3n de la GPU (Spark RAPIDS) y facilita sofisticadas tareas de ingenier\u00eda de caracter\u00edsticas y manipulaci\u00f3n de datos utilizando bibliotecas ampliamente adoptadas como Pandas, NumPy y las API de ingenier\u00eda de caracter\u00edsticas integradas en Spark. Este nuevo soporte agiliza significativamente los procesos de datos y ampl\u00eda las oportunidades de adopci\u00f3n de Couchbase en equipos de ingenier\u00eda y ciencia de datos.<\/p>\n

Primeros pasos con Couchbase PySpark<\/h2>\n

Empezar es muy sencillo. El conector Spark de Couchbase se distribuye como un \u00fanico archivo JAR (Java archive) que puedes a\u00f1adir a tu entorno Spark. Puedes obtener el conector en la p\u00e1gina oficial Sitio de descarga de Couchbase<\/a> o a trav\u00e9s de Coordenadas Maven<\/a>. Una vez que tengas el JAR, usarlo en PySpark es tan sencillo como configurar tu sesi\u00f3n Spark con la configuraci\u00f3n del conector y la conexi\u00f3n a Couchbase.<\/p>\n

1. Obtener o crear una base de datos operativa Couchbase o una base de datos Columnar Capella.<\/b><\/p>\n

La forma m\u00e1s r\u00e1pida de empezar con Couchbase es utilizar nuestra aplicaci\u00f3n Capella DBaaS<\/a>. Una vez all\u00ed, puede buscar su base de datos existente o crear una operativo<\/a> o columnar<\/a> (para an\u00e1lisis). Tambi\u00e9n puede utilizar nuestra Couchbase autogestionado<\/a>.<\/p>\n

2. Instale PySpark (si no lo est\u00e1 ya)<\/b><\/p>\n

Si est\u00e1s trabajando en un entorno Python, instala PySpark usando pip. Por ejemplo, en un entorno virtual:<\/p>\n

pip install pyspark<\/pre>\n
Esto instalar\u00e1 Apache Spark para su uso con Python. Si est\u00e1 ejecutando en un cl\u00faster Spark o Databricks existente, es posible que PySpark ya est\u00e9 disponible.<\/p>\n
3. Incluye el JAR del conector Spark de Couchbase<\/b><\/p>\n
Descargar<\/a> el spark-connector-assembly-.jar<\/code> para la \u00faltima versi\u00f3n del conector. Entonces, cuando crees tu sesi\u00f3n Spark o env\u00edes tu trabajo, proporciona este JAR en la configuraci\u00f3n. Puedes hacerlo estableciendo el par\u00e1metro --jarras<\/code> opci\u00f3n en spark-submit<\/code> o a trav\u00e9s del constructor SparkSession en c\u00f3digo (como se muestra a continuaci\u00f3n).<\/p>\n
4. Configurar la conexi\u00f3n Couchbase<\/b><\/p>\n
Es necesario especificar la cadena de conexi\u00f3n del cl\u00faster Couchbase y las credenciales (nombre de usuario y contrase\u00f1a). En Capella, puede encontrar esto en la pesta\u00f1a \"Conectar\" para las aplicaciones operativas y de gesti\u00f3n. Configuraci\u00f3n->Cadena de conexi\u00f3n<\/strong> para columnar. Opcionalmente, especifique un cubo o \u00e1mbito por defecto si es necesario (aunque tambi\u00e9n puede especificar cubo\/\u00e1mbito por operaci\u00f3n).<\/p>\n
A continuaci\u00f3n ejemplo r\u00e1pido de PySpark<\/b> que establece un SparkSession<\/code> para conectarse a un cl\u00faster Couchbase y luego lee algunos datos:<\/p>\n
from pyspark.sql import SparkSession\r\n# Inicializar SparkSession con conector Couchbase y configuraci\u00f3n de la conexi\u00f3n\r\n\r\nspark = SparkSession.builder \\\r\n    .appName(\"CouchbaseIntegrationExample\") \\\r\n    .master(\"local[*]\") \\ # usando Spark local por ejemplo; omitir o ajustar para cluster Spark\r\n    .config(\"spark.jars\", \"\/ruta\/a\/spark-conector-assembly-.jar\") \\\r\n    .config(\"spark.couchbase.connectionString\", \"couchbases:\/\/\") \\\r\n    .config(\"spark.couchbase.username\", \"\") \\\r\n    .config(\"spark.couchbase.password\", \"\") \\\r\n    .getOrCreate()\r\n\r\n# Prueba la conexi\u00f3n leyendo algunos documentos de Couchbase (usando un bucket de ejemplo)\r\ndf = spark.read.format(\"couchbase.query\") \\\r\n    .option(\"bucket\", \"bucket_name\") \\\r\n    .option(\"scope\", \"scope_name\") \\\r\n    .option(\"colecci\u00f3n\", \"nombre_colecci\u00f3n\") \\\r\n    .load()\r\n\r\ndf.printEsquema()\r\ndf.show(5)<\/pre>\n
En el c\u00f3digo anterior, configuramos la sesi\u00f3n de Spark para incluir el conector JAR de Couchbase y apuntarlo a un cluster de Couchbase. A continuaci\u00f3n creamos un DataFrame df<\/code> leyendo del nombre_cubo<\/code> cubo (concretamente el scope_name.collection_name<\/code> ) a trav\u00e9s del servicio de consulta.<\/p>\n
Para el resto de este documento, supondremos que ha cargado nuestro conjunto de datos de muestra viaje-muestra <\/a>que se puede hacer para Couchbase Capella operativa<\/a> o Columnar<\/a> muy f\u00e1cilmente.<\/p>\n
Lectura\/escritura en Couchbase usando PySpark<\/h2>\n
Una vez que tu sesi\u00f3n de Spark est\u00e1 conectada a Couchbase, puedes realizar ambas operaciones operaciones clave-valor<\/b> (para escrituras) y operaciones de consulta<\/b> (utilizando SQL++ tanto para lectura como para escritura) a trav\u00e9s de DataFrames.<\/p>\n
La siguiente tabla muestra el formato que soporta el conector Sparks para leer y escribir en Couchbase y bases de datos columnares:<\/p>\n\n\n\n\n\n
<\/td>\nBase de datos operativa Couchbase\/Capella<\/b><\/td>\nCapella Base de datos columnar<\/b><\/td>\n<\/tr>\n
Leer las operaciones<\/td>\nread.format(\"couchbase.query\")<\/code><\/td>\nread.format(\"couchbase.columnar\")<\/code><\/td>\n<\/tr>\n
Operaciones de escritura<\/td>\n(se recomienda utilizar el Servicio de Datos)<\/p>\n
write.format(\"couchbase.kv\")<\/code><\/p>\n
write.format(\"couchbase.query\")<\/code><\/td>\n
write.format(\"couchbase.columnar\")<\/code><\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
Lectura desde Couchbase con un DataFrame de consulta<\/h3>\n
El conector Spark de Couchbase te permite cargar datos desde un bucket de Couchbase como un Spark DataFrame a trav\u00e9s de consultas SQL++. Uso del lector DataFrame con formato couchbase.query<\/code>puede especificar un bucket (y \u00e1mbito\/colecci\u00f3n) y par\u00e1metros de consulta opcionales. Por ejemplo, para leer todos los documentos de una colecci\u00f3n o un subconjunto definido por un filtro:<\/p>\n
# Leer todos los documentos de una colecci\u00f3n Couchbase utilizando el servicio Query\r\nairlines_df = spark.read.format(\"couchbase.query\") \\\r\n    .option(\"bucket\", \"muestra-viaje\") \\\r\n    .option(\"scope\", \"inventory\") \\\r\n    .option(\"collection\", \"airline\") \\\r\n    .load()\r\n\r\n# Ejemplo: filtrar el DataFrame usando Spark (se enviar\u00e1 a Couchbase cuando sea posible)\r\nusa_airlines_df = airlines_df.filter(\"pais = 'Estados Unidos'\")\r\nusa_airlines_df.show(5)<\/pre>\n
En este ejemplo, aerol\u00edneas_df<\/code> carga todos los documentos del viajes-muestra.inventario.aerolinea<\/code> en un Spark DataFrame. A continuaci\u00f3n, aplicamos un filtro para encontrar las aerol\u00edneas con sede en Estados Unidos. El conector intentar\u00e1 empujar hacia abajo<\/a> a Couchbase para que no se transfieran datos innecesarios (es decir, incluir\u00e1 los filtros WHERE pa\u00eds = \"Estados Unidos<\/code> en la consulta SQL++ que ejecuta, si es posible). El resultado, usa_airlines_df<\/code>se puede utilizar como cualquier otro DataFrame en Spark (por ejemplo, se puede unir con otros DataFrames, aplicar agregaciones, etc.).<\/p>\n
Bajo el cap\u00f3, el tabiques conectores<\/a> los resultados de la consulta en varias tareas si se ha configurado (m\u00e1s informaci\u00f3n al respecto en Ajuste del rendimiento<\/i> m\u00e1s abajo), y utiliza el servicio de consultas de Couchbase (impulsado por el motor SQL++) para recuperar los datos. Cada partici\u00f3n de Spark corresponde a un subconjunto de datos recuperados por una consulta SQL++ equivalente. Esto permite lecturas paralelas desde Couchbase, aprovechando la naturaleza distribuida tanto de Spark como de Couchbase.<\/p>\n
Escritura en Couchbase con operaciones clave-valor (KV) (recomendado)<\/h3>\n
El conector tambi\u00e9n admite la escritura de datos en Couchbase, ya sea a trav\u00e9s de la aplicaci\u00f3n Servicio de datos (KV)<\/b> o a trav\u00e9s del servicio Query (ejecuci\u00f3n de SQL++ INSERTAR\/UPSERTAR<\/code> comandos para usted). En recomendado<\/b> para la mayor\u00eda de los casos de uso es utilizar el Fuente de datos clave-valor<\/b> (format(\"couchbase.kv\")<\/code>) para mejor rendimiento<\/a>. En el modo clave-valor, cada tarea Spark escribir\u00e1 documentos directamente en los nodos de datos de Couchbase.<\/p>\n
Al escribir un DataFrame en Couchbase, debes asegurarte de que existe un ID \u00fanico para cada documento (ya que Couchbase requiere un ID de documento). Por defecto, el conector busca una columna llamada __META_ID<\/code> (o META_ID<\/code> en versiones m\u00e1s recientes) en el DataFrame para el ID del documento. Tambi\u00e9n puede especificar un campo ID personalizado a trav\u00e9s de la opci\u00f3n IdFieldName<\/code> opci\u00f3n.<\/p>\n
Por ejemplo, supongamos que tenemos un Spark DataFrame nuevas_lineas_aereas_df<\/code> que queremos escribir en Couchbase. Tiene una columna airline_id<\/code> que debe servir como clave del documento de Couchbase, y el resto de columnas son el contenido del documento:<\/p>\n
# Supongamos que new_airlines_df es un DataFrame que queremos escribir en Couchbase\r\n# Contiene una columna \"airline_id\" para usarla como ID del documento.\r\nnew_airlines_df.write.format(\"couchbase.kv\") \\\r\n    .option(\"bucket\", \"mybucket\") \\\r\n    .option(\"scope\", \"myscope\") \\\r\n    .option(\"collection\", \"airlines\") \\\r\n    .option(\"idFieldName\", \"airline_id\") \\\r\n    .save()<\/pre>\n
Escribir en Couchbase con operaciones de consulta (SQL++)<\/h3>\n
Aunque recomendamos utilizar el servicio de datos (KV) como se ha indicado anteriormente, ya que suele ser m\u00e1s r\u00e1pido que el servicio de consulta, si lo prefiere, tambi\u00e9n puede escribir a trav\u00e9s del servicio de consulta utilizando format(\"couchbase.query\")<\/code> en escritura. Esto ejecutar\u00e1 internamente sentencias UPSERT de SQL++ para cada fila. Esto puede ser \u00fatil si necesita aprovechar una caracter\u00edstica de SQL++ (por ejemplo, transformaciones del lado del servidor), pero para inserciones\/actualizaciones directas, el enfoque KV es m\u00e1s eficiente.<\/p>\n
df.write.format(\"couchbase.query\") \\\r\n    .option(\"bucket\", \"mybucket\") \\\r\n    .option(\"scope\", \"myscope\") \\\r\n    .option(\"collection\", \"airlines\") \\\r\n    .mode(\"sobrescribir\") \\\r\n    .save()<\/pre>\n
En la siguiente secci\u00f3n, vamos a modificar estos casos b\u00e1sicos de lectura\/escritura para el \u00faltimo producto anal\u00edtico de Couchbase - Capella Columnar.<\/p>\n
Compatibilidad de PySpark con Capella Columnar<\/h2>\n
Una de las principales novedades de Couchbase Spark Connector GA es el soporte de Capella Columnar. Capella Columnar es un servicio de base de datos anal\u00edtica nativa JSON en Couchbase Capella que almacena datos en un formato orientado a columnas para anal\u00edtica de alto rendimiento.<\/p>\n
Lectura de datos en formato columnar con PySpark<\/h3>\n
La lectura de datos de un cluster Couchbase Capella Columnar en PySpark es similar al cluster operacional couchbase excepto por tres cambios:<\/p>\n
    \n
  1. Utiliza el format(\"couchbase.columnar\")<\/code> para especificar que la conexi\u00f3n es para servicio en columna.<\/li>\n
  2. La cadena de conexi\u00f3n para columnar puede recuperarse desde Capella UI.<\/li>\n
  3. Tambi\u00e9n puede especificar el conjunto de datos que desea cargar proporcionando como opciones los nombres de la base de datos, el \u00e1mbito y la colecci\u00f3n (de forma an\u00e1loga a bucket\/scope\/collection en Couchbase)<\/li>\n<\/ol>\n
    Una vez configurado Spark, puede utilizar la API del lector Spark DataFrame para cargar datos del servicio columnar:<\/p>\n
    from pyspark.sql import SparkSession\r\n# Inicializar SparkSession con la configuraci\u00f3n de Couchbase (suponiendo que el conector est\u00e9 disponible)\r\nspark = SparkSession.builder \\\r\n    .appName(\"Couchbase Spark Connector Columnar Example\") \\\r\n    .config(\"spark.couchbase.connectionString\", \"couchbases:\/\/su.columnar.connection.string\") \\\r\n    .config(\"spark.couchbase.username\", \"YourColumnarUsername\") \\\r\n    .config(\"spark.couchbase.password\", \"YourColumnarPassword\") \\\r\n    .getOrCreate()\r\n\r\n# Leer un DataFrame de Couchbase Capella Columnar (travel-sample.inventory.airline collection)\r\nairlines_df = spark.read.format(\"couchbase.columnar\") \\\r\n    .option(\"database\", \"travel-sample\") \\\r\n    .option(\"\u00e1mbito\", \"inventario\") \\\r\n    .option(\"collection\", \"airline\") \\\r\n    .load()<\/pre>\n
    En este ejemplo, el resultado aerol\u00edneas_df<\/code> es un DataFrame de Spark normal - puedes inspeccionarlo, ejecutar transformaciones y realizar acciones como .count()<\/code> o .mostrar()<\/code> como de costumbre. Por ejemplo, airlines_df.show(5)<\/code> imprimir\u00e1 algunos documentos de la aerol\u00ednea, y airlines_df.count()<\/code> devolver\u00e1 el n\u00famero de documentos de la colecci\u00f3n. Bajo el cap\u00f3, el conector infiere autom\u00e1ticamente un esquema para los documentos JSON muestreando hasta un cierto n\u00famero de registros (por defecto 1000). Todos los campos que aparecen de forma consistente en los documentos muestreados se convierten en columnas en el DataFrame, con los tipos de datos Spark apropiados.<\/p>\n
    Tenga en cuenta que si sus documentos tienen esquemas variables, la inferencia puede producir un esquema que incluya la uni\u00f3n de todos los campos (los campos no presentes en algunos documentos ser\u00e1n nulos en esas filas). En los casos en los que el esquema evoluciona o en los que desea restringir los registros que se tienen en cuenta, puede proporcionar un filtro expl\u00edcito (predicado) al lector, como se describe a continuaci\u00f3n.<\/p>\n
    Consulta de un conjunto de datos columnares en Couchbase a trav\u00e9s de Spark<\/h3>\n
    A menudo puede que no desee cargar una colecci\u00f3n completa, especialmente si es grande. Puede optimizar el rendimiento enviando predicados de filtro directamente al servicio Columnar de Capella al cargar los datos, evitando la transferencia innecesaria de datos. Utilice .option(\"filtro\", \"\")<\/code> para aplicar una cl\u00e1usula WHERE de SQL++ durante la operaci\u00f3n de lectura. Por ejemplo, para cargar solo las aerol\u00edneas con sede en Estados Unidos:<\/p>\n
    usa_airlines_df = spark.read.format(\"couchbase.columnar\") \\\r\n    .option(\"database\", \"travel-sample\") \\\r\n    .option(\"scope\", \"inventory\") \\\r\n    .option(\"collection\", \"airline\") \\\r\n    .option(\"filter\", \"country = 'United States'\") \\\r\n    .load()\r\n\r\nprint(usa_airlines_df.count()) # S\u00f3lo aerol\u00edneas cuyo pa\u00eds = 'Estados Unidos'<\/pre>\n
    El conector ejecuta este filtro directamente en la fuente, recuperando s\u00f3lo los documentos relevantes. Tambi\u00e9n puede realizar proyecciones (seleccionando campos espec\u00edficos) y agregaciones en algunos casos. agregados simples<\/a> como CONTAR<\/code>, MIN<\/code>, MAX<\/code>y SUM<\/code> al motor Columnar siempre que sea posible, en lugar de calcularlos en Spark, para mejorar el rendimiento.<\/p>\n
    Una vez cargados los datos en un DataFrame, puede realizar las operaciones est\u00e1ndar de Transformaciones Spark<\/a>y agregaciones. Por ejemplo, para contar las aerol\u00edneas por pa\u00eds utilizando Spark SQL, puede incluso crear una vista temporal para ejecutar consultas Spark SQL en los datos de la siguiente manera:<\/p>\n
    airlines_df.createOrReplaceTempView(\"airlines_view\")\r\nresult_df = spark.sql(\"\"\r\n    SELECT pa\u00eds, COUNT(*) COMO recuento_l\u00edneas_a\u00e9reas\r\n    FROM airlines_view\r\n    GROUP BY pa\u00eds\r\n    ORDER BY recuento_l\u00edneas a\u00e9reas DESC\r\n\"\"\")\r\nresult_df.show(10)<\/pre>\n
    Esta consulta se ejecuta \u00edntegramente en el motor Spark, lo que aporta flexibilidad para integrar los datos de Couchbase sin problemas en flujos de trabajo anal\u00edticos complejos.<\/p>\n
    Habiendo cubierto las lecturas y escrituras b\u00e1sicas, pasemos a c\u00f3mo puedes ajustar el rendimiento al mover grandes vol\u00famenes de datos entre Couchbase y Spark.<\/p>\n
    Consejos para mejorar el rendimiento<\/h2>\n
    Para maximizar el rendimiento y la eficiencia al utilizar el conector PySpark de Couchbase, ten en cuenta las siguientes pr\u00e1cticas recomendadas.<\/p>\n
    Ajuste de las operaciones de lectura<\/h3>\n
    Utilizar el particionamiento de consultas para el paralelismo<\/b>
    \n(    Couchbase Capella (DBaaS)<\/a>, base de datos operativa autogestionada<\/a> o Capella Columnar<\/a>)<\/p>\n
    Cuando lea a trav\u00e9s del servicio de consulta para bases de datos operativas o columnares, aproveche la capacidad del conector para particionar los resultados de la consulta. Puede especificar una partitionCount<\/a> (y un campo de partici\u00f3n num\u00e9rico con l\u00edmites inferior\/superior) para la lectura del DataFrame. Una buena regla general es establecer partitionCount<\/code> a al menos el n\u00famero total de n\u00facleos de CPU del servicio de consulta<\/b> disponibles en tu cl\u00faster Couchbase. Esto asegura que Spark ejecutar\u00e1 m\u00faltiples consultas en paralelo, aprovechando todos los nodos de consulta. Por ejemplo, si el servicio de consultas de tu cluster Couchbase tiene 8 n\u00facleos en total, establece partitionCount >= 8<\/code> para que se emitan al menos 8 consultas SQL++ paralelas. Esto puede aumentar dr\u00e1sticamente el rendimiento de lectura mediante la utilizaci\u00f3n de todos los nodos de consulta simult\u00e1neamente. Tenga en cuenta que debe tener suficientes n\u00facleos en su cl\u00faster Spark para ejecutar tantas consultas paralelas.<\/p>\n
    Aprovechar los \u00edndices de cobertura para mejorar la eficacia de las consultas
    \n<\/b>(    Couchbase Capella (DBaaS)<\/a>, base de datos operativa autogestionada<\/a>)
    \n<\/b><\/p>\n
    Si utiliza consultas SQL++, intente realizar la consulta a trav\u00e9s de \u00edndices de cobertura<\/a> siempre que sea posible. Un \u00edndice de cobertura es un \u00edndice que incluye todos<\/i> que necesita la consulta, de modo que \u00e9sta pueda realizarse \u00edntegramente a partir del \u00edndice sin tener que recurrir al servicio de datos. Las consultas cubiertas evitan el salto de red adicional para obtener documentos completos, por lo que mejores resultados<\/b>. Dise\u00f1e sus \u00edndices secundarios de Couchbase para incluir los campos sobre los que filtra y<\/i> los campos que devuelve, si es factible. Esto podr\u00eda significar la creaci\u00f3n de \u00edndices espec\u00edficos para tus trabajos Spark que cubran exactamente los datos necesarios.<\/p>\n
    Garantizar r\u00e9plicas de \u00edndices para evitar cuellos de botella
    \n<\/b>(    Couchbase Capella (DBaaS)<\/a>, base de datos operativa autogestionada<\/a>)<\/p>\n
    Adem\u00e1s de utilizar \u00edndices de cobertura, aseg\u00farese de que sus \u00edndices est\u00e1n replicados en varios nodos de \u00edndice. Replicaci\u00f3n de \u00edndices<\/a> no s\u00f3lo proporciona alta disponibilidad, sino que tambi\u00e9n permite que las consultas sean carga equilibrada entre copias de \u00edndices en diferentes nodos para un mayor rendimiento<\/b>. En la pr\u00e1ctica, si tienes (por ejemplo) 3 nodos de \u00edndice, replicar \u00edndices importantes entre ellos significa que las consultas paralelas del conector Spark pueden golpear diferentes nodos de \u00edndice en lugar de golpear todos un solo nodo.<\/p>\n
    Ajuste de las operaciones de escritura<\/h3>\n
    Prefiera el servicio Datos para escrituras masivas<\/b>
    \n(    Couchbase Capella (DBaaS)<\/a>, base de datos operativa autogestionada<\/a>)<\/p>\n
    Recomendamos utilizar la fuente de datos clave-valor (Servicio de datos<\/a>) en lugar del servicio de consulta para las operaciones de escritura. La escritura a trav\u00e9s del servicio Data (KV upserts directos) suele ser varias veces m\u00e1s r\u00e1pido<\/b> que las inserciones basadas en SQL++. De hecho, las pruebas comparativas internas han demostrado que escribir a trav\u00e9s de KV puede rondar el 3 veces m\u00e1s r\u00e1pido<\/i> que utilizando SQL++ en los trabajos de Spark. Esto se debe a que el servicio de datos puede ingerir documentos en paralelo directamente en los nodos responsables, con una latencia menor por operaci\u00f3n. Ten en cuenta que los \u00edndices se actualizan por separado, si es necesario, para esos nuevos documentos, ya que las escrituras KV no activar\u00e1n autom\u00e1ticamente actualizaciones de \u00edndices m\u00e1s all\u00e1 del \u00edndice primario.<\/p>\n
    Aumentar las particiones de escritura para las escrituras del servicio de consulta<\/b>
    \n(    Couchbase Capella (DBaaS)<\/a>, base de datos operativa autogestionada<\/a>)<\/p>\n
    Aunque no es recomendable, si decide utilizar couchbase.query<\/code> para escribir (por ejemplo, si se realizan transformaciones del lado del servidor mientras se escribe), optimiza el rendimiento utilizando un n\u00famero elevado de particiones de escritura. Puedes reparticionar tu DataFrame antes de escribir para que Spark ejecute muchas tareas de escritura concurrentes. Una pauta aproximada es utilizar del orden de cientos de particiones<\/b> para escrituras a gran escala mediante SQL++. Por ejemplo, utilizando 128 particiones por nodo de consulta CPU<\/i> es un punto de partida que algunos usuarios han encontrado efectivo. Esto significa que si tiene 8 n\u00facleos de consulta, pruebe con ~1024 particiones. La idea es inundar el servicio de consulta con suficientes sentencias UPSERT paralelas para maximizar el rendimiento. Ten cuidado y encuentra el equilibrio adecuado para tu cluster - una concurrencia demasiado alta podr\u00eda sobrecargar el servicio de consultas. Monitoriza el rendimiento de consultas de Couchbase y aj\u00fastalo en consecuencia.<\/p>\n
    Siguiendo estos consejos de ajuste - alineando los recuentos de particiones con los recursos del cl\u00faster, indexando inteligentemente y eligiendo el servicio adecuado para el trabajo - puedes lograr un rendimiento \u00f3ptimo para la integraci\u00f3n Couchbase-Spark. No pierdas de vista las m\u00e9tricas de trabajo de Spark y las estad\u00edsticas de rendimiento de Couchbase (disponibles en la interfaz de usuario y los registros de Couchbase) para identificar cualquier cuello de botella (por ejemplo, si un nodo de consulta est\u00e1 haciendo todo el trabajo, o si la red est\u00e1 saturada) y ajusta la configuraci\u00f3n seg\u00fan sea necesario.<\/p>\n
    Comunidad y apoyo<\/h2>\n
    El soporte de Couchbase PySpark se basa en Couchbase Spark Connector para Couchbase y es de c\u00f3digo abierto<\/a>y le animamos a que contribuya, nos haga llegar sus comentarios y se una a la conversaci\u00f3n. documentaci\u00f3n<\/a>\u00fanete al Foros de Couchbase<\/a> o Couchbase Discord<\/a>.<\/p>\n
    Para saber m\u00e1s<\/h2>\n
    Para m\u00e1s informaci\u00f3n y documentaci\u00f3n detallada, consulte la p\u00e1gina oficial Documentaci\u00f3n de Couchbase Spark Connector<\/a> y la secci\u00f3n correspondiente sobre PySpark<\/a>:<\/p>\n