Provided by: ubuntu-fan_0.12.10_all bug

NAME

       fanatic - fan bridge configuration and test wizard

SYNOPSIS

       fanatic [<cmd> [<arg> ...]]
       fanatic configure
       fanatic deconfigure
       fanatic test

DESCRIPTION

       fanatic  is the configuration and test wizard for Fan networking.  It is designed to simplify the process
       of configuring persistent Fan bridges.  It will also configure both LXD and Docker to use  those  bridges
       as required.

       It  also  can be used to configure Fan networking without any user interaction (see NON-INTERACTIVE USAGE
       below).

       A Fan network is a mechanism for expanding the range of IP addresses available to a system.  It  is  most
       useful for containers systems such as Docker and LXC/LXD, but it can be used in other contexts as well.

TERMINOLOGY

       The  Fan  mapping  is  defined  by a combination of an underlay and an overlay address.  Each of these is
       defined in CIDR network address form.  The overlay prefix defines the  overall  network  prefix  for  the
       overlay  slice.   The  underlay  prefix  defines the prefix bits to strip to obtain the slice identifier.
       This is concatenated with the overlay prefix to calculate the overlay slice which is the range of the Fan
       network  that is assigned to a specific single address within the underlay network. This way each address
       within a 192.168.0.0/16 underlay, mapped to a 250.0.0.0/8 overlay would cover the range:

              250.x.y.0/(8 + (32-16) = 24)

       Thus 8 (32-24) address bits will equate to 254 additional addresses for  each  address  mapped  from  the
       underlay network (you cannot use the first and last address within an IPv4 subnet).

       The following diagram shows a more advanced example with three hosts which will be joined in a single Fan
       network. Two of the hosts are in the same subnet (192.168.12.0/24) and the other  in  a  separate  subnet
       (192.168.13.0/24).   Since  all  three  will share the same overlay network (250.0.0.0/8) we would use an
       underlay of 192.168.0.0/16. The choice of the underlay prefix depends on  the  network  layout  which  is
       mapped  into  an  overlay  network (which overlay prefix is used does not matter).  So, if we really only
       were interested in joining 192.168.12/13.0/24, we could use an underlay of  192.168.12.0/23  which  would
       maximize  the  number  of  addresses per slice but the CIDR network addresses of the slices would be less
       obvious to read.

                            +-------------+
                    ... ----+    Router   +---------------------+
                            +------+------+                     |
                                   |                            |
                            +------+------+                     |
                            |             |                     |
              +-------------+----+   +----+-------------+  +----+-------------+
              | 192.168.12.13/24 |   | 192.168.12.14/24 |  | 192.168.13.13/24 |
              +------------------+   +------------------+  +------------------+
                            .             .                     .
                            .             .                     .
                   +----------------+ +----------------+ +----------------+
                   | 250.12.13.1/24 | | 250.12.14.1/24 | | 250.13.13.1/24 |
                   +----------------+ +----------------+ +----------------+
                   |                     250.0.0.0/8                      |
                   +------------------------------------------------------+

       For the example above, a /16 over /8 layout was chosen because that moves numbers in the  dotted  decimal
       notation in a way that is simpler to read.

       The  overlay  prefix  is  8  bits.  The  underlay  prefix takes the lower 16 bits of each host’s physical
       interface and shifts those left until hitting the least significant bit of the overlay (32-16-8=8).   The
       result is, each interface of the host that is part of the Fan overlay gets a /24 (=8+16) slice of the Fan
       network. The 250.x.y.1 address is assigned to the fan-250 bridge on  each  host  and  would  act  as  the
       gateway address of any container that runs within the overlay slice.

COMMAND SYNTAX

       Running fanatic with no arguments is equivalent to running fanatic configure.

       fanatic [configure]
              Interactively  configure  the local system for Fan.  This action will identify the interface to be
              used and offer to configure an appropriate Fan over the addresses  on  that  interface.   It  will
              further  offer  to  configure  LXD and/or Docker to use this interface.  Finally, it will offer to
              test the configuration as applied both locally and with an optional remote host.

       fanatic deconfigure
              Reverses the interactive configuration above.   It  will  deconfigure  both  LXD  and  Docker  (if
              configured) and then deconfigure the Fan.  These steps are only performed if the configuration was
              generated by fanatic.

       fanatic test
              Runs the testing phase of the interactive setup.  This action enables retesting  of  a  previously
              configured system.  Only those pieces configured will be tested.

       fanatic help
              Shows basic help including usage information and pointers to further help on use of fanatic.

NON-INTERACTIVE USAGE

       It  is  possible  to  run  any  sub-phase of the configure, deconfigure or test phases, which are done by
       fanatic in interactive mode, individually and without user interaction:

       fanatic enable-fan -u <underlay> -o <overlay>
              Configure a Fan over the specified interface.

       fanatic disable-fan -u <underlay> -o <overlay>
              Deconfigure a Fan over the specified interface.

       fanatic enable-lxd -u <underlay> -o <overlay>
              Configure LXD for use on the Fan over the specified interface.

       fanatic disable-lxd -u <underlay> -o <overlay>
              Deconfigure LXD for use on the Fan over the specified interface.

       fanatic enable-docker -u <underlay> -o <overlay>
              Configure docker for use on the Fan over the specified interface.

       fanatic disable-docker -u <underlay> -o <overlay>
              Deconfigure docker for use on the Fan over the specified interface.

       test-host -u <underlay> -o <overlay> -r <remote host IP>
              Test host-to-host Fan functionality.  This requires you to be running the same test script on both
              hosts in the test.

       test-local-lxd -u <underlay> -o <overlay>
              Test  the local LXD configuration by creating a container and running host-to-host testing against
              that container.

       test-local-docker -u <underlay> -o <overlay>
              Test the local Docker configuration by creating  a  container  and  running  host-to-host  testing
              against that container.

USE WITH LXC/LXD

       Once  the  Fan bridges are configured (and LXD is installed), LXC/LXD can be configured to use a specific
       Fan bridge for the network device of containers. This  can  be  done  by  either  modifying  the  default
       template  or  by  creating  a separate template which can be used when creating containers. The latter is
       what fanatic enable-lxd does internally. The same could be done manually by setting link and MTU as shown
       below:

              lxc.network.link = <Fan bridge name>
              lxc.network.mtu = 1450

USE WITH DOCKER

       Once  the Fan bridges are configured (and docker installed), a docker network must be configured (similar
       to the LXD template). New containers can then be configured to use the  Fan  network.  This  is  how  the
       fanatic  enable-docker  call  internally works. The new network will be a bridge network type named after
       the name of the Fan bridge which is to be used. If this were done manually, the docker command would look
       like:

              # sudo docker network create --driver bridge \
                      -o "com.docker.network.bridge.name=<bridge name>" \
                      -o "com.docker.network.driver.mtu=1450" \
                      --subnet <overlay> --ip-range <slice subnet> \
                      --gateway <slice host> \
                      --aux-address "reserved0=<slice host>" \
                      <bridge name>

       This  defines the complete Fan overlay network to be accessed through the Fan bridge given and limits the
       scope of addresses used for containers to a given slice subnet (which is the CIDR  notation  of  the  Fan
       overlay  slice that is assigned to the given Fan bridge). All addresses, within that range, which are not
       to be used need to be declared individually. Usually this is the slice host which is the address  of  the
       host  within the overlay slice (and assigned to the Fan bridge). For example, if the overlay network were
       a 250.0.0.0/8 and the address of the host in the underlay address space were u.u.x.y/16  the  Fan  bridge
       would be called fan-250 and have a 250.x.y.1/24 assigned to it which would be declared as the gateway for
       the 250.x.y.0/24 overlay slice.

LIMITATIONS

       Since docker (at the time of writing) does not support to allow an external  DHCP  service  to  be  used,
       there  is  no  way  to  safely mix docker and LXD containers in the same Fan overlay slice. Both types of
       containers can be mixed though in the same Fan overlay, as long as they use their individual slice.

EXAMPLES

       Assuming that a Fan network should be attached to the primary interface of  the  host  without  any  user
       interaction, the first step is to figure out which is the default interface:

              # ip route show | awk '$1 == "default"{print $NF}'
              ens3

       Next we need to find out what IPv4 address this interface is configured to:

              # ip address show ens3 | awk '$1 == "inet"{print $2}'
              192.168.2.120/24

       If  all  hosts  which participate in the Fan network are located in 192.168.2.0/24, then we can use a /24
       underlay address and get 65535 addresses per slice instead of the 254 if we had to include hosts from the
       192.168.0.0/16 range.

       For all of the following commands of this example we use the address of the interface with a prefix of 20
       which assumes we only care for hosts in 192.168.[0-15].0/24 and results  in  4095  addresses  per  slice.
       Using the interface address tells fanatic to only configure this single interface.

              # sudo fanatic enable-fan -u 192.168.2.120/20 -o 250.0.0.0/8
              configuring fan underlay:192.168.2.120/20 overlay:250.0.0.0/8

              # sudo fanatic enable-lxd -u 192.168.2.120/20 -o 250.0.0.0/8
              configuring LXD for underlay:192.168.2.120/20 \
                overlay:250.0.0.0/8 (fan-250)
              Profile fan-250 created

              # sudo fanatic test-local-lxd -u 192.168.2.120/20 -o 250.0.0.0/8
              local lxd test: creating test container (Ubuntu:lts) ...
              Creating fanatic-test
              Starting fanatic-test
              lxd test: Waiting for addresses on eth0 ...
              lxd test: Waiting for addresses on eth0 ...
              lxd test: Waiting for addresses on eth0 ...
              test master: ping test (250.39.132.96) ...
              test slave: ping test (250.39.128.1) ...
              test master: ping test ... PASS
              test master: short data test (250.39.128.1 -> 250.39.132.96) ...
              test slave: ping test ... PASS
              test slave: short data test (250.39.132.96 -> 250.39.128.1) ...
              test slave: short data ... PASS
              test master: short data ... PASS
              test master: long data test (250.39.128.1 -> 250.39.132.96) ...
              test slave: long data test (250.39.132.96 -> 250.39.128.1) ...
              test master: long data ... PASS
              test slave: long data ... PASS
              local lxd test: destroying test container ...
              local lxd test: test complete PASS (master=0 slave=0)

SEE ALSO

       fanctl(8), /usr/share/doc/ubuntu-fan/README

AUTHOR(s)

       Andy Whitcroft <apw@canonical.com>,
       Stefan Bader <stefan.bader@canonical.com>

                                                  July 25, 2017                                       FANATIC(8)