Set up docs MCPAmazon Glue es un servicio de integración de datos sin servidor y totalmente gestionado de Amazon Web Services (AWS). Simplifica el proceso de descubrir, preparar y transformar datos para tareas de análisis, aprendizaje automático y desarrollo de aplicaciones.
Instalación
Para integrar su código de Glue con ClickHouse, puede usar nuestro conector de Spark oficial en Glue de una de las siguientes maneras:
- Instalar el conector de ClickHouse Glue desde AWS Marketplace (recomendado).
- Añadir manualmente los JARs del Spark Connector a su job de Glue.
Suscribirse al conector
Para acceder al conector en su cuenta, suscríbase al ClickHouse AWS Glue conector desde AWS Marketplace.
Conceder los permisos necesarios
Asegúrese de que el IAM role de su job de Glue tenga los permisos necesarios, como se describe en la guía de privilegios mínimos.
Activar el conector y crear una conexión
Después de suscribirse, seleccione la versión de Glue que coincida con los requisitos de su job. En la sección Additional details, en Usage instructions, haga clic en el enlace para Open Glue Studio - Add ClickHouse connector. Esto abre la página de creación de conexiones de Glue con los campos clave ya rellenados. Asigne un nombre a la conexión y haga clic en Create (no es necesario proporcionar los detalles de conexión de ClickHouse en esta etapa).
Usarlo en un job de Glue
En su job de Glue, seleccione la pestaña Job details y expanda la ventana Advanced properties. En la sección Connections, seleccione la conexión que acaba de crear. El conector inyecta automáticamente los JARs necesarios en el entorno de ejecución del job.
Para añadir manualmente los JARs necesarios, siga estos pasos:
Cargar el JAR del conector
Cargue el JAR más reciente del conector de Spark (clickhouse-spark-runtime-3.X_2.X-0.10.X.jar) en un bucket de S3.
Conceder acceso al bucket de S3
Asegúrese de que el job de Glue tenga acceso a este bucket.
Configurar la ruta de JAR dependientes
En la pestaña Job details, desplácese hacia abajo, expanda el menú desplegable Advanced properties y complete la ruta de los JARs en Dependent JARs path:
Uso de AWS Secrets Manager para las credenciales
En lugar de incluir de forma fija el usuario y la contraseña de ClickHouse en el job, guárdalos en AWS Secrets Manager y haz referencia al secreto desde tu conexión de Glue o el script del job. En tiempo de ejecución, Glue obtiene el secreto y combina sus pares clave-valor en las opciones de conexión del conector.
Crear el secreto
En AWS Secrets Manager, crea un secreto de tipo Otro tipo de secreto con pares clave-valor cuyas claves coincidan con los nombres de las opciones del conector:
| Clave | Valor |
|---|---|
user |
tu nombre de usuario de ClickHouse |
password |
tu contraseña de ClickHouse |
Cualquier clave que incluyas en el secreto se pasa al conector, así que también puedes almacenar host, database o cualquier otra opción allí si quieres mantenerlos fuera del código.
Referenciar el secreto
Hay dos formas de vincular el secreto a un job.
Opción 1: adjuntarlo a la conexión de Glue. Al crear o editar la conexión de ClickHouse en Glue Studio, establece el campo AWS secret con el nombre del secreto. Cualquier job que use esta conexión resolverá el secreto automáticamente, sin necesidad de cambiar el código.
Opción 2: pasar secretId en las opciones de conexión. Úsalo cuando el secreto no esté adjunto a la conexión. Agrega secretId junto con connectionName:
source = glueContext.create_dynamic_frame.from_options(
connection_type="marketplace.spark",
connection_options={
"connectionName": "<your-connection-name>",
"secretId": "clickhouse/glue/credentials",
"database": "default",
"table": "example_table"
},
transformation_ctx="clickhouse_source"
)val source = glueContext.getSource(
connectionType = "marketplace.spark",
connectionOptions = JsonOptions(Map(
"connectionName" -> "<your-connection-name>",
"secretId" -> "clickhouse/glue/credentials",
"database" -> "default",
"table" -> "example_table"
)),
transformationContext = "clickhouseSource"
)Las claves user y password del secreto se combinan con las opciones del conector en tiempo de ejecución, por lo que nunca necesitas leerlas en tu script.
Ejemplos
Los ejemplos siguientes usan marketplace.spark y hacen referencia al conector mediante connectionName. Si instaló el conector manualmente (pestaña Instalación manual), use connection_type="custom.spark" y pase className, host, http_port, user y password directamente en las opciones.
Si asoció un secreto de AWS a la propia conexión (opción 1 en Uso de AWS Secrets Manager para credenciales), elimine secretId de las opciones: Glue obtiene las credenciales de la conexión automáticamente.
Puede usar el conector de ClickHouse como origen o destino en el editor visual de Glue Studio. Solo tiene que arrastrar el componente ClickHouse Spark Connector al lienzo y conectarlo a su pipeline de datos.
import com.amazonaws.services.glue.GlueContext
import com.amazonaws.services.glue.util.{GlueArgParser, Job, JsonOptions}
import org.apache.spark.SparkContext
import scala.collection.JavaConverters._
object ClickHouseGlueExample {
def main(sysArgs: Array[String]): Unit = {
val args = GlueArgParser.getResolvedOptions(sysArgs, Seq("JOB_NAME").toArray)
val sc = new SparkContext()
val glueContext = new GlueContext(sc)
Job.init(args("JOB_NAME"), glueContext, args.asJava)
val readOptions = JsonOptions(Map(
"connectionName" -> "<your-connection-name>",
"secretId" -> "clickhouse/glue/credentials",
"database" -> "default",
"table" -> "example_table"
))
val source = glueContext.getSource(
connectionType = "marketplace.spark",
connectionOptions = readOptions,
transformationContext = "clickhouseSource"
)
val dyf = source.getDynamicFrame()
val writeOptions = JsonOptions(Map(
"connectionName" -> "<your-connection-name>",
"secretId" -> "clickhouse/glue/credentials",
"database" -> "default",
"table" -> "target_table"
))
glueContext.getSink(
connectionType = "marketplace.spark",
connectionOptions = writeOptions
).writeDynamicFrame(dyf)
Job.commit()
}
}import sys
from awsglue.utils import getResolvedOptions
from pyspark.context import SparkContext
from awsglue.context import GlueContext
from awsglue.job import Job
args = getResolvedOptions(sys.argv, ['JOB_NAME'])
sc = SparkContext()
glueContext = GlueContext(sc)
logger = glueContext.get_logger()
job = Job(glueContext)
job.init(args['JOB_NAME'], args)
read_options = {
"connectionName": "<your-connection-name>",
"secretId": "clickhouse/glue/credentials",
"database": "default",
"table": "example_table"
}
source = glueContext.create_dynamic_frame.from_options(
connection_type="marketplace.spark",
connection_options=read_options,
transformation_ctx="clickhouse_source"
)
dyf = source
logger.info(f"Read {dyf.count()} rows from ClickHouse")
write_options = {
"connectionName": "<your-connection-name>",
"secretId": "clickhouse/glue/credentials",
"database": "default",
"table": "target_table"
}
glueContext.write_dynamic_frame.from_options(
frame=dyf,
connection_type="marketplace.spark",
connection_options=write_options,
transformation_ctx="clickhouse_sink"
)
job.commit()Para obtener más información, visite nuestra documentación de Spark.