Ganeti automatic instance allocation
====================================
-Documents Ganeti version 2.1
+Documents Ganeti version 2.9
.. contents::
Command line interface changes
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-The node selection options in instanece add and instance replace disks
+The node selection options in instance add and instance replace disks
can be replace by the new ``--iallocator=NAME`` option (shortened to
``-I``), which will cause the auto-assignement of nodes with the
passed iallocator. The selected node(s) will be show as part of the
enabled_hypervisors
the list of enabled hypervisors
+ipolicy
+ the cluster-wide instance policy (for information; the per-node group
+ values take precedence and should be used instead)
+
request
a dictionary containing the details of the request; the keys vary
depending on the type of operation that's being requested, as
alloc_policy
the allocation policy of the node group (consult the semantics of
this attribute in the :manpage:`gnt-group(8)` manpage)
+ networks
+ the list of network UUID's this node group is connected to
+ ipolicy
+ the instance policy of the node group
+ tags
+ the list of node group tags
instances
a dictionary with the data for the current existing instance on the
cluster, indexed by instance name; the contents are similar to the
instance definitions for the allocate mode, with the addition of:
- admin_up
+ admin_state
if this instance is set to run (but not the actual status of the
instance)
In all cases, it includes:
type
- the request type; this can be either ``allocate``, ``relocate`` or
- ``multi-evacuate``; the ``allocate`` request is used when a new
- instance needs to be placed on the cluster, while the ``relocate``
- request is used when an existing instance needs to be moved within
- the cluster; the ``multi-evacuate`` protocol requests that the
- script computes the optimal relocate solution for all secondary
- instances of the given nodes
+ the request type; this can be either ``allocate``, ``relocate``,
+ ``change-group`` or ``node-evacuate``. The
+ ``allocate`` request is used when a new instance needs to be placed
+ on the cluster. The ``relocate`` request is used when an existing
+ instance needs to be moved within its node group.
+
+ The ``multi-evacuate`` protocol used to request that the script
+ computes the optimal relocate solution for all secondary instances
+ of the given nodes. It is now deprecated and needs only be
+ implemented if backwards compatibility with Ganeti 2.4 and lower is
+ needed.
+
+ The ``change-group`` request is used to relocate multiple instances
+ across multiple node groups. ``node-evacuate`` evacuates instances
+ off their node(s). These are described in a separate :ref:`design
+ document <multi-reloc-detailed-design>`.
+
+ The ``multi-allocate`` request is used to allocate multiple
+ instances on the cluster. The request is beside of that very
+ similiar to the ``allocate`` one. For more details look at
+ :doc:`Ganeti bulk create <design-bulk-create>`.
For both allocate and relocate mode, the following extra keys are needed
in the ``request`` dictionary:
name
the name of the instance; if the request is a realocation, then this
name will be found in the list of instances (see below), otherwise
- is the FQDN of the new instance
+ is the FQDN of the new instance; type *string*
required_nodes
how many nodes should the algorithm return; while this information
can be deduced from the instace's disk template, it's better if
this computation is left to Ganeti as then allocator scripts are
- less sensitive to changes to the disk templates
+ less sensitive to changes to the disk templates; type *integer*
disk_space_total
the total disk space that will be used by this instance on the
(new) nodes; again, this information can be computed from the list
of instance disks and its template type, but Ganeti is better
- suited to compute it
+ suited to compute it; type *integer*
+
+.. pyassert::
+
+ constants.DISK_ACCESS_SET == set([constants.DISK_RDONLY,
+ constants.DISK_RDWR])
Allocation needs, in addition:
instance (in the order they are exported to the hypervisor):
mode
- either ``r`` or ``w`` denoting if the disk is read-only or
+ either :pyeval:`constants.DISK_RDONLY` or
+ :pyeval:`constants.DISK_RDWR` denoting if the disk is read-only or
writable
size
Relocation:
relocate_from
- a list of nodes to move the instance away from (note that with
- Ganeti 2.0, this list will always contain a single node, the
- current secondary of the instance)
+ a list of nodes to move the instance away from; for DRBD-based
+ instances, this will contain a single node, the current secondary
+ of the instance, whereas for shared-storage instance, this will
+ contain also a single node, the current primary of the instance;
+ type *list of strings*
+
+As for ``node-evacuate``, it needs the following request arguments:
+
+ instances
+ a list of instance names to evacuate; type *list of strings*
-In the case of multi-evacuate, there's one single request argument (in
-addition to ``type``):
+ evac_mode
+ specify which instances to evacuate; one of ``primary-only``,
+ ``secondary-only``, ``all``, type *string*
- evac_nodes
- the names of the nodes to be evacuated
+``change-group`` needs the following request arguments:
+
+ instances
+ a list of instance names whose group to change; type
+ *list of strings*
+
+ target_groups
+ must either be the empty list, or contain a list of group UUIDs that
+ should be considered for relocating instances to; type
+ *list of strings*
+
+``multi-allocate`` needs the following request arguments:
+
+ instances
+ a list of request dicts
Response message
~~~~~~~~~~~~~~~~
entry in the input message, otherwise Ganeti will consider the result
as failed
- for multi-evacuation mode, this is a list of lists; each element of
- the list is a list of instance name and the new secondary node
+ for the ``node-evacuate`` and ``change-group`` modes, this is a
+ dictionary containing, among other information, a list of lists of
+ serialized opcodes; see the :ref:`design document
+ <multi-reloc-result>` for a detailed description
+
+ for the ``multi-allocate`` mode this is a tuple of 2 lists, the first
+ being element of the tuple is a list of succeeded allocation, with the
+ instance name as first element of each entry and the node placement in
+ the second. The second element of the tuple is the instance list of
+ failed allocations.
.. note:: Current Ganeti version accepts either ``result`` or ``nodes``
as a backwards-compatibility measure (older versions only supported
"nodegroups": {
"f4e06e0d-528a-4963-a5ad-10f3e114232d": {
"name": "default",
- "alloc_policy": "preferred"
+ "alloc_policy": "preferred",
+ "networks": ["net-uuid-1", "net-uuid-2"],
+ "ipolicy": {
+ "disk-templates": ["drbd", "plain"],
+ "minmax": [
+ {
+ "max": {
+ "cpu-count": 2,
+ "disk-count": 8,
+ "disk-size": 2048,
+ "memory-size": 12800,
+ "nic-count": 8,
+ "spindle-use": 8
+ },
+ "min": {
+ "cpu-count": 1,
+ "disk-count": 1,
+ "disk-size": 1024,
+ "memory-size": 128,
+ "nic-count": 1,
+ "spindle-use": 1
+ }
+ }
+ ],
+ "spindle-ratio": 32.0,
+ "std": {
+ "cpu-count": 1,
+ "disk-count": 1,
+ "disk-size": 1024,
+ "memory-size": 128,
+ "nic-count": 1,
+ "spindle-use": 1
+ },
+ "vcpu-ratio": 4.0
+ },
+ "tags": ["ng-tag-1", "ng-tag-2"]
}
},
"instances": {
}
}
-Input message, node evacuation::
-
- {
- "version": 2,
- ...
- "request": {
- "type": "multi-evacuate",
- "evac_nodes": [
- "node2"
- ],
- }
- }
-
Response messages
~~~~~~~~~~~~~~~~~
Reference implementation
~~~~~~~~~~~~~~~~~~~~~~~~
-Ganeti's default iallocator is "hail" which is part of the separate
-ganeti-htools project. In order to see its source code please clone
-``git://git.ganeti.org/htools.git``. Note that htools is implemented
-using the Haskell programming language.
+Ganeti's default iallocator is "hail" which is available when "htools"
+components have been enabled at build time (see :doc:`install-quick` for
+more details).
.. vim: set textwidth=72 :
.. Local Variables:
projects / ganeti-local / blobdiff