Integrando o Amazon Glue ao ClickHouse e ao Spark

Integre o ClickHouse ao Amazon Glue

Amazon 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.

AWS Marketplace

1. Assinar o conector

   Para acessar o conector na sua conta, assine o ClickHouse AWS Glue Conector no AWS Marketplace.

2. 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.

3. 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).

4. 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.

   Certifique-se de selecionar a versão do conector que corresponde à configuração do seu job do Glue:

   • Glue 4: Spark 3.3, Scala 2, Python 3
   • Glue 5: Spark 3.5, Scala 2, Python 3

Instalação manual

Para adicionar manualmente os JARs necessários, siga estas etapas:

1. 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.

2. Conceder acesso ao bucket do S3

   Certifique-se de que o job do Glue tenha acesso a esse bucket.

3. 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:

Python

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"
)

Scala

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.

Editor visual

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.

Scala

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()
  }
}

Python

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.