Pular para o conteúdo
PT
Obter chave API
Explorar documentação

Guias

Implantar cargas de trabalho FlashData

Execute as tarefas CLI do seu aplicativo ou agente em Linux ou Docker, então verifique o acesso e a reutilização do resultado após um reinício.

Nesta página

1. Escolha o tempo de execução

Use um host Linux com Bash e jq, e uma chave API proprietária com permissão google_search. Executar configuração como o usuário OS que irá executar a tarefa. Crie esta pasta de tarefas privada para os passos 1–4; as etiquetas de arquivos mostram qualquer subpasta.

Crie a pasta de tarefas
umask 077
mkdir -p "$HOME/flashdata-tasks/deployment-check"
cd "$HOME/flashdata-tasks/deployment-check"

Instale o CLI nativo primeiro. Executar comando -v flashdata para encontrar seu caminho absoluto, em seguida, definir FLASHDATA_BIN para esse caminho em runtime.sh. Defina o nome do perfil e o caminho do estado persistente uma vez aqui, e então salve o arquivo.

runtime.sh
# runtime.sh — edit the executable and persistent state paths.
export FLASHDATA_BIN=/usr/local/bin/flashdata
export FLASHDATA_PROFILE=research
export FLASHDATA_STATE_DIR="$HOME/.local/state/flashdata-research"

run_flashdata() {
  env -u FLASHDATA_API_KEY "$FLASHDATA_BIN" "$@" \
    --profile "$FLASHDATA_PROFILE" \
    --state-dir "$FLASHDATA_STATE_DIR"
}

Verifique o tempo de execução selecionado

run_flashdata é o ajudante salvo no runtime.sh; todos os comandos posteriores usam seu perfil e diretório de estado. Ele ignora FLASHDATA_API_KEY para que uma chave de ambiente não possa substituir o perfil salvo. Espere as versões CLI e jq.

Prepare o estado persistente sem consulta API
set -euo pipefail
umask 077
. ./runtime.sh
mkdir -p "$FLASHDATA_STATE_DIR"
chmod 700 "$FLASHDATA_STATE_DIR"
run_flashdata --version
jq --version

2. Instale o acesso do proprietário uma vez

Se o perfil já tiver acesso ao proprietário, pule a importação e execute a verificação abaixo. Caso contrário, monte um arquivo secreto legível pelo usuário do serviço e substitua o caminho do exemplo por sua localização. A importação lê através de stdin; Docker não copia para a imagem.

Aponte para o arquivo secreto implantado
export FLASHDATA_KEY_FILE='/run/secrets/flashdata_api_key'
Importar e verificar no tempo de execução selecionado
set -euo pipefail
. ./runtime.sh
: "${FLASHDATA_KEY_FILE:?Set the path to your mounted owner-key secret}"
run_flashdata auth login --api-key-stdin --non-interactive \
  < "$FLASHDATA_KEY_FILE"
run_flashdata auth status --json --non-interactive

Confirme a conta e permissão

O verificação imprime a conta ID, fontes permitidas e proteção credencial, e depois true. Confirmar a conta ID é o proprietário pretendido antes de continuar access.json permanece na pasta de tarefas para inspeção.

Acesso do proprietário salvo. verificação grátis
set -euo pipefail
umask 077
. ./runtime.sh
run_flashdata auth status --json --non-interactive > access.json
jq '{accountId: .data.identity.identity.accountId,
     sources: .data.identity.permittedSources,
     credentialProtection: .data.credentialProtection}' access.json
jq -e '.ok and .data.accessVerified
  and (.data.identity.identity.recurringAllowed == true)
  and (.data.identity.permittedSources | index("google_search") != null)' access.json

Armazenamento de credenciais e arquivos persistentes

Inspecione data.credentialProtection em auth status. Linux pode usar um Serviço Secreto destrancado, um hospedeiro sem cabeça ou o recipiente acima podem usar um arquivo de texto simples. Mantenha o diretório estadual privado e persistente. Providencie o usuário implantado separadamente do perfil criptografado do seu laptop.

ContinueLocalização
Credenciais e revistasFLASHDATA_STATE_DIR
Entrada, recibos e resultadosA pasta de tarefas, montada como /work em Docker.

3. Validar o pedido e o custo

Salve request.json ao lado de runtime.sh. O seguinte verificação valida o acesso recorrente e o pedido, lê os preços atuais e compara com o saldo disponível. Ele não envia nenhuma busca e não reserva créditos. Continue apenas quando o filtro imprime true.

request.json
{
  "source": "google_search",
  "query": "battery recycling research",
  "params": {
    "num": 5
  }
}
Verifique antes da primeira tarefa paga
set -euo pipefail
umask 077
. ./runtime.sh
run_flashdata account balance --json --non-interactive > balance.json
run_flashdata query --input request.json --mode realtime --dry-run --recurring \
  --run-id deployment-first-task --json --non-interactive > preflight.json
jq -e --slurpfile balance balance.json '
  .ok and .data.dryRun and .data.estimateAvailable
  and ($balance[0].ok == true)
  and any(.data.estimate.prices[]?;
    .source == "google_search" and .available == true
    and (.estimatedCredits | type == "number")
    and ($balance[0].data.availableCredits | type == "number")
    and .estimatedCredits <= $balance[0].data.availableCredits)
' preflight.json

4. Execute uma vez e verifique a reutilização

Salve deployment-check.sh abaixo. Com uma nova execução ID, a primeira execução envia uma busca paga; a segunda inicia um novo processo e lê o resultado salvo. Se este ID já estiver completo no mesmo perfil, ambas as tentativas de reutilizá-lo.

Salve deployment-check.sh

Criar deployment-check.sh ao lado de runtime.sh e request.json na pasta de tarefas privada no host. Copie o script completo abaixo e guarde-o.

deployment-check.sh
#!/usr/bin/env bash
set -euo pipefail
umask 077
cd -- "$(dirname -- "$0")"
. ./runtime.sh
attempt=$(mktemp -d ./deployment-check.XXXXXX)
printf 'Attempt files: %s\n' "$attempt" >&2
cp -- request.json "$attempt/request.json"
if ! run_flashdata query --input "$attempt/request.json" --mode realtime --recurring \
  --run-id deployment-first-task --timeout 2m --json --non-interactive \
  --output "$attempt/result.json" \
  > "$attempt/receipt.json" 2> "$attempt/error.json"; then
  cat "$attempt/error.json" >&2
  exit 1
fi
jq -e '.ok == true' "$attempt/receipt.json" >/dev/null
jq -e '.source == "google_search" and .status == "done"
  and (.results[0].organic | type == "array")' "$attempt/result.json" >/dev/null
jq '{runId, cached, usage}' "$attempt/receipt.json"
printf 'Saved result: %s\n' "$attempt/result.json"

Faça o verificação salvo duas vezes

Corra da pasta de tarefas do host como o mesmo usuário de serviço. Ambos os processos carregam o runtime.sh salvo no passo 1.

Corra, então reinicie o processo
# A new run ID submits one paid search; a completed ID reuses its result.
bash deployment-check.sh

# New process; Docker uses a new container with the same mounts.
# Same account, input and state: cached: true, no new search.
bash deployment-check.sh

Verifique o segundo recibo

Para uma nova corrida, espere cached: false, então cached: true. Cada tentativa imprime sua pasta deployment-check.XXXXXX e salva request.json, receipt.json e error.json, além de result.json no sucesso. O recibo em cache relata o uso original. Uma tentativa fracassada mantém seus arquivos para recuperação.

Segundo recibo · Excerto
{
  "ok": true,
  "runId": "deployment-first-task",
  "cached": true
}

Leia o resultado da busca salva

Defina ATTEMPT_DIR para a segunda pasta de sucesso impressa acima, por exemplo, exportar ATTEMPT_DIR='./deployment-check.ABC123'. Esses comandos só lêem arquivos locais.

Recibo e links de origem
# Use one attempt folder printed by deployment-check.sh.
: "${ATTEMPT_DIR:?Set a saved deployment-check.XXXXXX folder}"
jq '{runId, cached, usage}' "$ATTEMPT_DIR/receipt.json"
jq '.results[0].organic[] | {title, link, snippet}' "$ATTEMPT_DIR/result.json"

Passe de uma verificação de implantação para uma tarefa recorrente.

Este verificação tem um ID fixo. Para o trabalho recorrente, dê a cada ocorrência pretendida seu próprio ID e mantenha o tempo de execução selecionado, conta, instantâneos de entrada e montagens de estado. Adapte o comando de busca do corredor recorrente para usar run_flashdata para que as tarefas Docker permaneçam dentro do contêiner.

Verifique o acesso das ações GitHub

Use um corredor Linux confiável e persistente com Bash, jq e o perfil CLI já instalado sob o usuário OS do corredor. Guarde esse fluxo de trabalho no repositório da sua aplicação. Verifica o CLI sem executar uma tarefa paga.

  1. Atribua o rótulo de pesquisa de dados para aquele corredor.
  2. Defina variáveis de repositório FLASHDATA_BIN e FLASHDATA_STATE_DIR para seus caminhos absolutos, e FLASHDATA_PROFILE para o nome do perfil instalado.
.github/workflows/flashdata-check.yml
name: FlashData access check
on: workflow_dispatch
permissions: {}
concurrency:
  group: flashdata-research
  cancel-in-progress: false
jobs:
  verify:
    runs-on: [self-hosted, linux, flashdata-research]
    timeout-minutes: 5
    steps:
      - name: Verify the installed profile without a paid query
        shell: bash
        env:
          FLASHDATA_BIN: ${{ vars.FLASHDATA_BIN }}
          FLASHDATA_STATE_DIR: ${{ vars.FLASHDATA_STATE_DIR }}
          FLASHDATA_PROFILE: ${{ vars.FLASHDATA_PROFILE }}
          FLASHDATA_API_KEY: ""
        run: |
          set -euo pipefail
          : "${FLASHDATA_BIN:?Set the absolute CLI path}"
          : "${FLASHDATA_STATE_DIR:?Set the existing absolute state directory}"
          : "${FLASHDATA_PROFILE:?Set the installed profile name}"
          test -d "$FLASHDATA_STATE_DIR"
          "$FLASHDATA_BIN" auth status --profile "$FLASHDATA_PROFILE" \
            --state-dir "$FLASHDATA_STATE_DIR" --json --non-interactive |
            jq -e '.ok and .data.accessVerified
              and (.data.identity.identity.recurringAllowed == true)
              and (.data.identity.permittedSources | index("google_search") != null)'

Faça a verificação de acesso

Após salvar o fluxo de trabalho no ramo padrão do repositório, abra Ações → verificação o acesso FlashData → Execute o fluxo de trabalho. Espere true e um verificação de sucesso. Falta de acesso ou permissão falha o trabalho sem enviar uma busca.

Mantenha o estado de execução em todos os trabalhos

Um corredor efêmero começa sem o diário original. Use o estado de aplicação durável ou um corredor persistente para trabalho recorrente pago. Reinstalar apenas a chave não pode identificar a submissão de um trabalho anterior. Mantenha o diretório estadual e saídas de tarefas privadas, não os carregue como artefatos de IC.

Rodar ou revogar o acesso implantado

Pause o despacho. Na pasta de tarefas, aponte FLASHDATA_KEY_FILE em uma chave de substituição para a mesma conta e fontes necessárias, e execute os comandos abaixo. Repita a verificação de acesso e deployment-check.sh, espere cached: true. Revogar a velha chave após a verificação e manter o perfil e o diretório do estado.

Substitua a chave por Stdin
set -euo pipefail
. ./runtime.sh
: "${FLASHDATA_KEY_FILE:?Point to the mounted replacement key for the same account}"
run_flashdata auth login --replace --api-key-stdin --non-interactive \
  < "$FLASHDATA_KEY_FILE"
run_flashdata auth status --json --non-interactive

Parar o acesso completamente

Pause o agendador, revogue a chave ou a conexão do agente no console, e repita a verificação de acesso livre. Deve falhar. O logout local sozinho não revoga a credencial do servidor; os arquivos já exportados permanecem no disco.

Verificações de implantação que falham

SintomaConsertar
Comando não encontrado / versão errada do CLIVerifique o comando -v flashdata e FLASHDATA_BIN em runtime.sh. Para Docker, reconstrua e execute a verificação --version da imagem.
Faltando montagem ou permissão negadaCrie as pastas de estado e tarefa no host Docker, propriedade do serviço UID/GID. Mantenha seus caminhos estáveis.
replacement_requires_flagO perfil tem uma chave diferente. Verifique o acesso existente primeiro, use o procedimento de rotação para uma substituição pretendida.
Não foi possível descodificar o acesso salvoCorra como o usuário que providenciou, no mesmo ambiente de loja de credenciais. Acesso de provisão em um novo destino em vez de copiar um perfil criptografado de laptop.
A verificação de custos devolve falsoExamine balance.json e preflight.json. Antes de enviar a requisição, confirme um preço disponível, a permissão para a fonte e saldo suficiente.
run_account_mismatchVerifique a conta selecionada e as origens do API. Restaure o acesso original, não mude o nome da corrida para evitar a recuperação.
run_id_input_conflictRestaure o pedido original do request.json. Use uma nova corrida ID apenas para uma nova tarefa paga.
O informante fica na filaVerifique se o corredor está online e tem todas as etiquetas. Este fluxo de trabalho requer um persistente corredor Linux.