Importar arquivos de servidores web

🤖/http/import importa para a Transloadit qualquer arquivo disponível publicamente por meio de uma URL da web.

Exemplo de uso

{
  "steps": {
    "imported": {
      "robot": "/http/import",
      "url": "https://demos.transloadit.com/inputs/chameleon.jpg"
    }
  }
}

Parâmetros

• interpolate

  boolean | Record<string, boolean>

  Controla se as Assembly Variables são interpoladas em campos individuais de instruções.

  Por padrão, a maioria dos campos de instruções dos Robots interpola Assembly Variables. Defina isso como false para tratar todos os campos de instruções como texto literal, ou defina o caminho de um campo individual como false para tratar apenas esse campo como texto literal. Para campos específicos de um Robot que são literais por padrão, defina isso como true ou defina o caminho desse campo como true para voltar a usar a interpolação.

  Use nomes de campos como path ou caminhos com pontos como ffmpeg.vf para objetos aninhados.

• output_meta

  Record<string, boolean> | boolean | Array<string>

  Permite especificar um conjunto de metadados cujo cálculo exige mais CPU e que, por isso, vem desativado por padrão para manter o processamento das suas Assemblies rápido.

  Para imagens, você pode adicionar "has_transparency": true neste objeto para extrair se a imagem contém partes transparentes e "dominant_colors": true para extrair um array de códigos de cores hexadecimais da imagem.

  Para imagens, você também pode adicionar "blurhash": true para extrair uma string BlurHash⁠ — uma representação compacta de um placeholder da imagem, útil para exibir uma prévia desfocada enquanto a imagem completa carrega.

  Para vídeos, você pode adicionar o parâmetro "colorspace": true para extrair o espaço de cores do vídeo de saída.

  Para vídeos, você também pode adicionar "interlaced": true para detectar se o vídeo é entrelaçado. Isso combina a flag computacionalmente barata field_order do ffprobe com uma passagem de amostragem idet limitada sobre os primeiros quadros da origem, expondo interlaced, field_order e um objeto de diagnóstico interlace_detection em file.meta. Isso é computacionalmente caro e cobrado de acordo.

  Para áudio, você pode adicionar "mean_volume": true para obter um único valor que representa o volume médio do arquivo de áudio.

  Você também pode definir isso como false para pular a extração de metadados e acelerar a transcodificação.

• user_meta

  Record<string, any>(padrão: {})

  Adiciona metadados JSON personalizados a cada arquivo emitido sem modificar seu conteúdo. Objetos e arrays aninhados são suportados.

  A herança depende do Robot. Os valores são mesclados com o user_meta existente no arquivo de saída; o Step atual substitui as chaves de nível superior com o mesmo nome. Atribua explicitamente as chaves necessárias quando um Robot criar novas saídas.

  Nos Steps de processamento, ${file.*} se refere à primeira entrada e ${result.*} ao arquivo emitido. Os valores são avaliados para cada saída após a execução do Robot, antes da extração subsequente de metadados e do armazenamento temporário. Em :original, os valores são avaliados para cada upload antes da extração de metadados.

  Os Steps subsequentes leem ${file.user_meta.key}. Consulte Metadados personalizados para ver um exemplo completo e as regras de herança.

• result

  boolean(padrão: false)

  Se os resultados deste Step devem estar presentes no Assembly Status JSON

• queue

  batch

  Definir a fila como “batch” rebaixa manualmente a prioridade dos Jobs deste Step, para evitar o consumo de vagas prioritárias de Jobs em Jobs que não precisam de tempo zero de espera na fila

• force_accept

  boolean(padrão: false)

  Forçar um Robot a aceitar um tipo de arquivo que ele teria ignorado.

  Por padrão, os Robots ignoram arquivos que não conhecem. O 🤖/video/encode, por exemplo, ignora tranquilamente imagens de entrada.

  Com o parâmetro force_accept definido como true, você pode forçar os Robots a aceitar todos os arquivos enviados a eles. Isso normalmente leva a erros e só deve ser usado para depuração ou para lidar com casos extremos.

• ignore_errors

  boolean | Array<meta | import | execute>(padrão: [])

  Ignorar erros durante fases específicas do processamento.

  Definir isso como ["meta"] fará com que o Robot ignore erros durante a extração de metadados.

  Definir isso como ["execute"] fará com que o Robot ignore erros durante a fase principal de execução.

  Definir isso como ["import"] fará com que o Robot ignore erros ao importar o arquivo de origem. A fase "import" está disponível apenas para Robots de importação.

  Definir isso como true equivale a ["meta", "import", "execute"] e fará com que erros sejam ignorados nas três fases.

• force_name

  string | Array<string> | null(padrão: null)

  Nome personalizado para o(s) arquivo(s) importado(s). Por padrão, os nomes dos arquivos são derivados da origem.

• import_on_errors

  Array<meta>(padrão: [])

  Definir isso como ["meta"] ainda importa o arquivo quando ocorrem erros de extração de metadados. ignore_errors é parecido: também ignora o erro e garante que o Robot não pare, mas não importa o arquivo.

• url — obrigatório

  string | Array<string>

  A URL da qual o arquivo a ser importado pode ser obtido.

  As URLs HTTPS devem apresentar um certificado válido em que a Transloadit confie e que corresponda ao nome de host solicitado. Certificados autoassinados, expirados ou que não correspondam ao nome de host causam HTTP_IMPORT_FAILURE.

  Você também pode especificar um array de URLs ou uma string de URLs delimitadas por | para importar vários arquivos de uma só vez. Consulte também o parâmetro url_delimiter para isso.

• url_delimiter

  string(padrão: "|")

  Fornece o delimitador usado para separar as URLs no valor do parâmetro url.

• headers

  Array<string> | Array<Record<string, string>> | string(padrão: [])

  Cabeçalhos personalizados a serem enviados para a importação de arquivos.

  Por padrão, este é um array vazio, de modo que nenhum cabeçalho adicional seja enviado além dos necessários (por exemplo, Host).

  Os cabeçalhos podem ser especificados como:

  • Um array de strings no formato “Header-Name: value”
  • Um array de objetos com os nomes dos cabeçalhos como chaves e seus valores como valores
  • Uma string JSON que será interpretada como um objeto

  Os nomes dos cabeçalhos devem ser tokens HTTP válidos. Os valores dos cabeçalhos podem conter tabulações horizontais, mas outros caracteres de controle, incluindo retornos de carro e quebras de linha, são rejeitados.

  Em um array de strings de cabeçalhos, "Header-Name;" envia um valor de cabeçalho vazio. Cada entrada deve ser um cabeçalho literal; a leitura de cabeçalhos de um arquivo com @filename não é compatível.

  O mesmo valor de headers é enviado com cada URL neste Step /http/import. Se url for um array, headers não será associado às URLs pelo índice do array. Use Steps /http/import separados quando URLs diferentes precisarem de cabeçalhos diferentes.

• fail_fast

  boolean(padrão: false)

  Desative o mecanismo interno de novas tentativas e retorne uma falha imediatamente se um recurso não puder ser importado. Isso pode ser útil para aplicações em que o desempenho é crítico.

• max_file_size

  string | number

  Tamanho máximo permitido em bytes para cada arquivo importado. Se o servidor remoto informar um tamanho de arquivo maior, a importação será rejeitada antes do início do download. Se o servidor remoto não informar um tamanho antecipadamente, o download será abortado assim que esse limite for excedido.

• return_file_stubs

  boolean(padrão: false)

  Se definido como true, o Robot ainda não importará os arquivos em si, e em vez disso retornará um stub de arquivo vazio que inclui uma URL a partir da qual o arquivo pode ser importado por Robots subsequentes. Isso é útil em casos em que os Steps subsequentes precisam de mais controle sobre o processo de importação, como acontece com o 🤖/video/ondemand. Este parâmetro só deve ser definido se todos os Steps subsequentes usarem Robots que suportem stubs de arquivo.

• range

  string | Array<string>

  Permite especificar um ou mais intervalos de bytes a importar do arquivo. O servidor precisa oferecer suporte a requisições de intervalo para que isso funcione.

  Intervalo único: use uma string como "0-99" para importar os bytes de 0 a 99 (os primeiros 100 bytes).

  Múltiplos intervalos: use um array como ["0-99", "200-299"] para importar vários intervalos separados. O arquivo resultante conterá todos os intervalos solicitados concatenados, com bytes de valor zero (\0) preenchendo as lacunas entre intervalos não contíguos.

  Formatos de intervalo:

  • "0-99": bytes de 0 a 99 (inclusive)
  • "100-199": bytes de 100 a 199 (inclusive)
  • "-100": os últimos 100 bytes do arquivo

  Observações importantes:

  • O servidor precisa oferecer suporte a requisições HTTP de intervalo (responder com 206 Partial Content)
  • Se o servidor não oferecer suporte a requisições de intervalo, o arquivo inteiro será importado
  • Intervalos sobrepostos são permitidos e serão incluídos conforme solicitado
  • O tamanho do arquivo resultante corresponderá à maior posição de byte solicitada, com as lacunas preenchidas com bytes de valor zero

Demonstrações

Publicações relacionadas no blog