{"id":23332,"date":"2017-04-27T22:33:33","date_gmt":"2017-04-27T19:33:33","guid":{"rendered":"https:\/\/www.altoros.com\/blog\/?p=23332"},"modified":"2018-08-01T17:22:46","modified_gmt":"2018-08-01T14:22:46","slug":"addressing-complex-software-systems-with-microservices-and-ci-cd","status":"publish","type":"post","link":"https:\/\/www.altoros.com\/blog\/addressing-complex-software-systems-with-microservices-and-ci-cd\/","title":{"rendered":"Addressing Complex Software Systems with Microservices and CI\/CD"},"content":{"rendered":"<p>For a monolithic application\u2014delivered as a single cohesive unit of code\u2014it may take just 2\u20133 years to become an outdated \u201cblack box\u201d that is hard to support and maintain. Over time, a major update may require redeployment of the entire system, while a single failure may turn into a disaster and, eventually, downtime. A once chosen technology stack becomes a rigid structure, hardly able to fit in new components.<\/p>\n<p>This article describes a more reasonable approach to building a software architecture to solve the problem\u2014based on microservices, continuous integration, and related practices. It was not supposed to be a deep technical dive\u2014instead, it was intended to provide a high-level overview to help your CEO\/CIO stop doing the things the outdated way.<\/p>\n<p>&nbsp;<\/p>\n<div id=\"ez-toc-container\" class=\"ez-toc-v2_0_79_2 counter-hierarchy ez-toc-counter ez-toc-transparent ez-toc-container-direction\">\n<div class=\"ez-toc-title-container\">\n<p class=\"ez-toc-title\" style=\"cursor:inherit\">Table of Contents<\/p>\n<span class=\"ez-toc-title-toggle\"><a href=\"#\" class=\"ez-toc-pull-right ez-toc-btn ez-toc-btn-xs ez-toc-btn-default ez-toc-toggle\" aria-label=\"Toggle Table of Content\"><span class=\"ez-toc-js-icon-con\"><span class=\"\"><span class=\"eztoc-hide\" style=\"display:none;\">Toggle<\/span><span class=\"ez-toc-icon-toggle-span\"><svg style=\"fill: #999;color:#999\" xmlns=\"http:\/\/www.w3.org\/2000\/svg\" class=\"list-377408\" width=\"20px\" height=\"20px\" viewBox=\"0 0 24 24\" fill=\"none\"><path d=\"M6 6H4v2h2V6zm14 0H8v2h12V6zM4 11h2v2H4v-2zm16 0H8v2h12v-2zM4 16h2v2H4v-2zm16 0H8v2h12v-2z\" fill=\"currentColor\"><\/path><\/svg><svg style=\"fill: #999;color:#999\" class=\"arrow-unsorted-368013\" xmlns=\"http:\/\/www.w3.org\/2000\/svg\" width=\"10px\" height=\"10px\" viewBox=\"0 0 24 24\" version=\"1.2\" baseProfile=\"tiny\"><path d=\"M18.2 9.3l-6.2-6.3-6.2 6.3c-.2.2-.3.4-.3.7s.1.5.3.7c.2.2.4.3.7.3h11c.3 0 .5-.1.7-.3.2-.2.3-.5.3-.7s-.1-.5-.3-.7zM5.8 14.7l6.2 6.3 6.2-6.3c.2-.2.3-.5.3-.7s-.1-.5-.3-.7c-.2-.2-.4-.3-.7-.3h-11c-.3 0-.5.1-.7.3-.2.2-.3.5-.3.7s.1.5.3.7z\"\/><\/svg><\/span><\/span><\/span><\/a><\/span><\/div>\n<nav><ul class='ez-toc-list ez-toc-list-level-1 ' ><li class='ez-toc-page-1 ez-toc-heading-level-3'><a class=\"ez-toc-link ez-toc-heading-1\" href=\"https:\/\/www.altoros.com\/blog\/addressing-complex-software-systems-with-microservices-and-ci-cd\/#Whats_important\" >What\u2019s important?<\/a><\/li><li class='ez-toc-page-1 ez-toc-heading-level-3'><a class=\"ez-toc-link ez-toc-heading-2\" href=\"https:\/\/www.altoros.com\/blog\/addressing-complex-software-systems-with-microservices-and-ci-cd\/#Whats_wrong_with_monoliths\" >What\u2019s wrong with monoliths?<\/a><\/li><li class='ez-toc-page-1 ez-toc-heading-level-3'><a class=\"ez-toc-link ez-toc-heading-3\" href=\"https:\/\/www.altoros.com\/blog\/addressing-complex-software-systems-with-microservices-and-ci-cd\/#Changing_the_architectural_approach_to_innovate_faster\" >Changing the architectural approach to innovate faster<\/a><\/li><li class='ez-toc-page-1 ez-toc-heading-level-3'><a class=\"ez-toc-link ez-toc-heading-4\" href=\"https:\/\/www.altoros.com\/blog\/addressing-complex-software-systems-with-microservices-and-ci-cd\/#An_integrated_deployment_workflow\" >An integrated deployment workflow<\/a><\/li><li class='ez-toc-page-1 ez-toc-heading-level-3'><a class=\"ez-toc-link ez-toc-heading-5\" href=\"https:\/\/www.altoros.com\/blog\/addressing-complex-software-systems-with-microservices-and-ci-cd\/#Easier_on_a_Platform-as-a-Service\" >Easier on a Platform-as-a-Service<\/a><\/li><li class='ez-toc-page-1 ez-toc-heading-level-3'><a class=\"ez-toc-link ez-toc-heading-6\" href=\"https:\/\/www.altoros.com\/blog\/addressing-complex-software-systems-with-microservices-and-ci-cd\/#Real-life_implementations_at_large_organizations\" >Real-life implementations at large organizations<\/a><\/li><li class='ez-toc-page-1 ez-toc-heading-level-3'><a class=\"ez-toc-link ez-toc-heading-7\" href=\"https:\/\/www.altoros.com\/blog\/addressing-complex-software-systems-with-microservices-and-ci-cd\/#Where_to_start\" >Where to start?<\/a><\/li><li class='ez-toc-page-1 ez-toc-heading-level-3'><a class=\"ez-toc-link ez-toc-heading-8\" href=\"https:\/\/www.altoros.com\/blog\/addressing-complex-software-systems-with-microservices-and-ci-cd\/#References\" >References<\/a><\/li><\/ul><\/nav><\/div>\n<h3><span class=\"ez-toc-section\" id=\"Whats_important\"><\/span>What\u2019s important?<span class=\"ez-toc-section-end\"><\/span><\/h3>\n<p>Requirements may vary, depending on a product or a specific industry, however, most enterprises focus on the essentials as described below when building complex large-scale systems.<\/p>\n<p>Because innovating ahead of competitors is a matter of survival for businesses, they need to be able to <strong>deliver apps fast<\/strong> and update often. It should also be <strong>easy<\/strong> for a company <strong>to maintain<\/strong> a system after it is in the production stage while introducing new features as the software evolves.<\/p>\n<p><strong>High availability<\/strong> is of major importance, too, comprising fault tolerance, automated disaster recovery and backups, etc. <strong>Scalability<\/strong> of a system should guarantee its ability to serve a growing amount of users, requests, and data.<\/p>\n<p><strong>Transparency<\/strong> across the technology stack and processes should make it possible to detect and eliminate problems as soon as they occur by monitoring essential technical and business metrics. Most enterprises are strict about <strong>security<\/strong>, which covers protection of sensitive data (or devices), prevention of unauthorized access, etc. This requirement becomes even more important as the system grows in size and complexity.<\/p>\n<p><a href=\"https:\/\/www.altoros.com\/blog\/wp-content\/uploads\/2017\/04\/Business-Software.png\"><img decoding=\"async\" src=\"https:\/\/www.altoros.com\/blog\/wp-content\/uploads\/2017\/04\/Business-Software.png\" alt=\"Business-Software\" width=\"640\" class=\"aligncenter size-full wp-image-23333\" \/><\/a><\/p>\n<p>The above mentioned is hardly a complete list of requirements, which vary depending on a specific industry and type of business. For a <a href=\"https:\/\/www.altoros.com\/blog\/building-scaled-down-highly-available-mission-critical-architecture-with-cloud-foundry\/\">healthcare project<\/a>, for instance, regulations will also matter, which may be different in various regions. The reality is that every large business\u2014even a traditional one, such as a clothes retailer or an 80-year-old insurance company\u2014is now a software business, managing and delivering apps to stay ahead of the curve.<\/p>\n<p>&nbsp;<\/p>\n<h3><span class=\"ez-toc-section\" id=\"Whats_wrong_with_monoliths\"><\/span>What\u2019s wrong with monoliths?<span class=\"ez-toc-section-end\"><\/span><\/h3>\n<p>Although a monolithic architecture may meet most of the essential requirements when just launched, it eventually ends up facing some (or all) of the following challenges as the system grows:<\/p>\n<ul>\n<li style=\"margin-bottom: 8px;\"><strong>Long release cycles<\/strong>. Over time, the system\u2019s code becomes more and more complex, with introduction of new features getting harder and longer. As a result, adding even a minor update may take weeks or months of work, yet requiring engineers to rebuild and redeploy the entire monolith. Frequent changes are too bulky to handle, since developers have to thoroughly review the existing code to avoid mistakes and system instability.<\/li>\n<li style=\"margin-bottom: 8px;\"><strong>A monolithic architecture is hard to maintain<\/strong>. As time passes, technologies tend to become obsolete. For a monolithic architecture, however, adopting a new framework or language often becomes a task nearly impossible to accomplish. In many cases, developers have to stick to a chosen technology stack, as migrating to another one may require rewriting the entire application.<\/li>\n<li style=\"margin-bottom: 8px;\"><strong>Limited scalability<\/strong>. To scale horizontally, companies build sophisticated load balancing models, otherwise the only way to go about it would be to scale vertically\u2014by buying more hardware. Both scenarios are not only time- and resource-consuming, but also have physical limitations.<\/li>\n<li style=\"margin-bottom: 8px;\"><strong>Low resilience<\/strong>. A fault in a monolithic architecture can turn into a total crash, when the entire system is down. Lacking proper scaling due to a rigorous architecture, a monolith also runs high risks of failure at unexpected load (or traffic) spikes. On top of that, introduction of new functionality may cause new bottlenecks in the code base, making the system even more unstable.<\/li>\n<p><a href=\"https:\/\/www.altoros.com\/blog\/wp-content\/uploads\/2017\/04\/Software-Development-Challenges.png\"><img decoding=\"async\" src=\"https:\/\/www.altoros.com\/blog\/wp-content\/uploads\/2017\/04\/Software-Development-Challenges.png\" alt=\"Software-Development-Challenges\" width=\"640\" class=\"aligncenter size-full wp-image-23335\" \/><\/a><\/p>\n<li style=\"margin-bottom: 8px;\"><strong>Insufficient monitoring and prediction<\/strong>. Lack of transparency in a monolithic architecture makes it difficult to discover the actual cause of a fault or find an efficient remedy for it. Very often, monolithic architectures provide only a general insight into the inner workings of a system, without the ability to measure performance or status of a particular feature. Therefore, recovery from a fault may become a time-consuming process associated with significant financial losses while the system is not operating as it should.<\/li>\n<\/ul>\n<p>For a more detailed comparison of monolithic and microservices-based architectures, as well as the pros and cons of the both, read our <a href=\"https:\/\/www.altoros.com\/research-papers\/microservices-vs-monolithic-architectures-the-pros-cons-and-cloud-foundry-examples\/\">technical guide<\/a> on the topic.<\/p>\n<p>&nbsp;<\/p>\n<h3><span class=\"ez-toc-section\" id=\"Changing_the_architectural_approach_to_innovate_faster\"><\/span>Changing the architectural approach to innovate faster<span class=\"ez-toc-section-end\"><\/span><\/h3>\n<p>One of the efficient ways to address the challenges described earlier would be to adopt a <strong>microservices-based approach<\/strong>\u2014by decomposing a monolithic architecture into a number of loosely coupled smaller parts. Each of the parts is delivered in accordance with a <a href=\"https:\/\/www.altoros.com\/blog\/reducing-complexity-of-software-with-domain-driven-design-and-microservices\/\">domain-driven design<\/a> and the <a href=\"https:\/\/12factor.net\/\" target=\"_blank\">12\u2013factor app<\/a> concept. Some of the results that these approach brings:<\/p>\n<ul>\n<li style=\"margin-bottom: 8px;\"><strong>Independence of services<\/strong>. Each microservice is a small-size, separately deployed delivery unit with its own simple business logic. So, developers in a team can add new features independent of other functional teams and update without affecting the entire system.<\/li>\n<li style=\"margin-bottom: 8px;\"><strong>Isolated execution<\/strong>. Microservices run as isolated single-purpose applications with explicit dependencies. Due to this, it is possible to employ the containerization technology (e.g., Docker, Warden, or Rocket) to ensure a more efficient use of computational resources.<\/li>\n<li style=\"margin-bottom: 8px;\"><strong>Flexible scaling options<\/strong>. When components in a system are implemented as microservices, scaling does not have to cover the total of them. One can scale up only specific services as needed.<\/li>\n<li style=\"margin-bottom: 8px;\"><strong>Autonomous teams<\/strong>. As a rule, the system is divided into multiple components corresponding to functional teams focusing on different business units\/features\u2014e.g., finance, customer service, delivery, etc. Teams can work rather independently\u2014each on its own part of functionality and services with their preferred technologies. In case of distributed teams, it is a critical advantage, as they can disregard the time difference and collocation.<\/li>\n<p><a href=\"https:\/\/www.altoros.com\/blog\/wp-content\/uploads\/2017\/04\/Different-Ways-of-Application-Decomposition.png\"><img decoding=\"async\" src=\"https:\/\/www.altoros.com\/blog\/wp-content\/uploads\/2017\/04\/Different-Ways-of-Application-Decomposition.png\" alt=\"Different-Ways-of-Application-Decomposition\" width=\"640\" class=\"aligncenter size-full wp-image-23336\" \/><\/a><\/p>\n<li style=\"margin-bottom: 8px;\"><strong>Choice of technology<\/strong>. A microservices architecture gives teams the freedom to use <a href=\"https:\/\/www.altoros.com\/blog\/microservices-building-a-distributed-app-with-cf-and-spring\/\" target=\"_blank\">multiple data storages<\/a> (MySQL, CouchDB, Redis, etc.), languages (Java, Ruby, Python, Go, etc.), and frameworks (Spring Boot, Java EE, etc.). This facilitates migrating from one technology stack to another and combining various technologies within one stack to build different system components.<\/li>\n<li style=\"margin-bottom: 8px;\"><strong>Fault tolerance<\/strong>. Although a system based on microservices comprises multiple small units that can fail, the units are loosely coupled. So, it takes less time and efforts to identify the exact system component responsible for a failure and to find a way to fix it.<\/li>\n<\/ul>\n<p>Microservices <a href=\"https:\/\/www.altoros.com\/blog\/running-microservices-and-apis-with-cloud-foundry\/\">communicate<\/a> with each other via message brokers (such as RabbitMQ) and APIs. Note that there is <a href=\"https:\/\/www.altoros.com\/blog\/10-key-criteria-for-evaluating-api-automation-tools\/\">a variety of frameworks<\/a> enabling developers to speed up and automate API implementation.<\/p>\n<p>A special type of microservices-based solutions feature event-driven architectures, where services are triggered by notable events. Although such architectures are more difficult to implement, they enable efficient management of computational resources (e.g., with <a href=\"https:\/\/www.altoros.com\/blog\/event-driven-iot-challenges-requirements-difference-ibm-openwhisk\/\">OpenWhisk<\/a>), while saving money due to flexible charging.<\/p>\n<p>&nbsp;<\/p>\n<h3><span class=\"ez-toc-section\" id=\"An_integrated_deployment_workflow\"><\/span>An integrated deployment workflow<span class=\"ez-toc-section-end\"><\/span><\/h3>\n<p>Containing numerous components, a microservices-based architecture implies that the integration and deployment processes are becoming more challenging to manage. Here\u2019s where continuous integration and continuous delivery step in.<\/p>\n<p><strong>Continuous integration<\/strong> (CI) is understood as a practice requiring developers to merge their code to a shared repository, at least, on a daily basis.The practice implies maintaining a single code base with a revision control system (e.g., Git, Mercurial, Subversion) and the need to keep committing changes at a reasonable frequency to avoid integration conflicts. Frequent integrations make it possible to locate and eliminate errors in the source code faster and easier, focusing more on development than bug fixing. The CI practice also involves automatic integration tests that are run on a CI server as soon as it detects a new commit.<\/p>\n<p><strong>Continuous delivery<\/strong> (CD) is an engineering approach\u2014continuous integration being part of it\u2014that provides the ability to build and release software safely and quickly in a sustainable way. The approach requires implementing a deployment pipeline and involves the following:<\/p>\n<ul>\n<li>Automating delivery of builds, possibly making it a matter of just a couple of clicks. Such tools as Capistrano, Maven, and Gradle can assist in achieving the goal.<\/li>\n<li>Ensuring traceability of builds.<\/li>\n<li>Enabling automatic testing of builds and rapid feedback on code issues.<\/li>\n<li>Keeping software deployable throughout a development life cycle.<\/li>\n<li>Automating deployment and release of software versions.<\/li>\n<\/ul>\n<p>Automation of testing is key for continuous integration and continuous delivery to work properly, as it reduces substantially the duration of a development life cycle. Those are the types of tests used in a CI\/CD pipeline:<\/p>\n<ul>\n<li>unit tests (with Unit, NUnit, or TestNG)<\/li>\n<li>acceptance tests (using Cucumber)<\/li>\n<li>user interface tests (e.g., Ranorex, TestComplete)<\/li>\n<li>end-to-end tests (with WebDriver)<\/li>\n<\/ul>\n<p><center><a href=\"https:\/\/www.altoros.com\/blog\/wp-content\/uploads\/2017\/04\/CI-CD-Pipeline.png\"><img decoding=\"async\" src=\"https:\/\/www.altoros.com\/blog\/wp-content\/uploads\/2017\/04\/CI-CD-Pipeline.png\" alt=\"CI-CD-Pipeline\" width=\"640\" class=\"aligncenter size-full wp-image-23339\" \/><\/a><small>Continuous delivery in action (<a href=\"https:\/\/commons.wikimedia.org\/wiki\/File:Continuous_Delivery_process_diagram.svg\" target=\"_blank\">Image credit<\/a>)<\/center><\/small><\/p>\n<p>A CI\/CD pipeline can be implemented using a standardized tool (e.g., <a href=\"https:\/\/www.altoros.com\/blog\/continuous-integration-with-jenkins-and-travis-ci\/\">Jenkins, Travis CI<\/a>, or <a href=\"https:\/\/www.altoros.com\/blog\/8-pro-tips-for-using-concourse-ci-with-cloud-foundry\/\">Concourse<\/a>). In addition, it often requires creating a DevOps culture within an organization, fostering communication and collaboration of developers with operations engineers and management. Read the <a href=\"https:\/\/www.altoros.com\/blog\/devops-five-key-challenges-and-five-tips\/\">blog post<\/a> to learn about the related tips and challenges.<\/p>\n<p>&nbsp;<\/p>\n<h3><span class=\"ez-toc-section\" id=\"Easier_on_a_Platform-as-a-Service\"><\/span>Easier on a Platform-as-a-Service<span class=\"ez-toc-section-end\"><\/span><\/h3>\n<p>Although microservices and Platform-as-a-Service (PaaS) do not necessarily require each other, they work together well. A PaaS like Cloud Foundry (including all of its distributions, such as IBM Bluemix, Pivotal CF, GE Predix, Stackato, etc.) <a href=\"https:\/\/www.altoros.com\/blog\/the-business-benefits-of-microservices-and-cloud-foundry\/\">takes away a lot of headache<\/a> associated with managing microservices. It addresses such issues as implicit interfaces, operational overheads, and operational complexity.<\/p>\n<p>A PaaS ensures high-level automation, simplifying deployment and management of microservices:<\/p>\n<ul>\n<li style=\"margin-bottom: 8px;\">Developers <a href=\"https:\/\/www.altoros.com\/blog\/paas-vs-iaas-for-microservices-architectures-top-6-differences\/\">do not have to worry<\/a> about infrastructure, but can focus on the code instead.<\/li>\n<li style=\"margin-bottom: 8px;\">Application runtimes are automatically deployed to isolated containers, which, above all, makes it possible to achieve loose coupling of microservices.<\/li>\n<li style=\"margin-bottom: 8px;\">With a build-automation solution deployed to a PaaS as a regular application, delivery of microservices becomes a continuous and a way less time-consuming process.<\/li>\n<li style=\"margin-bottom: 8px;\">Service binding via a service broker makes it easier to integrate an application with an external service.<\/li>\n<\/ul>\n<p>In addition to backup and disaster recovery, a PaaS like Pivotal CF may offer <a href=\"https:\/\/www.altoros.com\/blog\/cloud-foundry-in-use-high-availability-backup-and-disaster-recovery\/\">self-healing and deployment capabilities<\/a> that can help to achieve high availability with:<\/p>\n<ul>\n<li>restoring failed application instances<\/li>\n<li>restarting failed platform processes<\/li>\n<li>recreating failed virtual machines<\/li>\n<li>deploying app instances and components to different availability zones<\/li>\n<\/ul>\n<p>A PaaS may also include tools that simplify monitoring performance of microservices. Altoros has recently introduced a tool for PaaS monitoring\u2014<a href=\"https:\/\/www.altoros.com\/blog\/introducing-heartbeat-a-full-stack-monitoring-tool-for-cloud-foundry\/\">Heartbeat<\/a>. Featuring logging, alerting, and metrics visualization capabilities, the solution helps to track the status of an IaaS, PaaS components, third-party services, containers, and apps.<\/p>\n<p><center><a href=\"https:\/\/www.altoros.com\/blog\/wp-content\/uploads\/2017\/04\/Metrics-Visualization-with-Heartbeat.png\"><img decoding=\"async\" src=\"https:\/\/www.altoros.com\/blog\/wp-content\/uploads\/2017\/04\/Metrics-Visualization-with-Heartbeat.png\" alt=\"Metrics-Visualization-with-Heartbeat\" width=\"640\" class=\"aligncenter size-full wp-image-23341\" \/><\/a><small>Metrics visualization with Heartbeat<\/center><\/small><\/p>\n<p>&nbsp;<\/p>\n<h3><span class=\"ez-toc-section\" id=\"Real-life_implementations_at_large_organizations\"><\/span>Real-life implementations at large organizations<span class=\"ez-toc-section-end\"><\/span><\/h3>\n<p>So far, introducing microservices and a CI\/CD pipeline has helped numerous organizations to optimize their business processes, manufacturing workflows, and product delivery.<\/p>\n<p><a href=\"https:\/\/www.altoros.com\/blog\/cloud-foundry-for-pricing-optimization-gaps-experience\/\">GAP<\/a>\u2014a global fashion business\u2014adopted a microservices-based approach as part of its strategy aimed at optimization of pricing in local stores around the globe. The new approach has brought a major change to the corporate development workflow, speeding up and automating deployment via a federated continuous integration pipeline.<\/p>\n<p>Using microservices on top of a PaaS, <a href=\"https:\/\/www.altoros.com\/blog\/bny-mellon-nexen-drives-digital-transformation-with-cloud-foundry\/\">BNY Mellon<\/a> and <a href=\"https:\/\/www.altoros.com\/blog\/allstate-uses-cloud-foundry-to-conceive-apps-on-monday-deliver-on-friday\/\">Allstate<\/a>, major players in banking and insurance accordingly, made the application delivery process times faster and easier, while meeting strict requirements of the highly regulated and traditional industries.<\/p>\n<p>Relying on the Cloud Foundry platform, microservices, and continuous delivery, <a href=\"https:\/\/www.altoros.com\/blog\/a-car-app-in-6-months-mercedes-benz-daimler-gains-pace-with-cloud-foundry\/\">Daimler<\/a> was able to iterate more frequently and integrate early customer feedback into the development process. As a result, a new release of its smart <em>Mercedes me<\/em> app was pushed into production in just six months.<\/p>\n<p><center><a href=\"https:\/\/www.altoros.com\/blog\/wp-content\/uploads\/2017\/04\/Mercedes-Benz-daimler-pivotal.jpg\"><img decoding=\"async\" src=\"https:\/\/www.altoros.com\/blog\/wp-content\/uploads\/2017\/04\/Mercedes-Benz-daimler-pivotal.jpg\" alt=\"Mercedes-Benz-daimler-pivotal\" width=\"640\" class=\"aligncenter size-full wp-image-23342\" \/><\/a><small>Daimler <a href=\"https:\/\/www.altoros.com\/blog\/a-car-app-in-6-months-mercedes-benz-daimler-gains-pace-with-cloud-foundry\/\">making iterations<\/a> more frequently<\/center><\/small><\/p>\n<p>Microservices also helped to accelerate delivery of services to multiple organizations from the public sector: <a href=\"https:\/\/www.altoros.com\/blog\/gsa-cuts-app-deployment-from-14-months-to-2-3-days-with-cloud-foundry\/\">US government administration<\/a>, <a href=\"https:\/\/www.altoros.com\/blog\/the-dutch-government-delivers-an-alert-system-on-cloud-foundry-in-just-7-months\/\">the Dutch government<\/a>, <a href=\"https:\/\/www.altoros.com\/blog\/a-predix-driven-smart-watering-system-aims-at-fighting-droughts\/\">San Francisco University<\/a>, etc.<\/p>\n<p>Based on microservices, <a href=\"https:\/\/www.altoros.com\/blog\/smart-locomotive-manufacturing-material-tracking-with-predix-and-rfid-tags\/\">GE<\/a> built an IoT dashboard to improve the legacy processes at its manufacturing premises, while <a href=\"https:\/\/www.altoros.com\/blog\/cisco-cloud-collaboration-celebrates-the-oscars-with-cloud-foundry\/\">Cisco<\/a> delivered the Collaboration Cloud\u2014a virtual conference platform that was used to create the \u201cWall of America.\u201d<\/p>\n<p>Having built a CI\/CD pipeline, <a href=\"https:\/\/www.altoros.com\/blog\/comcast-deploys-1000-times-per-month-with-pivotal-cloud-foundry\/\">Comcast<\/a> and <a href=\"https:\/\/www.altoros.com\/blog\/digitalglobe-builds-satellite-control-system-with-microservices-and-cloud-foundry\/\">DigitalGlobe<\/a> from the telecommunications industry managed to substantially increase development speed.<\/p>\n<p><a href=\"https:\/\/www.altoros.com\/blog\/an-msp-provider-builds-a-cross-iaas-management-platform-with-ibm-bluemix\/\">Unigma<\/a> is one of the most recent projects where Altoros\u2014partnering with a managed infrastructure services provider\u2014delivered a multi-tenant cloud platform. Using the Bluemix platform and microservices, the company was able to release a full-fledged system in just 6 months.<\/p>\n<p>&nbsp;<\/p>\n<h3><span class=\"ez-toc-section\" id=\"Where_to_start\"><\/span>Where to start?<span class=\"ez-toc-section-end\"><\/span><\/h3>\n<p>Building a proof of concept is one of the best ways to see microservices and a CI\/CD pipeline in action. Prototyping enables to try out a technology stack against the existing infrastructure and to see how a system will perform without having to actually build it. This saves a lot of trouble with identifying and eliminating possible bottlenecks and risks.<\/p>\n<p><p>For instance, Altoros\u2014together with GE, Oracle, and M2Mi\u2014is participating in the <a href=\"https:\/\/www.prnewswire.com\/news-releases\/altoros-joins-the-smart-airline-baggage-management-testbed-to-solve-the-problem-of-mishandled-bags-300334903.html\" target=\"_blank\">Smart Airline Baggage Management Testbed<\/a>. The initiative aims at building a prototype of an <a href=\"https:\/\/www.altoros.com\/blog\/iot-for-airlines-smart-baggage-tracking-with-rfid-tags-and-cloud-foundry\/\">IoT system<\/a> to reduce baggage mishandling at airports, using microservices on top of GE\u2019s Predix platform. The prototype enables airlines to evaluate how RFID-based baggage tracking can ensure compliance with <a href=\"https:\/\/www.iata.org\/programs\/stb\/Documents\/baggage-tracking-res753.pdf\" target=\"_blank\">Resolution 753<\/a> of the International Air Transport Association, which should be achieved by June 2018.<\/p>\n<p><a href=\"https:\/\/www.altoros.com\/blog\/wp-content\/uploads\/2017\/04\/Proof-of-Concept-for-Airlines-Altoros.png\"><img decoding=\"async\" src=\"https:\/\/www.altoros.com\/blog\/wp-content\/uploads\/2017\/04\/Proof-of-Concept-for-Airlines-Altoros.png\" alt=\"Proof-of-Concept-for-Airlines-Altoros\" width=\"640\" class=\"aligncenter size-full wp-image-23343\" \/><\/a><\/p>\n<p>Another example of rapid prototyping is an <a href=\"https:\/\/www.altoros.com\/blog\/prototyping-a-greenhouse-management-system-with-node-red-and-predix-in-48-hours\/\">automation system <\/a> for greenhouse farming. In this case, using GE&#8217;s Predix as a PaaS helped Altoros to create a microservices-based prototype in just 48 hours.<\/p>\n<p>Today, enterprises are subject to disruption by smaller innovative startups, only few will still be alive in the course of the decade. So, the ability to transform faster becomes key to survival. Microservices, a CI\/CD pipeline, and a PaaS can help companies to outperform their competitors in the long run. Or, at least, to remain in the business.<\/p>\n<hr\/>\n<p><center><small>We\u2019ll be happy to share our experience in adopting a PaaS, microservices, and CI\/CD.<br \/>\nIf you need to identify bottlenecks in your complex infrastructure<br \/>\nor improve performance of a monolith,<a href=\"https:\/\/www.altoros.com\/contact-us\"> contact us<\/a> to start a change.<\/small><\/center><\/p>\n<hr\/>\n<h3><span class=\"ez-toc-section\" id=\"References\"><\/span>References<span class=\"ez-toc-section-end\"><\/span><\/h3>\n<ul>\n<li><a href=\"https:\/\/12factor.net\/\" target=\"_blank\">&#8220;The Twelve-Factor App&#8221;<\/a> (Adam Wiggings)<\/li>\n<li><a href=\"https:\/\/www.oreilly.com\/programming\/free\/migrating-cloud-native-application-architectures.csp\" target=\"_blank\"> &#8220;Migrating to Cloud-Native Application Architectures&#8221;<\/a> (Matt Stine)<\/li>\n<li><a href=\"https:\/\/www.amazon.com\/Domain-Driven-Design-Tackling-Complexity-Software\/dp\/0321125215\" target=\"_blank\">&#8220;Domain-Driven Design: Tackling Complexity in the Heart of Software&#8221;<\/a> (Eric Evans)<\/li>\n<li><a href=\"https:\/\/www.altoros.com\/research-papers\/microservices-vs-monolithic-architectures-the-pros-cons-and-cloud-foundry-examples\/\" target=\"_blank\">&#8220;Microservices vs. Monolithic Architectures: the Pros and Cons and Cloud Foundry Examples&#8221;<\/a> (Sergey Sverchkov)<\/li>\n<li><a href=\"https:\/\/martinfowler.com\/articles\/continuousIntegration.html\" target=\"_blank\">&#8220;Continuous Integration&#8221;<\/a> (Martin Fowler)<\/li>\n<li><a href=\"https:\/\/www.amazon.com\/Continuous-Delivery-Deployment-Automation-Addison-Wesley\/dp\/0321601912\/ref\" target=\"_blank\">&#8220;Continuous Delivery: Reliable Software Releases Through Build, Test, and Deployment Automation&#8221;<\/a> (Jez Humble, David Farley)<\/li>\n<\/ul>\n<hr\/>\n<p><center><small>The post is written by  <a href=\"https:\/\/www.altoros.com\/blog\/author\/alesia-bulanok\/\">Alesia Bulanok<\/a> and <a href=\"https:\/\/www.altoros.com\/blog\/author\/alex\/\">Alex Khizhniak<\/a>.<\/small><\/center><\/p>\n","protected":false},"excerpt":{"rendered":"<p>For a monolithic application\u2014delivered as a single cohesive unit of code\u2014it may take just 2\u20133 years to become an outdated \u201cblack box\u201d that is hard to support and maintain. Over time, a major update may require redeployment of the entire system, while a single failure may turn into a disaster [&#8230;]<\/p>\n","protected":false},"author":111,"featured_media":23361,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"_acf_changed":false,"content-type":"","footnotes":"","_links_to":"","_links_to_target":""},"categories":[7],"tags":[911,873,187,146,206,28,647],"class_list":["post-23332","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-news-and-opinion","tag-ci-cd","tag-cloud-native","tag-ibm-bluemix","tag-microservices","tag-oss-cloud-foundry","tag-pivotal-cf","tag-predix"],"acf":[],"yoast_head":"<!-- This site is optimized with the Yoast SEO plugin v26.6 - https:\/\/yoast.com\/wordpress\/plugins\/seo\/ -->\n<title>Addressing Complex Software Systems with Microservices and CI\/CD | Altoros<\/title>\n<meta name=\"description\" content=\"The growing complexity of software requires new architectural approaches to speed up development. If you\u2019re still not into microservices, read on.\" \/>\n<meta name=\"robots\" content=\"index, follow, max-snippet:-1, max-image-preview:large, max-video-preview:-1\" \/>\n<link rel=\"canonical\" href=\"https:\/\/www.altoros.com\/blog\/addressing-complex-software-systems-with-microservices-and-ci-cd\/\" \/>\n<meta property=\"og:locale\" content=\"en_US\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"Addressing Complex Software Systems with Microservices and CI\/CD | Altoros\" \/>\n<meta property=\"og:description\" content=\"For a monolithic application\u2014delivered as a single cohesive unit of code\u2014it may take just 2\u20133 years to become an outdated \u201cblack box\u201d that is hard to support and maintain. Over time, a major update may require redeployment of the entire system, while a single failure may turn into a disaster [...]\" \/>\n<meta property=\"og:url\" content=\"https:\/\/www.altoros.com\/blog\/addressing-complex-software-systems-with-microservices-and-ci-cd\/\" \/>\n<meta property=\"og:site_name\" content=\"Altoros\" \/>\n<meta property=\"article:published_time\" content=\"2017-04-27T19:33:33+00:00\" \/>\n<meta property=\"article:modified_time\" content=\"2018-08-01T14:22:46+00:00\" \/>\n<meta property=\"og:image\" content=\"https:\/\/www.altoros.com\/blog\/wp-content\/uploads\/2017\/04\/Addressing-Complexity-with-Microservices-and-CI-CD_v4.gif\" \/>\n\t<meta property=\"og:image:width\" content=\"640\" \/>\n\t<meta property=\"og:image:height\" content=\"360\" \/>\n\t<meta property=\"og:image:type\" content=\"image\/gif\" \/>\n<meta name=\"author\" content=\"Alesia Bulanok\" \/>\n<meta name=\"twitter:label1\" content=\"Written by\" \/>\n\t<meta name=\"twitter:data1\" content=\"Alesia Bulanok\" \/>\n\t<meta name=\"twitter:label2\" content=\"Est. reading time\" \/>\n\t<meta name=\"twitter:data2\" content=\"12 minutes\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\/\/schema.org\",\"@graph\":[{\"@type\":\"WebPage\",\"@id\":\"https:\/\/www.altoros.com\/blog\/addressing-complex-software-systems-with-microservices-and-ci-cd\/\",\"url\":\"https:\/\/www.altoros.com\/blog\/addressing-complex-software-systems-with-microservices-and-ci-cd\/\",\"name\":\"Addressing Complex Software Systems with Microservices and CI\/CD | Altoros\",\"isPartOf\":{\"@id\":\"https:\/\/www.altoros.com\/blog\/#website\"},\"primaryImageOfPage\":{\"@id\":\"https:\/\/www.altoros.com\/blog\/addressing-complex-software-systems-with-microservices-and-ci-cd\/#primaryimage\"},\"image\":{\"@id\":\"https:\/\/www.altoros.com\/blog\/addressing-complex-software-systems-with-microservices-and-ci-cd\/#primaryimage\"},\"thumbnailUrl\":\"https:\/\/www.altoros.com\/blog\/wp-content\/uploads\/2017\/04\/Addressing-Complexity-with-Microservices-and-CI-CD_v4.gif\",\"datePublished\":\"2017-04-27T19:33:33+00:00\",\"dateModified\":\"2018-08-01T14:22:46+00:00\",\"author\":{\"@id\":\"https:\/\/www.altoros.com\/blog\/#\/schema\/person\/df3dad74c56cbef54ff4a8bc79d23163\"},\"breadcrumb\":{\"@id\":\"https:\/\/www.altoros.com\/blog\/addressing-complex-software-systems-with-microservices-and-ci-cd\/#breadcrumb\"},\"inLanguage\":\"en-US\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\/\/www.altoros.com\/blog\/addressing-complex-software-systems-with-microservices-and-ci-cd\/\"]}]},{\"@type\":\"ImageObject\",\"inLanguage\":\"en-US\",\"@id\":\"https:\/\/www.altoros.com\/blog\/addressing-complex-software-systems-with-microservices-and-ci-cd\/#primaryimage\",\"url\":\"https:\/\/www.altoros.com\/blog\/wp-content\/uploads\/2017\/04\/Addressing-Complexity-with-Microservices-and-CI-CD_v4.gif\",\"contentUrl\":\"https:\/\/www.altoros.com\/blog\/wp-content\/uploads\/2017\/04\/Addressing-Complexity-with-Microservices-and-CI-CD_v4.gif\",\"width\":640,\"height\":360},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\/\/www.altoros.com\/blog\/addressing-complex-software-systems-with-microservices-and-ci-cd\/#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"Home\",\"item\":\"https:\/\/www.altoros.com\/blog\/\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"Addressing Complex Software Systems with Microservices and CI\/CD\"}]},{\"@type\":\"WebSite\",\"@id\":\"https:\/\/www.altoros.com\/blog\/#website\",\"url\":\"https:\/\/www.altoros.com\/blog\/\",\"name\":\"Altoros\",\"description\":\"Insight\",\"potentialAction\":[{\"@type\":\"SearchAction\",\"target\":{\"@type\":\"EntryPoint\",\"urlTemplate\":\"https:\/\/www.altoros.com\/blog\/?s={search_term_string}\"},\"query-input\":{\"@type\":\"PropertyValueSpecification\",\"valueRequired\":true,\"valueName\":\"search_term_string\"}}],\"inLanguage\":\"en-US\"},{\"@type\":\"Person\",\"@id\":\"https:\/\/www.altoros.com\/blog\/#\/schema\/person\/df3dad74c56cbef54ff4a8bc79d23163\",\"name\":\"Alesia Bulanok\",\"image\":{\"@type\":\"ImageObject\",\"inLanguage\":\"en-US\",\"@id\":\"https:\/\/www.altoros.com\/blog\/#\/schema\/person\/image\/\",\"url\":\"https:\/\/www.altoros.com\/blog\/wp-content\/uploads\/2016\/12\/bulanok.jpg\",\"contentUrl\":\"https:\/\/www.altoros.com\/blog\/wp-content\/uploads\/2016\/12\/bulanok.jpg\",\"caption\":\"Alesia Bulanok\"},\"description\":\"Alesia Bulanok is a Technical Writer at Altoros. She has been in the profession for more than two years and has an extensive experience in software-related user documentation. With her publications, she aspires to help people in the IT industry and outside it to find what\u2019s new, interesting and can be useful for them in their daily activities.\",\"url\":\"https:\/\/www.altoros.com\/blog\/author\/alesia-bulanok\/\"}]}<\/script>\n<!-- \/ Yoast SEO plugin. -->","yoast_head_json":{"title":"Addressing Complex Software Systems with Microservices and CI\/CD | Altoros","description":"The growing complexity of software requires new architectural approaches to speed up development. If you\u2019re still not into microservices, read on.","robots":{"index":"index","follow":"follow","max-snippet":"max-snippet:-1","max-image-preview":"max-image-preview:large","max-video-preview":"max-video-preview:-1"},"canonical":"https:\/\/www.altoros.com\/blog\/addressing-complex-software-systems-with-microservices-and-ci-cd\/","og_locale":"en_US","og_type":"article","og_title":"Addressing Complex Software Systems with Microservices and CI\/CD | Altoros","og_description":"For a monolithic application\u2014delivered as a single cohesive unit of code\u2014it may take just 2\u20133 years to become an outdated \u201cblack box\u201d that is hard to support and maintain. Over time, a major update may require redeployment of the entire system, while a single failure may turn into a disaster [...]","og_url":"https:\/\/www.altoros.com\/blog\/addressing-complex-software-systems-with-microservices-and-ci-cd\/","og_site_name":"Altoros","article_published_time":"2017-04-27T19:33:33+00:00","article_modified_time":"2018-08-01T14:22:46+00:00","og_image":[{"width":640,"height":360,"url":"https:\/\/www.altoros.com\/blog\/wp-content\/uploads\/2017\/04\/Addressing-Complexity-with-Microservices-and-CI-CD_v4.gif","type":"image\/gif"}],"author":"Alesia Bulanok","twitter_misc":{"Written by":"Alesia Bulanok","Est. reading time":"12 minutes"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"WebPage","@id":"https:\/\/www.altoros.com\/blog\/addressing-complex-software-systems-with-microservices-and-ci-cd\/","url":"https:\/\/www.altoros.com\/blog\/addressing-complex-software-systems-with-microservices-and-ci-cd\/","name":"Addressing Complex Software Systems with Microservices and CI\/CD | Altoros","isPartOf":{"@id":"https:\/\/www.altoros.com\/blog\/#website"},"primaryImageOfPage":{"@id":"https:\/\/www.altoros.com\/blog\/addressing-complex-software-systems-with-microservices-and-ci-cd\/#primaryimage"},"image":{"@id":"https:\/\/www.altoros.com\/blog\/addressing-complex-software-systems-with-microservices-and-ci-cd\/#primaryimage"},"thumbnailUrl":"https:\/\/www.altoros.com\/blog\/wp-content\/uploads\/2017\/04\/Addressing-Complexity-with-Microservices-and-CI-CD_v4.gif","datePublished":"2017-04-27T19:33:33+00:00","dateModified":"2018-08-01T14:22:46+00:00","author":{"@id":"https:\/\/www.altoros.com\/blog\/#\/schema\/person\/df3dad74c56cbef54ff4a8bc79d23163"},"breadcrumb":{"@id":"https:\/\/www.altoros.com\/blog\/addressing-complex-software-systems-with-microservices-and-ci-cd\/#breadcrumb"},"inLanguage":"en-US","potentialAction":[{"@type":"ReadAction","target":["https:\/\/www.altoros.com\/blog\/addressing-complex-software-systems-with-microservices-and-ci-cd\/"]}]},{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/www.altoros.com\/blog\/addressing-complex-software-systems-with-microservices-and-ci-cd\/#primaryimage","url":"https:\/\/www.altoros.com\/blog\/wp-content\/uploads\/2017\/04\/Addressing-Complexity-with-Microservices-and-CI-CD_v4.gif","contentUrl":"https:\/\/www.altoros.com\/blog\/wp-content\/uploads\/2017\/04\/Addressing-Complexity-with-Microservices-and-CI-CD_v4.gif","width":640,"height":360},{"@type":"BreadcrumbList","@id":"https:\/\/www.altoros.com\/blog\/addressing-complex-software-systems-with-microservices-and-ci-cd\/#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Home","item":"https:\/\/www.altoros.com\/blog\/"},{"@type":"ListItem","position":2,"name":"Addressing Complex Software Systems with Microservices and CI\/CD"}]},{"@type":"WebSite","@id":"https:\/\/www.altoros.com\/blog\/#website","url":"https:\/\/www.altoros.com\/blog\/","name":"Altoros","description":"Insight","potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/www.altoros.com\/blog\/?s={search_term_string}"},"query-input":{"@type":"PropertyValueSpecification","valueRequired":true,"valueName":"search_term_string"}}],"inLanguage":"en-US"},{"@type":"Person","@id":"https:\/\/www.altoros.com\/blog\/#\/schema\/person\/df3dad74c56cbef54ff4a8bc79d23163","name":"Alesia Bulanok","image":{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/www.altoros.com\/blog\/#\/schema\/person\/image\/","url":"https:\/\/www.altoros.com\/blog\/wp-content\/uploads\/2016\/12\/bulanok.jpg","contentUrl":"https:\/\/www.altoros.com\/blog\/wp-content\/uploads\/2016\/12\/bulanok.jpg","caption":"Alesia Bulanok"},"description":"Alesia Bulanok is a Technical Writer at Altoros. She has been in the profession for more than two years and has an extensive experience in software-related user documentation. With her publications, she aspires to help people in the IT industry and outside it to find what\u2019s new, interesting and can be useful for them in their daily activities.","url":"https:\/\/www.altoros.com\/blog\/author\/alesia-bulanok\/"}]}},"_links":{"self":[{"href":"https:\/\/www.altoros.com\/blog\/wp-json\/wp\/v2\/posts\/23332","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.altoros.com\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.altoros.com\/blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.altoros.com\/blog\/wp-json\/wp\/v2\/users\/111"}],"replies":[{"embeddable":true,"href":"https:\/\/www.altoros.com\/blog\/wp-json\/wp\/v2\/comments?post=23332"}],"version-history":[{"count":50,"href":"https:\/\/www.altoros.com\/blog\/wp-json\/wp\/v2\/posts\/23332\/revisions"}],"predecessor-version":[{"id":33237,"href":"https:\/\/www.altoros.com\/blog\/wp-json\/wp\/v2\/posts\/23332\/revisions\/33237"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/www.altoros.com\/blog\/wp-json\/wp\/v2\/media\/23361"}],"wp:attachment":[{"href":"https:\/\/www.altoros.com\/blog\/wp-json\/wp\/v2\/media?parent=23332"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.altoros.com\/blog\/wp-json\/wp\/v2\/categories?post=23332"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.altoros.com\/blog\/wp-json\/wp\/v2\/tags?post=23332"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}