Tag: microservices

  • DevOps Teams: Containers Will Help You Become Future Ready

    DevOps Teams: Containers Will Help You Become Future Ready

    Container frameworks are emerging as a superior choice to create, manage, and run distributed applications in a scalable and secure fashion. Docker’s growth is testimony to the fact. There are 100 million downloads of the Docker Engine, 75,000 Dockerized applications, 770 contributors, and 50,000 third-party projects on GitHub using Docker in less than two years.

    The State of Containers 2015 Docker Adoption Survey found that more than 70 percent of respondents are either using Docker or evaluating for future use. Given Docker’s overwhelming popularity, here are three trends that DevOps teams should prepare for:

     

    –THIS STORY HAS BEEN MOVED TO CONTAINER JOURNAL–


     

    About the Author / Varma Kunaparaju

    YaCNNVuUVarma Kunaparaju is CTO at Vistara and a seasoned technologist with over 20 years of experience leading engineering teams to deliver enterprise software. Reach him on Twitter @varma1

  • 3 golden rules of microservices deployments

    3 golden rules of microservices deployments

    As a developer, you value the principles of SOA. You aspire to build applications as a set of consumable services via endpoints. Remember how Amazon used SOA to build the AWS platform and how Google is emulating AWS? However, not all is hunky-dory in the SOA world.

    Developing is one thing but running, managing, and maintaining services is a whole other beast. When it comes to the latter, many enterprises still act monolithic. They run and manage applications services as a unit on one or many servers. This approach fails to scale when the services themselves scale or when you need to update and maintain them regularly. So do you lament over the spiking costs and time spent on these efforts or fix the problem?

    Recent trends point to microservices as the answer. By definition, microservices are much smaller than services. In fact, Wikipedia says a microservice performs a small task often just one. There are many articles that go in deep about microservices architecture, but we cover an important part here, which is deployment automation. In other words, our daily job.

    The self-contained, independent, and reusable principles of microservice architecture help solve the problem of scaling and maintaining application services.

    • Self-contained. Microservices are standalone operations that run without requiring other services. That means each runs on its own. You can scale each up or down and replace a service individually instead of updating the entire monolith given the business need and load.
    • Reusable. Microservices are self-contained so you can reuse them for other applications and functions. We’re talking of reusing already deployed microservices.
    • Independent. Microservices are platform agnostic, which means you can design them independent of infrastructure needs to run anywhere, in any cloud.

    So is it easy to shift from SOA-based architecture to microservices? Adopting microservices is not without challenges. To name some, you need to modularize existing software services as self-contained units, you need to configure the microservices to communicate with each other, and you need lots of deployment and test automation.

    To address these challenges out of the box, we recommend a DevOps solution like ElasticBox. Take a look at how ElasticBox supports microservice deployments.

    1. Modularize self-contained microservices

    The box model in ElasticBox wraps each microservice as a standalone component in a service catalog that you can reuse across applications. A script box automates the lifecycle of microservices using Bash, Puppet, Chef, SaltStack, Ansible, PowerShell; a container automates Dockerfile deploys; a CloudFormation box automates AWS resource stacks.

    2. Connect microservices via bindings

    More microservices means more endpoints to manage. Such endpoints handle REST or other protocol communications over the network. With ElasticBox bindings, network references are as easy to manipulate as programming variables. Want to route database connections to another MySQL service? It’s easy to do. Just point the services to deploy with a different binding value.

    3. Deploy microservices independently

    Boxes are inherently agnostic. Put infrastructure metadata for CPU, memory, storage, additional disks, virtual networks, firewalls, load balancing, and autoscaling in deployment policies attached to a cloud service like AWS, Google cloud, and more. Policies help you deploy the microservices defined in the script boxes to any platform and cloud. The orchestration engine in ElasticBox interacts with the cloud APIs to auto-provision virtual machines based on metadata from deployment policies. So it’s easy to spin up and destroy microservices on demand without disrupting service availability.

    ElasticBox can simplify microservices deployments. For instance the Jenkins ElasticBox plugin continuously integrates ElasticBox automation with Jenkins jobs to test and deliver what the software developments teams build continuously. So the next time you think SOA, think microservices instead.  Feel free to check out how ElasticBox can help.

  • What DevOps Needs to Know About Microservices

    What DevOps Needs to Know About Microservices

    In this fast-moving, immature space, expect to spend cycles assessing where the greatest value lies for each team and the business as a whole.

    The term “microservices” is popping up everywhere in software development circles. Indeed, microservices are frequently touted as The Next Big Thing in terms of how to write applications to avoid the problems of complex, monolithic architectures.

    From a Devops perspective, the microservices discussion is usually related to Docker or other containers. Both share an emphasis on lightweight individual units that can be managed independently, so containers are often regarded as a natural implementation choice for a microservice architecture. But what are microservices actually?

    Microservices constitute a software architectural style that approaches a single application as a suite of small services, each running its own process and communicating with lightweight mechanisms, such as an HTTP-based API. The services are small, highly decoupled and focus on providing a single “useful” business capability. Typically, microservices involve very little centralized management, may be written in different programming languages, and use different data storage technologies.

    A good way to understand the microservice style is to compare it to the monolithic style, in which an application is built as a single unit. A classic example of this approach is the “standard” three-tier enterprise application, consisting of a client-side user interface, a database, and a server-side application. Changes made to monolithic applications can be both painful and costly as any change made to a small part of the application requires the entire monolith to be rebuilt and deployed.

    Microservices clearly offer many advantages — notably the ability to make small changes to code quickly and efficiently, and with minimum risk. The services are organized around business capabilities, and they lend themselves to Continuous Delivery.

    Some of these advantages include the following:

    Small, Easy-to-understand Code

    As a microservice app is responsible for only one thing it requires little code, is easy to understand, and involves minimal risks when changes are made.      

    Easy-to-scale, Easy-to-deploy and Easy-to-discard

    Size is important. Microservices technology make it easy for developers to scale, deploy and discard apps and features. In contrast, a single change to a monolithic app requires changing the whole application.

    Smaller Teams

    It’s much easier and faster to work with a small team than a large one. Each small team can own a microservice and access other services via a high-level API.   

    Facilitates System Resilience

    If a monolith application stops working a lot of functionality will stop working. In contrast, if a microservices app stops working only a small, specific functionality will be lost.

    However they are not without their serious challenges, especially relevant from a DevOps perspective — such as coordinating interdependent deployments, fusing developer skills with technologies, and confronting disagreements between developers. 

    As developers break down monolithic applications and move complexity from within to between applications, obvious challenges come to the fore. Some of these include the following:

    Coordinating Interdependent Deployments

    Individual microservices are supposed to be independently deployable, but in order to provide any kind of useful functionality from the perspective of the user you typically need to get a whole set of microservices running.

    Deploying microservices requires a new generation of tools that can manage a multitude of simple deployments, while tracking and managing their dependencies. These tools need to be able to bring everything together on time to deliver an app without being too rigid, for instance by supporting version ranges for services rather than fixing on individual versions. These tools should help developers to deploy different bundles of services easily, without having to ask an administrator to reconfigure the deployment tool.

    Planning and configuration should be done through a single interface with a real-time view of app deployment. Essentially, developers should seek to attain the same balance of speed and efficiency that Continuous Delivery offers.

    Microservices Need Skilled Developers and Operators

    While there are many potential productivity boosts to separating services, tracking all of the relationships between them is vital. The team needs to know the entire development landscape and be able to test live components together.

    Testing isolated services is a simple enough proposition, but testing the entire user-facing business service can be problematical.

    Developer Disagreements

    There will be a lot of time-consuming debate and friction when developers butt heads about the pros and cons of keeping a monolithic stack versus embracing microservices: which applications to refactor, which to rewrite, which to leave alone, etc.

    The worst-case scenario: developers lose sight of the overarching system goals, focus on the service they are working on, refuse to be flexible, and resist being part of an overall team.

    Finding the right set of technologies for a microservices implementation will not be a quick or simple task. As this is a fast-moving, immature space, expect to spend a lot of time assessing where the greatest value lies for each team and the business as a whole. Delivering the greatest benefits may mean adopting a hybrid system that draws on and integrates different technologies.

    About the Author/Andrew Phillips

    Andrew_Phillips_XebiaLabs_cropAndrew Phillips heads up product management at XebiaLabs. Andrew is an evangelist and thought leader in the DevOps, Cloud and Continuous Delivery space. He sits on the management team and drives product direction, positioning and planning.

  • In DevOps, On-Prem Is Dead

    In DevOps, On-Prem Is Dead

    What you need to know about SaaS management tools

    The SaaS vs. on-premise debate has spanned the years since new age consumption models for technology were born.

    The accepted reasons to adopt SaaS are no-brainers for DevOps organizations. SaaS lets you start up fast, is asset-free, and has a lower commitment subscription model. You expect time to production in hours or days, rather than the months or years that an on-premise software installation can take to fully deploy the solution. Here’s why SaaS IT Ops tools are a better choice for your DevOps implementations:

    Agility and Time to Market. It makes no sense to invest up-front in a solution that commits you to a technology when you’re moving at light speed. Long feature release cycles from traditional software vendors and the regular maintenance required slow down your DevOps teams. On-premise upgrades will likely require central IT support, not to mention the risk inherent in upgrading the software.

    Evergreen Platform. As you grow your environment and add new technologies, your management solution needs the requisite features and plugins to work. A SaaS platform continually updates the technology, behind the scenes at the vendor, so your engineer’s time isn’t wasted on managing the maintenance and upgrades.

    Microservices. With application workloads migrating to the cloud, monolithic app architectures are falling out of favor. Microservices allow you to build applications as suites of services where each unit of software can be independently upgraded. Enterprises can quickly adopt hybrid cloud architectures thanks to microservices, where some services live in a public cloud while others in owned data centers. SaaS tools offer an integrated approach to monitor dynamic architectures by tracking the performance of your application as a logical entity before and after each update.

    Infrastructure as Code. With Infrastructure as code, sysadmins use automation frameworks for standing up or turning off production environments. IT teams can orchestrate complex deployments without manual intervention in an error-free manner. SaaS tools help you manage automated infrastructure that’s written as code and monitor different production instances across hybrid clouds.

    Enterprise applications are clearly going the SaaS way. By 2018, IDC estimates that 28% of enterprise software will be SaaS based with on-premise software attaining negative growth rates. Embrace the age of agile operations by leveraging SaaS tools to improve build quality, increase release velocity, and manage complex infrastructures across your enterprise.

    About the Author / Varma Kunaparaju

    YaCNNVuUVarma Kunaparaju is CTO at Vistara and a seasoned technologist with over 20 years of experience leading engineering teams to deliver enterprise software. Reach him on twitter at: @varma1

     

  • The benefits of micro-services

    The benefits of micro-services

    The adoption of a micro-services architecture has two main advantages, according to ThoughtWorks technologist Sam Newman.

    One is that micro-services increase the autonomy of individual development teams within an organization, as ideas can be implemented and deployed without having to coordinate with a wider IT delivery function.

    This allows new or changed features to be delivered more quickly. Organizations that understand they make money through technology – Netflix is one example Newman cited – know they need to get new features out the door as quickly as possible.

    The other main advantage is that micro-services aids the adoption of new technologies, although this is arguably a subset of the autonomy argument.

    Since a micro-service is by definition a small, self-contained function, it provides a low-risk opportunity to try a new technology. That is definitely not the case where monolithic systems are concerned, Newman said, as greater care is required when all the eggs are in one basket. But where a less-critical element is concerned, there are fewer barriers to experimenting with a new programming language or database, for example.

    So which organizations are setting the pace? “Netflix is a very good example,” said Newman, observing that the driver for its adoption of micro-services was to ship new features quickly, rather than handling scaling issues.

    Locally, REA (the company behind realestate.com.au and related real-estate sites) “is probably a couple of years ahead” in the use of micro-services, he said, noting that REA has been a ThoughtWorks client for many years, and has also embraced DevOps and automation. Its technology architecture is aligned with its organizational architecture, so REA can readily absorb companies that it acquires and therefore grow more easily. Organizational issues are key to understanding the significance of micro-services, he said.

    REA approached micro-services progressively. In the first three months it made sure the foundations were in place and put two micro-services into production. But in the second trimester it was able to deploy around a dozen more, and in 18 months more than 60 were live.

    Other micro-services adopters mentioned by Newman included MYOB (see DevOps in Action: MYOB) and PwC (which is progressively migrating its system for handling expatriates’ tax returns and related issues from a traditional enterprise system to a finer-grained, more decomposed architecture using micro-services, to reflect the way some parts of the system are common to all geographies while others are country-specific).

    There is a very real risk that building micro-services will lead to duplication, but that is not necessarily a bad thing, Newman said. Many SOA (service-oriented architecture) implementations have been hamstrung by efforts to optimize services for reuse slowing the pace of change, so organizations may choose to accept a degree of duplication in order to speed delivery.

    An Australian bank is currently exploring this issue, realizing that it previously made a mistake by emphasizing reuse over time to market, he said. “It has to be a balance… [but] reuse in itself shouldn’t be the goal.”

    That said, it can be beneficial to eliminate at least some of this duplication over time in order to improve the maintainability of the systems. Otherwise the result can be “quite a chaotic environment.”

    “It’s a governance thing,” Newman explained – organizations need to detect any duplicate micro-services, and then make a deliberate decision to either continue as they are or to converge them. This is healthier than simply forbidding divergence and duplication as that can negatively affect time to market.

    Allowing duplication – even if only in the first instance – also mitigates questions of ownership, allowing the team developing a micro-service to proceed without the need for ‘sign off’ from other parties that may be potentially affected.

    In any case, developing a micro-service typically takes around two weeks, so there is no great loss if duplicates are retired. It is a different situation when monolithic systems are involved, as they are very hard to retire in an SOA environment – an enterprise application may be grossly underused, but it can’t be removed as long as other programs are consuming its services.

    The idea behind SOA was good, he said, but it became dominated by software vendors rather than by consideration of what works well for their customers.

    The micro-service architecture can be thought of as ‘SOA done well,’ Newman suggested, especially as it provides a mechanism for surfacing capabilities in multiple different ways, such as (in the case of a retailer) via web sites, native and web apps for mobile devices, and in-store software. When different capabilities are to be combined in different ways, working with smaller pieces is easier than larger ones.

    Newman’s book Building Micro-services is published by O’Reilly Media. It is now available as an ebook and will appear in print shortly.

  • DevOps in Action:  MYOB

    DevOps in Action: MYOB

    This is the first in a new series called DevOps in Action. A look at organizations who are putting DevOps into practice. Does your organization have experience putting DevOps into action that you think our readers might find useful or interesting? If so contact us at editor@devops.com and perhaps we can feature your story here.

    Australia-based MYOB is a long-established developer of accounting systems and related software. During the last several years its original focus on desktop software has changed, and it now offers cloud-enabled and pure SaaS products. This change had two significant impacts on the company.

    Firstly, it meant that instead of simply delivering packaged software to customers, MYOB now has to manage the infrastructure that its SaaS products run on.

    Secondly, the traditional annual update cycle primarily driven by tax and compliance issues goes out of the window in a SaaS world, where the norm is continuous improvement based on customer feedback.

    “Traditional operations management just doesn’t keep pace with that,” said MYOB business division product delivery manager John Sullivan. “The pace of change has changed dramatically.”

    Not only are there more ideas for improvements and new features, but the changes are increasingly “externally fuelled,” he said. This makes it difficult to plan infrastructure requirements very far ahead.

    MYOB joined the DevOps movement as it was seen as a way of releasing better software more quickly, and of ensuring that the hardware could be scaled to meet the demands of new software releases.

    At some companies, DevOps is about building infrastructure for developers to use, or having operations build infrastructure in parallel with software development, he said.

    But MYOB now has operations staff that literally work alongside developers to translate features requirements into infrastructure requirements, and then use repeatable methods to build that infrastructure.

    “We scale our infrastructure at the time features are being built,” said Sullivan.

    The company uses multiple cloud providers, reflecting the varying needs of its 40-plus products. AccountRight Live (a desktop program that stores its data in the cloud) was written using .NET, so it made sense to use Azure for the cloud element.

    And it has adopted a microservices architecture so a single implementation of a function can be used by multiple products (read more about this in ‘MYOB moving ahead with microservices’ http://www.itwire.com/business-it-news/accounting-software/65878-myob-moving-ahead-with-microservices). These microservices mostly run on Amazon Web Services.

    Everything else runs on virtual cloud infrastructure provided by Macquarie Telecom.

    Using these larger providers means MYOB can be confident that the physical resources are available whenever they are needed, without having to invest large amounts of money in private infrastructure. Having the infrastructure “come alive” at the moment any particular piece of software goes live provides significant savings.

    MYOB had an important advantage when starting its DevOps journey: the need for operations staff was new, as it was going from being a traditional software vendor to also offering SaaS products. Sullivan said that made it easier to put development and operations staff together than it would be for an organisation that has a history of managing its own infrastructure, especially with a steady release cadence as opposed to the rapid tempo associated with cloud services.

    “We were very lucky that we needed to manage infrastructure for the first time,” he said.

    But there were some cultural issues, particularly around making the delivery teams understand they had to take infrastructure into account when building features, as it is important that the cost of delivering the service is kept within reasonable limits. So developers need to tap into operational expertise to ensure that the patterns they use will scale adequately, and that the hooks for monitoring and managing the software are included.

    MYOB started with an independent DevOps team with an oversight role, but this was less than optimal, Sullivan said. “If you say you have a ‘DevOps team,’ you probably haven’t” because the closer that development and operations staff are, the better the systems become – getting the right design means looking at application features from several different angles.

    Those on the operations side need to be able to advise developers about the software patterns and tools that will be able to handle increasing load. Not only does that potentially avoid the need to build complex failover arrangements, it also saves you running into a situation where you have to re-architect the whole system when demand reaches a certain level. “That’s the advantage of having operations and development people close together.”

    MYOB uses the Agile methodology, and infrastructure concerns and requirements are included on feature cards so the software and infrastructure can be built together. As the company gets better at DevOps, developers become increasingly aware of infrastructure requirements and so they build as they go – “we’re just about there with one of our teams.”

    “You need operations people with the mindset of a developer … or you’re going to struggle,” he said. For example, you want systems that can automatically scale on demand, and that requires scriptable deployment processes: “a difficult thing to do at times.” Fortunately for MYOB, the company was able to find the right people. It can be hard for development staff to adapt to DevOps, Sullivan suggested, but it’s even harder for traditional operations staff.

    One of the ‘tricks’ used by MYOB to build the DevOps culture was to rotate developers into operations roles after the software they had been working on entered production in order to learn about operational requirements. “Then they actually feel the pain of phone calls in the middle of the night if something goes wrong.”

    Another is that the company favours ‘self-reflective teams’ (regardless of function) that review what has or has not worked for them during the last two weeks, and adapt their practices accordingly. DevOps is just one area where this practice is used. Sullivan notes that because the environment is so dynamic, ideas are not rejected permanently. So teams can decide that just because a certain technique or idea did not work on a previous project, it might be successful this time because the situation is different in a relevant way.

    Early in the transition MYOB filled some key roles with DevOps practitioners that had Azure and AWS experience. But Sullivan warned “there are very few conferences or training courses on DevOps … so most companies don’t do DevOps correctly.” Consequently, special care is needed when hiring people that claim experience in the field.

    “The term ‘DevOps’ is overused and sometimes misunderstood.” So some people say they have DevOps experience when all they really know about is doing scripted builds, and do not have the skills and practices to be embedded in a DevOps team.

    “There are few people that have the right mindset,” said Sullivan, so it is very important to check a candidate’s skill set against your requirements – and on the flip side, to take the steps necessary to retain your good DevOps staff.

    So did MYOB get what it wanted from DevOps?

    One initial goal was to go from the traditional software-only annual release to a six-week ‘software and infrastructure’ cycle. “We met that pretty quickly,” said Sullivan, and the company is now targeting ‘any time’ releases for online services with minimal or no interruption. This will allow the company to pick and choose which new features are to be released and when according to marketing priorities, rather than being hamstrung by arbitrary release cycles.

    The other was to achieve “one click deployment,” that is to be able to release code and infrastructure to customers with no manual tasks beyond initiating the process. The automated process should either run to completion, or back itself out if something goes wrong. This has been achieved for most products, the main exception being those for mobile devices because the requirements of the various app stores get in the way.

    “Other companies may have different metrics, but ours were about release capability and infrastructure efficiency,” said Sullivan.

    Asked if MYOB had any regrets about going down the DevOps route, the answer was succinct: “None whatsoever.”

    And his advice for others considering following this path sounds sensible for any part of working life. “Embrace the idea that you have to grow and learn, and keep making the best decisions you can at every step.”

    About the Author:

    stephenWithers

    Stephen Withers is one of Australia¹s most experienced IT journalists, covering everything from gadgets to enterprise systems. In previous lives he has been an academic, a systems programmer, an IT support manager, and an online services manager. Stephen holds an honours degree in Management Sciences, a PhD in Industrial and Business Studies, and is a senior member of the Australian Computer Society. You can see his Linkedin profile here: http://au.linkedin.com/pub/stephen-withers/0/222/687/