<?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.
-->

<chapter id="user-services-overview">
    <title>User Services Overview</title>
  <para>In addition to the physical and logical infrastructure of your cloud
    and the &PRODUCT; software and servers, you also need a layer of user
    services so that people can actually make use of the cloud. This means
    not just a user UI, but a set of options and resources that users can
    choose from, such as templates for creating virtual machines, disk
    storage, and more. If you are running a commercial service, you will be
    keeping track of what services and resources users are consuming and
    charging them for that usage. Even if you do not charge anything for
    people to use your cloud – say, if the users are strictly internal to your
    organization, or just friends who are sharing your cloud – you can still
    keep track of what services they use and how much of them.
  </para>
  <section id="offerings-and-templates">
    <title>Service Offerings, Disk Offerings, Network Offerings, and Templates</title>
    <para>A user creating a new instance can make a variety of choices about
      its characteristics and capabilities. &PRODUCT; provides several ways to
      present users with choices when creating a new instance:
    </para>
    <itemizedlist>
      <listitem><para>Service Offerings, defined by the &PRODUCT; administrator,
        provide a choice of CPU speed, number of CPUs, RAM size, tags on the
        root disk, and other choices. See Creating a New Compute Offering.</para>
      </listitem>
      <listitem><para>Disk Offerings, defined by the &PRODUCT; administrator,
        provide a choice of disk size and IOPS (Quality of Service) for primary
        data storage. See Creating a New Disk Offering.</para>
      </listitem>
      <listitem><para>Network Offerings, defined by the &PRODUCT; administrator,
        describe the feature set that is available to end users from the virtual
        router or external networking devices on a given guest network. See
        Network Offerings.</para>
      </listitem>
      <listitem><para>Templates, defined by the &PRODUCT; administrator or by
        any &PRODUCT; user, are the base OS images that the user can choose
        from when creating a new instance. For example, &PRODUCT; includes
        CentOS as a template. See Working with Templates.</para>
      </listitem>
    </itemizedlist>
    <para>In addition to these choices that are provided for users, there is
      another type of service offering which is available only to the &PRODUCT;
      root administrator, and is used for configuring virtual infrastructure
      resources. For more information, see Upgrading a Virtual Router with
      System Service Offerings.
    </para>
  </section>
</chapter>
