Are you trying to stand up a large-scale multi-tenant cloud infrastructure without all of the hassles, complexity or cost of other “leading” commercial approaches? SolidFire and Canonical have joined forces to deliver a production-ready deployment of OpenStack Compute (Nova) and OpenStack Block Storage (Cinder). This SSD-based reference architecture provides a comprehensive blueprint for any OpenStack deployer looking to stand up cloud compute and block storage environment with predictable performance, fine-grain quality-of-service and significantly enhanced ease-of-use characteristics.
Attend this session to learn about this reference architecture in more detail, including information on deployment tools, tips and tricks, targeted use cases, benchmark results and key enabling technologies.
Synopsis: There is no easy answer or magic solution for Architecting your private cloud. OpenStack is flexible and can be designed in many ways so architecting your cloud correctly is extremely important. The goal of this talk is to provide guidance on how to start thinking about your private cloud architecture. We will cover the following in this talk:
1. Build with the end in mind
2. To Swift or not to Swift
3. Architecture examples and thoughts for the following environment sizes:
a. 1-20 physical nodes
b. 20-100 physical nodes
4. Performance Considerations and Bottlenecks
4. Lessons Learned
5. Q/A and Community Input
Synopsis: Once your cloud is operational, day to day tasks are minimal however issues do arise. This talk is to designed to give operators ideas on what to monitor, tools available and some example procedures for common tasks.
1. Monitoring and Reporting
2. Tools used by the Rackspace Private Cloud support team
3. Performance and Scale considerations
4. Automated configuration Management
5. Examples of common day to day operational tasks
6. Lessons Learned
7. Q/A and Community Input
Horizon is an excellent general Dashboard for Openstack but it's not a solution that fits for everyone.
At Morphlabs we had specific needs for our Private Cloud solution that didn't quite fit with Horizon. In this presentation I'll cover our decisions for building our own, the tools we've used and discoveries made along the way.
Due to its open nature and rapidly growing user base, OpenStack has become a hotbed and testing ground for disruptive innovations in cloud-computing virtualization, networking, and storage technologies. Rather than modify core OpenStack components directly, these technologies are introduced by extending or enhancing component functionality via the creation of new services and API extensions.
In this talk we will present a real-world case study of one such extension, which allows the "streamed" launching of VMs from a snapshotted "golden image", thus skipping the boot process and providing more rapid transition from the "off" state to the "ready to perform work" state. We will detail the key architectural questions that must be answered in the creation of such an extension, the development challenges that we encountered, and we will walk through the architecture and design of our extension itself. Additionally, we will address some of the business challenges that arise from building commercial software atop an open source project.
Built on the materials from the popular Mirantis OpenStack BootCamp and delivered by the same instructors, this compact workshop will give you all the information you need to understand OpenStack and impress your peers with technical depth. The workshop is aimed at OpenStack newbies and semi-technical that just want to know what the hell is OpenStack all about.
Starting with a brief introduction to the problems OpenStack was designed to solve, we'll dive into vivid illustrations of how various components of OpenStack fit together by visually traversing the
request flow of provisioning a VM in NOVA and storing an object in Swift. Participants will work in groups to complete exercises and checkpoint each others understanding of the material. We'll close the session with a brief gloss over key lessons from real life deployments, HA deployment options and feature comparison with VMware and CloudStack.
Come learn how to deploy OpenStack Swift from the ground-up. This will be a hands-on workshop where we learn by typing rather than just a lecture. Come with a laptop, or watch and learn.
In this workshop you will be walked through deployment and configuration of OpenStack Swift by the Swift experts at SwiftStack. We will guide you through the architecture of Swift while we walk through a step-by-step installation from the ground up.
In this workshop, you'll learn:
- Swift's architecture (The Ring, Zones, Partitions, Accounts & Containers)
- How to bootstrap a basic Swift installation
- The guts of how swift works
- Swift’s failure recovery mechanisms
Bring your laptop (with virtualization extensions enabled in the BIOS)
and we will provide a virtual machine image that will be used in the workshop.
Folsom is out, and a major new feature is the Quantum network
service. In this session, the Quantum experts from Nicira/VMware will
walk you through a hands on deployment of Quantum along with other
core OpenStack components.
We will walk you through a 4 node OpenStack deployment (cloud
controller, network node, and two compute nodes) while demonstrating
the key new use cases that Quantum enables. We will provide
infrastructure using VMs in our very own OpenStack cloud (yes, that's
running Quantum on Quantum!). Alternately, with a bit more effort you
can use your own four Ubuntu 12.04 nodes if you want to keep the setup
running beyond the lab period.
We will also answer people's questions about more advanced scenarios
and provide experience from 6+ months of Quantum production
deployments on Essex.
Are you interested in learning more about the Puppet deployment tools for OpenStack that have been written as a collaborative effort by Cisco, Redhat, Enovance, CERN, Cybera, Morphlabs, Rackspace, and PuppetLabs?
Would you like to better understand how they can be used to deploy a fully functional OpenStack environment?
If, so this talk is a great place to get started.
It will discuss the Puppet deployment tools for OpenStack, with a focus on how users can use them to quickly and reliably build out OpenStack environemnt.
This talk will cover the operations knowledge that you will need to successfully run and operate an OpenStack Swift cluster. This session is for operators who want tactical advice on the operational tasks needed to run a Swift cluster.
In this workshop we will:
- Walk through the procedure of handling a drive failure
- Adding additional capacity to a Swift cluster
- Running benchmarks to simulate workloads
- Tuning a Swift cluster
- Using transaction IDs in the logs to find an error
- Monitoring Swift-specific metrics and what they mean such as async pending, quarantined objects and replication statistics.
Come prepared with an already running Swift cluster, or watch and learn. The all-in-one cluster created in the “Deploying OpenStack Swift” workshop is fine for this purpose.
OK, so now you have a Swift cluster set up. What are you going to do with it? Sure, you could throw some backups in there and call it a day. But Swift is capable of so much more when it can integrate more deeply with your app or infrastructure.
In this workshop, you'll use Swift to assemble Swinterest, a fully-featured web application that (if precedent is to be believed) is bound to garner you fame and fortune. Along the way, we'll discuss:
juju Charm School is an event where a juju expert is available to answer questions about writing your own juju charms. The intended audience are people who deploy software and want to contribute charms to the wider devops community to make deploying in the public and private cloud easy.
There has been much progress since last ODS, we are now able to export environments from public clouds and import them directly into OpenStack clouds; we will be showing how we use juju to move deployments from cloud to cloud.
Attendees are more than welcome to:
With object storage services becoming increasingly accepted as replacement for traditional file or block systems, it is important to effectively measure the performance of these systems. Thus people can compare different solutions or tune their systems for better performance. In this session, we present COSBench (Cloud Object Storage Benchmark), a benchmark tool that we are currently working on in Intel for cloud object storage systems. In addition, as a case study, we will demonstrate how we use COSBench to evaluate/analyze OpenStack* Swift performance and conduct optimizations.
jclouds is the leading Java cross-cloud toolkit for the OpenStack API and already has a broad adoption base. In this workshop, you will learn how to write code that can control any cloud with jclouds.
Developers tend towards cross-platform solutions. Many popular languages and toolkits can run on many operating systems and devices. HTML and the web browser are the prime example of this trend. The benefits are clear, it gives developers the most bang for their buck when it comes to learning new skills and reaching the widest audience.
The cloud has emerged as the next major platform. So where do developers turn for cross-cloud toolkits?
For Java, the answer is jclouds. jclouds is an open source cross-cloud toolkit that works with both public and private clouds, enabling hybrid cloud workloads. The list of supported clouds includes AWS, Azure, vCloud, HP Cloud, OpenStack, and the Rackspace Open Cloud. There is a great community behind this toolkit working together to provide a better experience for developers in the cloud. Their goal is to simplify the control of many different clouds while still giving you the freedom to use cloud-specific features. The result is a toolkit that allows developers to write better code, in a shorter period of time, that works with any cloud.
In this session, I will demostrate these qualities of jclouds. If you're so inclined, you'll be able to follow along with the demostration and write your own code that works with any cloud (hotel wifi permitting ;)
Prerequisites if you choose to follow along:
Cloud accounts such as:
OpenStack Swift is a versatile platform to build highly scalable and highly available storage clouds. However, deploying a Swift based storage cloud for high performance while keeping low cost (both upfront and ongoing) is a challenging task. First task for the cloud builders is to identify the characteristics of the workload that they are optimizing, i.e. the distribution of the object sizes and ratios between the read, write and delete operations. Next, for their specific workload characteristics, the cloud builders need to consider several important questions with overlapping implications:
(1) How to provision the hardware resources (e.g. CPU, memory, I/O devices) for the storage server and proxy server in a cost-effective way. (2) What is the best ratio between the number of storage servers and the number of proxy servers in a Swift storage cloud? (3) Should I use more expensive but faster I/O devices for certain Swift services (e.g. container)? (4) Based on certain hardware provisioning, what software-level tunings and optimizations (e.g. Swift configuration files, Filesystem, and OS settings) are recommended for optimal performance?
Besides considering above questions, the cloud builders also want to know how their Swift storage cloud performs in various degraded modes, i.e. when failures happen (e.g. one of the storage servers is down). Their SLA requirements may mandate a minimum performance even in face of some failures.
Based on our hands-on experience with several Swift implementations and hundreds of benchmark runs in our labs, we would like to share our methods on how to provision a Swift cloud storage on both hardware and software sides with the expected performance, while keeping low upfront cost. In addition, we would also talk about how to precisely benchmark a Swift storage cloud by simulating different workloads and failure scenarios. We will share both quantitative results and derived best practices.
OpenStack with its de-facto standard cloud fabric API and scheduling of elemental resources is an ideal platform for delivering advanced provisioning functionality using a template-based approach which simplifies and automates the job of infrastructure provisioning. Furthermore, OpenStack’s standard API layer sets the stage for users with various cloud products that would benefit from hybrid provisioning across private and public clouds.
HP, which has already invested heavily in OpenStack as the underlying platform for our public cloud offering has also been investing in OpenStack as a platform for private cloud offerings as well. As part of that investment HP Software has created an advanced provisioning technology, called Eve, which uses TOSCA standard semantics to express infrastructure templates that can be orchestrated against an OpenStack Nova API. As part of the Eve advanced provisioning service, hybrid provisioning can be accomplished with common templates across public and private OpenStack API compliant clouds.
This session will illustrate how core OpenStack services were used as a foundation for new services that bring composite and hybrid provisioning to OpenStack. Additionally, the session will outline how the new services are architected with the same principles around scalability and flexible deployment that OpenStack services themselves are created.
