53 new things to look for in OpenStack Newton (plus a few more)

OpenStack Newton, the technology’s 14th release, shows just how far we’ve come: where we used to focus on basic things, such as supporting specific hypervisors or enabling basic SDN capabilities, now that’s a given, and we’re talking about how OpenStack has reached its goal of supporting cloud-native applications in all of their forms — virtual machines, containers, and bare metal.

There are hundreds of changes and new features in OpenStack Newton, and you can see some of the most important in our What’s New in OpenStack Newton webinar.  Meanwhile, as we do with each release, let’s take a look at 53 things that are new in OpenStack Newton.

openstack_main_services-svg

Compute (Nova)

  1. Get me a network enables users to let OpenStack do the heavy lifting rather than having to understand the underlying networking setup.
  2. A default policy means that users no longer have to provide a full policy file; instead they can provide just those rules that are different from the default.
  3. Mutable config lets you change configuration options for a running Nova service without having to restart it.  (This option is available for a limited number of options, such as debugging, but the framework is in place for this to expand.)
  4. Placement API gives you more visibility into and control over resources such as Resource providers, Inventories, Allocations and Usage records.
  5. Cells v2, which enables you to segregate your data center into sections for easier manageability and scalability,has been revamped and is now feature-complete.

Network (Neutron)

  1. 802.1Q tagged VM connections (VLAN aware VMs) enables VNFs to target specific VMs.
  2. The ability to create VMs without IP Address means you  can create a VM with no IP address and specify complex networking later as a separate process.
  3. Specific pools of external IP addresses let you optimize resource placement by controlling IP decisions.
  4. OSProfiler support lets you find bottlenecks and troubleshoot interoperability issues.
  5. No downtime API service upgrades

Storage (Cinder, Glance, Swift)

Cinder

  1. Microversions let developers can add new features you can access without breaking the main version.
  2. Rolling upgrades let you update to Newton without having to take down the entire cloud.
  3. enabled_backends config option defines which backend types are available for volume creation.
  4. Retype volumes from encrypted to not encrypted, and back again after creation.
  5. Delete volumes with snapshots using the cascade feature rather than having to delete the snapshots first.
  6. The Cinder backup service can now be scaled to multiple instances for better reliability and scalability.

Glance

  1. Glare, the Glance Artifact Repository, provides the ability to store more than just images.
  2. A trust concept for long-lived snapshots makes it possible to avoid errors on long-running operations.
  3. The new restrictive default policy means that all operations are locked down unless you provide access, rather than the other way around.

Swift

  1. Object versioning lets you keep multiple copies of an individual object, and choose whether to keep all versions, or just the most recent.
  2. Object encryption provides some measure of confidentiality should your disk be separated from the cluster.
  3. Concurrent bulk-deletes speed up operations.

Other core projects (Keystone, Horizon)

Keystone

  1. Simplified configuration setup
  2. PCI support of password configuration options
  3. Credentials encrypted at rest

Horizon

  1. You can now exercise more control over user operations with parameters such as IMAGES_ALLOW_LOCATION, TOKEN_DELETE_DISABLED, LAUNCH_INSTANCE_DEFAULTS
  2. Horizon now works if only Keystone is deployed, making it possible to use Horizon to manage a Swift-only deployment.
  3. Horizon now checks for Network IP availability rather than enabling users to set bad configurations.
  4. Be more specific when setting up networking by restricting the CIDR range for a user private network, or specify a fixed IP or subnet when creating a port.
  5. Manage Consistency Groups.

Containers (Magnum, Kolla, Kuryr)

Magnum

  1. Magnum is now more about container orchestration engines (COEs) than containers, and can now deploy Swarm, Kubernetes, and Mesos.
  2. The API service is now protected by SSL.
  3. You can now use Kubernetes on bare metal.
  4. Asynchronous cluster creation improves performance for complex operations.

Kolla

  1. You can now use Kolla to deploy containerized OpenStack to bare metal.

Kuryr

  1. Use Neutron networking capabilities in containers.
  2. Nest VMs through integration with Magnum and Neutron.

Additional projects (Heat, Ceilometer, Fuel, Murano, Ironic, Community App Catalog, Mistral)

Heat

  1. Use DNS resolution and integration with an external DNS.
  2. Access external resources using the external_id attribute.

Ceilometer

  1. New REST API that makes it possible to use services such as Gnocchi rather than just interacting with the database.
  2. Magnum support.

FUEL

  1. Deploy Fuel without having to use an ISO.
  2. Improved life cycle management user experience, including Infrastructure as Code.
  3. Container-based deployment possibilities.

Murano

  1. Use the new Application Development Framework to build more complex applications.
  2. Enable users to deploy your application across multiple regions for better reliability and scalability.
  3. Specify that when resources are no longer needed, they should be deallocated.

Ironic

  1. You can now have multiple nova-compute services using Ironic without causing duplicate entries.
  2. Multi-tenant networking makes it possible for more than one tenant to use ironic without sharing network traffic.
  3. Specify granular access restrictions to the REST API rather than just turning it off or on.

Community App Catalog

  1. The Community App Catalog now uses Glare as its backend, making it possible to more easily store multiple application types.
  2. Use the new v2 API to add and manage assets directly, rather than having to go through gerrit.
  3. Add and manage applications via the Community App Catalog website.

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.

AppFormix now helps enterprises monitor and optimize their virtualized networks

AppFormix helps enterprises, including the likes of Rackspace and its customers, monitor and optimize their OpenStack- and container-based clouds. The company today announced that it has also now added support for virtualized network functions (VNF) to its service.

Traditionally, networking was the domain of highly specialized hardware, but increasingly, it’s commodity hardware and software performing these functions (often for a fraction of the cost). Almost by default, however, networking functions are latency sensitive, especially in the telco industry, which is one of the core users of VNF and also makes up a large number of OpenStack’s users. Using commodity hardware, however, introduces new problems, including increased lag and jitter.

AppFormix co-founder and CEO Sumeet Singh tells me that his company’s service can now reduce jitter by up to 70 percent. “People are just starting to roll out VNFs and as telcos move from hardware to software, that’s where they run into this problem,” he noted. “Our software is designed as this real-time system where we are able to analyze how everything is performing and do optimization based on this analysis.”

For VNF, this often means modifying how workloads are placed and how resources are allocated. Interestingly, AppFormix’s research showed that CPU allocations have very little influence on jitter. Instead, it’s all about how you use the available cache and memory. It’s controlling cache allocations correctly that allows Appformix to reduce jitter.

Singh stressed that it’s not just telcos that can benefit from this but also e-commerce sites and others who want to be able to offer their users a highly predictable experience.

The new feature is now available as part of AppFormix’s overall cloud optimization platform, which currently focuses on OpenStack and Kubernetes deployments.

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.

Deploy Openstack Juno Single Node on Redhat/Centos 7.0

In this article i am going to explain and show you how to Deploy  openstack IAAS Cloud on your home or Production server.

About Openstack Cloud :  Its IAAS  cloud plateform is Similar to AWS EC2
but here you can deploy on your home purpose.

A  Picture of Openstack Cloud is given below.

Requirement:

1.  Redhat/centos 7.0
2.  4GB  free RAM
3.  20GB  free Hard disk
4.  Virtualization support

Now follow the given steps  :-
Step 1:  configure yum client live or  local
A) Local
[root@rhel7 html]# cd  /etc/yum.repos.d/
[root@station123 yum.repos.d]# cat  juno.repo
[redhat]
baseurl=http://192.168.1.254/rhel7
gpgcheck=0

[ashu]
baseurl=http://192.168.1.254/juno-rpm/
gpgcheck=0

 OR 

B)  Live which must need internet connection 

[root@rhel7 html]# cd  /etc/yum.repos.d/

 [root@rhel7 html]# yum install epel-release -y
[root@station123 yum.repos.d]# yum install https://repos.fedorapeople.org/repos/openstack/openstack-juno/rdo-release-juno-1.noarch.rpm 
Step 2:  Follow some security  rules for juno

i)   [root@station123 ~]# systemctl   stop  NetworkManager
ii)  [root@station123 ~]# systemctl   disable  NetworkManager   
iii)  [root@station123 ~]# setenforce  0
iv)  [root@station123 ~]# cat  /etc/selinux/config 

# This file controls the state of SELinux on the system.
# SELINUX= can take one of these three values:
#     enforcing - SELinux security policy is enforced.
#     permissive - SELinux prints warnings instead of enforcing.
#     disabled - No SELinux policy is loaded.
SELINUX=permissive
# SELINUXTYPE= can take one of these two values:
#     targeted - Targeted processes are protected,
#     minimum - Modification of targeted policy. Only selected processes are protected. 
#     mls - Multi Level Security protection.
SELINUXTYPE=targeted 

Note :  here i have permanently disabled the selinux  

Step 3:  BY default  Required kernel is already installed just install openstack-packstack

[root@station123 ~]# yum  install openstack-packstack

Step 4:  Now time for generating  answer file 

[root@station123 ~]# packstack  --gen-answer-file   juno.txt

Note:  this file is text based file where you need to answer some points in 'y' or  'n' 


Some  Important changes that are required

i)   NTP  server  IP 

find out NTP in you local area or real world then place the IP like given below

[root@station123 ~]# grep  -i   ntp   juno.txt 
# Comma separated list of NTP servers. Leave plain if Packstack
# should not install ntpd on instances.
CONFIG_NTP_SERVERS=192.168.1.254

ii) DEMO version  

[root@station123 ~]# grep -i demo  juno.txt 
# The password to use for the Keystone demo user
CONFIG_KEYSTONE_DEMO_PW=e2f0614ae15f44ff
# Whether to provision for demo usage and testing. Note that
CONFIG_PROVISION_DEMO=n
CONFIG_PROVISION_DEMO_FLOATRANGE=172.24.4.224/28
# A URL or local file location for the Cirros demo image used for


iii)  EPEL  to no

[root@station123 ~]# grep -i  epel juno.txt 
# To subscribe each server to EPEL enter "y"
CONFIG_USE_EPEL=n
[root@station123 ~]# 

iv)  HOrizon ssl  to yes

 [root@station123 ~]# grep -i  horizon  juno.txt 
# Dashboard (Horizon)
CONFIG_HORIZON_INSTALL=y
# specific to controller role such as API servers, Horizon, etc.
# To set up Horizon communication over https set this to 'y'
CONFIG_HORIZON_SSL=y
[root@station123 ~]# 


v)  configure heat and celiometer as per your requirement


Step 5:  Now you can run answer file 
===========================

[root@station123 ~]# packstack  --answer-file  juno.txt 

it  may ask for your root password  then will take almost  20 to 35 minutes

Important :  if you got any error at this time then you can  send me snapshot


Step 6:   now find  your  admin  userpassword  inside your /root directory

[root@station123 ~]# cat  keystonerc_admin 
export OS_USERNAME=admin
export OS_TENANT_NAME=admin
export OS_PASSWORD=8bb1c812ec16418e
export OS_AUTH_URL=http://192.168.1.123:5000/v2.0/
export OS_REGION_NAME=RegionOne
export PS1='[\u@\h \W(keystone_admin)]\$ '


step  7:  Now  you can login to openstack panel and go for cloud creation

Now after login you will be offered by openstack internal services

like  shown below

Here  are few examples  are given by me .

IMportant:  After login almost  every thing you can do via clicking in project tab

A)  Now you can  create  network  routers and images as given 

i) Image creation  

in image link you can choose image from your hard disk or any Http url 
Note : url must be in http://  formate

now you are done with image creation

ii)  Network creation 

In project  tab  click on network menu then follow the steps as given below.

Private network 

Public network  –

NOte : public network will be your netwokr address where your base system have ip address

Important : 

 you can go ahead with graphical panel its really very simple. if you face any issue you can revert to me.

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

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.

VMware: We love OpenStack!

A few years ago VMware and OpenStack were foes. Oh, how times have changed.

This week VMware is out with the 2.5 release of its VMware Integrated OpenStack (VIO). The virtualization giant continues to make it easier to run the open source cloud management tools on top of VMware virtualized infrastructure.

VMware, Inc

VIO’s 2.5 release shows the continued commitment by VMware to embrace OpenStack, something that would have seen out of the question a few short years ago.

The 2.5 release comes with some nifty new features: Users can automatically important vSphere virtual machine images into their VIO OpenStack cloud now. The resource manager control plane is slimmed down by 30% so it takes up less memory. There are better integrations with VMware’s NSX too.

The news shows the continued maturation of both the open source project and the virtualization giant. Once VMware and OpenStack were seen as rivals. In many ways, they still are. Both allow organizations to build private clouds. But VMware (smartly in my opinion) realized that giving customers choice is a good thing. Instead of being an all or nothing VMware vs. OpenStack dichotomy, VMware has embraced OpenStack, allowing VMware’s virtualization management tools to serve up the virtualized infrastructure OpenStack needs to operate.

VMware’s doing the same thing with application containers. Once seen as a threat to virtual machines, VMware is making the argument that the best place to run containers are in it’s virtual machines that have been slimmed down and customized to run containers. Stay tuned to see if all these gambles pay off.

OpenStack digs for deeper value in telecoms, network virtualization

NFV can be a major OpenStack application, which is great for telecom, but will enterprises go for it, too?

OpenStack has long been portrayed as a low-cost avenue for creating private clouds without lock-in. But like many projects of its sprawl and size, it’s valuable for its subfunctions as well. In particular, OpenStack comes in handy for network function virtualization (NFV).

A report issued by the OpenStack Foundation, “Accelerating NFV Delivery with OpenStack,” makes a case for using OpenStack to replace the costly, proprietary hardware often employed with NFV, both inside and outside of telecoms. But it talks less about general enterprise settings than it does about telecoms, a vertical industry where OpenStack has been finding uptake.

money-shovel-100252571-primary.idge

The paper also shows how many telecom-specific NFV features — such as support for multiple IPv6 prefixes — are being requested or submitted by telecoms that are OpenStack users.

That’s not to say the telecom tail has been wagging the OpenStack dog, but it does mean that some of OpenStack’s most urgently requested — and most immediately adopted — features come from that crowd. It also raises the question of how readily those features will be deployed outside of telecoms, especially given OpenStack’s reputation as fragmented, friable, and difficult to learn.

OpenStack’s presence in the telecom world has been established for years now. Auser survey conducted back in 2014 showed that while the number of companies using OpenStack that described themselves as telecommunications companies were proportionately small, the companies in question were high-profile in their field (NTT, Deutsche Telekom).

In the most recent user survey, self-identified telecom comprised only 12 percent of the total OpenStack user base. But the 64 percent labeled “information technology” also included “cable TV and ISP,” “telco and networking,” “data center/co-location,” and other labels that could easily be considered part of a telco’s duty roster.

Network function virtualization is the second-largest OpenStack technology its users are interested in, according to the survey. The technology that took the top spot, however, was containers. That’s where OpenStack vendors (such asMirantis and Red Hat) are making their most direct appeals to the enterprise, but it’s still an open question whether a product of OpenStack’s size and cognitive load is the best way to do so.

To that end, even if OpenStack is a major force in NFV, the bigger question is whether enterprises interested in NFV/SDN (the two terms overlap) will adopt OpenStack as their solution. Some of the mystery may be due to how the changes involved in deploying NFV are a bitter pill for an enterprise of most any size to swallow — but it may again come down to OpenStack still being too top-heavy for its own good.