<?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="changing-root-password">
	<title>Changing the Root Password</title>
    <para>During installation and ongoing cloud administration, you will need to log in to the UI as the root administrator.
        The root administrator account manages the &PRODUCT; deployment, including physical infrastructure.
        The root administrator can modify configuration settings to change basic functionality, create or delete user accounts, and take many actions that should be performed only by an authorized person.
        When first installing &PRODUCT;, be sure to change the default password to a new, unique value.</para>
    <orderedlist>
        <listitem><para>Open your favorite Web browser and go to this URL. Substitute the IP address of your own Management Server:</para>
            <programlisting>http://&lt;management-server-ip-address&gt;:8080/client</programlisting>
        </listitem>
        <listitem><para>Log in to the UI using the current root user ID and password. The default is admin, password.</para></listitem>
        <listitem><para>Click Accounts.</para></listitem>
        <listitem><para>Click the admin account name.</para></listitem>
        <listitem><para>Click View Users.</para></listitem>
        <listitem><para>Click the admin user name.</para></listitem>
        <listitem>
            <para>Click the Change Password button.
                <inlinemediaobject>
                    <imageobject>
                        <imagedata fileref="./images/change-password.png" />
                    </imageobject>
                    <textobject><phrase>change-password.png: button to change a user's password</phrase></textobject>
                </inlinemediaobject></para>
        </listitem>
        <listitem><para>Type the new password, and click OK.</para></listitem>
    </orderedlist>
</section>
