Pular para o conteúdo principal

API de execução de instruções: Executar SQL em warehouses

important

Para acessar as APIs REST da Databricks, o senhor deve se autenticar.

Este tutorial mostra aos senhores como usar o Databricks SQL Statement Execution API 2.0 para executar SQL declarações de Databricks SQL armazéns.

Para acessar view a referência Databricks SQL Statement Execution API 2.0, consulte Statement Execution.

Antes de começar​

Antes de começar este tutorial, certifique-se de que o senhor tenha:

  • Ou Databricks CLI versão 0.205 ou acima ou curl, como segue:

nota

O procedimento a seguir usa a CLI do Databricks para criar um perfil de configuração do Databricks com o nome DEFAULT. Se você já tiver um perfil de configuração DEFAULT, esse procedimento substitui seu perfil de configuração DEFAULT existente.

Para verificar se você já tem um perfil de configuração DEFAULT e para ver as configurações desse perfil, se ele existir, use a CLI do Databricks para executar o comando databricks auth env --profile DEFAULT.

Para criar um perfil de configuração com um nome diferente de DEFAULT, substitua a parte DEFAULT de --profile DEFAULT no comando databricks configure a seguir por um nome diferente para o perfil de configuração.

  1. Use o para criar Databricks CLI um Databricks perfil de configuração chamado DEFAULT que usa a Databricks autenticação de tokens de acesso pessoal. Para fazer isso, execute o seguinte comando:
Bash
databricks configure --profile DEFAULT

  1. No prompt Databricks Host, digite o Databricks workspace URL da instância, por https://1234567890123456.7.gcp.databricks.com exemplo,.

  2. Para o prompt Access token pessoal , insira o access token pessoal do Databricks para seu workspace

Nos exemplos de CLI do Databricks deste tutorial, observe o seguinte:

  • Este tutorial pressupõe que o senhor tenha uma variável de ambiente DATABRICKS_SQL_WAREHOUSE_ID em seu computador de desenvolvimento local. Essa variável de ambiente representa o ID de seu armazém Databricks SQL. Essa ID é a sequência de letras e números que segue /sql/1.0/warehouses/ no campo HTTP path (caminho HTTP ) do seu depósito. Para saber como obter o valor do caminho HTTP do seu depósito, consulte Obter detalhes da conexão para um recurso Databricks compute.

  • Se o senhor usar o comando Windows shell em vez de um comando shell para Unix, Linux ou macOS, substitua \ por ^ e ${...} por %...%.

  • Se o senhor usar o comando Windows shell em vez de um comando shell para Unix, Linux ou macOS, nas declarações do documento JSON, substitua a abertura e o fechamento ' por " e substitua o " interno por \".

  • O curl é uma ferramenta de linha de comando para enviar e receber solicitações e respostas da API REST. Consulte também Instalar curl. Ou então, adapte os exemplos deste tutorial curl para uso com ferramentas semelhantes, como o HTTPie.

    Nos exemplos do site curl deste tutorial, observe o seguinte:

    • Em vez de --header "Authorization: Bearer ${DATABRICKS_TOKEN}", você pode usar um .netrc arquivo. Se você usar um arquivo .netrc, substitua --header "Authorization: Bearer ${DATABRICKS_TOKEN}" por --netrc.
    • Se o senhor usar o comando Windows shell em vez de um comando shell para Unix, Linux ou macOS, substitua \ por ^ e ${...} por %...%.
    • Se o senhor usar o comando Windows shell em vez de um comando shell para Unix, Linux ou macOS, nas declarações do documento JSON, substitua a abertura e o fechamento ' por " e substitua o " interno por \".

    Além disso, para os exemplos curl deste tutorial, este tutorial pressupõe que o senhor tenha a seguinte variável de ambiente em seu computador de desenvolvimento local:

    • DATABRICKS_HOST, representando o nome da instânciaworkspace, por exemplo, 1234567890123456.7.gcp.databricks.com, para seu Databricks workspace.

    • DATABRICKS_TOKENrepresentando um Databricks tokens de acesso pessoal para seu usuário Databricks workspace .

    • DATABRICKS_SQL_WAREHOUSE_IDrepresentando o ID do seu depósito Databricks SQL. Essa ID é a sequência de letras e números que segue /sql/1.0/warehouses/ no campo HTTP path (caminho HTTP ) do seu depósito. Para saber como obter o valor do caminho HTTP do seu depósito, consulte Obter detalhes da conexão para um recurso Databricks compute.

nota

Como prática recomendada de segurança, ao se autenticar com ferramentas, sistemas, scripts e aplicativos automatizados, o Databricks recomenda que o senhor use o acesso pessoal tokens pertencente à entidade de serviço em vez dos usuários do workspace. Para criar tokens o site para uma entidade de serviço, consulte gerenciar tokens para uma entidade de serviço.

Para criar tokens de acesso pessoal Databricks, siga os passos em Databricks personal access tokens para usuários workspace.

atenção

Databricks desaconselha fortemente a codificação de informações em seus scripts, pois essas informações confidenciais podem ser expostas em texto simples por meio de sistemas de controle de versão. Databricks recomenda que, em vez disso, o senhor use abordagens como a variável de ambiente definida em sua máquina de desenvolvimento. A remoção dessas informações codificadas de seus scripts também ajuda a torná-los mais portáteis.

  • Este tutorial pressupõe que o senhor também tenha o jq, um processador de linha de comando para consultar JSON cargas de resposta, que o Databricks SQL Statement Execution API retorna após cada chamada que o senhor faz para o Databricks SQL Statement Execution API. Veja o download do jq.

  • O senhor deve ter pelo menos uma tabela na qual possa executar instruções SQL. Este tutorial se baseia na tabela lineitem no esquema tpch (também conhecido como banco de dados) no catálogo samples. Se o senhor não tiver acesso a esse catálogo, esquema ou tabela no site workspace, substitua-os neste tutorial pelos seus próprios.

Etapa 1: Executar uma instrução SQL e salvar o resultado dos dados como JSON​

executar o seguinte comando, que faz o seguinte:

  1. Usa o endereço SQL warehouse especificado, juntamente com os tokens especificados, se o senhor estiver usando curl, para consultar três colunas das duas primeiras linhas da tabela lineitem no esquema tcph dentro do catálogo samples.
  2. Salva a carga útil da resposta no formato JSON em um arquivo chamado sql-execution-response.json no diretório de trabalho atual.
  3. Imprime o conteúdo do arquivo sql-execution-response.json.
  4. Define uma variável de ambiente local chamada SQL_STATEMENT_ID. Essa variável contém o ID da instrução SQL correspondente. O senhor pode usar esse ID de instrução SQL para obter informações sobre essa instrução posteriormente, conforme necessário, o que é demonstrado na Etapa 2. O senhor também pode view esse comando SQL e obter o ID do comando na seção de histórico de consultas do console Databricks SQL ou chamando o comando Query History API.
  5. Define uma variável de ambiente local adicional chamada NEXT_CHUNK_EXTERNAL_LINK que contém um fragmento de URL de API para obter o próximo bloco de dados JSON. Se os dados de resposta forem muito grandes, a API de Execução de Instrução Databricks SQL fornecerá a resposta em partes. Você pode usar esse fragmento de URL da API para obter a próxima parte de dados, que é demonstrada na passo 2. Se não houver próxima parte, essa variável de ambiente será definida como null.
  6. Imprime os valores de SQL_STATEMENT_ID e NEXT_CHUNK_INTERNAL_LINK variável de ambiente.
Bash
databricks api post /api/2.0/sql/statements \
--profile <profile-name> \
--json '{
  "warehouse_id": "'"$DATABRICKS_SQL_WAREHOUSE_ID"'",
  "catalog": "samples",
  "schema": "tpch",
  "statement": "SELECT l_orderkey, l_extendedprice, l_shipdate FROM lineitem WHERE l_extendedprice > :extended_price AND l_shipdate > :ship_date LIMIT :row_limit",
  "parameters": [
    { "name": "extended_price", "value": "60000", "type": "DECIMAL(18,2)" },
    { "name": "ship_date", "value": "1995-01-01", "type": "DATE" },
    { "name": "row_limit", "value": "2", "type": "INT" }
  ]
}' \
> 'sql-execution-response.json' \
&& jq . 'sql-execution-response.json' \
&& export SQL_STATEMENT_ID=$(jq -r .statement_id 'sql-execution-response.json') \
&& export NEXT_CHUNK_INTERNAL_LINK=$(jq -r .result.next_chunk_internal_link 'sql-execution-response.json') \
&& echo SQL_STATEMENT_ID=$SQL_STATEMENT_ID \
&& echo NEXT_CHUNK_INTERNAL_LINK=$NEXT_CHUNK_INTERNAL_LINK

Replace <profile-name> with the name of your Databricks configuration profile for authentication.

Na solicitação anterior:

  • As consultas parametrizadas consistem no nome de cada parâmetro de consulta precedido por dois pontos (por exemplo, :extended_price) com um objeto name e value correspondente na matriz parameters. Um type opcional também pode ser especificado, com o valor default de STRING se não for especificado.
atenção

A Databricks recomenda enfaticamente que o senhor use parâmetros como uma prática recomendada para suas instruções SQL.

Se o senhor usar a API Databricks SQL Statement Execution com um aplicativo que gera SQL dinamicamente, isso pode resultar em ataques de injeção de SQL. Por exemplo, se o senhor gerar código SQL com base nas seleções de um usuário em uma interface de usuário e não tomar as medidas adequadas, um invasor poderá injetar código SQL malicioso para alterar a lógica da consulta inicial, lendo, alterando ou excluindo dados confidenciais.

As consultas parametrizadas ajudam a proteger contra ataques de injeções de SQL, tratando os argumentos de entrada separadamente do restante do código SQL e interpretando esses argumentos como valores literais. Os parâmetros também ajudam na reutilização do código.

  • Por default, todos os dados retornados estão no formato de matriz JSON e o local default para qualquer resultado de dados da instrução SQL está dentro da carga útil da resposta. Para tornar esse comportamento explícito, adicione "format":"JSON_ARRAY","disposition":"INLINE" à carga útil da solicitação. Se o senhor tentar retornar resultados de dados maiores que 25 MiB na carga útil da resposta, será retornado um status de falha e a instrução SQL será cancelada. Para resultados de dados maiores que 25 MiB, você pode usar links externos em vez de tentar retorná-los na carga de resposta, o que é demonstrado na Etapa 3.

  • O comando armazena o conteúdo da carga útil da resposta em um arquivo local. O armazenamento local de dados não é suportado diretamente pelo Databricks SQL Statement Execution API.

  • Em default, após 10 segundos, se a instrução SQL ainda não tiver terminado de ser executada no depósito, o Databricks SQL Statement Execution API retorna apenas o ID da instrução SQL e seu status atual, em vez do resultado da instrução. Para alterar esse comportamento, adicione "wait_timeout" à solicitação e defina-a como "<x>s", onde <x> pode estar entre 5 e 50 segundos, inclusive, "50s". Para retornar o ID do comando SQL e seu status atual imediatamente, defina wait_timeout como 0s.

  • Por default, a instrução SQL continua a ser executada se o período de tempo limite for atingido. Para cancelar uma instrução SQL se o período de tempo limite for atingido, adicione "on_wait_timeout":"CANCEL" à carga útil da solicitação.

  • Para limitar o número de bytes retornados, adicione "byte_limit" à solicitação e defina-a como o número de bytes, por exemplo 1000.

  • Para limitar o número de linhas retornadas, em vez de adicionar uma cláusula LIMIT a statement, você pode adicionar "row_limit" à solicitação e defini-la como o número de linhas, por exemplo "statement":"SELECT * FROM lineitem","row_limit":2.

  • Se o resultado for maior que o byte_limit ou row_limit especificado, o campo truncated será definido como true na carga de resposta.

Se o resultado da declaração estiver disponível antes do término do tempo limite de espera, a resposta será a seguinte:

JSON
{
  "manifest": {
    "chunks": [
      {
        "chunk_index": 0,
        "row_count": 2,
        "row_offset": 0
      }
    ],
    "format": "JSON_ARRAY",
    "schema": {
      "column_count": 3,
      "columns": [
        {
          "name": "l_orderkey",
          "position": 0,
          "type_name": "LONG",
          "type_text": "BIGINT"
        },
        {
          "name": "l_extendedprice",
          "position": 1,
          "type_name": "DECIMAL",
          "type_precision": 18,
          "type_scale": 2,
          "type_text": "DECIMAL(18,2)"
        },
        {
          "name": "l_shipdate",
          "position": 2,
          "type_name": "DATE",
          "type_text": "DATE"
        }
      ]
    },
    "total_chunk_count": 1,
    "total_row_count": 2,
    "truncated": false
  },
  "result": {
    "chunk_index": 0,
    "data_array": [
      ["2", "71433.16", "1997-01-28"],
      ["7", "86152.02", "1996-01-15"]
    ],
    "row_count": 2,
    "row_offset": 0
  },
  "statement_id": "00000000-0000-0000-0000-000000000000",
  "status": {
    "state": "SUCCEEDED"
  }
}

Se o tempo limite de espera terminar antes que o resultado da declaração esteja disponível, a resposta ficará assim:

JSON
{
  "statement_id": "00000000-0000-0000-0000-000000000000",
  "status": {
    "state": "PENDING"
  }
}

Se os dados do resultado da instrução forem muito grandes (por exemplo, nesse caso, executando SELECT l_orderkey, l_extendedprice, l_shipdate FROM lineitem LIMIT 300000), os dados do resultado serão fragmentados e, em vez disso, ficarão assim. Observe que "...": "..." indica resultados omitidos aqui por motivos de brevidade:

JSON
{
  "manifest": {
    "chunks": [
      {
        "chunk_index": 0,
        "row_count": 188416,
        "row_offset": 0
      },
      {
        "chunk_index": 1,
        "row_count": 111584,
        "row_offset": 188416
      }
    ],
    "format": "JSON_ARRAY",
    "schema": {
      "column_count": 3,
      "columns": [
        {
          "...": "..."
        }
      ]
    },
    "total_chunk_count": 2,
    "total_row_count": 300000,
    "truncated": false
  },
  "result": {
    "chunk_index": 0,
    "data_array": [["2", "71433.16", "1997-01-28"], ["..."]],
    "next_chunk_index": 1,
    "next_chunk_internal_link": "/api/2.0/sql/statements/00000000-0000-0000-0000-000000000000/result/chunks/1?row_offset=188416",
    "row_count": 188416,
    "row_offset": 0
  },
  "statement_id": "00000000-0000-0000-0000-000000000000",
  "status": {
    "state": "SUCCEEDED"
  }
}

Etapa 2: Obter o status de execução atual de uma instrução e o resultado dos dados como JSON​

O senhor pode usar o ID de uma instrução SQL para obter o status atual de execução dessa instrução e, se a execução for bem-sucedida, o resultado dessa instrução. Se o senhor esquecer o ID do comando, poderá obtê-lo na seção de histórico de consultas do console Databricks SQL ou chamando o comando Query History API. Por exemplo, o senhor poderia continuar a sondar esse comando, verificando a cada vez se a execução foi bem-sucedida.

Para obter o status de execução atual de uma instrução SQL e, se a execução tiver sido bem-sucedida, o resultado dessa instrução e um fragmento de URL da API para obter qualquer parte seguinte de dados JSON, execute o seguinte comando. Esse comando pressupõe que o senhor tenha uma variável de ambiente em seu computador de desenvolvimento local chamada SQL_STATEMENT_ID, que é definida como o valor do ID da instrução SQL da etapa anterior. Obviamente, o senhor pode substituir ${SQL_STATEMENT_ID} no comando a seguir pelo ID codificado da instrução SQL.

Bash
databricks api get /api/2.0/sql/statements/${SQL_STATEMENT_ID} \
--profile <profile-name> \
> 'sql-execution-response.json' \
&& jq . 'sql-execution-response.json' \
&& export NEXT_CHUNK_INTERNAL_LINK=$(jq -r .result.next_chunk_internal_link 'sql-execution-response.json') \
&& echo NEXT_CHUNK_INTERNAL_LINK=$NEXT_CHUNK_INTERNAL_LINK

Replace <profile-name> with the name of your Databricks configuration profile for authentication.

Se o NEXT_CHUNK_INTERNAL_LINK for definido como um valor que não sejanull, o senhor poderá usá-lo para obter o próximo bloco de dados e assim por diante, por exemplo, com o seguinte comando:

Bash
databricks api get /${NEXT_CHUNK_INTERNAL_LINK} \
--profile <profile-name> \
> 'sql-execution-response.json' \
&& jq . 'sql-execution-response.json' \
&& export NEXT_CHUNK_INTERNAL_LINK=$(jq -r .next_chunk_internal_link 'sql-execution-response.json') \
&& echo NEXT_CHUNK_INTERNAL_LINK=$NEXT_CHUNK_INTERNAL_LINK

Replace <profile-name> with the name of your Databricks configuration profile for authentication.

O senhor pode continuar executando o comando anterior, repetidamente, para obter o próximo bloco, e assim por diante. Observe que, assim que o último bloco é obtido, a instrução SQL é encerrada. Após esse encerramento, você não pode usar o ID dessa instrução para obter seu status atual ou buscar mais partes.

Esta seção demonstra uma configuração opcional que usa a disposição EXTERNAL_LINKS para recuperar grandes conjuntos de dados. O local default (disposição) para os dados de resultado da declaração SQL está dentro da carga útil da resposta, mas esses resultados estão limitados a 25 MiB. Ao definir disposition como EXTERNAL_LINKS, a resposta contém URLs que você pode usar para buscar os fragmentos dos dados dos resultados com HTTP padrão. Os URLs apontam para o site workspaceinterno DBFS, onde os blocos de resultados são armazenados temporariamente.

atenção

A Databricks recomenda enfaticamente que o senhor proteja os URLs que são retornados pela disposição EXTERNAL_LINKS.

Quando o senhor usa a disposição EXTERNAL_LINKS, é gerado um URL assinado e de curta duração, que pode ser usado para fazer download dos resultados diretamente do Google Cloud Storage. Como uma credencial de acesso de curta duração está incorporada nesse URL assinado, você deve proteger o URL.

Como os URLs assinados já são gerados com credenciais de acesso temporário incorporadas, o senhor não deve definir um cabeçalho Authorization nas solicitações de download.

A disposição EXTERNAL_LINKS pode ser desativada mediante solicitação, criando um caso de suporte. Consulte o suporte.

Veja também as melhores práticas de segurança.

nota

O formato e o comportamento de saída da carga útil da resposta, uma vez definidos para um determinado ID de instrução SQL, não podem ser alterados.

Nesse modo, a API permite que o senhor armazene dados de resultados no formato JSON (JSON), no formato CSV (CSV) ou no formato Apache Arrow (ARROW_STREAM), que devem ser consultados separadamente com HTTP. Além disso, ao usar esse modo, não é possível embutir os dados do resultado na carga útil da resposta.

O comando a seguir demonstra o uso de EXTERNAL_LINKS e do formato Apache Arrow. Use esse padrão em vez da consulta semelhante demonstrada na Etapa 1:

Bash
databricks api post /api/2.0/sql/statements/ \
--profile <profile-name> \
--json '{
  "warehouse_id": "'"$DATABRICKS_SQL_WAREHOUSE_ID"'",
  "catalog": "samples",
  "schema": "tpch",
  "format": "ARROW_STREAM",
  "disposition": "EXTERNAL_LINKS",
  "statement": "SELECT l_orderkey, l_extendedprice, l_shipdate FROM lineitem WHERE l_extendedprice > :extended_price AND l_shipdate > :ship_date LIMIT :row_limit",
  "parameters": [
    { "name": "extended_price", "value": "60000", "type": "DECIMAL(18,2)" },
    { "name": "ship_date", "value": "1995-01-01", "type": "DATE" },
    { "name": "row_limit", "value": "100000", "type": "INT" }
  ]
}' \
> 'sql-execution-response.json' \
&& jq . 'sql-execution-response.json' \
&& export SQL_STATEMENT_ID=$(jq -r .statement_id 'sql-execution-response.json') \
&& echo SQL_STATEMENT_ID=$SQL_STATEMENT_ID

Replace <profile-name> with the name of your Databricks configuration profile for authentication.

A resposta é a seguinte:

JSON
{
  "manifest": {
    "chunks": [
      {
        "byte_count": 2843848,
        "chunk_index": 0,
        "row_count": 100000,
        "row_offset": 0
      }
    ],
    "format": "ARROW_STREAM",
    "schema": {
      "column_count": 3,
      "columns": [
        {
          "name": "l_orderkey",
          "position": 0,
          "type_name": "LONG",
          "type_text": "BIGINT"
        },
        {
          "name": "l_extendedprice",
          "position": 1,
          "type_name": "DECIMAL",
          "type_precision": 18,
          "type_scale": 2,
          "type_text": "DECIMAL(18,2)"
        },
        {
          "name": "l_shipdate",
          "position": 2,
          "type_name": "DATE",
          "type_text": "DATE"
        }
      ]
    },
    "total_byte_count": 2843848,
    "total_chunk_count": 1,
    "total_row_count": 100000,
    "truncated": false
  },
  "result": {
    "external_links": [
      {
        "byte_count": 2843848,
        "chunk_index": 0,
        "expiration": "<url-expiration-timestamp>",
        "external_link": "<url-to-data-stored-externally>",
        "row_count": 100000,
        "row_offset": 0
      }
    ]
  },
  "statement_id": "00000000-0000-0000-0000-000000000000",
  "status": {
    "state": "SUCCEEDED"
  }
}

Se a solicitação expirar, a resposta terá a seguinte aparência:

JSON
{
  "statement_id": "00000000-0000-0000-0000-000000000000",
  "status": {
    "state": "PENDING"
  }
}

Para obter o status atual de execução dessa declaração e, se a execução for bem-sucedida, o resultado dessa declaração, execute o seguinte comando:

Bash
databricks api get /api/2.0/sql/statements/${SQL_STATEMENT_ID} \
--profile <profile-name> \
> 'sql-execution-response.json' \
&& jq . 'sql-execution-response.json'

Replace <profile-name> with the name of your Databricks configuration profile for authentication.

Se a resposta for grande o suficiente (por exemplo, neste caso, ao executar SELECT l_orderkey, l_extendedprice, l_shipdate FROM lineitem sem limite de linhas), a resposta terá vários blocos, como no exemplo abaixo. Observe que "...": "..." indica resultados omitidos aqui por motivos de brevidade:

JSON
{
  "manifest": {
    "chunks": [
      {
        "byte_count": 11469280,
        "chunk_index": 0,
        "row_count": 403354,
        "row_offset": 0
      },
      {
        "byte_count": 6282464,
        "chunk_index": 1,
        "row_count": 220939,
        "row_offset": 403354
      },
      {
        "...": "..."
      },
      {
        "byte_count": 6322880,
        "chunk_index": 10,
        "row_count": 222355,
        "row_offset": 3113156
      }
    ],
    "format": "ARROW_STREAM",
    "schema": {
      "column_count": 3,
      "columns": [
        {
          "...": "..."
        }
      ]
    },
    "total_byte_count": 94845304,
    "total_chunk_count": 11,
    "total_row_count": 3335511,
    "truncated": false
  },
  "result": {
    "external_links": [
      {
        "byte_count": 11469280,
        "chunk_index": 0,
        "expiration": "<url-expiration-timestamp>",
        "external_link": "<url-to-data-stored-externally>",
        "next_chunk_index": 1,
        "next_chunk_internal_link": "/api/2.0/sql/statements/00000000-0000-0000-0000-000000000000/result/chunks/1?row_offset=403354",
        "row_count": 403354,
        "row_offset": 0
      }
    ]
  },
  "statement_id": "00000000-0000-0000-0000-000000000000",
  "status": {
    "state": "SUCCEEDED"
  }
}

Para download os resultados do conteúdo armazenado, o senhor pode executar o seguinte comando curl, usando o URL no objeto external_link e especificando onde deseja download o arquivo. Não inclua seus tokens Databricks nesse comando:

Bash
curl "<url-to-result-stored-externally>" \
--output "<path/to/download/the/file/locally>"

Para download uma parte específica dos resultados de um conteúdo de transmissão, o senhor pode usar uma das seguintes opções:

  • O valor next_chunk_index da carga de resposta para o próximo bloco (se houver um próximo bloco).
  • Um dos índices de fragmentos do manifesto da carga útil de resposta para qualquer bloco disponível, se houver vários blocos.

Por exemplo, para obter o trecho com chunk_index de 10 da resposta anterior, execute o seguinte comando:

Bash
databricks api get /api/2.0/sql/statements/${SQL_STATEMENT_ID}/result/chunks/10 \
--profile <profile-name> \
> 'sql-execution-response.json' \
&& jq . 'sql-execution-response.json'

Replace <profile-name> with the name of your Databricks configuration profile for authentication.

nota

A execução do comando anterior retorna um novo URL assinado.

Para fazer o download do bloco armazenado, use o URL no objeto external_link.

Para obter mais informações sobre o formato Apache Arrow, consulte:

Etapa 4: Cancelar a execução de uma instrução SQL​

Se o senhor precisar cancelar uma declaração do SQL que ainda não foi bem-sucedida, execute o seguinte comando:

Bash
databricks api post /api/2.0/sql/statements/${SQL_STATEMENT_ID}/cancel \
--profile <profile-name> \
--json '{}'

Replace <profile-name> with the name of your Databricks configuration profile for authentication.

Melhores práticas de segurança​

A API Databricks SQL Statement Execution aumenta a segurança das transferências de dados usando a criptografia TLS (Transport Layer Security) de ponta a ponta e credenciais de curta duração, como URLs assinados.

Databricks recomenda as seguintes práticas recomendadas de segurança sempre que o senhor usar o Databricks SQL Statement Execution API junto com a disposição EXTERNAL_LINKS para recuperar grandes conjuntos de dados:

  • Remover o cabeçalho de autorização do Databricks para solicitações do Google Cloud Storage
  • Proteja URLs assinados

A disposição EXTERNAL_LINKS pode ser desativada mediante solicitação, criando um caso de suporte. Consulte o suporte.

Remover o cabeçalho de autorização do Databricks para solicitações do Google Cloud Storage​

Todas as chamadas para o Databricks SQL Statement Execution API que usam curl devem incluir um cabeçalho Authorization que contenha as credenciais de acesso Databricks. Não inclua esse cabeçalho Authorization sempre que o senhor download dados de Google Cloud Storage. Esse cabeçalho não é obrigatório e pode expor involuntariamente suas credenciais de acesso ao Databricks.

Proteja URLs assinados​

Sempre que o senhor usa a disposição EXTERNAL_LINKS, é gerado um URL assinado e de curta duração, que o chamador pode usar para download os resultados diretamente de Google Cloud Storage usando TLS. Como uma credencial de curta duração está incorporada nesse URL assinado, você deve proteger o URL.

Última atualização em