<?xml version='1.0' encoding='utf-8' ?>
<!DOCTYPE section PUBLIC "-//OASIS//DTD DocBook XML V4.5//EN" "http://www.oasis-open.org/docbook/xml/4.5/docbookx.dtd" [
<!ENTITY % BOOK_ENTITIES SYSTEM "cloudstack.ent">
%BOOK_ENTITIES;
]>

<!-- Licensed to the Apache Software Foundation (ASF) under one
 or more contributor license agreements.  See the NOTICE file
 distributed with this work for additional information
 regarding copyright ownership.  The ASF licenses this file
 to you under the Apache License, Version 2.0 (the
 "License"); you may not use this file except in compliance
 with the License.  You may obtain a copy of the License at
 http://www.apache.org/licenses/LICENSE-2.0
 Unless required by applicable law or agreed to in writing,
 software distributed under the License is distributed on an
 "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 KIND, either express or implied.  See the License for the
 specific language governing permissions and limitations
 under the License.
-->
<section id="ipv6-support">
  <title>IPv6 Support in &PRODUCT;</title>
  <para>&PRODUCT;supports Internet Protocol version 6 (IPv6), the recent version of the Internet
    Protocol (IP) that defines routing the network traffic. IPv6 uses a 128-bit address that
    exponentially expands the current address space that is available to the users. IPv6 addresses
    consist of eight groups of four hexadecimal digits separated by colons, for example,
    5001:0dt8:83a3:1012:1000:8s2e:0870:7454. &PRODUCT; supports IPv6 for public IPs in shared
    networks. With IPv6 support, VMs in shared networks can obtain both IPv4 and IPv6 addresses from
    the DHCP server. You can deploy VMs either in a IPv6 or IPv4 network, or in a dual network
    environment. If IPv6 network is used, the VM generates a link-local IPv6 address by itself, and
    receives a stateful IPv6 address from the DHCPv6 server.</para>
  <para>IPv6 is supported only on KVM and XenServer hypervisors. The IPv6 support is only an
    experimental feature.</para>
  <para>Here's the sequence of events when IPv6 is used: </para>
  <orderedlist>
    <listitem>
      <para>The administrator creates an IPv6 shared network in an advanced zone.</para>
    </listitem>
    <listitem>
      <para>The user deploys a VM in an IPv6 shared network.</para>
    </listitem>
    <listitem>
      <para>The user VM generates an IPv6 link local address by itself, and gets an IPv6 global or
        site local address through DHCPv6.</para>
      <para>For information on API changes, see <xref linkend="changed-apicommands-4.1"/>.</para>
    </listitem>
  </orderedlist>
  <section id="guidelines-ipv6">
    <title>Prerequisites and Guidelines</title>
    <para>Consider the following:</para>
    <itemizedlist>
      <listitem>
        <para>CIDR size must be 64 for IPv6 networks.</para>
      </listitem>
      <listitem>
        <para>The DHCP client of the guest VMs should support generating DUID based on Link-layer
          Address (DUID- LL). DUID-LL derives from the MAC address of guest VMs, and therefore the
          user VM can be identified by using DUID. See <ulink
            url="http://tools.ietf.org/html/rfc3315">Dynamic Host Configuration Protocol for IPv6
          </ulink>for more information.</para>
      </listitem>
      <listitem>
        <para>The gateway of the guest network generates Router Advisement and Response messages to
          Router Solicitation. The M (Managed Address Configuration) flag of Router Advisement
          should enable stateful IP address configuration. Set the M flag to where the end nodes
          receive their IPv6 addresses from the DHCPv6 server as opposed to the router or
          switch.</para>
        <note>
          <para>The M flag is the 1-bit Managed Address Configuration flag for Router Advisement.
            When set, Dynamic Host Configuration Protocol (DHCPv6) is available for address
            configuration in addition to any IPs set by using stateless address
            auto-configuration.</para>
        </note>
      </listitem>
      <listitem>
        <para>Use the System VM template exclusively designed to support IPv6. Download the System
          VM template from <ulink url="http://cloudstack.apt-get.eu/systemvm/"
            >http://cloudstack.apt-get.eu/systemvm/</ulink>.</para>
      </listitem>
      <listitem>
        <para>The concept of Default Network applies to IPv6 networks. However, unlike IPv4
          &PRODUCT; does not control the routing information of IPv6 in shared network; the choice
          of Default Network will not affect the routing in the user VM.</para>
      </listitem>
      <listitem>
        <para>In a multiple shared network, the default route is set by the rack router, rather than
          the DHCP server, which is out of &PRODUCT; control. Therefore, in order for the user VM to
          get only the default route from the default NIC, modify the configuration of the user VM,
          and set non-default NIC's <code>accept_ra</code> to 0 explicitly. The
            <code>accept_ra</code> parameter accepts Router Advertisements and auto-configure
            <code>/proc/sys/net/ipv6/conf/interface</code> with received data.</para>
      </listitem>
    </itemizedlist>
  </section>
  <section id="limitsipv6">
    <title>Limitations of IPv6 in &PRODUCT; </title>
    <para>The following are not yet supported:</para>
    <orderedlist>
      <listitem>
        <para>Security groups</para>
      </listitem>
      <listitem>
        <para>Userdata and metadata</para>
      </listitem>
      <listitem>
        <para>Passwords</para>
      </listitem>
    </orderedlist>
  </section>
  <section id="network-conf-dhcpv6">
    <title>Guest VM Configuration for DHCPv6</title>
    <para>For the guest VMs to get IPv6 address, run dhclient command manually on each of the VMs.
      Use DUID-LL to set up dhclient. </para>
    <note><para>The IPv6 address is lost when a VM is stopped and started. Therefore, use the same procedure
        to get an IPv6 address when a VM is stopped and started.</para></note>
    <orderedlist>
      <listitem>
        <para>Set up dhclient by using DUID-LL.</para>
        <para>Perform the following for DHCP Client 4.2 and above:</para>
        <orderedlist numeration="loweralpha">
          <listitem>
            <para>Run the following command on the selected VM to get the dhcpv6 offer from
              VR:</para>
            <programlisting>dhclient -6 -D LL &lt;dev&gt;</programlisting>
          </listitem>
        </orderedlist>
        <para>Perform the following for DHCP Client 4.1:</para>
        <orderedlist numeration="loweralpha">
          <listitem>
            <para>Open the following to the dhclient configuration file:</para>
            <programlisting>vi /etc/dhcp/dhclient.conf</programlisting>
          </listitem>
          <listitem>
            <para>Add the following to the dhclient configuration file:</para>
            <programlisting>send dhcp6.client-id = concat(00:03:00, hardware);</programlisting>
          </listitem>
        </orderedlist>
      </listitem>
      <listitem>
        <para>Get IPv6 address from DHCP server as part of the system or network restart.</para>
        <para>Based on the operating systems, perform the following:</para>
        <para>On CentOS 6.2:</para>
        <orderedlist numeration="loweralpha">
          <listitem>
            <para>Open the Ethernet interface configuration file:</para>
            <programlisting>vi /etc/sysconfig/network-scripts/ifcfg-eth0</programlisting>
            <para>The <code>ifcfg-eth0</code> file controls the first NIC in a system.</para>
          </listitem>
          <listitem>
            <para>Make the necessary configuration changes, as given below:</para>
            <programlisting>DEVICE=eth0
HWADDR=06:A0:F0:00:00:38
NM_CONTROLLED=no
ONBOOT=yes
BOOTPROTO=dhcp6
TYPE=Ethernet
USERCTL=no
PEERDNS=yes
IPV6INIT=yes
DHCPV6C=yes</programlisting>
          </listitem>
          <listitem>
            <para>Open the following:</para>
            <programlisting>vi /etc/sysconfig/network</programlisting>
          </listitem>
          <listitem>
            <para>Make the necessary configuration changes, as given below:</para>
            <programlisting>NETWORKING=yes
HOSTNAME=centos62mgmt.lab.vmops.com
NETWORKING_IPV6=yes
IPV6_AUTOCONF=no</programlisting>
          </listitem>
        </orderedlist>
        <para>On Ubuntu 12.10</para>
        <orderedlist numeration="loweralpha">
          <listitem>
            <para>Open the following:</para>
            <programlisting>etc/network/interfaces:</programlisting>
          </listitem>
          <listitem>
            <para>Make the necessary configuration changes, as given below:</para>
            <programlisting>iface eth0 inet6 dhcp
autoconf 0
accept_ra 1</programlisting>
          </listitem>
        </orderedlist>
      </listitem>
    </orderedlist>
  </section>
</section>
