Início / computer / Perguntas / 1664197
Accepted
rawat
Asked: 2021-07-23 22:18:07 +0800 CST

Palavra-chave Ansible - acelerador

  • 772

Estou tentando usar e entender como funciona a palavra-chave acelerador.

Abaixo está como estou usando (test-playbook.yaml).

---
- name: Test throttle
  hosts: all
  
  tasks:

    # list of pre tasks
    
    - name: Execute sequentially
      throttle: 1
      block:
        - include_tasks: task-1.yaml
        
        - include_tasks: task-2.yaml
        
        # a task using some module
        
        # a task using some module

    # list of post tasks

Executadoansible-playbook --inventory some-inventory --limit host1:host2:host3

Estou esperando que em task (Execute sequencialmente) , todos os hosts especificados em --limit serão executados sequencialmente, ou seja, host1 concluirá todas as tarefas no bloco, depois host2 seguido por host3

Mas eles são executados em paralelo (comportamento padrão do Ansible).

Alguém pode ajudar a entender o comportamento do acelerador ? Perdi alguma configuração?

forks/serialtêm valores padrão.

E como posso conseguir um comportamento sequencial.

ansible

1 respostas

  1. Best Answer

    O comportamento padrão do ansible-playbook é a estratégia linear :

    A execução da tarefa está em lockstep por lote de host conforme definido por serial (padrão tudo) . Até o limite do fork de hosts, cada tarefa será executada ao mesmo tempo e, em seguida, a próxima série de hosts até que o lote seja concluído, antes de passar para a próxima tarefa .

    O acelerador serve ao propósito de " limitar o número de trabalhadores para uma tarefa específica... Use o acelerador para restringir tarefas que podem consumir muita CPU ou interagir com uma API de limitação de taxa ".

    Por exemplo, por padrão, execute a tarefa em paralelo (limitado por serial até os forks ) hosts

    - hosts: host1,host2,host3
  tasks:
    - command: sleep 1
      register: result
    - debug:
        msg: "{{ inventory_hostname }} task1
              {{ result.start }} - {{ result.end }}"

    Você pode ver que todos os hosts executaram a tarefa em paralelo

    ok: [host2] => 
  msg: host2 task1 2021-07-23 08:56:14.735263 - 2021-07-23 08:56:15.759474
ok: [host1] => 
  msg: host1 task1 2021-07-23 08:56:14.743419 - 2021-07-23 08:56:15.759518
ok: [host3] => 
  msg: host3 task1 2021-07-23 08:56:14.475249 - 2021-07-23 08:56:15.551159

    Se você limitar a execução por acelerador

        - command: sleep 1
      register: result
      throttle: 1
    - debug:
        msg: "{{ inventory_hostname }} task2
              {{ result.start }} - {{ result.end }}"

    Você pode ver que a execução da tarefa foi serializada

    ok: [host2] => 
  msg: host2 task2 2021-07-23 08:56:20.252623 - 2021-07-23 08:56:21.312210
ok: [host3] => 
  msg: host3 task2 2021-07-23 08:56:22.688410 - 2021-07-23 08:56:23.744130
ok: [host1] => 
  msg: host1 task2 2021-07-23 08:56:17.937011 - 2021-07-23 08:56:18.955631

    Certifique-se de que a hora foi sincronizada antes de começar a experimentar.

    P: " Usando include_tasks não estou obtendo o mesmo comportamento. Todas as tarefas incluídas estão sendo executadas em paralelo. "

    R: Não consigo reproduzir seu problema. Dados os arquivos

    shell> ansible --version
ansible 2.10.1

shell> cat test-119-tasks-2.yml
---
- command: sleep 1
  register: result
- debug:
    msg: "{{ inventory_hostname }} task2
          {{ result.start }} - {{ result.end }}"

shell> cat test-119-tasks-3.yml
---
- command: sleep 1
  register: result
- debug:
    msg: "{{ inventory_hostname }} task3
          {{ result.start }} - {{ result.end }}"

    a tarefa

        - name: Execute sequentially
      throttle: 1
      block:
        - include_tasks: test-119-tasks-2.yml
        - include_tasks: test-119-tasks-3.yml

    dá

    TASK [include_tasks] ***********************************************
included: /export/scratch/tmp8/test-119-tasks-2.yml for host1, host2, host3
TASK [command] *****************************************************
changed: [host1]
changed: [host2]
changed: [host3]

TASK [debug] *******************************************************
ok: [host1] => 
  msg: host1 task2 2021-07-25 10:56:11.832219 - 2021-07-25 10:56:12.848834
ok: [host2] => 
  msg: host2 task2 2021-07-25 10:56:14.312498 - 2021-07-25 10:56:15.330202
ok: [host3] => 
  msg: host3 task2 2021-07-25 10:56:16.751018 - 2021-07-25 10:56:17.774723

TASK [include_tasks] ***********************************************
included: /export/scratch/tmp8/test-119-tasks-3.yml for host1, host2, host3

TASK [command] ******************************************************
changed: [host1]
changed: [host2]
changed: [host3]

TASK [debug] ********************************************************
ok: [host1] => 
  msg: host1 task3 2021-07-25 10:56:20.373052 - 2021-07-25 10:56:21.405847
ok: [host2] => 
  msg: host2 task3 2021-07-25 10:56:22.761254 - 2021-07-25 10:56:23.788941
ok: [host3] => 
  msg: host3 task3 2021-07-25 10:56:25.134650 - 2021-07-25 10:56:26.151786

    Você pode ver que a execução das tarefas incluídas foi serializada. Isso funciona como esperado porque a palavra-chave acelerador é permitida no bloco . A aplicação dessa palavra-chave a um bloco é a mesma que a aplicação dessa palavra-chave a todas as tarefas do bloco.

    • 2

relate perguntas