Qual é a diferença entre include_tasks e import_tasks?

Question

No Ansible 2.4, o módulo include está obsoleto. Em seu lugar, ele vem com dois módulos de substituição, import_tasks e include_tasks . Mas eles têm descrições muito semelhantes:

• include_tasks : Inclui um arquivo com uma lista de tarefas a serem executadas no playbook atual.
• import_tasks : Importa uma lista de tarefas a serem adicionadas ao playbook atual para execução subseqüente.

Quando devo usar o primeiro e quando devo usá-lo?

    

Answer 1

Há um pouco sobre esse tópico na documentação:

• Inclui vs. importações
• Dinâmica vs. estática

A principal diferença é:

All import* statements are pre-processed at the time playbooks are parsed.
All include* statements are processed as they encountered during the execution of the playbook.

Portanto, import é estático, include é dinâmico.

Da minha experiência, você deve usar import quando lida com "unidades" lógicas. Por exemplo, separe uma longa lista de tarefas em arquivos de subtarefas:

main.yml:

- import_tasks: prepare_filesystem.yml
- import_tasks: install_prerequisites.yml
- import_tasks: install_application.yml

Mas você usaria include para lidar com diferentes fluxos de trabalho e tomar decisões com base em alguns fatos coletados dinamicamente:

install_prerequisites:

- include_tasks: prerequisites_{{ ansible_os_family | lower }}.yml

    

Answer 2

As importações são estáticas e as inclusões são dinâmicas. As importações acontecem no momento da análise, incluídas no tempo de execução.

As importações basicamente substituem a tarefa pelas tarefas do arquivo. Não há import_task no tempo de execução. Assim, atributos como tags e when (e provavelmente outros atributos) são copiados para cada tarefa importada.

include s são realmente executados. tags e when de uma tarefa incluída se aplicam somente à tarefa em si.

As tarefas marcadas de um arquivo importado são executadas se a tarefa import não estiver marcada. Nenhuma tarefa é executada a partir de um arquivo incluído se a tarefa include não estiver marcada.

Todas as tarefas de um arquivo importado são executadas se import task estiver marcada. Apenas tarefas marcadas de um arquivo incluído são executadas se include task for marcada.

Limitações de import s:

• não pode ser usado com with_* ou loop attributes
• não pode importar um arquivo, cujo nome depende de uma variável

Limitações de include s:

• --list-tags não mostra tags de arquivos incluídos
• --list-tasks não mostra tarefas dos arquivos incluídos
• você não pode usar notify para acionar um nome de manipulador que vem de dentro de uma inclusão dinâmica
• você não pode usar --start-at-task para começar a execução em uma tarefa dentro de uma inclusão dinâmica

Mais sobre isso aqui e aqui .

Para mim, isso basicamente se resume ao fato de que import s não pode ser usado com atributos de loop.

import certamente falharia em casos como isto :

# playbook.yml
- import_tasks: set-x.yml
  when: x is not defined

# set-x.yml
- set_fact
  x: foo
- debug:
  var: x

debug não é executado, pois herda when da tarefa import_tasks . Portanto, nenhum arquivo de tarefa de importação que altere as variáveis usadas no atributo import when .

Eu tinha uma política para começar com import s, mas depois que eu precisar de um include , verifique se nada foi importado por esse arquivo incluído ou pelos arquivos incluídos. Mas isso é muito difícil de manter. E ainda não está claro se isso vai me proteger dos problemas. Isso é misturar include s e import s, o que eles não recomendam.

Eu não posso usar apenas import s, já que ocasionalmente eu preciso fazer um loop de include tarefas. Eu provavelmente poderia mudar para apenas include s. Mas decidi mudar para importações em todos os lugares, exceto nos casos em que a tarefa deveria ser executada várias vezes. Eu decidi experimentar todos esses casos complicados em primeira mão. Talvez não haja nenhum em meus manuais. Ou espero encontrar uma maneira de fazer isso funcionar.