Configuração do contêiner do Agent Snowflake Connector for MySQL

Nota

O Snowflake Connector for MySQL está sujeito aos Termos do conector.

Este tópico descreve o procedimento para definir o contêiner de agente Snowflake Connector for MySQL. Um agente de conector de banco de dados é um aplicativo em contêiner que é executado dentro de sua infraestrutura, conectando-se diretamente aos seus bancos de dados e ao Snowflake.

O processo de configuração do agente Snowflake Connector for MySQL inclui as seguintes tarefas:

  1. Revisão dos pré-requisitos e escolha de um sistema de orquestração

  2. Configuração e execução do agente

  3. [Opcionalmente] Configuração da orquestração usando Kubernetes

  4. Monitoramento do agente

Revisão dos pré-requisitos e escolha de um sistema de orquestração

Revise e conclua todos os pré-requisitos e prossiga para Configuração e execução do agente.

Escolha de um sistema de orquestração de contêiner

O agente é empacotado como uma imagem de contêiner Docker padrão e pode ser executado em qualquer sistema de orquestração com suporte ao padrão. Pode ser uma instância autônoma do Docker, Kubernetes, RedHat OpenShift, uma solução gerenciada na nuvem, como AWS Fargate, dentre outras. Muitas vezes, sua organização terá um sistema preferencial existente para você usar.

Preste atenção à seção de configuração do agente deste documento, porque diferentes sistemas de orquestração apresentam diferentes restrições. Seu sistema, ou configuração específica, pode não permitir que você monte volumes graváveis (conforme é exigido com a opção de configuração primária do agente).

Exemplos posteriores se concentrarão no Kubernetes como o sistema de orquestração mais popular. A abordagem geralmente será semelhante em outros sistemas, e você precisará ajustar os exemplos para sua configuração.

Confirme os recursos do sistema necessários

  • O agente é um aplicativo que exige muita memória e requer um mínimo de 6GB de RAM para operar corretamente.

  • O número ideal de CPUs é 4. Menos CPUs pode diminuir o desempenho. Mais CPUs não melhorará o desempenho.

Configuração de conectividade

O agente precisa se conectar a todos os banco de dados de origem dos quais você pretende ler dados. Configure sua rede e firewalls para que conexões diretas sejam possíveis e a porta clássica do cliente MySQL esteja acessível. Normalmente é a porta 3306. Para obter mais informações, consulte Tabelas de referência de porta de MySQL.

Se seus bancos de dados de origem residirem em redes isoladas e a conexão a partir de um único agente não for possível, será necessário instalar instâncias adicionais do aplicativo nativo do conector, cada uma com seu próprio agente. Este recurso está atualmente em versão preliminar privada. Entre em contato com o suporte Snowflake para solicitar acesso.

O agente também se conecta diretamente à sua implementação do Snowflake. Para obter informações sobre quais nomes de host precisam estar disponíveis, consulte Permissão de nomes de host.

Se alguma das conexões do agente passar por um proxy, será necessário passar configuração adicional ao agente. Consulte Revisão das variáveis de ambiente de configuração opcionais.

Configuração e execução do agente

A configuração e execução do agente são compostas pelas seguintes etapas:

  1. Download do driver MariaDB JDBC

  2. [Opcional] Como obter e preparar certificados SSL para bancos de dados de origem

  3. Como preparar arquivos de configuração do agente ou as variáveis de ambiente para o agente e iniciar o agente

  4. Revisão das variáveis de ambiente de configuração opcionais

  5. Configuração da conectividade PrivateLink onde for necessário

Download do driver MariaDB JDBC

O agente usa esse driver para se conectar e interagir com bancos de dados MySQL. Apesar de ser nominalmente um driver para MariaDB, eles são compatíveis.

Devido às limitações de licenciamento, o driver JDBC não pode ser distribuído junto com o agente, e você terá que fornecê-lo. Baixe o MariaDB JDBC Connector 3.4.1 e salve-o em um diretório de onde você possa montá-lo no contêiner do agente.

[Opcional] Como obter e preparar certificados SSL para bancos de dados de origem

Quando o agente se conecta aos bancos de dados de origem via SSL, ele requer seus certificados para validar as conexões. Esses certificados devem estar disponíveis no Java Truststore dentro do contêiner do agente, no caminho /opt/java/openjdk/lib/security/cacerts.

A maneira mais simples de fornecer certificados ao agente é adicioná-los ao arquivo cacerts existente na máquina host e montar esse arquivo no contêiner em execução.

openssl x509 -outform der -in ca-root.pem -out ca-root.der
keytool -import -alias server-root \
    -keystore $JAVA_HOME/jre/lib/security/cacerrts -file ca-root.der
Copy

Como preparar a configuração do agente

O agente pode ser configurado por meio de arquivos JSON montados em contêiner, variáveis de ambiente ou uma mistura de ambos. As chaves de acesso necessárias para se conectar ao Snowflake podem ser montadas a partir do sistema de arquivo do host, fornecidas como segredos de contêiner ou variáveis de ambiente.

As seções a seguir descrevem diferentes opções de configuração, das mais simples às mais abrangentes. Escolha uma abordagem com base nas especificidades da infraestrutura.

A maneira mais simples de configurar o agente é montar dois arquivos JSON no contêiner em tempo de execução:

  • snowflake.json contém a configuração para o agente se conectar à sua conta Snowflake.

    Baixe este arquivo no final do processo de configuração do conector por meio do assistente disponível no Snowsight.

  • datasources.json contém a lista de bancos de dados de origem aos quais o agente se conectará.

    Você precisará preparar este arquivo por conta própria.

Logo após o download, snowflake.json inclui uma chave privada temporária para a conta de serviço Snowflake que representa o agente. Ao iniciar o agente pela primeira vez, ele substituirá automaticamente essa chave temporária por um novo conjunto de chaves definido permanentemente, e as saída para o caminho /home/agent/.ssh/ dentro do contêiner. Ambos snowflake.json e o caminho sob /home/agent/.ssh/ devem ser montados como graváveis para que o agente possa iniciar.

Como alternativa, você pode fornecer sua própria chave privada para a conta de serviço do agente. Consulte Revisão das variáveis de ambiente de configuração opcionais para as variáveis de ambiente que devem ser passadas.

Cuidado

Se o agente encontrar uma chave privada existente, seja como um arquivo montado ou como uma variável de ambiente, ele ignorará qualquer chave temporária que ainda possa estar presente em snowflake.json.

Prepare o arquivo datasources.json usando o seguinte modelo:

{
    "<data_source_name_1>": {
        "url": "jdbc:mariadb://<host>:<port>/[?<key1>=<value1>[&<key2>=<value2>]]",
        "username": "<mysql_db_username>",
        "password": "<mysql_db_password>"
    },
    "<data_source_name_2>": {
        "url": "jdbc:mariadb://<host>:<port>/[?<key1>=<value1>[&<key2>=<value2>]]",
        "username": "<mysql_db_username>",
        "password": "<mysql_db_password>"
    }
}
Copy

Ao criar o arquivo:

  • Você precisa adicionar pelo menos uma fonte de dados com um URL, caso contrário o agente não será iniciado.

  • É possível adicionar quantas fontes de dados precisar, desde que o agente possa se conectar diretamente a todas elas.

  • Os nomes inseridos se tornam os identificadores que você precisará mais tarde para chamar o aplicativo nativo do conector e habilitar a replicação. Eles devem ser exclusivos para cada fonte de dados.

  • Os nomes das fontes de dados podem conter apenas letras e números. Todas as letras minúsculas são automaticamente colocadas em maiúsculas pelo agente.

Após ter ambos os arquivos JSON no lugar, o arquivo JAR com os drivers JDBC e um diretório para saída do novo conjunto de chaves, será possível executar o contêiner:

docker run -d \
   --restart unless-stopped \
   --name database-connector-agent \
   --volume </path/to/ssh/keys/directory>:/home/agent/.ssh \
   --volume </path/to/mariadb/jdbc/jar>:/home/agent/libs/mariadb-jdbc-driver \
   --volume </path/to/snowflake/json/file>:/home/agent/snowflake.json \
   --volume </path/to/datasources/json/file>:/home/agent/datasources.json \
   -m 6g \
   snowflakedb/database-connector-agent:latest
Copy

Revisão das variáveis de ambiente de configuração opcionais

O agente oferece suporte às seguintes configurações opcionais, disponíveis ao configurar variáveis de ambiente adicionais no contêiner:

SNOWFLAKE_PRIVATEKEYPATH

Especifica o caminho absoluto para o arquivo com a chave privada do usuário do agente. Isso é usado ao montar sua própria chave privada no contêiner, geralmente por meio de um segredo do sistema de orquestração.

SNOWFLAKE_PRIVATEKEYPASSWORD

Especifica a senha para a chave privada do usuário do agente. Se você deixar o agente gerar as chaves, essa senha será definida na chave privada. Se você reutilizar chaves existentes, esta senha será usada para acessar a chave privada existente.

SNOWFLAKE_PRIVATEKEY

Especifica o conteúdo da chave privada do usuário do agente. Isso pode ser definido quando não for possível montar a chave privada como um arquivo no contêiner.

SNOWFLAKE_ENFORCEDURL

Especifica o URL da conexão ao Snowflake, substituindo o mecanismo de descoberta do próprio agente. Isso é usado principalmente para conectar-se a implementações do PrivateLink.

JAVA_OPTS

Especifica configurações ou propriedades Java adicionais que serão passadas para o processo do agente.

As mais comumente usadas são:

  • A opção -Xmx para definir o tamanho máximo do heap Java. A Snowflake recomenda configurar esse valor como a quantidade de memória disponível para o contêiner, menos 1GB.

    Por exemplo, se o contêiner tiver 6GB de RAM disponível, defina o seguinte:

    JAVA_OPTS=-Xmx5g
    
    Copy
  • Quando a conexão do agente ao Snowflake exigir um proxy, defina o seguinte:

    JAVA_OPTS=-Dhttp.useProxy=true -Dhttp.proxyHost=<proxy-host> -Dhttp.proxyPort=<proxy-port>
    
    Copy
  • Para ignorar o proxy para alguns hosts ou endereços IP, como bancos de dados de origem, defina a propriedade http.nonProxyHosts adicional. Use um símbolo de canal (|) para separar vários nomes de host. Use um asterisco (*) como caractere curinga.

    JAVA_OPTS=-Dhttp.useProxy=true -Dhttp.proxyHost=<proxy-host> -Dhttp.proxyPort=<proxy-port>
      -Dhttp.nonProxyHosts='*.my_company.com|localhost|myorganization-myaccount.snowflakecomputing.com|192.168.91.*'
    
    Copy
  • Para passar credenciais ao proxy, defina as propriedades do sistema http.proxyUser e http.proxyPassword.

    JAVA_OPTS=-Dhttp.useProxy=true -Dhttp.proxyHost=<proxy-host> -Dhttp.proxyPort=<proxy-port>
      -Dhttp.proxyUser=<proxy-user> -Dhttp.proxyPassword=<proxy-pass>
    
    Copy

Chaves de acesso Snowflake

O agente é autenticado no Snowflake como uma conta de serviço, criada pelo assistente de configuração do conector no Snowsight, usando um conjunto de chaves de acesso. O assistente de configuração cria chaves de acesso temporárias e adiciona a chave privada ao arquivo snowflake.json em um campo nomeado temporaryPrivateKey.

Durante sua inicialização, o agente substitui essas chaves temporárias:

  1. Gerando um novo conjunto de chaves de acesso e armazenando-as em /home/agent/.ssh como database-connector-agent-app-private-key.p8 e database-connector-agent-app-public-key.pub dentro do contêiner. Este diretório deve ser montado como um volume externo e gravável no contêiner, para que as chaves persistam quando o contêiner for desligado.

  2. Alterando sua conta de serviço para usar as novas chaves.

  3. Removendo o campo temporaryPrivateKey do arquivo snowflake.json.

Após a substituição inicial da chave, o agente nunca rotaciona as chaves de acesso.

É possível usar as chaves geradas pelo agente. Ou você pode criar seu próprio conjunto, alterar a conta de serviço e fornecer a chave privada ao agente.

A ordem de descoberta da chave privada do agente é:

  1. Qualquer chave passada usando a variável de ambiente SNOWFLAKE_PRIVATEKEY. Se esse valor for encontrado, o conector ignorará a chave temporária de snowflake.json.

  2. Chaves encontradas em volumes montados em /home/agent/.ssh/database-connector-agent-app-private-key.p8. Se este arquivo for encontrado, o conector ignorará a chave temporária de snowflake.json.

  3. O valor do campo temporaryPrivateKey do arquivo snowflake.json.

Configuração da orquestração usando Kubernetes

Nota

Embora esta seção se concentre no Kubernetes, o conector pode ser iniciado em qualquer sistema de orquestração de contêiner. As sintaxes de configuração geralmente são semelhantes. Para obter detalhes, consulte a documentação do seu sistema.

Ao usar o Kubernetes, normalmente não é possível montar volumes graváveis. Como resultado, o agente não poderá substituir automaticamente as chaves da conta de usuário do Snowflake. Você terá que criar um conjunto de chaves manualmente, alterar o usuário e então fornecer a chave privada ao contêiner que executa o agente, normalmente como um segredo montado. Para obter detalhes sobre como configurar pares de chaves para usuários Snowflake, consulte Configuração de autenticação de pares de chaves.

Recomendamos que você armazene os segredos em um local seguro, como o HashiCorp Vault. Essas lojas geralmente têm integrações existentes com o Kubernetes, por exemplo, o Vault oferece um operador especializado. Os detalhes da integração serão específicos para seu sistema de orquestração de contêiner e armazenamento seguro. Consulte a documentação respectiva para obter de detalhes.

O Kubernetes normalmente é executado em clusters de vários nós, sem nenhuma maneira de montar arquivos das máquinas host. Para fornecer os arquivos JSON de configuração ao contêiner do agente, é possível criar um Kubernetes ConfigMap armazenando todos os três arquivos.

A seguir, é mostrado um exemplo básico para configurar o agente no Kubernetes.

  1. Crie um ConfigMap que armazenará o driver JDBC e snowflake.json:

    kubectl create configmap database-connector-config \
      --from-file=jdbc-driver.jar=</path/to/mariadb/jdbc/jar> \
      --from-file=snowflake.json=</path/to/snowflake/json/file>
    
    Copy

    Dica

    O driver JDBC JAR tem um tamanho aproximado de 650KB, no momento em que este artigo foi escrito, e está bem abaixo do limite de ConfigMap de 1MB imposto pelo Kubernetes. Se preferir não colocar tantos dados em um ConfigMap, um padrão comum é criar uma imagem Docker personalizada, com base na imagem oficial do agente, com a adição do JDBC JAR.

  2. Crie um segredo que armazenará o conteúdo da chave privada do usuário do agente e datasources.json:

    kubectl create secret generic database-connector-secrets \
      --from-file=private-key=</path/to/private/key/file> \
      --from-file=datasources.json=</path/to/datasources.json>
    
    Copy
  3. Configure o Pod do agente, montando os arquivos de configuração e a chave privada como volumes:

    apiVersion: v1
    kind: Pod
    metadata:
      name: database-connector-agent
    spec:
      restartPolicy: Always
      containers:
        - name: database-connector-agent
          image: snowflakedb/database-connector-agent:latest
          resources:
            requests:
              memory: "6Gi"
            limits:
              memory: "8Gi"
          volumeMounts:
            - name: config
              mountPath: /home/agent/libs/jdbc-driver.jar
              subPath: jdbc-driver.jar
            - name: config
              mountPath: /home/agent/snowflake.json
              subPath: snowflake.json
            - name: secrets
              mountPath: /home/agent/datasources.json
              subPath: datasources.json
            - name: secrets
              mountPath: /etc/private-key/private-key
              subPath: private-key
          env:
            - name: MYSQL_DATASOURCE_DRIVERPATH
              value: /home/agent/libs/jdbc-driver.jar
            - name: SNOWFLAKE_PRIVATEKEYPATH
              value: /etc/private-key/private-key
      volumes:
        - name: config
          configMap:
            name: database-connector-config
        - name: secrets
          secret:
           secretName: database-connector-secrets
    
    Copy
  4. Salve a configuração do Pod como um arquivo YAML, por exemplo, database-connector.yaml e inicie:

    kubectl apply -f database-connector.yaml
    
    Copy

Monitoramento do agente

O contêiner do agente gera logs para stdout, que podem ser acessados usando o Docker. Por exemplo, se o nome do seu contêiner for database-connector-agent, o comando para exibição de logs seria:

docker container logs database-connector-agent
Copy

Esses logs também são transmitidos para o Snowflake. Consulte Monitoramento do Snowflake Connector for MySQL para obter informações sobre como acessá-los.

Como acessar o ponto de extremidade de verificação de integridade

O agente expõe um ponto de extremidade HTTP com informações de integridade. É possível usar esse ponto de extremidade ao executar o agente em um sistema de orquestração para determinar quando o agente foi totalmente iniciado e se ele está íntegro. O ponto de extremidade está disponível na porta 8080 e no caminho /actuator/health.

Para usar o ponto de extremidade como uma sonda de atividade no Kubernetes, adicione o seguinte à configuração de seu Pod:

apiVersion: v1
kind: Pod
spec:
  containers:
  - ...
    livenessProbe:
      httpGet:
        path: /actuator/health
        port: 8080
      initialDelaySeconds: 5
      periodSeconds: 10
Copy

Próximos passos

Após completar estes procedimentos, siga os passos em Configuração de replicação para o Snowflake Connector for MySQL.