Criar conectores personalizados - AWS Glue
Adição de conectores ao AWS Glue Studio

Criar conectores personalizados

Você também pode construir seu próprio conector e depois carregar o código do conector no AWS Glue Studio.

Os conectores personalizados são integrados ao AWS Glue Studio pela API de runtime do Spark no AWS Glue. O runtime do Spark no AWS Glue permite conectar qualquer conector compatível com a interface do Spark, Athena ou JDBC. Ele permite que você insira qualquer opção de conexão que esteja disponível com o conector personalizado.

Você pode encapsular todas as suas propriedades de conexão com conexões do AWS Glue e fornecer o nome da conexão ao seu trabalho de ETL. A integração com conexões do Data Catalog permite que você use as mesmas propriedades de conexão em várias chamadas em uma única aplicação Spark ou em diferentes aplicações.

Você pode especificar opções adicionais para a conexão. O script de trabalho que o AWS Glue Studio gera contém uma entrada Datasource que usa a conexão para ligar o conector com as opções de conexão especificadas. Por exemplo:

Datasource = glueContext.create_dynamic_frame.from_options(connection_type = 
"custom.jdbc", connection_options = {"dbTable":"Account","connectionName":"my-custom-jdbc-
connection"}, transformation_ctx = "DataSource0")
Para adicionar um conector personalizado ao AWS Glue Studio

  1. Crie o código para o seu conector personalizado. Para ter mais informações, consulte Desenvolvimento de conectores personalizados.

  2. Adicione suporte ao seu conector para os recursos do AWS Glue. Aqui estão alguns exemplos desses recursos e como eles são usados dentro do script de trabalho gerado pelo AWS Glue Studio:

    • Data type mapping (Mapeamento de tipo de dados): seu conector pode converter os tipos das colunas ao lê-las a partir do datastore subjacente. Por exemplo, um dataTypeMapping de {"INTEGER":"STRING"} converte todas as colunas do tipo Integer para colunas do tipo String ao analisar os registros e construir o DynamicFrame. Isso ajuda os usuários a converter colunas para tipos de sua escolha.

      DataSource0 = glueContext.create_dynamic_frame.from_options(connection_type 
= "custom.jdbc", connection_options = {"dataTypeMapping":{"INTEGER":"STRING"}", 
connectionName":"test-connection-jdbc"}, transformation_ctx = "DataSource0")

    • Partitioning for parallel reads (Particionamento para leituras paralelas): o AWS Glue permite leituras de dados paralelas do datastore ao particionar os dados em uma coluna. Você deve especificar a coluna de partição, o limite de partição inferior, o limite de partição superior e o número de partições. Esse recurso permite que você faça uso do paralelismo de dados e de vários executores do Spark alocados para a aplicação do Spark.

      DataSource0 = glueContext.create_dynamic_frame.from_options(connection_type 
= "custom.jdbc", connection_options = {"upperBound":"200","numPartitions":"4",
"partitionColumn":"id","lowerBound":"0","connectionName":"test-connection-jdbc"},
transformation_ctx = "DataSource0")

    • Usar o AWS Secrets Manager para armazenar credenciais): a conexão do Data Catalog também pode conter um secretId para um segredo armazenado no AWS Secrets Manager. O segredo da AWS pode armazenar com segurança informações de autenticação e credenciais e fornecê-las ao AWS Glue em runtime. Como alternativa, você pode especificar o secretId no script do Spark da seguinte forma:

      DataSource = glueContext.create_dynamic_frame.from_options(connection_type 
= "custom.jdbc", connection_options = {"connectionName":"test-connection-jdbc",
 "secretId"-> "my-secret-id"}, transformation_ctx = "DataSource0")

    • Filtrando os dados de origem com predicados de linha e projeções de coluna: o runtime do Spark no AWS Glue também permite que os usuários propaguem consultas SQL para filtrar dados na origem com predicados de linha e projeções de coluna. Isso permite que seu trabalho de ETL carregue dados filtrados mais rapidamente a partir de armazenamentos de dados que suportam propagações. Uma consulta SQL de exemplo enviada para uma origem dos dados JDBC é: SELECT id, name, department FROM department WHERE id < 200.

      DataSource = glueContext.create_dynamic_frame.from_options(connection_type = 
"custom.jdbc", connection_options = {"query":"SELECT id, name, department FROM department 
WHERE id < 200","connectionName":"test-connection-jdbc"}, transformation_ctx = 
"DataSource0")

    • Marcadores de trabalho: o AWS Glue suporta carregamento incremental de dados de fontes JDBC. O AWS Glue mantém o controle do último registro processado do datastore e processa novos registros de dados nas execuções de trabalho de ETL subsequentes. Os marcadores de trabalho usam a chave primária como a coluna padrão para a chave do marcador, desde que essa coluna aumente ou diminua sequencialmente. Para obter mais informações sobre marcadores de trabalhos, consulte Marcadores de trabalho no Guia do desenvolvedor do AWS Glue.

      DataSource0 = glueContext.create_dynamic_frame.from_options(connection_type = 
"custom.jdbc", connection_options = {"jobBookmarkKeys":["empno"], "jobBookmarkKeysSortOrder"
:"asc", "connectionName":"test-connection-jdbc"}, transformation_ctx = "DataSource0")

  3. Empacote o conector personalizado como um arquivo JAR e carregue-o no Amazon S3.

  4. Teste seu conector personalizado. Para obter mais informações, consulte as instruções no GitHub em Glue Custom Connectors: Local Validation Tests Guide (Conectores personalizados do Glue: guia de testes de validação local).

  5. No console do AWS Glue Studio, escolha Connectors (Conectores), no painel de navegação do console.

  6. Na página Connectors (Conectores) escolha Create custom connector (Criar um conector personalizado).

  7. Na página Create custom connector (Criar um conector personalizado), insira as informações a seguir:

    • O caminho para o local do arquivo JAR do código personalizado no Amazon S3.

    • Um nome para o conector que será usado pelo AWS Glue Studio.

    • Seu tipo de conector, que pode ser JDBC, Spark ou Athena.

    • O nome do ponto de entrada dentro do código personalizado que o AWS Glue Studio chama para usar o conector.

      • Para conectores JDBC, esse campo deve ser o nome da classe do driver do JDBC.

      • Para conectores do Spark, esse campo deve ser o nome da classe da origem dos dados totalmente qualificada, ou seu alias, que você usa ao carregar a origem dos dados do Spark com o operador format.

    • (Somente JDBC) o URL base usado pela conexão JDBC para o datastore.

    • (Opcional) uma descrição do conector personalizado.

  8. Escolha Create connector (Criar conector).

  9. Na página Connectors (Conectores), crie uma conexão que use esse conector, conforme descrito em Criar conexões para conectores.

Adição de conectores ao AWS Glue Studio

Um conector é um pedaço de código que facilita a comunicação entre o datastore e o AWS Glue. Você pode assinar um conector oferecido no AWS Marketplace ou pode criar seu próprio conector personalizado.

Assinatura dos conectores do AWS Marketplace

O AWS Glue Studio facilita a adição de conectores do AWS Marketplace.

Para adicionar um conector do AWS Marketplace no AWS Glue Studio

  1. No console do AWS Glue Studio, escolha Connectors (Conectores), no painel de navegação do console.

  2. Na página Conectores, escolha Ir para o AWS Marketplace.

  3. No AWS Marketplace, em Featured products (Produtos em destaque), escolha o conector que você deseja usar. Você pode escolher um dos conectores em destaque ou usar a pesquisa. Você pode pesquisar o nome ou tipo de conector e usar opções para refinar os resultados da pesquisa.

    Se você desejar usar um dos conectores em destaque, escolha View product (Ver produto). Se você usou a pesquisa para localizar um conector, escolha o nome do conector.

  4. Na página de produto do conector, use as guias para visualizar informações sobre o conector. Se você decidir adquirir esse conector, escolha Continue to Subscribe (Continuar para assinar).

  5. Forneça as informações de pagamento e escolha Continue to Configure (Continuar para configurar).

  6. Na página Configure this software (Configurar este software), escolha o método de implantação e a versão do conector a serem usados. Em seguida, escolha Continue to Launch (Continuar para iniciar).

  7. Na página Lauch this software (Iniciar este software), você pode analisar as Usage Instructions (Instruções de uso) fornecidas pelo provedor do conector. Quando estiver pronto para continuar, escolha Ativar conexão no AWS Glue Studio.

    Após um curto período, o console apresenta a pagina Create marketplace connection (Criar conexão com o marketplace) no AWS Glue Studio.

  8. Crie uma conexão que use esse conector, conforme descrito em Criar conexões para conectores.

    Como alternativa, você pode escolher Activate connector only (Ativar somente conector) para ignorar a criação de uma conexão no momento. Você deve criar uma conexão em uma data posterior para que possa usar o conector.