anchor.diff:  =======
     8. Attach priorities to SLAs
   
  +<<<<<<< HEAD
   >>>>>>> a0f5794... PERI-2 apiary changes
  +=======
  +_Note: not all of the features above are supported in the first `public beta` version. There are dependencies we contributed to Hadoop, Ambari and YARN and they will be included in the next releases (1.7 and 2.6)_
  +
  +>>>>>>> 046962f... PERI-2 typos fixed
   
   #Group Clusters
   <<<<<<< HEAD
  
positive.code: This means that the hardware resources are already given - and the throughput can't be increased by adding new nodes.
  Periscope introspects the job submission process, monitors the applications and applies the following SLAs:
  
    1. Application ordering - can guaranty that a higher priority application finishes before another one (supporting parallel or sequential execution)
    2. Moves running applications between priority queues
    3. *Attempts* to enforce time based SLA (execution time, finish by, finish between, recurring)
    4. *Attempts* to enforce guaranteed cluster capacity requests ( x % of the resources)
    5. Support for distributed (but not YARN ready) applications using Apache Slider
    6. Attach priorities to SLAs
  
  ### Autoscaling clusters
  From Periscope point of view we consider a cluster `dynamic` when the cluster capacity can be increased horizontally.
  This means that nodes can be added or removed dynamically - thus the throughput can be increased or decreased based on the cluster load, and scheduled applications.
  In order to do that Periscope instructs [Cloudbreak](http://sequenceiq.com/cloudbreak/) to add or remove nodes from the cluster based on the SLAs and thus continuously provide a high *quality of service* for the multi-tenand Hadoop cluster.
  Just to refresh memories - [Cloudbreak](http://sequenceiq.com/products.html) is [SequenceIQ's](http://sequenceiq.com) open source, cloud agnostic Hadoop as a Service API.
  Given the option of provisioning or decommissioning cluster nodes on the fly, Periscope allows you to use the following set of SLAs:
  
    1. Application ordering - can guaranty that a higher priority application finishes before another one (supporting parallel or sequential execution)
    2. Moves running applications between priority queues
    3. *Enforce* time based SLA (execution time, finish by, finish between, recurring) by increasing cluster capacity and throughput
    4. Smart decommissioning - avoids HDFS storms, keeps `payed` nodes alive till the last minute
    5. *Enforce* guaranteed cluster capacity requests ( x % of the resources)
    6. *Private* cluster requests - supports provisioning of short lived private clusters with the possibility to merge
    7. Support for distributed (but not YARN ready) applications using Apache Slider
  <<<<<<< HEAD
  <<<<<<< HEAD
  
negative.code: *Periscope brings QoS and autoscaling to Hadoop YARN. Built on cloud resource management and YARN schedulers, allows to associate SLA policies to applications.*
  
  >>>>>>> 2a07954... PERI-2 minor fix
  =======
  *Periscope brings QoS and autoscaling to Hadoop YARN. Built on cloud resource management and YARN schedulers,it allows to associate SLA policies to applications.*
  >>>>>>> 046962f... PERI-2 typos fixed
  
  ##Overview
  
  The purpose of Periscope is to bring QoS and autoscaling to a multi-tenant Hadoop YARN cluster, while allowing to apply SLA policies to individual applications.
  At [SequenceIQ](http://sequenceiq.com) working with multi-tenant Hadoop clusters for quite a while, we have always seen the same frustration and fight for resource between users.
  The **FairScheduler** was partially solving this problem - bringing in fairness based on the notion of [Dominant Resource Fairness](http://static.usenix.org/event/nsdi11/tech/full_papers/Ghodsi.pdf).
  With the emergence of Hadoop 2 YARN and the **CapacityScheduler** we had the option to maximize throughput and utilization for a multi-tenant cluster in an operator-friendly manner.
  The scheduler works around the concept of queues. These queues are typically setup by administrators to reflect the economics of the shared cluster.
  While this is a pretty good abstraction and brings some level of SLA for predictable workloads, it often needs proper design ahead.
  The queue hierarchy and resource allocation needs to be changed when new tenants and workloads are moved to the cluster.
  
  Periscope was designed around the idea of `autoscaling` clusters - without any need to preconfigure queues, cluster nodes or apply capacity planning ahead.
  
  ##How it works
  
  Periscope monitors the application progress, the number of YARN containers/resources and their allocation, queue depths, the number of available cluster nodes and their health. 
  Since we have switched to YARN a while ago (been among the first adopters) we have run an open source [monitoring project](https://github.com/sequenceiq/yarn-monitoring), based on R.
  We have been collecting metrics from the YARN Timeline server, Hadoop Metrics2 and Ambari's Nagios/Ganglia - and profiling the applications and correlating with these metrics.
  One of the key findings was that while low level metrics are good to understand the cluster health - they might not necessarily help on making decisions when applying different SLA policies on a multi-tenant cluster. 
  Focusing on higher level building blocks as queue depth, YARN containers, etc actually brings in the same quality of service, while not being lost in low level details.
  
  Periscope works with two types of Hadoop clusters: `static` and `dynamic`. Periscope does not require any pre-installation - the only thing it requires is to be `attached` to an Ambari server's REST API.
  
  