github.com/ferranbt/nomad@v0.9.3-0.20190607002617-85c449b7667c/website/source/docs/internals/scheduling/scheduling.html.md (about)

     1  ---
     2  layout: "docs"
     3  page_title: "Scheduling"
     4  sidebar_current: "docs-internals-scheduling-internals"
     5  description: |-
     6    Learn about how scheduling works in Nomad.
     7  ---
     8  
     9  # Scheduling in Nomad
    10  
    11  [![Nomad Data Model][img-data-model]][img-data-model]
    12  
    13  There are four primary "nouns" in Nomad; jobs, nodes, allocations, and
    14  evaluations. Jobs are submitted by users and represent a _desired state_. A job
    15  is a declarative description of tasks to run which are bounded by constraints
    16  and require resources. Tasks can be scheduled on  nodes in the cluster running
    17  the Nomad client. The mapping of tasks in a job to clients is done using
    18  allocations. An allocation is used to declare that a set of tasks in a job
    19  should be run on a particular node. Scheduling is the process of determining
    20  the appropriate allocations and is done as part of an evaluation.
    21  
    22  An evaluation is created any time the external state, either desired or
    23  emergent, changes. The desired state is based on jobs, meaning the desired
    24  state changes if a new job is submitted, an existing job is updated, or a job
    25  is deregistered. The emergent state is based on the client nodes, and so we
    26  must handle the failure of any clients in the system. These events trigger the
    27  creation of a new evaluation, as Nomad must _evaluate_ the state of the world
    28  and reconcile it with the desired state.
    29  
    30  This diagram shows the flow of an evaluation through Nomad:
    31  
    32  [![Nomad Evaluation Flow][img-eval-flow]][img-eval-flow]
    33  
    34  The lifecycle of an evaluation begins with an event causing the evaluation to
    35  be created. Evaluations are created in the `pending` state and are enqueued
    36  into the evaluation broker. There is a single evaluation broker which runs on
    37  the leader server. The evaluation broker is used to manage the queue of pending
    38  evaluations, provide priority ordering, and ensure at least once delivery.
    39  
    40  Nomad servers run scheduling workers, defaulting to one per CPU core, which are
    41  used to process evaluations. The workers dequeue evaluations from the broker,
    42  and then invoke the appropriate scheduler as specified by the job. Nomad ships
    43  with a `service` scheduler that optimizes for long-lived services, a `batch`
    44  scheduler that is used for fast placement of batch jobs, a `system` scheduler
    45  that is used to run jobs on every node, and a `core` scheduler which is used
    46  for internal maintenance. Nomad can be extended to support custom schedulers as
    47  well.
    48  
    49  Schedulers are responsible for processing an evaluation and generating an
    50  allocation _plan_. The plan is the set of allocations to evict, update, or
    51  create. The specific logic used to generate a plan may vary by scheduler, but
    52  generally the scheduler needs to first reconcile the desired state with the
    53  real state to determine what must be done. New allocations need to be placed
    54  and existing allocations may need to be updated, migrated, or stopped.
    55  
    56  Placing allocations is split into two distinct phases, feasibility checking and
    57  ranking. In the first phase the scheduler finds nodes that are feasible by
    58  filtering unhealthy nodes, those missing necessary drivers, and those failing
    59  the specified constraints.
    60  
    61  The second phase is ranking, where the scheduler scores feasible nodes to find
    62  the best fit. Scoring is primarily based on bin packing, which is used to
    63  optimize the resource utilization and density of applications, but is also
    64  augmented by affinity and anti-affinity rules. Nomad automatically applies a job
    65  anti-affinity rule which discourages colocating multiple instances of a task
    66  group. The combination of this anti-affinity and bin packing optimizes for
    67  density while reducing the probability of correlated failures.
    68  
    69  Once the scheduler has ranked enough nodes, the highest ranking node is
    70  selected and added to the allocation plan.
    71  
    72  When planning is complete, the scheduler submits the plan to the leader which
    73  adds the plan to the plan queue. The plan queue manages pending plans, provides
    74  priority ordering, and allows Nomad to handle concurrency races. Multiple
    75  schedulers are running in parallel without locking or reservations, making
    76  Nomad optimistically concurrent. As a result, schedulers might overlap work on
    77  the same node and cause resource over-subscription. The plan queue allows the
    78  leader node to protect against this and do partial or complete rejections of a
    79  plan.
    80  
    81  As the leader processes plans, it creates allocations when there is no conflict
    82  and otherwise informs the scheduler of a failure in the plan result. The plan
    83  result provides feedback to the scheduler, allowing it to terminate or explore
    84  alternate plans if the previous plan was partially or completely rejected.
    85  
    86  Once the scheduler has finished processing an evaluation, it updates the status
    87  of the evaluation and acknowledges delivery with the evaluation broker. This
    88  completes the lifecycle of an evaluation. Allocations that were created,
    89  modified or deleted as a result will be picked up by client nodes and will
    90  begin execution.
    91  
    92  [Omega]: https://research.google.com/pubs/pub41684.html
    93  [Borg]: https://research.google.com/pubs/pub43438.html
    94  [img-data-model]: /assets/images/nomad-data-model.png
    95  [img-eval-flow]: /assets/images/nomad-evaluation-flow.png