As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.
# Cache de chamadas para execuções HealthOmics
AWS HealthOmics suporta cache de chamadas, também conhecido como currículo, para fluxos de trabalho privados. O cache de chamadas salva as saídas das tarefas concluídas do fluxo de trabalho após o término da execução. As execuções subsequentes podem usar as saídas da tarefa do cache, em vez de computar as saídas da tarefa novamente. O cache de chamadas reduz o uso de recursos computacionais, o que resulta em menores durações de execução e economia de custos computacionais.
Você pode acessar os arquivos de saída da tarefa em cache após a conclusão da execução. Para executar a depuração e a solução de problemas avançadas de tarefas, você pode armazenar em cache arquivos de tarefas intermediárias especificando esses arquivos como saídas de tarefas na definição do fluxo de trabalho.
Você pode usar o cache de chamadas para salvar os resultados da tarefa concluída de execuções com falha. A próxima execução começa com a última tarefa concluída com êxito, em vez de computar as tarefas concluídas novamente.
Se HealthOmics não encontrar uma entrada de cache correspondente para uma tarefa, a execução não falhará. HealthOmics recalcula a tarefa e suas tarefas dependentes.
Para obter informações sobre como solucionar problemas de cache de chamadas, consulte[Solução de problemas de cache de chamadas](troubleshooting.md#workflow-cache-troubleshooting).
**Topics**
+ [Como funciona o cache de chamadas](how-run-cache.md)
+ [Criando um cache de execução](workflow-cache-create.md)
+ [Atualizando um cache de execução](workflow-cache-update.md)
+ [Excluindo um cache de execução](workflow-cache-delete.md)
+ [Conteúdo de um cache de execução](workflow-cache-contents.md)
+ [Recursos de cache específicos do mecanismo](workflow-cache-per-engine.md)
+ [Usando o cache de execução](workflow-cache-startrun.md)
# Como funciona o cache de chamadas
Para usar o cache de chamadas, você cria um cache de execução e o configura para ter um local Amazon S3 associado aos dados em cache. Ao iniciar uma execução, você especifica o cache de execução. Um cache de execução não é dedicado a um fluxo de trabalho. As execuções de vários fluxos de trabalho podem usar o mesmo cache.
Durante a fase de exportação de uma execução, o sistema exporta as saídas concluídas da tarefa para o local do Amazon S3. Para exportar arquivos de tarefas intermediárias, declare esses arquivos como saídas de tarefas na definição do fluxo de trabalho. O cache de chamadas também salva internamente os metadados e cria hashes exclusivos para cada entrada do cache.
Para cada tarefa em execução, o mecanismo de fluxo de trabalho detecta se há uma entrada de cache correspondente para essa tarefa. Se não houver nenhuma entrada de cache correspondente, HealthOmics calcula a tarefa. Se houver uma entrada de cache correspondente, o mecanismo recuperará os resultados em cache.
Para combinar as entradas do cache, HealthOmics usa o mecanismo de hash incluído nos mecanismos de fluxo de trabalho nativos. HealthOmicsestende essas implementações de hash existentes para contabilizar HealthOmics variáveis, como S3 ETags e resumos de contêineres ECR.
HealthOmics oferece suporte ao cache de chamadas para essas versões de linguagem do fluxo de trabalho:
+ Versões WDL 1.0, 1.1 e a versão de desenvolvimento
+ Nextflow versão 23.10 e posterior
+ Todas as versões do CWL
**nota**
HealthOmics não oferece suporte ao cache de chamadas para fluxos de trabalho do Ready2Run.
**Topics**
+ [Modelo de responsabilidade compartilhada](#run-cache-srm)
+ [Requisitos de armazenamento em cache para tarefas](#workflow-cache-task-prereqs)
+ [Execute o desempenho do cache](#run-cache-performance)
+ [Eventos de retenção e invalidação de dados em cache](#workflow-cache-data)
## Modelo de responsabilidade compartilhada
Há uma responsabilidade compartilhada entre os usuários de determinar AWS se tarefas e execuções são boas candidatas para o armazenamento em cache de chamadas. O cache de chamadas obtém os melhores resultados quando todas as tarefas são idempotentes (execuções repetidas de uma tarefa usando as mesmas entradas produzem os mesmos resultados).
No entanto, se uma tarefa incluir elementos não determinísticos (como gerações de números aleatórios ou hora do sistema), execuções repetidas da tarefa usando as mesmas entradas podem resultar em saídas diferentes. Isso pode afetar a eficácia do armazenamento em cache de chamadas das seguintes formas:
+ Se HealthOmics usar uma entrada de cache (criada por uma execução anterior) que não seja idêntica à saída que a execução da tarefa produziria para a execução atual, a execução poderá gerar resultados diferentes da mesma execução sem armazenamento em cache.
+ HealthOmics pode não encontrar uma entrada de cache correspondente para uma tarefa que deva corresponder, devido às saídas de tarefas não determinísticas. Se não encontrar a entrada de cache válida, a execução recomputará desnecessariamente a tarefa, o que reduz os benefícios de economia de custos do uso do cache de chamadas.
A seguir estão os comportamentos de tarefas conhecidos que podem causar resultados não determinísticos que afetam os resultados do cache de chamadas:
+ Usando geradores de números aleatórios.
+ Dependência da hora do sistema.
+ Usando a concorrência (condições de corrida podem causar variação na saída).
+ Buscar arquivos locais ou remotos além do especificado nos parâmetros de entrada da tarefa.
Para outros cenários que podem causar comportamento não determinístico, consulte [Entradas de processo não determinísticas no site de documentação do Nextflow](https://www.nextflow.io/docs/latest/cache-and-resume.html#non-deterministic-process-inputs).
Se você suspeitar que uma tarefa produz resultados não determinísticos, considere usar os recursos do mecanismo de fluxo de trabalho para evitar o armazenamento em cache de tarefas específicas que não sejam determinísticas. Para obter instruções sobre como desativar o armazenamento em cache para tarefas individuais em cada linguagem de fluxo de trabalho compatível, consulte[Recursos de cache específicos do mecanismo](workflow-cache-per-engine.md).
Recomendamos que você analise minuciosamente seus requisitos específicos de fluxo de trabalho e tarefas antes de ativar o cache de chamadas em qualquer ambiente em que o cache de chamadas ineficaz ou saídas diferentes do esperado possam apresentar riscos. Por exemplo, as possíveis limitações do armazenamento em cache de chamadas devem ser cuidadosamente consideradas para determinar se o cache de chamadas é apropriado para casos de uso clínico.
## Requisitos de armazenamento em cache para tarefas
HealthOmics armazena em cache as saídas de tarefas que atendem aos seguintes requisitos:
+ A tarefa deve definir um contêiner. HealthOmics não armazenará em cache as saídas de uma tarefa sem contêiner.
+ A tarefa deve produzir uma ou mais saídas. Você especifica as saídas da tarefa na definição do fluxo de trabalho.
+ A definição do fluxo de trabalho não deve usar valores dinâmicos. Por exemplo, se você passar um parâmetro para uma tarefa com um valor que aumenta a cada execução, HealthOmics não armazena em cache as saídas da tarefa.
**nota**
Se várias tarefas em uma execução usarem a mesma imagem de contêiner, HealthOmics fornecerá a mesma versão de imagem para todas essas tarefas. Depois de HealthOmics extrair a imagem, ela ignora todas as atualizações na imagem do contêiner durante a execução. Essa abordagem fornece uma experiência previsível e consistente e evita possíveis problemas que possam surgir de atualizações na imagem do contêiner implantadas no meio da execução.
## Execute o desempenho do cache
Ao ativar o cache de chamadas para uma execução, você pode observar os seguintes impactos no desempenho da execução:
+ Durante a primeira execução, HealthOmics salva os dados do cache para as tarefas na execução. Você pode ter tempos de exportação mais longos para essa execução, porque o cache de chamadas aumenta a quantidade de dados de exportação.
+ Em execuções subsequentes, ao retomar uma execução do cache, isso pode reduzir o número de etapas de processamento e reduzir o tempo de execução.
+ Se você também optar por declarar arquivos intermediários como saídas, o tempo de exportação poderá ser ainda maior, pois esses dados podem ser mais detalhados.
## Eventos de retenção e invalidação de dados em cache
O objetivo principal de um cache de execução é otimizar o cálculo das tarefas na execução. Se houver uma entrada de cache correspondente válida para uma tarefa, HealthOmics use a entrada de cache em vez de recalcular a tarefa. Caso contrário, HealthOmics reverte para o comportamento padrão do serviço, que é recalcular a tarefa e suas tarefas dependentes. Ao usar essa abordagem, falhas de cache não fazem com que a execução falhe.
Recomendamos que você gerencie o tamanho do cache de execução. Com o tempo, as entradas de cache podem não ser mais válidas devido às atualizações do mecanismo de fluxo de trabalho ou do HealthOmics serviço ou devido às alterações feitas na execução ou nas tarefas de execução. As seções a seguir fornecem detalhes adicionais.
**Topics**
+ [Atualizações de versões do manifesto e atualização de dados](#workflow-cache-data-versions)
+ [Comportamento do cache de execução](#run-cache-behavior)
+ [Controle o tamanho do cache de execução](#workflow-cache-manage)
### Atualizações de versões do manifesto e atualização de dados
Periodicamente, o HealthOmics serviço pode introduzir novos recursos ou atualizações do mecanismo de fluxo de trabalho que invalidam algumas ou todas as entradas de cache de execução. Nessa situação, suas execuções podem sofrer uma única perda de cache.
HealthOmics cria um [arquivo de manifesto JSON](workflow-cache-contents.md) para cada entrada de cache. Para execuções iniciadas após 12 de fevereiro de 2025, o arquivo de manifesto inclui um parâmetro de versão. Se uma atualização de serviço invalidar qualquer entrada de cache, HealthOmics incrementa o número da versão para que você possa identificar as entradas de cache herdadas para remoção.
O exemplo a seguir mostra um arquivo de manifesto com a versão definida como 2:
```
{
"arn": "arn:aws:omics:us-west-2:12345678901:runCache/0123456/cacheEntry/1234567-195f-3921-a1fa-ffffcef0a6a4",
"s3uri": "s3://example/1234567-d0d1-e230-d599-10f1539f4a32/1348677/4795326/7e8c69b1-145f-3991-a1fa-ffffcef0a6a4",
"taskArn": "arn:aws:omics:us-west-2:12345678901:task/4567891",
"workDir": "/mnt/workflow/1234567-d0d1-e230-d599-10f1539f4a32/workdir/call-TxtFileCopyTask/5w6tn5feyga7noasjuecdeoqpkltrfo3/wxz2fuddlo6hc4uh5s2lreaayczduxdm",
"files": [
{
"name": "output_txt_file",
"path": "out/output_txt_file/outfile.txt",
"etag": "ajdhyg9736b9654673b9fbb486753bc8"
}
],
"nextflowContext": {},
"otherOutputs": {},
"version": 2,
}
```
Para execuções com entradas de cache que não são mais válidas, reconstrua o cache para criar novas entradas válidas. Execute as seguintes etapas para cada execução:
1. Inicie a execução uma vez com a retenção de cache definida como CACHE ALWAYS. Essa execução cria as novas entradas de cache.
1. Para execuções subsequentes, defina a retenção do cache para a configuração anterior (CACHE ALWAYS ou CACHE ON FAILURE).
Para limpar as entradas de cache que não são mais válidas, você pode excluir essas entradas de cache do bucket cache do Amazon S3. HealthOmics nunca reutiliza essas entradas de cache. Se você optar por reter entradas que não são válidas, não haverá impacto em suas corridas.
**nota**
O cache de chamadas salva os dados de saída da tarefa no local do Amazon S3 especificado para o cache, o que gera cobranças para você. Conta da AWS
### Comportamento do cache de execução
Você pode definir o comportamento do cache de execução para salvar as saídas da tarefa para execuções que falham (cache em caso de falha) ou para todas as execuções (cache sempre). Ao criar um cache de execução, você define o comportamento padrão do cache para todas as execuções que usam esse cache. Você pode substituir o comportamento padrão ao iniciar uma execução.
**Cache on failure**é útil se você estiver depurando um fluxo de trabalho que falha após a conclusão bem-sucedida de várias tarefas. A execução subsequente é retomada a partir da última tarefa concluída com êxito se todas as variáveis exclusivas consideradas pelo hash forem idênticas à execução anterior.
**Cache always**é útil se você estiver atualizando uma tarefa em um fluxo de trabalho concluído com êxito. Recomendamos que você siga estas etapas:
1. Crie uma nova corrida. Defina o **comportamento** do **Cache como Cache sempre** e inicie a execução.
1. Depois que a execução for concluída, atualize a tarefa no fluxo de trabalho e inicie uma nova execução com o comportamento definido **Cache always**. Essa execução processa a tarefa atualizada e todas as tarefas subsequentes que dependam da tarefa atualizada. Todas as outras tarefas usam os resultados em cache.
1. Repita a etapa 2 conforme necessário, até que o desenvolvimento da tarefa atualizada esteja concluído.
1. Use a tarefa atualizada conforme necessário em execuções futuras. Lembre-se de alternar as execuções subsequentes para **Cache em caso de falha** se você planeja usar entradas novas ou diferentes para essas execuções.
**nota**
Recomendamos o modo **Cache sempre** usando o mesmo conjunto de dados de teste, mas não para um lote de execuções. Se você definir esse modo para um grande lote de execuções, o sistema poderá exportar grandes quantidades de dados para o Amazon S3, resultando em maiores tempos de exportação e custos de armazenamento.
### Controle o tamanho do cache de execução
HealthOmics não exclui nem arquiva automaticamente nenhum dado de cache executado nem aplica as regras de limpeza do Amazon S3 para gerenciar os dados do cache. Recomendamos que você realize limpezas regulares do cache para economizar nos custos de armazenamento do Amazon S3 e manter o tamanho do cache de execução gerenciável. Você pode excluir arquivos diretamente ou definir retention/replication políticas de dados no bucket de execução do cache.
Por exemplo, você pode configurar uma política de ciclo de vida do Amazon S3 para expirar objetos após 90 dias ou pode limpar manualmente os dados do cache no final de cada projeto de desenvolvimento.
As informações a seguir podem ajudá-lo a gerenciar o tamanho dos dados do cache:
+ Você pode ver quantos dados estão no cache verificando o Amazon S3. HealthOmics não monitora nem relata o tamanho do cache.
+ Se você excluir uma entrada de cache válida, a execução subsequente não falhará. HealthOmics recalcula a tarefa e suas tarefas dependentes.
+ Se você modificar nomes de cache ou estruturas de diretórios de forma que HealthOmics não consiga encontrar uma entrada correspondente para uma tarefa, HealthOmics recalculará a tarefa.
Se você precisar verificar se uma entrada de cache ainda é válida, verifique o número da versão do manifesto do cache. Para obter mais informações, consulte [Atualizações de versões do manifesto e atualização de dados](#workflow-cache-data-versions).
# Criando um cache de execução
Ao criar um cache de execução, você especifica uma localização do Amazon S3 para os dados do cache. Esses dados devem estar imediatamente acessíveis. O cache de chamadas não recupera objetos arquivados no Glacier (como as classes de armazenamento GFR e GDA).
Se o bucket do Amazon S3 para os dados do cache pertencer a outra pessoa Conta da AWS, forneça esse ID da conta ao criar o cache de execução.
## Criando um cache de execução usando o console
No console, siga estas etapas para criar um cache de execução.
1. Abra o [console do HealthOmics ](https://console.aws.amazon.com/omics/).
1. Se necessário, abra o painel de navegação esquerdo (≡). Escolha **Executar caches**.
1. Na página **Executar caches**, escolha **Criar cache de execução**.
1. No painel de **detalhes do cache de execução** da página **Criar cache de execução**, configure estes campos:
1. Insira um nome para o cache de execução.
1. (Opcional) Insira uma descrição.
1. Insira um local S3 para a saída em cache. Escolha um bucket na mesma região do seu fluxo de trabalho.
1. (Opcional) Insira o Conta da AWS do proprietário do bucket para verificar a propriedade do bucket. Se você não inserir um valor, o valor padrão será o ID da sua conta.
1. Em **Comportamento do cache**, configure o comportamento padrão (seja para armazenar em cache as saídas para execuções com falha ou para todas as execuções). Ao iniciar uma execução, você pode, opcionalmente, substituir o comportamento padrão.
1. (Opcional) Associe uma ou mais tags ao cache de execução.
1. Escolha **Criar cache de execução**. O console exibe o novo cache de execução na tabela **Executar caches**.
## Criando um cache de execução usando a CLI
Use o comando **create-run-cache**CLI para criar um cache de execução. O comportamento padrão do cache é`CACHE_ON_FAILURE`.
```
aws omics create-run-cache \
--name "workflow 123 run cache" \
--description "my run cache" \
--cache-s3-location "s3://amzn-s3-demo-bucket" \
--cache-behavior "CACHE_ALWAYS" \
--cache-bucket-owner-id "111122223333"
```
Se a criação for bem-sucedida, você receberá uma resposta com os seguintes campos.
```
{
"arn": "string",
"id": "string",
"status": "ACTIVE"
"tags": {}
}
```
# Atualizando um cache de execução
Você pode alterar o nome, a descrição, as tags ou o comportamento do cache, mas não a localização do cache no S3.
## Atualizando um cache de execução usando o console
No console, siga estas etapas para atualizar um cache de execução.
1. Abra o [console do HealthOmics ](https://console.aws.amazon.com/omics/).
1. Se necessário, abra o painel de navegação esquerdo (≡). Escolha **Executar caches**.
1. Na tabela **Executar caches**, escolha o cache de execução a ser atualizado e, em seguida, escolha **Editar**.
1. No painel de **detalhes da execução do cache**, você pode atualizar os campos de nome, descrição e comportamento do cache de execução.
1. (Opcional) Associe uma ou mais novas tags ao cache de execução ou remova as tags existentes.
1. Escolha **Salvar cache de execução**.
## Atualizando um cache de execução usando a CLI
Use o comando **update-run-cache**CLI para atualizar um cache de execução.
```
aws omics update-run-cache \
--name "workflow 123 run cache" \
--id "workflow id" \
--description "my run cache" \
--cache-behavior "CACHE_ALWAYS"
```
Se a atualização for bem-sucedida, você receberá uma resposta sem campos de dados.
# Excluindo um cache de execução
Você pode excluir um cache de execução se nenhuma execução ativa o estiver usando. Se alguma execução estiver usando o cache de execução, aguarde a conclusão das execuções ou você poderá cancelá-las.
A exclusão de um cache de execução remove o recurso e seus metadados, mas não exclui os dados no Amazon S3. Depois de excluir o cache, você não poderá reconectá-lo nem usá-lo para execuções subsequentes.
Os dados em cache permanecem no Amazon S3 para sua inspeção. Você pode remover dados antigos do cache usando **Delete** operações padrão do S3. Como alternativa, crie uma política de ciclo de vida do Amazon S3 para expirar dados em cache que você não usa mais.
## Excluindo um cache de execução usando o console
No console, siga estas etapas para excluir um cache de execução.
1. Abra o [console do HealthOmics ](https://console.aws.amazon.com/omics/).
1. Se necessário, abra o painel de navegação esquerdo (≡). Escolha **Executar caches**.
1. Na tabela **Executar caches**, escolha o cache de execução a ser excluído.
1. No menu **Executar tabela de caches**, escolha **Excluir**.
1. Na caixa de diálogo modal, salve o link de dados do cache do Amazon S3 para referência futura e confirme que você deseja excluir o cache de execução.
Você pode usar o link do Amazon S3 para inspecionar os dados em cache, mas não pode revincular os dados a outro cache de execução. Exclua os dados do cache quando terminar a inspeção.
## Excluindo um cache de execução usando a CLI
Use o comando **delete-run-cache**CLI para excluir um cache de execução.
```
aws omics delete-run-cache \
--id "my cache id"
```
Se a exclusão for bem-sucedida, você receberá uma resposta sem campos de dados.
# Conteúdo de um cache de execução
HealthOmics organiza seu cache de execução com a seguinte estrutura em seu bucket do S3:
```
s3://{cache.S3location}/{cache.uuid}/runID/taskID/{cacheentry.uuid}/
```
O cache.uuid é o ID global exclusivo do cache. O cacheentry.uuid é o uuid globalmente exclusivo para uma tarefa em cache. HealthOmics atribui os uuids a caches e tarefas.
Para todos os mecanismos de fluxo de trabalho, o cache contém os seguintes arquivos:
+ O **\$1cacheentryuuid\$1.json** arquivo — HealthOmics cria esse arquivo de manifesto, que contém informações sobre o cache, incluindo uma lista de todos os itens no cache e a [versão do cache](how-run-cache.md#workflow-cache-data-versions).
+ Arquivos de saída da tarefa — Cada saída da tarefa consiste em um ou mais arquivos, conforme definido pela tarefa.
Para um fluxo de trabalho que usa o Nextflow, o mecanismo do Nextflow cria esses arquivos adicionais no cache:
+ O **command.out** arquivo — Esse arquivo contém o conteúdo padrão da execução da tarefa.
+ O **.exitcode** arquivo — Esse arquivo contém o código de saída da tarefa (um número inteiro).
**nota**
Se você quiser acessar arquivos de tarefas intermediárias no cache de execução para solucionar problemas avançados, declare esses arquivos como saídas de tarefas na definição do fluxo de trabalho.
# Recursos de cache específicos do mecanismo
HealthOmics tenta fornecer uma implementação consistente do cache de chamadas em todos os mecanismos de fluxo de trabalho. Há algumas diferenças com base na forma como cada mecanismo de fluxo de trabalho lida com casos específicos:
+ Próximo fluxo
+ O armazenamento em cache em diferentes versões do Nextflow não é garantido. Se você executar uma tarefa em uma versão do Nextflow e depois executar a mesma tarefa em uma versão diferente do Nextflow, HealthOmics pode considerar a segunda execução como uma perda de cache.
+ Você pode desativar o armazenamento em cache para tarefas individuais usando a **false** diretiva cache. Para obter informações sobre essa diretiva, consulte os [Processos](https://www.nextflow.io/docs/latest/process.html#process-cache) na especificação Nextflow.
+ HealthOmics usa o modo tolerante Nextflow, mas não oferece suporte ao modo de cache profundo.
+ O armazenamento em cache avalia cada objeto individual do S3 se você usar um padrão global no caminho do S3 até as entradas de uma tarefa. Se você adicionar um novo objeto, HealthOmics recalcula somente as tarefas que usam o novo objeto.
+ HealthOmics não armazena em cache as novas tentativas de tarefas. Esse comportamento é consistente com o comportamento padrão do Nextflow.
+ WDL
+ HealthOmics suporta o novo tipo de “diretório” para entradas quando você usa a versão de desenvolvimento do fluxo de trabalho da WDL. Para o armazenamento em cache de chamadas, se algum objeto no diretório mudar, HealthOmics recalcula todas as tarefas que entram no diretório.
+ HealthOmics oferece suporte ao cache no nível da tarefa, mas não ao cache no nível do fluxo de trabalho.
+ Você pode desativar o armazenamento em cache para tarefas individuais usando o atributo **volatile**. Para obter mais informações, consulte [Desative o armazenamento em cache no nível da tarefa com o atributo volatile](workflow-languages-wdl.md#workflow-wdl-volatile-attribute).
+ CAPUZ
+ As saídas constantes das tarefas não são explicitamente visíveis nos manifestos. HealthOmics armazena em cache saídas constantes como arquivos intermediários.
+ Você pode controlar o armazenamento em cache para tarefas individuais usando o [WorkReuse](https://www.commonwl.org/v1.1/Workflow.html#WorkReuse)recurso.
# Usando o cache de execução
Por padrão, as execuções não usam um cache de execução. Para usar um cache para a execução, você especifica o cache de execução e o comportamento do cache de execução ao iniciar a execução.
Após a conclusão da execução, você pode usar o console, os CloudWatch registros ou as operações da API para rastrear os acessos ao cache ou solucionar problemas de cache. Para obter mais detalhes, consulte [Rastreando informações de cache de chamadas](#workflow-cache-track) e [Solução de problemas de cache de chamadas](troubleshooting.md#workflow-cache-troubleshooting).
Se uma ou mais tarefas em uma execução gerarem saídas não determinísticas, é altamente recomendável que você não use o cache de chamadas para a execução ou desative essas tarefas específicas do armazenamento em cache. Para obter mais informações, consulte [Modelo de responsabilidade compartilhada](how-run-cache.md#run-cache-srm).
**nota**
Você fornece uma função de serviço do IAM ao iniciar uma execução. Para usar o cache de chamadas, a função de serviço precisa de permissão para acessar a localização do cache de execução do Amazon S3. Para obter mais informações, consulte [Funções de serviço para AWS HealthOmics](permissions-service.md).
Você pode usar a [CLI do Kiro](https://docs.aws.amazon.com/kiro/latest/userguide/what-is.html) para analisar e gerenciar seus dados de cache de execução. Para obter mais informações, consulte [Exemplos de solicitações para a CLI do Kiro e o tutorial de IA generativa](getting-started.md#omics-kiro-prompts) da [HealthOmics Agentic](https://github.com/aws-samples/aws-healthomics-tutorials/tree/main/generative-ai) em. GitHub
**Topics**
+ [Configurando uma execução com cache de execução usando o console](#workflow-cache-startrun-console)
+ [Configurando uma execução com cache de execução usando a CLI](#workflow-cache-startrun-api)
+ [Casos de erro para executar caches](#workflow-cache-errors)
+ [Rastreando informações de cache de chamadas](#workflow-cache-track)
## Configurando uma execução com cache de execução usando o console
No console, você configura o cache de execução para uma execução ao iniciar a execução.
1. Abra o [console do HealthOmics ](https://console.aws.amazon.com/omics/).
1. Se necessário, abra o painel de navegação esquerdo (≡). Selecione **Execuções**.
1. Na página **Execuções**, escolha a execução a ser iniciada.
1. Escolha **Iniciar execução** e conclua as etapas 1 e 2 de **Iniciar execução** conforme descrito em[Iniciando uma execução usando o console](starting-a-run.md#starting-a-run-console).
1. Na etapa 3 de **Iniciar execução**, escolha **Selecionar um cache de execução existente**.
1. Selecione o cache na lista suspensa **Executar ID do cache**.
1. Para substituir o comportamento padrão do cache de execução, escolha o **comportamento do cache** para a execução. Para obter mais informações, consulte [Comportamento do cache de execução](how-run-cache.md#run-cache-behavior).
1. Continue com a etapa 4 de **Iniciar execução**.
## Configurando uma execução com cache de execução usando a CLI
**Para iniciar uma execução que usa um cache de execução, adicione o parâmetro cache-id ao comando da CLI start-run.** Opcionalmente, use o `cache-behavior` parâmetro para substituir o comportamento padrão que você configurou para o cache de execução. O exemplo a seguir mostra somente os campos de cache do comando:
```
aws omics start-run \
...
--cache-id "xxxxxx" \
--cache-behavior CACHE_ALWAYS
```
Se a operação for bem-sucedida, você receberá uma resposta sem campos de dados.
## Casos de erro para executar caches
Para os cenários a seguir, HealthOmics talvez não armazene em cache as saídas da tarefa, mesmo para uma execução com o comportamento de cache definido como **Cache always**.
+ Se a execução encontrar um erro antes que a primeira tarefa seja concluída com êxito, não há saídas de cache para exportar.
+ Se o processo de exportação falhar, HealthOmics não salva as saídas da tarefa no local do cache do Amazon S3.
+ Se a execução falhar devido a um **filesystem out of space** erro, o cache de chamadas não salvará nenhuma saída da tarefa.
+ Se você cancelar uma execução, o cache de chamadas não salvará nenhuma saída de tarefa.
+ Se a execução tiver um tempo limite de execução, o cache de chamadas não salvará nenhuma saída da tarefa, mesmo que você tenha configurado a execução para usar o cache em caso de falha.
## Rastreando informações de cache de chamadas
Você pode acompanhar eventos de cache de chamadas (como executar ocorrências de cache) usando o console, a CLI ou os registros. CloudWatch
**Topics**
+ [Rastreie os acessos ao cache usando o console](#workflow-cache-track-console)
+ [Rastreie o cache de chamadas usando a CLI](#workflow-cache-track-cli)
+ [Rastreie o armazenamento em cache de chamadas usando registros CloudWatch](#workflow-cache-track-cwl)
### Rastreie os acessos ao cache usando o console
Na página de detalhes da execução de uma execução, a tabela **Executar tarefas** exibe as informações de **ocorrência do Cache** para cada tarefa. A tabela também inclui um link para a entrada de cache associada. Use o procedimento a seguir para visualizar as informações de ocorrência do cache para uma execução.
1. Abra o [console do HealthOmics ](https://console.aws.amazon.com/omics/).
1. Se necessário, abra o painel de navegação esquerdo (≡). Selecione **Execuções**.
1. Na página **Execuções**, escolha a execução a ser inspecionada.
1. Na página de detalhes da execução, escolha a guia **Executar tarefas** para exibir a tabela de tarefas.
1. Se uma tarefa tiver um cache hit, a coluna **Cache hit** conterá um link para o local de execução da entrada do cache no Amazon S3.
1. Escolha o link para inspecionar a entrada do cache de execução.
### Rastreie o cache de chamadas usando a CLI
Use o comando da **CLI get-run** para confirmar se a execução usou um cache de chamadas.
```
aws omics get-run --id 1234567
```
Na resposta, se o `cacheId` campo estiver definido, a execução usa esse cache.
Use o comando **list-run-tasks**CLI para recuperar o local dos dados do cache para cada tarefa em cache na execução.
```
aws omics list-run-tasks --id 1234567
```
Na resposta, se o campo CacheHit de uma tarefa for verdadeiro, o campo Cache3URI fornecerá a localização dos dados do cache para essa tarefa.
Você também pode usar o comando **get-run-task**CLI para recuperar o local dos dados do cache para uma tarefa específica:
```
aws omics get-run-task --id 1234567 --task-id
```
### Rastreie o armazenamento em cache de chamadas usando registros CloudWatch
HealthOmics cria registros de atividades de cache no grupo de `/aws/omics/WorkflowLog` CloudWatch registros. Há um fluxo de log para cada cache de execução: **runCache//**.
Para execuções que usam o cache de chamadas, HealthOmics gera entradas de CloudWatch registros para esses eventos:
+ criando uma entrada de cache (CACHE\$1ENTRY\$1CREATED)
+ correspondendo a uma entrada de cache (CACHE\$1HIT)
+ falha em corresponder a uma entrada de cache (CACHE\$1MISS)
Para obter mais informações sobre esses registros, consulte[Login CloudWatch](monitoring-cloudwatch-logs.md#cloudwatch-logs).
Use a seguinte consulta do CloudWatch Insights no grupo de `/aws/omics/WorkflowLog` registros para retornar o número de acessos ao cache por execução desse cache:
```
filter @logStream like 'runCache//'
fields @timestamp, @message
filter logMessage like 'CACHE_HIT'
parse "run: *," as run
stats count(*) as cacheHits by run
```
Use a consulta a seguir para retornar o número de entradas de cache criadas por cada execução:
```
filter @logStream like 'runCache//'
fields @timestamp, @message
filter logMessage like 'CACHE_ENTRY_CREATED'
parse "run: *," as run
stats count(*) as cacheEntries by run
```