<?xml version='1.0' encoding='utf-8' ?>
<!DOCTYPE chapter 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="install-management-server-multi-nodes">
  <title>Prepare and Start Additional Management Servers</title>
  <para>For your second and subsequent Management Servers, you will install the Management Server
    software, connect it to the database, and set up the OS for the Management Server. </para>
  <orderedlist>
    <listitem>
      <para> Perform the steps in <xref linkend="prepare-os"/> and <xref
linkend="sect-source-buildrpm"/> or <xref linkend="sect-source-builddebs"/> as
        appropriate. </para>
    </listitem>
    <listitem>
      <para>This step is required only for installations where XenServer is installed on the hypervisor hosts.</para>
      <para>Download vhd-util from <ulink
          url="http://download.cloud.com.s3.amazonaws.com/tools/vhd-util">vhd-util</ulink></para>
      <para>If the Management Server is RHEL or CentOS, copy vhd-util to
        /usr/lib64/cloud/common/scripts/vm/hypervisor/xenserver.</para>
      <para>If the Management Server is Ubuntu, copy vhd-util to
        /usr/lib/cloud/common/scripts/vm/hypervisor/xenserver/vhd-util.</para>
    </listitem>
    <listitem>
      <para> Ensure that necessary services are started and set to start on boot.
        <programlisting><prompt>#</prompt> service rpcbind start
<prompt>#</prompt> service nfs start
<prompt>#</prompt> chkconfig nfs on
<prompt>#</prompt> chkconfig rpcbind on
</programlisting>
      </para>
    </listitem>
    <listitem>
      <para>Configure the database client. Note the absence of the --deploy-as argument in this
        case. (For more details about the arguments to this command, see <xref
          linkend="management-server-install-db-external"/>.) </para>
      <programlisting><prompt>#</prompt> cloud-setup-databases cloud:<replaceable>dbpassword</replaceable>@<replaceable>dbhost</replaceable> -e <replaceable>encryption_type</replaceable> -m <replaceable>management_server_key</replaceable> -k <replaceable>database_key</replaceable> -i <replaceable>management_server_ip</replaceable>
      </programlisting>
    </listitem>
    <listitem>
      <para>Configure the OS and start the Management Server:</para>
      <programlisting><prompt>#</prompt> cloud-setup-management</programlisting>
      <para>The Management Server on this node should now be running.</para>
    </listitem>
    <listitem>
      <para>Repeat these steps on each additional Management Server. </para>
    </listitem>
    <listitem>
      <para>Be sure to configure a load balancer for the Management Servers. See <xref linkend="management-server-lb"/>.</para>
    </listitem>
  </orderedlist>
</section>
