Set up docs MCPAmazon Glue é um serviço de integração de dados totalmente gerenciado e sem servidor fornecido pela Amazon Web Services (AWS). Ele simplifica o processo de descoberta, preparação e transformação de dados para análise, aprendizado de máquina e desenvolvimento de aplicações.
Instalação
Para integrar seu código do Glue ao ClickHouse, você pode usar nosso Spark conector oficial no Glue de uma das seguintes formas:
- Instalar o ClickHouse Glue Conector pelo AWS Marketplace (recomendado).
- Adicionar manualmente os JARs do Spark Conector ao seu job do Glue.
Assinar o conector
Para acessar o conector na sua conta, assine o ClickHouse AWS Glue Conector no AWS Marketplace.
Conceder as permissões necessárias
Certifique-se de que a IAM role do seu job do Glue tenha as permissões necessárias, conforme descrito no guia de privilégios mínimos.
Ativar o conector e criar uma conexão
Após assinar, selecione a versão do Glue que corresponde aos requisitos do seu job. Na seção Additional details, em Usage instructions, clique no link para Open Glue Studio - Add ClickHouse connector. Isso abre a página de criação de conexão do Glue com os principais campos já preenchidos. Dê um nome à conexão e clique em Create (não é necessário informar os detalhes de conexão do ClickHouse nesta etapa).
Usar no job do Glue
No seu job do Glue, selecione a aba Job details e expanda a seção Advanced properties. Na seção Connections, selecione a conexão que você acabou de criar. O conector injeta automaticamente os JARs necessários no ambiente de execução do job.
Para adicionar manualmente os JARs necessários, siga estas etapas:
Fazer upload do JAR do conector
Faça upload do JAR mais recente do Spark conector (clickhouse-spark-runtime-3.X_2.X-0.10.X.jar) para um bucket do S3.
Conceder acesso ao bucket do S3
Certifique-se de que o job do Glue tenha acesso a esse bucket.
Configurar o caminho do JAR dependente
Na aba Job details, role para baixo, expanda o menu suspenso Advanced properties e preencha o caminho dos JARs em Dependent JARs path:
Usando o AWS Secrets Manager para credenciais
Em vez de definir manualmente o usuário e a senha do ClickHouse no job, armazene-os no AWS Secrets Manager e faça referência ao segredo na conexão do Glue ou no script do job. Em tempo de execução, o Glue busca o segredo e mescla seus pares chave-valor às opções de conexão do conector.
Criar o segredo
No AWS Secrets Manager, crie um segredo do tipo Outro tipo de segredo com pares chave-valor cujas chaves correspondam aos nomes das opções do conector:
| Chave | Valor |
|---|---|
user |
seu nome de usuário do ClickHouse |
password |
sua senha do ClickHouse |
Qualquer chave que você incluir no segredo será encaminhada ao conector, então você também pode armazenar host, database ou qualquer outra opção nele, caso queira mantê-los fora do código.
Faça referência ao segredo
Há duas maneiras de vincular o segredo a um job.
Opção 1: anexá-lo à conexão do Glue. Ao criar ou editar a conexão do ClickHouse no Glue Studio, defina o campo AWS secret com o nome do segredo. Qualquer job que use essa conexão resolverá o segredo automaticamente — sem necessidade de alterar o código.
Opção 2: passe secretId nas opções de conexão. Use esta opção quando o segredo não estiver anexado à conexão. Adicione secretId junto com 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"
)As chaves user e password do segredo são mescladas às opções do conector em tempo de execução, portanto você nunca precisará lê-las no seu script.
Exemplos
Os exemplos abaixo usam marketplace.spark e fazem referência ao conector por connectionName. Se você instalou o conector manualmente (aba Instalação manual), use connection_type="custom.spark" e passe className, host, http_port, user e password diretamente nas opções.
Se você associou um segredo da AWS à própria conexão (Opção 1 em Usando o AWS Secrets Manager para credenciais), remova secretId das opções — o Glue resolve as credenciais da conexão automaticamente.
Você pode usar o conector do ClickHouse como origem ou destino no editor visual do Glue Studio. Basta arrastar o componente ClickHouse Spark conector para a área de trabalho e conectá-lo ao pipeline de dados.
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 mais detalhes, consulte nossa documentação do Spark.