Why Red Hat’s OpenShift, not OpenStack, is making waves with developers

Red Hat has historically whiffed with developers. But, its PaaS offering, OpenShift, may mark a new era for the open source giant.

Developers may be the new kingmakers in the enterprise, to borrow Redmonk’s phrase, but they’ve long ignored the enterprise open source leader, Red Hat. Two years ago, I called out Red Hat’s apparent inability to engage the very audience that would ensure its long-term relevance. Now, there are signs that Red Hat got the message.

And, no, I’m not talking about OpenStack. Though Red Hat keeps selling OpenStack (seven of its top-30 deals last quarter included OpenStack, according to Red Hat CEO Jim Whitehurst), it’s really OpenShift, the company’s Platform-as-a-Service (PaaS) offering, that promises a bright, developer-friendly future for Red Hat.

redhatLooking beyond OpenStack

Red Hat continues to push OpenStack, and rightly so—it’s a way for Red Hat to certify a cloud platform just as it once banked on certifying the Linux platform. There’s money in assuring risk-averse CIOs that it’s safe to go into the OpenStack cloud environment.

Even so, as Whitehurst told investors in June, OpenStack is not yet “material” to the company’s overall revenue, and generally generates deals under $100,000. It will continue to grow, but OpenStack adoption is primarily about telcos today, and that’s unlikely to change as enterprises grow increasingly comfortable with public IaaS and PaaS options. OpenStack feels like a way to help enterprises avoid the public cloud and try to dress up their data centers in the fancy “private cloud” lingo.

OpenShift, by contrast, is far more interesting.

OpenShift, after all, opens Red Hat up to containers and all they mean for enterprise developer productivity. It’s also a way to pull through other Red Hat software like JBoss and Red Hat Enterprise Linux, because Red Hat’s PaaS is built on these products. OpenShift has found particular traction among sophisticated financial services companies that want to get in early on containers, but the list of customers includes a wide range of companies like Swiss Rail, BBVA, and many others.

More and faster

To be clear, Red Hat still has work to do. According to Gartner’s most recent Magic Quadrant for PaaS, Salesforce and Microsoft are still a ways ahead, particularly in their ability to execute their vision:

mqdrnt.jpg

Still, there are reasons to think Red Hat will separate itself from the PaaS pack. For one thing, the company is putting its code where it hopes its revenue will be. Red Hat learned long ago that, to monetize Linux effectively, it needed to contribute heavily. In similar fashion, only Google surpasses Red Hat in Kubernetes code contributions, and Docker Inc. is the only company to contribute more code to the Docker container project.

Why does this matter? If you’re an enterprise that wants a container platform then you’re going to trust those vendors that best understand the underlying code and have the ability to influence its direction. That’s Red Hat.

Indeed, one of the things that counted against Red Hat in Gartner’s Magic Quadrant ranking was its focus on Kubernetes and Docker (“Docker and Kubernetes have tremendous potential, but these technologies are still young and evolving,” the report said). These may be young and relatively immature technologies, but all signs point to them dominating a container-crazy enterprise world for many years to come. Kubernetes, as I’ve written, is winning the container management war, putting Red Hat in pole position to benefit from that adoption, especially as it blends familiar tools like JBoss with exciting-but-unfamiliar technologies like Docker.

Red Hat has also been lowering the bar for getting started and productive with OpenShift, as Serdar Yegulalp described. By focusing on developer darlings like Docker and Kubernetes, and making them easily consumable by developers and more easily run by operations, Red Hat is positioning itself to finally be relevant to developers…and in a big way.

OpenStack’s latest release focuses on scalability and resilience

OpenStack, the massive open source project that helps enterprises run the equivalent of AWS in their own data centers, is launching the 14th major version of its software today. Newton, as this new version is called, shows how OpenStack has matured over the last few years. The focus this time is on making some of the core OpenStack services more scalable and resilient. In addition, though, the update also includes a couple of major new features. The project now better supports containers and bare metal servers, for example.

In total, more than 2,500 developers and users contributed to Newton. That gives you a pretty good sense of the scale of this project, which includes support for core data center services like compute, storage and networking, but also a wide range of smaller projects.

As OpenStack Foundation COO Mark Collier told me, the focus with Newton wasn’t so much on new features but on adding tools for supporting new kinds of workloads.

Both Collier and OpenStack Foundation executive director Jonathan Bryce stressed that OpenStack is mostly about providing the infrastructure that people need to run their workloads. The project itself is somewhat agnostic as to what workloads they want to run and which tools they want to use, though. “People aren’t looking at the cloud as synonymous with [virtual machines] anymore,” Collier said. Instead, they are mixing in bare metal and containers as well. OpenStack wants to give these users a single control plane to manage all of this.

Enterprises do tend to move slowly, though, and even the early adopters that use OpenStack are only now starting to adopt containers. “We see people who are early adopters who are running container in production,” Bryce told me. “But I think OpenStack or not OpenStack, it’s still early for containers in production usage.” He did note, however, that he is regularly talks to enterprise users who are looking at how they can use the different components in OpenStack to get to containers faster. 
networktopology

Core features of OpenStack, including the Nova compute service, as well as the Horizon dashboard and Swift object/blob store, have now become more scalable. The Magnum project for managing containers on OpenStack, which already supported Docker Swarm, Kubernetes and Mesos, now also allows operators to run Kubernetes clusters on bare metal servers, while the Ironic framework for provisioning those bare metal servers is now more tightly integrated with Magnuma and also now supports multi-tenant networking.

The release also includes plenty of other updates and tweaks, of course. You can find a full (and fully overwhelming) rundown of what’s new in all of the different projects here.

With this release out of the door, the OpenStack community is now looking ahead to the next release six months form now. This next release will go through its planning stages at the upcoming OpenStack Summit in Barcelona later this month and will then become generally available next February.

Building a Highly Available OpenStack Cloud

I Building a Highly Available OpenStack Cloud Computing some details in my previous post, about RPC-R’s reference architecture. Here, I want to drill down even more into how we worked with Red Hat to build high availability into the control plane of the RPC-R solution.

As we know, component failures will happen in a cloud environment, particularly as that cloud grows in scale. However, users still expect their OpenStack services and APIs will be always on and always available, even when servers fail. This is particularly important in a public cloud or in a private cloud where resources are being shared by multiple teams.

The starting point for architecting a highly available OpenStack cloud is the control plane. While a control plane outage would not disrupt running workloads, it would prevent users from being able to scale out or scale in in response to business demands. Accordingly, a great deal effort went into maintaining service uptime as we architected RPC-R, particularly the Red Hat OpenStack platform which is the OpenStack distribution at the core of RPC-R.

Red Hat uses a key set of open source technologies to create clustered active-active controller nodes for all Red Hat OpenStack Platform clouds. Rackspace augments that reference architecture with hardware, software and operational expertise to create RPC-R with our 99.99% API uptime guarantee. The key technologies for creating our clustered controller nodes are:

  • Pacemaker – A cluster resource manager used to manage and monitor the availability of OpenStack components across all nodes in the controller nodes cluster
  • HAProxy – Provides load balancing and proxy services to the cluster (Note that while HAProxy is the default for Red Hat OpenStack Platform, RPC-R uses F5 hardware load balancers instead)
  • Galera – Replicates the Red Hat OpenStack Platform database across the cluster

control-plane

Putting it all together, you can see in the diagram above that redundant instances of each OpenStack component run on each controller node in a collapsed cluster configuration managed by Pacemaker. As the cluster manager, Pacemaker monitors the state of the cluster and has responsibility for failover and failback of services in the event of hardware and software failures. This includes coordinating restart of services to ensure that startup is sequenced in the right order and takes into account service dependencies.

A three node cluster is the minimal size in our RPC-R reference architecture to ensure a quorum in the event of a node failure. A quorum defines the minimal number of nodes that must function for the cluster itself to remain functional. Since a quorum is defined as half the nodes + 1, three nodes is the smallest feasible cluster you can have. Having at least three nodes also allows Pacemaker to compare the content of each node in the cluster and in the event that inconsistencies are found, a majority rule algorithm can be applied to determine what should be the correct state of each node.

While Pacemaker is used to manage most of the OpenStack services, RPC-R uses the Galera multi-master database cluster manager to replicate and synchronize the MariaDB based OpenStack database running on each controller node. MariaDB is a community fork of MySQL that is used in a number of OpenStack distributions, including Red Hat OpenStack platform.

database read write

Using Galera, we are able to create an active-active OpenStack database cluster and do so without the need for shared storage. Reads and writes can be directed to any of the controller nodes and Galera will synchronize all database instances. In the event of a node failure, Galeria will handle failover and failback of database nodes.

By default, Red Hat OpenStack Platform uses HAProxy to load balance API requests to OpenStack services running in the control plane. In this configuration, each controller node runs an instance of HAProxy and each set of services has its own virtual IP. HAProxy is also clustered together using Pacemaker to provide fault tolerance for the API endpoints.

pacemaker

As mentioned previously, Rackspace has chosen to use redundant hardware load balancers in place of HAProxy. Per the previous diagram, the Red Hat OpenStack Platform architecture is identical to RPC-R with the exception that we use F5 appliances in place of clustered HAProxy instances. We believe this option provides better performance and manageability for RPC-R customers.

external-network

An enterprise grade Private Cloud is achievable but requires a combination of the right software, a well thought-out architecture and operational expertise. We believe that Rackspace and Red Hat collaborating together is the best choice for customers looking for partners to help them build out such a solution.

OpenStack users: Backup your Cinder volumes to Google Cloud Storage

OpenStack Mitaka has just launched and we’re super excited about it. In collaboration with Red Hat and Biarca, we’ve developed an OpenStack Cinder backup driver for Google Cloud Storage, available in the Mitaka release.

Google joined the OpenStack Foundation in July 2015, when we announced Kubernetes integration with OpenStack. Our work on Mitaka is the next step on our roadmap to making Google Cloud Platform a seamless public cloud complement for OpenStack environments. Backup and recovery services represent one of the most costly and complex aspects of large scale infrastructure management. OpenStack provides an efficient mechanism for allocation and management of persistent block storage through Cinder. In an OpenStack deployment, Cinder volumes house virtual machine data at rest as well as, potentially, the operating system boot device. In production deployments, it’s critical that this persistent data is protected as part of a comprehensive business continuity and disaster recovery strategy. To satisfy this requirement, Cinder provides a backup service that includes a backup driver specification allowing storage vendors to add support for additional backup targets. This is where we come in. The addition of highly durable and available cloud-scale object storage allows organizations to shift from bulk commodity storage for backup to a more operationally efficient and cost-effective architecture, all while avoiding additional capital expenditures and the complexity of managing storage device scale out. The traditional barrier to adoption for object storage is the engineering effort required to adapt existing software and systems, designed for either file or block storage access, to object store native REST interfaces. The Cinder backup driver model provides the potential to abstract this engineering complexity for OpenStack users. As long as an appropriate backup driver is installed, the backup target works with Cinder as intended. Our Openstack Cinder backup driver is included as part of the standard Cinder backup driver set in Mitaka and requires minimal setup to get up and running. Full Cinder backup functionality was successfully tested with the Cloud Storage driver against 1GB, 5GB and 10GB Cinder volume sizes. In addition, the driver provides the following user configurable parameters to allow administrators to tune the installation:

Parameter Purpose
backup_gcs_credential_file Denotes the full path of the json file of the Google service account (downloaded from the Google Developer Console in step 3)
backup_gcs_bucket GCS bucket name to use for backup. Please refer to the official bucket naming guidelines.
backup_gcs_driver Used for selecting the Google backup driver
backup_gcs_project_id Denotes the project ID where the backup bucket will be created
backup_gcs_object_size The size in bytes of GCS backup objects. default: 52428800 bytes
backup_gcs_block_size The change tracking size for incremental backup, in bytes. backup_gcs_object_size has to be a multiple of backup_gcs_block_size default: 327678 bytes
backup_gcs_user_agent http user-agent string for the gcs API
backup_gcs_reader_chunk_size Chunk size for GCS object downloads in bytes. default: 2097152 bytes
backup_gcs_writer_chunk_size Chunk size for GCS object uploads in bytes. Pass in a value of -1 to cause the file to be uploaded as a single chunk. default: 2097152 bytes
backup_gcs_num_retries/td> Number of times to retry transfers. default: 3
backup_gcs_bucket_location Location of GCS bucket. default: ‘US’
backup_gcs_storage_class Storage class of GCS bucket. default: ‘NEARLINE’
backup_gcs_retry_error_codes List of GCS error codes for which to initiate a retry. default: [‘429’]
backup_gcs_enable_progress_timer Enable or Disable the timer to send the periodic progress notifications to Ceilometer when backing up the volume to the GCS backend storage. The default value is True to enable the timer. default: True

The Cinder backup driver works with any class of Cloud Storage, including our Google Cloud Storage Nearline archival option. Nearline provides the full durability of Standard storage, at a slightly lower level of availability and with a slightly higher latency and offers read performance of 4MB/TB stored, scaling with storage density. As an example, 3TB of backup data can be restored at 12MB/s. The low cost yet high performance of Nearline makes backing up Cinder volumes economical while offering the ability to quickly restore if necessary. If you’re running OpenStack, there’s no need to invest in additional storage systems or build out a second datacenter for backup and recovery. You can now use Cloud Storage in a hybrid scenario, optimized via the Cinder backup driver now available in Mitaka.

What is OpenStack.

MNC’s define OpenStack as the future of Cloud Computing. OpenStack is a platform to create and handle massive groups of virtual machines through a Graphical User Interface.
Openstack is free, open-source software and works similar to Linux.
openstack
Key components of OpenStack?
• Horizon: This is the GUI of openstack.

• Nova: Primary computing engine to manage multiple virtual machines and computing tasks

• Swift: This is a very robust service used for the object storage management.
• Cinder: Like our traditional computer storage system, it is a block storage system in OpenStack.
• Neutron: Used for the networking services in openstack
• Keystone: Identity Management service which uses tokens.
• Glance: image service provider. Images are the virtual copies of hard disks.
• Ceilometer: Provides telemetry services to cloud users.
• Heat (Orchestration Engine): It helps developers to illustrate automated infrastructure deployment

 

Capitulation? Mirantis refactors OpenStack on top of Kubernetes

First, the guts of the announcement: Mirantis, the bad boys of the OpenStack world, are today announcing a collaboration with Google (a company that has pretty much zero history with OpenStack) and Intel. Under the intent of the collaboration, the life cycle management tool for OpenStack, Fuel, will be rewritten so that it uses Kubernetes as its underlying orchestration.

Lots of inside baseball there, so what are all these different products?

  • OpenStack is the open source cloud computing operating system that was jointly created by Rackspace and NASA and has since built a massive following of companies (including IBM, HPE, Intel and many, many others).
  • Kubernetes is the open source orchestration platform loosely descended from the tools that Google uses internally to operate its own data centers.
  • Fuel, as stated previously, was (is) the OpenStack-native life cycle management tool for OpenStack.

So what does it all mean? Well, it’s actually far more important than first appearances would suggest. It marks, at least to some extent, an admission by all concerned that OpenStack isn’t the be-all and end-all of the infrastructure world

That positioning, which might seem blindingly obvious to anyone who is aware of the heterogeneity of modern enterprise IT, somewhat goes against what we heard from the OpenStack camp for its first few years, when pundits would be excused for thinking that OpenStack was the solution for every possible situation. It seems now, however, that OpenStack is simply a part of the solution — and virtual machines, containers and bare-metal systems all have a part to play in enterprise IT going forward.

Under the terms of the collaboration, Mirantis will initiate a new continuous integration/continuous delivery (CI/CD) pipeline under the OpenStack Fuel project for building capabilities around containerized OpenStack deployment and operations. The resulting software will give users fine-grain control over the placement of services used for the OpenStack control plane, as well as the ability to do rolling updates of OpenStack, make the OpenStack control plane self-healing and more resilient, and smooth the path for the creating of microservices-based applications on OpenStack.

If that sounds familiar, that would be because it is much the same proposition that we heard from Alex Polvi of CoreOS fame a few months ago — the difference here is that it comes from an OpenStack player that is front-and-center of the movement, an arguably far more substantive statement.

And some big names have poured the love into this collaboration — in particular Mirantis and Google, originators of Kubernetes.

“With the emergence of Docker as the standard container image format and Kubernetes as the standard for container orchestration, we are finally seeing continuity in how people approach operations of distributed applications,” said Mirantis CMO Boris Renski. “Combining Kubernetes and Fuel will open OpenStack up to a new delivery model that allows faster consumption of updates, helping customers get to outcomes faster.”

Google Senior Product Manager Craig McLuckie also chimed in. “Leveraging Kubernetes in Fuel will turn OpenStack into a true microservice application, bridging the gap between legacy infrastructure software and the next generation of application development,” he said. “Many enterprises will benefit from using containers and sophisticated cluster management as the foundation for resilient, highly scalable infrastructure.”

Along with the initial work on the Fuel aspects, Mirantis will also become an active contributor to the Kubernetes project, and has stated the ambition to become a top contributor to the project over the next year.

Alongside that, Mirantis has joined the Cloud Native Computing Foundation, a Linux Foundation project dedicated to advancing the development of cloud-native applications and services, as a Silver member.

MyPOV

This is a big deal, there’s no denying that. OpenStack is slowly but inexorably becoming less of a “solution for everything” and more of an integral part. Skeptics would suggest that this marks a turning point where OpenStack ceases to be a compelling long-term proposition in and of itself and becomes simply a stop-gap measure between traditional architectures and more cloud-native approaches.

The reality is probably somewhere in the middle — and OpenStack will still have a part to play in infrastructure going forward — but clearly Mirantis’ move to embrace Kubernetes is an indication that it realizes that it needs to extend beyond a pure-play OpenStack offering.

As always, this space provides huge interest and much entertainment — a situation that looks unlikely to change anytime soon

Getting started with basics of building your own cloud

Openstack Cloud tutorial

My daily routine involves too much of AWS Cloud infrastructure. And let me tell you AWS now has grown to an extent that it has now become the synonym of Cloud. I mean they have grown without leap and bounds in the past few years and believe me many other major players are not even near them in the cloud arena (Yeah of course Google and Microsoft does have their own cloud solutions which are pretty brilliant for all use cases, but nobody has the user/customer base that aws has in their public cloud architecture).

Nothing can match the flexibility, elasticity, and ease of use that cloud provides.  Because I remember when I use to work with physical hardware machines (I had to literally wait for hours to get one ready up and running for an emergency requirement. Then if I need additional storage for that machine again wait some more time.) . And if you are using the cloud, then you can spin up a few cloud servers in seconds (believe me in seconds) and test whatever you want.

What is OpenStack Cloud?

An year ago I happen to read an article from netcraft regarding their findings on AWS. According to them in 2013 itself AWS has crossed the mark of 158K in the total number of public facing computers.

Now imagine if you get the same features that AWS cloud provides with something open source that you can build in your own data centre. Isn’t that amazing? Well that’s the reason why tech giants like IBM, HP, Intel, Red Hat, CISCO, Juniper, Yahoo, Dell, Netapp, Vmware, Godaddy, Paypal, Canonical(Ubuntu) support and fund such a project.

This open source project is called as Open Stack, and is currently supported by more than 150 tech companies worldwide. It all started as a combined project by NASA and Rackspace in 2009 (well both were independently developing their own individual projects, which at a later point got together and later called as OpenStack). Well NASA was behind a project called as NOVA(which is very analogous to amazon ec2 and provided computing feature), and Rackspace built another tool called as Swift(a highly scalable object storage solution, very similar to AWS S3).

Apart from these, there are other components that help make openstack very much same as aws cloud(we will be discussing each of them shortly, and in upcoming tutorials, we will configure each of them to build our own cloud).

Openstack can be used by anybody who wants their own cloud infrastructure, similar to AWS. Although its origin will trace back to NASA, its not actively developed/supported by NASA any more.

And they are currently leveraging aws public cloud infrastructure J

If you want to simply use openstack public cloud, then you can use Rackspace Cloud, ENovance, HP cloud etc(these are very much similar to aws cloud.) with their cost associated. Apart from these public openstack cloud offerings, there are plug and play cloud services, where you have dedicated hardware appliance for openstack. Just purchasing it and plugging it would turn it into an openstack cloud service without any further configurations.

Let’s now discuss some of the crucial components of OpenStack, which when combined together will make a robust cloud like any other commercial cloud (Like AWS), that too in your datacenter, completely managed and controlled by your team.

When you talk about cloud, the first thing that comes to your mind will be virtualization. Because virtualization is the technology that caused this cloud revolution possible. Virtualization basically is nothing but the method of slicing resources of a physical machine to smaller/required parts, and those slices will act as independent hosts sharing resources with other slices on the machine.  This enables optimal use of computing resources.

  • OpenStack Compute:  So one of the main component of cloud is virtual machines, that can scale without bounds. This need of the cloud in openstack is fulfilled by something called as Nova. Nova is the name of the software component in OpenStack cloud, that offers and manages virtual machines.

Apart from the compute requirements, the second major requirement is storage. There are two different types of storage in the cloud, one is block storage(very similar to the way how you use RAID partition on any of your servers and format it and use it for all kind of local storage needs), or  normal disk storage, where your operating system files are installed etc.

  • OpenStack block storage (Cynder): will work similar to attaching and detaching an external hard drive to your operating system, for its local use. Block storage is useful for database storage, or raw storage for the server(like format it, mount it and use it), or else you can combine several for distributed file system needs (like you can make a large gluster volume, out of several block storage devices attached to a virtual machine launched by Nova).

The second type of storage full fills the scaling needs, without bounds. You need a storage that can scale without worry. Where your storage need is of static objects. This can be used for storing static large data like backups, archives etc. It can be accessed with its own API, and is replicated cross datacenter, to withstand large disasters.

  • OpenStack Object storage(Swift): is suitable for storing multimedia content like videos, images, virtual machine images, backups, email storage, archives etc. This type of data needs to grow without any limitation, and needs to be replicated. This is exactly what OpenStack swift is designed to do.

Last but not the least, comes Networking. Networking in the cloud has become so matured that you can create your own private networks, access control lists, create routes between them, interconnect different networks, connect to remote network using VPN etc. Almost all of these needs of an enterprise cloud is taken care by openstack networking.

  • Openstack Networking(Nova-networking, or Neutron): When I say openstack networking, think of it as something that manages networking for all our virtual hosts(instances), and provide IP address both private and public. You might be thinking that networking in virtualization is quite easy by setting up a bridge adapter and routing all traffic through it, similar to many virtual adapters. But here we are talking about an entire cloud, that should have public ip’s, that can be attached, detached from the instances that we launch inside, there must be one fixed ip for each instance, and then there must never be a single point of failure etc.

According to me openstack networking is the most complex thing that needs to be designed by taking extreme care. We will be discussing openstack networking in very detail, in a dedicated post, because of its complexity, and importance. Also it can be done with two different tools. One is called as nova-networking, and the other is called as neutron. Please note the fact that each and every component of openstack cloud needs special attention on its own, as they are each very distinct and work combined together to form a cloud. Hence i will be doing dedicated post for each of its major components.

Openstack is very highly configurable, due to this very reason, its quite difficult to mention all of its possible configurations in a tutorial. You will come to know about this, at a later point, when we start configuring things in the upcoming series of posts.

Higher Level Overview of Openstack Architecture

Component Name Used for Similar to
Horizon A dashboard for end users or administrators to access other backend services AWS Management Web Console
Nova Compute Manages virtualization and takes requests from end user through dashboard or API to form virtual Instances AWS Elastic Compute
Cynder For Block storage, directly attachable to any virtual instance, similar to an external hard drive EBS(Elastic Block Store)
Glance This is used for maintaining a catalog for images and is kind of a repository for images. AMI (Amazon Machine Images)
Swift This is used for Object storage that can be used by your applications or instances to store static objects like multimedia files, backups, store images, archives etc. AWS S3
Keystone This component is responsible for managing authentication services for all components. Like a credentials and authorization, and authentication for users AWS Identity And Access Management(IAM)

You might have got an idea of what OpenStack Cloud actually is till now. Let’s now answer some questions, that can really prove helpful in getting a little bit more idea of what openstack really is, or say how these individual components fit together to form a cloud.

What is Horizon Dashboard?

Its nothing but a web interface for users and administrators to interact with your OpenStack cloud. Its basically a Django Web Application implemented in mod_wsgi and Apache. Its primary objective is to interact with the backend API’s of other components and execute requests initiated by users. It interacts with keystone authentication service, to authorize requests before doing anything

Does nova-compute perform virtualization?

Well, nova-compute basically is a daemon that does the job of creating and terminating virtual machines. It does this job through virtual machine API calls. There is something called as a libvirt library. Libvirt is nothing but an API for interacting with Linux virtualization technologies(its a free and open source software that needs to be installed with nova as a dependency).

Basically libvirt gives nova-compute, the functionality to send API requests to KVM, Xen, LXC, OpenVZ, Virtualbox, Vmware, Parallels hypervisors.

So when a user in openstack requests to launch a cloud instance, what actually happens is nova-compute sending requests to hypervisors using libvirt. Well other than libvirt, nova-compute can send requests directly to Xen-Api, vSphere API etc. This wide support of different virtualization technologies is the main strength of nova.

How does Swift Work?

Well swift is a highly scalable object storage. Object Storage in itself, is a big topic, so i recommend reading the below post.

Unlike block storage, files are not organized in hierarchical name space. But they are organized in a flat name space. Although it can give you an illusion of a folder with contents inside, all files inside all folders are in a single name space, due to which scaling becomes much easier compared to block storage.

Swift uses multiple commodity servers and backend storage devices to combine together and form a large pool of storage as per the requirement of the end user. This can be scaled without bounds, by simply adding more nodes in the future.

swift object storage

What is keystone?

Its a single point of contact for policy, authentication, and identity management in openstack cloud. It can work with different authentication backends like Ldap, SQL or a simple key value store.

Keystone has two primary functions

  • Manage Users. Like tracking of all users, and their permissions.
  • Service list/catalog. This is nothing but providing information regarding what services are available and their respective API endpoint details.

What is Openstack Cinder?

As discussed before and shown in the diagram, cinder is nothing but a block storage service. It provides a software block storage on top of basic traditional block storage devices to instances that nova-compute launches.

In simple terms we can say that cinder does the job of virtualizing pools of block storage(any traditional storage device) and makes it available to end users via API. Users use those virtual block storage volume inside their virtual machines, without knowing where the volume is actually deployed in the architecture, or knowing details about the underlying device of the storage.

Building Your Application for Cloud Portability – An Alternative Approach to Hybrid Cloud

 

TOSCA | Hybrid Cloud | Cloud Portability | Cloud Orchestration | Hybrid IT | Open Source Cloud Automation | Cloud Orchestration Tools | Multi-Cloud
In my previous post, I discussed the differences between hybrid cloud and cloud portability, as well as how to achieve true hybrid cloud deployments without compromising on infrastructure API abstraction, by providing several use cases for cloud portability.

Cloud Portability Defined (again)

For the sake of clarity, I thought it would be a good idea to include my definition of cloud portability again here: “Cloud portability is the ability to run the same application on multiple cloud infrastructures, private or public. This is basically what makes hybrid cloud possible.”

Clearly, the common infrastructure API abstraction approach forces too many restrictions on the user which makes it fairly useless for many of the cloud portability use cases.

In this post, I would like to propose another method for making cloud portability, and therefore true hybrid cloud, a reality.

An Alternative Approach

One of the use cases I previously mentioned for allowing application deployment portability to an environment, that doesn’t conform to the same set of features and APIs, is iOS and Android. With operating systems, we see that software providers are able to successfully solve the portability aspect without forcing a common abstraction.

What can we learn about cloud portability from the iOS/Android use case?

Treat portability differently between the application consumer and the application owner – One of the main observation from the iOS/Android case is that, while the consumer is often completely abstracted from the differences between the two platforms, the application developer is not abstracted and often needs to treat each platform differently and sometimes even duplicate certain aspects of the application’s components and logic to suit the underlying environment. The application owner, therefore, has the incentive to support and even invest in portability as this increases the application’s overall market reach.

Minimizing the differences, not eliminating them – While the application owner has more incentive to support each platform natively, it is important to use cloud portability as a framework that will allow for minimizing but not eliminating the differences to allow simpler development and maintenance.

The main lesson from this use case is that, to achieve a similar degree of cloud portability, we need to make a distinction between the application consumer and the application owner. For cloud portability, in order to ensure a native experience for the application consumer, we need to assume that the application owner will be required to duplicate their integration effort per target cloud.

 

This is the same approach we should take with cloud application portability!
 

So, how does one go about doing that?

Achieving Cloud Portability with ARIA – A Simple Multi-Cloud Orchestration Framework

In this section, I will refer to this specific project as a means by which to illustrate the principles that I mentioned above in more concrete terms.

Project ARIA is a new Apache-licensed project that provide simple, zero footprint multi-cloud orchestration based on TOSCA. It was built originally as the core orchestration for Cloudify and is now an independent project.

The diagram below provides an inside look at the ARIA architecture.

 

There are three pillars, upon which ARIA is built, that are needed to manage the entire stack and lifecycle of an application:

1) An infrastructure-neutral, easily extensible templating language

2) Cloud plugins

3) Workflows

TOSCA Templating Language vs. API Abstraction

ARIA utilizes the TOSCA templating language in its application blueprints which provides a means for deploying and orchestrating a single application on multiple infrastructures through individual plugins, thereby circumventing the need for a single abstraction layer.

Templating languages, such as TOSCA, provide far greater flexibility for abstraction than API abstraction as it allows easy extensibility and customization without the need to develop or change the underlying implementation code. This is done by mapping the underlying cloud API into types and allowing the user to define the way it accesses and uses those types through scripts.

With Cloudify, we chose to use TOSCA as the templating language because of its inherent infrastructure-neutral design as well as being designed as a DSL which has lots of the characteristics of a language that utilizes the support of inheritance, interfaces and a strong typing system.

Cloud Plugins

Built-in plugins for a wide range of cloud services provide out of the box integration points with the most common of these services, but unlike the least common denominator approach (i.e. a single API abstraction layer), they can be easily extended to support any cloud service.

Workflows

Workflows enable interaction with the deployment graph and provide another way to abstract common cloud operational tasks such as upgrades, snapshots, scaling, etc.

Putting It All Together

By combining the three aforementioned elements, the user is given a set of building blocks for managing the entire application stack and its lifecycle. It also provides a richer degree of flexibility that allows users to define their own degree of abstraction per use case or application.

In this manner, cloud portability is achievable without the need to change your underlying code, and, in doing so, you enable true hybrid cloud.

OpenStack simplifies management with Mitaka release

The latest OpenStack release provides a unified CLI, standardized APIs across projects, and one-step setups for many components

ent-software-businessman-ts-100539050-primary.idge

The latest revision of OpenStack, dubbed Mitaka, was officially released yesterday and boasts simplified management and improved user experience as two prominent features.

Rather than leave such features to a particular distribution, OpenStack has been attempting to integrate them into the project’s core mission. But another big OpenStack effort — its reorganization of the project’s management — is still drawing criticism.

Pulling it all together

A unified OpenStack command-line client is a key new feature intended to improve both management and user experiences. Each service, current or future, can register a command set with the client through a plug-in architecture. Previously, each OpenStack project had an individual CLI, and managing multiple aspects of OpenStack required a great deal of switching between clients, each with its own command sets.

At the same time, API calls for the various subprojects in OpenStack are now more uniform, along with the SDKs that go with them, so it’s easier for developers to write apps that plug directly into OpenStack components.
OpenStack instances are also easier to get up and running — an aim with each passing revision of OpenStack. This time around, more of the platform’s core settings come with defaults chosen, and many previously complex setup operations have been whittled to a single step. OpenStack’s identity and networking services, Keystone and Neutron, both feature these improvements.

Big tent or big problems?

Mitaka marks the first major OpenStack release since the project adopted its Big Tent governance model. In an attempt to tame project sprawl, OpenStack resolved to reform the way projects are included and to describe which projects are best suited to what scenarios.

Julien Danjou, software engineer at Red Hat and author of “The Hacker’s Guide to Python,” believes OpenStack’s core problems haven’t been solved by the Big Tent model. “OpenStack is still stuck between its old and new models,” he said in a blog post. The old model of OpenStack, a tiny ecosystem with a few integrated projects, has given way to a great many projects where “many are considered as second-class citizens. Efforts are made to continue to build an OpenStack project that does not exist anymore,” Danjou said.

Chris Dent, a core contributor to OpenStack, feels Big Tent has diluted the project’s unity of purpose. “We cannot effectively reach our goal of interoperable but disparate clouds if everyone can build their own custom cloud by picking and choosing their own pieces from a collection,” he said.

Dent thinks OpenStack should be kept small and focused, “with contractually strong APIs … allowing it to continue to be an exceptionally active member of and user of the larger open source community.”

Mitaka’s work in unifying the API set and providing a common CLI are steps in that direction. But countering that is OpenStack’s tendency to become more all-encompassing, which appeals only to a narrow, vertical set of customers — service providers, for instance, or operations like eBay — with the cash and manpower to make it work.

DreamHost replaces VMware SDN with open source for big savings

OpenStack code developed by spin-out company nets 70% capex, 40% opex cuts

SANTA CLARA – In a convincing example of the viability of open source networking, cloud provider DreamHost saved 70% in capital and 40% in operational costs by replacingVMware’s NSX SDN with open source alternatives.

In a presentation at the Open Networking Summit here, suppliers Cumulus Networks and Akanda – a DreamHost spin-out NFV business — said the cloud provider replaced NSX due to scaling and Layer 3 support issues. DreamHost did not speak and was not present during the presentation, but posted a blog entry on the project here last Friday

The project involved DreamHost’s DreamCompute public cloud compute service, which is based on OpenStack and Ceph object store and file system. The core networking requirements for DreamCompute are Layer 2 tenant isolation, IPv6 and 10G+ “everywhere.”

The first generation of the DreamCompute networking infrastructure included Nicira’s NVP network virtualization software for Layer 2 isolation, and Cumulus Linux as the network operating system running on white box switches. Layer 3 requirements were not met by Nicira NVP nor by software routing vendors who did not understand cloud, said Mark McClain, Akanda CTO.

The second generation of the DreamCompute network include Layer 3 capabilities in VMware NSX, which acquired Nicira, renamed the NVP product and enhanced it. But in a bake-off with the Astara open source network orchestration service for OpenStack – which was developed by DreamHost — Astara comes out on top and, with some enhancements, allows DreamCompute to scale to over 1,000 customers and thousands of VMs.

“Honestly, we expected Astara to lose this challenge,” states Jonathan LaCour, DreamHost vice president of cloud and development, in his blog. “However, Astara absolutely came out victorious, offering a significantly better experience and more reliability.”

In the third generation of the DreamCompute infrastructure, NSX was found to have scale limitations of 1,250 tenants. Open vSwitch was slow and unstable, and the software was difficult to debug and operate, the presenters said. As a result, NSX was replaced for Layer 2 isolation by hardware accelerated VXLAN in the switch and hypervisor, and by Astara for Layer 3-7 service orchestration.

Cumulus Linux remained as the physical underlay for the DreamCompute network.

Astara virtual network appliances allowed for easy scale, while VXLAN tunnels scaled “massively,” presenters said. Astara also simplified OpenStack Neutron networking deployments by requiring fewer Layer 2, DHCP and advanced services agents, and is generally easier to operate because it, VXLAN and the Linux networking stack on DreamCompute switches are “open” and familiar, presenters said.

“As far as performance and scale, DreamCompute is breaking through those limits we met with VMWare NSX,” LaCour states in his blog. “This is largely due to reductions in complexity, thanks to management and automation through OpenStack and Astara.”

VMware wouldn’t comment specifically on the DreamHost project but through a spokesperson said it is “very happy with the success” NSX has had in some of the largest OpenStack environments in the world, “as well as our track record in open networking through things like the Open vSwitch project.”

DreamHost’s project mirrors that of other cloud and Webscale providers, like Google and Facebook, that have opted to develop their own networking solutions to overcome the limitations of commercial offerings, and reduce capex and opex. That open source provides such a significant capex improvement over commercial products should perhaps come as no surprise.

But the opex reduction might be the proof point that familiar open source code, customized for specific operator requirements, is just as capable – if not more so – than commercially available, vendor-integrated products.