Configure a synchronization task by using the codeless UI or code editor - DataWorks: Central de Documentação do Alibaba Cloud

Antes de começar

Para conectar uma fonte de dados PolarDB e executar tarefas de sincronização, conclua as etapas a seguir nesta ordem:

Adicione o bloco CIDR da Virtual Private Cloud (VPC) do seu grupo de recursos exclusivo à lista de permissões de endereços IP do cluster PolarDB for MySQL.
Crie uma conta de banco de dados com as permissões necessárias.
(Apenas para sincronização em tempo real) Ative o log binário no cluster.
Adicione a fonte de dados PolarDB no DataWorks.

Limitações

Sincronização em lote

É possível ler dados de views do banco de dados.

Sincronização em tempo real

Apenas clusters PolarDB for MySQL são compatíveis como origem.
O log binário deve estar ativado no cluster. O PolarDB for MySQL usa logs físicos de alto nível por padrão. Ative o log binário para integrar o cluster ao ecossistema MySQL e dar suporte a CDC em tempo real.

Escolha um modo de sincronização

O DataWorks oferece três modos de sincronização para o PolarDB. Consulte a tabela abaixo para escolher o modo mais adequado ao seu cenário.

Modo	Quando usar	Guia de configuração
Sincronização em lote — tabela única	Cargas periódicas de dados em massa de uma única tabela	Interface visual sem código ou editor de código
Sincronização em tempo real — tabela única ou banco de dados completo	CDC de baixa latência de uma única tabela ou de um banco de dados inteiro	Configurar uma tarefa de sincronização em tempo real (legado)
Sincronização de banco de dados completo (lote + tempo real)	Combinação de sincronização em lote com carga completa e sincronização incremental em tempo real ou de banco de dados completo	Configurar uma tarefa de sincronização de banco de dados completo em tempo real

Mapeamentos de tipos de dados

Leitura em lote (PolarDB Reader)

Categoria	Tipo de dados PolarDB	Observações
Inteiro	INT, TINYINT, SMALLINT, MEDIUMINT, BIGINT	TINYINT(1) é tratado como inteiro, não como booleano
Ponto flutuante	FLOAT, DOUBLE, DECIMAL
String	VARCHAR, CHAR, TINYTEXT, TEXT, MEDIUMTEXT, LONGTEXT
Data e hora	DATE, DATETIME, TIMESTAMP, TIME, YEAR
Booleano	BIT, BOOL
Binário	TINYBLOB, MEDIUMBLOB, BLOB, LONGBLOB, VARBINARY

Tipos de dados não listados acima não têm suporte.

Escrita em lote (PolarDB Writer)

Categoria	Tipo de dados PolarDB	Observações
Inteiro	INT, TINYINT, SMALLINT, MEDIUMINT, BIGINT, YEAR	YEAR é classificado como Inteiro para escrita (não como Data e hora)
Ponto flutuante	FLOAT, DOUBLE, DECIMAL
String	VARCHAR, CHAR, TINYTEXT, TEXT, MEDIUMTEXT, LONGTEXT
Data e hora	DATE, DATETIME, TIMESTAMP, TIME	YEAR não pertence a esta categoria para escrita
Booleano	BOOL	BIT não tem suporte para escrita
Binário	TINYBLOB, MEDIUMBLOB, BLOB, LONGBLOB, VARBINARY

Configure o ambiente PolarDB

Configure uma lista de permissões de endereços IP

Adicione o bloco CIDR da VPC onde reside seu grupo de recursos exclusivo para Data Integration à lista de permissões de endereços IP do cluster PolarDB for MySQL.

Crie uma conta com as permissões necessárias

Crie uma conta de banco de dados para o cluster PolarDB for MySQL. Consulte Criar e gerenciar contas de banco de dados.

Conceda as permissões necessárias à conta. Execute a instrução SQL a seguir ou atribua diretamente a função SUPER.

-- CREATE USER 'Account for data synchronization'@'%' IDENTIFIED BY 'Account for data synchronization';
GRANT SELECT, REPLICATION SLAVE, REPLICATION CLIENT ON *.* TO 'Account for data synchronization'@'%';

Ative o log binário (apenas sincronização em tempo real)

Ative o log binário no cluster antes de configurar uma tarefa de sincronização em tempo real. Consulte Ativar log binário.

Adicione uma fonte de dados

Adicione a fonte de dados PolarDB ao DataWorks antes de desenvolver uma tarefa de sincronização. Para obter o procedimento completo e as descrições dos parâmetros, consulte Gerenciamento de fontes de dados.

Referência do editor de código

As seções a seguir descrevem os parâmetros JSON usados na configuração de tarefas de sincronização em lote no editor de código. Para ver o formato geral do script, consulte Configurar uma tarefa no editor de código.

PolarDB Reader

O exemplo a seguir lê uma única tabela com fragmentação de dados e limitação de largura de banda ativadas.

{
    "type": "job",
    "steps": [
        {
            "parameter": {
                "datasource": "test_005",
                "column": [
                    "id",
                    "name",
                    "age",
                    "sex",
                    "salary",
                    "interest"
                ],
                "where": "id=1001",
                "splitPk": "id",
                "table": "PolarDB_person",
                "useReadonly": "false"
            },
            "name": "Reader",
            "category": "reader"
        },
        {
            "parameter": {}
        }
    ],
    "version": "2.0",
    "order": {
        "hops": [
            {
                "from": "Reader",
                "to": "Writer"
            }
        ]
    },
    "setting": {
        "errorLimit": {
            "record": ""
        },
        "speed": {
            "concurrent": 6,
            "throttle": true,
            "mbps": "12"
        }
    }
}

Parâmetros do PolarDB Reader

Parâmetro	Obrigatório	Padrão	Descrição
`datasource`	Sim	—	Nome da fonte de dados. Deve corresponder ao nome adicionado no DataWorks.
`table`	Sim	—	Nome da tabela de origem da leitura.
`column`	Sim	—	Array JSON com nomes das colunas. Use `["*"]` para ler todas as colunas. Aceita constantes e expressões SQL. Não pode ficar em branco.
`useReadonly`	Não	`false`	Defina como `true` para ler do banco de dados secundário (divisão de leitura/escrita). O padrão é ler do banco de dados primário.
`splitPk`	Não	—	Campo usado para fragmentação de dados. Apenas tipos inteiros; use a chave primária para distribuição uniforme. Se deixado em branco, os dados serão lidos com uma única thread.
`splitFactor`	Não	`5`	Fator de fragmentação. Número de shards = threads paralelas × fator de fragmentação. Mantenha este valor entre 1 e 100; valores acima de 100 podem causar erros de falta de memória (OOM).
`where`	Não	—	Cláusula WHERE para filtragem de linhas, como `gmt_create>$bizdate` para leituras incrementais. Definir isso como `limit 10` não tem suporte.
`querySql`	Não	—	Instrução SQL avançada para filtragem personalizada, como junção de múltiplas tabelas. Quando especificado, substitui `column`, `table`, `where` e `splitPk`. Disponível apenas no editor de código.

PolarDB Writer

O exemplo abaixo escreve em uma única tabela usando o modo insert.

{
    "type": "job",
    "steps": [
        {
            "parameter": {},
            "name": "Reader",
            "category": "reader"
        },
        {
            "parameter": {
                "postSql": [],
                "datasource": "test_005",
                "column": [
                    "id",
                    "name",
                    "age",
                    "sex",
                    "salary",
                    "interest"
                ],
                "writeMode": "insert",
                "batchSize": 256,
                "table": "PolarDB_person_copy",
                "preSql": []
            },
            "name": "Writer",
            "category": "writer"
        }
    ],
    "version": "2.0",
    "order": {
        "hops": [
            {
                "from": "Reader",
                "to": "Writer"
            }
        ]
    },
    "setting": {
        "errorLimit": {
            "record": ""
        },
        "speed": {
            "throttle": true,
            "concurrent": 6,
            "mbps": "12"
        }
    }
}

Parâmetros do PolarDB Writer

Parâmetro	Obrigatório	Padrão	Descrição
`datasource`	Sim	—	Nome da fonte de dados. Deve corresponder ao nome adicionado no DataWorks.
`table`	Sim	—	Nome da tabela de destino.
`column`	Sim	—	Array JSON com nomes das colunas a serem escritas. Use `["*"]` para todas as colunas. Exemplo: `["id","name","age"]`.
`writeMode`	Não	`insert`	Modo de escrita. Consulte Comportamento do modo de escrita. O PolarDB for PostgreSQL aceita apenas `insert`.
`preSql`	Não	—	SQL a ser executado antes da tarefa, como uma instrução para excluir dados obsoletos. A interface visual sem código aceita uma instrução; o editor de código aceita várias.
`postSql`	Não	—	SQL a ser executado após a tarefa, como uma instrução para adicionar um carimbo de data/hora. A interface visual sem código aceita uma instrução; o editor de código aceita várias.
`batchSize`	Não	`1,024`	Quantidade de registros a serem escritos por lote. Valores maiores reduzem as idas e vindas (round trips), mas aumentam o uso de memória. Valores excessivamente altos podem causar erros OOM.
`updateColumn`	Não	—	Colunas a serem atualizadas quando ocorrer conflito de chave primária ou índice único. Tem efeito apenas quando `writeMode` é `update`. Compatível apenas com PolarDB for MySQL.

Comportamento do modo de escrita

Os três modos de escrita tratam linhas sem conflitos da mesma forma (equivalente a INSERT INTO). A diferença entre eles está no tratamento de conflitos de chave primária ou índice único.

Modo	Equivalente na UI	Comportamento em conflito	Quando usar
`insert`	INSERT INTO	Linhas conflitantes são ignoradas e contadas como dados incorretos	Para ignorar duplicatas
`update`	ON DUPLICATE KEY UPDATE	Linhas conflitantes são atualizadas com novos valores das colunas especificadas	Para atualizar registros existentes localmente
`replace`	REPLACE INTO	Linhas conflitantes são excluídas e novas linhas são inseridas (todos os campos substituídos)	Para sobrescrever totalmente registros existentes

Exemplos de dados

Os exemplos a seguir demonstram como cada modo lida com um conflito na coluna id.

Tabela de origem:

+----+----------+-----+
| id | name     | age |
+----+----------+-----+
|  1 | zhangsan |   1 |
|  2 | lisi     |     |
+----+----------+-----+

Tabela de destino original:

+----+--------+-----+
| id | name   | age |
+----+--------+-----+
|  2 | wangwu |   3 |
+----+--------+-----+

Resultado de insert — o conflito na linha 2 é ignorado; a linha 1 é inserida:

+----+----------+-----+
| id | name     | age |
+----+----------+-----+
|  1 | zhangsan |   1 |
|  2 | wangwu   |   3 |
+----+----------+-----+

Resultado de update (cenário 1: apenas algumas colunas especificadas — "column": ["id","name"]) — a linha 1 é inserida; a linha 2 é atualizada com o valor de nome da origem, mas idade mantém o valor original do destino:

+----+----------+-----+
| id | name     | age |
+----+----------+-----+
|  1 | zhangsan |   1 |
|  2 | lisi     |   3 |
+----+----------+-----+

Resultado de update (cenário 2: todas as colunas especificadas — "column": ["id","name","age"]) — a linha 2 é atualizada com todos os valores da origem:

+----+----------+-----+
| id | name     | age |
+----+----------+-----+
|  1 | zhangsan |   1 |
|  2 | lisi     |     |
+----+----------+-----+

Resultado de replace — a linha 2 é excluída e reinserida com os valores da origem:

+----+----------+-----+
| id | name     | age |
+----+----------+-----+
|  1 | zhangsan |   1 |
|  2 | lisi     |     |
+----+----------+-----+

Nota

Para o PolarDB for PostgreSQL, apenas o modo insert tem suporte. Para evitar conflitos de chave primária, adicione uma instrução TRUNCATE em preSql para limpar a tabela de destino antes da execução da tarefa ou trate a deduplicação em um nó upstream.

Perguntas frequentes

Por que erros são relatados repetidamente quando uma tarefa de sincronização em tempo real é executada para sincronizar dados do Oracle, PolarDB ou MySQL?