Provided by: ubuntu-fan_0.12.13_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)